move repos into monorepo

bin/coordinator/main.rs

@@ -0,0 +1,142 @@
+use clap::Parser;
+use std::net::{IpAddr, SocketAddr};
+use std::sync::Arc;
+
+use tracing::{error, info};
+use tracing_subscriber::EnvFilter;
+#[derive(Debug, Clone, Parser)]
+#[command(
+    name = "herocoordinator",
+    version,
+    about = "Hero Coordinator CLI",
+    long_about = None
+)]
+struct Cli {
+    #[arg(
+        long = "mycelium-ip",
+        short = 'i',
+        env = "MYCELIUM_IP",
+        default_value = "127.0.0.1",
+        help = "IP address where Mycelium JSON-RPC is listening (default: 127.0.0.1)"
+    )]
+    mycelium_ip: IpAddr,
+
+    #[arg(
+        long = "mycelium-port",
+        short = 'p',
+        env = "MYCELIUM_PORT",
+        default_value_t = 8990u16,
+        help = "Port for Mycelium JSON-RPC (default: 8990)"
+    )]
+    mycelium_port: u16,
+
+    #[arg(
+        long = "redis-addr",
+        short = 'r',
+        env = "REDIS_ADDR",
+        default_value = "127.0.0.1:6379",
+        help = "Socket address of Redis instance (default: 127.0.0.1:6379)"
+    )]
+    redis_addr: SocketAddr,
+
+    #[arg(
+        long = "api-http-ip",
+        env = "API_HTTP_IP",
+        default_value = "127.0.0.1",
+        help = "Bind IP for HTTP JSON-RPC server (default: 127.0.0.1)"
+    )]
+    api_http_ip: IpAddr,
+
+    #[arg(
+        long = "api-http-port",
+        env = "API_HTTP_PORT",
+        default_value_t = 9652u16,
+        help = "Bind port for HTTP JSON-RPC server (default: 9652)"
+    )]
+    api_http_port: u16,
+
+    #[arg(
+        long = "api-ws-ip",
+        env = "API_WS_IP",
+        default_value = "127.0.0.1",
+        help = "Bind IP for WebSocket JSON-RPC server (default: 127.0.0.1)"
+    )]
+    api_ws_ip: IpAddr,
+
+    #[arg(
+        long = "api-ws-port",
+        env = "API_WS_PORT",
+        default_value_t = 9653u16,
+        help = "Bind port for WebSocket JSON-RPC server (default: 9653)"
+    )]
+    api_ws_port: u16,
+}
+
+#[tokio::main]
+async fn main() {
+    let cli = Cli::parse();
+    // Initialize tracing subscriber (pretty formatter; controlled by RUST_LOG)
+    let filter = EnvFilter::try_from_default_env().unwrap_or_else(|_| EnvFilter::new("info"));
+    tracing_subscriber::fmt()
+        .with_env_filter(filter)
+        .pretty()
+        .with_target(true)
+        .with_level(true)
+        .init();
+
+    let http_addr = SocketAddr::new(cli.api_http_ip, cli.api_http_port);
+    let ws_addr = SocketAddr::new(cli.api_ws_ip, cli.api_ws_port);
+
+    // Initialize Redis driver
+    let redis = herocoordinator::storage::RedisDriver::new(cli.redis_addr.to_string())
+        .await
+        .expect("Failed to connect to Redis");
+
+    // Initialize Service
+    let service = herocoordinator::service::AppService::new(redis);
+    let service_for_router = service.clone();
+
+    // Shared application state
+    let state = Arc::new(herocoordinator::rpc::AppState::new(service));
+
+    // Start router workers (auto-discovered contexts) using a single global SupervisorHub (no separate inbound listener)
+    {
+        let base_url = format!("http://{}:{}", cli.mycelium_ip, cli.mycelium_port);
+        let hub = herocoordinator::clients::SupervisorHub::new(
+            base_url.clone(),
+            "supervisor.rpc".to_string(),
+        )
+        .expect("Failed to initialize SupervisorHub");
+        let cfg = herocoordinator::router::RouterConfig {
+            context_ids: Vec::new(), // ignored by start_router_auto
+            concurrency: 32,
+            base_url,
+            topic: "supervisor.rpc".to_string(),
+            sup_hub: hub.clone(),
+            transport_poll_interval_secs: 2,
+            transport_poll_timeout_secs: 300,
+        };
+        // Per-context outbound delivery loops (replies handled by SupervisorHub)
+        let _auto_handle = herocoordinator::router::start_router_auto(service_for_router, cfg);
+    }
+
+    // Build RPC modules for both servers
+    let http_module = herocoordinator::rpc::build_module(state.clone());
+    let ws_module = herocoordinator::rpc::build_module(state.clone());
+
+    info!(%http_addr, %ws_addr, redis_addr=%cli.redis_addr, "Starting JSON-RPC servers");
+
+    // Start servers
+    let _http_handle = herocoordinator::rpc::start_http(http_addr, http_module)
+        .await
+        .expect("Failed to start HTTP server");
+    let _ws_handle = herocoordinator::rpc::start_ws(ws_addr, ws_module)
+        .await
+        .expect("Failed to start WS server");
+
+    // Wait for Ctrl+C to terminate
+    if let Err(e) = tokio::signal::ctrl_c().await {
+        error!(error=%e, "Failed to listen for shutdown signal");
+    }
+    info!("Shutdown signal received, exiting.");
+}