feat: make axum host configurable via manifest and env vars

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

@@ -1,4 +1,5 @@
 use std::fs;
+use std::net::SocketAddr;
 use std::path::{Path, PathBuf};
 use std::process::Command;
 
@@ -139,11 +140,12 @@ fn deploy(_extra_args: &[String]) -> Result<(), String> {
     Err("Axum adapter does not define a deploy command. Extend your workspace manifest with one if needed.".into())
 }
 
+#[derive(Debug)]
 struct AxumProject {
     crate_dir: PathBuf,
     cargo_manifest: PathBuf,
     crate_name: String,
-    port: u16,
+    addr: SocketAddr,
 }
 
 fn locate_project() -> Result<AxumProject, String> {
@@ -155,8 +157,8 @@ fn locate_project() -> Result<AxumProject, String> {
 fn run_cargo(project: &AxumProject, subcommand: &str, extra_args: &[String]) -> Result<(), String> {
     let display = project.crate_dir.display();
     println!(
-        "[edgezero] Axum {subcommand} ({}) in {} (port: {})",
-        project.crate_name, display, project.port
+        "[edgezero] Axum {subcommand} ({}) in {} ({})",
+        project.crate_name, display, project.addr
     );
     let mut command = Command::new("cargo");
     command.arg(subcommand);
@@ -169,6 +171,8 @@ fn run_cargo(project: &AxumProject, subcommand: &str, extra_args: &[String]) ->
     );
     command.args(extra_args);
     command.current_dir(&project.crate_dir);
+    command.env("EDGEZERO_HOST", project.addr.ip().to_string());
+    command.env("EDGEZERO_PORT", project.addr.port().to_string());
     let status = command
         .status()
         .map_err(|err| format!("failed to run cargo {subcommand}: {err}"))?;
@@ -255,24 +259,25 @@ fn read_axum_project(manifest: &Path) -> Result<AxumProject, String> {
             })
         });
 
-    let port = match adapter.get("port").and_then(Value::as_integer) {
-        Some(value) => {
-            if !(1..=u16::MAX as i64).contains(&value) {
-                return Err(format!(
-                    "adapter.port in {} must be between 1 and 65535",
-                    manifest.display()
-                ));
-            }
-            value as u16
-        }
-        None => 8787,
+    let config_host = adapter.get("host").and_then(Value::as_str);
+    let config_port = match adapter.get("port").and_then(Value::as_integer) {
+        Some(value) => Some(u16::try_from(value).map_err(|_| {
+            format!(
+                "adapter.port in {} must be between 1 and 65535",
+                manifest.display()
+            )
+        })?),
+        None => None,
     };
 
+    let addr = edgezero_core::addr::resolve_bind_addr(None, None, config_host, config_port)
+        .map_err(|e| format!("{e} (in {})", manifest.display()))?;
+
     Ok(AxumProject {
         crate_dir,
         cargo_manifest,
         crate_name,
-        port,
+        addr,
     })
 }
 
@@ -301,7 +306,8 @@ mod tests {
         assert_eq!(project.crate_name, "demo");
         assert_eq!(project.crate_dir, root);
         assert_eq!(project.cargo_manifest, root.join("Cargo.toml"));
-        assert_eq!(project.port, 8787);
+        assert_eq!(project.addr.port(), edgezero_core::addr::DEFAULT_PORT);
+        assert_eq!(project.addr.ip(), edgezero_core::addr::DEFAULT_HOST);
     }
 
     #[test]
@@ -337,7 +343,7 @@ mod tests {
         .unwrap();
 
         let project = read_axum_project(&root.join("axum.toml")).expect("project");
-        assert_eq!(project.port, 4001);
+        assert_eq!(project.addr.port(), 4001);
     }
 
     #[test]
@@ -510,7 +516,7 @@ mod tests {
         .unwrap();
 
         let project = read_axum_project(&root.join("axum.toml")).expect("project");
-        assert_eq!(project.port, 65535);
+        assert_eq!(project.addr.port(), 65535);
     }
 
     #[test]
