feat(wash): dev.environment for host process env vars

ricochet · ricochet · commit 7339efb658bc · 2026-05-06T11:34:16.000-04:00
Add a `dev.environment` map that wash dev exports into its own process
before constructing the host, so plugins and runtime crates that read
from std::env (RUST_LOG, OTEL_*, libpq's PG*, ...) pick the values up.
Distinct from workload.environment, which is delivered to the component
via wasi:cli/env.

Also add the first schema tests for the Config struct, pinning the
camelCase contract on WorkloadConfig / EnvironmentLayer / ConfigSource
so a future refactor that drops a `rename_all` doesn't silently drop
user-configured fields.

Signed-off-by: Bailey Hayes &lt;bailey@cosmonic.com&gt;
diff --git a/crates/wash/src/cli/dev.rs b/crates/wash/src/cli/dev.rs
@@ -56,6 +56,23 @@ impl CliCommand for DevCommand {
         .context("failed to load config for development")?;
 
         let dev_config = config.dev();
+
+        // Export `dev.environment` into the wash process so plugins and
+        // runtime crates that read from `std::env` (tracing, OTEL exporters,
+        // libpq, …) see them. We do this before constructing the host so the
+        // first time a plugin reads its config, the values are present.
+        //
+        // SAFETY: `std::env::set_var` is unsafe in the 2024 edition because
+        // it races with concurrent `getenv` from other threads. At this point
+        // we're still on the command's entrypoint task. The host hasn't been
+        // built and no plugin has begun reading env. Tokio worker threads
+        // exist but none of our code reads env from them yet. Apply once,
+        // up front, and never touch the env again.
+        #[allow(unsafe_code)]
+        for (key, value) in &dev_config.environment {
+            unsafe { std::env::set_var(key, value) };
+        }
+
         let http_addr = dev_config
             .address
             .clone()
diff --git a/crates/wash/src/config.rs b/crates/wash/src/config.rs
@@ -241,6 +241,14 @@ pub struct DevConfig {
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub volumes: Vec<DevVolume>,
 
+    /// Environment variables exported into the `wash dev` process before the
+    /// host is built. Surfaces values to plugins and runtime crates that read
+    /// from `std::env` (e.g. `RUST_LOG`, `OTEL_*`, libpq's `PG*` family).
+    /// Distinct from `workload.environment`, which is delivered to the
+    /// component via `wasi:cli/env`.
+    #[serde(default, skip_serializing_if = "HashMap::is_empty")]
+    pub environment: HashMap<String, String>,
+
     /// Host interfaces configuration
     #[serde(default, skip_serializing_if = "Vec::is_empty")]
     pub host_interfaces: Vec<WitInterface>,
@@ -434,3 +442,115 @@ pub async fn generate_default_config(path: &Path, force: bool) -> Result<()> {
     info!(config_path = %path.display(), "Generated default configuration");
     Ok(())
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn dev_environment_deserializes_from_yaml() {
+        // Locks in the YAML contract surfaced to users:
+        //
+        //   dev:
+        //     environment:
+        //       KEY: value
+        //
+        // A regression here (e.g. someone adding `rename_all = "camelCase"`
+        // to `DevConfig`, or moving the field) would silently drop user-
+        // configured env vars at `wash dev` startup.
+        let yaml = r#"
+dev:
+  environment:
+    RUST_LOG: debug
+    OTEL_EXPORTER_OTLP_ENDPOINT: http://localhost:4317
+"#;
+        let config: Config = serde_yaml_ng::from_str(yaml).unwrap();
+        let env = config.dev().environment;
+        assert_eq!(env.get("RUST_LOG").map(String::as_str), Some("debug"));
+        assert_eq!(
+            env.get("OTEL_EXPORTER_OTLP_ENDPOINT").map(String::as_str),
+            Some("http://localhost:4317")
+        );
+    }
+
+    #[test]
+    fn workload_yaml_uses_camel_case_for_renamed_fields() {
+        // `WorkloadConfig`, `EnvironmentLayer`, and `ConfigSource` carry
+        // `rename_all = "camelCase"`. Users write `configFrom` / `secretFrom`
+        // / `allowedHosts` / `fromEnv` in YAML; if a refactor drops one of
+        // those `rename_all` attributes, the camelCase keys get silently
+        // dropped (parses fine, fields stay default). Pin the contract.
+        let yaml = r#"
+workload:
+  environment:
+    config:
+      INLINE_KEY: inline_value
+    configFrom:
+      - app
+    secretFrom:
+      - creds
+  config:
+    flag: "on"
+  allowedHosts:
+    - https://api.example.com
+"#;
+        let config: Config = serde_yaml_ng::from_str(yaml).unwrap();
+        let workload = config.workload.expect("workload should parse");
+
+        let env = workload
+            .environment
+            .expect("environment layer should parse");
+        assert_eq!(env.config.get("INLINE_KEY").unwrap(), "inline_value");
+        assert_eq!(env.config_from, vec!["app".to_string()]);
+        assert_eq!(env.secret_from, vec!["creds".to_string()]);
+
+        assert_eq!(workload.config.get("flag").unwrap(), "on");
+        assert_eq!(
+            workload.allowed_hosts,
+            vec!["https://api.example.com".to_string()]
+        );
+    }
+
+    #[test]
+    fn configs_and_secrets_named_map_with_camel_case_source_fields() {
+        // The top-level `configs:` and `secrets:` blocks are name -> ConfigSource
+        // maps, and ConfigSource's `from_env` field is `fromEnv` in YAML.
+        // `secrets:` shares the same struct as `configs:` — pin both so a
+        // future split into separate types doesn't silently lose schema parity.
+        let yaml = r#"
+configs:
+  app:
+    inline:
+      APP_FOO: app_foo_value
+    file: ./app.env
+secrets:
+  creds:
+    fromEnv:
+      - DB_PASSWORD
+    inline:
+      DB_USER: alice
+"#;
+        let config: Config = serde_yaml_ng::from_str(yaml).unwrap();
+
+        let app = config.configs.get("app").expect("configs.app should parse");
+        assert_eq!(app.inline.get("APP_FOO").unwrap(), "app_foo_value");
+        assert_eq!(app.file.as_deref(), Some(Path::new("./app.env")));
+
+        let creds = config
+            .secrets
+            .get("creds")
+            .expect("secrets.creds should parse");
+        assert_eq!(creds.from_env, vec!["DB_PASSWORD".to_string()]);
+        assert_eq!(creds.inline.get("DB_USER").unwrap(), "alice");
+    }
+
+    #[test]
+    fn dev_environment_defaults_to_empty() {
+        // `dev.environment` is optional — a `dev:` block without it must
+        // not fail to parse, and must produce an empty map (not panic on
+        // the `set_var` loop reading a None).
+        let yaml = "dev: {}\n";
+        let config: Config = serde_yaml_ng::from_str(yaml).unwrap();
+        assert!(config.dev().environment.is_empty());
+    }
+}
