wiki-viewer 1.0.0 → 1.1.0

package/.next/standalone/src/app/api/agent/internal/span/route.ts

@@ -0,0 +1,117 @@
+/**
+ * Internal span accept/revert. Callable by owner (browser cookie) or any agent
+ * with mutate scope. The `by` field on emitted events is the authenticated agent id.
+ */
+import { readFile, writeFile } from "node:fs/promises";
+import { NextResponse } from "next/server";
+import { revertProofSpan } from "@/lib/proof/proof-span";
+import { readSidecar, writeSidecar, emptySidecar } from "@/lib/proof/sidecar";
+import { withFileMutex } from "@/lib/proof/mutex";
+import { emitEvents } from "@/lib/proof/event-bus";
+import { getRootDir, safeRootPath } from "@/lib/root-dir";
+import { checkAuth, enforceScope } from "@/lib/proof/auth";
+
+export const runtime = "nodejs";
+
+function isMarkdown(p: string): boolean {
+	return p.endsWith(".md") || p.endsWith(".markdown");
+}
+
+/**
+ * Remove the wrapper for a specific spanId while keeping inner content.
+ */
+function acceptSpanById(markdown: string, spanId: string): string {
+	const escapedId = spanId.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+	const re = new RegExp(
+		`<proof-span\\b[^>]*\\bid="${escapedId}"[^>]*>([\\s\\S]*?)<\\/proof-span>`,
+		"g",
+	);
+	return markdown.replace(re, "$1");
+}
+
+export async function POST(req: Request): Promise<NextResponse> {
+	const authResult = await checkAuth(req);
+	if (!authResult.ok) {
+		return NextResponse.json({ error: "UNAUTHORIZED" }, { status: 401 });
+	}
+
+	let body: { path?: unknown; spanId?: unknown; action?: unknown };
+	try {
+		body = (await req.json()) as { path?: unknown; spanId?: unknown; action?: unknown };
+	} catch {
+		return NextResponse.json({ error: "INVALID_PAYLOAD", message: "Invalid JSON" }, { status: 400 });
+	}
+
+	if (typeof body.path !== "string" || !body.path) {
+		return NextResponse.json({ error: "INVALID_PAYLOAD", message: "path (string) required" }, { status: 400 });
+	}
+	if (typeof body.spanId !== "string" || !body.spanId) {
+		return NextResponse.json({ error: "INVALID_PAYLOAD", message: "spanId (string) required" }, { status: 400 });
+	}
+	if (body.action !== "accept" && body.action !== "revert") {
+		return NextResponse.json({ error: "INVALID_PAYLOAD", message: "action must be 'accept' or 'revert'" }, { status: 400 });
+	}
+
+	const rel = body.path as string;
+	const spanId = body.spanId as string;
+	const action = body.action as "accept" | "revert";
+
+	if (rel.startsWith(".proof")) {
+		return NextResponse.json({ error: "INVALID_PATH", message: "Path must not be under .proof" }, { status: 400 });
+	}
+	if (!isMarkdown(rel)) {
+		return NextResponse.json({ error: "INVALID_PATH", message: "Path must be .md or .markdown" }, { status: 400 });
+	}
+
+	const absPath = safeRootPath(rel);
+	if (!absPath) {
+		return NextResponse.json({ error: "INVALID_PATH", message: "Path traversal rejected" }, { status: 400 });
+	}
+
+	const scopeCheck = enforceScope(authResult.agent, { filePath: rel, op: "mutate" });
+	if (!scopeCheck.ok) {
+		return NextResponse.json({ error: scopeCheck.code, message: scopeCheck.message }, { status: 403 });
+	}
+
+	const rootDir = getRootDir();
+	const actorId = authResult.agent.id;
+
+	let notFound = false;
+	try {
+		await withFileMutex(rel, async () => {
+			let content: string;
+			try {
+				content = await readFile(absPath, "utf-8");
+			} catch (err) {
+				if ((err as NodeJS.ErrnoException).code === "ENOENT") {
+					notFound = true;
+					return;
+				}
+				throw err;
+			}
+
+			const newContent = action === "accept"
+				? acceptSpanById(content, spanId)
+				: revertProofSpan(content, spanId);
+
+			await writeFile(absPath, newContent, "utf-8");
+
+			const sidecar = (await readSidecar(rootDir, rel)) ?? emptySidecar(rel);
+			emitEvents(sidecar, [{
+				type: action === "accept" ? "span.accepted" : "span.reverted",
+				at: new Date().toISOString(),
+				by: actorId === "owner" ? "human" : actorId,
+				spanId,
+			}]);
+			await writeSidecar(rootDir, rel, sidecar);
+		});
+	} catch (err) {
+		return NextResponse.json({ error: "INTERNAL_ERROR", message: String(err) }, { status: 500 });
+	}
+
+	if (notFound) {
+		return NextResponse.json({ error: "NOT_FOUND", message: "File not found" }, { status: 404 });
+	}
+
+	return NextResponse.json({ ok: true });
+}

