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 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 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(¤t_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 memorize::check_and_register_file_mcard(file_path, clm_root)?;
412
413 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 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 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 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 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::*;