Solution for long term memory for agent coding CLIs and to facilitate handoff between different agent vendors
Rust
chore(test): move the e2e serve port retry to its own change
Éverton Toffanetto79dbce35bf41
diff --git a/crates/ai-memory-cli/tests/suite/backfill_e2e.rs b/crates/ai-memory-cli/tests/suite/backfill_e2e.rsindex 2473da11..1a0123b8 100644--- a/crates/ai-memory-cli/tests/suite/backfill_e2e.rs+++ b/crates/ai-memory-cli/tests/suite/backfill_e2e.rs@@ -34,11 +34,14 @@mod slow {use std::fs;use std::path::{Path, PathBuf};+ use std::process::Stdio;use std::time::{Duration, Instant};use serde_json::{Value, json};- use crate::e2e_support::{hermetic, run_cli, session_count, start_serve, write_jsonl};+ use crate::e2e_support::{+ ServerGuard, free_port, hermetic, run_cli, session_count, write_jsonl,+ };const BIN: &str = env!("CARGO_BIN_EXE_ai-memory");const WORKSPACE: &str = "backfill-e2e-ws";@@ -159,28 +162,51 @@ mod slow {// Start the real server (loopback, no auth, hermetic: no embedder, no// wiki watcher — a machine-global inotify instance concurrent server// children can exhaust, #745).+ let port = free_port();+ let base = format!("http://127.0.0.1:{port}");+ let server = ServerGuard(+ hermetic(BIN)+ .args([+ "serve",+ "--transport",+ "http",+ "--bind",+ &format!("127.0.0.1:{port}"),+ "--workspace",+ WORKSPACE,+ "--project",+ PROJECT,+ "--no-watcher",+ ])+ .current_dir(&cwd)+ .env("AI_MEMORY_DATA_DIR", data_dir.path())+ .env("AI_MEMORY_HOME", home.path())+ .env("AI_MEMORY_EMBEDDING_PROVIDER", "none")+ .env("RUST_LOG", "off")+ .stdin(Stdio::null())+ .stdout(Stdio::null())+ .stderr(Stdio::null())+ .spawn()+ .expect("spawn serve"),+ );+let client = reqwest::Client::new();- let (server, base) = start_serve(&client, &data_dir.path().join("serve.log"), |port| {- let mut cmd = hermetic(BIN);- cmd.args([- "serve",- "--transport",- "http",- "--bind",- &format!("127.0.0.1:{port}"),- "--workspace",- WORKSPACE,- "--project",- PROJECT,- "--no-watcher",- ])- .env("AI_MEMORY_DATA_DIR", data_dir.path())- .env("AI_MEMORY_HOME", home.path())- .env("AI_MEMORY_EMBEDDING_PROVIDER", "none");- cmd.current_dir(&cwd);- cmd- })- .await;++ // Wait for the server to accept connections.+ let deadline = Instant::now() + Duration::from_secs(30);+ loop {+ if client+ .get(format!("{base}/mcp"))+ .timeout(Duration::from_secs(2))+ .send()+ .await+ .is_ok()+ {+ break;+ }+ assert!(Instant::now() < deadline, "server never became reachable");+ tokio::time::sleep(Duration::from_millis(150)).await;+ }// Phase 1 — the store is empty before backfill.assert_eq!(diff --git a/crates/ai-memory-cli/tests/suite/doctor_e2e.rs b/crates/ai-memory-cli/tests/suite/doctor_e2e.rsindex 74846569..cf373863 100644--- a/crates/ai-memory-cli/tests/suite/doctor_e2e.rs+++ b/crates/ai-memory-cli/tests/suite/doctor_e2e.rs@@ -36,11 +36,14 @@/// lives in the slow tier (`cargo tf` / CI), not the everyday loop.mod slow {use std::fs;+ use std::process::Stdio;use std::time::{Duration, Instant};use serde_json::{Value, json};- use crate::e2e_support::{hermetic, run_cli, session_count, start_serve, write_jsonl};+ use crate::e2e_support::{+ ServerGuard, free_port, hermetic, run_cli, session_count, write_jsonl,+ };const BIN: &str = env!("CARGO_BIN_EXE_ai-memory");const WORKSPACE: &str = "doctor-e2e-ws";@@ -95,28 +98,51 @@ mod slow {// Start the real server (loopback, no auth, hermetic: no embedder, no// wiki watcher — a machine-global inotify instance concurrent server// children can exhaust, #745).+ let port = free_port();+ let base = format!("http://127.0.0.1:{port}");+ let server = ServerGuard(+ hermetic(BIN)+ .args([+ "serve",+ "--transport",+ "http",+ "--bind",+ &format!("127.0.0.1:{port}"),+ "--workspace",+ WORKSPACE,+ "--project",+ PROJECT,+ "--no-watcher",+ ])+ .current_dir(&cwd)+ .env("AI_MEMORY_DATA_DIR", data_dir.path())+ .env("AI_MEMORY_HOME", home.path())+ .env("AI_MEMORY_EMBEDDING_PROVIDER", "none")+ .env("RUST_LOG", "off")+ .stdin(Stdio::null())+ .stdout(Stdio::null())+ .stderr(Stdio::null())+ .spawn()+ .expect("spawn serve"),+ );+let client = reqwest::Client::new();- let (server, base) = start_serve(&client, &data_dir.path().join("serve.log"), |port| {- let mut cmd = hermetic(BIN);- cmd.args([- "serve",- "--transport",- "http",- "--bind",- &format!("127.0.0.1:{port}"),- "--workspace",- WORKSPACE,- "--project",- PROJECT,- "--no-watcher",- ])- .env("AI_MEMORY_DATA_DIR", data_dir.path())- .env("AI_MEMORY_HOME", home.path())- .env("AI_MEMORY_EMBEDDING_PROVIDER", "none");- cmd.current_dir(&cwd);- cmd- })- .await;++ // Wait for the server to accept connections.+ let deadline = Instant::now() + Duration::from_secs(30);+ loop {+ if client+ .get(format!("{base}/mcp"))+ .timeout(Duration::from_secs(2))+ .send()+ .await+ .is_ok()+ {+ break;+ }+ assert!(Instant::now() < deadline, "server never became reachable");+ tokio::time::sleep(Duration::from_millis(150)).await;+ }// Precondition: nothing captured yet for this scope.assert_eq!(diff --git a/crates/ai-memory-cli/tests/suite/e2e_support.rs b/crates/ai-memory-cli/tests/suite/e2e_support.rsindex ec74aa5f..d8dc0a03 100644--- a/crates/ai-memory-cli/tests/suite/e2e_support.rs+++ b/crates/ai-memory-cli/tests/suite/e2e_support.rs@@ -3,8 +3,8 @@//! `backfill_e2e`, `doctor_e2e`, and `message_e2e` each drive the shipped//! `ai-memory` binary against a real `ai-memory serve` child, exactly as an//! operator would. These are the pieces they all share: a hermetic `Command`,-//! the server start and lifetime guard, ephemeral port allocation, the-//! `by-agent` session count, and the subcommand runner.+//! the server-lifetime guard, ephemeral port allocation, the `by-agent`+//! session count, and the subcommand runner.//!//! Kept deliberately cfg-agnostic (no `#![cfg(unix)]`) so the non-unix//! `message_e2e` can use it too. The genuinely POSIX-specific fixtures — the@@ -14,8 +14,7 @@use std::fs;use std::net::TcpListener;use std::path::Path;-use std::process::{Child, Command, Stdio};-use std::time::{Duration, Instant};+use std::process::{Child, Command};use serde_json::Value;@@ -45,8 +44,8 @@ impl Drop for ServerGuard {}}-/// A free loopback port. It is released before the caller binds it; a spawned-/// server goes through [`start_serve`], which survives losing that race.+/// A free loopback port. The brief unbind→rebind race is acceptable for a+/// slow-tier test and is the same approach the shell smoke test uses.pub fn free_port() -> u16 {TcpListener::bind("127.0.0.1:0").expect("bind ephemeral port")@@ -55,81 +54,6 @@ pub fn free_port() -> u16 {.port()}-/// What `serve` logs once its HTTP listener is bound, with the address.-const SERVE_READY: &str = "MCP HTTP server ready";--/// Start `ai-memory serve` on a free loopback port and wait until it answers-/// HTTP. `command` builds the configured serve command for a port; the-/// child's stderr goes to `log`, with the serve module's log turned on.-///-/// [`free_port`] releases the port before the server binds it, and under a-/// parallel test load another socket can take it in between. The server then-/// exits at once and a bare readiness loop only times out, hiding why; and-/// another test's server there would answer the probe. So the child must log-/// that it bound the port before an answer counts. A child that failed to-/// bind is restarted on a fresh port; any other exit, or no answer within the-/// deadline, panics with the child's stderr.-pub async fn start_serve(- client: &reqwest::Client,- log: &Path,- command: impl Fn(u16) -> Command,-) -> (ServerGuard, String) {- start_serve_on(client, log, command, free_port).await-}--async fn start_serve_on(- client: &reqwest::Client,- log: &Path,- command: impl Fn(u16) -> Command,- mut next_port: impl FnMut() -> u16,-) -> (ServerGuard, String) {- const ATTEMPTS: usize = 5;- let output = || fs::read_to_string(log).unwrap_or_default();- for _ in 0..ATTEMPTS {- let port = next_port();- let addr = format!("127.0.0.1:{port}");- let base = format!("http://{addr}");- let stderr = fs::File::create(log).expect("create serve log");- let mut server = ServerGuard(- command(port)- .env("RUST_LOG", "ai_memory_cli::commands::serve=info")- .stdin(Stdio::null())- .stdout(Stdio::null())- .stderr(stderr)- .spawn()- .expect("spawn serve"),- );- let deadline = Instant::now() + Duration::from_secs(30);- loop {- let bound = output()- .lines()- .any(|line| line.contains(SERVE_READY) && line.contains(&addr));- // Bounded so a stalled answer cannot hide the child's exit.- let answered = bound- && client- .get(format!("{base}/mcp"))- .timeout(Duration::from_secs(2))- .send()- .await- .is_ok();- match server.0.try_wait().expect("poll serve") {- None if answered => return (server, base),- None => {}- // `serve` reports a failed bind as `binding <addr>`.- Some(_) if output().contains(&format!("binding {addr}")) => break,- Some(status) => panic!("serve exited ({status}) before answering:\n{}", output()),- }- assert!(- Instant::now() < deadline,- "serve never answered on {base}:\n{}",- output()- );- tokio::time::sleep(Duration::from_millis(50)).await;- }- }- panic!("serve could not bind a free port in {ATTEMPTS} attempts");-}-/// Write the JSONL lines (each already a `Value`) as one transcript file.////// Only the POSIX-gated fixtures plant transcripts, so this is unused on@@ -209,68 +133,3 @@ pub fn run_cli();String::from_utf8(out.stdout).expect("stdout utf8")}--mod slow {- use super::*;-- fn serve(root: &Path, port: u16) -> Command {- let mut cmd = hermetic(BIN);- cmd.env("HOME", root)- .env("USERPROFILE", root)- .env("AI_MEMORY_HOME", root)- .env("AI_MEMORY_DATA_DIR", root.join("data"))- .env("AI_MEMORY_EMBEDDING_PROVIDER", "none")- .env("AI_MEMORY_BACKFILL_ON_START", "false")- .env("AI_MEMORY_AUTO_IMPROVE__SCHEDULER__ENABLED", "false")- .env("RUST_LOG", "off")- .current_dir(root)- .args(["serve", "--transport", "http", "--bind"])- .arg(format!("127.0.0.1:{port}"))- .arg("--no-watcher");- cmd- }-- /// A port taken between [`free_port`] and the server's bind makes the- /// server exit at once; the start moves to a fresh port instead of- /// waiting out the readiness deadline, and does not take the answer of- /// whatever holds the port for its own.- #[tokio::test]- async fn start_serve_moves_off_a_port_taken_before_the_bind() {- use std::io::{Read as _, Write as _};-- let root = tempfile::tempdir().unwrap().keep();- let taken = TcpListener::bind("127.0.0.1:0").unwrap();- let busy = taken.local_addr().unwrap().port();- std::thread::spawn(move || {- for mut stream in taken.incoming().flatten() {- let _ = stream.read(&mut [0; 1024]);- let _ = stream.write_all(b"HTTP/1.1 200 OK\r\ncontent-length: 0\r\n\r\n");- }- });- let mut ports = [busy].into_iter();- let client = reqwest::Client::new();- let started = Instant::now();- let (_server, base) = start_serve_on(- &client,- &root.join("serve.log"),- |port| serve(&root, port),- || ports.next().unwrap_or_else(free_port),- )- .await;- assert_ne!(base, format!("http://127.0.0.1:{busy}"));- assert!(started.elapsed() < Duration::from_secs(20));- }-- /// Any other early exit fails at once with the server's own error.- #[tokio::test]- #[should_panic(expected = "serve exited")]- async fn start_serve_reports_an_early_exit() {- let root = tempfile::tempdir().unwrap().keep();- start_serve(&reqwest::Client::new(), &root.join("serve.log"), |port| {- let mut cmd = serve(&root, port);- cmd.arg("--no-such-flag");- cmd- })- .await;- }-}diff --git a/crates/ai-memory-cli/tests/suite/external_capture.rs b/crates/ai-memory-cli/tests/suite/external_capture.rsindex 6ebca1e1..8ecbd93a 100644--- a/crates/ai-memory-cli/tests/suite/external_capture.rs+++ b/crates/ai-memory-cli/tests/suite/external_capture.rs@@ -109,13 +109,13 @@ fn capture_inspection_reports_external_ownership_without_side_effects() {mod slow {use super::*;use std::process::Command;- use std::time::Duration;+ use std::time::{Duration, Instant};use ai_memory_core::SessionId;use ai_memory_store::ReaderPool;use sha2::{Digest, Sha256};- use crate::e2e_support::{ServerGuard, start_serve};+ use crate::e2e_support::{ServerGuard, free_port};const TOKEN: &str = "external-capture-local-test-token";const MARKER: &str = "external_capture_handoff_marker";@@ -163,27 +163,46 @@ mod slow {"workspace = \"external-test\"\nproject = \"capture-test\"\n",).unwrap();+ let port = free_port();+ let base = format!("http://127.0.0.1:{port}");+ let server = ServerGuard(+ command(root.as_path())+ .args([+ "serve",+ "--transport",+ "http",+ "--bind",+ &format!("127.0.0.1:{port}"),+ "--workspace",+ "external-test",+ "--project",+ "capture-test",+ "--no-watcher",+ ])+ .stdin(Stdio::null())+ .stdout(Stdio::null())+ .stderr(Stdio::null())+ .spawn()+ .unwrap(),+ );let client = reqwest::Client::builder().timeout(Duration::from_secs(15)).build().unwrap();- let (server, base) = start_serve(&client, &root.as_path().join("serve.log"), |port| {- let mut cmd = command(root.as_path());- cmd.args([- "serve",- "--transport",- "http",- "--bind",- &format!("127.0.0.1:{port}"),- "--workspace",- "external-test",- "--project",- "capture-test",- "--no-watcher",- ]);- cmd- })- .await;+ let deadline = Instant::now() + Duration::from_secs(30);+ loop {+ if client+ .get(format!("{base}/mcp"))+ .bearer_auth(TOKEN)+ .send()+ .await+ .is_ok()+ {+ break;+ }+ assert!(Instant::now() < deadline, "server readiness timeout");+ tokio::time::sleep(Duration::from_millis(50)).await;+ }let reader = ReaderPool::new(&root.as_path().join("data/db/memory.sqlite"), 2).unwrap();Self {_server: server,diff --git a/crates/ai-memory-cli/tests/suite/external_capture_ts.rs b/crates/ai-memory-cli/tests/suite/external_capture_ts.rsindex ee7174fe..0ac6db37 100644--- a/crates/ai-memory-cli/tests/suite/external_capture_ts.rs+++ b/crates/ai-memory-cli/tests/suite/external_capture_ts.rs@@ -104,14 +104,7 @@ const server = createServer((req, res) => {res.writeHead(404);res.end();});-await new Promise<void>((resolve, reject) => {- server.once("error", reject);- server.listen(port, "127.0.0.1", () => resolve());-}).catch((error) => {- // Taken before Node could bind it; nothing has run yet, so the test retries.- if (error?.code === "EADDRINUSE") process.exit(75);- throw error;-});+await new Promise<void>((resolve) => server.listen(port, "127.0.0.1", () => resolve()));const hooks: any = await (AiMemoryHooks as any)({ directory });await hooks.event({ event: { type: "session.created", properties: { info: { id: "s1", directory } } } });@@ -131,7 +124,7 @@ console.log(JSON.stringify({ events, handoffs, system: transformed.system }));/// `GIT_CONFIG_*` leaking in from the harness would point it somewhere/// outside the fixture. `PATH` and the rest of the environment stay so/// Node and git still resolve.- fn run_plugin(dir: &Path, port: u16, owner: Option<&str>) -> Option<Value> {+ fn run_plugin(dir: &Path, port: u16, owner: Option<&str>) -> Value {let mut command = hermetic("node");for (key, _) in std::env::vars_os() {if key.to_string_lossy().starts_with("GIT_") {@@ -153,41 +146,13 @@ console.log(JSON.stringify({ events, handoffs, system: transformed.system }));command.env("AI_MEMORY_CAPTURE_OWNER", owner);}let output = command.output().expect("run generated plugin");- if output.status.code() == Some(PORT_TAKEN) {- return None;- }assert!(output.status.success(),"generated plugin run failed (owner={owner:?})\nstdout:\n{}\nstderr:\n{}",String::from_utf8_lossy(&output.stdout),String::from_utf8_lossy(&output.stderr),);- Some(serde_json::from_slice(&output.stdout).expect("harness JSON"))- }-- /// The harness's exit code when its port was taken before it could bind.- const PORT_TAKEN: i32 = 75;-- /// Writes the plugin, rendered for `port`, and the harness into `dir`.- fn write_fixture(dir: &Path, port: u16) {- let plugin = render_opencode_plugin(dir, &format!("http://127.0.0.1:{port}"));- std::fs::write(dir.join("ai-memory.ts"), &plugin).unwrap();- std::fs::write(dir.join("harness.ts"), HARNESS).unwrap();- }-- /// One plugin run on `port`. The plugin names its server at render time,- /// and [`free_port`] releases the port before Node binds it, so under a- /// parallel test load another socket can take it first. The harness then- /// stops before the plugin runs and the fixture moves to a fresh port.- fn run_on_free_port(dir: &Path, port: &mut u16, owner: Option<&str>) -> Value {- for _ in 0..5 {- if let Some(run) = run_plugin(dir, *port, owner) {- return run;- }- *port = free_port();- write_fixture(dir, *port);- }- panic!("the harness could not bind a free port in 5 attempts");+ serde_json::from_slice(&output.stdout).expect("harness JSON")}fn spooled_entries(dir: &Path) -> usize {@@ -222,10 +187,12 @@ console.log(JSON.stringify({ events, handoffs, system: transformed.system }));return;}let dir = fixture_root();- let mut port = free_port();- write_fixture(&dir, port);+ let port = free_port();+ let plugin = render_opencode_plugin(&dir, &format!("http://127.0.0.1:{port}"));+ std::fs::write(dir.join("ai-memory.ts"), &plugin).unwrap();+ std::fs::write(dir.join("harness.ts"), HARNESS).unwrap();- let owned = run_on_free_port(&dir, &mut port, Some("orchestrator-a"));+ let owned = run_plugin(&dir, port, Some("orchestrator-a"));assert!(delivered_events(&owned).is_empty(),"owned run must POST nothing: {owned}"@@ -239,7 +206,7 @@ console.log(JSON.stringify({ events, handoffs, system: transformed.system }));// plugin and harness must capture normally. Without them the// assertions above could pass on a harness that never delivers.for (label, owner) in [("unset", None), ("whitespace", Some(" \t\n"))] {- let captured = run_on_free_port(&dir, &mut port, owner);+ let captured = run_plugin(&dir, port, owner);let events = delivered_events(&captured);for expected in ["session-start", "user-prompt", "session-end"] {assert!(@@ -254,21 +221,4 @@ console.log(JSON.stringify({ events, handoffs, system: transformed.system })););}}-- /// A port taken before Node binds it moves the fixture to a fresh one- /// instead of failing the run.- #[test]- fn generated_plugin_fixture_moves_off_a_taken_port() {- if !node_strip_types_available() {- return;- }- let dir = fixture_root();- let taken = std::net::TcpListener::bind("127.0.0.1:0").unwrap();- let busy = taken.local_addr().unwrap().port();- let mut port = busy;- write_fixture(&dir, port);- let run = run_on_free_port(&dir, &mut port, None);- assert_ne!(port, busy);- assert!(delivered_events(&run).contains(&"session-start"), "{run}");- }}diff --git a/crates/ai-memory-cli/tests/suite/message_e2e.rs b/crates/ai-memory-cli/tests/suite/message_e2e.rsindex 605478b7..d344e408 100644--- a/crates/ai-memory-cli/tests/suite/message_e2e.rs+++ b/crates/ai-memory-cli/tests/suite/message_e2e.rs@@ -29,11 +29,12 @@/// lives in the slow tier (`cargo tf` / CI), not the everyday loop.mod slow {use std::path::Path;+ use std::process::Stdio;use std::time::{Duration, Instant};use serde_json::{Value, json};- use crate::e2e_support::{hermetic, run_cli, session_count, start_serve};+ use crate::e2e_support::{ServerGuard, free_port, hermetic, run_cli, session_count};const BIN: &str = env!("CARGO_BIN_EXE_ai-memory");const WORKSPACE: &str = "message-e2e-ws";@@ -148,27 +149,50 @@ mod slow {// Start the real server (loopback, no auth, hermetic: no embedder, no// wiki watcher — a machine-global inotify instance concurrent server// children can exhaust, #745).+ let port = free_port();+ let base = format!("http://127.0.0.1:{port}");+ let server = ServerGuard(+ hermetic(BIN)+ .args([+ "serve",+ "--transport",+ "http",+ "--bind",+ &format!("127.0.0.1:{port}"),+ "--workspace",+ WORKSPACE,+ "--project",+ SENDER,+ "--no-watcher",+ ])+ .env("AI_MEMORY_DATA_DIR", data_dir.path())+ .env("AI_MEMORY_HOME", home.path())+ .env("AI_MEMORY_EMBEDDING_PROVIDER", "none")+ .env("RUST_LOG", "off")+ .stdin(Stdio::null())+ .stdout(Stdio::null())+ .stderr(Stdio::null())+ .spawn()+ .expect("spawn serve"),+ );+let client = reqwest::Client::new();- let (server, base) = start_serve(&client, &data_dir.path().join("serve.log"), |port| {- let mut cmd = hermetic(BIN);- cmd.args([- "serve",- "--transport",- "http",- "--bind",- &format!("127.0.0.1:{port}"),- "--workspace",- WORKSPACE,- "--project",- SENDER,- "--no-watcher",- ])- .env("AI_MEMORY_DATA_DIR", data_dir.path())- .env("AI_MEMORY_HOME", home.path())- .env("AI_MEMORY_EMBEDDING_PROVIDER", "none");- cmd- })- .await;++ // Wait for the server to accept connections.+ let deadline = Instant::now() + Duration::from_secs(30);+ loop {+ if client+ .get(format!("{base}/mcp"))+ .timeout(Duration::from_secs(2))+ .send()+ .await+ .is_ok()+ {+ break;+ }+ assert!(Instant::now() < deadline, "server never became reachable");+ tokio::time::sleep(Duration::from_millis(150)).await;+ }// A send is rejected unless the recipient project already exists, so make// all three projects real by "running an agent" in each once.