This repository has been archived on 2026-10-08. You can view files and clone it. You cannot open issues or pull requests or push a commit.
Files
maestro/crates/maestro-daemon/tests/sidecar.rs
T
naps62-yoloandClaude Opus 4.8 fd80ae152a
ci / rust (push) Failing after 2m15s
feat(maestro): infer session activity state + foreground (Active/Idle/AwaitingInput) (#18)
Add an orthogonal activity dimension to sessions, inferred entirely from
structured tmux/`/proc` state — no PTY byte-stream parsing, no work on the
attach hot path.

Protocol: `ActivityState` enum (Active/Idle/AwaitingInput) + three additive,
serde-defaulted `Session` fields (`foreground`, `activity`, `last_activity_at`)
so the snapshot/diff flow stays forward-compatible with older daemons.

Detection (piggybacks the existing ~2s liveness tick, no new timer):
- foreground command via `tmux list-panes -F '#{pane_pid} #{pane_current_command}
  #{pane_tty}'`;
- quiescence from a per-`PtyBridge` last-read `Instant`, bumped in `run_reader`;
- AwaitingInput via best-effort `/proc` walk to the deepest descendant: state
  `S` + a non-timer `wchan` + an stdio fd on the pane tty. (`/proc/pid/syscall`
  is ptrace-gated and unreadable for own sessions, so `wchan` distinguishes a
  blocking read from a plain `sleep`.)
- combine: recent output → Active; else input-blocked → AwaitingInput; else
  Idle. Emit `SessionUpdated` only on (activity, foreground) change — no diff
  storms at steady state.

`maestro list` gains an ACTIVITY column and shows the live foreground. Pure
combine/parse logic is unit-tested; an e2e asserts `cat` → AwaitingInput and
`sleep` → Idle with correct foreground against real tmux.

Closes #18
Closes #8

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-06-21 14:51:08 +00:00

111 lines
3.2 KiB
Rust

//! Round-trip and recovery tests for the on-disk sidecar session store.
mod common;
use std::collections::HashMap;
use std::path::PathBuf;
use chrono::{DateTime, Utc};
use maestro_daemon::sidecar::SidecarStore;
use maestro_protocol::{Session, SessionStatus};
use serde_json::Value;
use tempfile::TempDir;
use uuid::Uuid;
fn sample(id: Uuid, daemon_id: &str) -> Session {
Session {
id,
daemon_id: daemon_id.to_string(),
cwd: PathBuf::from("/tmp/work"),
command: "bash".into(),
env: HashMap::from([("FOO".into(), "bar".into())]),
metadata: HashMap::from([("label".into(), Value::String("personal/maestro".into()))]),
status: SessionStatus::Running,
created_at: DateTime::parse_from_rfc3339("2026-05-24T12:00:00Z")
.unwrap()
.with_timezone(&Utc),
foreground: None,
activity: Default::default(),
last_activity_at: chrono::Utc::now(),
}
}
#[test]
fn write_then_read_round_trip() {
let dir = TempDir::new().unwrap();
let store = SidecarStore::new(dir.path());
let id = Uuid::new_v4();
let s = sample(id, "laptop");
store.write(&s).expect("write");
let loaded = store.read(id).expect("read");
assert_eq!(loaded.as_ref(), Some(&s));
let path = store.path_for(id);
assert!(path.exists());
assert!(path.ends_with(format!("{id}.json")));
}
#[test]
fn read_missing_returns_none() {
let dir = TempDir::new().unwrap();
let store = SidecarStore::new(dir.path());
assert!(store.read(Uuid::new_v4()).unwrap().is_none());
}
#[test]
fn delete_removes_file_and_is_idempotent() {
let dir = TempDir::new().unwrap();
let store = SidecarStore::new(dir.path());
let id = Uuid::new_v4();
let s = sample(id, "laptop");
store.write(&s).unwrap();
assert!(store.path_for(id).exists());
store.delete(id).unwrap();
assert!(!store.path_for(id).exists());
// second delete is a no-op
store.delete(id).unwrap();
}
#[test]
fn load_all_recovers_every_sidecar_and_skips_garbage() {
let dir = TempDir::new().unwrap();
let store = SidecarStore::new(dir.path());
let s1 = sample(Uuid::new_v4(), "laptop");
let s2 = sample(Uuid::new_v4(), "dev-vm");
store.write(&s1).unwrap();
store.write(&s2).unwrap();
// garbage files in the directory should be ignored
std::fs::write(dir.path().join("not-json.txt"), b"hello").unwrap();
std::fs::write(dir.path().join("broken.json"), b"{not json}").unwrap();
let mut loaded = store.load_all().expect("load_all");
loaded.sort_by_key(|s| s.daemon_id.clone());
let mut expected = vec![s1, s2];
expected.sort_by_key(|s| s.daemon_id.clone());
assert_eq!(loaded, expected);
}
#[test]
fn load_all_returns_empty_when_directory_missing() {
let dir = TempDir::new().unwrap();
let store = SidecarStore::new(dir.path().join("does-not-exist"));
assert!(store.load_all().unwrap().is_empty());
}
#[test]
fn write_creates_parent_directory() {
let dir = TempDir::new().unwrap();
let nested = dir.path().join("a/b/c");
let store = SidecarStore::new(&nested);
let s = sample(Uuid::new_v4(), "laptop");
store.write(&s).expect("write");
assert!(nested.exists());
assert!(store.path_for(s.id).exists());
}