feat: make axum host configurable via manifest and env vars

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

@@ -35,7 +35,10 @@ pub struct AxumDevServerConfig {
 impl Default for AxumDevServerConfig {
     fn default() -> Self {
         Self {
-            addr: SocketAddr::from(([127, 0, 0, 1], 8787)),
+            addr: SocketAddr::from((
+                edgezero_core::addr::DEFAULT_HOST,
+                edgezero_core::addr::DEFAULT_PORT,
+            )),
             enable_ctrl_c: true,
         }
     }
@@ -292,17 +295,24 @@ pub fn run_app<A: Hooks>(manifest_src: &str) -> anyhow::Result<()> {
 
     SimpleLogger::new().with_level(level).init().ok();
 
+    let resolution = resolve_addr(m);
+    for warning in &resolution.warnings {
+        log::warn!("{warning}");
+    }
+    let addr = resolution.addr;
     let app = A::build_app();
     let router = app.router().clone();
+
+    println!("[edgezero] starting axum server on http://{}", addr);
+
     let runtime = RuntimeBuilder::new_multi_thread()
         .enable_all()
         .build()
         .context("failed to build tokio runtime")?;
 
     runtime.block_on(async move {
-        let config = AxumDevServerConfig::default();
-        let listener = StdTcpListener::bind(config.addr)
-            .with_context(|| format!("failed to bind dev server to {}", config.addr))?;
+        let listener = StdTcpListener::bind(addr)
+            .with_context(|| format!("failed to bind dev server to {}", addr))?;
         listener
             .set_nonblocking(true)
             .context("failed to set listener to non-blocking")?;
@@ -357,10 +367,35 @@ pub fn run_app<A: Hooks>(manifest_src: &str) -> anyhow::Result<()> {
             kv: kv_handle,
             secrets: secret,
         };
-        serve_with_stores(router, listener, config.enable_ctrl_c, stores).await
+        serve_with_stores(router, listener, true, stores).await
     })
 }
 
+/// Resolve the bind address from environment variables and manifest config.
+///
+/// Precedence (highest wins):
+/// 1. `EDGEZERO_HOST` / `EDGEZERO_PORT` environment variables
+/// 2. `[adapters.axum.adapter]` host/port in the manifest
+/// 3. Default: `127.0.0.1:8787`
+pub(crate) fn resolve_addr(
+    manifest: &edgezero_core::manifest::Manifest,
+) -> edgezero_core::addr::BindAddrResolution {
+    let env_host = std::env::var("EDGEZERO_HOST").ok();
+    let env_port = std::env::var("EDGEZERO_PORT").ok();
+    resolve_addr_from_parts(manifest, env_host.as_deref(), env_port.as_deref())
+}
+
+fn resolve_addr_from_parts(
+    manifest: &edgezero_core::manifest::Manifest,
+    env_host: Option<&str>,
+    env_port: Option<&str>,
+) -> edgezero_core::addr::BindAddrResolution {
+    let adapter = manifest.adapters.get("axum");
+    let config_host = adapter.and_then(|a| a.adapter.host.as_deref());
+    let config_port = adapter.and_then(|a| a.adapter.port);
+    edgezero_core::addr::resolve_bind_addr(env_host, env_port, config_host, config_port)
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -485,6 +520,79 @@ name = "EDGEZERO_KV"
             "unexpected file name length: {file_name}"
         );
     }
+
+    #[test]
+    fn resolve_addr_defaults_without_manifest_config() {
+        // Note: env var tests use resolve_addr_from_parts to avoid races.
+        let loader = ManifestLoader::load_from_str("");
+        let resolution = resolve_addr_from_parts(loader.manifest(), None, None);
+        assert_eq!(resolution.addr, SocketAddr::from(([127, 0, 0, 1], 8787)));
+        assert!(resolution.warnings.is_empty());
+    }
+
+    #[test]
+    fn resolve_addr_reads_manifest_host_and_port() {
+        let manifest = r#"
+[adapters.axum.adapter]
+host = "0.0.0.0"
+port = 3000
+"#;
+        let loader = ManifestLoader::load_from_str(manifest);
+        let resolution = resolve_addr_from_parts(loader.manifest(), None, None);
+        assert_eq!(resolution.addr, SocketAddr::from(([0, 0, 0, 0], 3000)));
+        assert!(resolution.warnings.is_empty());
+    }
+
+    #[test]
+    fn resolve_addr_env_overrides_manifest() {
+        let manifest = r#"
+[adapters.axum.adapter]
+host = "127.0.0.1"
+port = 3000
+"#;
+        let loader = ManifestLoader::load_from_str(manifest);
+        let resolution = resolve_addr_from_parts(loader.manifest(), Some("0.0.0.0"), Some("4000"));
+        assert_eq!(resolution.addr, SocketAddr::from(([0, 0, 0, 0], 4000)));
+        assert!(resolution.warnings.is_empty());
+    }
+
+    #[test]
+    fn resolve_addr_partial_env_override() {
+        let manifest = r#"
+[adapters.axum.adapter]
+port = 5000
+"#;
+        let loader = ManifestLoader::load_from_str(manifest);
+        let resolution = resolve_addr_from_parts(loader.manifest(), Some("0.0.0.0"), None);
+        assert_eq!(resolution.addr, SocketAddr::from(([0, 0, 0, 0], 5000)));
+        assert!(resolution.warnings.is_empty());
+    }
+
+    #[test]
+    fn resolve_addr_invalid_env_falls_back_to_manifest() {
+        let manifest = r#"
+[adapters.axum.adapter]
+host = "0.0.0.0"
+port = 5000
+"#;
+        let loader = ManifestLoader::load_from_str(manifest);
+        let resolution = resolve_addr_from_parts(loader.manifest(), Some("not-an-ip"), Some("abc"));
+        assert_eq!(resolution.addr, SocketAddr::from(([0, 0, 0, 0], 5000)));
+        assert_eq!(resolution.warnings.len(), 2);
+    }
+
+    #[test]
+    fn resolve_addr_invalid_manifest_falls_back_to_default() {
+        let manifest = r#"
+[adapters.axum.adapter]
+host = "localhost"
+port = 0
+"#;
+        let loader = ManifestLoader::load_from_str(manifest);
+        let resolution = resolve_addr_from_parts(loader.manifest(), None, None);
+        assert_eq!(resolution.addr, SocketAddr::from(([127, 0, 0, 1], 8787)));
+        assert_eq!(resolution.warnings.len(), 2);
+    }
 }
 
 #[cfg(test)]

