Solution for long term memory for agent coding CLIs and to facilitate handoff between different agent vendors
Rust
//! Integration tests against a fixture `/api/v1` server (axum, temp port):
//! 200/ETag/304/401/404 and incremental-cursor pagination, plus the
//! end-to-end plan/export/local-edit-refusal flow through `run`, and the
//! sync flow through the fixture's `POST /mcp`, which enforces the
//! server's conditional-write contract.
use std::collections::BTreeMap;
use std::fs;
use std::net::SocketAddr;
use std::path::PathBuf;
use std::sync::atomic::{AtomicUsize, Ordering};
use std::sync::{Arc, Mutex};
use ai_memory_wikisync::bidi::{self, CheckStatus, Outcome, Prefer, SyncArgs, SyncMode};
use ai_memory_wikisync::state::{self, SyncState};
use ai_memory_wikisync::sync::{Mode, RunArgs, run};
use axum::extract::{Path, Query, State};
use axum::http::{HeaderMap, StatusCode, header};
use axum::response::IntoResponse;
use axum::routing::{get, post};
use axum::{Json, Router};
use serde_json::json;
use tokio::net::TcpListener;
/// One fixture page: what the real server's page read returns, reduced to
/// the fields wikisync reads.
#[derive(Clone)]
struct FixturePage {
/// Version id: a new one for every write, like the server's page id.
id: String,
path: String,
body: String,
title: String,
tier: String,
pinned: bool,
frontmatter: serde_json::Value,
}
impl FixturePage {
fn new(path: &str, body: &str) -> Self {
Self {
id: next_version(),
path: path.to_string(),
body: body.to_string(),
title: format!("title {path}"),
tier: "semantic".to_string(),
pinned: false,
frontmatter: json!({}),
}
}
}
/// A fresh version id. Global, so ids never repeat across fixture servers.
fn next_version() -> String {
static NEXT: AtomicUsize = AtomicUsize::new(1);
format!(
"00000000-0000-7000-8000-{:012}",
NEXT.fetch_add(1, Ordering::SeqCst)
)
}
/// Fixture server state: pages, optional bearer token, call counters.
struct Fixture {
/// Pages in listing order.
pages: Mutex<Vec<FixturePage>>,
token: Option<&'static str>,
project_exists: bool,
/// Page advertised by the listing but missing on read, to simulate a
/// delete/expiry racing the run.
unreachable: Option<&'static str>,
/// Rewrite this page's body on its Nth read (1-based), to simulate an
/// edit landing between a sync's classification and its write.
edit_on_read: Option<(&'static str, usize)>,
/// Edit after capturing the Nth read's snapshot, before the next request.
/// The response still describes the old version, whether 200 or 304.
edit_after_read: Option<(&'static str, usize)>,
/// Save an editor's local change while the next page request is in flight.
repository_edit_on_read: Mutex<Option<(PathBuf, Vec<u8>)>>,
/// Text the fixture's write path redacts, like the server's sanitizer.
redact: Option<&'static str>,
/// Edit this page right before an MCP call on it is handled, to simulate
/// another writer landing between a sync's classification and its write.
edit_before_mcp: Option<&'static str>,
/// A server older than 3.0: no `expected_page_id` in the tool schema, no
/// `id` on pages, and preconditions silently ignored.
old_server: bool,
/// Serve a listing for any project name, not only `app`. Lets a test model
/// a second project on one server whose listing is successfully empty
/// (#1708) instead of a 404.
any_project: bool,
/// Arguments of every MCP tool call, in order.
mcp_calls: Mutex<Vec<serde_json::Value>>,
reads_by_path: Mutex<BTreeMap<String, usize>>,
recent_calls: AtomicUsize,
page_reads_200: AtomicUsize,
page_reads_304: AtomicUsize,
mcp_writes: AtomicUsize,
mcp_deletes: AtomicUsize,
}
impl Fixture {
fn new(pages: Vec<(String, String)>) -> Self {
Self::with_pages(
pages
.iter()
.map(|(path, body)| FixturePage::new(path, body))
.collect(),
)
}
fn with_pages(pages: Vec<FixturePage>) -> Self {
Self {
pages: Mutex::new(pages),
token: None,
project_exists: true,
unreachable: None,
edit_on_read: None,
edit_after_read: None,
repository_edit_on_read: Mutex::new(None),
redact: None,
edit_before_mcp: None,
old_server: false,
any_project: false,
mcp_calls: Mutex::new(Vec::new()),
reads_by_path: Mutex::new(BTreeMap::new()),
recent_calls: AtomicUsize::new(0),
page_reads_200: AtomicUsize::new(0),
page_reads_304: AtomicUsize::new(0),
mcp_writes: AtomicUsize::new(0),
mcp_deletes: AtomicUsize::new(0),
}
}
fn with_token(mut self, token: &'static str) -> Self {
self.token = Some(token);
self
}
fn missing_project(mut self) -> Self {
self.project_exists = false;
self
}
fn with_unreachable(mut self, path: &'static str) -> Self {
self.unreachable = Some(path);
self
}
fn page(&self, path: &str) -> Option<FixturePage> {
self.pages
.lock()
.unwrap()
.iter()
.find(|page| page.path == path)
.cloned()
}
fn update(&self, path: &str, edit: impl FnOnce(&mut FixturePage)) {
let mut pages = self.pages.lock().unwrap();
let page = pages
.iter_mut()
.find(|page| page.path == path)
.expect("fixture page");
edit(page);
page.id = next_version();
}
fn remove(&self, path: &str) {
self.pages.lock().unwrap().retain(|page| page.path != path);
}
fn authorize(&self, headers: &HeaderMap) -> Result<(), Box<axum::response::Response>> {
let expected = match self.token {
None => return Ok(()),
Some(token) => format!("Bearer {token}"),
};
match headers
.get(header::AUTHORIZATION)
.and_then(|value| value.to_str().ok())
{
Some(value) if value == expected => Ok(()),
_ => Err(Box::new(error_json(
StatusCode::UNAUTHORIZED,
"unauthorized",
))),
}
}
}
fn error_json(status: StatusCode, message: &str) -> axum::response::Response {
(status, Json(json!({ "error": message }))).into_response()
}
/// Incremental `recent` listing with a page size of 2, so tests exercise
/// cursor pagination. The cursor is an opaque index string.
async fn recent_handler(
State(fixture): State<Arc<Fixture>>,
Path((workspace, project)): Path<(String, String)>,
Query(query): Query<BTreeMap<String, String>>,
headers: HeaderMap,
) -> axum::response::Response {
fixture.recent_calls.fetch_add(1, Ordering::SeqCst);
if let Err(response) = fixture.authorize(&headers) {
return *response;
}
if !fixture.project_exists || workspace != "demo" || (project != "app" && !fixture.any_project)
{
return error_json(StatusCode::NOT_FOUND, "workspace or project not found");
}
// Ignore updated_since; the fixture serves everything after the epoch.
let start: usize = query
.get("cursor")
.and_then(|value| value.strip_prefix("idx:"))
.and_then(|value| value.parse().ok())
.unwrap_or(0);
let all = fixture.pages.lock().unwrap().clone();
let end = (start + 2).min(all.len());
let pages: Vec<serde_json::Value> = all[start..end]
.iter()
.enumerate()
.map(|(offset, page)| {
json!({
"path": page.path,
"title": page.title,
"kind": "note",
"tier": "semantic",
"updated_at": format!("2026-10-0{}T00:00:00Z", start + offset + 1),
})
})
.collect();
let next_cursor = if end < all.len() {
json!(format!("idx:{end}"))
} else {
json!(null)
};
(
[(header::CACHE_CONTROL, "private, no-store")],
Json(json!({ "pages": pages, "next_cursor": next_cursor })),
)
.into_response()
}
/// Page read with the server's exact-ETag 304 contract.
async fn page_handler(
State(fixture): State<Arc<Fixture>>,
Path((workspace, project, path)): Path<(String, String, String)>,
headers: HeaderMap,
) -> axum::response::Response {
if let Err(response) = fixture.authorize(&headers) {
return *response;
}
if !fixture.project_exists || workspace != "demo" || (project != "app" && !fixture.any_project)
{
return error_json(StatusCode::NOT_FOUND, "workspace or project not found");
}
if fixture.unreachable == Some(path.as_str()) {
return error_json(StatusCode::NOT_FOUND, "page not found");
}
if let Some((path, bytes)) = fixture.repository_edit_on_read.lock().unwrap().take() {
fs::create_dir_all(path.parent().unwrap()).unwrap();
fs::write(path, bytes).unwrap();
}
let read_count = {
let mut reads = fixture.reads_by_path.lock().unwrap();
let count = reads.entry(path.clone()).or_insert(0);
*count += 1;
*count
};
if let Some((target, nth)) = fixture.edit_on_read
&& target == path
&& nth == read_count
{
fixture.update(&path, |page| page.body.push_str("edited concurrently\n"));
}
let Some(page) = fixture.page(&path) else {
return error_json(StatusCode::NOT_FOUND, "page not found");
};
let mut frontmatter = page.frontmatter.clone();
frontmatter["tier"] = json!(page.tier);
if page.pinned {
frontmatter["pinned"] = json!(true);
}
let mut document = json!({
"id": page.id,
"project": project,
"workspace": workspace,
"path": path,
"title": page.title,
"kind": "note",
"tier": page.tier,
"pinned": page.pinned,
"created_at": "2026-10-01T00:00:00Z",
"updated_at": "2026-10-01T00:00:00Z",
"supersedes": null,
"frontmatter": frontmatter,
"body_markdown": page.body,
"links": [],
"backlinks": [],
});
if fixture.old_server {
document.as_object_mut().unwrap().remove("id");
}
// Like the server: the ETag covers the whole projection, so a change to
// metadata alone also changes it.
let etag = format!("\"{}\"", state::sha256_hex(document.to_string().as_bytes()));
if let Some((target, nth)) = fixture.edit_after_read
&& target == path
&& nth == read_count
{
fixture.update(&path, |page| page.body.push_str("edited concurrently\n"));
}
if let Some(if_none_match) = headers
.get(header::IF_NONE_MATCH)
.and_then(|v| v.to_str().ok())
&& if_none_match == etag
{
fixture.page_reads_304.fetch_add(1, Ordering::SeqCst);
return (
StatusCode::NOT_MODIFIED,
[(header::ETAG, etag)],
axum::body::Body::empty(),
)
.into_response();
}
fixture.page_reads_200.fetch_add(1, Ordering::SeqCst);
(
StatusCode::OK,
[
(header::ETAG, etag),
(header::CONTENT_TYPE, "application/json".to_string()),
],
Json(document),
)
.into_response()
}
fn rpc_result(id: &serde_json::Value, result: serde_json::Value) -> axum::response::Response {
Json(json!({"jsonrpc": "2.0", "id": id, "result": result})).into_response()
}
fn tool_text(id: &serde_json::Value, is_error: bool, text: String) -> axum::response::Response {
rpc_result(
id,
json!({"isError": is_error, "content": [{"type": "text", "text": text}]}),
)
}
/// The server's precondition failure: `invalid_request` with typed data.
fn precondition_failed(
id: &serde_json::Value,
path: &str,
expected: Option<&str>,
current: Option<&str>,
) -> axum::response::Response {
Json(json!({"jsonrpc": "2.0", "id": id, "error": {
"code": -32600,
"message": format!("precondition failed for {path}; nothing was changed"),
"data": {
"reason": "precondition_failed",
"path": path,
"expected_page_id": expected,
"current_page_id": current,
},
}}))
.into_response()
}
/// `POST /mcp`: `tools/list`, and `tools/call` of `memory_write_page` (the
/// server's replace semantics: every field the call omits is cleared, and the
/// stored body passes a redaction step like the server's sanitizer) and
/// `memory_delete_page`, both honouring `expected_page_id` / `create_only`.
async fn mcp_handler(
State(fixture): State<Arc<Fixture>>,
headers: HeaderMap,
Json(request): Json<serde_json::Value>,
) -> axum::response::Response {
if let Err(response) = fixture.authorize(&headers) {
return *response;
}
let accept = headers
.get(header::ACCEPT)
.and_then(|value| value.to_str().ok())
.unwrap_or_default();
if !(accept.contains("application/json") && accept.contains("text/event-stream")) {
return StatusCode::NOT_ACCEPTABLE.into_response();
}
let id = &request["id"];
if request["method"] == "tools/list" {
let mut properties = json!({"path": {"type": "string"}, "body": {"type": "string"}});
if !fixture.old_server {
properties["expected_page_id"] = json!({"type": "string"});
properties["create_only"] = json!({"type": "boolean"});
}
return rpc_result(
id,
json!({"tools": [
{"name": "memory_read_page", "inputSchema": {"type": "object"}},
{"name": "memory_write_page",
"inputSchema": {"type": "object", "properties": properties}},
]}),
);
}
let name = request["params"]["name"].as_str().unwrap_or_default();
let args = &request["params"]["arguments"];
if request["method"] != "tools/call"
|| !matches!(name, "memory_write_page" | "memory_delete_page")
|| args["workspace"] != "demo"
|| args["project"] != "app"
{
return tool_text(id, true, "bad call".to_string());
}
fixture.mcp_calls.lock().unwrap().push(json!({
"name": name,
"arguments": args,
}));
let path = args["path"].as_str().unwrap_or_default().to_string();
if fixture.edit_before_mcp == Some(path.as_str()) && fixture.page(&path).is_some() {
fixture.update(&path, |page| page.body.push_str("edited concurrently\n"));
}
let current = fixture.page(&path).map(|page| page.id);
let expected = args["expected_page_id"].as_str();
let create_only = args["create_only"].as_bool() == Some(true);
if !fixture.old_server {
let holds = match (expected, create_only) {
(Some(expected), _) => current.as_deref() == Some(expected),
(None, true) => current.is_none(),
(None, false) => true,
};
if !holds {
return precondition_failed(id, &path, expected, current.as_deref());
}
}
if name == "memory_delete_page" {
if current.is_none() {
return tool_text(id, true, format!("no page at {path}"));
}
fixture.remove(&path);
fixture.mcp_deletes.fetch_add(1, Ordering::SeqCst);
return tool_text(
id,
false,
json!({"path": path, "deleted": true}).to_string(),
);
}
fixture.mcp_writes.fetch_add(1, Ordering::SeqCst);
let mut body = args["body"].as_str().unwrap_or_default().to_string();
if let Some(secret) = fixture.redact {
body = body.replace(secret, "[REDACTED]");
}
let mut written = FixturePage::new(&path, &body);
if let Some(title) = args["title"].as_str() {
written.title = title.to_string();
}
if let Some(tier) = args["tier"].as_str() {
written.tier = tier.to_string();
}
written.pinned = args["pinned"].as_bool().unwrap_or(false);
if let Some(tags) = args["tags"].as_array().filter(|tags| !tags.is_empty()) {
written.frontmatter = json!({ "tags": tags });
}
let page_id = written.id.clone();
{
let mut pages = fixture.pages.lock().unwrap();
pages.retain(|page| page.path != path);
pages.push(written);
}
tool_text(
id,
false,
json!({"page_id": page_id, "path": path}).to_string(),
)
}
async fn serve(fixture: Fixture) -> (SocketAddr, Arc<Fixture>) {
let shared = Arc::new(fixture);
let app = Router::new()
.route(
"/api/v1/workspaces/{workspace}/projects/{project}/recent",
get(recent_handler),
)
.route(
"/api/v1/workspaces/{workspace}/projects/{project}/pages/{*path}",
get(page_handler),
)
.route("/mcp", post(mcp_handler))
.with_state(shared.clone());
let listener = TcpListener::bind("127.0.0.1:0")
.await
.expect("bind fixture server");
let addr = listener.local_addr().expect("fixture addr");
tokio::spawn(async move {
axum::serve(listener, app).await.expect("fixture server");
});
(addr, shared)
}
fn args(addr: SocketAddr, dest: &std::path::Path, families: &[&str]) -> RunArgs {
RunArgs {
server: format!("http://{addr}"),
token: None,
workspace: "demo".to_string(),
project: "app".to_string(),
dest: dest.to_path_buf(),
include: families.iter().map(|f| f.to_string()).collect(),
force: false,
adopt_scope: false,
}
}
fn fixture_pages() -> Vec<(String, String)> {
vec![
(
"_rules/postgres.md".to_string(),
"# Postgres only\nUse Postgres.\n".to_string(),
),
(
"decisions/0001-db.md".to_string(),
"# Standardised on Postgres\nBody.\n".to_string(),
),
("notes/a.md".to_string(), "# A\nalpha\n".to_string()),
("notes/b.md".to_string(), "# B\nbeta\n".to_string()),
("notes/c.md".to_string(), "# C\ngamma\n".to_string()),
]
}
/// The file export writes for a fixture page: the fixture's title as
/// frontmatter, then the body verbatim.
fn file(path: &str, body: &str) -> Vec<u8> {
format!("---\ntitle: \"title {path}\"\n---\n{body}").into_bytes()
}
fn temp_dest() -> (tempfile::TempDir, PathBuf) {
let tmp = tempfile::tempdir().expect("tempdir");
// Canonicalize so the symlink-free destination guard passes on every OS.
let root = tmp.path().canonicalize().unwrap().join("wiki");
(tmp, root)
}
#[tokio::test]
async fn plan_lists_actions_without_writing() {
let (addr, _fixture) = serve(Fixture::new(fixture_pages())).await;
let (_tmp, dest) = temp_dest();
run(&args(addr, &dest, &["notes"]), Mode::Plan)
.await
.expect("plan succeeds");
assert!(!dest.exists(), "plan must not create the destination");
}
#[tokio::test]
async fn export_apply_writes_files_and_state() {
let (addr, _fixture) = serve(Fixture::new(fixture_pages())).await;
let (_tmp, dest) = temp_dest();
run(&args(addr, &dest, &["notes", "_rules"]), Mode::Apply)
.await
.expect("first export");
assert_eq!(
fs::read(dest.join("notes/a.md")).unwrap(),
file("notes/a.md", "# A\nalpha\n")
);
assert_eq!(
fs::read(dest.join("_rules/postgres.md")).unwrap(),
file("_rules/postgres.md", "# Postgres only\nUse Postgres.\n")
);
// Only allowlisted families land on disk.
assert!(!dest.join("decisions/0001-db.md").exists());
let state = state::load(&dest).unwrap();
assert_eq!(state.pages.len(), 4, "notes/* plus _rules/postgres.md");
for path in [
"notes/a.md",
"notes/b.md",
"notes/c.md",
"_rules/postgres.md",
] {
let entry = state.pages.get(path).expect(path);
assert!(entry.etag.is_some(), "etag recorded for {path}");
}
}
#[tokio::test]
async fn reexport_revalidates_with_etag_and_writes_nothing() {
let (addr, fixture) = serve(Fixture::new(fixture_pages())).await;
let (_tmp, dest) = temp_dest();
run(&args(addr, &dest, &["notes"]), Mode::Apply)
.await
.expect("first export");
let before = fs::read(dest.join("notes/a.md")).unwrap();
let reads_before = fixture.page_reads_200.load(Ordering::SeqCst);
run(&args(addr, &dest, &["notes"]), Mode::Apply)
.await
.expect("second export");
assert!(
fixture.page_reads_304.load(Ordering::SeqCst) >= 3,
"every unchanged page revalidated via 304"
);
assert_eq!(
fixture.page_reads_200.load(Ordering::SeqCst),
reads_before,
"no full page body was fetched again"
);
assert_eq!(fs::read(dest.join("notes/a.md")).unwrap(), before);
}
#[tokio::test]
async fn local_edits_are_refused_until_forced() {
let (addr, _fixture) = serve(Fixture::new(fixture_pages())).await;
let (_tmp, dest) = temp_dest();
run(&args(addr, &dest, &["notes"]), Mode::Apply)
.await
.expect("first export");
fs::write(dest.join("notes/b.md"), b"# B\nlocally edited\n").unwrap();
// A brand-new local file inside an allowlisted family is unknown, not
// ours to clobber.
fs::write(dest.join("notes/zz-new.md"), b"# local\n").unwrap();
let refused = run(&args(addr, &dest, &["notes"]), Mode::Apply)
.await
.expect_err("must refuse when files diverged");
let message = refused.to_string();
assert!(message.contains("diverged"), "{message}");
assert_eq!(
fs::read(dest.join("notes/b.md")).unwrap(),
b"# B\nlocally edited\n",
"diverged file is untouched"
);
assert_eq!(
fs::read(dest.join("notes/a.md")).unwrap(),
file("notes/a.md", "# A\nalpha\n")
);
assert_eq!(
fs::read(dest.join("notes/zz-new.md")).unwrap(),
b"# local\n",
"unknown local file is untouched"
);
let mut force_args = args(addr, &dest, &["notes"]);
force_args.force = true;
run(&force_args, Mode::Apply)
.await
.expect("--force exports");
assert_eq!(
fs::read(dest.join("notes/b.md")).unwrap(),
file("notes/b.md", "# B\nbeta\n")
);
assert_eq!(
fs::read(dest.join("notes/zz-new.md")).unwrap(),
b"# local\n",
"--force overwrites divergent server pages; it still never deletes"
);
// State reflects the forced page.
let state = state::load(&dest).unwrap();
assert_eq!(
state.pages["notes/b.md"].hash,
state::sha256_hex(&file("notes/b.md", "# B\nbeta\n"))
);
}
#[tokio::test]
async fn export_preserves_edits_saved_while_fetching_pages_even_with_force() {
for force in [false, true] {
let (addr, fixture) = serve(Fixture::new(vec![(
"notes/a.md".to_string(),
"# Original\n".to_string(),
)]))
.await;
let (_tmp, dest) = temp_dest();
let mut run_args = args(addr, &dest, &["notes"]);
run(&run_args, Mode::Apply).await.unwrap();
let old_state = fs::read(state::state_path(&dest)).unwrap();
fixture.update("notes/a.md", |page| {
page.body = "# Server edit\n".to_string()
});
if force {
fs::write(dest.join("notes/a.md"), b"# Older local edit\n").unwrap();
}
run_args.force = force;
let newest = b"# Editor saved this during export\n";
*fixture.repository_edit_on_read.lock().unwrap() =
Some((dest.join("notes/a.md"), newest.to_vec()));
let result = run(&run_args, Mode::Apply).await;
assert_eq!(fs::read(dest.join("notes/a.md")).unwrap(), newest);
let message = result
.expect_err("must preserve an unseen edit")
.to_string();
assert!(
message.contains("changed in the repository during this run"),
"{message}"
);
assert_eq!(fs::read(state::state_path(&dest)).unwrap(), old_state);
}
}
#[tokio::test]
async fn export_preserves_a_file_created_while_fetching_pages() {
let (addr, fixture) = serve(Fixture::new(vec![(
"notes/a.md".to_string(),
"# Server page\n".to_string(),
)]))
.await;
let (_tmp, dest) = temp_dest();
let newest = b"# New local page\n";
*fixture.repository_edit_on_read.lock().unwrap() =
Some((dest.join("notes/a.md"), newest.to_vec()));
let result = run(&args(addr, &dest, &["notes"]), Mode::Apply).await;
assert_eq!(fs::read(dest.join("notes/a.md")).unwrap(), newest);
let message = result.expect_err("must preserve a new file").to_string();
assert!(
message.contains("changed in the repository during this run"),
"{message}"
);
assert!(!state::state_path(&dest).exists());
}
#[tokio::test]
async fn unauthorized_is_a_clear_error() {
let (addr, _fixture) = serve(Fixture::new(fixture_pages()).with_token("sekrit")).await;
let (_tmp, dest) = temp_dest();
let err = run(&args(addr, &dest, &["notes"]), Mode::Plan)
.await
.expect_err("must fail");
let message = err.to_string();
assert!(message.contains("401"), "{message}");
assert!(message.contains("AI_MEMORY_AUTH_TOKEN"), "{message}");
assert!(!message.contains("sekrit"), "token never leaks: {message}");
let mut authed = args(addr, &dest, &["notes"]);
authed.token = Some("sekrit".to_string());
run(&authed, Mode::Plan).await.expect("authorized plan");
}
#[tokio::test]
async fn unknown_scope_is_a_clear_404() {
let (addr, _fixture) = serve(Fixture::new(fixture_pages()).missing_project()).await;
let (_tmp, dest) = temp_dest();
let err = run(&args(addr, &dest, &["notes"]), Mode::Plan)
.await
.expect_err("must fail");
let message = err.to_string();
assert!(message.contains("404"), "{message}");
assert!(message.contains("--workspace/--project"), "{message}");
}
#[tokio::test]
async fn listing_follows_cursors_to_the_last_page() {
// Five pages with a fixture page size of 2 means three listing rounds.
let (addr, fixture) = serve(Fixture::new(fixture_pages())).await;
let (_tmp, dest) = temp_dest();
run(&args(addr, &dest, &["notes"]), Mode::Apply)
.await
.expect("export");
assert!(
fixture.recent_calls.load(Ordering::SeqCst) >= 3,
"cursor pagination was exercised"
);
assert!(dest.join("notes/c.md").exists(), "last page reached");
}
#[tokio::test]
async fn server_page_paths_escaping_dest_are_refused() {
let hostile = vec![
("notes/ok.md".to_string(), "# ok\n".to_string()),
(
"notes/../../escape.md".to_string(),
"# escape\n".to_string(),
),
];
let (addr, _fixture) = serve(Fixture::new(hostile)).await;
let (tmp, dest) = temp_dest();
let err = run(&args(addr, &dest, &["notes"]), Mode::Apply)
.await
.expect_err("hostile listing refused");
assert!(err.to_string().contains("refused"), "{err}");
// The batch failed during selection: no page files, nothing outside dest.
assert!(!dest.join("notes/ok.md").exists());
assert!(
!tmp.path().join("escape.md").exists(),
"nothing outside dest"
);
}
#[tokio::test]
async fn case_fold_collisions_from_server_are_refused() {
let colliding = vec![
("notes/a.md".to_string(), "# a\n".to_string()),
("Notes/A.md".to_string(), "# A\n".to_string()),
];
let (addr, _fixture) = serve(Fixture::new(colliding)).await;
let (_tmp, dest) = temp_dest();
let err = run(&args(addr, &dest, &["notes", "Notes"]), Mode::Apply)
.await
.expect_err("collision refused");
assert!(err.to_string().contains("case-fold"), "{}", err);
}
#[tokio::test]
async fn allowlist_rules_apply_end_to_end() {
let (addr, _fixture) = serve(Fixture::new(fixture_pages())).await;
let (_tmp, dest) = temp_dest();
let none = RunArgs {
include: vec![],
..args(addr, &dest, &[])
};
let err = run(&none, Mode::Plan).await.expect_err("empty allowlist");
assert!(err.to_string().contains("must be explicit"), "{err}");
let star = RunArgs {
include: vec!["*".to_string()],
..args(addr, &dest, &[])
};
let err = run(&star, Mode::Plan).await.expect_err("bare star refused");
assert!(err.to_string().contains("'*'"), "{err}");
}
#[tokio::test]
async fn page_missing_on_read_fails_loudly() {
// The listing advertises a page the read cannot find (deleted or
// expired mid-run): the run must fail instead of skipping silently.
let mut pages = fixture_pages();
pages.push(("notes/ghost.md".to_string(), "# ghost\n".to_string()));
let (addr, _fixture) = serve(Fixture::new(pages).with_unreachable("notes/ghost.md")).await;
let (_tmp, dest) = temp_dest();
let err = run(&args(addr, &dest, &["notes"]), Mode::Apply)
.await
.expect_err("ghost page must fail the run");
assert!(
err.to_string().contains("404") || err.to_string().contains("ghost"),
"{err}"
);
assert!(
!dest.join("notes/a.md").exists(),
"a failed batch writes nothing"
);
}
#[tokio::test]
async fn empty_state_after_user_deletes_local_file_recreates_it() {
let (addr, _fixture) = serve(Fixture::new(fixture_pages())).await;
let (_tmp, dest) = temp_dest();
run(&args(addr, &dest, &["notes"]), Mode::Apply)
.await
.expect("first export");
fs::remove_file(dest.join("notes/b.md")).unwrap();
run(&args(addr, &dest, &["notes"]), Mode::Apply)
.await
.expect("recreate");
assert_eq!(
fs::read(dest.join("notes/b.md")).unwrap(),
file("notes/b.md", "# B\nbeta\n")
);
let state: SyncState = state::load(&dest).unwrap();
assert!(state.pages.contains_key("notes/b.md"));
}
fn sync_args(addr: SocketAddr, dest: &std::path::Path, prefer: Option<Prefer>) -> SyncArgs {
SyncArgs {
run: args(addr, dest, &["decisions"]),
prefer,
propagate_deletes: false,
max_deletes: bidi::DEFAULT_MAX_DELETES,
}
}
fn deleting_args(addr: SocketAddr, dest: &std::path::Path, prefer: Option<Prefer>) -> SyncArgs {
SyncArgs {
propagate_deletes: true,
..sync_args(addr, dest, prefer)
}
}
async fn sync(addr: SocketAddr, dest: &std::path::Path) -> anyhow::Result<Outcome> {
bidi::run(&sync_args(addr, dest, None), SyncMode::Apply).await
}
fn decision() -> FixturePage {
let mut page = FixturePage::new("decisions/db.md", "# DB\nUse Postgres.\n");
page.title = "DB".to_string();
page.frontmatter = json!({"tags": ["db"]});
page.pinned = true;
page
}
const DECISION_FILE: &str =
"---\ntitle: \"DB\"\ntags: [\"db\"]\npinned: true\n---\n# DB\nUse Postgres.\n";
/// The reproduction from #1708: a destination exported from project `a` is
/// reused for project `b`, whose (empty) listing made every page of `a` read
/// as "deleted on the server", and `--propagate-deletes --apply` removed the
/// file and emptied the baseline. The baseline records its scope now, so the
/// reuse refuses before writing, and `--adopt-scope` is the explicit way to
/// take the destination over.
#[tokio::test]
async fn reusing_a_destination_for_another_project_refuses_and_keeps_the_files() {
let (addr, fixture) = serve(Fixture::with_pages(vec![decision()])).await;
let (_tmp, dest) = temp_dest();
sync(addr, &dest).await.expect("export of project a");
assert!(dest.join("decisions/db.md").exists());
// Project b lists no pages at all; nothing about this destination belongs
// to it.
let (b_addr, _b) = serve(Fixture {
any_project: true,
..Fixture::with_pages(Vec::new())
})
.await;
let mut b_args = deleting_args(b_addr, &dest, None);
b_args.run.project = "b".to_string();
let err = bidi::run(&b_args, SyncMode::Apply)
.await
.expect_err("another project's baseline must not be reused");
let message = format!("{err:#}");
assert!(
message.contains("belongs to") && message.contains("--adopt-scope"),
"{message}"
);
assert!(
dest.join("decisions/db.md").exists(),
"the previous project's file must survive the refusal"
);
assert!(
!state::load(&dest).unwrap().pages.is_empty(),
"the refusal must not empty the baseline"
);
// The explicit takeover discards the baseline instead of reading it as
// deletions. Project b here holds the same page, so the adopted run has
// nothing to write and simply stamps the new scope.
let (b_page_addr, _) = serve(Fixture {
any_project: true,
..Fixture::with_pages(vec![decision()])
})
.await;
let mut adopted = sync_args(b_page_addr, &dest, None);
adopted.run.project = "b".to_string();
adopted.run.adopt_scope = true;
bidi::run(&adopted, SyncMode::Apply)
.await
.expect("adopting the destination is explicit");
assert_eq!(
state::load(&dest).unwrap().scope,
Some(state::SyncScope::of(
&format!("http://{b_page_addr}"),
"demo",
"b"
))
);
assert!(
dest.join("decisions/db.md").exists(),
"adoption writes no delete"
);
assert_eq!(
fixture.page("decisions/db.md").unwrap().body,
"# DB\nUse Postgres.\n",
"the control: the first project's server copy is untouched"
);
}
/// The same project on the same server keeps working, which is the control
/// for the guard above.
#[tokio::test]
async fn reusing_a_destination_for_the_same_project_still_syncs() {
let (addr, _) = serve(Fixture::with_pages(vec![decision()])).await;
let (_tmp, dest) = temp_dest();
sync(addr, &dest).await.expect("first sync");
let second = sync(addr, &dest).await.expect("same-scope sync");
assert_eq!(
second.status(),
bidi::CheckStatus::InSync,
"a same-scope rerun is in sync"
);
}
#[tokio::test]
async fn sync_exports_metadata_and_round_trips_without_writes() {
let (addr, fixture) = serve(Fixture::with_pages(vec![decision()])).await;
let (_tmp, dest) = temp_dest();
sync(addr, &dest).await.expect("first sync");
assert_eq!(
fs::read_to_string(dest.join("decisions/db.md")).unwrap(),
DECISION_FILE
);
sync(addr, &dest).await.expect("second sync");
assert_eq!(fixture.page_reads_200.load(Ordering::SeqCst), 1);
assert_eq!(
fixture.page_reads_304.load(Ordering::SeqCst),
1,
"an unchanged repository file still revalidates with its ETag"
);
assert_eq!(
fixture.mcp_writes.load(Ordering::SeqCst),
0,
"nothing to import"
);
assert_eq!(
fs::read_to_string(dest.join("decisions/db.md")).unwrap(),
DECISION_FILE
);
}
#[tokio::test]
async fn sync_imports_a_repo_edit_with_its_metadata() {
let (addr, fixture) = serve(Fixture::with_pages(vec![decision()])).await;
let (_tmp, dest) = temp_dest();
sync(addr, &dest).await.expect("first sync");
let base = state::load(&dest).unwrap().pages["decisions/db.md"].clone();
let edited =
"---\ntitle: \"DB\"\ntags: [\"db\", \"ops\"]\npinned: true\n---\n# DB\nUse Postgres 17.\n";
fs::write(dest.join("decisions/db.md"), edited).unwrap();
// Dry-run first: nothing reaches the server.
bidi::run(&sync_args(addr, &dest, None), SyncMode::DryRun)
.await
.expect("dry run");
assert_eq!(fixture.mcp_writes.load(Ordering::SeqCst), 0);
assert_eq!(
fixture.page_reads_200.load(Ordering::SeqCst),
2,
"classifying an edited file needs one full read"
);
assert_eq!(fixture.page_reads_304.load(Ordering::SeqCst), 0);
sync(addr, &dest).await.expect("import");
assert_eq!(
fixture.mcp_calls.lock().unwrap()[0]["arguments"]["expected_page_id"],
base.page_id.unwrap(),
"the write is conditional on the version that was classified"
);
let page = fixture.page("decisions/db.md").unwrap();
assert_eq!(page.body, "# DB\nUse Postgres 17.\n");
assert!(
page.pinned,
"the write re-sent pinned, so the replace kept it"
);
assert_eq!(page.frontmatter["tags"], json!(["db", "ops"]));
assert_eq!(
fs::read_to_string(dest.join("decisions/db.md")).unwrap(),
edited
);
sync(addr, &dest).await.expect("settled");
assert_eq!(
fixture.mcp_writes.load(Ordering::SeqCst),
1,
"a settled page is not written again"
);
}
#[tokio::test]
async fn sync_creates_new_repo_pages_only_with_frontmatter() {
let (addr, fixture) = serve(Fixture::with_pages(vec![decision()])).await;
let (_tmp, dest) = temp_dest();
sync(addr, &dest).await.expect("first sync");
fs::write(dest.join("decisions/cache.md"), "# Cache\nUse Redis.\n").unwrap();
let err = sync(addr, &dest)
.await
.expect_err("a file without frontmatter is refused");
assert!(err.to_string().contains("refused"), "{err}");
assert!(fixture.page("decisions/cache.md").is_none());
assert_eq!(
fixture.mcp_writes.load(Ordering::SeqCst),
0,
"a refusal blocks the whole batch"
);
fs::write(
dest.join("decisions/cache.md"),
"---\ntitle: \"Cache\"\n---\n# Cache\nUse Redis.\n",
)
.unwrap();
sync(addr, &dest).await.expect("create");
let page = fixture
.page("decisions/cache.md")
.expect("created on the server");
assert_eq!(page.title, "Cache");
assert_eq!(page.body, "# Cache\nUse Redis.\n");
// Pages outside the allowlist never travel.
fs::create_dir_all(dest.join("notes")).unwrap();
fs::write(dest.join("notes/x.md"), "---\ntitle: \"X\"\n---\nx\n").unwrap();
sync(addr, &dest).await.expect("notes ignored");
assert!(fixture.page("notes/x.md").is_none());
}
#[tokio::test]
async fn sync_conflicts_until_a_side_is_preferred() {
let (addr, fixture) = serve(Fixture::with_pages(vec![decision()])).await;
let (_tmp, dest) = temp_dest();
sync(addr, &dest).await.expect("first sync");
let repo_edit = DECISION_FILE.replace("Use Postgres.", "Use Postgres in the repo.");
fs::write(dest.join("decisions/db.md"), &repo_edit).unwrap();
fixture.update("decisions/db.md", |page| {
page.body = "# DB\nUse Postgres on the server.\n".into()
});
let err = sync(addr, &dest).await.expect_err("conflict");
assert!(err.to_string().contains("refused"), "{err}");
assert_eq!(
fs::read_to_string(dest.join("decisions/db.md")).unwrap(),
repo_edit
);
assert_eq!(fixture.mcp_writes.load(Ordering::SeqCst), 0);
bidi::run(
&sync_args(addr, &dest, Some(Prefer::Server)),
SyncMode::Apply,
)
.await
.expect("prefer server");
assert!(
fs::read_to_string(dest.join("decisions/db.md"))
.unwrap()
.contains("on the server")
);
fs::write(dest.join("decisions/db.md"), &repo_edit).unwrap();
fixture.update("decisions/db.md", |page| {
page.body = "# DB\nAgain on the server.\n".into()
});
bidi::run(&sync_args(addr, &dest, Some(Prefer::Repo)), SyncMode::Apply)
.await
.expect("prefer repo");
assert!(
fixture
.page("decisions/db.md")
.unwrap()
.body
.contains("in the repo")
);
}
#[tokio::test]
async fn sync_refuses_to_clear_metadata_it_cannot_round_trip() {
let mut consolidated = decision();
consolidated.frontmatter = json!({"tags": ["db"], "summary": "s", "sources": ["x"]});
let (addr, fixture) = serve(Fixture::with_pages(vec![consolidated])).await;
let (_tmp, dest) = temp_dest();
sync(addr, &dest).await.expect("export still works");
let edited = fs::read_to_string(dest.join("decisions/db.md"))
.unwrap()
.replace("Use Postgres.", "Edited.");
fs::write(dest.join("decisions/db.md"), edited).unwrap();
let err = sync(addr, &dest).await.expect_err("import refused");
assert!(err.to_string().contains("refused"), "{err}");
assert_eq!(fixture.mcp_writes.load(Ordering::SeqCst), 0);
assert_eq!(
fixture.page("decisions/db.md").unwrap().frontmatter["summary"],
"s"
);
}
#[tokio::test]
async fn sync_import_sends_the_classified_version_and_records_the_new_one() {
let (addr, fixture) = serve(Fixture::with_pages(vec![decision()])).await;
let (_tmp, dest) = temp_dest();
sync(addr, &dest).await.expect("first sync");
let exported = fixture.page("decisions/db.md").unwrap().id;
assert_eq!(
state::load(&dest).unwrap().pages["decisions/db.md"]
.page_id
.as_deref(),
Some(exported.as_str()),
"the export records the version id"
);
fs::write(
dest.join("decisions/db.md"),
DECISION_FILE.replace("Use Postgres.", "Repo edit."),
)
.unwrap();
fs::write(
dest.join("decisions/new.md"),
"---\ntitle: \"New\"\n---\n# New\n",
)
.unwrap();
sync(addr, &dest).await.expect("import");
let calls = fixture.mcp_calls.lock().unwrap().clone();
let call = |path: &str| {
calls
.iter()
.find(|call| call["arguments"]["path"] == path)
.unwrap_or_else(|| panic!("no MCP call for {path}"))
.clone()
};
let update = call("decisions/db.md");
assert_eq!(update["arguments"]["expected_page_id"], exported.as_str());
assert!(update["arguments"].get("create_only").is_none());
let create = call("decisions/new.md");
assert_eq!(create["arguments"]["create_only"], true);
assert!(create["arguments"].get("expected_page_id").is_none());
let state = state::load(&dest).unwrap();
for path in ["decisions/db.md", "decisions/new.md"] {
assert_eq!(
state.pages[path].page_id,
Some(fixture.page(path).unwrap().id),
"{path}: the written version is the new base"
);
}
}
/// A 304 used to trigger a second, full read for an import's metadata. If
/// that read saw a concurrent edit, its id silently replaced the classified
/// version and the import overwrote it instead of failing its precondition.
#[tokio::test]
async fn sync_does_not_rebase_an_import_onto_a_concurrent_server_edit() {
let (addr, fixture) = serve(Fixture {
edit_after_read: Some(("decisions/db.md", 2)),
..Fixture::with_pages(vec![decision()])
})
.await;
let (_tmp, dest) = temp_dest();
sync(addr, &dest).await.expect("first sync");
let base = state::load(&dest).unwrap().pages["decisions/db.md"].clone();
let edited = DECISION_FILE.replace("Use Postgres.", "Repo edit.");
fs::write(dest.join("decisions/db.md"), &edited).unwrap();
let err = sync(addr, &dest)
.await
.expect_err("the concurrent server edit must be preserved");
assert!(err.to_string().contains("changed during this run"), "{err}");
let page = fixture.page("decisions/db.md").unwrap();
assert!(page.body.contains("edited concurrently"), "{}", page.body);
assert!(!page.body.contains("Repo edit"), "{}", page.body);
assert_eq!(fixture.mcp_writes.load(Ordering::SeqCst), 0);
assert_eq!(
fixture.mcp_calls.lock().unwrap()[0]["arguments"]["expected_page_id"],
base.page_id.as_ref().unwrap().as_str(),
"the import must keep the version it classified"
);
assert_eq!(state::load(&dest).unwrap().pages["decisions/db.md"], base);
assert_eq!(
fs::read_to_string(dest.join("decisions/db.md")).unwrap(),
edited
);
}
/// The race slice 3 could only narrow: another writer lands between the
/// classification read and the write. The server refuses the stale version,
/// the run reports it and fails, and every other page still syncs. Without
/// `expected_page_id` the fixture would accept the write and this fails.
#[tokio::test]
async fn sync_reports_a_page_changed_during_the_run_and_applies_the_rest() {
let mut other = decision();
other.path = "decisions/other.md".to_string();
let (addr, fixture) = serve(Fixture::with_pages(vec![decision(), other])).await;
let (_tmp, dest) = temp_dest();
sync(addr, &dest).await.expect("first sync");
let base = state::load(&dest).unwrap().pages["decisions/db.md"].clone();
let raced_edit = DECISION_FILE.replace("Use Postgres.", "Repo edit.");
fs::write(dest.join("decisions/db.md"), &raced_edit).unwrap();
fs::write(
dest.join("decisions/other.md"),
DECISION_FILE.replace("Use Postgres.", "Other edit."),
)
.unwrap();
let racing = Fixture {
edit_before_mcp: Some("decisions/db.md"),
..Fixture::with_pages(vec![
fixture.page("decisions/db.md").unwrap(),
fixture.page("decisions/other.md").unwrap(),
])
};
let (race_addr, raced) = serve(racing).await;
// The fixture binds a new ephemeral port, and the baseline records the
// origin it was exported from (#1708). This test means "the same project,
// served again", so restamp the scope rather than adopt a foreign one:
// adopting would discard the baseline the race classification needs.
let mut restamped = state::load(&dest).unwrap();
restamped.scope = Some(state::SyncScope::of(
&format!("http://{race_addr}"),
"demo",
"app",
));
state::save(&dest, &restamped).unwrap();
let err = sync(race_addr, &dest).await.expect_err("race reported");
let message = format!("{err:#}");
assert!(message.contains("changed during this run"), "{message}");
assert!(message.contains("decisions/db.md"), "{message}");
let page = raced.page("decisions/db.md").unwrap();
assert!(
page.body.contains("edited concurrently") && !page.body.contains("Repo edit"),
"the concurrent edit survives: {}",
page.body
);
assert!(
raced
.page("decisions/other.md")
.unwrap()
.body
.contains("Other edit"),
"the other page still synced"
);
let state = state::load(&dest).unwrap();
assert_eq!(
state.pages["decisions/db.md"], base,
"raced state untouched"
);
assert_eq!(
fs::read_to_string(dest.join("decisions/db.md")).unwrap(),
raced_edit,
"the repository edit is kept for the next run"
);
}
#[tokio::test]
async fn sync_apply_refuses_a_server_without_conditional_writes() {
let old = Fixture {
old_server: true,
..Fixture::with_pages(vec![decision()])
};
let (addr, fixture) = serve(old).await;
let (_tmp, dest) = temp_dest();
sync(addr, &dest)
.await
.expect("exports need no precondition");
fs::write(
dest.join("decisions/db.md"),
DECISION_FILE.replace("Use Postgres.", "Repo edit."),
)
.unwrap();
bidi::run(&sync_args(addr, &dest, None), SyncMode::DryRun)
.await
.expect("a dry run still plans against an old server");
let err = sync(addr, &dest).await.expect_err("old server refused");
assert!(
format!("{err:#}").contains("server too old for sync --apply"),
"{err:#}"
);
assert_eq!(fixture.mcp_writes.load(Ordering::SeqCst), 0);
assert!(fixture.mcp_calls.lock().unwrap().is_empty());
}
/// Only the tool schema can tell an old server apart when the plan has
/// nothing but creates, which carry no version id.
#[tokio::test]
async fn sync_apply_checks_the_tool_schema_before_a_create() {
let old = Fixture {
old_server: true,
..Fixture::with_pages(vec![])
};
let (addr, fixture) = serve(old).await;
let (_tmp, dest) = temp_dest();
fs::create_dir_all(dest.join("decisions")).unwrap();
fs::write(
dest.join("decisions/new.md"),
"---\ntitle: \"New\"\n---\n# New\n",
)
.unwrap();
let err = sync(addr, &dest).await.expect_err("old server refused");
assert!(format!("{err:#}").contains("ai-memory >= 3.0"), "{err:#}");
assert!(fixture.page("decisions/new.md").is_none());
assert!(fixture.mcp_calls.lock().unwrap().is_empty());
}
#[tokio::test]
async fn sync_only_reports_deletes_without_the_flag() {
let mut other = decision();
other.path = "decisions/other.md".to_string();
let (addr, fixture) = serve(Fixture::with_pages(vec![decision(), other])).await;
let (_tmp, dest) = temp_dest();
sync(addr, &dest).await.expect("first sync");
let before = state::load(&dest).unwrap();
fixture.remove("decisions/db.md");
fs::remove_file(dest.join("decisions/other.md")).unwrap();
let outcome = sync(addr, &dest)
.await
.expect("deletes are notices, not refusals");
assert_eq!(outcome.status(), CheckStatus::Drift);
assert!(
dest.join("decisions/db.md").exists(),
"server delete not propagated"
);
assert!(
fixture.page("decisions/other.md").is_some(),
"repo delete not propagated"
);
assert!(fixture.mcp_calls.lock().unwrap().is_empty());
assert_eq!(
state::load(&dest).unwrap(),
before,
"an unpropagated delete keeps its base entry"
);
fs::remove_file(dest.join("decisions/db.md")).unwrap();
sync(addr, &dest).await.expect("gone on both sides");
assert!(
!state::load(&dest)
.unwrap()
.pages
.contains_key("decisions/db.md")
);
}
#[tokio::test]
async fn sync_propagates_deletes_from_an_unchanged_side() {
let mut other = decision();
other.path = "decisions/other.md".to_string();
other.pinned = false;
let mut kept = decision();
kept.path = "decisions/kept.md".to_string();
let (addr, fixture) = serve(Fixture::with_pages(vec![decision(), other, kept])).await;
let (_tmp, dest) = temp_dest();
sync(addr, &dest).await.expect("first sync");
let other_id = fixture.page("decisions/other.md").unwrap().id;
fixture.remove("decisions/db.md");
fs::remove_file(dest.join("decisions/other.md")).unwrap();
// A dry run with the flag still changes nothing.
bidi::run(&deleting_args(addr, &dest, None), SyncMode::DryRun)
.await
.expect("dry run");
assert!(dest.join("decisions/db.md").exists());
assert!(fixture.page("decisions/other.md").is_some());
bidi::run(&deleting_args(addr, &dest, None), SyncMode::Apply)
.await
.expect("deletes propagate");
assert!(
!dest.join("decisions/db.md").exists(),
"server delete reached the repository"
);
assert!(
fixture.page("decisions/other.md").is_none(),
"repository delete reached the server"
);
let calls = fixture.mcp_calls.lock().unwrap().clone();
assert_eq!(calls.len(), 1, "{calls:?}");
assert_eq!(calls[0]["name"], "memory_delete_page");
assert_eq!(
calls[0]["arguments"]["expected_page_id"],
other_id.as_str(),
"the delete is conditional on the classified version"
);
let state = state::load(&dest).unwrap();
assert!(!state.pages.contains_key("decisions/db.md"));
assert!(!state.pages.contains_key("decisions/other.md"));
assert!(state.pages.contains_key("decisions/kept.md"));
assert!(
dest.join("decisions/kept.md").exists(),
"untouched pages stay"
);
}
/// A restored file invalidates the planned repository-side deletion even
/// though the server's version precondition still holds.
#[tokio::test]
async fn sync_keeps_a_server_page_when_its_file_reappears_during_planning() {
for prefer in [None, Some(Prefer::Repo)] {
let mut page = decision();
page.pinned = false;
let mut other = page.clone();
other.path = "decisions/other.md".to_string();
let (addr, fixture) = serve(Fixture::with_pages(vec![page, other])).await;
let (_tmp, dest) = temp_dest();
sync(addr, &dest).await.expect("first sync");
let before = state::load(&dest).unwrap();
let original = fixture.page("decisions/db.md").unwrap();
let restored = DECISION_FILE
.replace("pinned: true\n", "")
.replace("Use Postgres.", "Restored with a new repository edit.");
fs::remove_file(dest.join("decisions/db.md")).unwrap();
fs::remove_file(dest.join("decisions/other.md")).unwrap();
// The file is restored after the plan read its absence, while the
// server request is in flight, before any delete is sent.
*fixture.repository_edit_on_read.lock().unwrap() =
Some((dest.join("decisions/db.md"), restored.as_bytes().to_vec()));
let result = bidi::run(&deleting_args(addr, &dest, prefer), SyncMode::Apply).await;
assert!(
fixture.page("decisions/db.md").is_some(),
"a recreated file must prevent deleting its unchanged server page"
);
let kept = fixture.page("decisions/db.md").unwrap();
assert_eq!(kept.id, original.id);
assert_eq!(kept.body, original.body);
assert_eq!(
fs::read(dest.join("decisions/db.md")).unwrap(),
restored.as_bytes()
);
let after = state::load(&dest).unwrap();
assert_eq!(
after.pages["decisions/db.md"],
before.pages["decisions/db.md"]
);
let message = result
.expect_err("the local race must be reported")
.to_string();
assert!(message.contains("changed during this run"), "{message}");
assert!(message.contains("decisions/db.md"), "{message}");
// Control: the other file stayed absent, so its deletion proceeds.
assert!(fixture.page("decisions/other.md").is_none());
assert!(!after.pages.contains_key("decisions/other.md"));
assert_eq!(fixture.mcp_deletes.load(Ordering::SeqCst), 1);
let calls = fixture.mcp_calls.lock().unwrap().clone();
assert_eq!(calls.len(), 1, "{calls:?}");
assert_eq!(calls[0]["arguments"]["path"], "decisions/other.md");
// Retaining the baseline lets a later sync import the restored edit.
sync(addr, &dest)
.await
.expect("the next sync imports the restored file");
assert!(
fixture
.page("decisions/db.md")
.unwrap()
.body
.contains("Restored with a new repository edit.")
);
}
}
#[tokio::test]
async fn sync_delete_conflicts_follow_prefer() {
let mut other = decision();
other.path = "decisions/other.md".to_string();
other.pinned = false;
let (addr, fixture) = serve(Fixture::with_pages(vec![decision(), other.clone()])).await;
let (_tmp, dest) = temp_dest();
sync(addr, &dest).await.expect("first sync");
// db.md: deleted in the repository, edited on the server.
// other.md: deleted on the server, edited in the repository.
let repo_edit = DECISION_FILE
.replace("pinned: true\n", "")
.replace("Use Postgres.", "Repo edit.");
let setup = |fixture: &Fixture| {
let _ = fs::remove_file(dest.join("decisions/db.md"));
fixture.update("decisions/db.md", |page| {
page.body = "# DB\nServer edit.\n".into()
});
fs::write(dest.join("decisions/other.md"), &repo_edit).unwrap();
fixture.remove("decisions/other.md");
};
setup(&fixture);
let err = bidi::run(&deleting_args(addr, &dest, None), SyncMode::Apply)
.await
.expect_err("conflicts refuse the batch");
assert!(err.to_string().contains("refused"), "{err}");
assert!(fixture.mcp_calls.lock().unwrap().is_empty());
assert!(dest.join("decisions/other.md").exists());
// --prefer server: the server's edit comes back, its delete wins.
bidi::run(
&deleting_args(addr, &dest, Some(Prefer::Server)),
SyncMode::Apply,
)
.await
.expect("prefer server");
assert!(
fs::read_to_string(dest.join("decisions/db.md"))
.unwrap()
.contains("Server edit"),
"re-exported"
);
assert!(!dest.join("decisions/other.md").exists(), "file deleted");
assert!(fixture.mcp_calls.lock().unwrap().is_empty());
// --prefer repo: the repository's delete wins (pinned or not), and its
// edit is re-created with create_only.
fixture.pages.lock().unwrap().push(other);
sync(addr, &dest).await.expect("resettle other.md");
setup(&fixture);
bidi::run(
&deleting_args(addr, &dest, Some(Prefer::Repo)),
SyncMode::Apply,
)
.await
.expect("prefer repo");
assert!(fixture.page("decisions/db.md").is_none(), "server deleted");
let recreated = fixture.page("decisions/other.md").expect("re-created");
assert!(recreated.body.contains("Repo edit"), "{}", recreated.body);
let calls = fixture.mcp_calls.lock().unwrap().clone();
let create = calls
.iter()
.find(|call| call["name"] == "memory_write_page")
.expect("write");
assert_eq!(create["arguments"]["create_only"], true);
}
#[tokio::test]
async fn sync_never_deletes_a_pinned_page_without_prefer_repo() {
// decision() is pinned on the server.
let (addr, fixture) = serve(Fixture::with_pages(vec![decision()])).await;
let (_tmp, dest) = temp_dest();
sync(addr, &dest).await.expect("first sync");
fs::remove_file(dest.join("decisions/db.md")).unwrap();
for prefer in [None, Some(Prefer::Server)] {
let err = bidi::run(&deleting_args(addr, &dest, prefer), SyncMode::Apply)
.await
.expect_err("pinned page refused");
assert!(err.to_string().contains("refused"), "{err}");
}
assert!(fixture.page("decisions/db.md").is_some());
assert_eq!(fixture.mcp_deletes.load(Ordering::SeqCst), 0);
bidi::run(
&deleting_args(addr, &dest, Some(Prefer::Repo)),
SyncMode::Apply,
)
.await
.expect("--prefer repo deletes it");
assert!(fixture.page("decisions/db.md").is_none());
}
#[tokio::test]
async fn sync_refuses_more_deletes_than_the_ceiling() {
let pages: Vec<FixturePage> = (0..3)
.map(|n| FixturePage::new(&format!("decisions/d{n}.md"), "# D\n"))
.collect();
let (addr, fixture) = serve(Fixture::with_pages(pages)).await;
let (_tmp, dest) = temp_dest();
sync(addr, &dest).await.expect("first sync");
for n in 0..3 {
fixture.remove(&format!("decisions/d{n}.md"));
}
let capped = SyncArgs {
max_deletes: 2,
..deleting_args(addr, &dest, None)
};
let err = bidi::run(&capped, SyncMode::Apply)
.await
.expect_err("ceiling");
assert!(err.to_string().contains("--max-deletes 2"), "{err}");
for n in 0..3 {
assert!(dest.join(format!("decisions/d{n}.md")).exists());
}
let raised = SyncArgs {
max_deletes: 3,
..capped
};
bidi::run(&raised, SyncMode::Apply)
.await
.expect("within the ceiling");
for n in 0..3 {
assert!(!dest.join(format!("decisions/d{n}.md")).exists());
}
}
#[cfg(unix)]
#[tokio::test]
async fn sync_never_deletes_through_a_symlink() {
let (addr, fixture) = serve(Fixture::with_pages(vec![decision()])).await;
let (tmp, dest) = temp_dest();
sync(addr, &dest).await.expect("first sync");
let outside = tmp.path().join("outside.md");
fs::write(&outside, DECISION_FILE).unwrap();
fs::remove_file(dest.join("decisions/db.md")).unwrap();
std::os::unix::fs::symlink(&outside, dest.join("decisions/db.md")).unwrap();
fixture.remove("decisions/db.md");
let err = bidi::run(&deleting_args(addr, &dest, None), SyncMode::Apply)
.await
.expect_err("symlink refused");
assert!(err.to_string().contains("refused"), "{err}");
assert!(
fs::symlink_metadata(dest.join("decisions/db.md"))
.unwrap()
.file_type()
.is_symlink(),
"the link is left alone"
);
assert_eq!(fs::read_to_string(&outside).unwrap(), DECISION_FILE);
}
#[tokio::test]
async fn sync_adopts_the_server_rendering_after_an_import() {
let fixture = Fixture {
redact: Some("hunter2"),
..Fixture::with_pages(vec![decision()])
};
let (addr, fixture) = serve(fixture).await;
let (_tmp, dest) = temp_dest();
sync(addr, &dest).await.expect("first sync");
fs::write(
dest.join("decisions/db.md"),
DECISION_FILE.replace("Use Postgres.", "password hunter2"),
)
.unwrap();
sync(addr, &dest).await.expect("import");
let file = fs::read_to_string(dest.join("decisions/db.md")).unwrap();
assert!(
file.contains("[REDACTED]") && !file.contains("hunter2"),
"{file}"
);
sync(addr, &dest).await.expect("settled");
assert_eq!(fixture.mcp_writes.load(Ordering::SeqCst), 1);
}
#[tokio::test]
async fn sync_upgrades_a_slice_one_export_without_importing() {
let (addr, fixture) = serve(Fixture::with_pages(vec![decision()])).await;
let (_tmp, dest) = temp_dest();
// What slice 1 left behind: the bare body, and its hash as the base.
fs::create_dir_all(dest.join("decisions")).unwrap();
fs::write(dest.join("decisions/db.md"), "# DB\nUse Postgres.\n").unwrap();
let mut old = SyncState::default();
old.pages.insert(
"decisions/db.md".into(),
state::PageState {
hash: state::sha256_hex(b"# DB\nUse Postgres.\n"),
etag: None,
page_id: None,
},
);
state::save(&dest, &old).unwrap();
sync(addr, &dest).await.expect("upgrade");
assert_eq!(
fixture.mcp_writes.load(Ordering::SeqCst),
0,
"an unedited file is not imported"
);
assert_eq!(
fs::read_to_string(dest.join("decisions/db.md")).unwrap(),
DECISION_FILE
);
}
/// Run the built binary with a clean environment: no server or token
/// leaks in from the developer's shell.
async fn wikisync(args: Vec<String>, envs: Vec<(&'static str, &'static str)>) -> (i32, String) {
tokio::task::spawn_blocking(move || {
let output = std::process::Command::new(env!("CARGO_BIN_EXE_ai-memory-wikisync"))
.args(&args)
.env_remove("AI_MEMORY_SERVER_URL")
.env_remove("AI_MEMORY_AUTH_TOKEN")
.envs(envs)
.output()
.expect("run ai-memory-wikisync");
let text = format!(
"{}{}",
String::from_utf8_lossy(&output.stdout),
String::from_utf8_lossy(&output.stderr)
);
(output.status.code().unwrap_or(-1), text)
})
.await
.expect("join")
}
fn check_args(addr: SocketAddr, dest: &std::path::Path, extra: &[&str]) -> Vec<String> {
let mut args: Vec<String> = [
"sync",
"--check",
"--server",
&format!("http://{addr}"),
"--workspace",
"demo",
"--project",
"app",
"--dest",
dest.to_str().unwrap(),
"--include",
"decisions",
]
.iter()
.map(|arg| arg.to_string())
.collect();
args.extend(extra.iter().map(|arg| arg.to_string()));
args
}
/// Every file under `root` with its bytes, so a test can prove a run left
/// the tree exactly as it was.
fn snapshot(root: &std::path::Path) -> BTreeMap<PathBuf, Vec<u8>> {
let mut files = BTreeMap::new();
let mut pending = vec![root.to_path_buf()];
while let Some(dir) = pending.pop() {
let Ok(entries) = fs::read_dir(&dir) else {
continue;
};
for entry in entries.flatten() {
let path = entry.path();
if path.is_dir() {
pending.push(path);
} else {
files.insert(path.clone(), fs::read(&path).unwrap());
}
}
}
files
}
#[tokio::test]
async fn sync_check_exit_codes_and_writes_nothing() {
let (addr, fixture) = serve(Fixture::with_pages(vec![decision()])).await;
let (_tmp, dest) = temp_dest();
sync(addr, &dest).await.expect("first sync");
let (code, out) = wikisync(check_args(addr, &dest, &[]), vec![]).await;
assert_eq!(code, 0, "in sync: {out}");
// Drift: the server moved on.
fixture.update("decisions/db.md", |page| {
page.body = "# DB\nServer edit.\n".into()
});
let before = snapshot(&dest);
let (code, out) = wikisync(check_args(addr, &dest, &[]), vec![]).await;
assert_eq!(code, 3, "drift: {out}");
assert_eq!(snapshot(&dest), before, "--check wrote something");
// A conflict outranks drift.
fs::write(
dest.join("decisions/db.md"),
DECISION_FILE.replace("Use Postgres.", "Repo edit."),
)
.unwrap();
fs::write(
dest.join("decisions/new.md"),
"---\ntitle: \"New\"\n---\n# New\n",
)
.unwrap();
let before = snapshot(&dest);
let (code, out) = wikisync(check_args(addr, &dest, &[]), vec![]).await;
assert_eq!(code, 4, "conflict: {out}");
assert_eq!(snapshot(&dest), before, "--check wrote something");
assert!(fixture.mcp_calls.lock().unwrap().is_empty());
// An unreachable server is an error, not a verdict.
let mut unreachable = check_args(addr, &dest, &[]);
unreachable[3] = "http://127.0.0.1:1".to_string();
let (code, out) = wikisync(unreachable, vec![]).await;
assert_eq!(code, 1, "error: {out}");
// --check and --apply cannot be combined (a clap usage error).
let (code, _) = wikisync(check_args(addr, &dest, &["--apply"]), vec![]).await;
assert_eq!(code, 2);
}
/// A CI checkout has no state (it is never committed): the repository is
/// compared with the server directly, and a difference is drift.
#[tokio::test]
async fn sync_check_in_a_fresh_clone_reports_drift_not_conflict() {
let mut other = decision();
other.path = "decisions/other.md".to_string();
let (addr, fixture) = serve(Fixture::with_pages(vec![decision(), other])).await;
let (_tmp, dest) = temp_dest();
sync(addr, &dest).await.expect("first sync");
fs::remove_dir_all(dest.join(".ai-memory-wikisync")).unwrap();
let (code, out) = wikisync(check_args(addr, &dest, &[]), vec![]).await;
assert_eq!(code, 0, "a matching clone is in sync: {out}");
fixture.update("decisions/db.md", |page| {
page.body = "# DB\nServer edit.\n".into()
});
let before = snapshot(&dest);
let (code, out) = wikisync(check_args(addr, &dest, &[]), vec![]).await;
assert_eq!(code, 3, "differs is drift: {out}");
assert!(out.contains("differs"), "{out}");
assert_eq!(snapshot(&dest), before);
assert!(
!dest.join(".ai-memory-wikisync").exists(),
"--check never creates state"
);
}
#[tokio::test]
async fn install_hook_never_writes_a_token() {
let tmp = tempfile::tempdir().unwrap();
let root = tmp.path().canonicalize().unwrap();
fs::create_dir_all(root.join(".git/hooks")).unwrap();
fs::create_dir_all(root.join("docs/wiki")).unwrap();
let dest = root.join("docs/wiki");
let base = |extra: &[&str]| {
let mut args: Vec<String> = [
"install-hook",
"--workspace",
"demo",
"--project",
"app",
"--dest",
dest.to_str().unwrap(),
"--include",
"decisions",
]
.iter()
.map(|arg| arg.to_string())
.collect();
args.extend(extra.iter().map(|arg| arg.to_string()));
args
};
let (code, out) = wikisync(base(&["--token", "sekrit-flag"]), vec![]).await;
assert_eq!(code, 1, "{out}");
assert!(out.contains("never stores a token"), "{out}");
assert!(!root.join(".git/hooks/post-merge").exists());
let (code, out) = wikisync(
base(&["--on-merge", "apply"]),
vec![("AI_MEMORY_AUTH_TOKEN", "sekrit-env")],
)
.await;
assert_eq!(code, 0, "{out}");
let hook = fs::read_to_string(root.join(".git/hooks/post-merge")).unwrap();
assert!(!hook.contains("sekrit"), "{hook}");
assert!(!hook.contains("AI_MEMORY_AUTH_TOKEN"), "{hook}");
assert!(!out.contains("sekrit"), "{out}");
}