package/.next/standalone/src/app/api/agent/register/[regId]/route.ts

@@ -0,0 +1,50 @@
+/**
+ * GET /api/agent/register/:regId
+ *
+ * Poll registration status. No auth required — regId acts as secret.
+ *
+ * Responses:
+ *   202 { status: "pending" }
+ *   200 { status: "approved", agentId, token }  — one-shot pickup, deletes token
+ *   410 { status: "consumed" | "denied" }
+ *   404 { status: "not_found" }
+ */
+import { NextResponse } from "next/server";
+import { getRegistration, consumeRegistration } from "@/lib/proof/pending";
+
+export const runtime = "nodejs";
+
+export async function GET(
+	_req: Request,
+	{ params }: { params: Promise<{ regId: string }> },
+): Promise<NextResponse> {
+	const { regId } = await params;
+	const reg = getRegistration(regId);
+
+	if (!reg) {
+		return NextResponse.json({ status: "not_found" }, { status: 404 });
+	}
+
+	switch (reg.status) {
+		case "pending":
+			return NextResponse.json({ status: "pending" }, { status: 202 });
+
+		case "approved": {
+			const token = consumeRegistration(regId);
+			if (!token) {
+				// Already consumed between the get and consume (race) — treat as consumed
+				return NextResponse.json({ status: "consumed" }, { status: 410 });
+			}
+			return NextResponse.json(
+				{ status: "approved", agentId: reg.agentId, token },
+				{ status: 200 },
+			);
+		}
+
+		case "consumed":
+			return NextResponse.json({ status: "consumed" }, { status: 410 });
+
+		case "denied":
+			return NextResponse.json({ status: "denied" }, { status: 410 });
+	}
+}

package/.next/standalone/src/app/api/agent/register/route.ts

