Skip to content

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.md
index 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.0
provider. (#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 restart
by adding explicit `ai-memory run --force-unlock` recovery. The server
atomically expires and replaces only a lease attributed to the same
diff --git a/crates/ai-memory-cli/src/commands/backfill.rs b/crates/ai-memory-cli/src/commands/backfill.rs
index 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 honors
diff --git a/crates/ai-memory-cli/tests/suite/backfill_member.rs b/crates/ai-memory-cli/tests/suite/backfill_member.rs
new file mode 100644
index 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.rs
index 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;