agentguard-local 0.1.0

package/crates/agentguard/tests/integration.rs

@@ -0,0 +1,384 @@
+use serde_json::Value;
+use std::fs;
+use std::io;
+use std::os::unix::fs::PermissionsExt;
+use std::path::{Path, PathBuf};
+use std::process::{Child, Command, Output};
+use std::thread;
+use std::time::{Duration, Instant};
+use tempfile::{TempDir, tempdir};
+
+struct DaemonGuard {
+    child: Child,
+    _dir: TempDir,
+    socket: PathBuf,
+    db: PathBuf,
+    pressure_file: PathBuf,
+}
+
+impl DaemonGuard {
+    fn start() -> Self {
+        let dir = tempdir().unwrap();
+        let socket = dir.path().join("agentguard.sock");
+        let db = dir.path().join("state.db");
+        let pressure_file = dir.path().join("pressure.txt");
+        fs::write(&pressure_file, "normal").unwrap();
+        let child = Command::new(bin("agentguardd"))
+            .arg("--socket")
+            .arg(&socket)
+            .arg("--db")
+            .arg(&db)
+            .arg("--foreground")
+            .env("AGENTGUARD_TEST_MODE", "1")
+            .env("AGENTGUARD_FAKE_PRESSURE_FILE", &pressure_file)
+            .spawn()
+            .unwrap();
+        let daemon = Self {
+            child,
+            _dir: dir,
+            socket,
+            db,
+            pressure_file,
+        };
+        wait_for(
+            || daemon.status_json_result().is_ok(),
+            Duration::from_secs(5),
+        )
+        .unwrap();
+        let output = daemon
+            .cli()
+            .args(["policy", "set", "recovery_window_seconds", "1"])
+            .output()
+            .unwrap();
+        assert_success(&output);
+        daemon
+    }
+
+    fn restart(&mut self) {
+        let _ = self.child.kill();
+        let _ = self.child.wait();
+        self.child = Command::new(bin("agentguardd"))
+            .arg("--socket")
+            .arg(&self.socket)
+            .arg("--db")
+            .arg(&self.db)
+            .arg("--foreground")
+            .env("AGENTGUARD_TEST_MODE", "1")
+            .env("AGENTGUARD_FAKE_PRESSURE_FILE", &self.pressure_file)
+            .spawn()
+            .unwrap();
+        wait_for(|| self.status_json_result().is_ok(), Duration::from_secs(5)).unwrap();
+    }
+
+    fn set_pressure(&self, pressure: &str) {
+        fs::write(&self.pressure_file, pressure).unwrap();
+    }
+
+    fn cli(&self) -> Command {
+        let mut command = Command::new(bin("agentguard"));
+        command.arg("--socket").arg(&self.socket);
+        command
+    }
+
+    fn status_json(&self) -> Value {
+        self.status_json_result().unwrap()
+    }
+
+    fn status_json_result(&self) -> Result<Value, String> {
+        let output = self.cli().arg("status").arg("--json").output().unwrap();
+        if !output.status.success() {
+            return Err(format!(
+                "status={:?}\nstdout={}\nstderr={}",
+                output.status.code(),
+                String::from_utf8_lossy(&output.stdout),
+                String::from_utf8_lossy(&output.stderr)
+            ));
+        }
+        serde_json::from_slice(&output.stdout).map_err(|err| err.to_string())
+    }
+}
+
+impl Drop for DaemonGuard {
+    fn drop(&mut self) {
+        let _ = self.child.kill();
+        let _ = self.child.wait();
+    }
+}
+
+#[test]
+fn status_json_reports_pressure_policy_and_empty_job_state() {
+    let daemon = DaemonGuard::start();
+    let status = daemon.status_json();
+    assert_eq!(status["pressure"], "normal");
+    assert_eq!(status["policy"]["max_active_jobs"], 1);
+    assert!(status["jobs"].as_array().unwrap().is_empty());
+}
+
+#[test]
+fn run_fake_tool_records_job_and_preserves_stdio_and_exit_code() {
+    let daemon = DaemonGuard::start();
+    let output = daemon
+        .cli()
+        .args([
+            "run",
+            "--",
+            "/bin/sh",
+            "-c",
+            "echo out; echo err >&2; exit 7",
+        ])
+        .output()
+        .unwrap();
+    assert_eq!(output.status.code(), Some(7));
+    assert_eq!(String::from_utf8_lossy(&output.stdout).trim(), "out");
+    assert_eq!(String::from_utf8_lossy(&output.stderr).trim(), "err");
+
+    let status = daemon.status_json();
+    let jobs = status["jobs"].as_array().unwrap();
+    assert_eq!(jobs[0]["status"], "failed");
+    assert_eq!(jobs[0]["exit_code"], 7);
+}
+
+#[test]
+fn active_job_limit_queues_second_job_until_first_exits() {
+    let daemon = DaemonGuard::start();
+    let mut first = daemon
+        .cli()
+        .args(["run", "--", "/bin/sleep", "1"])
+        .spawn()
+        .unwrap();
+    wait_for(
+        || status_has_state(&daemon, "running"),
+        Duration::from_secs(5),
+    )
+    .unwrap();
+
+    let mut second = daemon
+        .cli()
+        .args(["run", "--", "/bin/sh", "-c", "echo second"])
+        .spawn()
+        .unwrap();
+    wait_for(
+        || status_has_state(&daemon, "queued"),
+        Duration::from_secs(5),
+    )
+    .unwrap();
+
+    assert_eq!(
+        wait_child(&mut first, Duration::from_secs(5)).unwrap(),
+        Some(0)
+    );
+    assert_eq!(
+        wait_child(&mut second, Duration::from_secs(5)).unwrap(),
+        Some(0)
+    );
+    let status = daemon.status_json();
+    assert!(status["jobs"].as_array().unwrap().iter().any(|job| {
+        job["command"] == "/bin/sh" && job["status"] == "exited" && job["exit_code"] == 0
+    }));
+}
+
+#[test]
+fn simulated_soft_pressure_queues_then_recovery_admits_job() {
+    let daemon = DaemonGuard::start();
+    daemon.set_pressure("soft");
+    let mut queued = daemon
+        .cli()
+        .args(["run", "--", "/bin/sh", "-c", "echo recovered"])
+        .stdout(std::process::Stdio::piped())
+        .spawn()
+        .unwrap();
+    wait_for(
+        || status_has_state(&daemon, "queued"),
+        Duration::from_secs(5),
+    )
+    .unwrap();
+    let queued_status = daemon.status_json();
+    assert!(queued_status["jobs"].as_array().unwrap().iter().any(|job| {
+        job["queued_reason"]
+            .as_str()
+            .is_some_and(|reason| reason.contains("soft memory pressure"))
+    }));
+
+    daemon.set_pressure("normal");
+    let code = wait_child(&mut queued, Duration::from_secs(5)).unwrap();
+    assert_eq!(code, Some(0));
+}
+
+#[test]
+fn simulated_critical_pressure_pauses_and_recovery_resumes_guarded_group() {
+    let daemon = DaemonGuard::start();
+    let mut child = daemon
+        .cli()
+        .args(["run", "--priority", "low", "--", "/bin/sleep", "3"])
+        .spawn()
+        .unwrap();
+    wait_for(
+        || status_has_state(&daemon, "running"),
+        Duration::from_secs(5),
+    )
+    .unwrap();
+    daemon.set_pressure("critical");
+    wait_for(
+        || {
+            let _ = daemon.status_json();
+            status_has_state(&daemon, "paused_by_guard")
+        },
+        Duration::from_secs(5),
+    )
+    .unwrap();
+
+    daemon.set_pressure("normal");
+    wait_for(
+        || {
+            let _ = daemon.status_json();
+            status_has_state(&daemon, "running") || child.try_wait().unwrap().is_some()
+        },
+        Duration::from_secs(5),
+    )
+    .unwrap();
+    let _ = child.kill();
+    let _ = child.wait();
+}
+
+#[test]
+fn daemon_restart_reconciles_still_running_job() {
+    let mut daemon = DaemonGuard::start();
+    let mut child = daemon
+        .cli()
+        .args(["run", "--", "/bin/sleep", "3"])
+        .spawn()
+        .unwrap();
+    wait_for(
+        || status_has_state(&daemon, "running"),
+        Duration::from_secs(5),
+    )
+    .unwrap();
+
+    daemon.restart();
+    wait_for(
+        || status_has_event(&daemon, "daemon_restart_reconciled"),
+        Duration::from_secs(5),
+    )
+    .unwrap();
+    let status = daemon.status_json();
+    assert!(
+        status["jobs"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .any(|job| { job["status"] == "running" || job["status"] == "exited" })
+    );
+    let _ = child.kill();
+    let _ = child.wait();
+}
+
+#[test]
+fn shim_wraps_fake_codex_without_real_codex_and_injects_thread_cap() {
+    let daemon = DaemonGuard::start();
+    let dir = tempdir().unwrap();
+    let real_codex = dir.path().join("codex-real");
+    fs::write(&real_codex, "#!/bin/sh\nprintf '%s\\n' \"$@\"\n").unwrap();
+    fs::set_permissions(&real_codex, fs::Permissions::from_mode(0o755)).unwrap();
+    let shim_dir = dir.path().join("shim");
+
+    let install = daemon
+        .cli()
+        .arg("install-shim")
+        .arg("codex")
+        .arg("--real-path")
+        .arg(&real_codex)
+        .arg("--shim-dir")
+        .arg(&shim_dir)
+        .output()
+        .unwrap();
+    assert_success(&install);
+
+    let output = Command::new(shim_dir.join("codex"))
+        .arg("exec")
+        .arg("hello")
+        .output()
+        .unwrap();
+    assert_success(&output);
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    assert!(stdout.contains("agents.max_threads=1"));
+    assert!(stdout.contains("exec"));
+
+    let output = Command::new(shim_dir.join("codex"))
+        .args(["-c", "agents.max_threads=9", "exec"])
+        .output()
+        .unwrap();
+    assert_success(&output);
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    assert!(stdout.contains("agents.max_threads=9"));
+    assert!(!stdout.contains("agents.max_threads=1"));
+}
+
+fn bin(name: &str) -> PathBuf {
+    let key = format!("CARGO_BIN_EXE_{name}");
+    std::env::var_os(&key)
+        .map(PathBuf::from)
+        .unwrap_or_else(|| {
+            let exe = std::env::current_exe().unwrap();
+            exe.parent().and_then(Path::parent).unwrap().join(name)
+        })
+}
+
+fn wait_for(mut predicate: impl FnMut() -> bool, timeout: Duration) -> io::Result<()> {
+    let start = Instant::now();
+    while start.elapsed() < timeout {
+        if predicate() {
+            return Ok(());
+        }
+        thread::sleep(Duration::from_millis(50));
+    }
+    Err(io::Error::new(
+        io::ErrorKind::TimedOut,
+        "condition timed out",
+    ))
+}
+
+fn status_has_state(daemon: &DaemonGuard, state: &str) -> bool {
+    let Ok(status) = daemon.status_json_result() else {
+        return false;
+    };
+    status["jobs"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .any(|job| job["status"] == state)
+}
+
+fn status_has_event(daemon: &DaemonGuard, event_type: &str) -> bool {
+    let Ok(status) = daemon.status_json_result() else {
+        return false;
+    };
+    status["events"]
+        .as_array()
+        .unwrap()
+        .iter()
+        .any(|event| event["event_type"] == event_type)
+}
+
+fn wait_child(child: &mut Child, timeout: Duration) -> io::Result<Option<i32>> {
+    let start = Instant::now();
+    loop {
+        if let Some(status) = child.try_wait()? {
+            return Ok(status.code());
+        }
+        if start.elapsed() >= timeout {
+            let _ = child.kill();
+            return Ok(None);
+        }
+        thread::sleep(Duration::from_millis(50));
+    }
+}
+
+fn assert_success(output: &Output) {
+    assert!(
+        output.status.success(),
+        "status={:?}\nstdout={}\nstderr={}",
+        output.status.code(),
+        String::from_utf8_lossy(&output.stdout),
+        String::from_utf8_lossy(&output.stderr)
+    );
+}

package/crates/agentguard-core/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "agentguard-core"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+authors.workspace = true
+
+[dependencies]
+anyhow.workspace = true
+chrono.workspace = true
+libc.workspace = true
+rusqlite.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+thiserror.workspace = true
+uuid.workspace = true
+
+[dev-dependencies]
+tempfile.workspace = true

package/crates/agentguard-core/src/adapter.rs

@@ -0,0 +1,69 @@
+pub mod codex {
+    pub fn apply_thread_cap(args: &[String], cap: u32) -> Vec<String> {
+        if has_explicit_thread_cap(args) {
+            return args.to_vec();
+        }
+        let mut adjusted = vec!["-c".to_string(), format!("agents.max_threads={cap}")];
+        adjusted.extend_from_slice(args);
+        adjusted
+    }
+
+    pub fn has_explicit_thread_cap(args: &[String]) -> bool {
+        let mut index = 0;
+        while index < args.len() {
+            let arg = &args[index];
+            if arg == "-c" || arg == "--config" {
+                if args
+                    .get(index + 1)
+                    .is_some_and(|next| config_sets_threads(next))
+                {
+                    return true;
+                }
+                index += 2;
+                continue;
+            }
+            if arg.strip_prefix("-c=").is_some_and(config_sets_threads)
+                || arg
+                    .strip_prefix("--config=")
+                    .is_some_and(config_sets_threads)
+                || arg.strip_prefix("-c").is_some_and(config_sets_threads)
+            {
+                return true;
+            }
+            index += 1;
+        }
+        false
+    }
+
+    fn config_sets_threads(value: &str) -> bool {
+        let trimmed = value.trim();
+        trimmed == "agents.max_threads" || trimmed.starts_with("agents.max_threads=")
+    }
+
+    #[cfg(test)]
+    mod tests {
+        use super::*;
+
+        #[test]
+        fn codex_adapter_injects_thread_cap_when_absent() {
+            let args = vec!["exec".to_string(), "fix tests".to_string()];
+            let adjusted = apply_thread_cap(&args, 1);
+            assert_eq!(adjusted[0], "-c");
+            assert_eq!(adjusted[1], "agents.max_threads=1");
+            assert_eq!(adjusted[2], "exec");
+        }
+
+        #[test]
+        fn codex_adapter_does_not_override_explicit_config() {
+            let args = vec![
+                "-c".to_string(),
+                "agents.max_threads=4".to_string(),
+                "exec".to_string(),
+            ];
+            assert_eq!(apply_thread_cap(&args, 1), args);
+
+            let args = vec!["--config=agents.max_threads=3".to_string()];
+            assert_eq!(apply_thread_cap(&args, 1), args);
+        }
+    }
+}

package/crates/agentguard-core/src/lib.rs

@@ -0,0 +1,14 @@
+pub mod adapter;
+pub mod lifecycle;
+pub mod policy;
+pub mod pressure;
+pub mod process;
+pub mod protocol;
+pub mod scheduler;
+pub mod server;
+pub mod store;
+pub mod types;
+
+pub use types::{
+    EventRecord, JobRecord, JobState, Policy, PressureState, Priority, StatusSnapshot, ToolPath,
+};

package/crates/agentguard-core/src/lifecycle.rs

@@ -0,0 +1,41 @@
+use crate::types::JobState;
+
+pub fn valid_transition(from: JobState, to: JobState) -> bool {
+    use JobState::*;
+    match (from, to) {
+        (PendingAdmission, Queued | Starting | Cancelled | Failed) => true,
+        (Queued, Starting | Cancelled | Lost) => true,
+        (Starting, Running | Failed | Lost | Cancelled) => true,
+        (Running, PausedByGuard | Exiting | Exited | Failed | Lost | Cancelled) => true,
+        (PausedByGuard, Running | Exiting | Lost | Cancelled) => true,
+        (Exiting, Exited | Failed | Lost | Cancelled) => true,
+        (Exited | Failed | Lost | Cancelled, _) => false,
+        (same_from, same_to) if same_from == same_to => true,
+        _ => false,
+    }
+}
+
+pub fn ensure_transition(from: JobState, to: JobState) -> anyhow::Result<()> {
+    anyhow::ensure!(
+        valid_transition(from, to),
+        "invalid job lifecycle transition from {from} to {to}"
+    );
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn validates_job_lifecycle_transitions() {
+        assert!(valid_transition(
+            JobState::PendingAdmission,
+            JobState::Queued
+        ));
+        assert!(valid_transition(JobState::Queued, JobState::Starting));
+        assert!(valid_transition(JobState::Running, JobState::PausedByGuard));
+        assert!(!valid_transition(JobState::Exited, JobState::Running));
+        assert!(!valid_transition(JobState::Queued, JobState::Exited));
+    }
+}

package/crates/agentguard-core/src/policy.rs

@@ -0,0 +1,117 @@
+use crate::types::Policy;
+
+impl Default for Policy {
+    fn default() -> Self {
+        Self::for_physical_memory(8 * 1024 * 1024 * 1024)
+    }
+}
+
+impl Policy {
+    pub fn for_physical_memory(bytes: u64) -> Self {
+        let gib = bytes / 1024 / 1024 / 1024;
+        if gib <= 8 {
+            Self {
+                max_active_jobs: 1,
+                soft_memory_pressure_percent: 72,
+                critical_memory_pressure_percent: 88,
+                recovery_memory_pressure_percent: 62,
+                default_codex_max_threads: 1,
+                pause_enabled: true,
+                queue_timeout_seconds: 1800,
+                recovery_window_seconds: 60,
+            }
+        } else if gib <= 16 {
+            Self {
+                max_active_jobs: 2,
+                soft_memory_pressure_percent: 80,
+                critical_memory_pressure_percent: 92,
+                recovery_memory_pressure_percent: 70,
+                default_codex_max_threads: 2,
+                pause_enabled: true,
+                queue_timeout_seconds: 1800,
+                recovery_window_seconds: 30,
+            }
+        } else {
+            Self {
+                max_active_jobs: 3,
+                soft_memory_pressure_percent: 85,
+                critical_memory_pressure_percent: 94,
+                recovery_memory_pressure_percent: 75,
+                default_codex_max_threads: 3,
+                pause_enabled: true,
+                queue_timeout_seconds: 1800,
+                recovery_window_seconds: 30,
+            }
+        }
+    }
+
+    pub fn set_key(&mut self, key: &str, value: &str) -> anyhow::Result<()> {
+        match key {
+            "max_active_jobs" => self.max_active_jobs = value.parse()?,
+            "soft_memory_pressure_percent" => self.soft_memory_pressure_percent = value.parse()?,
+            "critical_memory_pressure_percent" => {
+                self.critical_memory_pressure_percent = value.parse()?;
+            }
+            "recovery_memory_pressure_percent" => {
+                self.recovery_memory_pressure_percent = value.parse()?;
+            }
+            "default_codex_max_threads" => self.default_codex_max_threads = value.parse()?,
+            "pause_enabled" => self.pause_enabled = parse_bool(value)?,
+            "queue_timeout_seconds" => self.queue_timeout_seconds = value.parse()?,
+            "recovery_window_seconds" => self.recovery_window_seconds = value.parse()?,
+            other => anyhow::bail!("unknown policy key {other:?}"),
+        }
+        self.validate()
+    }
+
+    pub fn validate(&self) -> anyhow::Result<()> {
+        anyhow::ensure!(self.max_active_jobs > 0, "max_active_jobs must be > 0");
+        anyhow::ensure!(
+            self.recovery_memory_pressure_percent < self.soft_memory_pressure_percent,
+            "recovery threshold must be below soft threshold"
+        );
+        anyhow::ensure!(
+            self.soft_memory_pressure_percent < self.critical_memory_pressure_percent,
+            "soft threshold must be below critical threshold"
+        );
+        anyhow::ensure!(
+            self.critical_memory_pressure_percent <= 100,
+            "critical threshold must be <= 100"
+        );
+        anyhow::ensure!(
+            self.default_codex_max_threads > 0,
+            "default_codex_max_threads must be > 0"
+        );
+        Ok(())
+    }
+}
+
+fn parse_bool(value: &str) -> anyhow::Result<bool> {
+    match value {
+        "true" | "1" | "yes" | "on" => Ok(true),
+        "false" | "0" | "no" | "off" => Ok(false),
+        _ => anyhow::bail!("expected boolean value, got {value:?}"),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn selects_8gb_defaults_for_small_machines() {
+        let policy = Policy::for_physical_memory(8 * 1024 * 1024 * 1024);
+        assert_eq!(policy.max_active_jobs, 1);
+        assert_eq!(policy.default_codex_max_threads, 1);
+        assert!(policy.pause_enabled);
+    }
+
+    #[test]
+    fn updates_mvp_policy_keys() {
+        let mut policy = Policy::default();
+        policy.set_key("max_active_jobs", "2").unwrap();
+        policy.set_key("pause_enabled", "false").unwrap();
+        assert_eq!(policy.max_active_jobs, 2);
+        assert!(!policy.pause_enabled);
+    }
+}