wiki-viewer 1.7.1 → 1.8.0

package/.next/standalone/src/tests/proof/search-index.test.ts

@@ -0,0 +1,339 @@
+/**
+ * FTS5 full-text search indexer tests.
+ *
+ * Drives the indexer directly (ensureIndexer + initial scan, plus indexFile /
+ * deleteFile to simulate chokidar events) so assertions are deterministic and
+ * do not depend on filesystem-watcher timing.
+ */
+import { test, before, after, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtemp, rm, writeFile, mkdir, symlink } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+
+let tmpHome: string;
+let rootA: string;
+let rootB: string;
+
+before(async () => {
+	tmpHome = await mkdtemp(path.join(tmpdir(), "search-test-home-"));
+	rootA = await mkdtemp(path.join(tmpdir(), "search-test-rootA-"));
+	rootB = await mkdtemp(path.join(tmpdir(), "search-test-rootB-"));
+	process.env.HOME = tmpHome;
+});
+
+after(async () => {
+	await rm(tmpHome, { recursive: true, force: true });
+	await rm(rootA, { recursive: true, force: true });
+	await rm(rootB, { recursive: true, force: true });
+});
+
+import {
+	ensureIndexer,
+	ftsSearch,
+	indexFile,
+	deleteFile,
+	purgeWorkspace,
+	_resetIndexer,
+	_waitForIdle,
+} from "../../lib/search/indexer.js";
+import { _resetSearchDb, getSearchDb } from "../../lib/search/search-db.js";
+import { _resetWatcherPool } from "../../lib/search/watcher-pool.js";
+import { sanitizeFtsQuery } from "../../lib/search/sanitize.js";
+import { readFileSync } from "node:fs";
+
+afterEach(() => {
+	_resetIndexer();
+	_resetWatcherPool();
+	// Clear all rows so each test starts clean (cheaper than rebuilding the DB).
+	try {
+		const db = getSearchDb();
+		db.exec("DELETE FROM docs; DELETE FROM docs_meta;");
+	} catch {
+		/* db may not exist yet */
+	}
+});
+
+async function scan(wsId: string, root: string): Promise<void> {
+	await ensureIndexer(wsId, root);
+	await _waitForIdle(wsId);
+}
+
+test("indexes a markdown file and finds it", async () => {
+	await writeFile(path.join(rootA, "notes.md"), "the quick brown fox");
+	await scan("wsA", rootA);
+	const res = ftsSearch("wsA", "fox", 10);
+	assert.equal(res.matches.length, 1);
+	assert.equal(res.matches[0]!.path, "notes.md");
+	assert.match(res.matches[0]!.snippet, /<mark>fox<\/mark>/);
+});
+
+test("BM25 ordering: denser document ranks first", async () => {
+	await writeFile(path.join(rootA, "sparse.md"), "alpha one two three four");
+	await writeFile(
+		path.join(rootA, "dense.md"),
+		"alpha alpha alpha alpha alpha",
+	);
+	await scan("wsA", rootA);
+	const res = ftsSearch("wsA", "alpha", 10);
+	assert.equal(res.matches.length, 2);
+	assert.equal(res.matches[0]!.path, "dense.md");
+});
+
+test("snippet contains <mark> highlight", async () => {
+	const words = Array.from({ length: 200 }, (_, i) =>
+		i === 100 ? "needle" : `word${i}`,
+	).join(" ");
+	await writeFile(path.join(rootA, "long.md"), words);
+	await scan("wsA", rootA);
+	const res = ftsSearch("wsA", "needle", 10);
+	assert.equal(res.matches.length, 1);
+	assert.match(res.matches[0]!.snippet, /<mark>needle<\/mark>/);
+});
+
+test("workspace isolation: a doc in A never appears in a B query", async () => {
+	await writeFile(path.join(rootA, "secret.md"), "topsecretalpha");
+	await writeFile(path.join(rootB, "secret.md"), "topsecretbeta");
+	await scan("wsA", rootA);
+	await scan("wsB", rootB);
+
+	assert.equal(ftsSearch("wsA", "topsecretbeta", 10).matches.length, 0);
+	assert.equal(ftsSearch("wsB", "topsecretalpha", 10).matches.length, 0);
+	assert.equal(ftsSearch("wsA", "topsecretalpha", 10).matches.length, 1);
+	assert.equal(ftsSearch("wsB", "topsecretbeta", 10).matches.length, 1);
+});
+
+test("incremental update on file change", async () => {
+	const p = path.join(rootA, "x.md");
+	await writeFile(p, "foofoo");
+	await scan("wsA", rootA);
+	assert.equal(ftsSearch("wsA", "foofoo", 10).matches.length, 1);
+
+	await writeFile(p, "barbar");
+	await indexFile("wsA", rootA, "x.md");
+	assert.equal(ftsSearch("wsA", "foofoo", 10).matches.length, 0);
+	assert.equal(ftsSearch("wsA", "barbar", 10).matches.length, 1);
+});
+
+test("deleted file no longer matches", async () => {
+	await writeFile(path.join(rootA, "gone.md"), "deletetoken");
+	await scan("wsA", rootA);
+	assert.equal(ftsSearch("wsA", "deletetoken", 10).matches.length, 1);
+
+	await deleteFile("wsA", "gone.md");
+	assert.equal(ftsSearch("wsA", "deletetoken", 10).matches.length, 0);
+
+	const db = getSearchDb();
+	const row = db
+		.prepare("SELECT COUNT(*) AS n FROM docs_meta WHERE ws = ? AND path = ?")
+		.get("wsA", "gone.md") as { n: number };
+	assert.equal(row.n, 0);
+});
+
+test("frontmatter is searchable", async () => {
+	await writeFile(
+		path.join(rootA, "fm.md"),
+		"---\ntitle: ImportantDoc\ntags: [alphatag, betatag]\n---\nbody text",
+	);
+	await scan("wsA", rootA);
+	assert.equal(ftsSearch("wsA", "ImportantDoc", 10).matches.length, 1);
+	assert.equal(ftsSearch("wsA", "alphatag", 10).matches.length, 1);
+});
+
+test("non-text file: filename indexed, binary body skipped", async () => {
+	// PNG magic header + random-ish bytes (contains a null byte -> binary).
+	const buf = Buffer.from([0x89, 0x50, 0x4e, 0x47, 0x00, 0x01, 0x02, 0x03]);
+	await writeFile(path.join(rootA, "diagram.png"), buf);
+	await scan("wsA", rootA);
+	assert.equal(ftsSearch("wsA", "diagram", 10).matches.length, 1);
+});
+
+test("oversize file body skipped, filename still indexed", async () => {
+	const big = "needlebig ".repeat(150_000); // > 1 MiB
+	await writeFile(path.join(rootA, "huge.txt"), big);
+	await scan("wsA", rootA);
+	assert.equal(ftsSearch("wsA", "needlebig", 10).matches.length, 0);
+	assert.equal(ftsSearch("wsA", "huge", 10).matches.length, 1);
+});
+
+test("denied paths (.proof, .git) skipped", async () => {
+	await mkdir(path.join(rootA, ".proof"), { recursive: true });
+	await mkdir(path.join(rootA, ".git"), { recursive: true });
+	await writeFile(path.join(rootA, ".proof", "foo.md"), "prooftoken");
+	await writeFile(path.join(rootA, ".git", "HEAD"), "githeadtoken");
+	await writeFile(path.join(rootA, "real.md"), "realtoken");
+	await scan("wsA", rootA);
+	assert.equal(ftsSearch("wsA", "prooftoken", 10).matches.length, 0);
+	assert.equal(ftsSearch("wsA", "githeadtoken", 10).matches.length, 0);
+	assert.equal(ftsSearch("wsA", "realtoken", 10).matches.length, 1);
+});
+
+test("app dir contents are not indexed (node-app and static app)", async () => {
+	// node-app: directory with package.json
+	await mkdir(path.join(rootA, "my-app"), { recursive: true });
+	await writeFile(path.join(rootA, "my-app", "package.json"), "{}");
+	await writeFile(path.join(rootA, "my-app", "index.js"), "appinnertoken");
+	// static app: directory with index.html
+	await mkdir(path.join(rootA, "site"), { recursive: true });
+	await writeFile(path.join(rootA, "site", "index.html"), "sitehtmltoken");
+	await writeFile(path.join(rootA, "site", "app.js"), "siteinnertoken");
+	// a normal note that must still be searchable
+	await writeFile(path.join(rootA, "note.md"), "normalnotetoken");
+	await scan("wsA", rootA);
+
+	assert.equal(ftsSearch("wsA", "appinnertoken", 10).matches.length, 0);
+	assert.equal(ftsSearch("wsA", "sitehtmltoken", 10).matches.length, 0);
+	assert.equal(ftsSearch("wsA", "siteinnertoken", 10).matches.length, 0);
+	assert.equal(ftsSearch("wsA", "normalnotetoken", 10).matches.length, 1);
+});
+
+test("symlink escaping the workspace is not indexed", async () => {
+	// A secret file outside the workspace, reachable only via an in-root symlink.
+	const outside = await mkdtemp(path.join(tmpdir(), "search-test-outside-"));
+	await writeFile(path.join(outside, "leak.md"), "escapedsecrettoken");
+	try {
+		await symlink(
+			path.join(outside, "leak.md"),
+			path.join(rootA, "link.md"),
+		);
+	} catch {
+		// Platform without symlink permission: skip.
+		await rm(outside, { recursive: true, force: true });
+		return;
+	}
+	await scan("wsA", rootA);
+	// The symlinked-out content must never be searchable.
+	assert.equal(ftsSearch("wsA", "escapedsecrettoken", 10).matches.length, 0);
+	await rm(outside, { recursive: true, force: true });
+});
+
+test("purgeWorkspace removes all rows for that ws", async () => {
+	await writeFile(path.join(rootA, "a.md"), "purgetoken one");
+	await writeFile(path.join(rootA, "b.md"), "purgetoken two");
+	await scan("wsA", rootA);
+	assert.equal(ftsSearch("wsA", "purgetoken", 10).matches.length, 2);
+
+	await purgeWorkspace("wsA");
+	assert.equal(ftsSearch("wsA", "purgetoken", 10).matches.length, 0);
+
+	const db = getSearchDb();
+	const row = db
+		.prepare("SELECT COUNT(*) AS n FROM docs_meta WHERE ws = ?")
+		.get("wsA") as { n: number };
+	assert.equal(row.n, 0);
+});
+
+test("empty / whitespace / punctuation-only query returns empty without throwing", () => {
+	assert.deepEqual(ftsSearch("wsA", "", 10), { matches: [], truncated: false });
+	assert.deepEqual(ftsSearch("wsA", "   ", 10), {
+		matches: [],
+		truncated: false,
+	});
+	assert.deepEqual(ftsSearch("wsA", "***", 10), {
+		matches: [],
+		truncated: false,
+	});
+});
+
+test("sanitizer neutralizes FTS5 operators", () => {
+	assert.equal(sanitizeFtsQuery("alpha AND beta"), '"alpha" "AND" "beta"');
+	assert.equal(sanitizeFtsQuery("foo NEAR bar"), '"foo" "NEAR" "bar"');
+	// Quotes and semicolons are stripped to safe tokens.
+	assert.equal(sanitizeFtsQuery('"; DROP docs'), '"DROP" "docs"');
+	// Prefix star preserved.
+	assert.equal(sanitizeFtsQuery("devel*"), '"devel"*');
+});
+
+test("operator-keyword query still searches literally and does not throw", async () => {
+	await writeFile(path.join(rootA, "lit.md"), "this and that");
+	await scan("wsA", rootA);
+	// "and" is quoted by the sanitizer, so this matches the literal word.
+	const res = ftsSearch("wsA", "and", 10);
+	assert.equal(res.matches.length, 1);
+});
+
+test("porter stemmer collapses inflections", async () => {
+	await writeFile(path.join(rootA, "stem.md"), "running fast");
+	await scan("wsA", rootA);
+	assert.equal(ftsSearch("wsA", "run", 10).matches.length, 1);
+});
+
+test("diacritic folding: café matches cafe", async () => {
+	await writeFile(path.join(rootA, "dia.md"), "the cafe is open");
+	await scan("wsA", rootA);
+	assert.equal(ftsSearch("wsA", "café", 10).matches.length, 1);
+});
+
+test("prefix search with * finds longer words", async () => {
+	await writeFile(path.join(rootA, "pre.md"), "developer notes");
+	await scan("wsA", rootA);
+	assert.equal(ftsSearch("wsA", "devel*", 10).matches.length, 1);
+});
+
+test("concurrent ensureIndexer is deduped (single scan)", async () => {
+	await writeFile(path.join(rootA, "dedupe.md"), "dedupetoken");
+	const [a, b] = [
+		ensureIndexer("wsA", rootA),
+		ensureIndexer("wsA", rootA),
+	];
+	await Promise.all([a, b]);
+	await _waitForIdle("wsA");
+	const db = getSearchDb();
+	const row = db
+		.prepare("SELECT COUNT(*) AS n FROM docs WHERE ws = ? AND path = ?")
+		.get("wsA", "dedupe.md") as { n: number };
+	assert.equal(row.n, 1); // not double-inserted
+});
+
+test("unchanged file (same size+mtime) is not re-indexed", async () => {
+	const p = path.join(rootA, "stable.md");
+	await writeFile(p, "stabletoken");
+	await scan("wsA", rootA);
+	const db = getSearchDb();
+	const first = db
+		.prepare("SELECT indexed_at FROM docs_meta WHERE ws = ? AND path = ?")
+		.get("wsA", "stable.md") as { indexed_at: string };
+
+	await new Promise((r) => setTimeout(r, 5));
+	await indexFile("wsA", rootA, "stable.md"); // no file change
+	const second = db
+		.prepare("SELECT indexed_at FROM docs_meta WHERE ws = ? AND path = ?")
+		.get("wsA", "stable.md") as { indexed_at: string };
+	assert.equal(first.indexed_at, second.indexed_at);
+});
+
+test("rename via delete+add keeps only the new path", async () => {
+	await writeFile(path.join(rootA, "old.md"), "renametoken");
+	await scan("wsA", rootA);
+	await deleteFile("wsA", "old.md");
+	await writeFile(path.join(rootA, "new.md"), "renametoken");
+	await indexFile("wsA", rootA, "new.md");
+	const res = ftsSearch("wsA", "renametoken", 10);
+	assert.equal(res.matches.length, 1);
+	assert.equal(res.matches[0]!.path, "new.md");
+});
+
+test("DEFENSIVE: every 'FROM docs' in indexer.ts is ws-scoped", () => {
+	const raw = readFileSync(
+		new URL("../../lib/search/indexer.ts", import.meta.url),
+		"utf-8",
+	);
+	// Strip block and line comments so prose mentioning "FROM docs" is ignored;
+	// only real SQL counts.
+	const src = raw
+		.replace(/\/\*[\s\S]*?\*\//g, "")
+		.replace(/\/\/.*$/gm, "");
+	// Find each SELECT/DELETE ... FROM docs and assert a ws filter follows.
+	const re = /FROM docs\b([\s\S]{0,120})/g;
+	let m: RegExpExecArray | null;
+	let count = 0;
+	while ((m = re.exec(src)) !== null) {
+		count++;
+		assert.match(
+			m[1]!,
+			/ws\s*=\s*\?/,
+			`A 'FROM docs' query is missing a ws filter:\n${m[0]}`,
+		);
+	}
+	assert.ok(count >= 1, "expected at least one 'FROM docs' query");
+});

package/.next/standalone/src/tests/proof/workspace-isolation.test.ts

@@ -0,0 +1,87 @@
+/**
+ * Phase E — cross-workspace isolation (the "no bleed" contract).
+ *
+ * Two workspaces (different rootDirs) that contain the SAME relative path must
+ * not share in-memory state:
+ *   - edit leases (lease.ts is keyed by ns=rootDir)
+ *   - collab-state revision / active flag
+ *   - sidecars (live under <rootDir>/.proof/, naturally isolated)
+ */
+import { test, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtemp, rm, writeFile, mkdir } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+
+import {
+	setLease,
+	hasActiveLease,
+	clearLease,
+	leaseGeneration,
+	_resetLeaseStore,
+} from "../../lib/proof/lease.js";
+import { computeCollabState } from "../../lib/proof/collab-state.js";
+import { writeSidecar, emptySidecar } from "../../lib/proof/sidecar.js";
+
+let rootA: string;
+let rootB: string;
+
+before(async () => {
+	rootA = await mkdtemp(path.join(tmpdir(), "wsiso-A-"));
+	rootB = await mkdtemp(path.join(tmpdir(), "wsiso-B-"));
+	_resetLeaseStore();
+});
+
+after(async () => {
+	await rm(rootA, { recursive: true, force: true });
+	await rm(rootB, { recursive: true, force: true });
+});
+
+const REL = "notes.md";
+
+test("lease on (rootA, notes.md) does NOT make (rootB, notes.md) active", () => {
+	setLease(rootA, REL, "user:alice");
+	assert.equal(hasActiveLease(rootA, REL), true);
+	assert.equal(hasActiveLease(rootB, REL), false, "workspace B must be unaffected");
+	clearLease(rootA, REL, "user:alice");
+	assert.equal(hasActiveLease(rootA, REL), false);
+});
+
+test("lease generation counters are independent per workspace", () => {
+	const genA0 = leaseGeneration(rootA, REL);
+	const genB0 = leaseGeneration(rootB, REL);
+	// Bump A twice (open/close), leave B untouched.
+	setLease(rootA, REL, "user:alice");
+	clearLease(rootA, REL, "user:alice");
+	assert.equal(leaseGeneration(rootA, REL), genA0 + 2);
+	assert.equal(leaseGeneration(rootB, REL), genB0, "B generation must not move");
+});
+
+test("computeCollabState: human lease in A is 'active' only in A", async () => {
+	// Same relpath, a sidecar with one comment in BOTH workspaces would be
+	// 'active'; here neither has artifacts, so state is driven purely by lease.
+	await mkdir(path.join(rootA, ".proof"), { recursive: true });
+	await mkdir(path.join(rootB, ".proof"), { recursive: true });
+
+	setLease(rootA, REL, "user:alice");
+	const a = await computeCollabState(rootA, REL);
+	const b = await computeCollabState(rootB, REL);
+	assert.equal(a.state, "active", "A has a live human lease");
+	assert.equal(b.state, "untracked", "B has no lease, no sidecar");
+	clearLease(rootA, REL, "user:alice");
+});
+
+test("sidecars are isolated by rootDir (same relpath, different content)", async () => {
+	const scA = emptySidecar(REL);
+	scA.revision = 7;
+	const scB = emptySidecar(REL);
+	scB.revision = 99;
+	await writeSidecar(rootA, REL, scA);
+	await writeSidecar(rootB, REL, scB);
+
+	const a = await computeCollabState(rootA, REL);
+	const b = await computeCollabState(rootB, REL);
+	// revision = sidecar.revision + leaseGeneration(ns); leases cleared above.
+	assert.equal(a.revision - leaseGeneration(rootA, REL), 7);
+	assert.equal(b.revision - leaseGeneration(rootB, REL), 99);
+});

package/.next/standalone/src/tests/proof/workspaces-api.test.ts

@@ -0,0 +1,227 @@
+/**
+ * Phase D1 — Workspace & Admin API tests.
+ *
+ * Covers:
+ *   GET /workspaces        empty → after create
+ *   POST /workspaces       admin-only
+ *   PATCH /workspaces/[id] allowedUserIds admin-gating
+ *   DELETE /workspaces/[id]
+ *   GET /admins            GET/POST/DELETE + last-admin guard
+ */
+import { test, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+
+let tmpHome: string;
+let tmpDir: string;
+
+before(async () => {
+	tmpHome = await mkdtemp(path.join(tmpdir(), "ws-api-home-"));
+	tmpDir = await mkdtemp(path.join(tmpdir(), "ws-api-dir-"));
+	process.env.HOME = tmpHome;
+});
+
+after(async () => {
+	await rm(tmpHome, { recursive: true, force: true });
+	await rm(tmpDir, { recursive: true, force: true });
+});
+
+import { GET as wsGET, POST as wsPOST } from "../../app/api/system/workspaces/route.js";
+import { PATCH as wsPATCH, DELETE as wsDELETE } from "../../app/api/system/workspaces/[id]/route.js";
+import { POST as openPOST } from "../../app/api/system/workspaces/[id]/open/route.js";
+import { GET as adminsGET, POST as adminsPOST, DELETE as adminsDELETE } from "../../app/api/system/admins/route.js";
+
+async function signUp(tag: string): Promise<{ cookie: string; id: string; email: string }> {
+	const { auth, authReady } = await import("../../lib/auth/server.js");
+	await authReady();
+	const email = `${tag}${Date.now()}@test.local`;
+	const res = await auth.api.signUpEmail({
+		body: { email, password: "test1234!", name: tag },
+		asResponse: true,
+	});
+	if (!res.ok) throw new Error("signUp failed: " + res.status);
+	const setCookie = res.headers.get("set-cookie") ?? "";
+	const cookie = setCookie
+		.split(/,(?=[^ ])/)
+		.map((c) => c.split(";")[0].trim())
+		.join("; ");
+	const body = await res.json() as { user: { id: string } };
+	return { cookie, id: body.user.id, email };
+}
+
+function req(method: string, url: string, cookie: string, body?: unknown): Request {
+	return new Request(url, {
+		method,
+		headers: {
+			"content-type": "application/json",
+			cookie,
+		},
+		body: body !== undefined ? JSON.stringify(body) : undefined,
+	});
+}
+
+function params(id: string) {
+	return { params: Promise.resolve({ id }) };
+}
+
+/**
+ * Deterministically make a freshly-signed-up user an admin.
+ * Bootstrap only auto-promotes the FIRST-EVER user, so subsequent tests must
+ * promote their admin explicitly (no shared cookie for the bootstrapped one).
+ */
+async function makeAdmin(userId: string): Promise<void> {
+	const { addAdmin } = await import("../../lib/auth/admin.js");
+	await addAdmin(userId);
+}
+
+// ── Admin bootstrap + admins API ───────────────────────────────────────────────
+
+test("GET /admins: first user auto-promoted to admin", async () => {
+	const user = await signUp("admin1");
+	const res = await adminsGET(req("GET", "http://localhost/api/system/admins", user.cookie));
+	assert.equal(res.status, 200);
+	const json = await res.json() as { isAdmin: boolean; admins: string[]; users: unknown[] };
+	assert.equal(json.isAdmin, true);
+	assert.ok(json.admins.includes(user.id));
+	assert.ok(Array.isArray(json.users)); // admin sees user list
+});
+
+test("GET /admins: non-admin gets isAdmin:false, empty users", async () => {
+	// Sign up a second user — first user already bootstrapped above
+	const user2 = await signUp("nonadmin");
+	const res = await adminsGET(req("GET", "http://localhost/api/system/admins", user2.cookie));
+	assert.equal(res.status, 200);
+	const json = await res.json() as { isAdmin: boolean; users: unknown[] };
+	assert.equal(json.isAdmin, false);
+	assert.deepEqual(json.users, []);
+});
+
+test("POST /admins: admin promotes second user", async () => {
+	const admin = await signUp("admin2promo");
+	await makeAdmin(admin.id);
+	const user2 = await signUp("promo-target");
+	const res = await adminsPOST(req("POST", "http://localhost/api/system/admins", admin.cookie, { userId: user2.id }));
+	assert.equal(res.status, 200);
+	const json = await res.json() as { ok: boolean; admins: string[] };
+	assert.ok(json.ok);
+	assert.ok(json.admins.includes(user2.id));
+});
+
+test("DELETE /admins: refuses to remove last admin (LAST_ADMIN guard)", async () => {
+	// Create a fresh admin user, then ensure they are the ONLY admin by using
+	// removeAdmin directly, then verify the API returns 409.
+	const { removeAdmin: rm2, addAdmin: add2 } = await import("../../lib/auth/admin.js");
+	const { updateConfig: uc2 } = await import("../../lib/config.js");
+
+	// Set adminUserIds to a single known userId so last-admin guard fires.
+	const soloId = "solo-only-" + Date.now();
+	await uc2((cfg) => ({ ...cfg, adminUserIds: [soloId] }));
+
+	// Build a fake signed-in session for soloId is impossible without a real DB user.
+	// Instead, call removeAdmin directly to verify the guard, and also verify the
+	// API route returns 409 by calling it as an admin user that matches soloId.
+	// Since we cannot create a session for soloId, we verify guard via library:
+	try {
+		await rm2(soloId);
+		assert.fail("Expected LAST_ADMIN error");
+	} catch (e) {
+		const msg = e instanceof Error ? e.message : "";
+		assert.ok(msg.startsWith("LAST_ADMIN"), `Expected LAST_ADMIN, got: ${msg}`);
+	}
+
+	// Restore admin list for subsequent tests
+	const admin = await signUp("restore-admin");
+	await adminsGET(req("GET", "http://localhost/api/system/admins", admin.cookie));
+});
+
+// ── Workspace API ──────────────────────────────────────────────────────────────
+
+test("GET /workspaces: empty on fresh config", async () => {
+	const user = await signUp("ws-list-user");
+	const res = await wsGET(req("GET", "http://localhost/api/system/workspaces", user.cookie));
+	assert.equal(res.status, 200);
+	const json = await res.json() as { workspaces: unknown[] };
+	assert.ok(Array.isArray(json.workspaces));
+});
+
+test("POST /workspaces: admin creates workspace", async () => {
+	const admin = await signUp("ws-creator");
+	await makeAdmin(admin.id);
+	const newDir = await mkdtemp(path.join(tmpdir(), "ws-api-create-"));
+	try {
+		const res = await wsPOST(req("POST", "http://localhost/api/system/workspaces", admin.cookie, { rootDir: newDir }));
+		assert.equal(res.status, 200);
+		const json = await res.json() as { ok: boolean; workspace: { id: string; rootDir: string } };
+		assert.ok(json.ok);
+		assert.equal(json.workspace.rootDir, newDir);
+		assert.ok(json.workspace.id.startsWith("ws_"));
+
+		// Verify it shows in list
+		const listRes = await wsGET(req("GET", "http://localhost/api/system/workspaces", admin.cookie));
+		const listJson = await listRes.json() as { workspaces: Array<{ id: string }> };
+		assert.ok(listJson.workspaces.some((w) => w.id === json.workspace.id));
+
+		// PATCH name — any user with access
+		const patchRes = await wsPATCH(
+			req("PATCH", `http://localhost/api/system/workspaces/${json.workspace.id}`, admin.cookie, { name: "Renamed" }),
+			params(json.workspace.id),
+		);
+		assert.equal(patchRes.status, 200);
+		const patchJson = await patchRes.json() as { workspace: { name: string } };
+		assert.equal(patchJson.workspace.name, "Renamed");
+
+		// PATCH allowedUserIds: non-admin should fail
+		const nonAdmin = await signUp("non-admin-patch");
+		const patchForbidden = await wsPATCH(
+			req("PATCH", `http://localhost/api/system/workspaces/${json.workspace.id}`, nonAdmin.cookie, { allowedUserIds: [] }),
+			params(json.workspace.id),
+		);
+		assert.equal(patchForbidden.status, 403);
+
+		// PATCH allowedUserIds: admin succeeds
+		const patchAllowed = await wsPATCH(
+			req("PATCH", `http://localhost/api/system/workspaces/${json.workspace.id}`, admin.cookie, { allowedUserIds: [admin.id] }),
+			params(json.workspace.id),
+		);
+		assert.equal(patchAllowed.status, 200);
+
+		// DELETE workspace
+		const delRes = await wsDELETE(
+			req("DELETE", `http://localhost/api/system/workspaces/${json.workspace.id}`, admin.cookie),
+			params(json.workspace.id),
+		);
+		assert.equal(delRes.status, 200);
+		const delJson = await delRes.json() as { ok: boolean };
+		assert.ok(delJson.ok);
+	} finally {
+		await rm(newDir, { recursive: true, force: true });
+	}
+});
+
+test("POST /workspaces: non-existent dir returns 404", async () => {
+	const admin = await signUp("ws-baddir");
+	await makeAdmin(admin.id);
+	const res = await wsPOST(req("POST", "http://localhost/api/system/workspaces", admin.cookie, { rootDir: "/nonexistent/path/xyz" }));
+	assert.equal(res.status, 404);
+});
+
+test("POST /workspaces/[id]/open: updates lastOpenedAt", async () => {
+	const admin = await signUp("ws-open");
+	await makeAdmin(admin.id);
+	const newDir = await mkdtemp(path.join(tmpdir(), "ws-open-"));
+	try {
+		const createRes = await wsPOST(req("POST", "http://localhost/api/system/workspaces", admin.cookie, { rootDir: newDir }));
+		const { workspace } = await createRes.json() as { workspace: { id: string; lastOpenedAt: string } };
+
+		await new Promise((r) => setTimeout(r, 10)); // small delay for timestamp difference
+		const openRes = await openPOST(
+			req("POST", `http://localhost/api/system/workspaces/${workspace.id}/open`, admin.cookie),
+			params(workspace.id),
+		);
+		assert.equal(openRes.status, 200);
+	} finally {
+		await rm(newDir, { recursive: true, force: true });
+	}
+});