Skip to content

Solution for long term memory for agent coding CLIs and to facilitate handoff between different agent vendors

Rust

Merge remote-tracking branch 'upstream/main' into feature/admission-webhooks

Djalma Júnior67ce82247a4c
diff --cc crates/ai-memory-mcp/src/admin.rs
index 0a54becc,a1a34889..0fc7f2f6
--- a/crates/ai-memory-mcp/src/admin.rs
+++ b/crates/ai-memory-mcp/src/admin.rs
@@@ -1818,104 -2097,340 +2115,442 @@@ mod tests
assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
}
+ /// Bug E regression: purge deletes the project's DB rows first, so by the
+ /// time the admission chain fires, name-resolution from the (now gone)
+ /// project row would yield an empty name and a name-based mirror would
+ /// purge the wrong path. The handler must seed the admission context with
+ /// the request's workspace/project names. We capture the `purge_project`
+ /// webhook and assert it carries the real project name.
+ #[tokio::test]
+ async fn purge_project_admission_carries_the_project_name() {
+ use ai_memory_wiki::{AdmissionChain, FailurePolicy, WebhookConfig};
+ use axum::http::HeaderMap;
+ use axum::routing::post;
+ use std::sync::Mutex;
+
+ let captured: Arc<Mutex<Option<String>>> = Arc::new(Mutex::new(None));
+ let cap = captured.clone();
+ let app = Router::new().route(
+ "/sync",
+ post(
+ move |headers: HeaderMap, Json(payload): Json<serde_json::Value>| {
+ let cap = cap.clone();
+ async move {
+ if headers.get("X-Memory-Op").and_then(|v| v.to_str().ok())
+ == Some("purge_project")
+ {
+ *cap.lock().unwrap() = Some(
+ payload["ctx"]["project"]
+ .as_str()
+ .unwrap_or_default()
+ .to_string(),
+ );
+ }
+ StatusCode::NO_CONTENT
+ }
+ },
+ ),
+ );
+ let listener = tokio::net::TcpListener::bind("127.0.0.1:0").await.unwrap();
+ let base = format!("http://{}", listener.local_addr().unwrap());
+ tokio::spawn(async move { axum::serve(listener, app).await.unwrap() });
+ tokio::time::sleep(std::time::Duration::from_millis(20)).await;
+
+ let tmp = TempDir::new().unwrap();
+ let store = Store::open(tmp.path()).unwrap();
+ let chain = AdmissionChain::new(vec![WebhookConfig {
+ name: "mirror".into(),
+ url: format!("{base}/sync"),
+ timeout_ms: 2_000,
+ failure_policy: FailurePolicy::Ignore,
+ events: vec![AdmissionOp::WritePage, AdmissionOp::PurgeProject],
+ }])
+ .unwrap();
+ let wiki = Wiki::new(tmp.path(), store.writer.clone())
+ .unwrap()
+ .with_admission_chain(chain)
+ .with_store_reader(store.reader.clone());
+ let router = admin_router(AdminState {
+ writer: store.writer.clone(),
+ reader: store.reader.clone(),
+ wiki,
+ llm: None,
+ embedder: None,
+ provider_health: ProviderHealth::default(),
+ decay_params: DecayParams::default(),
+ data_dir: tmp.path().to_path_buf(),
+ db_path: store.db_path().to_path_buf(),
+ bind: "127.0.0.1:49374".to_string(),
+ bootstrap_lock: Arc::new(tokio::sync::Mutex::new(())),
++ token_pepper: None,
+ });
+
+ post_write_page(&router, "default", "doomed", "notes/x.md", "bye").await;
+
+ let resp = router
+ .clone()
+ .oneshot(
+ Request::builder()
+ .method("POST")
+ .uri("/admin/purge-project")
+ .header("content-type", "application/json")
+ .body(Body::from(
+ serde_json::to_vec(&serde_json::json!({
+ "workspace": "default",
+ "project": "doomed",
+ "confirm": true,
+ }))
+ .unwrap(),
+ ))
+ .unwrap(),
+ )
+ .await
+ .unwrap();
+ assert_eq!(resp.status(), StatusCode::OK, "purge should succeed");
+
+ // Let the async notify land.
+ tokio::time::sleep(std::time::Duration::from_millis(50)).await;
+ assert_eq!(
+ captured.lock().unwrap().as_deref(),
+ Some("doomed"),
+ "purge admission must carry the real project name, not an empty/_unscoped placeholder"
+ );
+ }
++
+ // ── user-management endpoints (P1.4) ──────────────────────────
+
+ /// Test router that has a token pepper configured (so user-management
+ /// endpoints don't return 503), runs the standard auth middleware
+ /// upstream so `Extension<AuthLevel>` is populated, and is reachable
+ /// as Root via a fixed bearer token.
+ fn user_admin_test_router(root_token: &'static str) -> (TempDir, Router) {
+ use ai_memory_core::ActorContext;
+ let tmp = TempDir::new().unwrap();
+ let store = Store::open(tmp.path()).unwrap();
+ let wiki = Wiki::new(tmp.path(), store.writer.clone()).unwrap();
+ let pepper = ai_memory_store::TokenPepper::new("test-pepper-admin");
+ let router = admin_router(AdminState {
+ writer: store.writer.clone(),
+ reader: store.reader.clone(),
+ wiki,
+ llm: None,
+ embedder: None,
+ provider_health: ProviderHealth::default(),
+ decay_params: DecayParams::default(),
+ data_dir: tmp.path().to_path_buf(),
+ db_path: store.db_path().to_path_buf(),
+ bind: "127.0.0.1:49374".to_string(),
+ bootstrap_lock: Arc::new(tokio::sync::Mutex::new(())),
+ token_pepper: Some(pepper),
+ });
+ // Wrap in a middleware that stamps the AuthLevel ourselves —
+ // the real auth middleware lives in ai-memory-cli, and this
+ // crate can't depend on it. The wrapper matches the Bearer
+ // header against `root_token`: match → Root, present-but-no-
+ // match → User (so we can test 403), absent → Anonymous.
+ let router = router.layer(axum::middleware::from_fn(
+ move |mut req: Request<Body>, next: axum::middleware::Next| async move {
+ let bearer = req
+ .headers()
+ .get(axum::http::header::AUTHORIZATION)
+ .and_then(|h| h.to_str().ok())
+ .and_then(|s| s.strip_prefix("Bearer "))
+ .map(str::to_string);
+ let level = match bearer.as_deref() {
+ Some(t) if t == root_token => ai_memory_core::AuthLevel::Root,
+ Some(_) => ai_memory_core::AuthLevel::User,
+ None => ai_memory_core::AuthLevel::Anonymous,
+ };
+ req.extensions_mut().insert(level);
+ req.extensions_mut().insert(ActorContext::anonymous());
+ next.run(req).await
+ },
+ ));
+ (tmp, router)
+ }
+
+ async fn post_create_user(
+ router: &Router,
+ root_token: &str,
+ body: serde_json::Value,
+ ) -> axum::http::Response<Body> {
+ router
+ .clone()
+ .oneshot(
+ Request::builder()
+ .method("POST")
+ .uri("/admin/users")
+ .header("content-type", "application/json")
+ .header("authorization", format!("Bearer {root_token}"))
+ .body(Body::from(serde_json::to_vec(&body).unwrap()))
+ .unwrap(),
+ )
+ .await
+ .unwrap()
+ }
+
+ #[tokio::test]
+ async fn create_user_happy_path_returns_token_once() {
+ let (_tmp, router) = user_admin_test_router("root-token");
+ let resp = post_create_user(
+ &router,
+ "root-token",
+ serde_json::json!({
+ "username": "alice",
+ "name": "Alice Smith",
+ "email": "[email protected]"
+ }),
+ )
+ .await;
+ assert_eq!(resp.status(), StatusCode::OK);
+ let body = to_bytes(resp.into_body(), usize::MAX).await.unwrap();
+ let json: serde_json::Value = serde_json::from_slice(&body).unwrap();
+ assert_eq!(json["user"]["username"], "alice");
+ // Email was normalised to lowercase by NewUser::validate.
+ assert_eq!(json["user"]["email"], "[email protected]");
+ assert_eq!(json["user"]["name"], "Alice Smith");
+ // Plaintext token is surfaced exactly once — 43 chars (32 bytes
+ // URL-safe-base64).
+ let token = json["token"].as_str().unwrap();
+ assert_eq!(token.len(), 43);
+ }
+
+ #[tokio::test]
+ async fn create_user_rejects_duplicate_username_with_409() {
+ let (_tmp, router) = user_admin_test_router("root-token");
+ let _ = post_create_user(
+ &router,
+ "root-token",
+ serde_json::json!({"username": "alice"}),
+ )
+ .await;
+ let resp = post_create_user(
+ &router,
+ "root-token",
+ serde_json::json!({"username": "alice"}),
+ )
+ .await;
+ assert_eq!(resp.status(), StatusCode::CONFLICT);
+ }
+
+ #[tokio::test]
+ async fn create_user_rejects_invalid_email_with_400() {
+ let (_tmp, router) = user_admin_test_router("root-token");
+ let resp = post_create_user(
+ &router,
+ "root-token",
+ serde_json::json!({"username": "alice", "email": "not-an-email"}),
+ )
+ .await;
+ assert_eq!(resp.status(), StatusCode::BAD_REQUEST);
+ }
+
+ #[tokio::test]
+ async fn create_user_as_anonymous_returns_401() {
+ let (_tmp, router) = user_admin_test_router("root-token");
+ // No Authorization header → middleware stamps Anonymous tier.
+ let resp = router
+ .oneshot(
+ Request::builder()
+ .method("POST")
+ .uri("/admin/users")
+ .header("content-type", "application/json")
+ .body(Body::from(
+ serde_json::to_vec(&serde_json::json!({"username": "alice"})).unwrap(),
+ ))
+ .unwrap(),
+ )
+ .await
+ .unwrap();
+ assert_eq!(resp.status(), StatusCode::UNAUTHORIZED);
+ }
+
+ #[tokio::test]
+ async fn create_user_as_user_tier_returns_403() {
+ let (_tmp, router) = user_admin_test_router("root-token");
+ let resp = post_create_user(
+ &router,
+ "not-the-root-token",
+ serde_json::json!({"username": "alice"}),
+ )
+ .await;
+ assert_eq!(resp.status(), StatusCode::FORBIDDEN);
+ }
+
+ #[tokio::test]
+ async fn list_users_returns_added_users_in_insertion_order() {
+ let (_tmp, router) = user_admin_test_router("root-token");
+ for n in ["alice", "bob", "carol"] {
+ let _ =
+ post_create_user(&router, "root-token", serde_json::json!({"username": n})).await;
+ }
+ let resp = router
+ .oneshot(
+ Request::builder()
+ .uri("/admin/users")
+ .header("authorization", "Bearer root-token")
+ .body(Body::empty())
+ .unwrap(),
+ )
+ .await
+ .unwrap();
+ assert_eq!(resp.status(), StatusCode::OK);
+ let body = to_bytes(resp.into_body(), usize::MAX).await.unwrap();
+ let json: serde_json::Value = serde_json::from_slice(&body).unwrap();
+ let users = json["users"].as_array().unwrap();
+ assert_eq!(users.len(), 3);
+ assert_eq!(users[0]["username"], "alice");
+ assert_eq!(users[1]["username"], "bob");
+ assert_eq!(users[2]["username"], "carol");
+ // Tokens are NEVER surfaced by the list endpoint.
+ for u in users {
+ assert!(u.get("token").is_none(), "list must not leak tokens");
+ }
+ }
+
+ #[tokio::test]
+ async fn expire_then_revive_round_trips() {
+ let (_tmp, router) = user_admin_test_router("root-token");
+ let _ = post_create_user(
+ &router,
+ "root-token",
+ serde_json::json!({"username": "alice"}),
+ )
+ .await;
+
+ // Expire.
+ let resp = router
+ .clone()
+ .oneshot(
+ Request::builder()
+ .method("POST")
+ .uri("/admin/users/alice/expire")
+ .header("authorization", "Bearer root-token")
+ .body(Body::empty())
+ .unwrap(),
+ )
+ .await
+ .unwrap();
+ assert_eq!(resp.status(), StatusCode::OK);
+ let body = to_bytes(resp.into_body(), usize::MAX).await.unwrap();
+ let json: serde_json::Value = serde_json::from_slice(&body).unwrap();
+ assert!(json["user"]["token_expired_at"].is_i64());
+
+ // Revive.
+ let resp = router
+ .oneshot(
+ Request::builder()
+ .method("POST")
+ .uri("/admin/users/alice/revive")
+ .header("authorization", "Bearer root-token")
+ .body(Body::empty())
+ .unwrap(),
+ )
+ .await
+ .unwrap();
+ assert_eq!(resp.status(), StatusCode::OK);
+ let body = to_bytes(resp.into_body(), usize::MAX).await.unwrap();
+ let json: serde_json::Value = serde_json::from_slice(&body).unwrap();
+ assert!(json["user"]["token_expired_at"].is_null());
+ }
+
+ #[tokio::test]
+ async fn expire_unknown_user_returns_404() {
+ let (_tmp, router) = user_admin_test_router("root-token");
+ let resp = router
+ .oneshot(
+ Request::builder()
+ .method("POST")
+ .uri("/admin/users/ghost/expire")
+ .header("authorization", "Bearer root-token")
+ .body(Body::empty())
+ .unwrap(),
+ )
+ .await
+ .unwrap();
+ assert_eq!(resp.status(), StatusCode::NOT_FOUND);
+ }
+
+ #[tokio::test]
+ async fn rotate_token_issues_a_distinct_token() {
+ let (_tmp, router) = user_admin_test_router("root-token");
+ let create_resp = post_create_user(
+ &router,
+ "root-token",
+ serde_json::json!({"username": "alice"}),
+ )
+ .await;
+ let body = to_bytes(create_resp.into_body(), usize::MAX).await.unwrap();
+ let original_token = serde_json::from_slice::<serde_json::Value>(&body).unwrap()["token"]
+ .as_str()
+ .unwrap()
+ .to_string();
+
+ let resp = router
+ .oneshot(
+ Request::builder()
+ .method("POST")
+ .uri("/admin/users/alice/rotate-token")
+ .header("authorization", "Bearer root-token")
+ .body(Body::empty())
+ .unwrap(),
+ )
+ .await
+ .unwrap();
+ assert_eq!(resp.status(), StatusCode::OK);
+ let body = to_bytes(resp.into_body(), usize::MAX).await.unwrap();
+ let json: serde_json::Value = serde_json::from_slice(&body).unwrap();
+ let new_token = json["token"].as_str().unwrap();
+ assert_eq!(new_token.len(), 43);
+ assert_ne!(new_token, original_token, "rotate must change the token");
+ }
+
+ #[tokio::test]
+ async fn create_user_returns_503_when_pepper_not_configured() {
+ // Same as user_admin_test_router but with token_pepper = None,
+ // covering the "rung 1-only" backward-compat install.
+ use ai_memory_core::ActorContext;
+ let tmp = TempDir::new().unwrap();
+ let store = Store::open(tmp.path()).unwrap();
+ let wiki = Wiki::new(tmp.path(), store.writer.clone()).unwrap();
+ let router = admin_router(AdminState {
+ writer: store.writer.clone(),
+ reader: store.reader.clone(),
+ wiki,
+ llm: None,
+ embedder: None,
+ provider_health: ProviderHealth::default(),
+ decay_params: DecayParams::default(),
+ data_dir: tmp.path().to_path_buf(),
+ db_path: store.db_path().to_path_buf(),
+ bind: "127.0.0.1:49374".to_string(),
+ bootstrap_lock: Arc::new(tokio::sync::Mutex::new(())),
+ token_pepper: None,
+ });
+ // Inject a Root level so we're past the require_root gate;
+ // the 503 must come from require_pepper.
+ let router = router.layer(axum::middleware::from_fn(
+ |mut req: Request<Body>, next: axum::middleware::Next| async move {
+ req.extensions_mut().insert(ai_memory_core::AuthLevel::Root);
+ req.extensions_mut().insert(ActorContext::anonymous());
+ next.run(req).await
+ },
+ ));
+
+ let resp = router
+ .oneshot(
+ Request::builder()
+ .method("POST")
+ .uri("/admin/users")
+ .header("content-type", "application/json")
+ .body(Body::from(
+ serde_json::to_vec(&serde_json::json!({"username": "alice"})).unwrap(),
+ ))
+ .unwrap(),
+ )
+ .await
+ .unwrap();
+ assert_eq!(resp.status(), StatusCode::SERVICE_UNAVAILABLE);
+ let _ = tmp;
+ }
}