Sync OSS release

Author: Symbiont OSS Sync

crates/runtime/src/api/server.rs

@@ -381,7 +381,7 @@ impl HttpApiServer {
             use axum::http::{header, HeaderValue, Method};
 
             let allowed_origins: Vec<HeaderValue> = std::env::var("SYMBIONT_CORS_ORIGINS")
-                .unwrap_or_else(|_| "http://localhost:3000".to_string())
+                .unwrap_or_else(|_| "http://localhost:3001,http://localhost:3000".to_string())
                 .split(',')
                 .filter_map(|origin| origin.trim().parse().ok())
                 .collect();

src/commands/status.rs

@@ -4,12 +4,26 @@ use sysinfo::System;
 pub async fn run() {
     println!("📊 Symbiont Runtime Status\n");
 
-    // Check if runtime is running
-    print!("Runtime: ");
-    if is_runtime_running() {
-        println!("✓ Running on :8080");
+    let api_up = is_port_listening(8080);
+    let http_up = is_port_listening(8081);
+
+    // Check if runtime is running (either port indicates a running instance)
+    print!("Runtime API :8080  ");
+    if api_up {
+        println!("✓ Running");
+    } else {
+        println!("✗ Not listening");
+    }
+
+    print!("HTTP Input  :8081  ");
+    if http_up {
+        println!("✓ Running");
     } else {
-        println!("✗ Not running (start with: symbi up)");
+        println!("✗ Not listening");
+    }
+
+    if !api_up && !http_up {
+        println!("\n✗ Not running (start with: symbi up)");
         return;
     }
 
@@ -27,10 +41,10 @@ pub async fn run() {
     // Routes
     println!("\n🔀 Routes:");
     println!("  • /webhook → webhook_handler (auto-configured)");
-
-    // I/O Handlers
-    println!("\n🔌 I/O Handlers:");
-    println!("  • HTTP Input :8081 (enabled)");
+    if api_up {
+        println!("  • /api/v1/* → management API");
+        println!("  • /swagger-ui → API documentation");
+    }
 
     // Resource usage
     println!("\n💾 Resources:");
@@ -42,9 +56,8 @@ pub async fn run() {
     println!();
 }
 
-fn is_runtime_running() -> bool {
-    // Check if runtime is listening on port 8080
-    std::net::TcpStream::connect("127.0.0.1:8080")
+fn is_port_listening(port: u16) -> bool {
+    std::net::TcpStream::connect(format!("127.0.0.1:{}", port))
         .map(|_| true)
         .unwrap_or(false)
 }

src/commands/up.rs

@@ -7,6 +7,7 @@ use symbi_channel_adapter::{
     AgentInvoker, BasicInteractionLogger, ChannelAdapterManager, ChannelConfig, ChatPlatform,
     MattermostConfig, PlatformSettings, SlackConfig, TeamsConfig,
 };
+use symbi_runtime::api::server::{HttpApiConfig, HttpApiServer};
 use symbi_runtime::http_input::llm_client::LlmClient;
 use symbi_runtime::http_input::{start_http_input, HttpInputConfig};
 use symbi_runtime::types::AgentId;
@@ -29,6 +30,9 @@ pub async fn run(matches: &ArgMatches) {
     let http_port = matches
         .get_one::<String>("http-port")
         .expect("http-port argument is required");
+    let http_bind = matches
+        .get_one::<String>("http-bind")
+        .expect("http-bind argument has default value");
     let http_token = matches.get_one::<String>("http-token");
     let cors_origins: Vec<String> = matches
         .get_one::<String>("http-cors-origins")
@@ -97,8 +101,8 @@ pub async fn run(matches: &ArgMatches) {
     // Scan agents directory
     let agents_found = scan_agents_directory();
 
-    println!("✓ Runtime started on :{}", port);
-    println!("✓ HTTP Input enabled on :{}", http_port);
+    println!("✓ Runtime API on {}:{}", http_bind, port);
+    println!("✓ HTTP Input on {}:{}", http_bind, http_port);
     println!("✓ Authentication: ENABLED (Bearer token required)");
 
     if let Some(agent) = agents_found.first() {
@@ -155,7 +159,7 @@ pub async fn run(matches: &ArgMatches) {
     };
 
     let http_config = HttpInputConfig {
-        bind_address: "127.0.0.1".to_string(),
+        bind_address: http_bind.clone(),
         port: http_port_num,
         path: "/webhook".to_string(),
         agent: agent_id,
@@ -433,7 +437,35 @@ pub async fn run(matches: &ArgMatches) {
         channel_manager = Some(manager);
     }
 
+    // Parse the API port and configure the management API server
+    let api_port_num = match port.parse::<u16>() {
+        Ok(p) => p,
+        Err(e) => {
+            eprintln!("✗ Invalid API port number '{}': {}", port, e);
+            return;
+        }
+    };
+
+    let api_config = HttpApiConfig {
+        bind_address: http_bind.clone(),
+        port: api_port_num,
+        enable_cors: true,
+        enable_tracing: true,
+        enable_rate_limiting: true,
+        api_keys_file: None,
+    };
+
+    let mut api_server = HttpApiServer::new(api_config);
+    if let Some(ref rt) = runtime {
+        api_server = api_server.with_runtime_provider(rt.clone());
+    }
+
     tokio::select! {
+        result = api_server.start() => {
+            if let Err(e) = result {
+                eprintln!("✗ API server error: {}", e);
+            }
+        },
         _ = start_http_input(http_config, runtime.clone(), secrets_config) => {},
         _ = tokio::signal::ctrl_c() => {}
     }

src/main.rs

@@ -30,6 +30,13 @@ async fn main() {
                         .help("HTTP Input port")
                         .default_value("8081"),
                 )
+                .arg(
+                    Arg::new("http-bind")
+                        .long("http-bind")
+                        .value_name("ADDRESS")
+                        .help("HTTP bind address (default: 127.0.0.1; use 0.0.0.0 for all interfaces)")
+                        .default_value("127.0.0.1"),
+                )
                 .arg(
                     Arg::new("http-token")
                         .long("http.token")