use agentos_kernel::bridge::LifecycleState;use agentos_kernel::command_registry::CommandDriver;use agentos_kernel::kernel::{KernelVm, KernelVmConfig, SpawnOptions};use agentos_kernel::permissions::Permissions;use agentos_kernel::process_table::SIGPIPE;use agentos_kernel::pty::LineDisciplineConfig;use agentos_kernel::vfs::MemoryFileSystem;use std::time::Duration; #[test]fn minimal_vm_lifecycle_transitions_between_ready_busy_and_terminated() {    let mut config = KernelVmConfig::new("vm-kernel");    config.permissions = Permissions::allow_all();    let mut kernel = KernelVm::new(MemoryFileSystem::new(), config);    kernel        .register_driver(CommandDriver::new("shell", ["sh"]))        .expect("register shell");     assert_eq!(kernel.state(), LifecycleState::Ready);     let process = kernel        .spawn_process(            "sh",            Vec::new(),            SpawnOptions {                requester_driver: Some(String::from("shell")),                ..SpawnOptions::default()            },        )        .expect("spawn shell");    assert_eq!(kernel.state(), LifecycleState::Busy);     let (master_fd, slave_fd, path) = kernel.open_pty("shell", process.pid()).expect("open pty");    assert!(path.starts_with("/dev/pts/"));    kernel        .pty_set_discipline(            "shell",            process.pid(),            master_fd,            LineDisciplineConfig {                canonical: Some(false),                echo: Some(false),                isig: Some(false),                ..Default::default()            },        )        .expect("set raw mode");     kernel        .fd_write("shell", process.pid(), master_fd, b"kernel-ready")        .expect("write PTY input");    let data = kernel        .fd_read("shell", process.pid(), slave_fd, 64)        .expect("read PTY slave");    assert_eq!(String::from_utf8(data).expect("valid utf8"), "kernel-ready");     process.finish(0);    let (_, exit_code) = kernel.wait_and_reap(process.pid()).expect("reap shell");    assert_eq!(exit_code, 0);    assert_eq!(kernel.state(), LifecycleState::Ready);    assert_eq!(kernel.resource_snapshot().fd_tables, 0);    assert_eq!(kernel.resource_snapshot().open_fds, 0);     kernel.dispose().expect("dispose kernel");    assert_eq!(kernel.state(), LifecycleState::Terminated);} #[test]fn raw_mode_recovery_lease_is_limited_to_foreground_process_group() {    let mut config = KernelVmConfig::new("vm-pty-raw-owner");    config.permissions = Permissions::allow_all();    let mut kernel = KernelVm::new(MemoryFileSystem::new(), config);    kernel        .register_driver(CommandDriver::new("shell", ["sh"]))        .expect("register shell");     let shell = kernel        .spawn_process(            "sh",            Vec::new(),            SpawnOptions {                requester_driver: Some(String::from("shell")),                ..SpawnOptions::default()            },        )        .expect("spawn shell");    let (master_fd, slave_fd, _) = kernel        .open_pty("shell", shell.pid())        .expect("open controlling pty");    kernel        .fd_dup2("shell", shell.pid(), slave_fd, 0)        .expect("install shell stdin");    kernel        .pty_set_foreground_pgid("shell", shell.pid(), master_fd, shell.pid())        .expect("make shell group foreground");     let foreground_child = kernel        .spawn_process(            "sh",            Vec::new(),            SpawnOptions {                requester_driver: Some(String::from("shell")),                parent_pid: Some(shell.pid()),                ..SpawnOptions::default()            },        )        .expect("spawn foreground child");    assert!(kernel        .pty_set_raw_mode("shell", foreground_child.pid(), 0, true)        .expect("foreground raw mode")        .is_some());     let background_child = kernel        .spawn_process(            "sh",            Vec::new(),            SpawnOptions {                requester_driver: Some(String::from("shell")),                parent_pid: Some(shell.pid()),                ..SpawnOptions::default()            },        )        .expect("spawn background child");    kernel        .setpgid("shell", background_child.pid(), background_child.pid())        .expect("move child into background process group");    assert_eq!(        kernel            .pty_set_raw_mode("shell", background_child.pid(), 0, true)            .expect("background raw mode"),        None,        "background process must not own foreground recovery"    );} #[test]fn dispose_kills_running_processes_and_cleans_special_resources() {    let mut config = KernelVmConfig::new("vm-dispose");    config.permissions = Permissions::allow_all();    let mut kernel = KernelVm::new(MemoryFileSystem::new(), config);    kernel        .register_driver(CommandDriver::new("shell", ["sh"]))        .expect("register shell");     let process = kernel        .spawn_process(            "sh",            Vec::new(),            SpawnOptions {                requester_driver: Some(String::from("shell")),                ..SpawnOptions::default()            },        )        .expect("spawn shell");    let _ = kernel.open_pipe("shell", process.pid()).expect("open pipe");    let _ = kernel.open_pty("shell", process.pid()).expect("open pty");     kernel.dispose().expect("dispose kernel");    assert_eq!(kernel.state(), LifecycleState::Terminated);    assert_eq!(process.wait(Duration::from_millis(50)), Some(143));    assert_eq!(process.kill_signals(), vec![15]);     let snapshot = kernel.resource_snapshot();    assert_eq!(snapshot.fd_tables, 0);    assert_eq!(snapshot.open_fds, 0);    assert_eq!(snapshot.pipes, 0);    assert_eq!(snapshot.ptys, 0);} #[test]fn process_exit_cleanup_closes_pipe_writers_and_returns_eof_to_readers() {    let mut config = KernelVmConfig::new("vm-process-exit-pipe");    config.permissions = Permissions::allow_all();    let mut kernel = KernelVm::new(MemoryFileSystem::new(), config);    kernel        .register_driver(CommandDriver::new("shell", ["sh"]))        .expect("register shell");     let writer = kernel        .spawn_process(            "sh",            Vec::new(),            SpawnOptions {                requester_driver: Some(String::from("shell")),                ..SpawnOptions::default()            },        )        .expect("spawn writer");    let (read_fd, write_fd) = kernel        .open_pipe("shell", writer.pid())        .expect("open writer pipe");    let reader = kernel        .spawn_process(            "sh",            Vec::new(),            SpawnOptions {                requester_driver: Some(String::from("shell")),                parent_pid: Some(writer.pid()),                ..SpawnOptions::default()            },        )        .expect("spawn reader");     kernel        .fd_close("shell", reader.pid(), write_fd)        .expect("close inherited write end");    kernel        .fd_write("shell", writer.pid(), write_fd, b"before-exit")        .expect("write pipe contents");    let bytes = kernel        .fd_read("shell", reader.pid(), read_fd, 64)        .expect("read pipe contents");    assert_eq!(String::from_utf8(bytes).expect("valid utf8"), "before-exit");     writer.finish(0);    assert_eq!(        kernel            .open_pipe("shell", writer.pid())            .expect_err("exited writer should lose PID ownership")            .code(),        "ESRCH"    );     let eof = kernel        .fd_read("shell", reader.pid(), read_fd, 64)        .expect("read EOF after writer exit");    assert!(eof.is_empty());} #[test]fn broken_pipe_writes_deliver_sigpipe_and_return_epipe() {    let mut config = KernelVmConfig::new("vm-broken-pipe-sigpipe");    config.permissions = Permissions::allow_all();    let mut kernel = KernelVm::new(MemoryFileSystem::new(), config);    kernel        .register_driver(CommandDriver::new("shell", ["sh"]))        .expect("register shell");     let writer = kernel        .spawn_process(            "sh",            Vec::new(),            SpawnOptions {                requester_driver: Some(String::from("shell")),                ..SpawnOptions::default()            },        )        .expect("spawn writer");    let (read_fd, write_fd) = kernel        .open_pipe("shell", writer.pid())        .expect("open writer pipe");     kernel        .fd_close("shell", writer.pid(), read_fd)        .expect("close inherited read end");     let error = kernel        .fd_write("shell", writer.pid(), write_fd, b"fail")        .expect_err("broken pipe writes should fail");    assert_eq!(error.code(), "EPIPE");    assert_eq!(writer.kill_signals(), vec![SIGPIPE]);    assert_eq!(writer.wait(Duration::from_millis(50)), Some(128 + SIGPIPE));} #[test]fn process_exit_cleanup_removes_fd_tables_before_and_after_reap() {    let mut config = KernelVmConfig::new("vm-process-exit-fds");    config.permissions = Permissions::allow_all();    let mut kernel = KernelVm::new(MemoryFileSystem::new(), config);    kernel        .register_driver(CommandDriver::new("shell", ["sh"]))        .expect("register shell");     let process = kernel        .spawn_process(            "sh",            Vec::new(),            SpawnOptions {                requester_driver: Some(String::from("shell")),                ..SpawnOptions::default()            },        )        .expect("spawn process");    let _ = kernel.open_pipe("shell", process.pid()).expect("open pipe");    let _ = kernel.open_pty("shell", process.pid()).expect("open pty");     process.finish(0);     let snapshot_after_exit = kernel.resource_snapshot();    assert_eq!(snapshot_after_exit.fd_tables, 0);    assert_eq!(snapshot_after_exit.open_fds, 0);    assert_eq!(snapshot_after_exit.pipes, 0);    assert_eq!(snapshot_after_exit.ptys, 0);     let (_, exit_code) = kernel        .wait_and_reap(process.pid())        .expect("wait and reap exited process");    assert_eq!(exit_code, 0);     let snapshot_after_reap = kernel.resource_snapshot();    assert_eq!(snapshot_after_reap.fd_tables, 0);    assert_eq!(snapshot_after_reap.open_fds, 0);    assert_eq!(        kernel            .fd_stat("shell", process.pid(), 0)            .expect_err("reaped process should not keep FD entries")            .code(),        "ESRCH"    );} #[test]fn spawn_process_executes_shebang_scripts_with_registered_interpreters() {    let mut config = KernelVmConfig::new("vm-shebang");    config.permissions = Permissions::allow_all();    let mut kernel = KernelVm::new(MemoryFileSystem::new(), config);    kernel        .register_driver(CommandDriver::new("shell", ["sh"]))        .expect("register shell");    kernel        .register_driver(CommandDriver::new("node", ["node"]))        .expect("register node");     kernel        .write_file("/tmp/script.sh", b"#!/bin/sh -eu\necho shell\n".to_vec())        .expect("write shell script");    kernel        .chmod("/tmp/script.sh", 0o755)        .expect("chmod shell script");    let shell_process = kernel        .spawn_process(            "/tmp/script.sh",            vec![String::from("arg")],            SpawnOptions::default(),        )        .expect("spawn shell script");    assert_eq!(        kernel            .read_file(&format!("/proc/{}/cmdline", shell_process.pid()))            .expect("read shell cmdline"),        b"sh\0-eu\0/tmp/script.sh\0arg\0".to_vec()    );     kernel        .write_file(            "/tmp/script.mjs",            b"#!/usr/bin/env node --trace-warnings\nconsole.log('node');\n".to_vec(),        )        .expect("write node script");    kernel        .chmod("/tmp/script.mjs", 0o755)        .expect("chmod node script");    let node_process = kernel        .spawn_process("/tmp/script.mjs", Vec::new(), SpawnOptions::default())        .expect("spawn node script");    assert_eq!(        kernel            .read_file(&format!("/proc/{}/cmdline", node_process.pid()))            .expect("read node cmdline"),        b"node\0--trace-warnings\0/tmp/script.mjs\0".to_vec()    );} #[test]fn spawn_process_rejects_invalid_shebang_scripts() {    let mut config = KernelVmConfig::new("vm-shebang-errors");    config.permissions = Permissions::allow_all();    let mut kernel = KernelVm::new(MemoryFileSystem::new(), config);    kernel        .register_driver(CommandDriver::new("shell", ["sh"]))        .expect("register shell");     kernel        .write_file("/tmp/missing.sh", b"#!/missing/interpreter\n".to_vec())        .expect("write missing-interpreter script");    kernel        .chmod("/tmp/missing.sh", 0o755)        .expect("chmod missing-interpreter script");    let missing = kernel        .spawn_process("/tmp/missing.sh", Vec::new(), SpawnOptions::default())        .expect_err("missing interpreter should fail");    assert_eq!(missing.code(), "ENOENT");     let long_shebang = format!("#!/{0}\n", "a".repeat(256));    kernel        .write_file("/tmp/long.sh", long_shebang.into_bytes())        .expect("write long-shebang script");    kernel        .chmod("/tmp/long.sh", 0o755)        .expect("chmod long-shebang script");    let long_error = kernel        .spawn_process("/tmp/long.sh", Vec::new(), SpawnOptions::default())        .expect_err("overlong shebang should fail");    assert_eq!(long_error.code(), "ENOEXEC");} #[test]fn driver_registration_rejects_command_names_that_escape_bin_stubs() {    let mut config = KernelVmConfig::new("vm-command-registry-traversal");    config.permissions = Permissions::allow_all();    let mut kernel = KernelVm::new(MemoryFileSystem::new(), config);     let error = kernel        .register_driver(CommandDriver::new("malicious", ["safe", "../escape"]))        .expect_err("path-like command names should be rejected");     assert_eq!(error.code(), "EINVAL");    assert!(        error.to_string().contains("invalid command name"),        "unexpected error: {error}"    );    assert!(!kernel.exists("/bin").expect("check /bin"));    assert!(!kernel.exists("/bin/safe").expect("check safe stub"));    assert!(!kernel.exists("/escape").expect("check escaped stub"));}