use std::{env, path::Path, time::Duration, io::{BufRead, BufReader, Write, Read}, net::TcpListener, sync::atomic::Ordering};
use clap::Parser;
use crate::{Commands, Cli, commands::{helpers::EXEC_MUTEX, 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 = std::env::var("CLM_RUST_PORT_FILE").map(std::path::PathBuf::from).unwrap_or_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())?;
let pool = DaemonPool::new(&clm_root, handle_daemon_stream);
println!("[DAEMON] 🚀 Persistent Compiled Core Daemon listening on port {}", bound_port);
let _ = std::io::stdout().flush();
for stream in listener.incoming().flatten() {
let _ = stream.set_nodelay(true);
pool.dispatch(stream, &clm_root);
}
Ok(())
}
fn handle_daemon_stream(mut stream: std::net::TcpStream, clm_root_clone: String) {
{
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
&& 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);
}
}
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 && (9095..=9098).contains(&port)) {
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),
}
}
#[path = "network_logic.rs"]
mod network_logic;
#[allow(unused_imports)]
pub use network_logic::*;