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.rsindex 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 testsassert_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;+ }}