wiki-viewer 1.14.1 → 2.0.0

package/.next/standalone/src/lib/search/search-db.ts

@@ -1,57 +0,0 @@
-/**
- * Search database lifecycle.
- *
- * Separate from auth.db: FTS5 shadow tables would pollute the auth schema and
- * better-auth's migrator could misidentify them. search.db is rebuildable from
- * the filesystem at any time -- deleting it only triggers a rescan on next access.
- *
- * Mirrors src/lib/proof/audit.ts structure.
- */
-import Database from "better-sqlite3";
-import path from "node:path";
-import os from "node:os";
-import { mkdirSync } from "node:fs";
-
-function dataDir(): string {
-	return path.join(process.env.HOME ?? os.homedir(), ".wiki-viewer");
-}
-
-let _db: InstanceType<typeof Database> | null = null;
-
-export function getSearchDb(): InstanceType<typeof Database> {
-	if (_db) return _db;
-	const dir = dataDir();
-	mkdirSync(dir, { recursive: true });
-	_db = new Database(path.join(dir, "search.db"));
-	_db.pragma("journal_mode = WAL");
-	_db.pragma("synchronous = NORMAL");
-	_db.pragma("temp_store = MEMORY");
-	_db.pragma("mmap_size = 134217728"); // 128 MiB
-	_db.exec(`
-		CREATE VIRTUAL TABLE IF NOT EXISTS docs USING fts5(
-			ws         UNINDEXED,
-			path       UNINDEXED,
-			name,
-			frontmatter,
-			body,
-			tokenize = 'porter unicode61 remove_diacritics 2'
-		);
-		CREATE TABLE IF NOT EXISTS docs_meta (
-			ws         TEXT NOT NULL,
-			path       TEXT NOT NULL,
-			size       INTEGER NOT NULL,
-			mtime_ns   INTEGER NOT NULL,
-			sha        TEXT NOT NULL,
-			indexed_at TEXT NOT NULL,
-			PRIMARY KEY (ws, path)
-		) WITHOUT ROWID;
-		CREATE INDEX IF NOT EXISTS docs_meta_ws_idx ON docs_meta(ws);
-	`);
-	return _db;
-}
-
-/** Reset cached DB handle. Used by tests to pick up a new HOME. */
-export function _resetSearchDb(): void {
-	try { _db?.close(); } catch { /* ignore */ }
-	_db = null;
-}

package/.next/standalone/src/lib/search/watcher-pool.ts

