Skip to main content

clm_rust_core/polyglot/
case_runner.rs

1use std::collections::HashMap;
2use std::path::Path;
3use serde_json::Value;
4use super::metrics::{get_peak_rss_kb, get_children_peak_rss_kb};
5use super::config::{create_sandboxed_command, resolve_python_cmd, resolve_self_exe};
6use crate::yaml;
7
8pub struct RuntimeRunResult {
9    pub run_status: i32,
10    pub stdout_data: String,
11    pub stderr_data: String,
12    pub elapsed_ms: i64,
13    pub peak_rss_val: i64,
14    pub fork_count: i64,
15}
16
17pub fn execute_runtime_case(
18    runtime: &str,
19    case_name: &str,
20    parsed: &Value,
21    internal_ref: Option<&str>,
22    native_harness: Option<&Value>,
23    pos_args: &[String],
24    env_vars: &HashMap<String, String>,
25    file_path: &str,
26    clm_root: &str,
27) -> Result<RuntimeRunResult, String> {
28    let mut fork_count = 0;
29    let elapsed_ms;
30    let peak_rss_val;
31
32    let (run_status, stdout_data, stderr_data) = if runtime == "rust" && internal_ref.is_some() {
33        let ref_path = internal_ref.unwrap();
34        let func = crate::evaluator::get_internal_registry(ref_path)
35            .ok_or_else(|| format!("No internal function registered for path '{}'", ref_path))?;
36        
37        let start_time = std::time::Instant::now();
38        let _start_rss = get_peak_rss_kb();
39
40        let run_res = {
41            let _sandbox_guard = crate::db::DatabaseSandboxGuard::activate(case_name);
42            func(clm_root, file_path)
43        };
44
45        elapsed_ms = start_time.elapsed().as_millis() as i64;
46        let end_rss = get_peak_rss_kb();
47        peak_rss_val = end_rss;
48
49        let (code, out) = run_res.map_err(|e| format!("Internal dispatch error: {}", e))?;
50        (code, out, String::new())
51    } else if let Some(harness) = native_harness {
52        let tool = harness.get("tool").and_then(|v| v.as_str()).ok_or("No tool specified in native_harness")?;
53        let cmd_arg = harness.get("command").and_then(|v| v.as_str()).ok_or("No command specified in native_harness")?;
54        
55        fork_count += 1;
56        let full_cmd = format!("{} {}", tool, cmd_arg);
57        let start_time = std::time::Instant::now();
58        let start_rss = get_children_peak_rss_kb();
59
60        let mut cmd = create_sandboxed_command(&crate::fs_utils::get_bash_command(), &["-c".to_string(), full_cmd], env_vars, clm_root);
61        let output = cmd.output().map_err(|e| format!("Failed to spawn native_harness: {}", e))?;
62        
63        elapsed_ms = start_time.elapsed().as_millis() as i64;
64        let end_rss = get_children_peak_rss_kb();
65        peak_rss_val = if end_rss > start_rss { end_rss - start_rss } else { 0 };
66
67        (output.status.code().unwrap_or(0), String::from_utf8_lossy(&output.stdout).into_owned(), String::from_utf8_lossy(&output.stderr).into_owned())
68    } else {
69        let impl_path = format!(".clm.concrete_impl.process.implementations.{}", runtime);
70        let script_val = yaml::evaluate_jq(parsed, &format!("{}.script", impl_path));
71        let handle_val = yaml::evaluate_jq(parsed, &format!("{}.script_handle", impl_path));
72        let cargo_val = yaml::evaluate_jq(parsed, &format!("{}.cargo_test", impl_path));
73        
74        let mut script_content = script_val.as_str().unwrap_or("").to_string();
75        let cargo_test_name = cargo_val.as_str().unwrap_or("").to_string();
76
77        if script_content.is_empty() && let Some(handle) = handle_val.as_str() && handle.starts_with("script:") {
78            let s_name = handle.trim_start_matches("script:");
79            let sh_path = Path::new(clm_root).join("scripts").join(format!("{}.sh", s_name));
80            if let Ok(content) = std::fs::read_to_string(&sh_path) {
81                script_content = content;
82            } else {
83                let sh_path = Path::new(clm_root).join("tests").join("00_microkernel").join(format!("{}.sh", s_name));
84                if let Ok(content) = std::fs::read_to_string(&sh_path) {
85                    script_content = content;
86                }
87            }
88        }
89
90        if script_content.is_empty() && cargo_test_name.is_empty() {
91            return Err(format!("Skipping runtime '{}' because no script or cargo_test is defined", runtime));
92        }
93
94        let entry_point_val = yaml::evaluate_jq(parsed, ".clm.concrete_impl.process.entry_point");
95        let entry_point = entry_point_val.as_str().unwrap_or("");
96
97        fork_count += 1;
98        let start_time = std::time::Instant::now();
99        let _start_rss = get_children_peak_rss_kb();
100
101        let (code, out, err) = match runtime {
102            "shell" => {
103                let entry_call = if !entry_point.is_empty() {
104                    let mut call = format!("{} ", entry_point);
105                    for a in pos_args {
106                        call.push_str(&format!("\"{}\" ", a.replace('\"', "\\\"")));
107                    }
108                    call
109                } else {
110                    "".to_string()
111                };
112                let full_script = format!("{}\n{}", script_content, entry_call);
113                let mut cmd = create_sandboxed_command(&crate::fs_utils::get_bash_command(), &["-c".to_string(), full_script], env_vars, clm_root);
114                let output = cmd.output().map_err(|e| format!("Failed to spawn bash: {}", e))?;
115                (
116                    output.status.code().unwrap_or(0),
117                    String::from_utf8_lossy(&output.stdout).into_owned(),
118                    String::from_utf8_lossy(&output.stderr).into_owned(),
119                )
120            }
121            "python" => {
122                let py_cmd = resolve_python_cmd(clm_root);
123                let mut cmd_args = vec!["-c".to_string(), script_content.to_string()];
124                cmd_args.extend(pos_args.iter().cloned());
125                let mut py_env_vars = env_vars.clone();
126                py_env_vars.insert("PYTHONPATH".to_string(), format!("{}/kernel/clm_py_core", clm_root));
127                let mut cmd = create_sandboxed_command(&py_cmd, &cmd_args, &py_env_vars, clm_root);
128                let output = cmd.output().map_err(|e| format!("Failed to spawn python: {}", e))?;
129                (
130                    output.status.code().unwrap_or(0),
131                    String::from_utf8_lossy(&output.stdout).into_owned(),
132                    String::from_utf8_lossy(&output.stderr).into_owned(),
133                )
134            }
135            "node" => {
136                let rand_id = std::time::SystemTime::now()
137                    .duration_since(std::time::UNIX_EPOCH)
138                    .map(|d| d.as_nanos())
139                    .unwrap_or(0);
140                let pid = std::process::id();
141                let temp_dir = std::env::temp_dir().join("clm_execution_logs/.tmp");
142                let _ = std::fs::create_dir_all(&temp_dir);
143                let temp_file = temp_dir.join(format!("clm_node_inline_{}_{}.cjs", rand_id, pid));
144                std::fs::write(&temp_file, script_content).map_err(|e| format!("Failed to write node inline script: {}", e))?;
145
146                let mut cmd_args = vec!["--trace-uncaught".to_string(), temp_file.to_string_lossy().to_string()];
147                cmd_args.extend(pos_args.iter().cloned());
148                let mut cmd = create_sandboxed_command("node", &cmd_args, env_vars, clm_root);
149                let output = cmd.output();
150                let _ = std::fs::remove_file(&temp_file);
151
152                let output = output.map_err(|e| format!("Failed to spawn node: {}", e))?;
153                (
154                    output.status.code().unwrap_or(0),
155                    String::from_utf8_lossy(&output.stdout).into_owned(),
156                    String::from_utf8_lossy(&output.stderr).into_owned(),
157                )
158            }
159            "rust" => {
160                if !cargo_test_name.is_empty() {
161                    let self_exe = resolve_self_exe(clm_root);
162                    let mut cmd = create_sandboxed_command(
163                        &self_exe.to_string_lossy(),
164                        &["run-test".to_string(), cargo_test_name.to_string()],
165                        env_vars,
166                        clm_root,
167                    );
168                    cmd.current_dir(Path::new(clm_root).join("kernel/clm_rust_core"));
169
170                    let output = cmd.output().map_err(|e| format!("Failed to spawn clm_rust_core: {}", e))?;
171                    (
172                        output.status.code().unwrap_or(if output.status.success() { 0 } else { 1 }),
173                        String::from_utf8_lossy(&output.stdout).into_owned(),
174                        String::from_utf8_lossy(&output.stderr).into_owned(),
175                    )
176                } else {
177                    let rand_id = std::time::SystemTime::now()
178                        .duration_since(std::time::UNIX_EPOCH)
179                        .map(|d| d.as_nanos())
180                        .unwrap_or(0);
181                    let pid = std::process::id();
182                    let temp_dir = std::env::temp_dir().join("clm_execution_logs/.tmp");
183                    let _ = std::fs::create_dir_all(&temp_dir);
184                    let src_file = temp_dir.join(format!("clm_rust_inline_{}_{}.rs", rand_id, pid));
185                    let bin_file = temp_dir.join(format!("clm_rust_bin_{}_{}", rand_id, pid));
186
187                    let full_rust_src = if !script_content.contains("fn main") {
188                        format!(
189                            "use std::io::{{self, Read}};\nfn main() {{\n{}\n}}",
190                            script_content
191                        )
192                    } else {
193                        script_content.to_string()
194                    };
195                    std::fs::write(&src_file, full_rust_src).map_err(|e| format!("Failed to write rust inline source: {}", e))?;
196
197                    let compile_output = std::process::Command::new("rustc")
198                        .arg("-O")
199                        .arg("-o")
200                        .arg(&bin_file)
201                        .arg(&src_file)
202                        .output();
203                    let _ = std::fs::remove_file(&src_file);
204
205                    let compile_res = compile_output.map_err(|e| format!("Failed to run rustc: {}", e))?;
206                    if !compile_res.status.success() {
207                        return Err(format!("Rust compilation failed:\n{}", String::from_utf8_lossy(&compile_res.stderr)));
208                    }
209
210                    let mut cmd = std::process::Command::new(&bin_file);
211                    for a in pos_args {
212                        cmd.arg(a);
213                    }
214                    for (k, v) in env_vars {
215                        cmd.env(k, v);
216                    }
217                    cmd.current_dir(clm_root);
218
219                    let output = cmd.output();
220                    let _ = std::fs::remove_file(&bin_file);
221                    
222                    let output = output.map_err(|e| format!("Failed to run rust binary: {}", e))?;
223                    (
224                        output.status.code().unwrap_or(0),
225                        String::from_utf8_lossy(&output.stdout).into_owned(),
226                        String::from_utf8_lossy(&output.stderr).into_owned(),
227                    )
228                }
229            }
230            _ => unreachable!(),
231        };
232
233        elapsed_ms = start_time.elapsed().as_millis() as i64;
234        let end_rss = get_children_peak_rss_kb();
235        #[cfg(unix)]
236        {
237            peak_rss_val = if end_rss > _start_rss { end_rss - _start_rss } else { 0 };
238        }
239        #[cfg(windows)]
240        {
241            peak_rss_val = end_rss;
242        }
243
244        (code, out, err)
245    };
246
247    Ok(RuntimeRunResult {
248        run_status,
249        stdout_data,
250        stderr_data,
251        elapsed_ms,
252        peak_rss_val,
253        fork_count,
254    })
255}