clm-kernel 0.0.14

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
#![allow(unused_imports)]
use super::*;

pub fn run_logic(command: Commands, _clm_root: &str) -> (i32, String, String) {
    match command {
        Commands::Daemon { .. } => (0, String::new(), String::new()),
        _ => (0, String::new(), String::new()),
    }
}

pub(super) static RUST_NODE_IDENTITY: std::sync::OnceLock<clm_rust_core::mesh::noise::SovereignNodeIdentity> = std::sync::OnceLock::new();

pub(super) fn get_rust_node_identity() -> &'static clm_rust_core::mesh::noise::SovereignNodeIdentity {
    RUST_NODE_IDENTITY.get_or_init(clm_rust_core::mesh::noise::SovereignNodeIdentity::generate)
}

pub(super) fn canonical_json_str(val: &serde_json::Value) -> String {
    // Sprint 529: single canonicalizer (parity pinned by canonical_parity_tests).
    clm_rust_core::layer0::codec::canonical_json(val).unwrap_or_default()
}

pub(super) fn handle_satori_envelope_line(line: &str) -> Option<String> {
    let incoming: serde_json::Value = serde_json::from_str(line).ok()?;
    if incoming.get("command").and_then(|c| c.as_str()) == Some("shutdown") {
        return Some("{\"status\":\"shutting_down\"}".to_string());
    }
    if incoming.get("protocol").and_then(|p| p.as_str()) != Some("satori.v1") {
        return None;
    }
    let identity = get_rust_node_identity();
    let sender_did = incoming.get("sender_did").and_then(|s| s.as_str()).unwrap_or("");
    let message_id = incoming.get("message_id").and_then(|m| m.as_str()).unwrap_or("");
    let speech_act = incoming.get("speech_act").and_then(|a| a.as_str()).unwrap_or("");
    let payload = incoming.get("payload").cloned().unwrap_or(serde_json::Value::Null);
    let payload_hash = incoming.get("payload_hash").and_then(|h| h.as_str()).unwrap_or("");
    let signature = incoming.get("signature").and_then(|s| s.as_str()).unwrap_or("");

    // Verify payload hash
    let expected_hash = blake3::hash(canonical_json_str(&payload).as_bytes()).to_hex().to_string();
    let hash_matched = expected_hash == payload_hash;

    // Verify signature
    let mut sig_valid = false;
    if let Some(pub_hex) = sender_did.strip_prefix("did:clm:key:")
        && let (Ok(pub_bytes), Ok(sig_bytes)) = (hex::decode(pub_hex), hex::decode(signature))
        && pub_bytes.len() == 32
        && sig_bytes.len() == 64
    {
        let mut pub_arr = [0u8; 32];
        pub_arr.copy_from_slice(&pub_bytes);
        let mut sig_arr = [0u8; 64];
        sig_arr.copy_from_slice(&sig_bytes);

        let recipient_did = incoming.get("recipient_did").and_then(|r| r.as_str()).unwrap_or("");
        let signing_string = format!(
            "satori.v1:{}:{}:{}:{}:{}",
            message_id, sender_did, recipient_did, speech_act, payload_hash
        );
        sig_valid = clm_rust_core::mesh::noise::SovereignNodeIdentity::verify_signature(
            &pub_arr,
            signing_string.as_bytes(),
            &sig_arr,
        );
    }
    let verified = hash_matched && sig_valid;

    let rust_did = format!("did:clm:key:{}", hex::encode(identity.ed25519_public_key));

    let (resp_act, resp_payload) = match speech_act {
        "handshake" | "inform" => (
            "accept",
            serde_json::json!({
                "status": "acknowledged",
                "received_act": speech_act,
                "verified": verified,
                "message": "Handshake acknowledged by Rust Satori Daemon",
                "timestamp": chrono::Utc::now().timestamp_millis()
            }),
        ),
        "request" => (
            "propose",
            serde_json::json!({
                "action": payload.get("action").and_then(|a| a.as_str()).unwrap_or("action:augment_cache"),
                "fitness": 0.084210,
                "status": "ready",
                "timestamp": chrono::Utc::now().timestamp_millis()
            }),
        ),
        "propose" => (
            "accept",
            serde_json::json!({
                "proposal_id": message_id,
                "verdict": "COMMITTED",
                "timestamp": chrono::Utc::now().timestamp_millis()
            }),
        ),
        "accept" => (
            "inform",
            serde_json::json!({
                "status": "session_sealed",
                "completed": true,
                "timestamp": chrono::Utc::now().timestamp_millis()
            }),
        ),
        _ => (
            "inform",
            serde_json::json!({
                "status": "echo",
                "received_act": speech_act,
                "timestamp": chrono::Utc::now().timestamp_millis()
            }),
        ),
    };

    let canonical_payload = canonical_json_str(&resp_payload);
    let resp_payload_hash = blake3::hash(canonical_payload.as_bytes()).to_hex().to_string();
    let resp_msg_id = format!("urn:uuid:{}", uuid::Uuid::new_v4());
    let signing_str = format!(
        "satori.v1:{}:{}:{}:{}:{}",
        resp_msg_id, rust_did, sender_did, resp_act, resp_payload_hash
    );
    let sig_bytes = identity.sign(signing_str.as_bytes());

    let envelope = serde_json::json!({
        "protocol": "satori.v1",
        "message_id": resp_msg_id,
        "sender_did": rust_did,
        "recipient_did": sender_did,
        "speech_act": resp_act,
        "payload_hash": resp_payload_hash,
        "payload": resp_payload,
        "signature": hex::encode(sig_bytes),
        "in_response_to": message_id
    });

    Some(serde_json::to_string(&envelope).unwrap_or_default())
}