@@ -1,79 +0,0 @@
-/**
- * Shared chokidar watcher pool.
- *
- * Ensures exactly ONE FSWatcher per workspace regardless of how many SSE
- * connections or indexer subscriptions are active. When the last subscriber
- * unsubscribes, the watcher is closed.
- *
- * The watch route and the indexer both subscribe through this pool.
- */
-import { watch, type FSWatcher } from "chokidar";
-import path from "node:path";
-
-export type WatchEvent = "add" | "unlink" | "addDir" | "unlinkDir" | "change";
-export type WatchListener = (ev: WatchEvent, relPath: string) => void;
-
-interface PoolEntry {
-	watcher: FSWatcher;
-	listeners: Set<WatchListener>;
-	rootDir: string;
-}
-
-const pool = new Map<string, PoolEntry>();
-
-/**
- * Subscribe to file-system events for a workspace.
- * Returns an unsubscribe function. Call it when the subscriber is done.
- * The pool creates a watcher on first subscribe and closes it on last unsubscribe.
- */
-export function subscribe(
-	wsId: string,
-	rootDir: string,
-	fn: WatchListener,
-): () => void {
-	let entry = pool.get(wsId);
-	if (!entry) {
-		const watcher = watch(rootDir, {
-			ignoreInitial: true,
-			ignored: /(node_modules|\.git|\.next|\.proof)/,
-			persistent: true,
-			awaitWriteFinish: { stabilityThreshold: 150, pollInterval: 50 },
-		});
-		entry = { watcher, listeners: new Set(), rootDir };
-		pool.set(wsId, entry);
-
-		const emit = (ev: WatchEvent, abs: string) => {
-			const e = pool.get(wsId);
-			if (!e) return;
-			const rel = path.relative(e.rootDir, abs);
-			e.listeners.forEach((l) => {
-				try { l(ev, rel); } catch { /* listener errors must not crash the pool */ }
-			});
-		};
-
-		watcher.on("add",       (p: string) => emit("add",       p));
-		watcher.on("unlink",    (p: string) => emit("unlink",    p));
-		watcher.on("change",    (p: string) => emit("change",    p));
-		watcher.on("addDir",    (p: string) => { const rel = path.relative(rootDir, p); if (rel) emit("addDir",    p); });
-		watcher.on("unlinkDir", (p: string) => { const rel = path.relative(rootDir, p); if (rel) emit("unlinkDir", p); });
-	}
-	entry.listeners.add(fn);
-
-	return () => {
-		const e = pool.get(wsId);
-		if (!e) return;
-		e.listeners.delete(fn);
-		if (e.listeners.size === 0) {
-			e.watcher.close().catch(() => { /* ignore */ });
-			pool.delete(wsId);
-		}
-	};
-}
-
-/** Reset entire pool. Used by tests. */
-export function _resetWatcherPool(): void {
-	for (const e of pool.values()) {
-		e.watcher.close().catch(() => { /* ignore */ });
-	}
-	pool.clear();
-}

package/.next/standalone/src/lib/shared-docs/db.ts

