clm-kernel 0.0.7

Cubical Logic Model (CLM) sovereign execution engine, CPN-VM, and Cordis spatiotemporal substrate
Documentation
use std::collections::HashSet;
use std::env;
use std::path::{Path, PathBuf};
use std::sync::Arc;
use tokio::net::{TcpListener, TcpStream};
use tokio::io::AsyncWriteExt;
#[cfg(unix)]
use tokio::net::UnixStream;

use tokio::sync::Mutex;
use tokio::time::{sleep, Duration};
use futures_util::{StreamExt, SinkExt};
use tokio_tungstenite::accept_async;
use tokio_tungstenite::tungstenite::Message;
use serde::Serialize;
use serde_json::Value;
use regex::Regex;

#[derive(Clone)]
pub struct NetworkGateway {
    pub host: String,
    pub port: u16,
    pub timeout: u64,
}

#[derive(Serialize)]
struct StatusResponse<'a> {
    #[serde(rename = "type")]
    msg_type: &'static str,
    status: &'static str,
    clm: &'a str,
    payload: &'a str,
}

#[derive(Serialize)]
struct ErrorResponse<'a> {
    #[serde(rename = "type")]
    msg_type: &'static str,
    error: &'a str,
    #[serde(skip_serializing_if = "Option::is_none")]
    exit_code: Option<i32>,
}

#[allow(dead_code)]
#[derive(Serialize)]
struct LogResponse<'a> {
    #[serde(rename = "type")]
    msg_type: &'static str,
    message: &'a str,
}

#[derive(Serialize)]
struct CompletedResponse<'a> {
    #[serde(rename = "type")]
    msg_type: &'static str,
    exit_code: i32,
    #[serde(skip_serializing_if = "Option::is_none")]
    witness_hash: Option<&'a str>,
    #[serde(skip_serializing_if = "Option::is_none")]
    witness_yaml: Option<&'a str>,
    #[serde(skip_serializing_if = "Option::is_none")]
    result: Option<&'static str>,
}

type WsWriter = Arc<Mutex<futures_util::stream::SplitSink<tokio_tungstenite::WebSocketStream<TcpStream>, Message>>>;

// Response message serialization helpers
async fn send_error(writer: &WsWriter, error: &str, exit_code: Option<i32>) {
    let err_res = ErrorResponse {
        msg_type: "error",
        error,
        exit_code,
    };
    if let Ok(json_str) = serde_json::to_string(&err_res) {
        let mut writer_lock = writer.lock().await;
        let _ = writer_lock.send(Message::Text(json_str)).await;
    }
}

async fn send_status(writer: &WsWriter, status: &'static str, clm: &str, payload: &str) {
    let start_res = StatusResponse {
        msg_type: "status",
        status,
        clm,
        payload,
    };
    if let Ok(json_str) = serde_json::to_string(&start_res) {
        let mut writer_lock = writer.lock().await;
        let _ = writer_lock.send(Message::Text(json_str)).await;
    }
}

#[allow(dead_code)]
async fn send_log(writer: &WsWriter, message: &str) {
    let log_res = LogResponse {
        msg_type: "log",
        message,
    };
    if let Ok(json_str) = serde_json::to_string(&log_res) {
        let mut writer_lock = writer.lock().await;
        let _ = writer_lock.send(Message::Text(json_str)).await;
    }
}

async fn send_completed(
    writer: &WsWriter,
    exit_code: i32,
    witness_hash: Option<&str>,
    witness_yaml: Option<&str>,
    result: Option<&'static str>,
) {
    let completed_res = CompletedResponse {
        msg_type: "completed",
        exit_code,
        witness_hash,
        witness_yaml,
        result,
    };
    if let Ok(json_str) = serde_json::to_string(&completed_res) {
        let mut writer_lock = writer.lock().await;
        let _ = writer_lock.send(Message::Text(json_str)).await;
    }
}

async fn send_chat_token(writer: &WsWriter, token: &str) {
    let token_msg = serde_json::json!({
        "type": "chat_token",
        "token": token
    }).to_string();
    let mut writer_lock = writer.lock().await;
    let _ = writer_lock.send(Message::Text(token_msg)).await;
}

impl Default for NetworkGateway {
    fn default() -> Self {
        Self::new()
    }
}

impl NetworkGateway {
    pub fn new() -> Self {
        let payload = crate::cross_cutting::context::CLMContext::get_scoped_or_env("CLM_PAYLOAD").unwrap_or_default();
        let mut host = "127.0.0.1".to_string();
        let mut port = 8080;
        let mut timeout = 30000;

        if !payload.is_empty() {
            if let Ok(host_re) = Regex::new(r"host=([^\s]+)")
                && let Some(caps) = host_re.captures(&payload)
                    && let Some(m) = caps.get(1) {
                        host = m.as_str().to_string();
                    }
            if let Ok(port_re) = Regex::new(r"port=(\d+)")
                && let Some(caps) = port_re.captures(&payload)
                    && let Some(m) = caps.get(1)
                        && let Ok(p) = m.as_str().parse::<u16>() {
                            port = p;
                        }
            if let Ok(timeout_re) = Regex::new(r"timeout=(\d+)")
                && let Some(caps) = timeout_re.captures(&payload)
                    && let Some(m) = caps.get(1)
                        && let Ok(t) = m.as_str().parse::<u64>() {
                            timeout = t;
                        }
        }

        Self { host, port, timeout }
    }