pub(super) fn handle_satori_stream(stream: &std::net::TcpStream, reader: &mut BufReader<&std::net::TcpStream>, initial_line: &str) {
    let mut write_stream = stream;
    if let Some(resp) = handle_satori_envelope_line(initial_line) {
        let is_shutdown = resp.contains("\"shutting_down\"");
        let _ = write_stream.write_all(resp.as_bytes());
        let _ = write_stream.write_all(b"\n");
        let _ = write_stream.flush();
        if is_shutdown {
            std::process::exit(0);
        }
    }
    let mut line_buf = String::new();
    while let Ok(n) = reader.read_line(&mut line_buf) {
        if n == 0 { break; }
        let t = line_buf.trim();
        if !t.is_empty()
            && let Some(resp) = handle_satori_envelope_line(t) {
                let is_shutdown = resp.contains("\"shutting_down\"");
                let _ = write_stream.write_all(resp.as_bytes());
                let _ = write_stream.write_all(b"\n");
                let _ = write_stream.flush();
                if is_shutdown {
                    std::process::exit(0);
                }
            }
        line_buf.clear();
    }
}

#[cfg(test)]
mod canonical_parity_tests {
    use super::canonical_json_str;
    use clm_rust_core::layer0::codec::canonical_json;
    use serde_json::json;

    // The bin target compiles the lib without `cfg(test)`, so the corpus is local here.
    #[test]
    fn network_logic_matches_layer0() {
        let corpus = vec![
            json!(null), json!(true), json!(0), json!(-17), json!(1.5), json!(1e10), json!("plain"),
            json!("quote \" and backslash \\"), json!("unicode: héllo 世界"), json!([]), json!({}),
            json!({"b": 1, "a": 2}), json!({"z": [1, {"y": 2, "x": 3}], "a": "s"}),
            json!({"n": null, "arr": [null, 1]}), json!({"nested": {"deep": {"deeper": [true, false]}}}),
        ];
        for value in corpus {
            assert_eq!(canonical_json_str(&value), canonical_json(&value).unwrap(), "divergence at {value}");
        }
    }
}