@@ -1,177 +0,0 @@
-/**
- * Shared docs DB — stores share links for public read-only access.
- *
- * Each share link references a (workspaceId, filePath) pair. The link
- * can optionally be password-protected and/or time-limited.
- *
- * DB: ~/.wiki-viewer/shared.db (WAL mode, separate from auth.db and search.db).
- */
-import Database from "better-sqlite3";
-import path from "node:path";
-import os from "node:os";
-import { mkdirSync } from "node:fs";
-import { randomBytes, scryptSync, timingSafeEqual } from "node:crypto";
-
-export interface SharedDoc {
-	id: string;
-	workspaceId: string;
-	filePath: string;
-	token: string;
-	passwordHash: string | null;
-	expiresAt: string | null;
-	createdBy: string;
-	createdAt: string;
-	viewCount: number;
-	isRevoked: boolean;
-}
-
-export interface CreateSharedDocInput {
-	workspaceId: string;
-	filePath: string;
-	password?: string;
-	expiresAt?: string; // ISO date string, e.g. "2026-07-10T00:00:00Z"
-	createdBy: string;
-}
-
-function dataDir(): string {
-	return path.join(process.env.HOME ?? os.homedir(), ".wiki-viewer");
-}
-
-let _db: InstanceType<typeof Database> | null = null;
-
-function getDb(): InstanceType<typeof Database> {
-	if (_db) return _db;
-	const dir = dataDir();
-	mkdirSync(dir, { recursive: true });
-	_db = new Database(path.join(dir, "shared.db"));
-	_db.pragma("journal_mode = WAL");
-	_db.pragma("synchronous = NORMAL");
-	_db.exec(`
-		CREATE TABLE IF NOT EXISTS shared_docs (
-			id            TEXT PRIMARY KEY,
-			workspace_id  TEXT NOT NULL,
-			file_path     TEXT NOT NULL,
-			token         TEXT NOT NULL UNIQUE,
-			password_hash TEXT,
-			expires_at    TEXT,
-			created_by    TEXT NOT NULL,
-			created_at    TEXT NOT NULL,
-			view_count    INTEGER NOT NULL DEFAULT 0,
-			is_revoked    INTEGER NOT NULL DEFAULT 0
-		);
-		CREATE INDEX IF NOT EXISTS shared_docs_token_idx ON shared_docs(token);
-		CREATE INDEX IF NOT EXISTS shared_docs_file_idx ON shared_docs(workspace_id, file_path);
-	`);
-	return _db;
-}
-
-export function createShare(input: CreateSharedDocInput): SharedDoc {
-	const db = getDb();
-	const id = "shr_" + randomBytes(8).toString("base64url");
-	const token = randomBytes(16).toString("base64url");
-	const passwordHash = input.password ? hashPassword(input.password) : null;
-
-	const shared: SharedDoc = {
-		id,
-		workspaceId: input.workspaceId,
-		filePath: input.filePath,
-		token,
-		passwordHash,
-		expiresAt: input.expiresAt ?? null,
-		createdBy: input.createdBy,
-		createdAt: new Date().toISOString(),
-		viewCount: 0,
-		isRevoked: false,
-	};
-
-	const dbValues = {
-		...shared,
-		isRevoked: shared.isRevoked ? 1 : 0,
-	};
-
-	db.prepare(
-		`INSERT INTO shared_docs
-		 (id, workspace_id, file_path, token, password_hash, expires_at, created_by, created_at, view_count, is_revoked)
-		 VALUES (@id, @workspaceId, @filePath, @token, @passwordHash, @expiresAt, @createdBy, @createdAt, @viewCount, @isRevoked)`,
-	).run(dbValues);
-	return shared;
-}
-
-type DbRow = Record<string, unknown>;
-
-function rowToShare(row: DbRow): SharedDoc {
-	return {
-		id: row.id as string,
-		workspaceId: row.workspace_id as string,
-		filePath: row.file_path as string,
-		token: row.token as string,
-		passwordHash: (row.password_hash as string | null) ?? null,
-		expiresAt: (row.expires_at as string | null) ?? null,
-		createdBy: row.created_by as string,
-		createdAt: row.created_at as string,
-		viewCount: (row.view_count as number) ?? 0,
-		isRevoked: (row.is_revoked as number) === 1,
-	};
-}
-
-export function getShareByToken(token: string): SharedDoc | null {
-	const db = getDb();
-	const row = db.prepare("SELECT * FROM shared_docs WHERE token = ?").get(token) as
-		| DbRow
-		| undefined;
-	return row ? rowToShare(row) : null;
-}
-
-export function listSharesForFile(
-	workspaceId: string,
-	filePath: string,
-): SharedDoc[] {
-	const db = getDb();
-	const rows = db
-		.prepare(
-			"SELECT * FROM shared_docs WHERE workspace_id = ? AND file_path = ? AND is_revoked = 0 ORDER BY created_at DESC",
-		)
-		.all(workspaceId, filePath) as DbRow[];
-	return rows.map(rowToShare);
-}
-
-export function revokeShare(id: string): void {
-	const db = getDb();
-	db.prepare("UPDATE shared_docs SET is_revoked = 1 WHERE id = ?").run(id);
-}
-
-export function incrementViewCount(token: string): void {
-	const db = getDb();
-	db.prepare(
-		"UPDATE shared_docs SET view_count = view_count + 1 WHERE token = ?",
-	).run(token);
-}
-
-export function isExpired(share: SharedDoc): boolean {
-	if (!share.expiresAt) return false;
-	return new Date(share.expiresAt) < new Date();
-}
-
-function hashPassword(password: string): string {
-	const salt = randomBytes(16).toString("hex");
-	const hash = scryptSync(password, salt, 64).toString("hex");
-	return `${salt}:${hash}`;
-}
-
-export function verifyPassword(password: string, stored: string): boolean {
-	const [salt, hash] = stored.split(":");
-	const expected = scryptSync(password, salt, 64);
-	const actual = Buffer.from(hash, "hex");
-	if (expected.length !== actual.length) return false;
-	return timingSafeEqual(expected, actual);
-}
-
-/** Reset cached DB handle (used by tests). */
-export function _resetSharedDb(): void {
-	try {
-		_db?.close();
-	} catch {
-		/* ignore */
-	}
-	_db = null;
-}

