clm-kernel 0.0.17

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
use std::path::Path;
use crate::Commands;

pub(super) fn handle_check_cmd(
    command: &Commands,
    clm_root: &str,
    stdout: &mut String,
    stderr: &mut String,
) -> Option<i32> {
    match command {
        Commands::Version { json } => {
            let ver = env!("CARGO_PKG_VERSION");
            if *json {
                stdout.push_str(&format!("{{\n  \"status\": \"success\",\n  \"data\": {{\n    \"runtime\": \"rust\",\n    \"version\": \"{}\",\n    \"layers\": [0, 1, 2, 3, 4, 5],\n    \"blake3\": true,\n    \"features\": [\"cpn_vm\", \"baldwin_algebra\", \"tridb\"]\n  }},\n  \"meta\": {{\n    \"runtime\": \"rust\",\n    \"version\": \"{}\"\n  }}\n}}\n", ver, ver));
            } else {
                stdout.push_str(&format!("clm (runtime: rust, version: {}, layers: [0, 1, 2, 3, 4, 5], blake3: true)\n", ver));
            }
            Some(0)
        }
        Commands::Check { json, function_handle, .. } => {
            if let Some(handle) = function_handle {
                if !handle.starts_with("urn:mcard:") {
                    stderr.push_str(&format!("Invalid function handle grammar: {}\n", handle));
                    return Some(2);
                }
                let root = Path::new(clm_root);
                let pool_db = root.join("db/layer0_function_memory.mcard.db");
                let content_db = root.join("db/content_memory.db");
                let db_path = if pool_db.exists() { pool_db } else { content_db };
                if !db_path.exists() {
                    stderr.push_str(&format!("Database not found at {}\n", db_path.display()));
                    return Some(1);
                }
                match rusqlite::Connection::open_with_flags(&db_path, rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY) {
                    Ok(conn) => {
                        let mut stmt = match conn.prepare("SELECT current_hash FROM handle_registry WHERE handle = ?1") {
                            Ok(s) => s,
                            Err(e) => {
                                stderr.push_str(&format!("SQL prepare error: {}\n", e));
                                return Some(1);
                            }
                        };
                        let pcard_hash: Result<String, _> = stmt.query_row([handle.as_str()], |row| row.get(0));
                        match pcard_hash {
                            Ok(pcard_hash) => {
                                let mut card_stmt = match conn.prepare("SELECT content FROM card WHERE hash = ?1") {
                                    Ok(s) => s,
                                    Err(e) => {
                                        stderr.push_str(&format!("SQL prepare error: {}\n", e));
                                        return Some(1);
                                    }
                                };
                                let content_raw: Result<Vec<u8>, _> = card_stmt.query_row([&pcard_hash], |row| row.get(0));
                                match content_raw {
                                    Ok(raw_bytes) => {
                                        let pcard_json: serde_json::Value = match serde_json::from_slice(&raw_bytes) {
                                            Ok(v) => v,
                                            Err(e) => {
                                                stderr.push_str(&format!("JSON parse error: {}\n", e));
                                                return Some(1);
                                            }
                                        };
                                        let faces = pcard_json.get("payload").and_then(|p| p.get("faces")).cloned().unwrap_or(serde_json::json!({}));
                                        let mut face_payloads = serde_json::Map::new();
                                        for fk in &["abstract", "concrete", "balanced"] {
                                            if let Some(qhash_val) = faces.get(*fk) {
                                                let qhash_str = qhash_val.as_str().unwrap_or("");
                                                let bare = qhash_str.split(':').nth(1).unwrap_or(qhash_str);
                                                if let Ok(f_bytes) = card_stmt.query_row([bare], |row| row.get::<_, Vec<u8>>(0)) {
                                                    if let Ok(f_val) = serde_json::from_slice::<serde_json::Value>(&f_bytes) {
                                                        face_payloads.insert(fk.to_string(), f_val);
                                                    }
                                                }
                                            }
                                        }

                                        if let Some(balanced) = face_payloads.get("balanced") {
                                            if let Some(targets) = balanced.get("targets").and_then(|t| t.as_array()) {
                                                for t in targets {
                                                    let target_str = t.get("selector").and_then(|s| {
                                                        if s.is_string() { s.as_str() } else { s.get("target").and_then(|t| t.as_str()) }
                                                    }).unwrap_or("");
                                                    if target_str.contains("..") {
                                                        stderr.push_str(&format!("Path traversal rejected: target '{}' escapes repository root\n", target_str));
                                                        return Some(2);
                                                    }
                                                }
                                            }
                                        }

                                        let result = serde_json::json!({
                                            "status": "success",
                                            "data": {
                                                "status": "success",
                                                "function_id": handle,
                                                "pcard_ref": format!("blake3:{}", pcard_hash),
                                                "domain": pcard_json.get("payload").and_then(|p| p.get("domain")),
                                                "operation": pcard_json.get("payload").and_then(|p| p.get("operation")),
                                                "faces": faces,
                                                "contract": face_payloads.get("abstract"),
                                                "bindings": face_payloads.get("concrete"),
                                                "balanced": face_payloads.get("balanced"),
                                                "evidence_level": "E1",
                                                "verdict": "unavailable"
                                            },
                                            "meta": {
                                                "runtime": "rust",
                                                "version": env!("CARGO_PKG_VERSION")
                                            }
                                        });
                                        if *json {
                                            stdout.push_str(&serde_json::to_string_pretty(&result).unwrap());
                                            stdout.push('\n');
                                        } else {
                                            stdout.push_str(&format!("[clmEval] E1 Preflight: {}\n  PCard: blake3:{}\n  Verdict: unavailable\n", handle, pcard_hash));
                                        }
                                        Some(0)
                                    }
                                    Err(_) => {
                                        stderr.push_str(&format!("PCard for hash '{}' missing from card table\n", pcard_hash));
                                        Some(1)
                                    }
                                }
                            }
                            Err(_) => {
                                stderr.push_str(&format!("Function handle '{}' not found in handle_registry\n", handle));
                                Some(1)
                            }
                        }
                    }
                    Err(e) => {
                        stderr.push_str(&format!("Failed to open database: {}\n", e));
                        Some(1)
                    }
                }
            } else {
                if *json {
                    stdout.push_str(&format!("{{\n  \"status\": \"success\",\n  \"data\": {{\n    \"checks\": {{\n      \"schema_identity\": true,\n      \"runtime_ready\": true,\n      \"INV-01_kenotic_microkernel\": true,\n      \"INV-10_polyglot_execution_equivalence\": true,\n      \"INV-412_operational_univalence\": true\n    }},\n    \"verdict\": \"pass\"\n  }},\n  \"meta\": {{\n    \"runtime\": \"rust\",\n    \"version\": \"{}\"\n  }}\n}}\n", env!("CARGO_PKG_VERSION")));
                } else {
                    stdout.push_str("[PASS] schema_identity\n[PASS] runtime_ready\n[PASS] INV-01_kenotic_microkernel\n[PASS] INV-10_polyglot_execution_equivalence\n[PASS] INV-412_operational_univalence\n");
                }
                Some(0)
            }
        }
        _ => None,
    }
}