use clm_rust_core::layer0::vocabulary::{HASH_PREFIX_BLAKE3};
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(clm_rust_core::layer0::vocabulary::URI_SCHEME_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!("{HASH_PREFIX_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,
}
}