wiki-viewer 1.5.2 → 1.7.0

package/.next/standalone/src/tests/proof/agent-fs.test.ts

@@ -23,6 +23,7 @@ import { _resetAuditDb } from "../../lib/proof/audit.js";
 // Route handlers (loaded after env is set)
 let fileGET: (req: Request, ctx: { params: Promise<{ path: string[] }> }) => Promise<Response>;
 let filePUT: (req: Request, ctx: { params: Promise<{ path: string[] }> }) => Promise<Response>;
+let filePATCH: (req: Request, ctx: { params: Promise<{ path: string[] }> }) => Promise<Response>;
 let fileDELETE: (req: Request, ctx: { params: Promise<{ path: string[] }> }) => Promise<Response>;
 let lsGET: (req: Request, ctx: { params: Promise<{ path?: string[] }> }) => Promise<Response>;
 let movePOST: (req: Request) => Promise<Response>;
@@ -103,6 +104,7 @@ before(async () => {
 	const fileRoute = await import("../../app/api/agent/fs/file/[...path]/route.js");
 	fileGET = fileRoute.GET;
 	filePUT = fileRoute.PUT;
+	filePATCH = fileRoute.PATCH;
 	fileDELETE = fileRoute.DELETE;
 
 	const lsRoute = await import("../../app/api/agent/fs/ls/[[...path]]/route.js");
@@ -822,3 +824,150 @@ test("traversal: .proof/ denied on PUT", async () => {
 	const res = await filePUT(req, makeCtx([".proof", "inject.json"]));
 	assert.equal(res.status, 400);
 });
+
+// ── PATCH (server-side str-replace) ──────────────────────────────────────────
+
+test("PATCH: str-replace on .md succeeds, sends only find/replace", async () => {
+	const orig = Buffer.from("# Title\n\nHello world. Keep this.\n");
+	await writeFile(path.join(tmpRoot, "patch1.md"), orig);
+	const req = new Request(fileUrl("patch1.md"), {
+		method: "PATCH",
+		headers: { ...agentHeaders(MUTATE_TOKEN, "ai:mutate-agent"), "Content-Type": "application/json", "If-Match": sha256(orig) },
+		body: JSON.stringify({ find: "Hello world", replace: "Goodbye moon" }),
+	});
+	const res = await filePATCH(req, makeCtx(["patch1.md"]));
+	assert.equal(res.status, 200, await res.text());
+	const out = await readFile(path.join(tmpRoot, "patch1.md"), "utf-8");
+	assert.equal(out, "# Title\n\nGoodbye moon. Keep this.\n");
+});
+
+test("PATCH: missing If-Match → 412", async () => {
+	const orig = Buffer.from("alpha beta gamma");
+	await writeFile(path.join(tmpRoot, "patch2.txt"), orig);
+	const req = new Request(fileUrl("patch2.txt"), {
+		method: "PATCH",
+		headers: { ...agentHeaders(MUTATE_TOKEN, "ai:mutate-agent"), "Content-Type": "application/json" },
+		body: JSON.stringify({ find: "beta", replace: "BETA" }),
+	});
+	const res = await filePATCH(req, makeCtx(["patch2.txt"]));
+	assert.equal(res.status, 412);
+});
+
+test("PATCH: If-Match mismatch → 412", async () => {
+	const orig = Buffer.from("alpha beta gamma");
+	await writeFile(path.join(tmpRoot, "patch3.txt"), orig);
+	const req = new Request(fileUrl("patch3.txt"), {
+		method: "PATCH",
+		headers: { ...agentHeaders(MUTATE_TOKEN, "ai:mutate-agent"), "Content-Type": "application/json", "If-Match": "sha256:deadbeef" },
+		body: JSON.stringify({ find: "beta", replace: "BETA" }),
+	});
+	const res = await filePATCH(req, makeCtx(["patch3.txt"]));
+	assert.equal(res.status, 412);
+});
+
+test("PATCH: zero matches → 422 MATCH_COUNT_MISMATCH", async () => {
+	const orig = Buffer.from("alpha beta gamma");
+	await writeFile(path.join(tmpRoot, "patch4.txt"), orig);
+	const req = new Request(fileUrl("patch4.txt"), {
+		method: "PATCH",
+		headers: { ...agentHeaders(MUTATE_TOKEN, "ai:mutate-agent"), "Content-Type": "application/json", "If-Match": sha256(orig) },
+		body: JSON.stringify({ find: "nonexistent", replace: "x" }),
+	});
+	const res = await filePATCH(req, makeCtx(["patch4.txt"]));
+	assert.equal(res.status, 422);
+	const j = await res.json();
+	assert.equal(j.error, "MATCH_COUNT_MISMATCH");
+	assert.equal(j.found, 0);
+});
+
+test("PATCH: multiple matches but expected 1 → 422", async () => {
+	const orig = Buffer.from("foo bar foo baz foo");
+	await writeFile(path.join(tmpRoot, "patch5.txt"), orig);
+	const req = new Request(fileUrl("patch5.txt"), {
+		method: "PATCH",
+		headers: { ...agentHeaders(MUTATE_TOKEN, "ai:mutate-agent"), "Content-Type": "application/json", "If-Match": sha256(orig) },
+		body: JSON.stringify({ find: "foo", replace: "X" }),
+	});
+	const res = await filePATCH(req, makeCtx(["patch5.txt"]));
+	assert.equal(res.status, 422);
+	const j = await res.json();
+	assert.equal(j.found, 3);
+});
+
+test("PATCH: expectedOccurrences matching multi replaces all", async () => {
+	const orig = Buffer.from("foo bar foo baz foo");
+	await writeFile(path.join(tmpRoot, "patch6.txt"), orig);
+	const req = new Request(fileUrl("patch6.txt"), {
+		method: "PATCH",
+		headers: { ...agentHeaders(MUTATE_TOKEN, "ai:mutate-agent"), "Content-Type": "application/json", "If-Match": sha256(orig) },
+		body: JSON.stringify({ find: "foo", replace: "X", expectedOccurrences: 3 }),
+	});
+	const res = await filePATCH(req, makeCtx(["patch6.txt"]));
+	assert.equal(res.status, 200, await res.text());
+	const out = await readFile(path.join(tmpRoot, "patch6.txt"), "utf-8");
+	assert.equal(out, "X bar X baz X");
+});
+
+test("PATCH: empty find → 400", async () => {
+	const orig = Buffer.from("abc");
+	await writeFile(path.join(tmpRoot, "patch7.txt"), orig);
+	const req = new Request(fileUrl("patch7.txt"), {
+		method: "PATCH",
+		headers: { ...agentHeaders(MUTATE_TOKEN, "ai:mutate-agent"), "Content-Type": "application/json", "If-Match": sha256(orig) },
+		body: JSON.stringify({ find: "", replace: "x" }),
+	});
+	const res = await filePATCH(req, makeCtx(["patch7.txt"]));
+	assert.equal(res.status, 400);
+});
+
+test("PATCH: binary file → 415", async () => {
+	const orig = Buffer.from([0x00, 0x01, 0x02, 0xff, 0xfe, 0x00, 0x10]);
+	await writeFile(path.join(tmpRoot, "patch8.bin"), orig);
+	const req = new Request(fileUrl("patch8.bin"), {
+		method: "PATCH",
+		headers: { ...agentHeaders(MUTATE_TOKEN, "ai:mutate-agent"), "Content-Type": "application/json", "If-Match": sha256(orig) },
+		body: JSON.stringify({ find: "x", replace: "y" }),
+	});
+	const res = await filePATCH(req, makeCtx(["patch8.bin"]));
+	assert.equal(res.status, 415);
+});
+
+test("PATCH: nonexistent file → 404 (no create)", async () => {
+	const req = new Request(fileUrl("patch-missing.txt"), {
+		method: "PATCH",
+		headers: { ...agentHeaders(MUTATE_TOKEN, "ai:mutate-agent"), "Content-Type": "application/json", "If-Match": "sha256:abc" },
+		body: JSON.stringify({ find: "a", replace: "b" }),
+	});
+	const res = await filePATCH(req, makeCtx(["patch-missing.txt"]));
+	assert.equal(res.status, 404);
+});
+
+test("PATCH: .md emits file.rawWritten + reconciles (same path as PUT)", async () => {
+	const orig = Buffer.from("# H\n\noriginal paragraph here\n");
+	await writeFile(path.join(tmpRoot, "patch-md.md"), orig);
+	const req = new Request(fileUrl("patch-md.md"), {
+		method: "PATCH",
+		headers: { ...agentHeaders(MUTATE_TOKEN, "ai:mutate-agent"), "Content-Type": "application/json", "If-Match": sha256(orig) },
+		body: JSON.stringify({ find: "original", replace: "updated" }),
+	});
+	const res = await filePATCH(req, makeCtx(["patch-md.md"]));
+	assert.equal(res.status, 200, await res.text());
+	const sidecar = await readSidecar(tmpRoot, "patch-md.md");
+	assert.ok(sidecar, "sidecar created");
+	const events = sidecar!.events.filter((e) => e.type === "file.rawWritten");
+	assert.ok(events.length > 0, "file.rawWritten event present");
+	const newContent = await readFile(path.join(tmpRoot, "patch-md.md"), "utf-8");
+	assert.equal(sidecar!.fingerprint, sha256(Buffer.from(newContent)), "fingerprint matches new content (eager reconcile)");
+});
+
+test("PATCH: requires mutate scope", async () => {
+	const orig = Buffer.from("hello");
+	await writeFile(path.join(tmpRoot, "patch-scope.txt"), orig);
+	const req = new Request(fileUrl("patch-scope.txt"), {
+		method: "PATCH",
+		headers: { ...agentHeaders(READ_TOKEN, "ai:read-agent"), "Content-Type": "application/json", "If-Match": sha256(orig) },
+		body: JSON.stringify({ find: "hello", replace: "hi" }),
+	});
+	const res = await filePATCH(req, makeCtx(["patch-scope.txt"]));
+	assert.equal(res.status, 403);
+});

package/.next/standalone/src/tests/proof/bench-write.ts

@@ -0,0 +1,179 @@
+/**
+ * Isolated write-path benchmark — NOT a test, NOT touching production state.
+ *
+ * Drives the real Tier-1 route handlers (filePUT / fileGET) against a throwaway
+ * temp rootDir + temp HOME (lock dir), exactly like agent-fs.test.ts, and
+ * measures end-to-end server-side latency for the write path:
+ *   - non-.md overwrite (raw, no lock/sidecar)
+ *   - .md overwrite (cross-proc lock + reconcile + sidecar write + datasync)
+ *   - edit_file equivalent (GET + PUT round-trip on .md)
+ *
+ * Run:  npx tsx src/tests/proof/bench-write.ts
+ * Optional env: BENCH_ITERS (default 300), BENCH_WARMUP (default 30)
+ */
+import { mkdtemp, writeFile, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import { createHash, randomBytes } from "node:crypto";
+
+import { setRootDir } from "../../lib/root-dir.js";
+import { ensureRegistry, addAgent, hashToken } from "../../lib/proof/registry.js";
+
+const ITERS = Number(process.env.BENCH_ITERS) || 300;
+const WARMUP = Number(process.env.BENCH_WARMUP) || 30;
+
+function sha256(buf: Buffer): string {
+	return "sha256:" + createHash("sha256").update(buf).digest("hex");
+}
+function hdrs(token: string, id: string): Record<string, string> {
+	return { Authorization: `Bearer ${token}`, "X-Agent-Id": id };
+}
+function fileUrl(rel: string, qs = ""): string {
+	return `http://localhost/api/agent/fs/file/${rel}${qs}`;
+}
+
+function pct(sorted: number[], p: number): number {
+	const i = Math.min(sorted.length - 1, Math.floor((p / 100) * sorted.length));
+	return sorted[i];
+}
+function stats(label: string, samples: number[]) {
+	const s = [...samples].sort((a, b) => a - b);
+	const sum = s.reduce((a, b) => a + b, 0);
+	const mean = sum / s.length;
+	return {
+		label,
+		n: s.length,
+		mean: +mean.toFixed(3),
+		p50: +pct(s, 50).toFixed(3),
+		p95: +pct(s, 95).toFixed(3),
+		p99: +pct(s, 99).toFixed(3),
+		min: +s[0].toFixed(3),
+		max: +s[s.length - 1].toFixed(3),
+	};
+}
+
+async function timeIt(fn: () => Promise<void>): Promise<number> {
+	const t0 = performance.now();
+	await fn();
+	return performance.now() - t0;
+}
+
+async function main() {
+	const tmpHome = await mkdtemp(path.join(tmpdir(), "bench-home-"));
+	const tmpRoot = await mkdtemp(path.join(tmpdir(), "bench-root-"));
+	process.env.HOME = tmpHome;
+	setRootDir(tmpRoot);
+	await ensureRegistry();
+
+	const TOKEN = randomBytes(32).toString("hex");
+	await addAgent({
+		id: "ai:bench",
+		displayName: "Bench",
+		tokenHash: hashToken(TOKEN),
+		scope: { paths: ["**/*"], ops: ["read", "mutate", "delete"] },
+		createdAt: new Date().toISOString(),
+		lastSeen: new Date().toISOString(),
+	});
+
+	const fileRoute = await import("../../app/api/agent/fs/file/[...path]/route.js");
+	const filePUT = fileRoute.PUT;
+	const fileGET = fileRoute.GET;
+	const H = hdrs(TOKEN, "ai:bench");
+
+	const ctx = (rel: string) => ({ params: Promise.resolve({ path: rel.split("/") }) });
+
+	// Seed bodies (~1KB, realistic small doc)
+	const body = Buffer.from("# Doc\n\n" + "lorem ipsum dolor sit amet. ".repeat(40));
+	const txtBody = Buffer.from("config_value = " + "x".repeat(900));
+
+	async function putOnce(rel: string, data: Buffer, ifMatch?: string, ifCollab?: string): Promise<Response> {
+		const headers: Record<string, string> = { ...H, "Content-Type": "application/octet-stream" };
+		if (ifMatch) headers["If-Match"] = ifMatch;
+		if (ifCollab) headers["If-Collab-Match"] = ifCollab;
+		return filePUT(new Request(fileUrl(rel), { method: "PUT", headers, body: new Uint8Array(data) }), ctx(rel));
+	}
+	async function getSha(rel: string): Promise<{ sha: string; collabRev: string | null }> {
+		const res = await fileGET(new Request(fileUrl(rel), { headers: H }), ctx(rel));
+		const etag = (res.headers.get("ETag") ?? "").replace(/"/g, "");
+		return { sha: etag, collabRev: res.headers.get("X-Collab-Revision") };
+	}
+
+	// ── Scenario A: non-.md overwrite (lean path) ──────────────────────────────
+	await putOnce("bench.txt", txtBody, undefined); // create
+	const txtSamples: number[] = [];
+	{
+		let sha = (await getSha("bench.txt")).sha;
+		for (let i = 0; i < WARMUP + ITERS; i++) {
+			const data = Buffer.from(txtBody.toString() + i);
+			const t = await timeIt(async () => {
+				const res = await putOnce("bench.txt", data, sha);
+				if (res.status !== 200) throw new Error("txt PUT " + res.status);
+				sha = (await res.json() as { sha256: string }).sha256;
+			});
+			if (i >= WARMUP) txtSamples.push(t);
+		}
+	}
+
+	// ── Scenario B: .md overwrite (lock + reconcile + sidecar + datasync) ──────
+	await putOnce("bench.md", body, undefined); // create
+	const mdSamples: number[] = [];
+	{
+		let sha = (await getSha("bench.md")).sha;
+		for (let i = 0; i < WARMUP + ITERS; i++) {
+			const data = Buffer.from(body.toString() + "\n\nedit " + i);
+			const t = await timeIt(async () => {
+				const res = await putOnce("bench.md", data, sha);
+				if (res.status !== 200) throw new Error("md PUT " + res.status + " " + await res.text());
+				sha = (await res.json() as { sha256: string }).sha256;
+			});
+			if (i >= WARMUP) mdSamples.push(t);
+		}
+	}
+
+	// ── Scenario C: edit_file equivalent — GET + PUT round-trip on .md ─────────
+	const editSamples: number[] = [];
+	{
+		for (let i = 0; i < WARMUP + ITERS; i++) {
+			const data = Buffer.from(body.toString() + "\n\nrt " + i);
+			const t = await timeIt(async () => {
+				const { sha } = await getSha("bench.md");
+				const res = await putOnce("bench.md", data, sha);
+				if (res.status !== 200) throw new Error("edit PUT " + res.status);
+				await res.json();
+			});
+			if (i >= WARMUP) editSamples.push(t);
+		}
+	}
+
+	const results = [
+		stats("non-.md overwrite (lean)", txtSamples),
+		stats(".md overwrite (lock+reconcile+sidecar+datasync)", mdSamples),
+		stats("edit_file (GET+PUT .md round-trip)", editSamples),
+	];
+
+	console.log(`\nwrite-path benchmark  (iters=${ITERS}, warmup=${WARMUP}, ~1KB bodies)\n`);
+	console.log(
+		["scenario".padEnd(48), "p50", "p95", "p99", "mean", "max"].join("  "),
+	);
+	for (const r of results) {
+		console.log(
+			[
+				r.label.padEnd(48),
+				`${r.p50}ms`.padStart(7),
+				`${r.p95}ms`.padStart(7),
+				`${r.p99}ms`.padStart(7),
+				`${r.mean}ms`.padStart(7),
+				`${r.max}ms`.padStart(7),
+			].join("  "),
+		);
+	}
+	console.log("");
+
+	await rm(tmpHome, { recursive: true, force: true });
+	await rm(tmpRoot, { recursive: true, force: true });
+}
+
+main().catch((e) => {
+	console.error(e);
+	process.exit(1);
+});