@@ -529,7 +535,65 @@ mod tests {
         .unwrap();
 
         let project = read_axum_project(&root.join("axum.toml")).expect("project");
-        assert_eq!(project.port, 1);
+        assert_eq!(project.addr.port(), 1);
+    }
+
+    #[test]
+    fn read_axum_project_defaults_host_to_localhost() {
+        let dir = tempdir().unwrap();
+        let root = dir.path();
+        fs::write(
+            root.join("axum.toml"),
+            "[adapter]\ncrate = \"demo\"\ncrate_dir = \".\"\n",
+        )
+        .unwrap();
+        fs::write(
+            root.join("Cargo.toml"),
+            "[package]\nname = \"demo\"\nversion = \"0.1.0\"\n",
+        )
+        .unwrap();
+
+        let project = read_axum_project(&root.join("axum.toml")).expect("project");
+        assert_eq!(project.addr.ip(), edgezero_core::addr::DEFAULT_HOST);
+    }
+
+    #[test]
+    fn read_axum_project_uses_custom_host() {
+        let dir = tempdir().unwrap();
+        let root = dir.path();
+        fs::write(
+            root.join("axum.toml"),
+            "[adapter]\ncrate = \"demo\"\ncrate_dir = \".\"\nhost = \"0.0.0.0\"\n",
+        )
+        .unwrap();
+        fs::write(
+            root.join("Cargo.toml"),
+            "[package]\nname = \"demo\"\nversion = \"0.1.0\"\n",
+        )
+        .unwrap();
+
+        let project = read_axum_project(&root.join("axum.toml")).expect("project");
+        assert_eq!(project.addr.ip(), std::net::IpAddr::from([0, 0, 0, 0]));
+    }
+
+    #[test]
+    fn read_axum_project_rejects_invalid_host() {
+        let dir = tempdir().unwrap();
+        let root = dir.path();
+        fs::write(
+            root.join("axum.toml"),
+            "[adapter]\ncrate = \"demo\"\ncrate_dir = \".\"\nhost = \"not-an-ip\"\n",
+        )
+        .unwrap();
+        fs::write(
+            root.join("Cargo.toml"),
+            "[package]\nname = \"demo\"\nversion = \"0.1.0\"\n",
+        )
+        .unwrap();
+
+        let result = read_axum_project(&root.join("axum.toml"));
+        assert!(result.is_err());
+        assert!(result.unwrap_err().contains("valid IP address"));
     }
 
     #[test]

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

@@ -31,7 +31,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,
         }
     }
@@ -253,18 +256,24 @@ pub fn run_app<A: Hooks>(manifest_src: &str) -> anyhow::Result<()> {
 
     SimpleLogger::new().with_level(level).init().ok();
 
+    let addr = resolve_addr(manifest).map_err(|e| anyhow::anyhow!("{e}"))?;
     let app = A::build_app();
     let router = app.router().clone();
 
+    println!(
+        "[edgezero] starting axum server on http://{}:{}",
+        addr.ip(),
+        addr.port()
+    );
+
     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")?;
@@ -294,10 +303,35 @@ pub fn run_app<A: Hooks>(manifest_src: &str) -> anyhow::Result<()> {
                 }
             }
         };
-        serve_with_listener_and_kv_handle(router, listener, config.enable_ctrl_c, kv_handle).await
+        serve_with_listener_and_kv_handle(router, listener, true, kv_handle).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,
+) -> Result<SocketAddr, String> {
+    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>,
+) -> Result<SocketAddr, String> {
+    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::*;
@@ -422,6 +456,50 @@ 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 addr = resolve_addr_from_parts(loader.manifest(), None, None).unwrap();
+        assert_eq!(addr, SocketAddr::from(([127, 0, 0, 1], 8787)));
+    }
+
+    #[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 addr = resolve_addr_from_parts(loader.manifest(), None, None).unwrap();
+        assert_eq!(addr, SocketAddr::from(([0, 0, 0, 0], 3000)));
+    }
+
+    #[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 addr =
+            resolve_addr_from_parts(loader.manifest(), Some("0.0.0.0"), Some("4000")).unwrap();
+        assert_eq!(addr, SocketAddr::from(([0, 0, 0, 0], 4000)));
+    }
+
+    #[test]
+    fn resolve_addr_partial_env_override() {
+        let manifest = r#"
+[adapters.axum.adapter]
+port = 5000
+"#;
+        let loader = ManifestLoader::load_from_str(manifest);
+        let addr = resolve_addr_from_parts(loader.manifest(), Some("0.0.0.0"), None).unwrap();
+        assert_eq!(addr, SocketAddr::from(([0, 0, 0, 0], 5000)));
+    }
 }
 
 #[cfg(test)]

crates/edgezero-cli/src/dev_server.rs

@@ -25,7 +25,13 @@ pub fn run_dev() {
         Err(err) => eprintln!("[edgezero] dev manifest error: {err}"),
     }
 
-    let addr = SocketAddr::from(([127, 0, 0, 1], 8787));
+    let addr = match resolve_dev_addr() {
+        Ok(addr) => addr,
+        Err(err) => {
+            eprintln!("[edgezero] {err}");
+            return;
+        }
+    };
     println!(
         "[edgezero] dev: starting local server on http://{}:{}",
         addr.ip(),
@@ -83,6 +89,14 @@ 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() -> Result<SocketAddr, String> {
+    let env_host = std::env::var("EDGEZERO_HOST").ok();
+    let env_port = std::env::var("EDGEZERO_PORT").ok();
+    edgezero_core::addr::resolve_bind_addr(env_host.as_deref(), env_port.as_deref(), None, None)
+}
+
 fn try_run_manifest_axum() -> Result<bool, String> {
     let manifest = match load_manifest_optional()? {
         Some(manifest) => manifest,