#![allow(unused_imports)]
use super::*;
pub fn evaluate_card_with_context(
ctx: &crate::cross_cutting::context::CLMContext,
sub_card_path: &Path,
) -> Result<i32, String> {
evaluate_card_with_context_dispatch(ctx, sub_card_path).map_err(|e| e.to_string())
}
pub(crate) fn evaluate_card_with_context_dispatch(
ctx: &crate::cross_cutting::context::CLMContext,
sub_card_path: &Path,
) -> Result<i32, super::DispatchError> {
let clm_root = ctx
.project_root()
.map(|p| p.to_path_buf())
.or_else(|| resolve_clm_root().ok())
.unwrap_or_else(|| PathBuf::from("."));
let payload_opt = ctx.get_var(crate::layer0::vocabulary_env::ENV_CLM_PAYLOAD);
let post_rc_opt = ctx
.get_var(crate::layer0::vocabulary_env::ENV_CLM_POST_RC)
.and_then(|v| v.parse::<i32>().ok());
let quiet = ctx
.get_var(crate::layer0::vocabulary_env::ENV_CLM_QUIET)
.map(|v| matches!(v.trim().to_ascii_lowercase().as_str(), "1" | "true"))
.unwrap_or(false);
let _scope_guard = ctx.enter_scope();
run_evaluation_dispatch(
&clm_root,
Some(&sub_card_path.to_string_lossy()),
payload_opt.as_deref(),
post_rc_opt,
quiet,
None,
)
}
pub fn run_evaluation(
clm_root: &Path,
clm_file: Option<&str>,
payload: Option<&str>,
post_rc: Option<i32>,
quiet: bool,
instance_id: Option<&str>,
) -> Result<i32, String> {
run_evaluation_dispatch(clm_root, clm_file, payload, post_rc, quiet, instance_id)
.map_err(|e| e.to_string())
}
pub(crate) fn run_evaluation_dispatch(
clm_root: &Path,
clm_file: Option<&str>,
payload: Option<&str>,
post_rc: Option<i32>,
quiet: bool,
instance_id: Option<&str>,
) -> Result<i32, super::DispatchError> {
if let Ok(mut lock) = crate::cpn::vm::EVAL_CALLBACK.write() {
*lock = Some(run_evaluation);
}
let current_depth = thread_local_depth_get();
if current_depth > 3 {
return Err(format!("Maximum evaluation nesting depth of 3 exceeded (current depth: {})", current_depth).into());
}
let _nested_depth_guard = if current_depth > 0 {
let child_ctx = crate::cross_cutting::context::CLMContext::current().with_nested_exec(true);
Some(child_ctx.enter_scope())
} else {
None
};
verify::verify_integrity(clm_root)?;
cli::compile_evaluator_cache(clm_root, quiet)?;
if let Some(file) = clm_file {
match dispatch::try_internal_dispatch(clm_root, file, payload, post_rc, quiet, crate::layer0::gtime::unix_timestamp_nanos) {
Ok(exit_code) => return Ok(exit_code),
Err(e @ super::DispatchError::SovereignSubprocessForbidden(_)) => return Err(e),
Err(_) => {}
}
}
crate::cross_cutting::context::CLMContext::check_current_process_policy(
&crate::fs_utils::get_bash_command(),
&[clm_file.unwrap_or("clmEval").to_string()],
)?;
let shell_script_raw = cli::extract_bootstrap_script(clm_root)?;
let shell_script = shell_script_raw.replace("\r", "");
let mut remaining_args = Vec::new();
if let Some(file) = clm_file {
remaining_args.push(file.to_string());
}
if let Some(pay) = payload {
remaining_args.push(pay.to_string());
}
if let Some(rc) = post_rc {
remaining_args.push(rc.to_string());
}
let mut daemon_child: Option<Child> = None;
let mut rust_port_file = None;
let mut daemon_port = None;
if crate::cross_cutting::context::CLMContext::get_scoped_or_env(crate::layer0::vocabulary_env::ENV_CLM_RUNTIME_BACKEND).as_deref() == Some("rust")
&& crate::cross_cutting::context::CLMContext::get_scoped_or_env(crate::layer0::vocabulary_env::ENV_CLM_NESTED_EXEC).as_deref() != Some("1")
&& crate::cross_cutting::context::CLMContext::get_scoped_or_env(crate::layer0::vocabulary_env::ENV_CLM_RUST_DAEMON_PORT).is_none()
{
if !quiet {
eprintln!("[clmEval-rs] Waking up Swappable Parity Engine (Rust Core)...");
}
let mut self_exe = env::current_exe().map_err(|e| format!("Failed to get current exe: {}", e))?;
if self_exe.to_string_lossy().contains("deps") {
let alt_exe = clm_root.join({
#[cfg(windows)] { "kernel/clm_rust_core/target/debug/clm_rust_core.exe" }
#[cfg(not(windows))] { "kernel/clm_rust_core/target/debug/clm_rust_core" }
});
if alt_exe.exists() {
self_exe = alt_exe;
} else {
let alt_exe_release = clm_root.join({
#[cfg(windows)] { "kernel/clm_rust_core/target/release/clm_rust_core.exe" }
#[cfg(not(windows))] { "kernel/clm_rust_core/target/release/clm_rust_core" }
});
if alt_exe_release.exists() {
self_exe = alt_exe_release;
}
}
}
let pid = std::process::id();
let unique_id = if let Some(id) = instance_id {
format!("{}_{}", pid, id)
} else {
use std::sync::atomic::{AtomicUsize, Ordering};
static COUNTER: AtomicUsize = AtomicUsize::new(0);
let count = COUNTER.fetch_add(1, Ordering::SeqCst);
format!("{}_{}", pid, count)
};
let port_file_path = clm_root.join(format!("data/ipc/rust_daemon.port.{}", unique_id));
if port_file_path.exists() {
let _ = fs::remove_file(&port_file_path);
}
let _ = fs::create_dir_all(clm_root.join("data/ipc"));
let log_file_path = clm_root.join(format!("data/ipc/rust_daemon.log.{}", unique_id));
let log_file = fs::File::create(&log_file_path)
.map_err(|e| format!("Failed to create daemon log file: {}", e))?;
let mut daemon_cmd = Command::new(self_exe);
daemon_cmd.current_dir(clm_root);
daemon_cmd.arg("daemon")
.arg("--port")
.arg("0")
.env(crate::layer0::vocabulary_env::ENV_CLM_RUST_PORT_FILE, &port_file_path)
.stdout(Stdio::from(log_file.try_clone().unwrap()))
.stderr(Stdio::from(log_file));
daemon_cmd.env_remove(crate::layer0::vocabulary_env::ENV_CLM_MOCK_LLM_BEHAVIOR);
daemon_cmd.env_remove(crate::layer0::vocabulary_env::ENV_CLM_MOCK_OI_BEHAVIOR);
daemon_cmd.env_remove(crate::layer0::vocabulary_env::ENV_CLM_MOCK_COMPILER_BEHAVIOR);
let snap_dir = if let Some(id) = instance_id {
std::env::temp_dir().join(id).to_string_lossy().replace('\\', "/")
} else {
std::env::temp_dir().join(format!("clm_daemon_{}", pid)).to_string_lossy().replace('\\', "/")
};
let _ = fs::remove_dir_all(&snap_dir);
let _ = fs::create_dir_all(&snap_dir);
daemon_cmd.env(crate::layer0::vocabulary_env::ENV_CLM_MEMBROKER_SNAP_DIR, &snap_dir);
let mut child = daemon_cmd.spawn()
.map_err(|e| format!("Failed to spawn daemon process: {}", e))?;
let mut timeout = 20;
while !port_file_path.exists() && timeout > 0 {
std::thread::sleep(std::time::Duration::from_millis(100));
timeout -= 1;
}
if !port_file_path.exists() {
if !quiet {
eprintln!("[clmEval-rs] ⚠️ Daemon failed to start. Falling back to standard CLI mode.");
}
let _ = child.kill();
} else {
let port_str = fs::read_to_string(&port_file_path)
.map_err(|e| format!("Failed to read port file: {}", e))?;
let port = port_str.trim().to_string();
daemon_port = Some(port);
rust_port_file = Some(port_file_path);
daemon_child = Some(child);
}
}
let runner_script_path = {
let temp_dir = crate::layer0::environment::var("TMPDIR").map(std::path::PathBuf::from).unwrap_or_else(|_| std::env::temp_dir());
let _ = fs::create_dir_all(&temp_dir);
let path = temp_dir.join(format!("bootstrap_runner_{}.sh", std::process::id()));
let _ = fs::write(&path, &shell_script);
path
};
let mut cmd = Command::new(crate::fs_utils::get_bash_command());
cmd.current_dir(clm_root);
#[cfg(windows)]
{
let script_arg = runner_script_path.to_string_lossy().replace('\\', "/");
cmd.arg(&script_arg);
}
#[cfg(not(windows))]
{
cmd.arg("-c");
cmd.arg(&shell_script);
cmd.arg("clmEval");
}
for arg in &remaining_args {
cmd.arg(arg);
}
for (key, val) in crate::layer0::environment::vars() {
cmd.env(key, val);
}
if let Some(port) = &daemon_port {
cmd.env(crate::layer0::vocabulary_env::ENV_CLM_RUST_DAEMON_PORT, port);
}
if let Some(port_file) = &rust_port_file {
cmd.env(crate::layer0::vocabulary_env::ENV_CLM_RUST_PORT_FILE, port_file);
}
cmd.env(crate::layer0::vocabulary_env::ENV_CLM_ROOT, clm_root);
if let Some(proj_root) = clm_root.parent() {
cmd.env("PROJECT_ROOT", proj_root);
} else {
cmd.env("PROJECT_ROOT", clm_root);
}
cmd.env("SELF", "clmEval");
if quiet {
cmd.env(crate::layer0::vocabulary_env::ENV_CLM_QUIET, "true");
}
let snap_dir = if let Some(id) = instance_id {
format!("/tmp/{}", id)
} else if let Ok(existing) = crate::layer0::environment::var(crate::layer0::vocabulary_env::ENV_CLM_MEMBROKER_SNAP_DIR) {
existing
} else {
format!("/tmp/clm_daemon_{}", std::process::id())
};
cmd.env(crate::layer0::vocabulary_env::ENV_CLM_MEMBROKER_SNAP_DIR, &snap_dir);
let exit_status = if quiet {
let mut child = cmd
.stdout(Stdio::piped())
.stderr(Stdio::null())
.spawn()
.map_err(|e| format!("Failed to spawn bash: {}", e))?;
let stdout = child.stdout.take().ok_or("Failed to open stdout")?;
let reader = BufReader::new(stdout);
let quiet_filter = regex::Regex::new(
r"^(?:\[clmEval\]|\[VERIFY\]|\[VCARD POST\]|PASS: |\[TYPE_REG\]|\[POST\]|━+$|[[:space:]]*clmEval[[:space:]]+—|[[:space:]]*Evaluating:)"
).unwrap();
for line_res in reader.lines() {
if let Ok(line) = line_res
&& !quiet_filter.is_match(&line) {
println!("{}", line);
}
}
child.wait().map_err(|e| format!("Failed to wait for bash: {}", e))?
} else {
cmd.stdout(Stdio::inherit())
.stderr(Stdio::inherit())
.status()
.map_err(|e| format!("Failed to execute bash: {}", e))?
};
let exit_code = exit_status.code().unwrap_or(1);
let _ = fs::remove_file(&runner_script_path);
if let Some(mut child) = daemon_child {
if let Some(ref port) = daemon_port
&& let Ok(mut stream) = std::net::TcpStream::connect(format!("127.0.0.1:{}", port)) {
let _ = stream.write_all(b"RSTQ\tshutdown\t0\n");
let _ = stream.flush();
}
let _ = child.kill();
let _ = child.wait();
if let Some(ref path) = rust_port_file {
let _ = fs::remove_file(path);
}
let pid = std::process::id();
let log_file_path = clm_root.join(format!("data/ipc/rust_daemon.log.{}", pid));
let _ = fs::remove_file(&log_file_path);
let snap_dir = if let Some(id) = instance_id {
format!("/tmp/{}", id)
} else {
format!("/tmp/clm_daemon_{}", pid)
};
let _ = fs::remove_dir_all(&snap_dir);
}
Ok(exit_code)
}