@@ -0,0 +1,110 @@
+/**
+ * POST /api/agent/register
+ *
+ * Anonymous registration request. No auth required.
+ * The registrationId returned acts as the agent's secret for polling.
+ */
+import { NextResponse } from "next/server";
+import { createRegistration } from "@/lib/proof/pending";
+import type { AgentScope } from "@/lib/proof/registry";
+import { checkRegisterRateLimit } from "@/lib/proof/register-rate-limit";
+
+export const runtime = "nodejs";
+
+const AGENT_ID_RE = /^ai:[a-z][a-z0-9-]{0,30}$/i;
+const VALID_OPS = new Set(["read", "mutate"]);
+
+function validateScope(s: Record<string, unknown>): AgentScope | { error: string } {
+	if (!Array.isArray(s.paths) || s.paths.length === 0 || s.paths.length > 20) {
+		return { error: "scope.paths must be an array of 1\u201320 glob pattern strings" };
+	}
+	for (const p of s.paths) {
+		if (typeof p !== "string" || p.length < 1 || p.length > 200) {
+			return { error: "Each scope.paths entry must be a string of 1\u2013200 characters" };
+		}
+	}
+	if (!Array.isArray(s.ops) || s.ops.length === 0) {
+		return { error: "scope.ops must be a non-empty array" };
+	}
+	for (const op of s.ops) {
+		if (!VALID_OPS.has(op as string)) {
+			return { error: `scope.ops values must be "read" or "mutate"` };
+		}
+	}
+	return { paths: s.paths as string[], ops: s.ops as Array<"read" | "mutate"> };
+}
+
+/** Exported for reuse in approve route. */
+export { validateScope };
+
+export async function POST(req: Request): Promise<NextResponse> {
+	// Rate limit by remote IP (best-effort; fall back to global key)
+	const ip =
+		(req.headers.get("x-forwarded-for") ?? "").split(",")[0]?.trim() ||
+		"__global__";
+	if (!checkRegisterRateLimit(ip)) {
+		return NextResponse.json(
+			{ error: "RATE_LIMITED", message: "Too many registration attempts" },
+			{ status: 429 },
+		);
+	}
+
+	let body: { id?: unknown; displayName?: unknown; scope?: unknown };
+	try {
+		body = (await req.json()) as { id?: unknown; displayName?: unknown; scope?: unknown };
+	} catch {
+		return NextResponse.json({ error: "INVALID_PAYLOAD", message: "Invalid JSON" }, { status: 400 });
+	}
+
+	if (typeof body.id !== "string" || !AGENT_ID_RE.test(body.id)) {
+		return NextResponse.json(
+			{
+				error: "INVALID_PAYLOAD",
+				message: "id must match /^ai:[a-z][a-z0-9-]{0,30}$/i (e.g. ai:claude)",
+			},
+			{ status: 400 },
+		);
+	}
+
+	// displayName: required, 1–80 chars
+	if (
+		typeof body.displayName !== "string" ||
+		body.displayName.trim().length < 1 ||
+		body.displayName.trim().length > 80
+	) {
+		return NextResponse.json(
+			{ error: "INVALID_PAYLOAD", message: "displayName must be a string of 1\u201380 characters" },
+			{ status: 400 },
+		);
+	}
+	const displayName = body.displayName.trim();
+
+	// scope: required, must pass validation
+	if (
+		body.scope === undefined ||
+		body.scope === null ||
+		typeof body.scope !== "object" ||
+		Array.isArray(body.scope)
+	) {
+		return NextResponse.json(
+			{ error: "INVALID_PAYLOAD", message: "scope is required" },
+			{ status: 400 },
+		);
+	}
+	const scopeResult = validateScope(body.scope as Record<string, unknown>);
+	if ("error" in scopeResult) {
+		return NextResponse.json({ error: "INVALID_PAYLOAD", message: scopeResult.error }, { status: 400 });
+	}
+	const requestedScope: AgentScope = scopeResult;
+
+	const reg = createRegistration({ agentId: body.id, displayName, requestedScope });
+
+	return NextResponse.json(
+		{
+			registrationId: reg.registrationId,
+			pollUrl: `/api/agent/register/${reg.registrationId}`,
+			status: "pending",
+		},
+		{ status: 202 },
+	);
+}

package/.next/standalone/src/app/api/agent/settings/route.ts

@@ -0,0 +1,30 @@
+import { NextResponse } from "next/server";
+import { checkAuth, enforceScope } from "@/lib/proof/auth";
+import { getRootDir } from "@/lib/root-dir";
+import { readRegistry } from "@/lib/proof/registry";
+import { listPendingRegistrations } from "@/lib/proof/pending";
+
+export const runtime = "nodejs";
+
+export async function GET(req: Request): Promise<NextResponse> {
+	const auth = await checkAuth(req);
+	if (!auth.ok) {
+		return NextResponse.json({ error: "UNAUTHORIZED" }, { status: 401 });
+	}
+
+	const scopeCheck = enforceScope(auth.agent, { op: "read" });
+	if (!scopeCheck.ok) {
+		return NextResponse.json({ error: scopeCheck.code, message: scopeCheck.message }, { status: 403 });
+	}
+
+	const registry = await readRegistry();
+	const registeredAgents = registry?.agents.length ?? 0;
+	const pendingRegistrations = listPendingRegistrations().length;
+
+	return NextResponse.json({
+		rateLimit: Number(process.env.AGENT_RATE_LIMIT) || 60,
+		root: getRootDir(),
+		registeredAgents,
+		pendingRegistrations,
+	});
+}