package/.next/standalone/src/lib/toast.ts

@@ -1,9 +0,0 @@
-import { type ExternalToast, toast } from "sonner";
-
-export function showSuccess(message: string, options?: ExternalToast) {
-	toast.success(message, options);
-}
-
-export function showError(message: string, options?: ExternalToast) {
-	toast.error(message, options);
-}

package/.next/standalone/src/lib/utils.ts

@@ -1,6 +0,0 @@
-import { type ClassValue, clsx } from "clsx";
-import { twMerge } from "tailwind-merge";
-
-export function cn(...inputs: ClassValue[]) {
-	return twMerge(clsx(inputs));
-}

package/.next/standalone/src/lib/wiki-helpers.ts

@@ -1,36 +0,0 @@
-import { stat } from "node:fs/promises";
-import path from "node:path";
-
-/**
- * Returns true if the directory has a package.json — treated as a runnable node app.
- * Checked before isAppFolder so package.json wins over index.html.
- */
-export async function isNodeApp(
-	wikiDir: string,
-	relPath: string,
-): Promise<boolean> {
-	try {
-		const pkgJson = path.join(wikiDir, relPath, "package.json");
-		const info = await stat(pkgJson);
-		return info.isFile();
-	} catch {
-		return false;
-	}
-}
-
-/**
- * Returns true if `<wikiDir>/<relPath>/index.html` exists and is a regular file.
- * Used server-side to classify a directory as a self-contained static app folder.
- */
-export async function isAppFolder(
-	wikiDir: string,
-	relPath: string,
-): Promise<boolean> {
-	try {
-		const indexHtml = path.join(wikiDir, relPath, "index.html");
-		const info = await stat(indexHtml);
-		return info.isFile();
-	} catch {
-		return false;
-	}
-}

package/.next/standalone/src/lib/workspace-client.ts

@@ -1,82 +0,0 @@
-/**
- * workspace-client.ts — browser-safe ws injection helpers.
- * No React, no server imports. Safe to use in any "use client" file.
- */
-
-/**
- * URL prefixes that are workspace-scoped and need ?ws= injected.
- * Rules:
- *   include:  /api/wiki, /api/assets/, /api/agent/ (except sub-paths below),
- *             /api/upload/, /api/system/reveal
- *   exclude:  /api/agent/admin, /api/agent/register, /api/agents
- *             (those are global registrations, not file-workspace calls)
- */
-const WS_SCOPED_PREFIXES = [
-	"/api/wiki",
-	"/api/assets/",
-	"/api/upload/",
-	"/api/system/reveal",
-];
-
-const WS_AGENT_PREFIX = "/api/agent/";
-
-const WS_AGENT_EXCLUDED_PREFIXES = [
-	"/api/agent/admin",
-	"/api/agent/register",
-	"/api/agents",
-];
-
-export function getActiveWorkspaceId(): string | null {
-	if (typeof window === "undefined") return null;
-	return new URLSearchParams(window.location.search).get("ws");
-}
-
-/** Returns true if this URL is workspace-scoped and needs ?ws= appended. */
-function needsWs(pathname: string): boolean {
-	// Excluded patterns first (match on prefix + segment boundary so
-	// "/api/agent/adminfoo" is NOT treated as "/api/agent/admin").
-	for (const ex of WS_AGENT_EXCLUDED_PREFIXES) {
-		if (pathname === ex || pathname.startsWith(ex + "/")) return false;
-	}
-	if (pathname.startsWith(WS_AGENT_PREFIX)) return true;
-	for (const prefix of WS_SCOPED_PREFIXES) {
-		if (pathname.startsWith(prefix)) return true;
-	}
-	return false;
-}
-
-/**
- * Append ?ws=<activeId> to a workspace-scoped URL if:
- *   - the URL needs ws injection (needsWs)
- *   - an active workspace id exists in the current URL
- *   - the URL doesn't already carry a ws= param
- *
- * Handles both plain paths (/api/wiki) and paths with existing query strings
- * (/api/wiki/content?path=foo → /api/wiki/content?path=foo&ws=<id>).
- */
-export function withWs(url: string): string {
-	const wsId = getActiveWorkspaceId();
-	if (!wsId) return url;
-
-	// Split on first '?' to isolate the pathname
-	const qIdx = url.indexOf("?");
-	const pathname = qIdx === -1 ? url : url.slice(0, qIdx);
-	const search = qIdx === -1 ? "" : url.slice(qIdx + 1);
-
-	if (!needsWs(pathname)) return url;
-
-	// Don't double-inject
-	const params = new URLSearchParams(search);
-	if (params.has("ws")) return url;
-
-	params.set("ws", wsId);
-	return `${pathname}?${params.toString()}`;
-}
-
-/**
- * drop-in fetch replacement that injects ?ws=<activeId> on workspace-scoped
- * URLs. Non-scoped URLs pass through unchanged.
- */
-export function wsFetch(input: string, init?: RequestInit): Promise<Response> {
-	return fetch(withWs(input), init);
-}

