use super::{InternalFn, get_clm_args};
pub(super) fn dispatch(module_path: &str) -> Option<InternalFn> {
dispatch_network_discovery(module_path)
.or_else(|| dispatch_testing_verification(module_path))
}
fn dispatch_network_discovery(module_path: &str) -> Option<InternalFn> {
match module_path {
"clm_rust_core::discovery_engine::mdns_discovery" => Some(|_clm_root, clm_file| {
let args = get_clm_args(clm_file)?;
let mut mode = "both";
let mut port = None;
let mut name = None;
let mut did = None;
let mut i = 0;
while i < args.len() {
match args[i].as_str() {
"--mode" => { if i+1 < args.len() { mode = &args[i+1]; i += 2; } else { i += 1; } }
"--port" => { if i+1 < args.len() { port = args[i+1].parse().ok(); i += 2; } else { i += 1; } }
"--name" => { if i+1 < args.len() { name = Some(args[i+1].clone()); i += 2; } else { i += 1; } }
"--did" => { if i+1 < args.len() { did = Some(args[i+1].clone()); i += 2; } else { i += 1; } }
_ => i += 1,
}
}
let resolved_port = port.unwrap_or(9095);
let resolved_name = name.unwrap_or_else(|| "pkc-localnode".to_string());
let resolved_did = did.unwrap_or_else(|| "did:pkc:local:unknown".to_string());
let engine = crate::discovery_engine::DiscoveryEngine::new();
if mode == "announce" {
engine.announce(&resolved_name, &resolved_did, resolved_port).map_err(|e| e.to_string())?;
Ok((0, "Announced".to_string()))
} else {
let peers = engine.discover(std::time::Duration::from_secs(5)).map_err(|e| e.to_string())?;
let out = serde_json::to_string_pretty(&serde_json::json!({ "peers": peers })).unwrap();
Ok((0, out))
}
}),
"clm_rust_core::discovery_engine::discovery_node" => Some(|clm_root, clm_file| {
let args = get_clm_args(clm_file)?;
let mut port = None;
let mut db_path = None;
let mut i = 0;
while i < args.len() {
match args[i].as_str() {
"--port" => { if i+1 < args.len() { port = args[i+1].parse().ok(); i += 2; } else { i += 1; } }
"--db" => { if i+1 < args.len() { db_path = Some(args[i+1].clone()); i += 2; } else { i += 1; } }
_ => i += 1,
}
}
let resolved_port = port.unwrap_or(9095);
let resolved_db = db_path.unwrap_or_else(|| {
crate::db::get_db_path("agent_identities", clm_root).to_string_lossy().into_owned()
});
crate::discovery_engine::run_discovery_node(resolved_port, &resolved_db)
.map(|_| (0, "".to_string())).map_err(|e| e.to_string())
}),
"clm_rust_core::discovery_engine::discover" => Some(|_clm_root, clm_file| {
let args = get_clm_args(clm_file)?;
let mut handshake = None;
let mut did = None;
let mut key = None;
let mut i = 0;
while i < args.len() {
match args[i].as_str() {
"--handshake" => { if i+1 < args.len() { handshake = Some(args[i+1].clone()); i += 2; } else { i += 1; } }
"--did" => { if i+1 < args.len() { did = Some(args[i+1].clone()); i += 2; } else { i += 1; } }
"--key" => { if i+1 < args.len() { key = Some(args[i+1].clone()); i += 2; } else { i += 1; } }
_ => i += 1,
}
}
if let Some(target) = handshake {
let resolved_did = did.unwrap_or_default();
let resolved_key = key.unwrap_or_default();
let parts: Vec<&str> = target.split(':').collect();
if parts.len() != 2 {
return Err("Invalid handshake target. Must be ip:port".to_string());
}
let ip = parts[0];
let port: u16 = parts[1].parse().unwrap_or(0);
crate::discovery_engine::perform_handshake(ip, port, &resolved_did, &resolved_key)
.map(|res| (0, serde_json::to_string_pretty(&res).unwrap())).map_err(|e| e.to_string())
} else {
Err("Discover mode needs --handshake".to_string())
}
}),
"clm_rust_core::network_gateway::chat_gateway" => Some(|_clm_root, clm_file| {
let args = get_clm_args(clm_file)?;
let mut port = None;
let mut timeout = None;
let mut i = 0;
while i < args.len() {
match args[i].as_str() {
"--port" => { if i+1 < args.len() { port = args[i+1].parse().ok(); i += 2; } else { i += 1; } }
"--timeout" => { if i+1 < args.len() { timeout = args[i+1].parse().ok(); i += 2; } else { i += 1; } }
_ => i += 1,
}
}
let mut gateway = crate::network_gateway::NetworkGateway::new();
if let Some(p) = port { gateway.port = p; }
if let Some(t) = timeout { gateway.timeout = t; }
let rt = tokio::runtime::Runtime::new().map_err(|e| e.to_string())?;
rt.block_on(async {
gateway.start().await.map_err(|e| e.to_string())
})?;
Ok((0, "".to_string()))
}),
_ => None,
}
}
#[path = "registry_infra_testing.rs"]
mod registry_infra_testing;
#[allow(unused_imports)]
pub use registry_infra_testing::*;