package/.next/standalone/src/app/api/agent/settings/token/regenerate/route.ts

@@ -0,0 +1,20 @@
+/**
+ * Token regeneration — deprecated and removed.
+ *
+ * Auth is now managed via TOFU registration flow. Use the AI Panel or
+ * /api/agent/admin/* endpoints to manage agents.
+ */
+import { NextResponse } from "next/server";
+
+export const runtime = "nodejs";
+
+export async function POST(_req: Request): Promise<NextResponse> {
+	return NextResponse.json(
+		{
+			error: "GONE",
+			message:
+				"Token regeneration is deprecated. Manage agents via /api/agent/admin/* or the AI Panel.",
+		},
+		{ status: 410 },
+	);
+}

package/.next/standalone/src/app/api/agent/sidecar/[...path]/route.ts

@@ -0,0 +1,49 @@
+import { NextResponse } from "next/server";
+import { checkAuth, enforceScope } from "@/lib/proof/auth";
+import { readSidecar, emptySidecar } from "@/lib/proof/sidecar";
+import { getRootDir, safeRootPath } from "@/lib/root-dir";
+
+export const runtime = "nodejs";
+
+function isMarkdown(p: string): boolean {
+	return p.endsWith(".md") || p.endsWith(".markdown");
+}
+
+function mdPath(segments: string[]): string {
+	return segments.join("/");
+}
+
+export async function GET(
+	req: Request,
+	{ params }: { params: Promise<{ path: string[] }> },
+): Promise<NextResponse> {
+	const auth = await checkAuth(req);
+	if (!auth.ok) {
+		return NextResponse.json({ error: "UNAUTHORIZED" }, { status: 401 });
+	}
+
+	const { path: segments } = await params;
+	const rel = mdPath(segments);
+
+	if (rel.startsWith(".proof")) {
+		return NextResponse.json({ error: "INVALID_PATH", message: "Path must not be under .proof" }, { status: 400 });
+	}
+	if (!isMarkdown(rel)) {
+		return NextResponse.json({ error: "INVALID_PATH", message: "Path must be .md or .markdown" }, { status: 400 });
+	}
+
+	const absPath = safeRootPath(rel);
+	if (!absPath) {
+		return NextResponse.json({ error: "INVALID_PATH", message: "Path traversal rejected" }, { status: 400 });
+	}
+
+	const scopeCheck = enforceScope(auth.agent, { filePath: rel, op: "read" });
+	if (!scopeCheck.ok) {
+		return NextResponse.json({ error: scopeCheck.code, message: scopeCheck.message }, { status: 403 });
+	}
+
+	const rootDir = getRootDir();
+	const sidecar = (await readSidecar(rootDir, rel)) ?? emptySidecar(rel);
+
+	return NextResponse.json(sidecar);
+}

package/.next/standalone/src/app/api/agents/install/route.ts