package/.next/standalone/src/lib/workspace-context.ts

@@ -1,173 +0,0 @@
-/**
- * Request-scoped workspace resolution for browser/session routes.
- *
- * Determines which workspace a request targets and enforces access control.
- * Phase B routes call this instead of getRootDir().
- */
-
-import path from "node:path";
-import { requireUser } from "@/lib/auth/server";
-import { isAdmin } from "@/lib/auth/admin";
-import { getRootDir } from "@/lib/root-dir";
-import {
-	getWorkspace,
-	listWorkspaces,
-	userCanAccess,
-	migrateConfigToWorkspaces,
-	type Workspace,
-} from "@/lib/workspaces";
-
-/**
- * Synthetic fallback workspace built from the legacy process-global rootDir
- * (root-dir.ts). Used only when the registry has no workspaces — keeps the
- * ROOT_DIR / CLI / test paths working until Phase E removes the global.
- * Returns null when no global root is set either.
- */
-function fallbackWorkspace(): Workspace | null {
-	const root = getRootDir();
-	if (!root) return null;
-	return {
-		id: "ws_default",
-		name: path.basename(root) || "workspace",
-		rootDir: root,
-		createdAt: new Date(0).toISOString(),
-	};
-}
-
-/**
- * Resolve the target workspace from the request alone (no auth/access check).
- * Selection: ?ws= query → x-workspace header → most-recent lastOpenedAt →
- * synthetic fallback from the global rootDir. Returns null if nothing resolves.
- */
-async function pickWorkspace(req: Request): Promise<Workspace | null> {
-	await migrateConfigToWorkspaces();
-	const url = new URL(req.url);
-	const wsId = url.searchParams.get("ws") ?? req.headers.get("x-workspace") ?? null;
-	if (wsId) {
-		return (await getWorkspace(wsId)) ?? null;
-	}
-	const all = await listWorkspaces();
-	if (all.length === 0) return fallbackWorkspace();
-	return all
-		.slice()
-		.sort((a, b) => {
-			const ta = a.lastOpenedAt ? new Date(a.lastOpenedAt).getTime() : 0;
-			const tb = b.lastOpenedAt ? new Date(b.lastOpenedAt).getTime() : 0;
-			if (tb !== ta) return tb - ta;
-			return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
-		})[0];
-}
-
-export interface WorkspaceContext {
-	ok: true;
-	ws: Workspace;
-	rootDir: string;
-	userId: string;
-	isAdmin: boolean;
-}
-
-export interface WorkspaceError {
-	ok: false;
-	status: number;
-	code: string;
-}
-
-/**
- * Resolves the workspace for a browser/session request.
- *
- * Selection order:
- *   1. `?ws=<id>` query param (preferred).
- *   2. `x-workspace` header.
- *   3. Fall back to the workspace with the most recent lastOpenedAt.
- *      If exactly one workspace exists, use it.
- *      If zero workspaces -> 400 WORKSPACE_REQUIRED.
- *
- * Pass intent="write" on any route that mutates the filesystem.
- * Returns 403 WORKSPACE_READ_ONLY for write intent on a readOnly workspace.
- */
-export async function resolveWorkspaceForUser(
-	req: Request,
-	intent: "read" | "write" = "read",
-): Promise<WorkspaceContext | WorkspaceError> {
-	// --no-auth bypass
-	if (process.env.WIKI_NO_AUTH === "1") {
-		const ws = await pickWorkspace(req);
-		if (!ws) {
-			return {
-				ok: false,
-				status: 400,
-				code: "WORKSPACE_REQUIRED",
-			};
-		}
-		if (intent === "write" && ws.readOnly) {
-			return { ok: false, status: 403, code: "WORKSPACE_READ_ONLY" };
-		}
-		return { ok: true, ws, rootDir: ws.rootDir, userId: "local", isAdmin: true };
-	}
-
-	// Authenticate
-	const auth = await requireUser(req);
-	if (!auth.ok) return { ok: false, status: 401, code: "UNAUTHORIZED" };
-
-	const admin = await isAdmin(auth.user.id, auth.user.email);
-	const url = new URL(req.url);
-	const explicitWsId =
-		url.searchParams.get("ws") ?? req.headers.get("x-workspace") ?? null;
-
-	const ws = await pickWorkspace(req);
-	if (!ws) {
-		// No workspace and no global root configured yet.
-		return {
-			ok: false,
-			status: explicitWsId ? 404 : 400,
-			code: explicitWsId ? "WORKSPACE_NOT_FOUND" : "WORKSPACE_REQUIRED",
-		};
-	}
-
-	if (!userCanAccess(ws, auth.user.id, admin)) {
-		return { ok: false, status: 403, code: "WORKSPACE_FORBIDDEN" };
-	}
-
-	if (intent === "write" && ws.readOnly) {
-		return { ok: false, status: 403, code: "WORKSPACE_READ_ONLY" };
-	}
-
-	return { ok: true, ws, rootDir: ws.rootDir, userId: auth.user.id, isAdmin: admin };
-}
-
-export interface AgentWorkspaceContext {
-	ok: true;
-	ws: Workspace;
-	rootDir: string;
-}
-
-/**
- * Resolve the target workspace for an AUTHENTICATED agent request.
- *
- * Phase B: resolution only (no per-agent workspace grant check - that is added
- * in Phase C, which will verify the agent's scope.workspaceId === ws.id).
- * Selection mirrors the session resolver: ?ws / x-workspace / default / global.
- *
- * Pass intent="write" on any route that mutates the filesystem.
- * Returns 403 WORKSPACE_READ_ONLY for write intent on a readOnly workspace.
- */
-export async function resolveWorkspaceForAgent(
-	req: Request,
-	intent: "read" | "write" = "read",
-): Promise<AgentWorkspaceContext | WorkspaceError> {
-	const ws = await pickWorkspace(req);
-	if (!ws) {
-		const url = new URL(req.url);
-		const explicit =
-			url.searchParams.get("ws") ?? req.headers.get("x-workspace") ?? null;
-		return {
-			ok: false,
-			status: explicit ? 404 : 400,
-			code: explicit ? "WORKSPACE_NOT_FOUND" : "WORKSPACE_REQUIRED",
-		};
-	}
-	if (intent === "write" && ws.readOnly) {
-		return { ok: false, status: 403, code: "WORKSPACE_READ_ONLY" };
-	}
-	return { ok: true, ws, rootDir: ws.rootDir };
-}