Add provider-neutral secret store support

.gitignore

@@ -14,6 +14,12 @@ target/
 # OS
 .DS_Store
 
+# Worktrees
+.worktrees/
+
+# Superpowers plans
+docs/superpowers/
+
 # Editors
 .claude/*
 !.claude/settings.json

crates/edgezero-adapter-axum/Cargo.toml

@@ -50,6 +50,7 @@ walkdir = { workspace = true, optional = true }
 [dev-dependencies]
 async-trait = { workspace = true }
 axum = { workspace = true, features = ["macros"] }
+edgezero-core = { path = "../edgezero-core", features = ["test-utils"] }
 serde = { workspace = true }
 tempfile = { workspace = true }
 tokio = { workspace = true, features = ["macros", "rt", "rt-multi-thread"] }

crates/edgezero-adapter-axum/src/dev_server.rs

@@ -196,19 +196,23 @@
     let kv_handle = kv_path
         .map(|kv_path| kv_handle_from_path(Path::new(kv_path)))
         .transpose()?;
-    serve_with_listener_and_kv_handle(router, listener, enable_ctrl_c, kv_handle).await
+    serve_with_listener_and_stores(router, listener, enable_ctrl_c, kv_handle, None).await
 }
 
-async fn serve_with_listener_and_kv_handle(
+async fn serve_with_listener_and_stores(
     router: RouterService,
     listener: tokio::net::TcpListener,
     enable_ctrl_c: bool,
     kv_handle: Option<edgezero_core::key_value_store::KvHandle>,
+    secret_handle: Option<edgezero_core::secret_store::SecretHandle>,
 ) -> anyhow::Result<()> {
     let mut service = EdgeZeroAxumService::new(router);
     if let Some(kv_handle) = kv_handle {
         service = service.with_kv_handle(kv_handle);
     }
+    if let Some(secret_handle) = secret_handle {
+        service = service.with_secret_handle(secret_handle);
+    }
 
     let service = service;
     let router = Router::new().fallback_service(service_fn(move |req| {
@@ -243,6 +247,8 @@
     let kv_init_requirement = kv_init_requirement(manifest);
     let kv_store_name = manifest.kv_store_name("axum").to_string();
     let kv_path = kv_store_path(&kv_store_name);
+    let secret_store_name = manifest.secret_store_name("axum").to_string();
+    let has_secret_store = manifest.secret_store_enabled("axum");
 
     let level: LevelFilter = logging.level.into();
     let level = if logging.echo_stdout.unwrap_or(true) {
@@ -294,7 +300,25 @@
                 }
             }
         };
-        serve_with_listener_and_kv_handle(router, listener, config.enable_ctrl_c, kv_handle).await
+        let secret_handle = if has_secret_store {
+            log::info!(
+                "Secret store '{}': reading from environment variables",
+                secret_store_name
+            );
+            Some(edgezero_core::secret_store::SecretHandle::new(
+                std::sync::Arc::new(crate::secret_store::EnvSecretStore::new()),
+            ))
+        } else {
+            None
+        };
+        serve_with_listener_and_stores(
+            router,
+            listener,
+            config.enable_ctrl_c,
+            kv_handle,
+            secret_handle,
+        )
+        .await
     })
 }
 
@@ -427,8 +451,10 @@
 #[cfg(test)]
 mod integration_tests {
     use super::*;
+    use edgezero_core::action;
     use edgezero_core::context::RequestContext;
     use edgezero_core::error::EdgeError;
+    use edgezero_core::extractor::Secrets;
     use edgezero_core::router::RouterService;
     use std::time::{Duration, Instant};
 
@@ -781,4 +807,113 @@
 
         server.handle.abort();
     }
+
+    // -----------------------------------------------------------------------
+    // Secret store helpers
+    // -----------------------------------------------------------------------
+
+    struct TestServerSecrets {
+        base_url: String,
+        handle: tokio::task::JoinHandle<()>,
+    }
+
+    async fn start_test_server_with_secret_handle(
+        router: RouterService,
+        secret_handle: Option<edgezero_core::secret_store::SecretHandle>,
+    ) -> TestServerSecrets {
+        let listener = tokio::net::TcpListener::bind("127.0.0.1:0")
+            .await
+            .expect("bind secrets test server");
+        let addr = listener.local_addr().expect("local addr");
+        let handle = tokio::spawn(async move {
+            let _ =
+                super::serve_with_listener_and_stores(router, listener, false, None, secret_handle)
+                    .await;
+        });
+        TestServerSecrets {
+            base_url: format!("http://{}", addr),
+            handle,
+        }
+    }
+
+    #[action]
+    async fn secret_value_handler(Secrets(store): Secrets) -> Result<String, EdgeError> {
+        store.require_str("API_KEY").await.map_err(EdgeError::from)
+    }
+
+    // -----------------------------------------------------------------------
+    // Secret store integration tests
+    // -----------------------------------------------------------------------
+
+    #[tokio::test(flavor = "multi_thread")]
+    async fn secret_present_returns_value() {
+        use edgezero_core::secret_store::{InMemorySecretStore, SecretHandle};
+        use std::sync::Arc;
+
+        let router = RouterService::builder()
+            .get("/secret", secret_value_handler)
+            .build();
+        let store = InMemorySecretStore::new([("API_KEY", bytes::Bytes::from("s3cr3t"))]);
+        let handle = SecretHandle::new(Arc::new(store));
+        let server = start_test_server_with_secret_handle(router, Some(handle)).await;
+
+        let client = reqwest::Client::new();
+        let url = format!("{}/secret", server.base_url);
+        let response = send_with_retry(&client, |c| c.get(url.as_str())).await;
+
+        assert_eq!(response.status(), reqwest::StatusCode::OK);
+        assert_eq!(response.text().await.unwrap(), "s3cr3t");
+
+        server.handle.abort();
+    }
+
+    #[tokio::test(flavor = "multi_thread")]
+    async fn secret_missing_returns_500() {
+        use edgezero_core::secret_store::{InMemorySecretStore, SecretHandle};
+        use std::sync::Arc;
+
+        let router = RouterService::builder()
+            .get("/secret", secret_value_handler)
+            .build();
+        let store = InMemorySecretStore::new(std::iter::empty::<(&str, bytes::Bytes)>());
+        let handle = SecretHandle::new(Arc::new(store));
+        let server = start_test_server_with_secret_handle(router, Some(handle)).await;
+
+        let client = reqwest::Client::new();
+        let url = format!("{}/secret", server.base_url);
+        let response = send_with_retry(&client, |c| c.get(url.as_str())).await;
+
+        assert_eq!(
+            response.status(),
+            reqwest::StatusCode::INTERNAL_SERVER_ERROR
+        );
+        let body = response.text().await.unwrap();
+        assert!(!body.contains("API_KEY"));
+        assert!(body.contains("required secret is not configured"));
+
+        server.handle.abort();
+    }
+
+    #[tokio::test(flavor = "multi_thread")]
+    async fn no_secret_store_configured_returns_500() {
+        let router = RouterService::builder()
+            .get("/secret", secret_value_handler)
+            .build();
+        let server = start_test_server_with_secret_handle(router, None).await;
+
+        let client = reqwest::Client::new();
+        let url = format!("{}/secret", server.base_url);
+        let response = send_with_retry(&client, |c| c.get(url.as_str())).await;
+
+        assert_eq!(
+            response.status(),
+            reqwest::StatusCode::INTERNAL_SERVER_ERROR
+        );
+        let body = response.text().await.unwrap();
+        assert!(body.contains(
+            "no secret store configured -- check [stores.secrets] in edgezero.toml and platform bindings"
+        ));
+
+        server.handle.abort();
+    }
 }

crates/edgezero-adapter-axum/src/lib.rs

@@ -13,6 +13,8 @@ mod request;
 #[cfg(feature = "axum")]
 mod response;
 #[cfg(feature = "axum")]
+pub mod secret_store;
+#[cfg(feature = "axum")]
 mod service;
 
 #[cfg(feature = "cli")]
@@ -31,4 +33,6 @@ pub use request::into_core_request;
 #[cfg(feature = "axum")]
 pub use response::into_axum_response;
 #[cfg(feature = "axum")]
+pub use secret_store::EnvSecretStore;
+#[cfg(feature = "axum")]
 pub use service::EdgeZeroAxumService;

crates/edgezero-adapter-axum/src/secret_store.rs

@@ -0,0 +1,150 @@
+//! Environment variable secret store for local development.
+//!
+//! Reads secrets from the process environment. Set secrets as environment
+//! variables before starting the dev server:
+//!
+//! ```bash
+//! API_KEY=mysecret cargo edgezero dev
+//! ```
+
+use async_trait::async_trait;
+use bytes::Bytes;
+use edgezero_core::secret_store::{SecretError, SecretStore};
+
+/// Secret store for local development that reads secrets from environment variables.
+///
+/// When `[stores.secrets]` is declared in `edgezero.toml`, the dev server
+/// creates an `EnvSecretStore` that reads secrets from the process environment.
+pub struct EnvSecretStore;
+
+impl EnvSecretStore {
+    pub fn new() -> Self {
+        Self
+    }
+}
+
+impl Default for EnvSecretStore {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[async_trait(?Send)]
+impl SecretStore for EnvSecretStore {
+    async fn get_bytes(&self, name: &str) -> Result<Option<Bytes>, SecretError> {
+        #[cfg(unix)]
+        {
+            use std::os::unix::ffi::OsStringExt;
+
+            match std::env::var_os(name) {
+                Some(value) => Ok(Some(Bytes::from(value.into_vec()))),
+                None => Ok(None),
+            }
+        }
+
+        #[cfg(not(unix))]
+        {
+            match std::env::var(name) {
+                Ok(value) => Ok(Some(Bytes::from(value.into_bytes()))),
+                Err(std::env::VarError::NotPresent) => Ok(None),
+                Err(std::env::VarError::NotUnicode(_)) => Err(SecretError::Internal(
+                    anyhow::anyhow!("secret store returned an invalid Unicode value"),
+                )),
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use bytes::Bytes;
+    use std::ffi::OsString;
+    use std::sync::OnceLock;
+
+    fn env_guard() -> &'static tokio::sync::Mutex<()> {
+        static GUARD: OnceLock<tokio::sync::Mutex<()>> = OnceLock::new();
+        GUARD.get_or_init(|| tokio::sync::Mutex::new(()))
+    }
+
+    struct EnvOverride {
+        key: &'static str,
+        original: Option<OsString>,
+    }
+
+    impl EnvOverride {
+        fn set(key: &'static str, value: impl AsRef<std::ffi::OsStr>) -> Self {
+            let original = std::env::var_os(key);
+            std::env::set_var(key, value);
+            Self { key, original }
+        }
+
+        fn clear(key: &'static str) -> Self {
+            let original = std::env::var_os(key);
+            std::env::remove_var(key);
+            Self { key, original }
+        }
+    }
+
+    impl Drop for EnvOverride {
+        fn drop(&mut self) {
+            if let Some(ref original) = self.original {
+                std::env::set_var(self.key, original);
+            } else {
+                std::env::remove_var(self.key);
+            }
+        }
+    }
+
+    #[tokio::test(flavor = "current_thread")]
+    async fn get_bytes_returns_none_when_var_not_set() {
+        let _guard = env_guard().lock().await;
+        let _env = EnvOverride::clear("__EDGEZERO_TEST_MISSING_VAR_XYZ__");
+        let store = EnvSecretStore::new();
+        let result = store
+            .get_bytes("__EDGEZERO_TEST_MISSING_VAR_XYZ__")
+            .await
+            .unwrap();
+        assert!(result.is_none());
+    }
+
+    #[tokio::test(flavor = "current_thread")]
+    async fn get_bytes_returns_value_when_var_set() {
+        let _guard = env_guard().lock().await;
+        let _env = EnvOverride::set("__EDGEZERO_TEST_SECRET__", "test_value_123");
+        let store = EnvSecretStore::new();
+        let result = store.get_bytes("__EDGEZERO_TEST_SECRET__").await.unwrap();
+        assert_eq!(result, Some(Bytes::from("test_value_123")));
+    }
+
+    #[cfg(unix)]
+    #[tokio::test(flavor = "current_thread")]
+    async fn get_bytes_preserves_non_utf8_secret_values() {
+        use std::os::unix::ffi::OsStringExt;
+
+        let _guard = env_guard().lock().await;
+        let _env = EnvOverride::set(
+            "__EDGEZERO_TEST_BINARY_SECRET__",
+            OsString::from_vec(vec![0xff, 0x61]),
+        );
+        let store = EnvSecretStore::new();
+        let result = store
+            .get_bytes("__EDGEZERO_TEST_BINARY_SECRET__")
+            .await
+            .unwrap();
+        assert_eq!(result, Some(Bytes::from_static(&[0xff, 0x61])));
+    }
+
+    // Contract tests: use InMemorySecretStore since EnvSecretStore needs
+    // real env vars, which are unsafe in parallel tests.
+    // The EnvSecretStore is tested individually above.
+    use edgezero_core::secret_store::InMemorySecretStore;
+    use edgezero_core::secret_store_contract_tests;
+
+    secret_store_contract_tests!(env_secret_contract, {
+        InMemorySecretStore::new([
+            ("contract_key", Bytes::from("contract_value")),
+            ("contract_key_2", Bytes::from("another_value")),
+        ])
+    });
+}