@@ -0,0 +1,83 @@
+export const runtime = "nodejs";
+
+import { NextRequest, NextResponse } from "next/server";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+
+async function readVersion(): Promise<string> {
+	try {
+		const raw = await readFile(path.resolve(process.cwd(), "package.json"), "utf-8");
+		const p = JSON.parse(raw) as { version?: string };
+		return p.version ?? "0.0.0";
+	} catch {
+		return "0.0.0";
+	}
+}
+
+function deriveEndpoint(req: NextRequest): string {
+	const proto =
+		req.headers.get("x-forwarded-proto") ??
+		(req.url.startsWith("https") ? "https" : "http");
+	const host =
+		req.headers.get("x-forwarded-host") ??
+		req.headers.get("host") ??
+		new URL(req.url).host;
+	return `${proto}://${host}`;
+}
+
+export async function GET(req: NextRequest): Promise<NextResponse> {
+	const [bootstrapPrompt, version] = await Promise.all([
+		readFile(path.resolve(process.cwd(), "agents/bootstrap-prompt.md"), "utf-8").catch(() => ""),
+		readVersion(),
+	]);
+
+	const endpoint = deriveEndpoint(req);
+	const hostHeader = req.headers.get("host") ?? "";
+	const hostname = hostHeader.replace(/:[0-9]+$/, "").replace(/^\[(.*)\]$/, "$1").toLowerCase();
+	const loopback = hostname === "localhost" || hostname === "127.0.0.1" || hostname === "::1";
+	const extraHosts = (process.env.WIKI_OWNER_HOSTS ?? "")
+		.split(",").map((h) => h.trim().toLowerCase()).filter(Boolean);
+	const ownerHostTrusted = loopback || extraHosts.includes(hostname);
+
+	return NextResponse.json({
+		name: "wiki-viewer",
+		version,
+		endpoint,
+		humanInstructions:
+			"Open the wiki-viewer AI Panel (Bot icon in header). Register the agent, then approve it in the Pending Registrations list. The agent receives a one-shot token.",
+		ownerBootstrap: {
+			hostnameSeen: hostname,
+			ownerHostTrusted,
+			hint: ownerHostTrusted
+				? "This host is trusted for owner cookie issuance. Open the AI Panel in a browser and approve pending registrations."
+				: `This host (${hostname}) is not in the owner-trust allowlist, so the AI Panel cannot bootstrap an owner cookie. Restart the server with WIKI_OWNER_HOSTS=${hostname} or access via localhost.`,
+		},
+		bootstrapPrompt,
+		skillTarball: "/api/agents/skill.tar.gz",
+		skillRaw: "/api/agents/skill",
+		skillCli: "npx skills add anh-chu/wiki-viewer/agents/wiki-viewer-skill",
+		routes: [
+			{ method: "POST", path: "/api/agent/register", auth: "none", purpose: "Register an agent" },
+			{ method: "GET", path: "/api/agent/register/<regId>", auth: "none", purpose: "Poll registration status" },
+			{ method: "GET", path: "/api/agent/files/<path>.md", auth: "bearer+agent-id", purpose: "Read snapshot" },
+			{ method: "POST", path: "/api/agent/files/<path>.md", auth: "bearer+agent-id", purpose: "Apply ops" },
+			{ method: "GET", path: "/api/agent/events/<path>.md", auth: "bearer+agent-id", purpose: "Poll events" },
+			{ method: "POST", path: "/api/agent/events/<path>.md", auth: "bearer+agent-id", purpose: "Ack events" },
+		],
+		ops: [
+			"block.replace",
+			"block.insertAfter",
+			"block.insertBefore",
+			"block.delete",
+			"block.append",
+			"block.prepend",
+			"comment.add",
+			"comment.reply",
+			"comment.resolve",
+			"comment.reopen",
+			"suggestion.add",
+			"suggestion.accept",
+			"suggestion.reject",
+		],
+	});
+}

package/.next/standalone/src/app/api/agents/skill/route.ts

@@ -0,0 +1,20 @@
+export const runtime = "nodejs";
+
+import { NextRequest, NextResponse } from "next/server";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+
+export async function GET(_req: NextRequest): Promise<NextResponse> {
+	const skillPath = path.resolve(
+		process.cwd(),
+		"agents/wiki-viewer-skill/SKILL.md"
+	);
+	const content = await readFile(skillPath, "utf-8");
+	return new NextResponse(content, {
+		status: 200,
+		headers: {
+			"Content-Type": "text/markdown; charset=utf-8",
+			"Cache-Control": "no-store",
+		},
+	});
+}

