clm-kernel 0.0.8

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

pub(super) fn run_logic_part3(command: Commands, clm_root: &str, mut stdout: String, mut stderr: String) -> (i32, String, String) {
    match command {
        Commands::SubstrateRead { uri, hash } => {
            let adapter = match clm_rust_core::substrate::parse_adapter(&uri) {
                Ok(a) => a,
                Err(e) => {
                    stderr.push_str(&format!("[SUBSTRATE ERROR] {}\n", e));
                    return (1, stdout, stderr);
                }
            };
            match adapter.read_by_hash(&hash) {
                Ok(bytes) => {
                    let content = String::from_utf8_lossy(&bytes);
                    stdout.push_str(&format!("[SUBSTRATE READ] Hash {} from {}:\n{}\n", hash, uri, content));
                    (0, stdout, stderr)
                }
                Err(e) => {
                    stderr.push_str(&format!("[SUBSTRATE READ ERROR] {}\n", e));
                    (1, stdout, stderr)
                }
            }
        }
        Commands::SubstrateList { uri } => {
            let adapter = match clm_rust_core::substrate::parse_adapter(&uri) {
                Ok(a) => a,
                Err(e) => {
                    stderr.push_str(&format!("[SUBSTRATE ERROR] {}\n", e));
                    return (1, stdout, stderr);
                }
            };
            match adapter.list_hashes() {
                Ok(hashes) => {
                    stdout.push_str(&format!("[SUBSTRATE LIST] Found {} hashes in {}:\n", hashes.len(), uri));
                    for h in &hashes {
                        stdout.push_str(&format!("  - {}\n", h));
                    }
                    (0, stdout, stderr)
                }
                Err(e) => {
                    stderr.push_str(&format!("[SUBSTRATE LIST ERROR] {}\n", e));
                    (1, stdout, stderr)
                }
            }
        }
        Commands::SubstrateMigrate { from, to, hash } => {
            let src_adapter = match clm_rust_core::substrate::parse_adapter(&from) {
                Ok(a) => a,
                Err(e) => {
                    stderr.push_str(&format!("[SUBSTRATE ERROR] Source: {}\n", e));
                    return (1, stdout, stderr);
                }
            };
            let dst_adapter = match clm_rust_core::substrate::parse_adapter(&to) {
                Ok(a) => a,
                Err(e) => {
                    stderr.push_str(&format!("[SUBSTRATE ERROR] Target: {}\n", e));
                    return (1, stdout, stderr);
                }
            };

            match clm_rust_core::substrate::migrate_mcard(src_adapter.as_ref(), dst_adapter.as_ref(), &hash) {
                Ok(vcard) => {
                    stdout.push_str(&format!("[SUBSTRATE MIGRATE] Migrated hash {} from {} -> {}\n[SUBSTRATE PINNED VCARD] vcard_hash: {}\n", hash, from, to, vcard.vcard_hash));
                    (0, stdout, stderr)
                }
                Err(e) => {
                    stderr.push_str(&format!("[SUBSTRATE MIGRATE ERROR] {}\n", e));
                    (1, stdout, stderr)
                }
            }
        }
        Commands::ObsConfig { tempo, loki, mimir, sampling_rate, db } => {
            match clm_rust_core::observability::configure_observability(&db, Some(clm_root), &tempo, &loki, &mimir, Some(sampling_rate)) {
                Ok(cfg) => {
                    stdout.push_str(&format!("[OBS CONFIG] Configured observability telemetry in {}\n  Tempo: {}\n  Loki: {}\n  Mimir: {}\n  Sampling Rate: {}\n  Handle: {}\n", db, cfg.tempo_endpoint, cfg.loki_endpoint, cfg.mimir_endpoint, cfg.sampling_rate, cfg.handle));
                    (0, stdout, stderr)
                }
                Err(e) => {
                    stderr.push_str(&format!("[OBS CONFIG ERROR] {}\n", e));
                    (1, stdout, stderr)
                }
            }
        }
        Commands::ObsTraceEmit { trace_id, span_id, parent_span_id, pcard, vcard_hash, duration_ms, db } => {
            match clm_rust_core::observability::emit_trace_span(&db, Some(clm_root), &trace_id, &span_id, parent_span_id.as_deref(), &pcard, &vcard_hash, duration_ms) {
                Ok(tr) => {
                    stdout.push_str(&format!("[OBS TRACE EMIT] Emitted trace span {} ({}) in {}\n  PCard: {}\n  VCard Hash: {}\n  Duration: {}ms\n  Handle: {}\n", tr.trace_id, tr.span_id, db, tr.pcard_handle, tr.vcard_hash, tr.duration_ms, tr.handle));
                    (0, stdout, stderr)
                }
                Err(e) => {
                    stderr.push_str(&format!("[OBS TRACE EMIT ERROR] {}\n", e));
                    (1, stdout, stderr)
                }
            }
        }
        Commands::ObsMetricRecord { metric_name, value, labels, db } => {
            match clm_rust_core::observability::record_metric(&db, Some(clm_root), &metric_name, value, labels.as_deref()) {
                Ok(m) => {
                    stdout.push_str(&format!("[OBS METRIC RECORD] Recorded metric {} = {} in {}\n  Labels: {}\n  Handle: {}\n", m.metric_name, m.value, db, m.labels, m.handle));
                    (0, stdout, stderr)
                }
                Err(e) => {
                    stderr.push_str(&format!("[OBS METRIC RECORD ERROR] {}\n", e));
                    (1, stdout, stderr)
                }
            }
        }
        Commands::ObsLogEmit { trace_id, level, vcard_hash, eoa_did, message, db } => {
            match clm_rust_core::observability::emit_structured_log(&db, Some(clm_root), &trace_id, &level, &vcard_hash, &eoa_did, &message) {
                Ok(l) => {
                    stdout.push_str(&format!("[OBS LOG EMIT] Emitted {} log for trace {} in {}\n  Log ID: {}\n  EOA DID: {}\n  VCard Hash: {}\n  Message: {}\n", l.level, l.trace_id, db, l.log_id, l.eoa_did, l.vcard_hash, l.message));
                    (0, stdout, stderr)
                }
                Err(e) => {
                    stderr.push_str(&format!("[OBS LOG EMIT ERROR] {}\n", e));
                    (1, stdout, stderr)
                }
            }
        }
        Commands::ObsTraceGet { trace_id, db } => {
            match clm_rust_core::observability::get_trace(&db, Some(clm_root), &trace_id) {
                Ok(tr) => {
                    stdout.push_str(&format!("[OBS TRACE GET] Found trace span {}\n  PCard: {}\n  VCard Hash: {}\n  Duration: {}ms\n", tr.trace_id, tr.pcard_handle, tr.vcard_hash, tr.duration_ms));
                    (0, stdout, stderr)
                }
                Err(e) => {
                    stderr.push_str(&format!("[OBS TRACE GET ERROR] {}\n", e));
                    (1, stdout, stderr)
                }
            }
        }
        Commands::ObsMetricGet { metric_name, db } => {
            match clm_rust_core::observability::get_metric(&db, Some(clm_root), &metric_name) {
                Ok(m) => {
                    stdout.push_str(&format!("[OBS METRIC GET] Found metric {} = {}\n  Labels: {}\n", m.metric_name, m.value, m.labels));
                    (0, stdout, stderr)
                }
                Err(e) => {
                    stderr.push_str(&format!("[OBS METRIC GET ERROR] {}\n", e));
                    (1, stdout, stderr)
                }
            }
        }
        Commands::BackupCreate { tier, output_dir, db } => {
            match clm_rust_core::backup::create_backup_snapshot(&db, Some(clm_root), &tier, &output_dir) {
                Ok(snap) => {
                    stdout.push_str(&format!("[BACKUP CREATE] Created {} snapshot {} in {}\n  Card Count: {}\n  Merkle DAG Root: {}\n  Handle: {}\n", snap.tier, snap.snapshot_id, output_dir, snap.card_count, snap.merkle_dag_root, snap.handle));
                    (0, stdout, stderr)
                }
                Err(e) => {
                    stderr.push_str(&format!("[BACKUP CREATE ERROR] {}\n", e));
                    (1, stdout, stderr)
                }
            }
        }
        Commands::BackupRestore { snapshot_id, input_dir, db } => {
            match clm_rust_core::backup::restore_backup_snapshot(&db, Some(clm_root), &snapshot_id, &input_dir) {
                Ok(rec) => {
                    stdout.push_str(&format!("[BACKUP RESTORE] ✅ Restored snapshot {} in {}\n  Cards Restored: {}\n  Verification Verdict: {}\n  Handle: {}\n", rec.snapshot_id, db, rec.cards_restored, rec.verification_verdict, rec.handle));
                    (0, stdout, stderr)
                }
                Err(e) => {
                    stderr.push_str(&format!("[BACKUP RESTORE ERROR] {}\n", e));
                    (1, stdout, stderr)
                }
            }
        }
        Commands::BackupVerify { snapshot_id, db } => {
            match clm_rust_core::backup::verify_backup_snapshot(&db, Some(clm_root), &snapshot_id) {
                Ok(is_valid) => {
                    if is_valid {
                        stdout.push_str(&format!("[BACKUP VERIFY] ✅ Snapshot {} restore integrity verified\n", snapshot_id));
                        (0, stdout, stderr)
                    } else {
                        stdout.push_str(&format!("[BACKUP VERIFY] ❌ Snapshot {} restore verification failed\n", snapshot_id));
                        (1, stdout, stderr)
                    }
                }
                Err(e) => {
                    stderr.push_str(&format!("[BACKUP VERIFY ERROR] {}\n", e));
                    (1, stdout, stderr)
                }
            }
        }
        Commands::BackupShardGenerate { did, secret, guardians, threshold, db } => {
            match clm_rust_core::backup::generate_recovery_shards(&db, Some(clm_root), &did, &secret, guardians, threshold) {
                Ok(rec) => {
                    stdout.push_str(&format!("[BACKUP SHARD GENERATE] Generated {} recovery shards ({}/{} threshold) for {}\n  Handle: {}\n", rec.guardian_count, rec.threshold, rec.guardian_count, rec.did, rec.handle));
                    for s in &rec.shards {
                        stdout.push_str(&format!("  Shard {}: {}\n", s.index, s.value));
                    }
                    (0, stdout, stderr)
                }
                Err(e) => {
                    stderr.push_str(&format!("[BACKUP SHARD GENERATE ERROR] {}\n", e));
                    (1, stdout, stderr)
                }
            }
        }
        Commands::BackupKeyReassemble { shards } => {
            match clm_rust_core::backup::reassemble_recovery_key(&shards) {
                Ok(secret) => {
                    stdout.push_str(&format!("[BACKUP KEY REASSEMBLE] ✅ Secret key reassembled: {}\n", secret));
                    (0, stdout, stderr)
                }
                Err(e) => {
                    stderr.push_str(&format!("[BACKUP KEY REASSEMBLE ERROR] {}\n", e));
                    (1, stdout, stderr)
                }
            }
        }
        Commands::DcaMint { content_hash, owner, db } => {
            match clm_rust_core::tokens::mint_dca_nft(&db, Some(clm_root), &content_hash, &owner) {
                Ok(dca) => {
                    stdout.push_str(&format!("[DCA MINT] Minted Digital Content Asset {} (NFT: {}) for {}\n  Content Hash: {}\n  Handle: {}\n", dca.asset_id, dca.token_id, dca.owner_did, dca.content_hash, dca.handle));
                    (0, stdout, stderr)
                }
                Err(e) => {
                    stderr.push_str(&format!("[DCA MINT ERROR] {}\n", e));
                    (1, stdout, stderr)
                }
            }
        }
        Commands::NftTransfer { token_id, current_owner, new_owner, db } => {
            match clm_rust_core::tokens::transfer_nft(&db, Some(clm_root), &token_id, &current_owner, &new_owner) {
                Ok(rec) => {
                    stdout.push_str(&format!("[NFT TRANSFER] ✅ Transferred NFT {} from {} to {}\n  Handle: {}\n", rec.token_id, rec.previous_owner_did, rec.new_owner_did, rec.handle));
                    (0, stdout, stderr)
                }
                Err(e) => {
                    stderr.push_str(&format!("[NFT TRANSFER ERROR] {}\n", e));
                    (1, stdout, stderr)
                }
            }
        }
        Commands::SbtMint { recipient, role, db } => {
            match clm_rust_core::tokens::mint_soulbound_credential(&db, Some(clm_root), &recipient, &role) {
                Ok(sbt) => {
                    stdout.push_str(&format!("[SBT MINT] Minted Soulbound Credential {} ({}) for {}\n  Transferable: {}\n  Handle: {}\n", sbt.credential_id, sbt.role_name, sbt.recipient_did, sbt.is_transferable, sbt.handle));
                    (0, stdout, stderr)
                }
                Err(e) => {
                    stderr.push_str(&format!("[SBT MINT ERROR] {}\n", e));
                    (1, stdout, stderr)
                }
            }
        }
        Commands::CreditsMint { recipient, amount, db } => {
            match clm_rust_core::tokens::mint_community_credits(&db, Some(clm_root), &recipient, amount) {
                Ok(c) => {
                    stdout.push_str(&format!("[CREDITS MINT] Minted {} community credits for {}\n  New Balance: {}\n  Handle: {}\n", amount, c.did, c.balance, c.handle));
                    (0, stdout, stderr)
                }
                Err(e) => {
                    stderr.push_str(&format!("[CREDITS MINT ERROR] {}\n", e));
                    (1, stdout, stderr)
                }
            }
        }
        Commands::EditionMint { asset_id, owner, edition_no, max_editions, db } => {
            match clm_rust_core::tokens::mint_edition_token(&db, Some(clm_root), &asset_id, &owner, edition_no, max_editions) {
                Ok(ed) => {
                    stdout.push_str(&format!("[EDITION MINT] Minted Edition {} ({}/{}) for asset {} to {}\n  Handle: {}\n", ed.edition_id, ed.edition_number, ed.max_editions, ed.asset_id, ed.owner_did, ed.handle));
                    (0, stdout, stderr)
                }
                Err(e) => {
                    stderr.push_str(&format!("[EDITION MINT ERROR] {}\n", e));
                    (1, stdout, stderr)
                }
            }
        }
        Commands::Hash { algo, prefixed, file, input } => {
            let bytes: Result<Vec<u8>, String> = if let Some(path) = file {
                std::fs::read(&path).map_err(|e| format!("Failed to read file '{}': {}", path, e))
            } else if let Some(inp) = input {
                Ok(inp.into_bytes())
            } else {
                let mut buffer = Vec::new();
                match std::io::stdin().read_to_end(&mut buffer) {
                    Ok(_) => Ok(buffer),
                    Err(e) => Err(format!("Failed to read stdin: {}", e)),
                }
            };

            match bytes {
                Ok(content) => {
                    let reg = clm_rust_core::hash::global_registry().lock().unwrap();
                    let prefix = if algo.ends_with(':') { algo.clone() } else { format!("{}:", algo) };
                    if let Some(provider) = reg.get(&prefix) {
                        let raw = provider.hash(&content);
                        if prefixed {
                            stdout.push_str(&format!("{}{}\n", provider.prefix(), raw));
                        } else {
                            stdout.push_str(&format!("{}\n", raw));
                        }
                        (0, stdout, stderr)
                    } else {
                        stderr.push_str(&format!("Unknown hash algorithm: '{}'. Available: {:?}\n", algo, reg.algorithms()));
                        (1, stdout, stderr)
                    }
                }
                Err(e) => {
                    stderr.push_str(&format!("{}\n", e));
                    (1, stdout, stderr)
                }
            }
        }
        _ => (0, String::new(), String::new()),
    }
}