    pub async fn start(&self) -> Result<(), String> {
        let addr = format!("{}:{}", self.host, self.port);
        let listener = TcpListener::bind(&addr).await
            .map_err(|e| format!("Failed to bind to {}: {}", addr, e))?;

        println!("[GATEWAY] WebSocket Gateway server listening on ws://{}", addr);

        let active_connections = Arc::new(Mutex::new(HashSet::new()));
        let shutdown_trigger = Arc::new(tokio::sync::Notify::new());

        // Spawn timeout clean sweep
        let _active_connections_clone = Arc::clone(&active_connections);
        let shutdown_trigger_clone = Arc::clone(&shutdown_trigger);
        let timeout_duration = self.timeout;
        tokio::spawn(async move {
            sleep(Duration::from_millis(timeout_duration)).await;
            println!("[GATEWAY] Reached timeout of {}ms. Shutting down.", timeout_duration);
            shutdown_trigger_clone.notify_one();
        });

        loop {
            tokio::select! {
                _ = shutdown_trigger.notified() => {
                    break;
                }
                accept_res = listener.accept() => {
                    match accept_res {
                        Ok((stream, _)) => {
                            let active_connections = Arc::clone(&active_connections);
                            let shutdown_trigger = Arc::clone(&shutdown_trigger);
                            tokio::spawn(async move {
                                if let Err(e) = handle_connection(stream, active_connections, shutdown_trigger).await {
                                    eprintln!("[GATEWAY] Error handling connection: {}", e);
                                }
                            });
                        }
                        Err(e) => {
                            eprintln!("[GATEWAY] Failed to accept connection: {}", e);
                        }
                    }
                }
            }
        }

        // Graceful exit
        Ok(())
    }
}

async fn execute_ollama(
    query_text: &str,
    json_msg: &Option<Value>,
    writer: &WsWriter,
) -> Result<(), String> {
    println!("[GATEWAY] Entering Ollama fallback logic...");
    let selected_model = json_msg.as_ref()
        .and_then(|v| v.get("model").and_then(|m| m.as_str()))
        .unwrap_or("gemma4:latest");
    let ollama_url = env::var("OLLAMA_URL").unwrap_or_else(|_| "http://127.0.0.1:11434".to_string());
    
    let ollama_host;
    let mut ollama_port = 11434;

    // Parse basic host/port
    let temp = ollama_url.trim_start_matches("http://").trim_start_matches("https://");
    let temp = temp.split('/').next().unwrap_or(temp);
    if let Some(idx) = temp.find(':') {
        ollama_host = temp[..idx].to_string();
        if let Ok(p) = temp[idx + 1..].parse::<u16>() {
            ollama_port = p;
        }
    } else {
        ollama_host = temp.to_string();
    }

    let mut system_content = "You are a friendly and helpful AI math assistant inside the GASING (Gampang, Asyik, Menyenangkan) interactive learning game. Keep your answers brief, encouraging, and clear for kids.".to_string();
    if let Some(val) = json_msg
        && let Some(game_id) = val.get("gameId").and_then(|g| g.as_str()) {
            system_content.push_str(&format!("\nCurrent Game context:\n- Game ID: {}\n- Round: {}", game_id, val.get("round").and_then(|r| r.as_u64()).unwrap_or(1)));
            if let Some(q) = val.get("question").and_then(|q| q.as_str()) {
                system_content.push_str(&format!("\n- Current Problem: {}", q));
            }
            if let Some(exp) = val.get("gasingExplanation").and_then(|e| e.as_str()) {
                system_content.push_str(&format!("\n- GASING Methodology/Explanation: {}", exp));
            }
        }

    let post_data = serde_json::json!({
        "model": selected_model,
        "messages": [
            { "role": "system", "content": system_content },
            { "role": "user", "content": query_text }
        ],
        "stream": true
    }).to_string();

    // Send status
    send_status(writer, "started", &format!("Ollama ({})", selected_model), query_text).await;

    match TcpStream::connect(format!("{}:{}", ollama_host, ollama_port)).await {
        Ok(mut tcp_stream) => {
            let request_headers = format!(
                "POST /api/chat HTTP/1.1\r\n\
                 Host: {}:{}\r\n\
                 Content-Type: application/json\r\n\
                 Content-Length: {}\r\n\
                 Connection: close\r\n\r\n{}",
                ollama_host, ollama_port, post_data.len(), post_data
            );
            if tcp_stream.write_all(request_headers.as_bytes()).await.is_ok() {
                let mut reader = tokio::io::BufReader::new(tcp_stream);
                let mut line = String::new();
                use tokio::io::AsyncBufReadExt;
                
                // Skip HTTP response headers
                loop {
                    line.clear();
                    if reader.read_line(&mut line).await.unwrap_or(0) == 0 {
                        break;
                    }
                    if line.trim().is_empty() {
                        break;
                    }
                }

                // Read HTTP body line by line
                loop {
                    line.clear();
                    if reader.read_line(&mut line).await.unwrap_or(0) == 0 {
                        break;
                    }
                    let trimmed = line.trim();
                    if trimmed.is_empty() {
                        continue;
                    }
                    if let Ok(parsed) = serde_json::from_str::<Value>(trimmed)
                        && let Some(token) = parsed.get("message").and_then(|m| m.get("content")).and_then(|c| c.as_str()) {
                            send_chat_token(writer, token).await;
                        }
                }
            }
            send_completed(writer, 0, None, None, None).await;
        }
        Err(err) => {
            send_error(writer, &format!("Ollama is offline or model could not be loaded. Error: {}", err), None).await;
        }
    }
    Ok(())
}


#[path = "network_gateway_handlers.rs"]
mod network_gateway_handlers;
#[allow(unused_imports)]
pub use network_gateway_handlers::*;