Files
plan2code/plan2code-app/src-tauri/tests/agent_manager.rs
T
2026-11-09 15:05:12 -08:00

532 lines
17 KiB
Rust

//! The agent lifecycle against the fake agent in a real pseudo-terminal. Real
//! agents are never started here: `PLAN2CODE_APP_AGENT_BIN` points every agent
//! kind at the fake one.
use std::path::PathBuf;
use std::sync::mpsc::{channel, Receiver, RecvTimeoutError};
use std::sync::{Arc, Mutex, Once};
use std::time::{Duration, Instant};
use plan2code_app_lib::agent_manager::{AgentEvent, AgentManager, AgentSnapshot, AgentState};
use plan2code_app_lib::agents::{
agent_launch_spec, builtin_entry, parse_agents_file, Agent, PermissionMode, AGENT_BIN_ENV,
};
mod common;
use common::process_alive;
const TIMEOUT: Duration = Duration::from_secs(20);
const READY: &str = "FAKE-AGENT ready";
struct Harness {
manager: AgentManager,
rx: Receiver<AgentEvent>,
/// Everything the agents printed, in order.
seen: String,
/// Every state change, in order.
states: Vec<AgentSnapshot>,
/// How many of `states` `wait_state` has already looked at.
cursor: usize,
}
impl Harness {
fn new() -> Harness {
static BIN: Once = Once::new();
BIN.call_once(|| std::env::set_var(AGENT_BIN_ENV, common::fake_agent()));
let (tx, rx) = channel();
let tx = Mutex::new(tx);
let sink = Arc::new(move |event| {
let _ = tx.lock().unwrap().send(event);
});
Harness {
manager: AgentManager::new(PathBuf::from("."), sink),
rx,
seen: String::new(),
states: Vec::new(),
cursor: 0,
}
}
fn take(&mut self, event: AgentEvent) {
match event {
AgentEvent::Output(bytes) => {
let text = String::from_utf8_lossy(&bytes).into_owned();
// Windows' pseudo-terminal asks where the cursor is (ESC [ 6 n)
// and holds the output until told, as xterm does on its own.
for _ in text.matches("[6n") {
self.manager.input(b"\x1b[1;1R").unwrap();
}
self.seen.push_str(&text);
}
AgentEvent::State(snapshot) => self.states.push(snapshot),
}
}
/// Handle events for `how_long`, answering the terminal's questions.
fn pump_for(&mut self, how_long: Duration) {
let deadline = Instant::now() + how_long;
loop {
let left = deadline.saturating_duration_since(Instant::now());
match self.rx.recv_timeout(left) {
Ok(event) => self.take(event),
Err(_) => return,
}
}
}
fn wait_for_output(&mut self, needle: &str, times: usize) {
let deadline = Instant::now() + TIMEOUT;
while self.seen.matches(needle).count() < times {
let left = deadline.saturating_duration_since(Instant::now());
match self.rx.recv_timeout(left) {
Ok(event) => self.take(event),
Err(RecvTimeoutError::Timeout) | Err(RecvTimeoutError::Disconnected) => {
panic!("never saw {needle:?} {times} time(s); got {:?}", self.seen)
}
}
}
}
/// The next state change (after the last one this returned) that matches.
fn wait_state(
&mut self,
what: &str,
matches: impl Fn(&AgentSnapshot) -> bool,
) -> AgentSnapshot {
let deadline = Instant::now() + TIMEOUT;
loop {
while self.cursor < self.states.len() {
let snapshot = self.states[self.cursor].clone();
self.cursor += 1;
if matches(&snapshot) {
return snapshot;
}
}
let left = deadline.saturating_duration_since(Instant::now());
match self.rx.recv_timeout(left) {
Ok(event) => self.take(event),
Err(_) => panic!("never saw the state {what}; got {:?}", self.states),
}
}
}
fn start_and_wait_ready(&mut self) {
self.manager
.start(
Agent::Builtin(builtin_entry("claude").unwrap()),
None,
None,
PermissionMode::Bypass,
None,
)
.expect("start the fake agent");
self.wait_for_output(READY, 1);
}
fn type_line(&self, line: &str) {
self.manager.input(format!("{line}\r").as_bytes()).unwrap();
}
}
fn is_running(snapshot: &AgentSnapshot) -> bool {
snapshot.state == AgentState::Running
}
#[test]
fn a_second_start_while_running_is_refused() {
let mut h = Harness::new();
h.start_and_wait_ready();
let generation = h.manager.snapshot().generation;
let refused = h.manager.start(
Agent::Builtin(builtin_entry("devin").unwrap()),
None,
None,
PermissionMode::Bypass,
None,
);
assert!(refused.is_err(), "a second start must be refused");
let after = h.manager.snapshot();
assert_eq!(after.state, AgentState::Running);
assert_eq!(
after.generation, generation,
"the running agent was replaced"
);
h.manager.stop();
}
#[test]
fn restart_keeps_the_previous_agent_kind_mode_model_and_effort() {
let mut h = Harness::new();
h.manager
.start(
Agent::Builtin(builtin_entry("codex").unwrap()),
Some("gpt-5".to_string()),
Some("high".to_string()),
PermissionMode::Checked,
None,
)
.expect("start the fake agent");
h.wait_for_output(READY, 1);
let before = h.manager.snapshot();
assert_eq!(before.kind, Some("codex".to_string()));
assert_eq!(before.mode, Some(PermissionMode::Checked));
assert_eq!(
h.manager.model_and_effort(),
(Some("gpt-5".to_string()), Some("high".to_string()))
);
h.manager.restart().unwrap();
h.wait_for_output(READY, 2);
let after = h.manager.snapshot();
assert_eq!(
after.kind,
Some("codex".to_string()),
"restart must keep the same agent"
);
assert_eq!(
after.mode,
Some(PermissionMode::Checked),
"restart must keep the same permission mode"
);
assert_eq!(
h.manager.model_and_effort(),
(Some("gpt-5".to_string()), Some("high".to_string())),
"restart must keep the same model and effort"
);
h.manager.stop();
}
#[test]
fn snapshot_carries_the_model_and_effort_for_the_bar_only_when_known() {
let mut h = Harness::new();
h.manager
.start(
Agent::Builtin(builtin_entry("codex").unwrap()),
Some("gpt-5".to_string()),
Some("high".to_string()),
PermissionMode::Checked,
None,
)
.expect("start the fake agent");
h.wait_for_output(READY, 1);
let known = h.manager.snapshot();
assert_eq!(known.model.as_deref(), Some("gpt-5"));
assert_eq!(known.effort.as_deref(), Some("high"));
let json = serde_json::to_value(&known).unwrap();
assert_eq!(json["model"], "gpt-5");
assert_eq!(json["effort"], "high");
h.manager.stop();
h.manager
.start(
Agent::Builtin(builtin_entry("codex").unwrap()),
None,
None,
PermissionMode::Checked,
None,
)
.expect("start the fake agent on its own model");
h.wait_for_output(READY, 2);
let unknown = h.manager.snapshot();
assert_eq!(unknown.model, None);
assert_eq!(unknown.effort, None);
let json = serde_json::to_value(&unknown).unwrap();
assert!(json.get("model").is_none(), "an unknown model is left out");
assert!(
json.get("effort").is_none(),
"an unknown effort is left out"
);
h.manager.stop();
}
#[test]
fn restart_between_steps_replaces_the_agent_at_once() {
let mut h = Harness::new();
h.start_and_wait_ready();
let generation = h.manager.snapshot().generation;
h.manager.restart().unwrap();
let now = h.manager.snapshot();
assert_eq!(now.state, AgentState::Running);
assert!(now.generation > generation, "a fresh agent was not started");
h.wait_for_output(READY, 2);
h.manager.stop();
}
#[test]
fn restart_mid_step_kills_the_step_at_once_instead_of_waiting_for_it() {
let mut h = Harness::new();
h.start_and_wait_ready();
h.type_line("STEP 30");
h.wait_for_output("working 1/30", 1);
let started = Instant::now();
h.manager.restart().unwrap();
// Running again straight away: no wait for the step to finish.
h.wait_state("Running again", is_running);
h.wait_for_output(READY, 2);
assert!(
started.elapsed() < Duration::from_secs(5),
"restart must not wait on the step; took {:?}",
started.elapsed()
);
assert!(
!h.seen.contains("STEP DONE"),
"the step should have been cut short, not finished"
);
h.manager.stop();
}
#[test]
fn an_agent_that_exits_by_itself_ends_with_its_code_and_nothing_restarts() {
let mut h = Harness::new();
h.start_and_wait_ready();
h.type_line("EXIT 7");
let ended = h.wait_state("Ended", |s| matches!(s.state, AgentState::Ended { .. }));
match &ended.state {
AgentState::Ended { reason } => assert!(reason.contains('7'), "reason was {reason:?}"),
other => panic!("expected Ended, got {other:?}"),
}
// Nothing starts without a press.
h.pump_for(Duration::from_millis(1500));
assert!(matches!(
h.manager.snapshot().state,
AgentState::Ended { .. }
));
assert_eq!(
h.seen.matches(READY).count(),
1,
"an agent started by itself"
);
assert!(!h.manager.is_active());
// A press of Restart starts a fresh one on the same brief.
h.manager.restart().unwrap();
h.wait_for_output(READY, 2);
assert_eq!(h.manager.snapshot().state, AgentState::Running);
h.manager.stop();
}
#[test]
fn quitting_with_a_running_agent_stops_it() {
let mut h = Harness::new();
h.start_and_wait_ready();
assert!(h.manager.is_active());
h.type_line("PID");
h.wait_for_output("PID ", 1);
let pid = h
.seen
.rsplit("PID ")
.next()
.unwrap()
.trim_start()
.split(|c: char| !c.is_ascii_digit())
.next()
.unwrap()
.parse::<u32>()
.expect("the agent's pid");
assert!(
process_alive(pid),
"the agent should be running before the stop"
);
h.manager.stop();
assert!(!process_alive(pid), "the agent's process outlived stop()");
assert_eq!(h.manager.snapshot().state, AgentState::Idle);
assert!(!h.manager.is_active());
// The stopped agent does not come back or print again.
let before = h.seen.len();
h.pump_for(Duration::from_millis(1000));
assert!(
!h.seen[before..].contains(READY),
"an agent started after the stop"
);
assert!(
h.manager.restart().is_err(),
"there is nothing left to restart"
);
}
#[test]
fn the_replay_buffer_holds_recent_output_and_clears_on_a_fresh_agent() {
let mut h = Harness::new();
h.start_and_wait_ready();
let replay = String::from_utf8_lossy(&h.manager.replay()).into_owned();
assert!(
replay.contains(READY),
"replay should hold what was just printed; got {replay:?}"
);
h.manager.restart().unwrap();
h.wait_for_output(READY, 2);
let replay = String::from_utf8_lossy(&h.manager.replay()).into_owned();
assert_eq!(
replay.matches(READY).count(),
1,
"a fresh agent's replay must not carry the old one's output"
);
h.manager.stop();
}
#[test]
fn a_restart_runs_the_brief_hook_and_the_bar_gets_its_note() {
let mut h = Harness::new();
let runs = Arc::new(Mutex::new(0));
let counter = Arc::clone(&runs);
h.manager.set_before_fresh(Arc::new(move || {
*counter.lock().unwrap() += 1;
Some("Brief ready on the dashboard".to_string())
}));
h.start_and_wait_ready();
assert_eq!(*runs.lock().unwrap(), 0, "a first start leaves no brief");
assert_eq!(h.manager.snapshot().brief_note, None);
h.manager.restart().unwrap();
assert_eq!(
*runs.lock().unwrap(),
1,
"the restart did not run the brief once"
);
assert_eq!(
h.manager.snapshot().brief_note.as_deref(),
Some("Brief ready on the dashboard")
);
h.manager.stop();
}
#[test]
fn the_agent_gets_the_in_app_signal_and_a_restart_keeps_it() {
let mut h = Harness::new();
h.manager.set_env(vec![
("PLAN2CODE_IN_APP".to_string(), "1".to_string()),
(
"PLAN2CODE_CONSOLE_SID".to_string(),
"sid-window-a".to_string(),
),
]);
h.start_and_wait_ready();
h.type_line("ENV PLAN2CODE_IN_APP");
h.wait_for_output("ENV PLAN2CODE_IN_APP=1", 1);
h.type_line("ENV PLAN2CODE_CONSOLE_SID");
h.wait_for_output("ENV PLAN2CODE_CONSOLE_SID=sid-window-a", 1);
// The signal changes with the console; a Restart starts on the newest.
h.manager.set_env(vec![(
"PLAN2CODE_CONSOLE_SID".to_string(),
"sid-window-b".to_string(),
)]);
h.manager.restart().unwrap();
h.wait_for_output(READY, 2);
h.type_line("ENV PLAN2CODE_CONSOLE_SID");
h.wait_for_output("ENV PLAN2CODE_CONSOLE_SID=sid-window-b", 1);
h.type_line("ENV PLAN2CODE_IN_APP");
h.wait_for_output("ENV PLAN2CODE_IN_APP=\r", 1);
h.manager.stop();
}
#[test]
fn an_agent_with_no_signal_set_gets_none() {
let mut h = Harness::new();
h.start_and_wait_ready();
h.type_line("ENV PLAN2CODE_IN_APP");
h.wait_for_output("ENV PLAN2CODE_IN_APP=", 1);
assert!(!h.seen.contains("ENV PLAN2CODE_IN_APP=1"));
h.manager.stop();
}
#[test]
fn a_custom_agent_runs_the_override_too_and_restart_keeps_its_id() {
let mut h = Harness::new();
// Its command is nowhere on PATH: the override replaces it, as for a built-in.
let (mut agents, warnings) = parse_agents_file(
r#"{"schema":1,"agents":[{"id":"goose","name":"Goose","command":"goose-not-installed","bypassArgs":["--yes"]}]}"#,
);
assert!(warnings.is_empty(), "{warnings:?}");
let goose = Agent::Custom(agents.remove(0));
let spec = agent_launch_spec(
&goose,
&std::env::temp_dir(),
Some("m"),
None,
PermissionMode::Bypass,
"/plan2code",
);
assert_eq!(PathBuf::from(&spec.program), common::fake_agent());
assert!(spec.args.is_empty());
h.manager
.start(goose, None, None, PermissionMode::Checked, None)
.expect("start the custom agent");
h.wait_for_output(READY, 1);
assert_eq!(h.manager.snapshot().kind, Some("goose".to_string()));
h.manager.restart().unwrap();
h.wait_for_output(READY, 2);
assert_eq!(
h.manager.snapshot().kind,
Some("goose".to_string()),
"restart must keep the custom agent"
);
h.manager.stop();
}
#[test]
fn a_phase_start_runs_on_its_model_and_env_and_leaves_the_launch_choice_alone() {
let mut h = Harness::new();
h.manager
.start(
Agent::Builtin(builtin_entry("claude").unwrap()),
Some("opus".to_string()),
Some("high".to_string()),
PermissionMode::Checked,
None,
)
.expect("start the fake agent");
h.wait_for_output(READY, 1);
h.manager
.start_phase_on(
"/plan2code phase".to_string(),
"sonnet".to_string(),
Some("low".to_string()),
vec![("PLAN2CODE_LOOP_STRENGTH".to_string(), "thrifty".to_string())],
)
.expect("start the phase on its strength");
h.wait_for_output(READY, 2);
// The agent-bin override drops every argument, so the fake agent sees the
// env only; the model is checked through the stored choice below.
h.type_line("ENV PLAN2CODE_LOOP_STRENGTH");
h.wait_for_output("ENV PLAN2CODE_LOOP_STRENGTH=thrifty", 1);
// The stored choice, kind and mode are what they were.
let (kind, model, effort, mode) = h.manager.launch_choice().unwrap();
assert_eq!(kind.id(), "claude");
assert_eq!(model.as_deref(), Some("opus"));
assert_eq!(effort.as_deref(), Some("high"));
assert_eq!(mode, PermissionMode::Checked);
// The next plain start runs on the original choice, with no strength.
h.manager
.start_fresh("/plan2code next".to_string())
.unwrap();
h.wait_for_output(READY, 3);
h.type_line("ENV PLAN2CODE_LOOP_STRENGTH");
h.wait_for_output("ENV PLAN2CODE_LOOP_STRENGTH=\r", 1);
h.manager.stop();
}
#[test]
fn a_phase_start_with_no_launch_choice_is_refused() {
let h = Harness::new();
let refused = h
.manager
.start_phase_on("p".to_string(), "sonnet".to_string(), None, Vec::new());
assert!(refused.is_err());
}