package/.next/standalone/src/app/api/agents/skill.tar.gz/route.ts

@@ -0,0 +1,87 @@
+export const runtime = "nodejs";
+
+import { NextRequest, NextResponse } from "next/server";
+import { readdir, readFile } from "node:fs/promises";
+import { gzipSync } from "node:zlib";
+import path from "node:path";
+
+function encodeOctal(n: number, length: number): string {
+	return n.toString(8).padStart(length - 1, "0") + "\0";
+}
+
+function writePaddedString(buf: Buffer, offset: number, str: string, len: number): void {
+	const bytes = Buffer.from(str, "utf-8").subarray(0, len);
+	bytes.copy(buf, offset);
+}
+
+function tarHeader(name: string, size: number, mtime: number): Buffer {
+	const header = Buffer.alloc(512, 0);
+
+	writePaddedString(header, 0, name, 100);          // name
+	writePaddedString(header, 100, "0000644\0", 8);   // mode
+	writePaddedString(header, 108, "0000000\0", 8);   // uid
+	writePaddedString(header, 116, "0000000\0", 8);   // gid
+	writePaddedString(header, 124, encodeOctal(size, 12), 12); // size
+	writePaddedString(header, 136, encodeOctal(mtime, 12), 12); // mtime
+	header[156] = 0x30;                                // typeflag '0' = regular
+	// linkname: 157-256, all zero
+	writePaddedString(header, 257, "ustar\0", 6);     // magic
+	writePaddedString(header, 263, "00", 2);           // version
+	// uname, gname, devmajor, devminor, prefix: zeros
+
+	// checksum
+	let sum = 0;
+	for (let i = 0; i < 512; i++) {
+		// treat checksum field (148..155) as spaces while computing
+		sum += i >= 148 && i < 156 ? 32 : header[i];
+	}
+	writePaddedString(header, 148, encodeOctal(sum, 7) + " ", 8);
+
+	return header;
+}
+
+function buildTar(entries: Array<{ name: string; content: Buffer; mtime: number }>): Buffer {
+	const parts: Buffer[] = [];
+
+	for (const entry of entries) {
+		const hdr = tarHeader(entry.name, entry.content.length, entry.mtime);
+		parts.push(hdr);
+		parts.push(entry.content);
+		// pad content to 512-byte boundary
+		const rem = entry.content.length % 512;
+		if (rem !== 0) {
+			parts.push(Buffer.alloc(512 - rem, 0));
+		}
+	}
+
+	// two zero blocks = end-of-archive
+	parts.push(Buffer.alloc(1024, 0));
+
+	return Buffer.concat(parts);
+}
+
+export async function GET(_req: NextRequest): Promise<NextResponse> {
+	const skillDir = path.resolve(process.cwd(), "agents/wiki-viewer-skill");
+	const files = await readdir(skillDir, { withFileTypes: true });
+	const mtime = Math.floor(Date.now() / 1000);
+
+	const entries: Array<{ name: string; content: Buffer; mtime: number }> = [];
+
+	for (const f of files) {
+		if (!f.isFile()) continue;
+		const content = await readFile(path.join(skillDir, f.name));
+		entries.push({ name: `wiki-viewer-skill/${f.name}`, content, mtime });
+	}
+
+	const tar = buildTar(entries);
+	const gz = gzipSync(tar);
+
+	return new NextResponse(gz, {
+		status: 200,
+		headers: {
+			"Content-Type": "application/gzip",
+			"Content-Disposition": `attachment; filename="wiki-viewer-skill.tar.gz"`,
+			"Cache-Control": "no-store",
+		},
+	});
+}

package/.next/standalone/src/app/api/auth/[...all]/route.ts

@@ -0,0 +1,7 @@
+import { auth } from "@/lib/auth/server";
+import { toNextJsHandler } from "better-auth/next-js";
+
+export const runtime = "nodejs";
+
+const handler = toNextJsHandler(auth);
+export const { GET, POST, PATCH, PUT, DELETE } = handler;

