clm-kernel 0.0.13

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
// evaluator/dispatch/registry_infra.rs
// ─────────────────────────────────────────────────────────────
// L3 Network + Infrastructure dispatch entries:
//   - Network Discovery & Gateway (mDNS, handshake, chat gateway)
//   - Testing & Verification (prove_tests, all integration::test_* entries, test math/braid ops)
// ─────────────────────────────────────────────────────────────

use super::{InternalFn, get_clm_args};

/// Composite dispatcher for infrastructure modules.
pub(super) fn dispatch(module_path: &str) -> Option<InternalFn> {
    dispatch_network_discovery(module_path)
        .or_else(|| dispatch_testing_verification(module_path))
}

// ── Network Discovery & Gateway ─────────────────────────────

fn dispatch_network_discovery(module_path: &str) -> Option<InternalFn> {
    match module_path {
        // L3 Network Gateway & P2P Mesh
        "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::*;