Skip to main content

clm_rust_core/
polyglot.rs

1use std::collections::HashMap;
2use std::path::{Path, PathBuf};
3use serde_json::Value;
4use crate::memorize;
5use crate::yaml;
6use crate::db;
7
8#[cfg(unix)]
9#[repr(C)]
10#[derive(Clone, Copy)]
11pub struct timeval {
12    pub tv_sec: i64,
13    pub tv_usec: i32,
14    #[cfg(target_os = "macos")]
15    pub _padding: i32,
16}
17
18#[cfg(unix)]
19#[repr(C)]
20pub struct rusage {
21    pub ru_utime: timeval,
22    pub ru_stime: timeval,
23    pub ru_maxrss: i64,
24    pub ru_ixrss: i64,
25    pub ru_idrss: i64,
26    pub ru_isrss: i64,
27    pub ru_minflt: i64,
28    pub ru_majflt: i64,
29    pub ru_nswap: i64,
30    pub ru_inblock: i64,
31    pub ru_oublock: i64,
32    pub ru_msgsnd: i64,
33    pub ru_msgrcv: i64,
34    pub ru_nsignals: i64,
35    pub ru_nvcsw: i64,
36    pub ru_nivcsw: i64,
37}
38
39#[cfg(unix)]
40const RUSAGE_SELF: i32 = 0;
41#[cfg(unix)]
42const RUSAGE_CHILDREN: i32 = -1;
43
44#[cfg(unix)]
45#[allow(dead_code)]
46unsafe extern "C" {
47    fn dup(fd: i32) -> i32;
48    fn dup2(src: i32, dst: i32) -> i32;
49    fn close(fd: i32) -> i32;
50    fn getrusage(who: i32, usage: *mut rusage) -> i32;
51}
52
53#[cfg(unix)]
54pub fn get_peak_rss_kb() -> i64 {
55    let mut usage = unsafe { std::mem::zeroed::<rusage>() };
56    let res = unsafe { getrusage(RUSAGE_SELF, &mut usage) };
57    if res == 0 {
58        #[cfg(target_os = "macos")]
59        {
60            usage.ru_maxrss / 1024
61        }
62        #[cfg(not(target_os = "macos"))]
63        {
64            usage.ru_maxrss
65        }
66    } else {
67        0
68    }
69}
70
71#[cfg(unix)]
72pub fn get_children_peak_rss_kb() -> i64 {
73    let mut usage = unsafe { std::mem::zeroed::<rusage>() };
74    let res = unsafe { getrusage(RUSAGE_CHILDREN, &mut usage) };
75    if res == 0 {
76        #[cfg(target_os = "macos")]
77        {
78            usage.ru_maxrss / 1024
79        }
80        #[cfg(not(target_os = "macos"))]
81        {
82            usage.ru_maxrss
83        }
84    } else {
85        0
86    }
87}
88
89#[cfg(windows)]
90#[repr(C)]
91#[allow(non_snake_case)]
92struct PROCESS_MEMORY_COUNTERS {
93    cb: u32,
94    PageFaultCount: u32,
95    PeakWorkingSetSize: usize,
96    WorkingSetSize: usize,
97    QuotaPeakPagedPoolUsage: usize,
98    QuotaPagedPoolUsage: usize,
99    QuotaPeakNonPagedPoolUsage: usize,
100    QuotaNonPagedPoolUsage: usize,
101    PagefileUsage: usize,
102    PeakPagefileUsage: usize,
103}
104
105#[cfg(windows)]
106#[link(name = "psapi")]
107unsafe extern "system" {
108    fn GetCurrentProcess() -> *mut std::ffi::c_void;
109    fn GetProcessMemoryInfo(
110        process: *mut std::ffi::c_void,
111        counters: *mut PROCESS_MEMORY_COUNTERS,
112        cb: u32,
113    ) -> i32;
114}
115
116#[cfg(windows)]
117pub fn get_peak_rss_kb() -> i64 {
118    let mut counters = unsafe { std::mem::zeroed::<PROCESS_MEMORY_COUNTERS>() };
119    counters.cb = std::mem::size_of::<PROCESS_MEMORY_COUNTERS>() as u32;
120    let res = unsafe { GetProcessMemoryInfo(GetCurrentProcess(), &mut counters, counters.cb) };
121    if res != 0 {
122        (counters.PeakWorkingSetSize / 1024) as i64
123    } else {
124        0
125    }
126}
127
128#[cfg(windows)]
129pub fn get_children_peak_rss_kb() -> i64 {
130    get_peak_rss_kb()
131}
132
133pub fn resolve_python_cmd(clm_root: &str) -> String {
134    let root_path = std::path::Path::new(clm_root);
135    
136    // Windows virtual env python
137    let venv_py_win = root_path.join(".venv/Scripts/python.exe");
138    if venv_py_win.exists() {
139        return venv_py_win.to_string_lossy().to_string();
140    }
141    
142    // Unix virtual env python
143    let venv_py_unix = root_path.join(".venv/bin/python3");
144    if venv_py_unix.exists() {
145        return venv_py_unix.to_string_lossy().to_string();
146    }
147    
148    let venv_py_unix_2 = root_path.join(".venv/bin/python");
149    if venv_py_unix_2.exists() {
150        return venv_py_unix_2.to_string_lossy().to_string();
151    }
152
153    if cfg!(target_os = "windows") {
154        for cmd in &["python", "python3"] {
155            if std::process::Command::new(cmd).arg("--version").output().map(|o| o.status.success()).unwrap_or(false) {
156                return cmd.to_string();
157            }
158        }
159    } else {
160        for cmd in &["python3", "python"] {
161            if std::process::Command::new(cmd).arg("--version").output().map(|o| o.status.success()).unwrap_or(false) {
162                return cmd.to_string();
163            }
164        }
165    }
166    
167    if cfg!(target_os = "windows") {
168        "python".to_string()
169    } else {
170        "python3".to_string()
171    }
172}
173
174pub fn get_interpreter_version(interpreter: &str, clm_root: &str) -> Option<String> {
175    let cmd_name = match interpreter {
176        "python" | "python3" => resolve_python_cmd(clm_root),
177        other => other.to_string(),
178    };
179    let output = std::process::Command::new(&cmd_name)
180        .arg("--version")
181        .output()
182        .ok();
183    if let Some(out) = output {
184        let text = String::from_utf8_lossy(&out.stdout).to_string()
185            + String::from_utf8_lossy(&out.stderr).as_ref();
186        let re = regex::Regex::new(r"(\d+\.\d+(?:\.\d+)?)").unwrap();
187        if let Some(caps) = re.captures(&text) {
188            return Some(caps[1].to_string());
189        }
190    }
191    None
192}
193
194pub fn compare_versions(current: &str, op: &str, req: &str) -> bool {
195    let parse_ver = |s: &str| -> (u32, u32, u32) {
196        let parts: Vec<&str> = s.split('.').collect();
197        let major = parts.first().and_then(|v| v.parse().ok()).unwrap_or(0);
198        let minor = parts.get(1).and_then(|v| v.parse().ok()).unwrap_or(0);
199        let patch = parts.get(2).and_then(|v| v.parse().ok()).unwrap_or(0);
200        (major, minor, patch)
201    };
202    let v1 = parse_ver(current);
203    let v2 = parse_ver(req);
204    match op {
205        ">=" => v1 >= v2,
206        "<=" => v1 <= v2,
207        ">" => v1 > v2,
208        "<" => v1 < v2,
209        _ => v1 == v2,
210    }
211}
212
213pub fn check_precondition(req_str: &str, clm_root: &str) -> bool {
214    let re = regex::Regex::new(r"^interpreter:([a-zA-Z0-9_-]+)(>=|<=|>|<|==|=)([0-9.]+)$").unwrap();
215    if let Some(caps) = re.captures(req_str) {
216        let interpreter = &caps[1];
217        let op = &caps[2];
218        let req_ver = &caps[3];
219        if let Some(current_ver) = get_interpreter_version(interpreter, clm_root) {
220            compare_versions(&current_ver, op, req_ver)
221        } else {
222            false
223        }
224    } else {
225        true
226    }
227}
228
229pub fn create_sandboxed_command(
230    program: &str,
231    args: &[String],
232    envs: &HashMap<String, String>,
233    clm_root: &str,
234) -> std::process::Command {
235    let clm_no_sandbox = envs.get("CLM_NO_SANDBOX").map(|v| v == "true").unwrap_or_else(|| {
236        crate::cross_cutting::context::CLMContext::get_scoped_or_env("CLM_NO_SANDBOX")
237            .unwrap_or_default()
238            == "true"
239    });
240    let has_sandbox_exec = std::process::Command::new("which")
241        .arg("sandbox-exec")
242        .output()
243        .map(|o| o.status.success())
244        .unwrap_or(false);
245
246    let mut cmd = if !clm_no_sandbox && has_sandbox_exec {
247        let home_dir = std::env::var("HOME").unwrap_or_default();
248        let profile = format!(
249            r#"(version 1)
250(deny default)
251(allow file-read-metadata)
252(allow file-read-data)
253(allow file-write-data)
254(allow file-read*
255    (subpath "/usr")
256    (subpath "/System")
257    (subpath "/Library")
258    (subpath "/private")
259    (subpath "/var")
260    (subpath "/tmp")
261    (subpath "/etc")
262    (subpath "/opt")
263    (subpath "/dev")
264    (subpath "{}")
265    (subpath "{}"))
266(allow file-write*
267    (subpath "{}/data")
268    (subpath "{}/db")
269    (subpath "{}/types/meta")
270    (literal "{}/result_open_interpreter.txt")
271    (subpath "{}/.clm")
272    (subpath "/private/var")
273    (subpath "/private/tmp")
274    (subpath "/var")
275    (subpath "/tmp")
276    (literal "/dev/null")
277    (literal "/dev/zero"))
278(allow file-map-executable
279    (subpath "/usr")
280    (subpath "/System")
281    (subpath "/Library")
282    (subpath "/opt")
283    (subpath "{}")
284    (subpath "{}"))
285(allow process-exec
286    (subpath "/bin")
287    (subpath "/usr/bin")
288    (subpath "/usr/local/bin")
289    (subpath "/opt/homebrew")
290    (subpath "/Library/Frameworks/Python.framework")
291    (subpath "/Library/Developer/CommandLineTools")
292    (subpath "/private/var")
293    (subpath "/var")
294    (subpath "/tmp")
295    (subpath "{}")
296    (subpath "{}"))
297(allow process-fork)
298(allow process-info*)
299(allow ipc-posix*)
300(allow sysctl-read)
301(allow mach-lookup)
302(allow dynamic-code-generation)
303(allow network-bind)
304(allow network-inbound)
305(allow network-outbound)
306(deny file-read*
307    (literal "/private/etc/passwd")
308    (literal "/etc/passwd"))
309(deny file-read-data
310    (literal "/private/etc/passwd")
311    (literal "/etc/passwd"))"#,
312            clm_root, home_dir, clm_root, clm_root, clm_root, clm_root, home_dir, clm_root, home_dir, clm_root, home_dir
313        );
314        let mut c = std::process::Command::new("sandbox-exec");
315        c.arg("-p").arg(profile).arg(program);
316        c
317    } else {
318        std::process::Command::new(program)
319    };
320
321    for var_name in crate::layer0::runtime_contract::ENV_PASSTHROUGH_WHITELIST {
322        if let Some(val) = crate::cross_cutting::context::CLMContext::get_scoped_or_env(var_name) {
323            cmd.env(var_name, val);
324        }
325    }
326    crate::cross_cutting::context::CLMContext::apply_current_to_command(&mut cmd);
327    for (k, v) in envs {
328        cmd.env(k, v);
329    }
330    for a in args {
331        cmd.arg(a);
332    }
333    cmd
334}
335
336pub fn normalize_output(raw_out: &str) -> String {
337    use serde_json::Value;
338    let stripped = raw_out.replace('\r', "");
339    let stripped = stripped.trim_end().to_string();
340    if let Ok(val) = serde_json::from_str::<Value>(&stripped) {
341        serde_json::to_string(&val).unwrap_or(stripped)
342    } else {
343        stripped
344    }
345}
346
347pub fn print_diff(first_norm: &str, second_norm: &str) {
348    let temp_dir = std::env::temp_dir().join("clm_execution_logs/.tmp");
349    let f1 = temp_dir.join(format!("norm_f1_{}", std::process::id()));
350    let f2 = temp_dir.join(format!("norm_f2_{}", std::process::id()));
351    let _ = std::fs::write(&f1, first_norm);
352    let _ = std::fs::write(&f2, second_norm);
353    
354    let diff_output = std::process::Command::new("diff")
355        .arg("-u")
356        .arg(&f1)
357        .arg(&f2)
358        .output();
359    if let Ok(out) = diff_output {
360        let text = String::from_utf8_lossy(&out.stdout);
361        eprintln!("{}", text);
362    }
363    
364    let _ = std::fs::remove_file(f1);
365    let _ = std::fs::remove_file(f2);
366}
367
368pub fn resolve_self_exe(clm_root: &str) -> PathBuf {
369    if let Ok(self_exe) = std::env::current_exe() {
370        if self_exe.to_string_lossy().contains("deps") {
371            let alt_exe = Path::new(clm_root).join({
372                #[cfg(windows)] { "kernel/clm_rust_core/target/debug/clm_rust_core.exe" }
373                #[cfg(not(windows))] { "kernel/clm_rust_core/target/debug/clm_rust_core" }
374            });
375            if alt_exe.exists() {
376                return alt_exe;
377            }
378            let alt_exe_release = Path::new(clm_root).join({
379                #[cfg(windows)] { "kernel/clm_rust_core/target/release/clm_rust_core.exe" }
380                #[cfg(not(windows))] { "kernel/clm_rust_core/target/release/clm_rust_core" }
381            });
382            if alt_exe_release.exists() {
383                return alt_exe_release;
384            }
385        }
386        if let Some(parent) = self_exe.parent() {
387            let local_exe = parent.join({
388                #[cfg(windows)] { "clm_rust_core.exe" }
389                #[cfg(not(windows))] { "clm_rust_core" }
390            });
391            if local_exe.exists() {
392                return local_exe;
393            }
394        }
395        return self_exe;
396    }
397    Path::new(clm_root).join({
398        #[cfg(windows)] { "kernel/clm_rust_core/target/release/clm_rust_core.exe" }
399        #[cfg(not(windows))] { "kernel/clm_rust_core/target/release/clm_rust_core" }
400    })
401}
402
403pub fn exec_polyglot(
404    file_path: &str,
405    payload: Option<&str>,
406    clm_root: &str,
407) -> std::result::Result<(i32, String), String> {
408    let payload = payload.filter(|s| !s.is_empty());
409
410    // Register CLM manifest file and its AST cards in the database
411    memorize::check_and_register_file_mcard(file_path, clm_root)?;
412
413    // 1. Load the manifest content as JSON
414    let json_str = yaml::parse_to_mcards(file_path).map_err(|e| e.to_string())?;
415    let parsed: Value = serde_json::from_str(&json_str)
416        .map_err(|e| format!("Failed to parse JSON AST: {}", e))?;
417
418    // 2. Locate polyglot cases
419    let polyglot_cases = yaml::evaluate_jq(&parsed, ".clm.balanced_exp.polyglot_cases");
420    let cases_arr = match polyglot_cases {
421        Value::Array(arr) => arr,
422        _ => return Err("No polyglot_cases found".to_string()),
423    };
424
425    // 3. Find the target cases to run
426    let mut target_cases = Vec::new();
427    if let Some(p) = payload {
428        let mut found = false;
429        for c in cases_arr.iter() {
430            if let Some(name) = c.get("name").and_then(|v| v.as_str())
431                && name == p {
432                    target_cases.push(c.clone());
433                    found = true;
434                    break;
435                }
436        }
437        if !found {
438            return Err(format!("Case matching payload '{}' not found", p));
439        }
440    } else {
441        // Run all cases
442        for c in cases_arr.iter() {
443            target_cases.push(c.clone());
444        }
445    }
446
447    if target_cases.is_empty() {
448        return Err("No cases to execute".to_string());
449    }
450
451    let target_runtime = std::env::var("CLM_POLYGLOT_RUNTIME").ok();
452    if let Some(target) = &target_runtime {
453        eprintln!("[PAL:polyglot] Active runtime choice: {}", target);
454    }
455
456    // Resolve active hashes
457    let active_a_hash = std::env::var("CLM_ACTIVE_A_HASH").unwrap_or_default();
458    let active_c_hash = std::env::var("CLM_ACTIVE_C_HASH").unwrap_or_default();
459
460    let mut last_case_output = String::new();
461    let mut consensus_exit_code = 0;
462
463    include!("polyglot_case_loop.rs")
464}
465
466#[path = "polyglot_runtime_script.rs"]
467mod polyglot_runtime_script;
468#[allow(unused_imports)]
469pub use polyglot_runtime_script::*;