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}