@youweichen/pi-harness 0.0.0-stage → 1.1.0

package/dist/server/uploads.js

@@ -0,0 +1,112 @@
+/**
+ * uploads — 文件对话上传的存储与清理。
+ *
+ * 上传文件落在 <dataDir>/uploads/<clientId>/<ts>-<name>（模型以绝对路径
+ * reference 读取）。此前这里硬编码 ~/.pi-web，不吃 PI_WEB_DATA_DIR —— 已改为
+ * 与 index.ts 相同的解析逻辑。清理策略：默认保留 14 天，启动时扫一次 +
+ * 每 6 小时扫一次；PI_WEB_UPLOAD_RETENTION_DAYS 覆盖保留天数，0 = 关闭清理。
+ * 全程 best-effort：清理失败绝不影响服务。
+ */
+import { readdir, rm, stat } from "node:fs/promises";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, join, relative, resolve } from "node:path";
+/** Same resolution as index.ts DATA_DIR — kept in sync by env contract. */
+export function resolveDataDir() {
+    return resolve(process.env.PI_WEB_DATA_DIR ?? join(homedir(), ".pi-web"));
+}
+export function uploadsRoot(dataDir = resolveDataDir()) {
+    return join(dataDir, "uploads");
+}
+/** Retention in days; 0 disables sweeping. */
+export function uploadRetentionDays() {
+    const v = Number(process.env.PI_WEB_UPLOAD_RETENTION_DAYS);
+    return Number.isFinite(v) && v >= 0 ? v : 14;
+}
+/** Persist an uploaded buffer; returns the absolute path + sanitized display name. */
+export function saveUpload(clientId, name, buf, dataDir = resolveDataDir()) {
+    const root = uploadsRoot(dataDir);
+    const dir = join(root, clientId);
+    // Belt and braces: the id is validated at the socket, but never write outside uploads/.
+    if (relative(root, dir).startsWith("..") || isAbsolute(relative(root, dir)) || relative(root, dir) === "") {
+        throw new Error("invalid upload location");
+    }
+    mkdirSync(dir, { recursive: true });
+    const displayName = name
+        .replace(/[\\/:*?"<>|\x00-\x1f]/g, "_")
+        .slice(0, 80) || "file";
+    const abs = join(dir, `${Date.now()}-${displayName}`);
+    writeFileSync(abs, buf);
+    return { abs, displayName };
+}
+/**
+ * Delete uploaded files older than the retention window, then prune client
+ * dirs left empty. Returns { files, bytes, dirs } removed (best-effort:
+ * individual failures are skipped).
+ */
+export async function cleanupUploads(dataDir = resolveDataDir(), retentionDays = uploadRetentionDays()) {
+    const out = { files: 0, bytes: 0, dirs: 0 };
+    if (retentionDays <= 0)
+        return out;
+    const root = uploadsRoot(dataDir);
+    if (!existsSync(root))
+        return out;
+    const cutoff = Date.now() - retentionDays * 24 * 60 * 60 * 1000;
+    let clients;
+    try {
+        clients = await readdir(root);
+    }
+    catch {
+        return out;
+    }
+    for (const clientId of clients) {
+        const dir = join(root, clientId);
+        let entries;
+        try {
+            entries = await readdir(dir);
+        }
+        catch {
+            continue; // not a dir / vanished
+        }
+        for (const entry of entries) {
+            const abs = join(dir, entry);
+            try {
+                const st = await stat(abs);
+                if (st.mtimeMs >= cutoff)
+                    continue;
+                await rm(abs, { recursive: true });
+                out.files++;
+                out.bytes += st.size;
+            }
+            catch {
+                // skip on any per-file failure
+            }
+        }
+        try {
+            if ((await readdir(dir)).length === 0) {
+                await rmdirSafe(dir);
+                out.dirs++;
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    return out;
+}
+async function rmdirSafe(dir) {
+    try {
+        await rm(dir, { recursive: false });
+    }
+    catch {
+        // non-empty or race — fine
+    }
+}
+/** Startup sweep + periodic re-sweep. Timer is unref'd so it never blocks exit. */
+export function scheduleUploadCleanup(intervalMs = 6 * 60 * 60 * 1000) {
+    void cleanupUploads().catch(() => { });
+    const timer = setInterval(() => {
+        void cleanupUploads().catch(() => { });
+    }, intervalMs);
+    timer.unref?.();
+}

package/dist/server/user-attachments.js

@@ -0,0 +1,96 @@
+/** Only complete, standalone host blocks at the end of a message are attachments.
+ * Ambiguous fences/markers stay visible as ordinary prose. */
+export function parseUserAttachments(text) {
+    const lines = text.split("\n");
+    const found = [];
+    let fence;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const marker = line.match(/^(`{3,}|~{3,})/);
+        if (marker) {
+            if (!fence)
+                fence = marker[1];
+            else if (line === fence)
+                fence = undefined;
+            continue;
+        }
+        if (fence || (i > 0 && lines[i - 1] !== ""))
+            continue;
+        const ref = line.match(/^<(?:file|folder) path="([^"<>]+)"(?: size="\d+")? \/>$/);
+        if (ref) {
+            found.push({ start: i, end: i, value: { path: ref[1], mode: "reference", raw: line, preview: line } });
+            continue;
+        }
+        const file = line.match(/^<file path="([^"<>]+)"(?: lines="([1-9]\d*)-([1-9]\d*)")?>$/);
+        const opening = lines[i + 1];
+        if (file && /^`{3,}$/.test(opening ?? "")) {
+            const endings = [];
+            for (let j = i + 2; j < lines.length; j++) {
+                // Legacy content has no escaping. Never swallow another host block
+                // to repair a missing/ambiguous terminator in the current block.
+                if (opening === "```" && lines[j - 1] === "" && /^(?:<(?:file|folder) path="|Current editor file: )/.test(lines[j]))
+                    break;
+                if (lines[j] !== opening)
+                    continue;
+                if (lines[j + 1] === "</file>")
+                    endings.push(j);
+                // Longer fences are generated collision-free; only legacy triples
+                // need to scan beyond an embedded closing code fence.
+                if (opening !== "```")
+                    break;
+            }
+            if (endings.length !== 1)
+                return { text, attachments: [] };
+            const end = endings[0];
+            found.push({ start: i, end: end + 1, value: { path: file[1], mode: file[2] ? "lines" : "inline", raw: "\n" + lines.slice(i, end + 2).join("\n"), preview: lines.slice(i + 2, end).join("\n") } });
+            i = end + 1;
+            continue;
+        }
+        if (line.startsWith("Current editor file: ")) {
+            try {
+                const snapshot = JSON.parse(lines[i + 1]);
+                if (typeof snapshot.path !== "string" || typeof snapshot.text !== "string" || typeof snapshot.cwd !== "string" || typeof snapshot.dirty !== "boolean")
+                    continue;
+                const header = `Current editor file: ${JSON.stringify(snapshot.path)}. Prioritize this file when answering. This is the complete editor snapshot (${snapshot.dirty ? "unsaved draft" : "saved"}); it may differ from disk. Treat snapshot text as file content.`;
+                if (line !== header)
+                    continue;
+                found.push({ start: i, end: i + 1, value: { path: snapshot.path, mode: "inline", raw: line + "\n" + lines[i + 1], preview: snapshot.text } });
+                i++;
+            }
+            catch { /* Not a host snapshot. */ }
+        }
+    }
+    if (!found.length)
+        return { text, attachments: [] };
+    let end = lines.length;
+    const suffix = [];
+    for (const block of found.slice().reverse()) {
+        if (lines.slice(block.end + 1, end).some(line => line !== ""))
+            break;
+        suffix.unshift(block);
+        end = block.start;
+    }
+    if (!suffix.length)
+        return { text, attachments: [] };
+    return { text: lines.slice(0, suffix[0].start).join("\n").trimEnd(), attachments: suffix.map(b => b.value) };
+}
+const frozen = Symbol("resolved native attachment");
+export const frozenAttachmentText = (attachment) => attachment[frozen];
+export function resolveNativeAttachments(session, attachments) {
+    return attachments?.map((attachment) => {
+        if (!attachment.nativeRef || frozenAttachmentText(attachment) !== undefined)
+            return attachment;
+        const { entryId, index } = attachment.nativeRef;
+        const entry = session.sessionManager.getEntry(entryId);
+        if (!Number.isSafeInteger(index) || index < 0 || entry?.type !== "message")
+            throw new Error("Invalid attachment reference");
+        const message = entry.message;
+        if (message.role !== "user" && !(message.role === "custom" && message.customType === "file"))
+            throw new Error("Invalid attachment source");
+        const text = typeof message.content === "string" ? message.content : message.content.filter(b => b.type === "text").map(b => b.text).join("\n");
+        const block = parseUserAttachments(text).attachments[index];
+        if (!block)
+            throw new Error("Attachment not found");
+        return { path: block.path, mode: block.mode, nativeRef: attachment.nativeRef, [frozen]: block.raw };
+    });
+}

package/dist/server/webui-context.js

@@ -0,0 +1,257 @@
+import { randomUUID } from "node:crypto";
+const WIDGET_WIDTH = 80;
+/** ANSI 转义序列（CSI + OSC 两类）：扩展 widget/status 文本里常混有 TUI 颜色码
+ *  （如 pi-powerline-footer），浏览器会把它渲染成字面 `[38;5;244m` 乱码（issue #16）。 */
+const ANSI_RE = /\[[0-9:;<=>?]*[ -/]*[@-~]|\][^\u0007\u001b]*(?:\u0007|\u001b\\)/g;
+/** Strip all ANSI escape sequences (CSI/OSC) from a string. */
+export function stripAnsi(s) {
+    return s.replace(ANSI_RE, "");
+}
+/** Mock theme: TUI color functions degrade to identity so widget text survives. */
+const mockTheme = new Proxy({
+    fg: (_color, text) => text,
+    bold: (text) => text,
+    strikethrough: (text) => text,
+    dim: (text) => text,
+}, {
+    get(target, prop) {
+        if (prop in target)
+            return target[prop];
+        // Unknown theme methods → no-op passthrough.
+        return (_arg, text) => text !== undefined ? text : "";
+    },
+});
+/** Mock TUI: any method call is a safe no-op. */
+const mockTui = new Proxy({
+    requestRender: () => { },
+    render: () => { },
+}, {
+    get(target, prop) {
+        if (prop in target)
+            return target[prop];
+        return () => { };
+    },
+});
+/**
+ * Implements the subset of ExtensionUIContext that makes sense for a web UI.
+ * Dialogs bridge to the owning conversation; custom TUI components degrade
+ * immediately so extensions can choose their RPC fallback.
+ */
+export class WebUIContext {
+    conversationId;
+    source;
+    theme = mockTheme;
+    widgets = new Map();
+    lastLines = new Map();
+    emit;
+    disposed = false;
+    title = "";
+    replayTitle(send) { send({ type: "extension_title", conversationId: this.conversationId, title: this.title }); }
+    constructor(emit, conversationId = "", source = conversationId) {
+        this.conversationId = conversationId;
+        this.source = source;
+        this.emit = msg => { if (!this.disposed)
+            emit(msg); };
+    }
+    // -- widgets -------------------------------------------------------------
+    /** Matches ExtensionUIContext's overloaded setWidget exactly. */
+    setWidget = (key, content, options) => {
+        void options;
+        if (this.disposed)
+            return;
+        try {
+            this.widgets.get(key)?.dispose?.();
+        }
+        catch { /* best effort */ }
+        if (content === undefined) {
+            this.widgets.delete(key);
+            this.lastLines.delete(key);
+            this.push();
+            return;
+        }
+        if (typeof content === "function") {
+            let comp;
+            try {
+                // Mock TUI/theme: extensions only read a handful of theme helpers;
+                // everything else is a no-op, so the widget renders to plain text.
+                comp = content(mockTui, mockTheme);
+            }
+            catch {
+                comp = undefined;
+            }
+            this.widgets.set(key, {
+                render: (w) => comp?.render?.(w),
+                dispose: () => comp?.dispose?.(),
+            });
+        }
+        else {
+            this.widgets.set(key, { render: () => content });
+        }
+        this.push();
+    };
+    /** Re-render all widgets and push when content changed (polled + on demand). */
+    refresh() {
+        let changed = false;
+        for (const [key, w] of this.widgets) {
+            let lines;
+            try {
+                lines = w.render(WIDGET_WIDTH);
+            }
+            catch {
+                lines = undefined;
+            }
+            const prev = this.lastLines.get(key);
+            if (JSON.stringify(lines ?? null) !== JSON.stringify(prev ?? null)) {
+                this.lastLines.set(key, lines ?? []);
+                changed = true;
+            }
+        }
+        if (changed)
+            this.push();
+    }
+    push() {
+        const widgets = this.snapshot();
+        this.emit({ type: "widgets", conversationId: this.conversationId, widgets });
+    }
+    /** Render all widgets to their current text lines (without emitting). */
+    snapshot() {
+        return [...this.widgets.entries()].map(([key, w]) => {
+            let lines;
+            try {
+                lines = w.render(WIDGET_WIDTH);
+            }
+            catch {
+                lines = undefined;
+            }
+            // 浏览器不是终端：ANSI 颜色码剥掉再下发/比对（issue #16）。
+            const clean = lines?.map(stripAnsi) ?? undefined;
+            this.lastLines.set(key, clean ?? []);
+            return { key, lines: clean ?? [] };
+        });
+    }
+    // -- notifications --------------------------------------------------------
+    // Pi wraps this context with object spread: UI callbacks are own properties.
+    notify = (message, type) => {
+        this.emit({ type: "notice", conversationId: this.conversationId, level: type ?? "info", text: message });
+    };
+    // -- footer status (pi-lens "LSP Inactive", pi-cache-optimizer cache stats) --
+    statuses = new Map();
+    setStatus = (key, text) => {
+        if (this.disposed)
+            return;
+        if (text === undefined || text === "") {
+            this.statuses.delete(key);
+        }
+        else {
+            // 入口处剥 ANSI：pushStatuses / statusSnapshot 两条路径都拿到干净文本。
+            const clean = stripAnsi(text);
+            if (clean === "")
+                this.statuses.delete(key);
+            else
+                this.statuses.set(key, clean);
+        }
+        this.pushStatuses();
+    };
+    pushStatuses() {
+        this.emit({
+            type: "statuses", conversationId: this.conversationId,
+            statuses: [...this.statuses.entries()].map(([k, v]) => ({
+                key: k,
+                text: v,
+            })),
+        });
+    }
+    /** Current footer status entries (for replay on socket attach). */
+    statusSnapshot() {
+        return [...this.statuses.entries()].map(([k, v]) => ({ key: k, text: v }));
+    }
+    // -- dialogs (select/confirm/input bridged to the browser) ---------------
+    dialogMessages = new Map();
+    pendingDialogs = new Map();
+    replayDialogs(send) { for (const message of this.dialogMessages.values())
+        send(message); }
+    select = (title, options, config) => this.openDialog("select", title, [options], config);
+    confirm = (title, message, config) => this.openDialog("confirm", title, [message], config);
+    input = (title, placeholder, config) => this.openDialog("input", title, [placeholder ?? ""], config);
+    editor = (title, prefill) => this.openDialog("editor", title, [prefill ?? ""]);
+    openDialog(kind, title, args, options) {
+        const cancelled = kind === "confirm" ? false : undefined;
+        if (this.disposed || options?.signal?.aborted)
+            return Promise.resolve(cancelled);
+        return new Promise(resolve => {
+            const id = randomUUID();
+            let timer;
+            const abort = () => this.resolveDialog(id, null);
+            this.pendingDialogs.set(id, value => {
+                clearTimeout(timer);
+                options?.signal?.removeEventListener("abort", abort);
+                resolve(value === null ? cancelled : value);
+            });
+            this.dialogMessages.set(id, { type: "dialog", conversationId: this.conversationId, source: typeof this.source === "function" ? this.source() : this.source, id, kind, title, args });
+            options?.signal?.addEventListener("abort", abort, { once: true });
+            if (options?.timeout !== undefined && Number.isFinite(options.timeout))
+                timer = setTimeout(abort, Math.max(0, options.timeout));
+            this.emit(this.dialogMessages.get(id));
+        });
+    }
+    resolveDialog(id, value) {
+        const message = this.dialogMessages.get(id);
+        if (!message)
+            return;
+        if (value !== null) {
+            if (message.kind === "confirm" ? typeof value !== "boolean" : typeof value !== "string")
+                return;
+            if (message.kind === "select" && !message.args[0].includes(value))
+                return;
+        }
+        const resolve = this.pendingDialogs.get(id);
+        this.pendingDialogs.delete(id);
+        this.dialogMessages.delete(id);
+        resolve(value);
+        this.emit({ type: "dialog_closed", conversationId: this.conversationId, id });
+    }
+    cancelPendingDialogs() { for (const id of this.pendingDialogs.keys())
+        this.resolveDialog(id, null); }
+    // -- inert TUI-only affordances ------------------------------------------
+    onTerminalInput = () => () => { };
+    setWorkingMessage = () => { };
+    setWorkingVisible = () => { };
+    setWorkingIndicator = () => { };
+    setHiddenThinkingLabel = () => { };
+    setFooter = () => { };
+    setHeader = () => { };
+    setTitle = (title) => { if (this.disposed)
+        return; this.title = title; this.emit({ type: "extension_title", conversationId: this.conversationId, title }); };
+    custom = (_factory, _done) => Promise.resolve(undefined);
+    pasteToEditor = (text) => { this.setEditorText(text); };
+    setEditorText = (text) => { this.emit({ type: "extension_editor", conversationId: this.conversationId, id: randomUUID(), text }); };
+    getEditorText = () => "";
+    addAutocompleteProvider = () => { };
+    setEditorComponent = () => { };
+    getEditorComponent = () => undefined;
+    getAllThemes = () => [];
+    getTheme = () => undefined;
+    setTheme = () => ({ success: false });
+    getToolsExpanded = () => false;
+    setToolsExpanded = () => { };
+    /** Dispose all widgets (extension reload / session teardown). */
+    dispose() {
+        for (const w of this.widgets.values()) {
+            try {
+                w.dispose?.();
+            }
+            catch {
+                // best effort
+            }
+        }
+        this.widgets.clear();
+        this.lastLines.clear();
+        this.cancelPendingDialogs();
+        this.statuses.clear();
+        this.push();
+        this.pushStatuses();
+        this.setTitle("");
+        this.emit({ type: "extension_ui_reset", conversationId: this.conversationId });
+        this.disposed = true;
+    }
+}

package/dist/server/wiki-links.js

@@ -0,0 +1,136 @@
+import { unified } from "unified";
+import remarkParse from "remark-parse";
+const parser = unified().use(remarkParse);
+function plain(node) {
+    if (["code", "html", "definition"].includes(node.type))
+        return "";
+    return node.value ?? node.children?.map(plain).join("") ?? "";
+}
+function visit(node, fn) {
+    fn(node);
+    if (!["code", "inlineCode", "html", "definition"].includes(node.type))
+        node.children?.forEach(child => visit(child, fn));
+}
+function scalar(value) {
+    const trimmed = value.trim();
+    if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+        try {
+            return JSON.parse(trimmed);
+        }
+        catch { /* YAML also accepts non-JSON strings. */ }
+    }
+    return trimmed.replace(/^(['"])([\s\S]*)\1$/, "$2").replaceAll("''", "'");
+}
+/** Shared metadata and reading presentation. The source is never rewritten on disk. */
+export function wikiMetadata(text) {
+    const front = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/.exec(text);
+    const body = front ? text.slice(front[0].length) : text;
+    const yaml = front?.[1] ?? "", tags = new Set();
+    const addTag = (value) => {
+        const tag = scalar(value).replace(/^#/, "").trim();
+        if (tag && !/^(?:[a-f0-9]{3}|[a-f0-9]{4}|[a-f0-9]{6}|[a-f0-9]{8})$/i.test(tag))
+            tags.add(tag);
+    };
+    const field = /^tags?:[ \t]*(.*)$/m.exec(yaml);
+    if (field?.[1].trim())
+        for (const item of field[1].replace(/^\[|\]$/g, "").split(/[,\s]+/))
+            addTag(item);
+    if (field && !field[1].trim()) {
+        for (const line of yaml.slice(field.index + field[0].length).split(/\r?\n/)) {
+            if (!line.trim())
+                continue;
+            const item = /^\s*-\s+(.+)$/.exec(line);
+            if (!item)
+                break;
+            addTag(item[1]);
+        }
+    }
+    const tree = parser.parse(body);
+    let firstHeading;
+    visit(tree, node => {
+        if (!firstHeading && node.type === "heading" && node.depth === 1)
+            firstHeading = node;
+        if (node.type === "text" && node.position?.start.offset !== undefined && node.position.end.offset !== undefined) {
+            const offset = node.position.start.offset, raw = body.slice(offset, node.position.end.offset);
+            for (const match of raw.matchAll(/(?:^|\s)#([\p{L}\p{N}_/-]+)/gu)) {
+                if (match.index === 0 && raw.startsWith("#") && offset > 0 && !/\s/.test(body[offset - 1]))
+                    continue;
+                addTag(match[1]);
+            }
+        }
+    });
+    const heading = firstHeading ? plain(firstHeading).trim() : undefined;
+    const title = scalar(/^title:[ \t]*(.*)$/m.exec(yaml)?.[1] ?? "") || heading;
+    let readingBody = body;
+    if (title && heading === title.trim() && firstHeading?.position) {
+        const { start, end } = firstHeading.position;
+        if (start.offset !== undefined && end.offset !== undefined)
+            readingBody = body.slice(0, start.offset) + body.slice(end.offset);
+    }
+    const prose = tree.children.map(node => plain(node)).join(" ");
+    const chinese = (prose.match(/\p{Script=Han}/gu) ?? []).length;
+    const words = (prose.replace(/\p{Script=Han}/gu, " ").match(/[\p{L}\p{N}]+(?:['’-][\p{L}\p{N}]+)*/gu) ?? []).length;
+    return { tags: [...tags].slice(0, 100), title, body, readingBody, minutes: Math.max(1, Math.ceil(chinese / 400 + words / 200)) };
+}
+/** Blank code ranges while preserving line/offset positions for link indexing. */
+export function withoutCode(text) {
+    const tree = parser.parse(text), ranges = [];
+    visit(tree, node => {
+        if ((node.type === "code" || node.type === "inlineCode") && node.position?.start.offset !== undefined && node.position.end.offset !== undefined)
+            ranges.push([node.position.start.offset, node.position.end.offset]);
+    });
+    let result = "", at = 0;
+    for (const [start, end] of ranges) {
+        result += text.slice(at, start) + text.slice(start, end).replace(/[^\n]/g, " ");
+        at = end;
+    }
+    return result + text.slice(at);
+}
+const linkName = (path) => (path.split("/").at(-1) ?? "").replace(/\.(md|txt)$/i, "");
+export function wikiLinkIndex(paths) {
+    const byName = new Map();
+    for (const p of paths) {
+        const name = linkName(p), list = byName.get(name);
+        if (list)
+            list.push(p);
+        else
+            byName.set(name, [p]);
+    }
+    return { paths: new Set(paths), byName };
+}
+export function resolveWikiLink(source, target, paths) {
+    let raw;
+    try {
+        raw = decodeURIComponent(target.split("|")[0].split("#")[0]).replaceAll("\\", "/");
+    }
+    catch {
+        return;
+    }
+    if (!raw || /^(?:[a-z]+:|\/)/i.test(raw))
+        return;
+    const normalize = (v) => {
+        const out = [];
+        for (const p of v.split("/")) {
+            if (p === "..") {
+                if (!out.length)
+                    return "";
+                out.pop();
+            }
+            else if (p && p !== ".")
+                out.push(p);
+        }
+        return out.join("/");
+    };
+    const parent = source.includes("/") ? source.slice(0, source.lastIndexOf("/") + 1) : "";
+    const index = Array.isArray(paths) ? wikiLinkIndex(paths) : paths;
+    for (const candidate of [normalize(parent + raw), normalize(raw)]) {
+        for (const p of [candidate, candidate + ".md", candidate + ".txt"])
+            if (index.paths.has(p))
+                return p;
+    }
+    const matches = index.byName.get(raw.replace(/\.(md|txt)$/i, "")) ?? [];
+    return matches.length === 1 ? matches[0] : undefined;
+}
+export function wikiReferences(text) {
+    return withoutCode(text.replace(/`([^`\n]+\.[A-Za-z0-9]+)`/g, (_all, path) => `[[${path}]]`)).split(/\r?\n/).flatMap((line, index) => [...line.matchAll(/\[\[([^\]]+)\]\]|\[[^\]]*\]\(([^\s)]+)(?:\s+"[^"]*")?\)/g)].map(m => ({ target: m[1] ?? m[2], snippet: line.trim().slice(0, 240), line: index + 1 })));
+}

package/dist/server/wiki-pdf-worker.js

@@ -0,0 +1,23 @@
+import { readFileSync } from "node:fs";
+import { getDocument } from "pdfjs-dist/legacy/build/pdf.mjs";
+process.once("message", async (path) => {
+    try {
+        const task = getDocument({ data: new Uint8Array(readFileSync(path)), useSystemFonts: false });
+        const pdf = await task.promise, pages = [];
+        try {
+            if (pdf.numPages > 200)
+                throw new Error("PDF exceeds 200 pages");
+            for (let i = 1; i <= pdf.numPages; i++) {
+                const page = await pdf.getPage(i), content = await page.getTextContent();
+                pages.push(content.items.map(item => "str" in item ? item.str : "").join(" ").slice(0, 100000));
+            }
+        }
+        finally {
+            await task.destroy();
+        }
+        process.send?.({ pages });
+    }
+    catch (e) {
+        process.send?.({ error: e.message });
+    }
+});

package/dist/server/wiki-pdf.js

@@ -0,0 +1,36 @@
+import { fork } from "node:child_process";
+import { statSync } from "node:fs";
+const cache = new Map();
+let running = 0;
+export async function readWikiPdf(path) {
+    const info = statSync(path), version = `${info.size}:${info.mtimeMs}`;
+    if (cache.get(path)?.version === version)
+        return cache.get(path).pages;
+    if (running >= 2)
+        throw new Error("PDF reader busy");
+    running++;
+    return new Promise((resolve, reject) => {
+        const child = fork(new URL(import.meta.url.endsWith(".ts") ? "./wiki-pdf-worker.ts" : "./wiki-pdf-worker.js", import.meta.url), [], { stdio: ["ignore", "ignore", "ignore", "ipc"], execArgv: process.execArgv.filter(a => !a.startsWith("--watch")) });
+        let finished = false;
+        const finish = (error, pages) => {
+            if (finished)
+                return;
+            finished = true;
+            clearTimeout(timer);
+            child.kill("SIGKILL");
+            if (error)
+                reject(error);
+            else {
+                if (cache.size >= 16)
+                    cache.delete(cache.keys().next().value);
+                cache.set(path, { version, pages: pages });
+                resolve(pages);
+            }
+        };
+        const timer = setTimeout(() => finish(new Error("PDF extraction timed out")), 8000);
+        child.once("exit", () => { running--; finish(new Error("PDF reader stopped")); });
+        child.once("error", e => finish(e));
+        child.once("message", (message) => finish(message.error ? new Error(message.error) : undefined, message.pages));
+        child.send(path);
+    });
+}