use std::collections::HashMap;
use std::path::{Path, PathBuf};
use serde_json::Value;
use crate::memorize;
use crate::yaml;
use crate::db;
#[cfg(unix)]
#[repr(C)]
#[derive(Clone, Copy)]
pub struct timeval {
pub tv_sec: i64,
pub tv_usec: i32,
#[cfg(target_os = "macos")]
pub _padding: i32,
}
#[cfg(unix)]
#[repr(C)]
pub struct rusage {
pub ru_utime: timeval,
pub ru_stime: timeval,
pub ru_maxrss: i64,
pub ru_ixrss: i64,
pub ru_idrss: i64,
pub ru_isrss: i64,
pub ru_minflt: i64,
pub ru_majflt: i64,
pub ru_nswap: i64,
pub ru_inblock: i64,
pub ru_oublock: i64,
pub ru_msgsnd: i64,
pub ru_msgrcv: i64,
pub ru_nsignals: i64,
pub ru_nvcsw: i64,
pub ru_nivcsw: i64,
}
#[cfg(unix)]
const RUSAGE_SELF: i32 = 0;
#[cfg(unix)]
const RUSAGE_CHILDREN: i32 = -1;
#[cfg(unix)]
#[allow(dead_code)]
unsafe extern "C" {
fn dup(fd: i32) -> i32;
fn dup2(src: i32, dst: i32) -> i32;
fn close(fd: i32) -> i32;
fn getrusage(who: i32, usage: *mut rusage) -> i32;
}
#[cfg(unix)]
pub fn get_peak_rss_kb() -> i64 {
let mut usage = unsafe { std::mem::zeroed::<rusage>() };
let res = unsafe { getrusage(RUSAGE_SELF, &mut usage) };
if res == 0 {
#[cfg(target_os = "macos")]
{
usage.ru_maxrss / 1024
}
#[cfg(not(target_os = "macos"))]
{
usage.ru_maxrss
}
} else {
0
}
}
#[cfg(unix)]
pub fn get_children_peak_rss_kb() -> i64 {
let mut usage = unsafe { std::mem::zeroed::<rusage>() };
let res = unsafe { getrusage(RUSAGE_CHILDREN, &mut usage) };
if res == 0 {
#[cfg(target_os = "macos")]
{
usage.ru_maxrss / 1024
}
#[cfg(not(target_os = "macos"))]
{
usage.ru_maxrss
}
} else {
0
}
}
#[cfg(windows)]
#[repr(C)]
#[allow(non_snake_case)]
struct PROCESS_MEMORY_COUNTERS {
cb: u32,
PageFaultCount: u32,
PeakWorkingSetSize: usize,
WorkingSetSize: usize,
QuotaPeakPagedPoolUsage: usize,
QuotaPagedPoolUsage: usize,
QuotaPeakNonPagedPoolUsage: usize,
QuotaNonPagedPoolUsage: usize,
PagefileUsage: usize,
PeakPagefileUsage: usize,
}
#[cfg(windows)]
#[link(name = "psapi")]
unsafe extern "system" {
fn GetCurrentProcess() -> *mut std::ffi::c_void;
fn GetProcessMemoryInfo(
process: *mut std::ffi::c_void,
counters: *mut PROCESS_MEMORY_COUNTERS,
cb: u32,
) -> i32;
}
#[cfg(windows)]
pub fn get_peak_rss_kb() -> i64 {
let mut counters = unsafe { std::mem::zeroed::<PROCESS_MEMORY_COUNTERS>() };
counters.cb = std::mem::size_of::<PROCESS_MEMORY_COUNTERS>() as u32;
let res = unsafe { GetProcessMemoryInfo(GetCurrentProcess(), &mut counters, counters.cb) };
if res != 0 {
(counters.PeakWorkingSetSize / 1024) as i64
} else {
0
}
}
#[cfg(windows)]
pub fn get_children_peak_rss_kb() -> i64 {
get_peak_rss_kb()
}
pub fn resolve_python_cmd(clm_root: &str) -> String {
let root_path = std::path::Path::new(clm_root);
let venv_py_win = root_path.join(".venv/Scripts/python.exe");
if venv_py_win.exists() {
return venv_py_win.to_string_lossy().to_string();
}
let venv_py_unix = root_path.join(".venv/bin/python3");
if venv_py_unix.exists() {
return venv_py_unix.to_string_lossy().to_string();
}
let venv_py_unix_2 = root_path.join(".venv/bin/python");
if venv_py_unix_2.exists() {
return venv_py_unix_2.to_string_lossy().to_string();
}
if cfg!(target_os = "windows") {
for cmd in &["python", "python3"] {
if std::process::Command::new(cmd).arg("--version").output().map(|o| o.status.success()).unwrap_or(false) {
return cmd.to_string();
}
}
} else {
for cmd in &["python3", "python"] {
if std::process::Command::new(cmd).arg("--version").output().map(|o| o.status.success()).unwrap_or(false) {
return cmd.to_string();
}
}
}
if cfg!(target_os = "windows") {
"python".to_string()
} else {
"python3".to_string()
}
}
pub fn get_interpreter_version(interpreter: &str, clm_root: &str) -> Option<String> {
let cmd_name = match interpreter {
"python" | "python3" => resolve_python_cmd(clm_root),
other => other.to_string(),
};
let output = std::process::Command::new(&cmd_name)
.arg("--version")
.output()
.ok();
if let Some(out) = output {
let text = String::from_utf8_lossy(&out.stdout).to_string()
+ String::from_utf8_lossy(&out.stderr).as_ref();
let re = regex::Regex::new(r"(\d+\.\d+(?:\.\d+)?)").unwrap();
if let Some(caps) = re.captures(&text) {
return Some(caps[1].to_string());
}
}
None
}
pub fn compare_versions(current: &str, op: &str, req: &str) -> bool {
let parse_ver = |s: &str| -> (u32, u32, u32) {
let parts: Vec<&str> = s.split('.').collect();
let major = parts.first().and_then(|v| v.parse().ok()).unwrap_or(0);
let minor = parts.get(1).and_then(|v| v.parse().ok()).unwrap_or(0);
let patch = parts.get(2).and_then(|v| v.parse().ok()).unwrap_or(0);
(major, minor, patch)
};
let v1 = parse_ver(current);
let v2 = parse_ver(req);
match op {
">=" => v1 >= v2,
"<=" => v1 <= v2,
">" => v1 > v2,
"<" => v1 < v2,
_ => v1 == v2,
}
}
pub fn check_precondition(req_str: &str, clm_root: &str) -> bool {
let re = regex::Regex::new(r"^interpreter:([a-zA-Z0-9_-]+)(>=|<=|>|<|==|=)([0-9.]+)$").unwrap();
if let Some(caps) = re.captures(req_str) {
let interpreter = &caps[1];
let op = &caps[2];
let req_ver = &caps[3];
if let Some(current_ver) = get_interpreter_version(interpreter, clm_root) {
compare_versions(¤t_ver, op, req_ver)
} else {
false
}
} else {
true
}
}
pub fn create_sandboxed_command(
program: &str,
args: &[String],
envs: &HashMap<String, String>,
clm_root: &str,
) -> std::process::Command {
let clm_no_sandbox = std::env::var("CLM_NO_SANDBOX").unwrap_or_default() == "true";
let has_sandbox_exec = std::process::Command::new("which")
.arg("sandbox-exec")
.output()
.map(|o| o.status.success())
.unwrap_or(false);
let mut cmd = if !clm_no_sandbox && has_sandbox_exec {
let home_dir = std::env::var("HOME").unwrap_or_default();
let profile = format!(
r#"(version 1)
(deny default)
(allow file-read-metadata)
(allow file-read-data)
(allow file-write-data)
(allow file-read*
(subpath "/usr")
(subpath "/System")
(subpath "/Library")
(subpath "/private")
(subpath "/var")
(subpath "/tmp")
(subpath "/etc")
(subpath "/opt")
(subpath "/dev")
(subpath "{}")
(subpath "{}"))
(allow file-write*
(subpath "{}/data")
(subpath "{}/db")
(subpath "{}/types/meta")
(literal "{}/result_open_interpreter.txt")
(subpath "{}/.clm")
(subpath "/private/var")
(subpath "/private/tmp")
(subpath "/var")
(subpath "/tmp")
(literal "/dev/null")
(literal "/dev/zero"))
(allow file-map-executable
(subpath "/usr")
(subpath "/System")
(subpath "/Library")
(subpath "/opt")
(subpath "{}")
(subpath "{}"))
(allow process-exec
(subpath "/bin")
(subpath "/usr/bin")
(subpath "/usr/local/bin")
(subpath "/opt/homebrew")
(subpath "/Library/Frameworks/Python.framework")
(subpath "/Library/Developer/CommandLineTools")
(subpath "/private/var")
(subpath "/var")
(subpath "/tmp")
(subpath "{}")
(subpath "{}"))
(allow process-fork)
(allow process-info*)
(allow ipc-posix*)
(allow sysctl-read)
(allow mach-lookup)
(allow dynamic-code-generation)
(allow network-bind)
(allow network-inbound)
(allow network-outbound)
(deny file-read*
(literal "/private/etc/passwd")
(literal "/etc/passwd"))
(deny file-read-data
(literal "/private/etc/passwd")
(literal "/etc/passwd"))"#,
clm_root, home_dir, clm_root, clm_root, clm_root, clm_root, home_dir, clm_root, home_dir, clm_root, home_dir
);
let mut c = std::process::Command::new("sandbox-exec");
c.arg("-p").arg(profile).arg(program);
c
} else {
std::process::Command::new(program)
};
cmd.env_clear();
for (k, v) in std::env::vars() {
if !k.starts_with("CLM_") {
cmd.env(k, v);
}
}
let clm_whitelist = [
"CLM_NESTED_EXEC", "CLM_RUST_DAEMON_PORT", "CLM_RUNTIME_BACKEND",
"CLM_POLYGLOT_RUNTIME", "CLM_RUN_ID", "CLM_ZERO_FS", "CLM_PETRI_MARKING_DIR", "CLM_EVENT_LOG_PATH",
"CLM_ROOT", "PROJECT_ROOT", "CLM_TARGET_FILE", "CLM_PAYLOAD_FILE",
"CLM_ACTIVE_A_HASH", "CLM_ACTIVE_C_HASH", "CLM_MLP_CONTEXT", "CLM_PAYLOAD",
"CLM_SESSION_DELEGATION", "CLM_KENOTIC_SPONSOR_DID", "CLM_EXECUTION_LOCALE_HASH",
"CLM_TRANSPORT_REF", "CLM_PETRI_KENOTIC", "CLM_REPL_TRACE", "CLM_NO_SANDBOX",
"CLM_SYMBOL_HANDLES", "CLM_DB_BACKEND", "CLM_MEMBROKER_PORT", "CLM_MEMBROKER_NO_DISK",
"CLM_MEMBROKER_SNAP_DIR", "CLM_SCRATCH", "CLM_TEST_FAST_BOOT", "CLM_SKIP_GRAMMAR",
"CLM_PETRI_HALT", "CLM_PETRI_VISUAL", "CLM_QUIET",
"CLM_NATIVE_PETRI_VM", "CLM_DISPATCH_SOCK", "CLM_SCRIPT_CONTENT",
"CLM_ENTRY_POINT", "CLM_FILE", "CLM_RUST_PORT_FILE",
"CLM_ACTIVE_B_HASH", "CLM_SKIP_CONDITIONS", "ACTIVE_AGENT_DID",
"CLM_TARGET_PATH", "CLM_AGENT_CLASS", "CLM_AGENT_ROLE",
"CLM_RISK_LEVEL", "CLM_EOA_APPROVAL", "CLM_AGENT_DID",
"CLM_ACTIVE_FILE", "CLM_LAST_MCARD_HASH", "CLM_LAST_MCARD_FILE"
];
for var_name in &clm_whitelist {
if let Ok(val) = std::env::var(var_name) {
cmd.env(var_name, val);
}
}
for (k, v) in envs {
cmd.env(k, v);
}
for a in args {
cmd.arg(a);
}
cmd
}
pub fn normalize_output(raw_out: &str) -> String {
use serde_json::Value;
let stripped = raw_out.replace('\r', "");
let stripped = stripped.trim_end().to_string();
if let Ok(val) = serde_json::from_str::<Value>(&stripped) {
serde_json::to_string(&val).unwrap_or(stripped)
} else {
stripped
}
}
pub fn print_diff(first_norm: &str, second_norm: &str) {
let temp_dir = std::env::temp_dir().join("clm_execution_logs/.tmp");
let f1 = temp_dir.join(format!("norm_f1_{}", std::process::id()));
let f2 = temp_dir.join(format!("norm_f2_{}", std::process::id()));
let _ = std::fs::write(&f1, first_norm);
let _ = std::fs::write(&f2, second_norm);
let diff_output = std::process::Command::new("diff")
.arg("-u")
.arg(&f1)
.arg(&f2)
.output();
if let Ok(out) = diff_output {
let text = String::from_utf8_lossy(&out.stdout);
eprintln!("{}", text);
}
let _ = std::fs::remove_file(f1);
let _ = std::fs::remove_file(f2);
}
pub fn resolve_self_exe(clm_root: &str) -> PathBuf {
if let Ok(self_exe) = std::env::current_exe() {
if self_exe.to_string_lossy().contains("deps") {
let alt_exe = Path::new(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() {
return alt_exe;
}
let alt_exe_release = Path::new(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() {
return alt_exe_release;
}
}
if let Some(parent) = self_exe.parent() {
let local_exe = parent.join({
#[cfg(windows)] { "clm_rust_core.exe" }
#[cfg(not(windows))] { "clm_rust_core" }
});
if local_exe.exists() {
return local_exe;
}
}
return self_exe;
}
Path::new(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" }
})
}
pub fn exec_polyglot(
file_path: &str,
payload: Option<&str>,
clm_root: &str,
) -> std::result::Result<(i32, String), String> {
let payload = payload.filter(|s| !s.is_empty());
memorize::check_and_register_file_mcard(file_path, clm_root)?;
let json_str = yaml::parse_to_mcards(file_path).map_err(|e| e.to_string())?;
let parsed: Value = serde_json::from_str(&json_str)
.map_err(|e| format!("Failed to parse JSON AST: {}", e))?;
let polyglot_cases = yaml::evaluate_jq(&parsed, ".clm.balanced_exp.polyglot_cases");
let cases_arr = match polyglot_cases {
Value::Array(arr) => arr,
_ => return Err("No polyglot_cases found".to_string()),
};
let mut target_cases = Vec::new();
if let Some(p) = payload {
let mut found = false;
for c in cases_arr.iter() {
if let Some(name) = c.get("name").and_then(|v| v.as_str())
&& name == p {
target_cases.push(c.clone());
found = true;
break;
}
}
if !found {
return Err(format!("Case matching payload '{}' not found", p));
}
} else {
for c in cases_arr.iter() {
target_cases.push(c.clone());
}
}
if target_cases.is_empty() {
return Err("No cases to execute".to_string());
}
let target_runtime = std::env::var("CLM_POLYGLOT_RUNTIME").ok();
if let Some(target) = &target_runtime {
eprintln!("[PAL:polyglot] Active runtime choice: {}", target);
}
let active_a_hash = std::env::var("CLM_ACTIVE_A_HASH").unwrap_or_default();
let active_c_hash = std::env::var("CLM_ACTIVE_C_HASH").unwrap_or_default();
let mut last_case_output = String::new();
let mut consensus_exit_code = 0;
for case in &target_cases {
let case_name = case.get("name").and_then(|v| v.as_str()).unwrap_or("unnamed_case");
let given = case.get("given").ok_or_else(|| format!("No given block found in case '{}'", case_name))?;
let runtimes = match given.get("runtimes") {
Some(Value::Array(arr)) => arr.iter().filter_map(|v| v.as_str()).map(|s| s.to_string()).collect::<Vec<String>>(),
_ => return Err(format!("No runtimes found in given block of case '{}'", case_name)),
};
let active_runtimes = if let Some(target) = &target_runtime {
vec![target.clone()]
} else {
runtimes.clone()
};
let mut inputs = serde_json::Map::new();
let mut env_vars = std::collections::HashMap::new();
let mut pos_args = Vec::new();
if let Value::Object(map) = given {
for (k, v) in map {
if k != "runtimes" && k != "requires" {
inputs.insert(k.clone(), v.clone());
let val_str = match v {
Value::String(s) => s.clone(),
other => other.to_string(),
};
env_vars.insert(k.clone(), val_str.clone());
pos_args.push(val_str);
}
}
}
for (k, v) in crate::utils::collect_clm_mock_vars() {
env_vars.insert(k, v);
}
let then = case.get("then").ok_or_else(|| format!("No then block found in case '{}'", case_name))?;
let internal_ref = then.get("internal_reference").and_then(|v| v.as_str());
let native_harness = then.get("native_harness");
if internal_ref.is_some() && native_harness.is_some() {
return Err(format!("Schema validation failed in case '{}': internal_reference and native_harness are mutually exclusive", case_name));
}
let sla = then.get("performance_sla");
let max_duration_ms = sla.and_then(|s| s.get("max_duration_ms")).and_then(|v| v.as_i64());
let max_rss_kb = sla.and_then(|s| s.get("max_rss_kb")).and_then(|v| v.as_i64());
let max_forks = sla.and_then(|s| s.get("max_forks")).and_then(|v| v.as_i64());
if internal_ref.is_some()
&& let Some(mf) = max_forks
&& mf != 0 {
return Err(format!("Schema validation failed in case '{}': max_forks must be 0 for internal_reference cases", case_name));
}
let mut executed_runtimes = Vec::new();
let mut runtime_outputs = Vec::new();
let mut runtime_exit_codes = Vec::new();
let mut runtime_exec_hashes = Vec::new();
for runtime in &active_runtimes {
if !runtimes.contains(runtime) {
eprintln!("[PAL:polyglot] ⏭️ Target runtime '{}' not requested in Gherkin cover: {:?}", runtime, runtimes);
continue;
}
if runtime != "shell" && runtime != "python" && runtime != "node" && runtime != "rust" {
if target_runtime.is_some() {
return Err(format!("Target runtime '{}' is not supported in Sprint 97", runtime));
} else {
eprintln!("[PAL:polyglot] ⏭️ Skipping unsupported runtime '{}' in cover", runtime);
continue;
}
}
if let Some(req_guard) = given.get("requires").and_then(|v| v.get(runtime)).and_then(|v| v.as_str())
&& !check_precondition(req_guard, clm_root) {
eprintln!("[PAL:polyglot] ⏭️ Pruning runtime '{}' (precondition not met: {})", runtime, req_guard);
continue;
}
let mut fork_count = 0;
let elapsed_ms;
let peak_rss_val;
let (run_status, stdout_data, stderr_data) = if runtime == "rust" && internal_ref.is_some() {
let ref_path = internal_ref.unwrap();
let func = crate::evaluator::get_internal_registry(ref_path)
.ok_or_else(|| format!("No internal function registered for path '{}'", ref_path))?;
let start_time = std::time::Instant::now();
let _start_rss = get_peak_rss_kb();
let run_res = {
let _sandbox_guard = crate::db::DatabaseSandboxGuard::activate(case_name);
func(clm_root, file_path)
};
elapsed_ms = start_time.elapsed().as_millis() as i64;
let end_rss = get_peak_rss_kb();
peak_rss_val = end_rss;
let (code, out) = run_res.map_err(|e| format!("Internal dispatch error: {}", e))?;
(code, out, String::new())
} else if let Some(harness) = native_harness {
let tool = harness.get("tool").and_then(|v| v.as_str()).ok_or("No tool specified in native_harness")?;
let cmd_arg = harness.get("command").and_then(|v| v.as_str()).ok_or("No command specified in native_harness")?;
fork_count += 1;
let full_cmd = format!("{} {}", tool, cmd_arg);
let start_time = std::time::Instant::now();
let start_rss = get_children_peak_rss_kb();
let mut cmd = create_sandboxed_command(&crate::fs_utils::get_bash_command(), &["-c".to_string(), full_cmd], &env_vars, clm_root);
let output = cmd.output().map_err(|e| format!("Failed to spawn native_harness: {}", e))?;
elapsed_ms = start_time.elapsed().as_millis() as i64;
let end_rss = get_children_peak_rss_kb();
peak_rss_val = if end_rss > start_rss { end_rss - start_rss } else { 0 };
(
output.status.code().unwrap_or(0),
String::from_utf8_lossy(&output.stdout).into_owned(),
String::from_utf8_lossy(&output.stderr).into_owned(),
)
} else {
let impl_path = format!(".clm.concrete_impl.process.implementations.{}", runtime);
let script_val = yaml::evaluate_jq(&parsed, &format!("{}.script", impl_path));
let handle_val = yaml::evaluate_jq(&parsed, &format!("{}.script_handle", impl_path));
let cargo_val = yaml::evaluate_jq(&parsed, &format!("{}.cargo_test", impl_path));
let mut script_content = script_val.as_str().unwrap_or("").to_string();
let cargo_test_name = cargo_val.as_str().unwrap_or("").to_string();
if script_content.is_empty()
&& let Some(handle) = handle_val.as_str()
&& handle.starts_with("script:") {
let s_name = handle.trim_start_matches("script:");
let sh_path = Path::new(clm_root).join("scripts").join(format!("{}.sh", s_name));
if let Ok(content) = std::fs::read_to_string(&sh_path) {
script_content = content;
} else {
let sh_path = Path::new(clm_root).join("tests").join("00_microkernel").join(format!("{}.sh", s_name));
if let Ok(content) = std::fs::read_to_string(&sh_path) {
script_content = content;
}
}
}
if script_content.is_empty() && cargo_test_name.is_empty() {
eprintln!("[PAL:polyglot] Skipping runtime '{}' because no script or cargo_test is defined", runtime);
continue;
}
let entry_point_val = yaml::evaluate_jq(&parsed, ".clm.concrete_impl.process.entry_point");
let entry_point = entry_point_val.as_str().unwrap_or("");
fork_count += 1;
let start_time = std::time::Instant::now();
let _start_rss = get_children_peak_rss_kb();
let (code, out, err) = match runtime.as_str() {
"shell" => {
let entry_call = if !entry_point.is_empty() {
let mut call = format!("{} ", entry_point);
for a in &pos_args {
call.push_str(&format!("\"{}\" ", a.replace('\"', "\\\"")));
}
call
} else {
"".to_string()
};
let full_script = format!("{}\n{}", script_content, entry_call);
let mut cmd = create_sandboxed_command(&crate::fs_utils::get_bash_command(), &["-c".to_string(), full_script], &env_vars, clm_root);
let output = cmd.output().map_err(|e| format!("Failed to spawn bash: {}", e))?;
(
output.status.code().unwrap_or(0),
String::from_utf8_lossy(&output.stdout).into_owned(),
String::from_utf8_lossy(&output.stderr).into_owned(),
)
}
"python" => {
let py_cmd = resolve_python_cmd(clm_root);
let mut cmd_args = vec!["-c".to_string(), script_content.to_string()];
cmd_args.extend(pos_args.clone());
let mut py_env_vars = env_vars.clone();
py_env_vars.insert("PYTHONPATH".to_string(), format!("{}/kernel/scripts", clm_root));
let mut cmd = create_sandboxed_command(&py_cmd, &cmd_args, &py_env_vars, clm_root);
let output = cmd.output().map_err(|e| format!("Failed to spawn python: {}", e))?;
(
output.status.code().unwrap_or(0),
String::from_utf8_lossy(&output.stdout).into_owned(),
String::from_utf8_lossy(&output.stderr).into_owned(),
)
}
"node" => {
let rand_id = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_nanos())
.unwrap_or(0);
let pid = std::process::id();
let temp_dir = std::env::temp_dir().join("clm_execution_logs/.tmp");
let _ = std::fs::create_dir_all(&temp_dir);
let temp_file = temp_dir.join(format!("clm_node_inline_{}_{}.cjs", rand_id, pid));
std::fs::write(&temp_file, script_content).map_err(|e| format!("Failed to write node inline script: {}", e))?;
let mut cmd_args = vec!["--trace-uncaught".to_string(), temp_file.to_string_lossy().to_string()];
cmd_args.extend(pos_args.clone());
let mut cmd = create_sandboxed_command("node", &cmd_args, &env_vars, clm_root);
let output = cmd.output();
let _ = std::fs::remove_file(&temp_file);
let output = output.map_err(|e| format!("Failed to spawn node: {}", e))?;
(
output.status.code().unwrap_or(0),
String::from_utf8_lossy(&output.stdout).into_owned(),
String::from_utf8_lossy(&output.stderr).into_owned(),
)
}
"rust" => {
if !cargo_test_name.is_empty() {
let self_exe = resolve_self_exe(clm_root);
let mut cmd = create_sandboxed_command(
&self_exe.to_string_lossy(),
&["run-test".to_string(), cargo_test_name.to_string()],
&env_vars,
clm_root,
);
cmd.current_dir(Path::new(clm_root).join("kernel/clm_rust_core"));
let output = cmd.output().map_err(|e| format!("Failed to spawn clm_rust_core: {}", e))?;
(
output.status.code().unwrap_or(if output.status.success() { 0 } else { 1 }),
String::from_utf8_lossy(&output.stdout).into_owned(),
String::from_utf8_lossy(&output.stderr).into_owned(),
)
} else {
let rand_id = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_nanos())
.unwrap_or(0);
let pid = std::process::id();
let temp_dir = std::env::temp_dir().join("clm_execution_logs/.tmp");
let _ = std::fs::create_dir_all(&temp_dir);
let src_file = temp_dir.join(format!("clm_rust_inline_{}_{}.rs", rand_id, pid));
let bin_file = temp_dir.join(format!("clm_rust_bin_{}_{}", rand_id, pid));
let full_rust_src = if !script_content.contains("fn main") {
format!(
"use std::io::{{self, Read}};\nfn main() {{\n{}\n}}",
script_content
)
} else {
script_content.to_string()
};
std::fs::write(&src_file, full_rust_src).map_err(|e| format!("Failed to write rust inline source: {}", e))?;
let compile_output = std::process::Command::new("rustc")
.arg("-O")
.arg("-o")
.arg(&bin_file)
.arg(&src_file)
.output();
let _ = std::fs::remove_file(&src_file);
let compile_res = compile_output.map_err(|e| format!("Failed to run rustc: {}", e))?;
if !compile_res.status.success() {
return Err(format!("Rust compilation failed:\n{}", String::from_utf8_lossy(&compile_res.stderr)));
}
let mut cmd = std::process::Command::new(&bin_file);
for a in &pos_args {
cmd.arg(a);
}
for (k, v) in &env_vars {
cmd.env(k, v);
}
cmd.current_dir(clm_root);
let output = cmd.output();
let _ = std::fs::remove_file(&bin_file);
let output = output.map_err(|e| format!("Failed to run rust binary: {}", e))?;
(
output.status.code().unwrap_or(0),
String::from_utf8_lossy(&output.stdout).into_owned(),
String::from_utf8_lossy(&output.stderr).into_owned(),
)
}
}
_ => unreachable!(),
};
elapsed_ms = start_time.elapsed().as_millis() as i64;
let end_rss = get_children_peak_rss_kb();
#[cfg(unix)]
{
peak_rss_val = if end_rss > _start_rss { end_rss - _start_rss } else { 0 };
}
#[cfg(windows)]
{
peak_rss_val = end_rss;
}
(code, out, err)
};
if !stderr_data.is_empty() {
eprintln!("{}", stderr_data);
}
if let Some(max_dur) = max_duration_ms
&& elapsed_ms > max_dur {
return Err(format!("❌ [SLA_VIOLATION] Case '{}' runtime '{}' exceeded max_duration_ms: {}ms > {}ms", case_name, runtime, elapsed_ms, max_dur));
}
if let Some(max_rss) = max_rss_kb
&& peak_rss_val > max_rss {
return Err(format!("❌ [SLA_VIOLATION] Case '{}' runtime '{}' exceeded max_rss_kb: {}KB > {}KB", case_name, runtime, peak_rss_val, max_rss));
}
if let Some(max_f) = max_forks
&& fork_count > max_f {
return Err(format!("❌ [SLA_VIOLATION] Case '{}' runtime '{}' exceeded max_forks: {} > {}", case_name, runtime, fork_count, max_f));
}
let runtime_facts = std::env::var("CLM_RUNTIME_FACTS").unwrap_or_default();
let clean_out = stdout_data.trim_end();
let exec_hash_input = format!(
"inputs: {} | outputs: {} | exit_code: {} | runtime: {} | runtime_facts: {}",
Value::Object(inputs.clone()), clean_out, run_status, runtime, runtime_facts
);
let exec_hash = crate::fs_utils::compute_content_hash(&exec_hash_input);
let mut extra_fields = format!(
"exit_code: {}\noutputs:\n result: \"{}\"\ninputs:\n",
run_status, clean_out.replace('\"', "\\\"")
);
for (k, v) in &inputs {
let val_str = match v {
Value::String(s) => s.clone(),
other => other.to_string(),
};
extra_fields.push_str(&format!(" {}: {}\n", k, val_str));
}
let mcard_path = db::emit_exec_mcard(
&format!("polyglot_execution_{}", runtime),
&exec_hash,
&extra_fields,
&active_a_hash,
&active_c_hash,
clm_root,
).map_err(|e| e.to_string())?;
eprintln!("[PAL:polyglot] ✅ Execution MCard ({}) registered: {}", runtime, mcard_path);
executed_runtimes.push(runtime.clone());
runtime_outputs.push(stdout_data);
runtime_exit_codes.push(run_status);
runtime_exec_hashes.push(exec_hash);
}
let exec_count = executed_runtimes.len();
if exec_count == 0 {
return Err(format!("No runtimes were successfully executed for case '{}'.", case_name));
}
let first_out = &runtime_outputs[0];
let first_code = runtime_exit_codes[0];
let first_norm = normalize_output(first_out);
let mut parity_failed = false;
let mut mismatch_rt = "";
let mut mismatch_out = String::new();
for i in 1..exec_count {
let r_name = &executed_runtimes[i];
let r_out = &runtime_outputs[i];
let r_code = runtime_exit_codes[i];
let r_norm = normalize_output(r_out);
if r_code != first_code {
parity_failed = true;
mismatch_rt = r_name;
mismatch_out = format!("Exit code mismatch: {}={} vs {}={}", executed_runtimes[0], first_code, r_name, r_code);
break;
}
if r_norm != first_norm {
parity_failed = true;
mismatch_rt = r_name;
mismatch_out = r_out.clone();
break;
}
}
if parity_failed {
let err_msg = format!(
"COHOMOLOGICAL OBSTRUCTION: Cross-Runtime Parity Fail\n\
❌ [PARITY_ERR] Polyglot execution mismatch between '{}' and '{}' in case '{}'!\n\
--- Outputs:\n\
1. {}: {}\n\
2. {}: {}\n\
--- Diff:\n",
executed_runtimes[0], mismatch_rt, case_name,
executed_runtimes[0], first_out.trim(),
mismatch_rt, mismatch_out.trim()
);
print_diff(&first_norm, &normalize_output(&mismatch_out));
return Err(err_msg);
}
if exec_count > 1 {
let mut sorted_hashes = runtime_exec_hashes.clone();
sorted_hashes.sort();
let fold_input = sorted_hashes.join("");
let parity_hash = crate::fs_utils::compute_sha256_hex(fold_input.as_bytes());
let clean_first_out = first_out.trim_end();
let mut parity_fields = format!(
"consensus_exit_code: {}\nconsensus_result: \"{}\"\nactive_runtimes:\n",
first_code, clean_first_out.replace('\"', "\\\"")
);
for r in &executed_runtimes {
parity_fields.push_str(&format!(" - {}\n", r));
}
let parity_file = db::emit_exec_mcard(
"polyglot_parity",
&parity_hash,
&parity_fields,
&active_a_hash,
&active_c_hash,
clm_root,
).map_err(|e| e.to_string())?;
eprintln!("[PAL:polyglot] ✅ Consensus Parity MCard registered: {}", parity_file);
}
let shared_points = if exec_count > 1 { 1 } else { 0 };
let cross_confirmed = exec_count.saturating_sub(1);
eprintln!(
"[EPIPLEXITY] Metrics for case '{}': runtimes={}, shared_test_points={}, cross_confirmed_assertions={}",
case_name, exec_count, shared_points, cross_confirmed
);
consensus_exit_code = first_code;
last_case_output = first_out.clone();
}
Ok((consensus_exit_code, last_case_output))
}
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct RuntimeScriptInput {
pub runtime: String,
pub script: String,
#[serde(default)]
pub env: HashMap<String, String>,
#[serde(default)]
pub entry_point: String,
#[serde(default)]
pub cargo_test: String,
#[serde(default)]
pub args: Vec<String>,
#[serde(default)]
pub clm_root: String,
}
#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
pub struct RuntimeScriptOutput {
pub exit_code: i32,
pub stdout: String,
pub stderr: String,
}
pub fn exec_runtime_script(input: &RuntimeScriptInput) -> Result<RuntimeScriptOutput, String> {
let clm_root = if input.clm_root.is_empty() {
std::env::var("CLM_ROOT").unwrap_or_default()
} else {
input.clm_root.clone()
};
let runtime = input.runtime.as_str();
let script_content = input.script.as_str();
let entry_point = input.entry_point.as_str();
let cargo_test_name = input.cargo_test.as_str();
let pos_args = &input.args;
let (code, out, err) = match runtime {
"shell" => {
let entry_call = if !entry_point.is_empty() {
let mut call = format!("{} ", entry_point);
for a in pos_args {
call.push_str(&format!("\"{}\" ", a.replace('"', "\\\"")));
}
call
} else {
String::new()
};
let full_script = format!("{}\n{}", script_content, entry_call);
let mut cmd = create_sandboxed_command(
&crate::fs_utils::get_bash_command(),
&["-c".to_string(), full_script],
&input.env,
&clm_root,
);
let output = cmd.output().map_err(|e| format!("Failed to spawn bash: {}", e))?;
(
output.status.code().unwrap_or(0),
String::from_utf8_lossy(&output.stdout).into_owned(),
String::from_utf8_lossy(&output.stderr).into_owned(),
)
}
"python" => {
let py_cmd = resolve_python_cmd(&clm_root);
let mut cmd_args = vec!["-c".to_string(), script_content.to_string()];
cmd_args.extend(pos_args.clone());
let mut py_env = input.env.clone();
py_env.insert("PYTHONPATH".to_string(), format!("{}/kernel/scripts", clm_root));
let mut cmd = create_sandboxed_command(&py_cmd, &cmd_args, &py_env, &clm_root);
let output = cmd.output().map_err(|e| format!("Failed to spawn python: {}", e))?;
(
output.status.code().unwrap_or(0),
String::from_utf8_lossy(&output.stdout).into_owned(),
String::from_utf8_lossy(&output.stderr).into_owned(),
)
}
"node" => {
let rand_id = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_nanos())
.unwrap_or(0);
let pid = std::process::id();
let temp_dir = std::env::temp_dir().join("clm_execution_logs/.tmp");
let _ = std::fs::create_dir_all(&temp_dir);
let temp_file = temp_dir.join(format!("clm_node_inline_{}_{}.cjs", rand_id, pid));
std::fs::write(&temp_file, script_content)
.map_err(|e| format!("Failed to write node inline script: {}", e))?;
let mut cmd_args = vec!["--trace-uncaught".to_string(), temp_file.to_string_lossy().to_string()];
cmd_args.extend(pos_args.clone());
let mut cmd = create_sandboxed_command("node", &cmd_args, &input.env, &clm_root);
let output = cmd.output();
let _ = std::fs::remove_file(&temp_file);
let output = output.map_err(|e| format!("Failed to spawn node: {}", e))?;
(
output.status.code().unwrap_or(0),
String::from_utf8_lossy(&output.stdout).into_owned(),
String::from_utf8_lossy(&output.stderr).into_owned(),
)
}
"rust" => {
if !cargo_test_name.is_empty() {
let self_exe = resolve_self_exe(&clm_root);
let mut cmd = create_sandboxed_command(
&self_exe.to_string_lossy(),
&["run-test".to_string(), cargo_test_name.to_string()],
&input.env,
&clm_root,
);
cmd.current_dir(Path::new(&clm_root).join("kernel/clm_rust_core"));
let output = cmd.output().map_err(|e| format!("Failed to spawn clm_rust_core: {}", e))?;
(
output.status.code().unwrap_or(if output.status.success() { 0 } else { 1 }),
String::from_utf8_lossy(&output.stdout).into_owned(),
String::from_utf8_lossy(&output.stderr).into_owned(),
)
} else {
let rand_id = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_nanos())
.unwrap_or(0);
let pid = std::process::id();
let temp_dir = std::env::temp_dir().join("clm_execution_logs/.tmp");
let _ = std::fs::create_dir_all(&temp_dir);
let src_file = temp_dir.join(format!("clm_rust_inline_{}_{}.rs", rand_id, pid));
let bin_file = temp_dir.join(format!("clm_rust_bin_{}_{}", rand_id, pid));
let full_rust_src = if !script_content.contains("fn main") {
format!("use std::io::{{self, Read}};\nfn main() {{\n{}\n}}", script_content)
} else {
script_content.to_string()
};
std::fs::write(&src_file, full_rust_src)
.map_err(|e| format!("Failed to write rust inline source: {}", e))?;
let compile_output = std::process::Command::new("rustc")
.arg("-O")
.arg("-o")
.arg(&bin_file)
.arg(&src_file)
.output();
let _ = std::fs::remove_file(&src_file);
let compile_res = compile_output.map_err(|e| format!("Failed to run rustc: {}", e))?;
if !compile_res.status.success() {
return Ok(RuntimeScriptOutput {
exit_code: 1,
stdout: String::new(),
stderr: format!("Rust compilation failed:\n{}", String::from_utf8_lossy(&compile_res.stderr)),
});
}
let mut cmd = std::process::Command::new(&bin_file);
for a in pos_args {
cmd.arg(a);
}
for (k, v) in &input.env {
cmd.env(k, v);
}
cmd.current_dir(&clm_root);
let output = cmd.output();
let _ = std::fs::remove_file(&bin_file);
let output = output.map_err(|e| format!("Failed to run rust binary: {}", e))?;
(
output.status.code().unwrap_or(0),
String::from_utf8_lossy(&output.stdout).into_owned(),
String::from_utf8_lossy(&output.stderr).into_owned(),
)
}
}
_ => {
return Err(format!("Unsupported runtime: {}", runtime));
}
};
Ok(RuntimeScriptOutput {
exit_code: code,
stdout: out,
stderr: err,
})
}