clm-kernel 0.0.16

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
#![allow(unused_imports)]
use super::*;

pub fn evaluate_card_with_context(
    ctx: &crate::cross_cutting::context::CLMContext,
    sub_card_path: &Path,
) -> Result<i32, String> {
    let clm_root = ctx
        .project_root()
        .map(|p| p.to_path_buf())
        .or_else(|| resolve_clm_root().ok())
        .unwrap_or_else(|| PathBuf::from("."));
    let payload_opt = ctx.get_var("CLM_PAYLOAD");
    let post_rc_opt = ctx
        .get_var("CLM_POST_RC")
        .and_then(|v| v.parse::<i32>().ok());
    let quiet = ctx
        .get_var("CLM_QUIET")
        .map(|v| matches!(v.trim().to_ascii_lowercase().as_str(), "1" | "true"))
        .unwrap_or(false);
    let _scope_guard = ctx.enter_scope();
    run_evaluation(
        &clm_root,
        Some(&sub_card_path.to_string_lossy()),
        payload_opt.as_deref(),
        post_rc_opt,
        quiet,
        None,
    )
}

pub fn run_evaluation(
    clm_root: &Path,
    clm_file: Option<&str>,
    payload: Option<&str>,
    post_rc: Option<i32>,
    quiet: bool,
    instance_id: Option<&str>,
) -> Result<i32, String> {
    if let Ok(mut lock) = crate::cpn::vm::EVAL_CALLBACK.write() {
        *lock = Some(run_evaluation);
    }

    let current_depth = thread_local_depth_get();
    if current_depth > 3 {
        return Err(format!("Maximum evaluation nesting depth of 3 exceeded (current depth: {})", current_depth));
    }
    
    let _nested_depth_guard = if current_depth > 0 {
        let child_ctx = crate::cross_cutting::context::CLMContext::current().with_nested_exec(true);
        Some(child_ctx.enter_scope())
    } else {
        None
    };

    // 1. Verify integrity of clmEval.yaml
    verify::verify_integrity(clm_root)?;

    // 2. Compile cache if needed
    cli::compile_evaluator_cache(clm_root, quiet)?;

    // 3. Try internal Rust dispatch before waking up the daemon or extracting bootstrap script
    if let Some(file) = clm_file {
        match dispatch::try_internal_dispatch(clm_root, file, payload, post_rc, quiet) {
            Ok(exit_code) => return Ok(exit_code),
            Err(e) if e.contains("SovereignSubprocessForbiddenError") => return Err(e),
            Err(_) => {}
        }
    }

    // Enforce zero-fork process policy before falling through to bootstrap bash subprocess
    crate::cross_cutting::context::CLMContext::check_current_process_policy(
        &crate::fs_utils::get_bash_command(),
        &[clm_file.unwrap_or("clmEval").to_string()],
    )
    .map_err(|e| e.to_string())?;

    // 4. Extract the bootstrap payload script (only for legacy non-internal fallback)
    let shell_script_raw = cli::extract_bootstrap_script(clm_root)?;
    let shell_script = shell_script_raw.replace("\r", "");

    let mut remaining_args = Vec::new();
    if let Some(file) = clm_file {
        remaining_args.push(file.to_string());
    }
    if let Some(pay) = payload {
        remaining_args.push(pay.to_string());
    }
    if let Some(rc) = post_rc {
        remaining_args.push(rc.to_string());
    }

    // 5. Handle Swappable Parity Engine (Daemon startup)
    let mut daemon_child: Option<Child> = None;
    let mut rust_port_file = None;
    let mut daemon_port = None;

    if crate::cross_cutting::context::CLMContext::get_scoped_or_env("CLM_RUNTIME_BACKEND").as_deref() == Some("rust")
        && crate::cross_cutting::context::CLMContext::get_scoped_or_env("CLM_NESTED_EXEC").as_deref() != Some("1")
        && crate::cross_cutting::context::CLMContext::get_scoped_or_env("CLM_RUST_DAEMON_PORT").is_none()
    {
        if !quiet {
            eprintln!("[clmEval-rs] Waking up Swappable Parity Engine (Rust Core)...");
        }
        let mut self_exe = env::current_exe().map_err(|e| format!("Failed to get current exe: {}", e))?;
        if self_exe.to_string_lossy().contains("deps") {
            let alt_exe = 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() {
                self_exe = alt_exe;
            } else {
                let alt_exe_release = 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() {
                    self_exe = alt_exe_release;
                }
            }
        }
        let pid = std::process::id();
        let unique_id = if let Some(id) = instance_id {
            format!("{}_{}", pid, id)
        } else {
            use std::sync::atomic::{AtomicUsize, Ordering};
            static COUNTER: AtomicUsize = AtomicUsize::new(0);
            let count = COUNTER.fetch_add(1, Ordering::SeqCst);
            format!("{}_{}", pid, count)
        };
        let port_file_path = clm_root.join(format!("data/ipc/rust_daemon.port.{}", unique_id));
        if port_file_path.exists() {
            let _ = fs::remove_file(&port_file_path);
        }
        let _ = fs::create_dir_all(clm_root.join("data/ipc"));

        let log_file_path = clm_root.join(format!("data/ipc/rust_daemon.log.{}", unique_id));
        let log_file = fs::File::create(&log_file_path)
            .map_err(|e| format!("Failed to create daemon log file: {}", e))?;

        let mut daemon_cmd = Command::new(self_exe);
        daemon_cmd.current_dir(clm_root);
        daemon_cmd.arg("daemon")
            .arg("--port")
            .arg("0")
            .env("CLM_RUST_PORT_FILE", &port_file_path)
            .stdout(Stdio::from(log_file.try_clone().unwrap()))
            .stderr(Stdio::from(log_file));
        daemon_cmd.env_remove("CLM_MOCK_LLM_BEHAVIOR");
        daemon_cmd.env_remove("CLM_MOCK_OI_BEHAVIOR");
        daemon_cmd.env_remove("CLM_MOCK_COMPILER_BEHAVIOR");
            
        let snap_dir = if let Some(id) = instance_id {
            std::env::temp_dir().join(id).to_string_lossy().replace('\\', "/")
        } else {
            std::env::temp_dir().join(format!("clm_daemon_{}", pid)).to_string_lossy().replace('\\', "/")
        };
        
        let _ = fs::remove_dir_all(&snap_dir);
        let _ = fs::create_dir_all(&snap_dir);

        daemon_cmd.env("CLM_MEMBROKER_SNAP_DIR", &snap_dir);

        let mut child = daemon_cmd.spawn()
            .map_err(|e| format!("Failed to spawn daemon process: {}", e))?;

        let mut timeout = 20;
        while !port_file_path.exists() && timeout > 0 {
            std::thread::sleep(std::time::Duration::from_millis(100));
            timeout -= 1;
        }

        if !port_file_path.exists() {
            if !quiet {
                eprintln!("[clmEval-rs] ⚠️ Daemon failed to start. Falling back to standard CLI mode.");
            }
            let _ = child.kill();
        } else {
            let port_str = fs::read_to_string(&port_file_path)
                .map_err(|e| format!("Failed to read port file: {}", e))?;
            let port = port_str.trim().to_string();
            daemon_port = Some(port);
            rust_port_file = Some(port_file_path);
            daemon_child = Some(child);
        }
    }

    // 6. Set up the bash evaluation command (legacy fallback)
    let runner_script_path = {
        let temp_dir = std::env::var("TMPDIR").map(std::path::PathBuf::from).unwrap_or_else(|_| std::env::temp_dir());
        let _ = fs::create_dir_all(&temp_dir);
        let path = temp_dir.join(format!("bootstrap_runner_{}.sh", std::process::id()));
        let _ = fs::write(&path, &shell_script);
        path
    };

    let mut cmd = Command::new(crate::fs_utils::get_bash_command());
    cmd.current_dir(clm_root);
    #[cfg(windows)]
    {
        let script_arg = runner_script_path.to_string_lossy().replace('\\', "/");
        cmd.arg(&script_arg);
    }
    #[cfg(not(windows))]
    {
        cmd.arg("-c");
        cmd.arg(&shell_script);
        cmd.arg("clmEval");
    }
    for arg in &remaining_args {
        cmd.arg(arg);
    }

    for (key, val) in env::vars() {
        cmd.env(key, val);
    }
    
    if let Some(port) = &daemon_port {
        cmd.env("CLM_RUST_DAEMON_PORT", port);
    }
    if let Some(port_file) = &rust_port_file {
        cmd.env("CLM_RUST_PORT_FILE", port_file);
    }
    cmd.env("CLM_ROOT", clm_root);
    if let Some(proj_root) = clm_root.parent() {
        cmd.env("PROJECT_ROOT", proj_root);
    } else {
        cmd.env("PROJECT_ROOT", clm_root);
    }
    cmd.env("SELF", "clmEval");

    if quiet {
        cmd.env("CLM_QUIET", "true");
    }

    let snap_dir = if let Some(id) = instance_id {
        format!("/tmp/{}", id)
    } else if let Ok(existing) = env::var("CLM_MEMBROKER_SNAP_DIR") {
        existing
    } else {
        format!("/tmp/clm_daemon_{}", std::process::id())
    };
    cmd.env("CLM_MEMBROKER_SNAP_DIR", &snap_dir);

    // 7. Execute subshell with stdout/stderr handling
    let exit_status = if quiet {
        let mut child = cmd
            .stdout(Stdio::piped())
            .stderr(Stdio::null())
            .spawn()
            .map_err(|e| format!("Failed to spawn bash: {}", e))?;

        let stdout = child.stdout.take().ok_or("Failed to open stdout")?;
        let reader = BufReader::new(stdout);
        let quiet_filter = regex::Regex::new(
            r"^(?:\[clmEval\]|\[VERIFY\]|\[VCARD POST\]|PASS: |\[TYPE_REG\]|\[POST\]|━+$|[[:space:]]*clmEval[[:space:]]+—|[[:space:]]*Evaluating:)"
        ).unwrap();

        for line_res in reader.lines() {
            if let Ok(line) = line_res
                && !quiet_filter.is_match(&line) {
                    println!("{}", line);
                }
        }
        child.wait().map_err(|e| format!("Failed to wait for bash: {}", e))?
    } else {
        cmd.stdout(Stdio::inherit())
           .stderr(Stdio::inherit())
           .status()
           .map_err(|e| format!("Failed to execute bash: {}", e))?
     };

    let exit_code = exit_status.code().unwrap_or(1);
    let _ = fs::remove_file(&runner_script_path);

    // 8. Clean up daemon if we started it
    if let Some(mut child) = daemon_child {
        if let Some(ref port) = daemon_port
            && let Ok(mut stream) = std::net::TcpStream::connect(format!("127.0.0.1:{}", port)) {
                let _ = stream.write_all(b"RSTQ\tshutdown\t0\n");
                let _ = stream.flush();
            }
        let _ = child.kill();
        let _ = child.wait();

        if let Some(ref path) = rust_port_file {
            let _ = fs::remove_file(path);
        }
        let pid = std::process::id();
        let log_file_path = clm_root.join(format!("data/ipc/rust_daemon.log.{}", pid));
        let _ = fs::remove_file(&log_file_path);

        let snap_dir = if let Some(id) = instance_id {
            format!("/tmp/{}", id)
        } else {
            format!("/tmp/clm_daemon_{}", pid)
        };
        let _ = fs::remove_dir_all(&snap_dir);
    }

    Ok(exit_code)
}