package/.next/standalone/src/app/api/owner/init/route.ts

@@ -0,0 +1,14 @@
+/**
+ * GET /api/owner/init
+ *
+ * Legacy bootstrap endpoint. Now redirects to /signin (Better Auth).
+ * Kept for back-compat — any agent or UI calling this will be redirected.
+ */
+import { NextResponse } from "next/server";
+
+export const runtime = "nodejs";
+
+export function GET(req: Request): NextResponse {
+	const url = new URL("/signin", req.url);
+	return NextResponse.redirect(url, { status: 308 });
+}

package/.next/standalone/src/app/api/system/auth-settings/route.ts

@@ -0,0 +1,85 @@
+/**
+ * GET  /api/system/auth-settings — read the effective signup allowlist.
+ * PUT  /api/system/auth-settings — update the allowlist in config.json.
+ *
+ * Single-tenant local app: any authenticated user may read/edit. The effective
+ * list resolves config first, env as fallback (see getAllowlist). `source`
+ * tells the UI where the active values came from so it can warn that editing
+ * here overrides the env vars.
+ */
+import { NextResponse } from "next/server";
+import { checkOrigin } from "@/lib/auth/csrf";
+import { requireUser } from "@/lib/auth/server";
+import { getAllowlist } from "@/lib/auth/allowlist";
+import { readConfig, writeConfig } from "@/lib/config";
+
+export const runtime = "nodejs";
+
+export async function GET(request: Request) {
+	const auth = await requireUser(request);
+	if (!auth.ok)
+		return NextResponse.json({ error: "UNAUTHORIZED" }, { status: 401 });
+
+	const config = await readConfig();
+	const effective = await getAllowlist();
+	const usingConfig =
+		(config.allowedEmails?.length ?? 0) > 0 ||
+		(config.allowedDomains?.length ?? 0) > 0;
+
+	return NextResponse.json({
+		allowedEmails: effective.emails,
+		allowedDomains: effective.domains,
+		source: usingConfig ? "config" : "env",
+		envFallbackActive: !usingConfig,
+	});
+}
+
+function normalizeList(value: unknown): string[] {
+	if (!Array.isArray(value)) return [];
+	return value
+		.filter((v): v is string => typeof v === "string")
+		.map((s) => s.trim().toLowerCase())
+		.filter(Boolean);
+}
+
+export async function PUT(request: Request) {
+	const csrf = checkOrigin(request);
+	if (csrf) return csrf;
+	const auth = await requireUser(request);
+	if (!auth.ok)
+		return NextResponse.json({ error: "UNAUTHORIZED" }, { status: 401 });
+
+	let body: { allowedEmails?: unknown; allowedDomains?: unknown };
+	try {
+		body = await request.json();
+	} catch {
+		return NextResponse.json({ error: "Invalid JSON" }, { status: 400 });
+	}
+
+	const allowedEmails = normalizeList(body.allowedEmails);
+	const allowedDomains = normalizeList(body.allowedDomains);
+
+	// Reject obviously malformed email entries (must contain a single @ with text
+	// on both sides). Domains are looser but must not contain @ or spaces.
+	const badEmail = allowedEmails.find((e) => !/^[^@\s]+@[^@\s]+$/.test(e));
+	if (badEmail)
+		return NextResponse.json(
+			{ error: `Invalid email entry: ${badEmail}` },
+			{ status: 400 },
+		);
+	const badDomain = allowedDomains.find((d) => /[@\s]/.test(d));
+	if (badDomain)
+		return NextResponse.json(
+			{ error: `Invalid domain entry: ${badDomain}` },
+			{ status: 400 },
+		);
+
+	await writeConfig({ allowedEmails, allowedDomains });
+
+	return NextResponse.json({
+		ok: true,
+		allowedEmails,
+		allowedDomains,
+		source: allowedEmails.length || allowedDomains.length ? "config" : "env",
+	});
+}