crates/edgezero-adapter-axum/src/templates/axum.toml.hbs

@@ -1,4 +1,5 @@
 [adapter]
 crate = "{{proj_axum}}"
 crate_dir = "."
+host = "127.0.0.1"
 port = 8787

crates/edgezero-cli/src/dev_server.rs

@@ -25,12 +25,8 @@ pub fn run_dev() {
         Err(err) => eprintln!("[edgezero] dev manifest error: {err}"),
     }
 
-    let addr = SocketAddr::from(([127, 0, 0, 1], 8787));
-    println!(
-        "[edgezero] dev: starting local server on http://{}:{}",
-        addr.ip(),
-        addr.port()
-    );
+    let addr = resolve_dev_addr();
+    println!("[edgezero] dev: starting local server on http://{}", addr);
 
     let router = build_dev_router();
     let config = AxumDevServerConfig {
@@ -83,6 +79,23 @@ async fn dev_echo(Path(params): Path<EchoParams>) -> Text<String> {
     Text::new(format!("hello {}", params.name))
 }
 
+/// Resolve the dev server bind address from `EDGEZERO_HOST` / `EDGEZERO_PORT`
+/// environment variables, falling back to `127.0.0.1:8787`.
+fn resolve_dev_addr() -> SocketAddr {
+    let env_host = std::env::var("EDGEZERO_HOST").ok();
+    let env_port = std::env::var("EDGEZERO_PORT").ok();
+    let resolution = edgezero_core::addr::resolve_bind_addr(
+        env_host.as_deref(),
+        env_port.as_deref(),
+        None,
+        None,
+    );
+    for warning in &resolution.warnings {
+        eprintln!("[edgezero] {warning}");
+    }
+    resolution.addr
+}
+
 fn try_run_manifest_axum() -> Result<bool, String> {
     let manifest = match load_manifest_optional()? {
         Some(manifest) => manifest,