use std::env;
use std::path::Path;
use std::time::Duration;
use std::io::{BufRead, BufReader, Write, Read};
use std::net::TcpListener;
use std::sync::atomic::Ordering;
use clap::Parser;
use crate::{Commands, Cli};
use crate::commands::helpers::EXEC_MUTEX;
use crate::commands::run_command_logic;
use clm_rust_core::{db, discovery_engine, network_gateway};
pub fn run_daemon(clm_root: String, port_opt: u16) -> std::io::Result<()> {
clm_rust_core::utils::set_env_var("CLM_NESTED_EXEC", "1");
let listener = TcpListener::bind(format!("127.0.0.1:{}", port_opt))?;
let bound_port = listener.local_addr()?.port();
let port_dir = Path::new(&clm_root).join("data/ipc");
std::fs::create_dir_all(&port_dir)?;
let port_file = if let Ok(custom_path) = std::env::var("CLM_RUST_PORT_FILE") {
std::path::PathBuf::from(custom_path)
} else if port_opt == 0 {
port_dir.join("rust_daemon.port")
} else {
port_dir.join(format!("rust_daemon.port.{}", bound_port))
};
std::fs::write(&port_file, bound_port.to_string())?;
println!("[DAEMON] 🚀 Persistent Compiled Core Daemon listening on port {}", bound_port);
for stream_res in listener.incoming() {
let mut stream = match stream_res {
Ok(s) => s,
Err(_) => continue,
};
let clm_root_clone = clm_root.clone();
std::thread::spawn(move || {
let mut reader = BufReader::new(&stream);
let mut header_line = String::new();
if reader.read_line(&mut header_line).is_err() {
return;
}
let mut next_line = header_line;
let mut trimmed = next_line.trim_end();
let mut parts: Vec<&str> = trimmed.split('\t').collect();
let mut env_vars = Vec::new();
if !parts.is_empty() && parts[0] == "ENV" {
for pair in parts.iter().skip(1) {
if let Some(pos) = pair.find('=') {
let key = &pair[..pos];
let val = &pair[pos+1..];
let mut unescaped = String::new();
let mut chars = val.chars().peekable();
while let Some(c) = chars.next() {
if c == '\\' {
match chars.peek() {
Some(&'n') => { unescaped.push('\n'); chars.next(); }
Some(&'r') => { unescaped.push('\r'); chars.next(); }
Some(&'t') => { unescaped.push('\t'); chars.next(); }
Some(&'\\') => { unescaped.push('\\'); chars.next(); }
Some(&other) => { unescaped.push(other); chars.next(); }
None => { unescaped.push('\\'); }
}
} else {
unescaped.push(c);
}
}
env_vars.push((key.to_string(), unescaped));
}
}
next_line = String::new();
if reader.read_line(&mut next_line).is_err() {
return;
}
trimmed = next_line.trim_end();
parts = trimmed.split('\t').collect();
}
if parts.is_empty() || parts[0] != "RSTQ" {
if trimmed.starts_with('{') && (trimmed.contains("\"satori.v1\"") || trimmed.contains("\"command\"")) {
handle_satori_stream(&stream, &mut reader, trimmed);
return;
}
let _ = stream.write_all(b"RSTR\t1\t0\t24\nInvalid request protocol");
return;
}
let command = parts[1];
let argc: usize = parts[2].parse().unwrap_or(0);
let mut lens = Vec::new();
for i in 0..argc {
if 3 + i < parts.len() {
let len: usize = parts[3 + i].parse().unwrap_or(0);
lens.push(len);
}
}
let mut args = Vec::new();
for len in lens {
let mut buf = vec![0; len];
if reader.read_exact(&mut buf).is_err() {
let _ = stream.write_all(b"RSTR\t1\t0\t24\nFailed to read arguments");
return;
}
let arg = String::from_utf8_lossy(&buf).into_owned();
args.push(arg);
}
eprintln!("[DAEMON IPC] Received command: {} with args: {:?}", command, args);
if command == "shutdown" {
let _ = stream.write_all(b"RSTR\t0\t19\t0\nShutdown initiated\n");
std::process::exit(0);
}
let mut full_args = vec!["clm_rust_core".to_string(), command.to_string()];
full_args.extend(args);
let (exit_code, out, err) = {
let _lock = EXEC_MUTEX.lock().unwrap();
let clm_keys: Vec<String> = std::env::vars()
.map(|(k, _)| k)
.filter(|k| k.starts_with("CLM_") && k != "CLM_NESTED_EXEC")
.collect();
for key in clm_keys {
clm_rust_core::utils::remove_env_var(&key);
}
let mut total_env_len = 0;
for (key, val) in &env_vars {
total_env_len += key.len() + val.len();
clm_rust_core::utils::set_env_var(key, val);
}
eprintln!("[DAEMON] env_vars count: {}, total len: {}", env_vars.len(), total_env_len);
let count = clm_rust_core::TEMP_COUNTER.fetch_add(1, Ordering::SeqCst);
let temp_dir = std::env::temp_dir();
let temp_stdout_path = temp_dir.join(format!("clm_rust_stdout_{}.tmp", count));
let temp_stderr_path = temp_dir.join(format!("clm_rust_stderr_{}.tmp", count));
let mut guard_out = None;
let mut guard_err = None;
let mut fd_out = -1;
let mut fd_err = -1;
if let (Ok(file_out), Ok(file_err)) = (
std::fs::File::create(&temp_stdout_path),
std::fs::File::create(&temp_stderr_path),
) {
fd_out = clm_rust_core::sys_ffi::get_file_fd(&file_out);
fd_err = clm_rust_core::sys_ffi::get_file_fd(&file_err);
if fd_out >= 0 && fd_err >= 0 {
if let (Ok(g_out), Ok(g_err)) = (
clm_rust_core::sys_ffi::FdRedirectGuard::redirect_stdout_to(fd_out),
clm_rust_core::sys_ffi::FdRedirectGuard::redirect_stderr_to(fd_err),
) {
guard_out = Some(g_out);
guard_err = Some(g_err);
}
}
}
let active_clm_root_raw = std::env::var("CLM_ROOT").unwrap_or_else(|_| clm_root_clone.clone());
let active_clm_root = clm_rust_core::fs_utils::normalize_windows_path(Path::new(&active_clm_root_raw))
.to_string_lossy()
.into_owned();
let (code, logic_out, logic_err) = match Cli::try_parse_from(full_args) {
Ok(parsed_cli) => {
run_command_logic(parsed_cli.command, &active_clm_root)
}
Err(e) => {
(1, String::new(), e.to_string())
}
};
let mut captured_stdout = String::new();
let mut captured_stderr = String::new();
if guard_out.is_some() && guard_err.is_some() {
drop(guard_out);
drop(guard_err);
if fd_out >= 0 { unsafe { clm_rust_core::sys_ffi::sys_close(fd_out); } }
if fd_err >= 0 { unsafe { clm_rust_core::sys_ffi::sys_close(fd_err); } }
if let Ok(c_out) = std::fs::read_to_string(&temp_stdout_path) {
captured_stdout = c_out;
}
if let Ok(c_err) = std::fs::read_to_string(&temp_stderr_path) {
captured_stderr = c_err;
}
let _ = std::fs::remove_file(&temp_stdout_path);
let _ = std::fs::remove_file(&temp_stderr_path);
} else {
if fd_out >= 0 { unsafe { clm_rust_core::sys_ffi::sys_close(fd_out); } }
if fd_err >= 0 { unsafe { clm_rust_core::sys_ffi::sys_close(fd_err); } }
}
let combined_out = format!("{}{}", captured_stdout, logic_out);
let combined_err = format!("{}{}", captured_stderr, logic_err);
(code, combined_out, combined_err)
};
let resp_header = format!("RSTR\t{}\t{}\t{}\n", exit_code, out.len(), err.len());
let mut payload = Vec::new();
payload.extend(resp_header.as_bytes());
payload.extend(out.as_bytes());
payload.extend(err.as_bytes());
let _ = stream.write_all(&payload);
});
}
Ok(())
}
pub fn run_network_cli(command: Commands, clm_root: &str) {
match command {
Commands::Daemon { port } => {
if let Err(e) = run_daemon(clm_root.to_string(), port) {
eprintln!("[DAEMON] ❌ Failed to start daemon: {}", e);
std::process::exit(1);
}
}
Commands::MdnsDiscovery { mode, port, name, did, db: _db } => {
let resolved_port = port.unwrap_or_else(|| {
env::var("CLM_PORT")
.ok()
.and_then(|p| p.parse().ok())
.unwrap_or(9095)
});
let resolved_name = name.unwrap_or_else(|| {
env::var("CLM_NODE_NAME")
.unwrap_or_else(|_| {
let host = env::var("HOSTNAME").unwrap_or_else(|_| "localnode".to_string());
format!("pkc-{}", host)
})
});
let resolved_did = did.unwrap_or_else(|| {
env::var("CLM_NODE_DID")
.unwrap_or_else(|_| "did:pkc:local:unknown".to_string())
});
let engine = discovery_engine::DiscoveryEngine::new();
if mode == "announce" {
if let Err(e) = engine.announce(&resolved_name, &resolved_did, resolved_port) {
eprintln!("[mDNS PKC] Announcer error: {}", e);
std::process::exit(1);
}
} else if mode == "discover" {
match engine.discover(Duration::from_secs(5)) {
Ok(peers) => {
println!("\n[mDNS PKC] ===========================================");
println!("[mDNS PKC] Discovered {} PKC peer(s):", peers.len());
println!("[mDNS PKC] ===========================================");
for (index, peer) in peers.iter().enumerate() {
println!("[mDNS PKC] {}. {}", index + 1, peer.name);
println!("[mDNS PKC] Address: {}:{}", peer.ip, peer.port);
println!("[mDNS PKC] DID: {}", peer.did);
println!("[mDNS PKC] Capabilities: {}", peer.capabilities.join(", "));
}
println!("[mDNS PKC] ===========================================\n");
println!("{}", serde_json::to_string_pretty(&serde_json::json!({ "peers": peers })).unwrap());
std::process::exit(0);
}
Err(e) => {
eprintln!("[mDNS PKC] Discovery error: {}", e);
std::process::exit(1);
}
}
} else {
let name_clone = resolved_name.clone();
let did_clone = resolved_did.clone();
std::thread::spawn(move || {
let engine = discovery_engine::DiscoveryEngine::new();
let _ = engine.announce(&name_clone, &did_clone, resolved_port);
});
println!("[mDNS PKC] Service running. Press Ctrl+C to stop.");
loop {
std::thread::sleep(Duration::from_secs(10));
}
}
}
Commands::DiscoveryNode { port, db } => {
let resolved_port = port.unwrap_or_else(|| {
env::var("CLM_PORT")
.ok()
.and_then(|p| p.parse().ok())
.unwrap_or(9095)
});
let resolved_db = db.unwrap_or_else(|| {
env::var("CLM_IDENTITY_DB")
.unwrap_or_else(|_| db::get_db_path("agent_identities", &clm_root).to_string_lossy().into_owned())
});
if let Err(e) = discovery_engine::run_discovery_node(resolved_port, &resolved_db) {
eprintln!("[P2P NODE] ❌ Server failed: {}", e);
std::process::exit(1);
}
}
Commands::Discover { handshake, did, key, test } => {
let rt = tokio::runtime::Runtime::new().unwrap();
rt.block_on(async {
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 {
eprintln!("Invalid handshake target. Must be ip:port");
std::process::exit(1);
}
let ip = parts[0];
let port: u16 = parts[1].parse().unwrap_or(0);
match discovery_engine::perform_handshake(ip, port, &resolved_did, &resolved_key) {
Ok(res) => {
println!("{}", serde_json::to_string_pretty(&res).unwrap());
if res.get("status").and_then(|s| s.as_str()) == Some("authorized") {
std::process::exit(0);
} else {
std::process::exit(1);
}
}
Err(e) => {
eprintln!("{}", serde_json::to_string_pretty(&serde_json::json!({
"status": "error",
"reason": e
})).unwrap());
std::process::exit(1);
}
}
} else {
let test_mode = test || env::var("CLM_DISCOVER_TEST").unwrap_or_default() == "true";
let allow_subnet = env::var("CLM_DISCOVER_ALLOW_SUBNET").unwrap_or_default() == "true";
let local_ip = discovery_engine::DiscoveryEngine::get_local_ip();
let mut targets = vec!["127.0.0.1".to_string()];
if !test_mode && allow_subnet && local_ip != "127.0.0.1" {
eprintln!(
"[discover] ⚠️ CLM_DISCOVER_ALLOW_SUBNET=true — scanning full /24 subnet from {}. \
This may trigger network IDS/IPS quarantine.",
local_ip
);
let parts: Vec<&str> = local_ip.split('.').collect();
if parts.len() == 4 {
let prefix = format!("{}.{}.{}", parts[0], parts[1], parts[2]);
for i in 1..=254 {
let target_ip = format!("{}.{}", prefix, i);
if target_ip != local_ip {
targets.push(target_ip);
}
}
}
} else if !test_mode && !allow_subnet {
eprintln!(
"[discover] Loopback-only discovery (safe default). \
Set CLM_DISCOVER_ALLOW_SUBNET=true to scan the local subnet."
);
}
let ports = if test_mode {
(9090..=9100).collect::<Vec<u16>>()
} else {
vec![9095, 9096, 9000, 5001, 9090]
};
async fn probe_target(ip: String, port: u16, timeout: Duration) -> Option<(String, u16)> {
match tokio::time::timeout(timeout, tokio::net::TcpStream::connect(format!("{}:{}", ip, port))).await {
Ok(Ok(_)) => Some((ip, port)),
_ => None,
}
}
let mut tasks = Vec::new();
for ip in targets {
for port in &ports {
let ip_clone = ip.clone();
let p = *port;
tasks.push(tokio::spawn(async move {
probe_target(ip_clone, p, Duration::from_millis(250)).await
}));
}
}
let mut open_ports = Vec::new();
for task in tasks {
if let Ok(Some(res)) = task.await {
open_ports.push(res);
}
}
let mut discovered_nodes = Vec::new();
let mut s3_services = Vec::new();
let mut ipfs_services = Vec::new();
let mut webrtc_services = Vec::new();
for (ip, port) in open_ports {
if port == 9095 || port == 9096 || (test_mode && port >= 9095 && port <= 9098) {
discovered_nodes.push(serde_json::json!({ "ip": ip, "port": port }));
} else if port == 9000 {
s3_services.push(serde_json::json!({ "ip": ip, "port": port, "type": "minio" }));
} else if port == 5001 {
ipfs_services.push(serde_json::json!({ "ip": ip, "port": port, "type": "ipfs" }));
} else if port == 9090 {
webrtc_services.push(serde_json::json!({ "ip": ip, "port": port, "type": "relay" }));
}
}
let res = serde_json::json!({
"timestamp": chrono::Utc::now().to_rfc3339_opts(chrono::SecondsFormat::Millis, true),
"nodes": discovered_nodes,
"services": {
"s3": s3_services,
"ipfs": ipfs_services,
"webrtc": webrtc_services,
}
});
println!("{}", serde_json::to_string_pretty(&res).unwrap());
std::process::exit(0);
}
});
}
Commands::ChatGateway { port, timeout } => {
let rt = tokio::runtime::Runtime::new().unwrap();
rt.block_on(async {
let mut gateway = network_gateway::NetworkGateway::new();
if let Some(p) = port {
gateway.port = p;
}
if let Some(t) = timeout {
gateway.timeout = t;
}
if let Err(e) = gateway.start().await {
eprintln!("[GATEWAY] ❌ Failed to start gateway: {}", e);
std::process::exit(1);
}
});
std::process::exit(0);
}
_ => std::process::exit(0),
}
}
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()),
}
}
static RUST_NODE_IDENTITY: std::sync::OnceLock<clm_rust_core::mesh::noise::SovereignNodeIdentity> = std::sync::OnceLock::new();
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)
}
fn canonical_json_str(val: &serde_json::Value) -> String {
match val {
serde_json::Value::Object(map) => {
let mut sorted: std::collections::BTreeMap<&str, &serde_json::Value> = std::collections::BTreeMap::new();
for (k, v) in map {
sorted.insert(k.as_str(), v);
}
let mut s = String::from("{");
for (i, (k, v)) in sorted.iter().enumerate() {
if i > 0 { s.push(','); }
s.push_str(&serde_json::to_string(k).unwrap_or_default());
s.push(':');
s.push_str(&canonical_json_str(v));
}
s.push('}');
s
}
serde_json::Value::Array(arr) => {
let mut s = String::from("[");
for (i, v) in arr.iter().enumerate() {
if i > 0 { s.push(','); }
s.push_str(&canonical_json_str(v));
}
s.push(']');
s
}
other => serde_json::to_string(other).unwrap_or_default(),
}
}
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 sender_did.starts_with("did:clm:key:") {
let pub_hex = &sender_did["did:clm:key:".len()..];
if let (Ok(pub_bytes), Ok(sig_bytes)) = (hex::decode(pub_hex), hex::decode(signature)) {
if 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())
}
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() {
if 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();
}
}