#![allow(unused_imports)]
use clm_rust_core::layer0::vocabulary_identities::{DID_CLM_KEY};
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) struct DaemonPool {
tx: std::sync::mpsc::Sender<std::net::TcpStream>,
idle: std::sync::Arc<std::sync::atomic::AtomicUsize>,
handler: fn(std::net::TcpStream, String),
}
impl DaemonPool {
pub(super) fn new(clm_root: &str, handler: fn(std::net::TcpStream, String)) -> Self {
let (tx, rx) = std::sync::mpsc::channel::<std::net::TcpStream>();
let rx = std::sync::Arc::new(std::sync::Mutex::new(rx));
let idle = std::sync::Arc::new(std::sync::atomic::AtomicUsize::new(4));
for _ in 0..4 {
let rx_w = std::sync::Arc::clone(&rx);
let idle_w = std::sync::Arc::clone(&idle);
let root_w = clm_root.to_string();
std::thread::spawn(move || {
loop {
let recv_res = rx_w.lock().unwrap().recv();
let Ok(stream) = recv_res else {
break;
};
idle_w.fetch_sub(1, Ordering::AcqRel);
handler(stream, root_w.clone());
idle_w.fetch_add(1, Ordering::AcqRel);
}
});
}
Self { tx, idle, handler }
}
pub(super) fn dispatch(&self, stream: std::net::TcpStream, clm_root: &str) {
let handler = self.handler;
if self.idle.load(Ordering::Acquire) == 0 {
let root = clm_root.to_string();
std::thread::spawn(move || handler(stream, root));
} else if let Err(err) = self.tx.send(stream) {
let root = clm_root.to_string();
std::thread::spawn(move || handler(err.0, root));
}
}
}
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 {
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("");
let expected_hash = blake3::hash(canonical_json_str(&payload).as_bytes()).to_hex().to_string();
let hash_matched = expected_hash == payload_hash;
let mut sig_valid = false;
if let Some(pub_hex) = sender_did.strip_prefix(clm_rust_core::layer0::vocabulary_identities::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;
#[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}");
}
}
}