Solution for long term memory for agent coding CLIs and to facilitate handoff between different agent vendors
Rust
fix(backfill): a non-root key can backfill on a multi-user server
luisfnicolaue90ef2d2814f
diff --git a/CHANGELOG.md b/CHANGELOG.mdindex c0229db6..99535fc6 100644--- a/CHANGELOG.md+++ b/CHANGELOG.md@@ -12,6 +12,10 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0provider. (#1026)### Fixed+- `backfill` works with a non-root key on a multi-user server. Its emptiness+ check used the root-only `/admin/sessions/by-agent` route, so every+ developer's own key got 403; on a 403 it now asks the grant-checked+ `GET /api/v1/workspaces/{ws}/projects/{p}/sessions` instead.- Fixed interrupted launchers blocking an immediate managed-workstream restartby adding explicit `ai-memory run --force-unlock` recovery. The serveratomically expires and replaces only a lease attributed to the samediff --git a/crates/ai-memory-cli/src/commands/backfill.rs b/crates/ai-memory-cli/src/commands/backfill.rsindex bab712a6..4c2d8a22 100644--- a/crates/ai-memory-cli/src/commands/backfill.rs+++ b/crates/ai-memory-cli/src/commands/backfill.rs@@ -291,12 +291,86 @@ async fn project_is_empty(// yet, so the no-create lookup answers 404 — which is the strongest// possible "empty", and the common case for a first-time backfill.Err(error) if super::is_scope_not_found(&error) => Ok(true),+ // A multi-user server keeps `/admin/*` for the operator, so a+ // developer's own key is refused here. Ask the grant-checked web API+ // instead: it answers for the sessions this caller can see.+ Err(error) if is_forbidden(&error) => {+ project_is_empty_for_member(endpoint, workspace, project).await+ }+ Err(error) => Err(error).with_context(|| {+ format!("checking whether {workspace}/{project} already has captured sessions")+ }),+ }+}++fn is_forbidden(error: &anyhow::Error) -> bool {+ error+ .downcast_ref::<crate::http_client::ServerResponseError>()+ .is_some_and(|response| response.status() == reqwest::StatusCode::FORBIDDEN)+}++/// The sessions the web API lists for a project, open ones included.+#[derive(Debug, Deserialize)]+struct SessionListResponse {+ sessions: Vec<serde_json::Value>,+}++/// [`project_is_empty`] through `GET /api/v1/workspaces/{ws}/projects/{p}/sessions`,+/// which any member may read. Its 404 means the project does not exist (or is+/// not this caller's to see); either way the hook ingress, not this check,+/// decides whether an import may write there. A 404 whose body is not a JSON+/// error — a server without the web API — stays an error: guessing "empty"+/// there could import history twice.+async fn project_is_empty_for_member(+ endpoint: &ServerEndpoint,+ workspace: &str,+ project: &str,+) -> Result<bool> {+ let path = member_sessions_path(workspace, project)?;+ match get_json::<SessionListResponse>(+ endpoint,+ &path,+ &[("limit", "1"), ("include_open", "true")],+ )+ .await+ {+ Ok(response) => Ok(response.sessions.is_empty()),+ Err(error) if is_json_not_found(&error) => Ok(true),Err(error) => Err(error).with_context(|| {format!("checking whether {workspace}/{project} already has captured sessions")}),}}+/// The path with each name percent-encoded as one segment, so a name can+/// never reach another route.+fn member_sessions_path(workspace: &str, project: &str) -> Result<String> {+ let mut url = reqwest::Url::parse("http://placeholder/")?;+ url.path_segments_mut()+ .map_err(|()| anyhow::anyhow!("placeholder URL cannot hold a path"))?+ .clear()+ .extend([+ "api",+ "v1",+ "workspaces",+ workspace,+ "projects",+ project,+ "sessions",+ ]);+ Ok(url.path().to_owned())+}++fn is_json_not_found(error: &anyhow::Error) -> bool {+ error+ .downcast_ref::<crate::http_client::ServerResponseError>()+ .is_some_and(|response| {+ response.status() == reqwest::StatusCode::NOT_FOUND+ && serde_json::from_str::<serde_json::Value>(response.body())+ .is_ok_and(|body| body.get("error").is_some())+ })+}+/// Enumerate local native sessions for `cwd` across every scanned harness./// Read-only; a harness whose store is absent/unreadable contributes nothing.///@@ -754,6 +828,18 @@ mod tests {);}+ #[test]+ fn member_sessions_path_encodes_each_name_as_one_segment() {+ assert_eq!(+ member_sessions_path("team", "app").unwrap(),+ "/api/v1/workspaces/team/projects/app/sessions"+ );+ assert_eq!(+ member_sessions_path("a/b", "c d?").unwrap(),+ "/api/v1/workspaces/a%2Fb/projects/c%20d%3F/sessions"+ );+ }+#[test]fn select_sessions_cap_zero_is_raised_to_one_by_caller_contract() {// The caller passes max_sessions.max(1); select_sessions itself honorsdiff --git a/crates/ai-memory-cli/tests/suite/backfill_member.rs b/crates/ai-memory-cli/tests/suite/backfill_member.rsnew file mode 100644index 00000000..9c327d25--- /dev/null+++ b/crates/ai-memory-cli/tests/suite/backfill_member.rs@@ -0,0 +1,102 @@+//! Backfill on a multi-user server, where `/admin/*` refuses a developer's own+//! key: the emptiness check falls back to the grant-checked web API.+use axum::{Json, Router, http::StatusCode, response::IntoResponse, routing::get};+use serde_json::{Value, json};++/// What the member-readable sessions route answers.+#[derive(Clone, Copy, Debug)]+enum Member {+ Empty,+ Populated,+ NotFound,+ NoWebApi,+ Forbidden,+}++async fn run_dry(member: Member) -> (bool, String, String) {+ let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();+ let addr = listener.local_addr().unwrap();+ let app = Router::new()+ .route(+ "/admin/sessions/by-agent",+ get(|| async {+ (+ StatusCode::FORBIDDEN,+ Json(json!({"error": "admin operation is root-only in multi-user mode"})),+ )+ }),+ )+ .route(+ "/api/v1/workspaces/review/projects/fixture/sessions",+ get(move || async move {+ match member {+ Member::Empty => Json(json!({"sessions": []})).into_response(),+ Member::Populated => {+ Json(json!({"sessions": [{"session_id": "s1"}]})).into_response()+ }+ Member::NotFound => (+ StatusCode::NOT_FOUND,+ Json(json!({"error": "project 'fixture' not found"})),+ )+ .into_response(),+ Member::NoWebApi => (StatusCode::NOT_FOUND, "").into_response(),+ Member::Forbidden => (+ StatusCode::FORBIDDEN,+ Json(json!({"error": "no access to this project"})),+ )+ .into_response(),+ }+ }),+ );+ let server = tokio::spawn(async move { axum::serve(listener, app).await.unwrap() });+ let data = tempfile::tempdir().unwrap();+ let home = tempfile::tempdir().unwrap();+ let cwd = tempfile::tempdir().unwrap();+ let mut cmd = crate::e2e_support::hermetic(env!("CARGO_BIN_EXE_ai-memory"));+ cmd.current_dir(cwd.path())+ .env("AI_MEMORY_HOME", home.path())+ .env("AI_MEMORY_DATA_DIR", data.path())+ .env("AI_MEMORY_SERVER_URL", format!("http://{addr}"))+ .args([+ "backfill",+ "--workspace",+ "review",+ "--project",+ "fixture",+ "--dry-run",+ "--json",+ ]);+ let output = tokio::process::Command::from(cmd).output().await.unwrap();+ server.abort();+ (+ output.status.success(),+ String::from_utf8(output.stdout).unwrap(),+ String::from_utf8(output.stderr).unwrap(),+ )+}++#[tokio::test]+async fn a_refused_admin_check_falls_back_to_the_member_sessions_route() {+ for (member, skipped) in [+ (Member::Empty, false),+ (Member::NotFound, false),+ (Member::Populated, true),+ ] {+ let (ok, stdout, stderr) = run_dry(member).await;+ assert!(ok, "{member:?}: backfill failed: {stderr}");+ let report: Value = serde_json::from_str(&stdout).unwrap();+ assert_eq!(report["skipped_non_empty"], skipped, "{member:?}: {stdout}");+ }+}++#[tokio::test]+async fn an_unanswerable_member_check_is_an_error_never_empty() {+ for member in [Member::NoWebApi, Member::Forbidden] {+ let (ok, stdout, stderr) = run_dry(member).await;+ assert!(!ok, "{member:?}: guessed an answer: {stdout}");+ assert!(+ stderr.contains("already has captured sessions"),+ "{member:?}: {stderr}"+ );+ }+}diff --git a/crates/ai-memory-cli/tests/suite/main.rs b/crates/ai-memory-cli/tests/suite/main.rsindex c422f05b..7ee7dfd7 100644--- a/crates/ai-memory-cli/tests/suite/main.rs+++ b/crates/ai-memory-cli/tests/suite/main.rs@@ -9,6 +9,7 @@ mod autoscope_env;mod backfill_dry_run;mod backfill_e2e;mod backfill_failures;+mod backfill_member;mod completions;mod doctor_e2e;mod e2e_support;