ultron-kernel 1.0.0

Supervisor for Ultron's persistent Python kernel (runtime.py): process, wire protocol, host requests
Documentation
//! A kernel given a base environment (a session's own) starts from it instead of this process's: its variables
//! (through the credential filter), its PATH, and the `ULTRON_*` settings the supervisor reads (`ULTRON_PYTHON`, the
//! resource limits).

use kernel::{HostHandler, Kernel, KernelOptions, Signal, Status};
use serde_json::{Map, Value};
use std::path::{Path, PathBuf};
use std::sync::Arc;

fn runtime() -> PathBuf {
    Path::new(env!("CARGO_MANIFEST_DIR")).join("../../packages/coding-agent/src/ultron/rlm/runtime.py")
}

fn handler() -> Arc<dyn HostHandler> {
    Arc::new(|_: &str, _: Map<String, Value>, _: &Signal| Ok(Value::Null))
}

fn options(base: &[(&str, &str)]) -> KernelOptions {
    let mut options = KernelOptions::new(env!("CARGO_MANIFEST_DIR"), runtime());
    options.base_env = Some(base.iter().map(|(k, v)| (k.to_string(), v.to_string())).collect());
    options
}

#[test]
fn kernel_w16f_base_env_replaces_the_process_environment_of_the_kernel() {
    let kernel = Kernel::new(
        options(&[
            ("PATH", "/w16f/session/bin"),
            ("W16F_SESSION_ONLY", "from-session"),
            ("W16F_API_TOKEN", "hidden"),
            (kernel::env::RLM_MAX_MEMORY_MB_ENV, "1234"),
            (kernel::env::RLM_MAX_CPU_SECONDS_ENV, "77"),
        ]),
        handler(),
    )
    .unwrap();
    // The limits are read from the base environment.
    assert_eq!(
        (kernel.limits().max_memory_mb, kernel.limits().max_cpu_seconds),
        (1234, 77)
    );
    let result = kernel
        .execute(
            "import os\n(os.environ.get('PATH'), os.environ.get('W16F_SESSION_ONLY'), 'W16F_API_TOKEN' in os.environ, \
             os.environ.get('CARGO_MANIFEST_DIR'), os.environ['ULTRON_RLM_MAX_MEMORY_MB'], os.environ.get('ULTRON_IN_KERNEL'))",
            None,
            None,
        )
        .unwrap();
    assert_eq!(result.status, Status::Ok, "{result:?}");
    // CARGO_MANIFEST_DIR is in this process's environment (cargo sets it for tests), never in the kernel's.
    assert_eq!(
        result.result.as_deref(),
        Some("('/w16f/session/bin', 'from-session', False, None, '1234', '1')")
    );
    kernel.shutdown();
}

#[test]
fn kernel_w16f_the_interpreter_comes_from_the_base_envs_ultron_python() {
    let kernel = Kernel::new(
        options(&[(kernel::env::PYTHON_ENV, "/w16f/missing/python3")]),
        handler(),
    )
    .unwrap();
    let error = kernel.start().unwrap_err();
    assert!(error.message().starts_with("RLM kernel spawn failed"), "{error:?}");
    kernel.shutdown();
}

/// kernel.ts's interpreter: `ULTRON_PYTHON` as given (`??`: even blank), else /usr/bin/python3 on Linux when it
/// exists, else `python3`. Loki (after `ULTRON_LOKI_PYTHON`), `ultron setup` and `autoreview doctor` use it too.
#[test]
fn kernel_env_python_is_ultron_python_else_the_system_interpreter() {
    let set = |value: &'static str| move |name: &str| (name == kernel::env::PYTHON_ENV).then(|| value.to_string());
    assert_eq!(kernel::env::python(set("/opt/py")), "/opt/py");
    assert_eq!(kernel::env::python(set("")), "");
    let fallback = if cfg!(target_os = "linux") && std::path::Path::new("/usr/bin/python3").exists() {
        "/usr/bin/python3"
    } else {
        "python3"
    };
    assert_eq!(kernel::env::python(|_| None), fallback);
}