@youweichen/pi-harness 1.0.0 → 1.2.0

package/dist/server/document-conversion/service.js

@@ -0,0 +1,340 @@
+import { createHash, randomUUID } from "node:crypto";
+import { createReadStream } from "node:fs";
+import { readFile, writeFile, stat, mkdir, rm, rename, access, lstat, readdir, cp, copyFile } from "node:fs/promises";
+import { basename, dirname, extname, join, resolve, isAbsolute } from "node:path";
+import { withFileMutationQueue } from "@earendil-works/pi-coding-agent";
+import { unified } from "unified";
+import remarkParse from "remark-parse";
+import lockfile from "proper-lockfile";
+import { documentDataDir } from "./settings.js";
+import { decodeText } from "../text-sniff.js";
+import { CONVERSION_PROFILE, ensureRuntimeReady, runConversionWorker, runtimeFingerprint, waitDocumentQueue } from "./runtime.js";
+export const DOCUMENT_EXTENSIONS = new Set([".pdf", ".md", ".markdown", ".txt", ".docx", ".xlsx", ".pptx"]);
+const locks = new Map();
+async function hashFile(path, signal) {
+    const hash = createHash("sha256"), stream = createReadStream(path, { signal });
+    for await (const chunk of stream)
+        hash.update(chunk);
+    return hash.digest("hex");
+}
+function digest(value) { return createHash("sha256").update(value).digest("hex"); }
+function markdownImageNodes(text) {
+    const tree = unified().use(remarkParse).parse(text);
+    const nodes = [], references = new Set();
+    const visit = (node) => { nodes.push(node); if (node.type === "imageReference" && node.identifier)
+        references.add(node.identifier); node.children?.forEach(visit); };
+    visit(tree);
+    return nodes.filter(node => node.type === "image" || (node.type === "definition" && node.identifier && references.has(node.identifier)));
+}
+function imageSource(url, source, assets) {
+    if (assets !== undefined) {
+        if (!Object.hasOwn(assets, url) || !assets[url])
+            throw new Error("Image is not present in the archived evidence snapshot");
+        return assets[url];
+    }
+    return resolve(dirname(source), decodeURIComponent(url.split("#")[0]));
+}
+async function markdownDependencyFingerprint(text, source, assets) {
+    const dependencies = [];
+    for (const node of markdownImageNodes(text)) {
+        const url = node.url ?? "";
+        if (!url || /^(?:[a-z]+:|#)/i.test(url) || isAbsolute(url))
+            continue;
+        try {
+            const path = imageSource(url, source, assets), info = await stat(path);
+            if (!info.isFile() || info.size > 20 * 1024 * 1024)
+                throw new Error("Unsupported asset");
+            dependencies.push(`${url}:${await hashFile(path)}`);
+        }
+        catch {
+            dependencies.push(`${url}:missing`);
+        }
+    }
+    return digest(JSON.stringify(dependencies));
+}
+async function preserveMarkdownImages(text, source, output, warnings, assets) {
+    const replacements = [];
+    for (const node of markdownImageNodes(text)) {
+        const url = node.url ?? "";
+        if (!url || /^(?:https?:|data:|#)/i.test(url))
+            continue;
+        try {
+            if (isAbsolute(url) || /^[a-z]+:/i.test(url))
+                throw new Error("absolute image paths are not portable");
+            const local = imageSource(url, source, assets);
+            if (![".png", ".jpg", ".jpeg", ".webp", ".gif", ".svg", ".bmp", ".tiff"].includes(extname(local).toLowerCase()))
+                throw new Error("unsupported image format");
+            const info = await stat(local);
+            if (!info.isFile() || info.size > 20 * 1024 * 1024)
+                throw new Error("image is not a regular file below 20 MiB");
+            const target = `assets/${(await hashFile(local)).slice(0, 24)}${extname(local).toLowerCase()}`;
+            await copyFile(local, join(output, target));
+            const start = node.position?.start.offset, end = node.position?.end.offset;
+            if (start !== undefined && end !== undefined)
+                replacements.push({ start, end, text: node.type === "definition" ? `[${node.identifier}]: ${target}${node.title ? ` ${JSON.stringify(node.title)}` : ""}` : `![${(node.alt ?? "").replace(/]/g, "\\]")}](${target}${node.title ? ` ${JSON.stringify(node.title)}` : ""})` });
+        }
+        catch (error) {
+            warnings.push(`Markdown image was not copied: ${url}: ${error instanceof Error ? error.message : error}`);
+        }
+    }
+    for (const replacement of replacements.sort((a, b) => b.start - a.start))
+        text = text.slice(0, replacement.start) + replacement.text + text.slice(replacement.end);
+    return text;
+}
+export function textBlocks(text) {
+    const lines = text.split("\n"), blocks = [];
+    let start = 0, heading, fence;
+    const emit = (end) => {
+        const value = lines.slice(start, end).join("\n");
+        if (value.trim())
+            blocks.push({ id: `block-${blocks.length + 1}`, text: value, locator: { lineStart: start + 1, lineEnd: end, ...(heading ? { heading } : {}) } });
+        start = end;
+    };
+    for (let i = 0; i < lines.length; i++) {
+        const marker = lines[i].match(/^\s*(`{3,}|~{3,})/);
+        if (marker) {
+            if (!fence)
+                fence = marker[1];
+            else if (marker[1][0] === fence[0] && marker[1].length >= fence.length)
+                fence = undefined;
+        }
+        if (!fence && /^#{1,6}\s+/.test(lines[i])) {
+            emit(i);
+            heading = lines[i].replace(/^#{1,6}\s+/, "");
+        }
+        if (!fence && !lines[i].trim()) {
+            emit(i);
+            start = i + 1;
+        }
+    }
+    emit(lines.length);
+    return blocks;
+}
+export async function convertDocument(options) {
+    const key = resolve(options.outputDir), prior = locks.get(key) ?? Promise.resolve();
+    let release;
+    const lock = new Promise(done => { release = done; });
+    const chain = prior.then(() => lock);
+    locks.set(key, chain);
+    try {
+        await waitDocumentQueue(prior, options.signal);
+        options.signal?.throwIfAborted();
+        return await convert({ ...options, outputDir: key });
+    }
+    finally {
+        release();
+        if (locks.get(key) === chain)
+            locks.delete(key);
+    }
+}
+async function artifactFiles(root, prefix = "") {
+    const paths = [];
+    for (const entry of await readdir(join(root, prefix), { withFileTypes: true })) {
+        const path = join(prefix, entry.name);
+        if (entry.isSymbolicLink())
+            throw new Error("Parser artifacts must not contain symlinks");
+        if (entry.isDirectory())
+            paths.push(...await artifactFiles(root, path));
+        else if (entry.isFile() && path !== "manifest.json")
+            paths.push(path);
+    }
+    return paths;
+}
+async function loadResult(root, manifest) {
+    const sourceMap = JSON.parse(await readFile(join(root, "source-map.json"), "utf8"));
+    return { markdownPath: join(root, "document.md"), structurePath: join(root, "structure.json"), sourceMapPath: join(root, "source-map.json"), assetsDir: join(root, "assets"), sourceHash: manifest.sourceHash, parserVersion: manifest.parserVersion, warnings: manifest.warnings, status: manifest.status, blocks: sourceMap.blocks };
+}
+async function existingManifest(root, signal) {
+    try {
+        await access(root);
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return undefined;
+        throw error;
+    }
+    if ((await lstat(root)).isSymbolicLink())
+        throw new Error("Output directory must not be a symlink");
+    if ((await readdir(root)).length === 0)
+        return undefined;
+    let manifest;
+    try {
+        manifest = JSON.parse(await readFile(join(root, "manifest.json"), "utf8"));
+    }
+    catch {
+        throw new Error("Output directory contains existing files without a conversion manifest; choose another directory");
+    }
+    if (manifest.schemaVersion !== 1 || !manifest.files || typeof manifest.files !== "object")
+        throw new Error("Invalid existing conversion manifest");
+    const actual = await artifactFiles(root);
+    if (actual.length !== Object.keys(manifest.files).length)
+        throw new Error("Conversion output has added or removed files; choose another directory to preserve changes");
+    for (const path of actual) {
+        if (!manifest.files[path] || await hashFile(join(root, path), signal) !== manifest.files[path])
+            throw new Error(`Conversion output was edited: ${path}. Choose another directory to preserve changes.`);
+    }
+    for (const required of ["document.md", "structure.json", "source-map.json"])
+        if (!manifest.files[required])
+            throw new Error("Incomplete conversion manifest");
+    return manifest;
+}
+async function destinationLock(root, signal) {
+    for (;;) {
+        signal?.throwIfAborted();
+        try {
+            return await lockfile.lock(root, { realpath: false, lockfilePath: `${root}.conversion-lock`, stale: 120_000, retries: 0 });
+        }
+        catch (error) {
+            if (error.code !== "ELOCKED")
+                throw error;
+            await new Promise(done => setTimeout(done, 100));
+        }
+    }
+}
+async function withArtifactMutationQueues(root, paths, operation) {
+    const ordered = [...new Set(paths)].sort();
+    const acquire = (index) => index === ordered.length ? operation() : withFileMutationQueue(join(root, ordered[index]), () => acquire(index + 1));
+    return acquire(0);
+}
+async function convert(options) {
+    const { outputDir, signal, onProgress } = options, inputPath = resolve(options.inputPath), suffix = extname(inputPath).toLowerCase();
+    if (!DOCUMENT_EXTENSIONS.has(suffix))
+        throw new Error(`Unsupported document format: ${suffix}`);
+    if (inputPath === outputDir || inputPath.startsWith(outputDir + "/") || inputPath.startsWith(outputDir + "\\"))
+        throw new Error("Output directory must not contain the source document");
+    const info = await stat(inputPath);
+    if (!info.isFile() || info.size > 100 * 1024 * 1024)
+        throw new Error("Document must be a file no larger than 100 MiB");
+    const sourceHash = await hashFile(inputPath, signal), plain = [".md", ".markdown", ".txt"].includes(suffix);
+    let parserVersion = "text-v1", fingerprint = "text-v1", markdownDependencies;
+    if (suffix === ".md" || suffix === ".markdown") {
+        if (info.size > 16 * 1024 * 1024)
+            throw new Error("Text documents are limited to 16 MiB");
+        markdownDependencies = await markdownDependencyFingerprint(decodeText(await readFile(inputPath)), inputPath, options.markdownAssets);
+        fingerprint += markdownDependencies;
+    }
+    if (!plain) {
+        const doctor = await ensureRuntimeReady({ signal, onProgress });
+        if (!doctor.ready)
+            throw new Error(`Local document runtime is not ready. Run /pdf-md setup. ${doctor.missing.join("; ")}`);
+        parserVersion = `docling-${doctor.parserVersion}`;
+        fingerprint = await runtimeFingerprint();
+    }
+    const cacheKey = digest(JSON.stringify({ sourceHash, suffix, profile: CONVERSION_PROFILE, fingerprint }));
+    await mkdir(dirname(outputDir), { recursive: true });
+    const unlock = await destinationLock(outputDir, signal);
+    try {
+        const existing = await existingManifest(outputDir, signal);
+        if (existing?.cacheKey === cacheKey && existing.status === "complete") {
+            const priorSource = JSON.parse(await readFile(join(outputDir, "source-map.json"), "utf8")).source;
+            if (priorSource === inputPath) {
+                onProgress?.("Using unchanged document conversion");
+                return await loadResult(outputDir, existing);
+            }
+        }
+        const cacheDir = join(documentDataDir(), "document-cache", cacheKey);
+        const staging = join(dirname(outputDir), `.${basename(outputDir)}-${randomUUID()}.partial`), backup = `${staging}.previous`;
+        await mkdir(join(staging, "assets"), { recursive: true });
+        let installed = false, backedUp = false;
+        try {
+            let warnings = [], status = "complete";
+            let reused;
+            try {
+                reused = await existingManifest(cacheDir, signal);
+            }
+            catch {
+                signal?.throwIfAborted();
+            }
+            if (reused?.cacheKey === cacheKey && reused.status === "complete") {
+                await cp(cacheDir, staging, { recursive: true });
+                warnings = reused.warnings;
+                status = reused.status;
+                const sourceMap = JSON.parse(await readFile(join(staging, "source-map.json"), "utf8"));
+                sourceMap.source = inputPath;
+                await writeFile(join(staging, "source-map.json"), JSON.stringify(sourceMap, null, 2));
+                const structure = JSON.parse(await readFile(join(staging, "structure.json"), "utf8"));
+                if (structure.origin && typeof structure.origin === "object")
+                    structure.origin.filename = basename(inputPath);
+                await writeFile(join(staging, "structure.json"), JSON.stringify(structure, null, 2));
+                onProgress?.("Reusing the local document content cache");
+            }
+            else if (plain) {
+                if (info.size > 16 * 1024 * 1024)
+                    throw new Error("Text documents are limited to 16 MiB");
+                const data = await readFile(inputPath);
+                try {
+                    new TextDecoder("utf-8", { fatal: true }).decode(data);
+                }
+                catch {
+                    warnings.push("Source is not UTF-8; decoded using the legacy text encoding fallback. Verify non-ASCII text.");
+                }
+                const text = decodeText(data).replace(/^\uFEFF/, "").replace(/\r\n?/g, "\n"), blocks = textBlocks(text);
+                const markdown = suffix === ".txt" ? text : await preserveMarkdownImages(text, inputPath, staging, warnings, options.markdownAssets);
+                if (warnings.some(warning => warning.startsWith("Markdown image was not copied")))
+                    status = "partial";
+                await writeFile(join(staging, "document.md"), markdown.endsWith("\n") ? markdown : markdown + "\n");
+                await writeFile(join(staging, "structure.json"), JSON.stringify({ schemaVersion: 1, kind: "text", blocks }, null, 2));
+                await writeFile(join(staging, "source-map.json"), JSON.stringify({ schemaVersion: 1, source: inputPath, sourceHash, blocks }, null, 2));
+            }
+            else {
+                onProgress?.(`Converting ${basename(inputPath)} locally`);
+                const response = await runConversionWorker({ inputPath, outputDir: staging, sourceHash }, { signal, onProgress });
+                if (response.status !== "complete" && response.status !== "partial")
+                    throw new Error("Invalid parser completion status");
+                status = response.status;
+                warnings = response.warnings ?? [];
+            }
+            if (await hashFile(inputPath, signal) !== sourceHash)
+                throw new Error("Source changed during conversion; retry with the current document");
+            if (markdownDependencies !== undefined && await markdownDependencyFingerprint(decodeText(await readFile(inputPath)), inputPath, options.markdownAssets) !== markdownDependencies)
+                throw new Error("Markdown images changed during conversion; retry with the current document");
+            for (const path of ["document.md", "structure.json", "source-map.json"])
+                await access(join(staging, path));
+            const files = {};
+            for (const path of await artifactFiles(staging))
+                files[path] = await hashFile(join(staging, path), signal);
+            const manifest = { schemaVersion: 1, cacheKey, sourceHash, parserVersion, status, warnings, files };
+            await writeFile(join(staging, "manifest.json"), JSON.stringify(manifest, null, 2));
+            signal?.throwIfAborted();
+            onProgress?.("Committing verified document artifacts");
+            await withArtifactMutationQueues(outputDir, ["manifest.json", ...Object.keys(existing?.files ?? {}), ...Object.keys(files)], async () => {
+                // Revalidate after the slow parser run, catching edits made during OCR.
+                await existingManifest(outputDir, signal);
+                try {
+                    await access(outputDir);
+                    await rename(outputDir, backup);
+                    backedUp = true;
+                }
+                catch (error) {
+                    if (error.code !== "ENOENT")
+                        throw error;
+                }
+                await rename(staging, outputDir);
+                installed = true;
+            });
+            if (status === "complete") {
+                await mkdir(dirname(cacheDir), { recursive: true });
+                const temporaryCache = `${cacheDir}.${randomUUID()}.partial`;
+                try {
+                    await cp(outputDir, temporaryCache, { recursive: true });
+                    await rename(temporaryCache, cacheDir);
+                }
+                catch { /* Cache races or cache I/O failures never invalidate the output. */ }
+                finally {
+                    await rm(temporaryCache, { recursive: true, force: true });
+                }
+            }
+            return await loadResult(outputDir, manifest);
+        }
+        finally {
+            if (!installed && backedUp)
+                await rename(backup, outputDir);
+            await rm(staging, { recursive: true, force: true });
+            if (installed)
+                await rm(backup, { recursive: true, force: true });
+        }
+    }
+    finally {
+        await unlock();
+    }
+}

package/dist/server/document-conversion/settings.js

@@ -0,0 +1,63 @@
+import { randomUUID } from "node:crypto";
+import { mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, join, resolve } from "node:path";
+export function documentDataDir() {
+    return resolve(process.env.PI_WEB_DATA_DIR ?? join(homedir(), ".pi-web"));
+}
+function readSettings() {
+    try {
+        const value = JSON.parse(readFileSync(join(documentDataDir(), "document-extensions.json"), "utf8"));
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            throw new Error("Expected an object");
+        return value;
+    }
+    catch (error) {
+        if (error.code === "ENOENT")
+            return {};
+        throw new Error(`Cannot read document-extensions.json: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+function validate(value) {
+    const result = { pdfEnabled: true, okfEnabled: true };
+    for (const key of ["pdfEnabled", "okfEnabled"]) {
+        if (value[key] !== undefined) {
+            if (typeof value[key] !== "boolean")
+                throw new Error(`${key} must be a boolean`);
+            result[key] = value[key];
+        }
+    }
+    for (const key of ["pythonPath", "runtimePath"]) {
+        const path = value[key];
+        if (path === undefined || path === "")
+            continue;
+        if (typeof path !== "string" || !isAbsolute(path) || /[\0\r\n]/.test(path))
+            throw new Error(`${key} must be an absolute filesystem path`);
+        result[key] = resolve(path);
+    }
+    return result;
+}
+/** Read on every invocation so already loaded sessions honor a global disable. */
+export function getDocumentSettings() {
+    return validate(readSettings());
+}
+export function updateDocumentSettings(patch) {
+    const saved = readSettings();
+    const next = validate({ ...saved, ...patch });
+    const output = { ...saved, ...next };
+    for (const key of ["pythonPath", "runtimePath"])
+        if (!next[key])
+            delete output[key];
+    const folder = documentDataDir();
+    mkdirSync(folder, { recursive: true });
+    const target = join(folder, "document-extensions.json");
+    const temporary = `${target}.${randomUUID()}.tmp`;
+    try {
+        writeFileSync(temporary, JSON.stringify(output, null, 2) + "\n", { mode: 0o600, flag: "wx" });
+        renameSync(temporary, target);
+    }
+    finally {
+        rmSync(temporary, { force: true });
+    }
+    return next;
+}

package/dist/server/extensions-worker.js

@@ -1,8 +1,9 @@
 import { DefaultPackageManager, SettingsManager, ProjectTrustStore } from "@earendil-works/pi-coding-agent";
 import { writeFileSync, mkdirSync, renameSync } from "node:fs";
-import { basename, join, relative } from "node:path";
+import { join, relative } from "node:path";
 import { createHash } from "node:crypto";
 import { readJson, textField, resourceTypes, sourceOf, sourceInfo, packageDisabled, settingsVersion } from "./extensions-model.js";
+import { extensionDisplay } from "./extension-display.js";
 import { gitOutput, latestNpmVersion } from "./component-updates.js";
 const blankResources = () => ({ extensions: [], skills: [], prompts: [], themes: [] });
 export async function extensionWork(input, progress = () => { }) {
@@ -55,7 +56,7 @@ export async function extensionWork(input, progress = () => { }) {
         for (const resource of resources.extensions) {
             if (resource.metadata.origin !== "top-level" || resource.path.startsWith("builtin:") || resource.metadata.scope === "temporary")
                 continue;
-            result.push({ id: `file:${resource.metadata.scope}:${resource.path}`, source: resource.path, name: basename(resource.path), scope: resource.metadata.scope, kind: "file", path: resource.path, enabled: resource.enabled, pinned: false, trusted: resource.metadata.scope === "user" || trusted, resources: blankResources() });
+            result.push({ id: `file:${resource.metadata.scope}:${resource.path}`, source: resource.path, ...extensionDisplay(resource.path), scope: resource.metadata.scope, kind: "file", path: resource.path, enabled: resource.enabled, pinned: false, trusted: resource.metadata.scope === "user" || trusted, resources: blankResources() });
         }
         return { packages: result, version: settingsVersion(cwd, agentDir), trusted };
     }

package/dist/server/files-service.js

@@ -117,7 +117,7 @@ export function isRealPathInWorkspace(root, abs) {
  * win32: stability and completeness first, preview second. ACL-protected
  * system dirs (C:\$Recycle.Bin, Program Files internals, OneDrive placeholders)
  * throw EPERM/EACCES on open — that must not kill the panel, so it degrades
- * to an empty listing plus a warning. Directory symlinks/junctions are
+ * to an empty listing with a node-local error. Directory symlinks/junctions are
  * followed so mklink /D folders stay navigable; broken links still show as
  * files instead of vanishing. The cap is 4x posix and truncation is reported
  * via `truncated` instead of happening silently.
@@ -132,11 +132,11 @@ async function readDirForUI(abs, rel) {
         dirents = await fs.readdir(abs, { withFileTypes: true });
     }
     catch (err) {
-        if (!IS_WIN32)
-            throw err;
-        // Windows ACL-protected/system dirs throw EPERM/EACCES on open —
-        // degrade to an empty listing; listFiles turns this into a warning.
-        return { entries: [], truncated: false, error: err.message };
+        const code = err.code;
+        return { entries: [], truncated: false, error: {
+                code: code === "ENOENT" ? "missing" : code === "ENOTDIR" ? "not_directory" : code === "EACCES" || code === "EPERM" ? "denied" : "unavailable",
+                message: err.message,
+            } };
     }
     const out = [];
     for (const d of dirents) {
@@ -225,15 +225,6 @@ export class FilesService {
         // always use "/", but relative() returns "\\" on Windows.
         const rel = rawRel.split(sep).join("/");
         const { entries, truncated, error } = await readDirForUI(target, rel);
-        if (error) {
-            // Windows-only: unreadable system dirs degrade to an empty list
-            // with a warning instead of a hard error — the panel stays usable.
-            this.host.emit({
-                type: "notice",
-                level: "warning",
-                text: `目录不可读：${error}`,
-            });
-        }
         this.host.emit({
             type: "files",
             cwd,
@@ -245,6 +236,7 @@ export class FilesService {
                     : "",
             entries,
             truncated,
+            ...(error ? { error } : {}),
         });
         // Watch the listed directory — deferred until AFTER the response is on
         // the wire. On win32, fs.watch(root, {recursive:true}) registering over
@@ -253,7 +245,7 @@ export class FilesService {
         // macOS's FSEvents); doing it inline before the emit made every
         // project switch wait on that registration instead of just seeing the
         // file list immediately and having the watcher arm a beat later.
-        if (cwd === this.host.getCwd())
+        if (!error && cwd === this.host.getCwd())
             this.watchDir(target, rel);
     }
     /**

package/dist/server/index.js

@@ -29,6 +29,7 @@ import { homedir } from "node:os";
 import { fileURLToPath } from "node:url";
 import { randomUUID } from "node:crypto";
 import express from "express";
+import { shutdownDocumentRuntime } from "./document-conversion/runtime.js";
 import compression from "compression";
 import { WebSocket, WebSocketServer } from "ws";
 import { VERSION, getAgentDir } from "@earendil-works/pi-coding-agent";
@@ -615,7 +616,7 @@ wss.on("connection", (ws) => {
             pending.push(msg);
             return;
         }
-        if (cs.switchingWorkspace && msg.type !== "set_cwd" && msg.type !== "get_state") {
+        if (cs.switchingWorkspace && msg.type !== "set_cwd" && msg.type !== "get_state" && msg.type !== "node_request") {
             if (msg.type === "prompt" && msg.requestId)
                 send({ type: "prompt_result", requestId: msg.requestId, ok: false });
             if (msg.type === "read_file" || msg.type === "write_file")
@@ -628,6 +629,10 @@ wss.on("connection", (ws) => {
         }
         switch (msg.type) {
             case "node_request":
+                if (service.quiesceInfo().quiesced && ["agent_start", "agent_prompt", "agent_new", "agent_model"].includes(msg.action)) {
+                    send({ type: "node_event", event: "failure", requestId: msg.requestId, nodeId: msg.nodeId, conversationId: msg.conversationId, data: { action: msg.action, message: "服务暂停接收新操作。" } });
+                    break;
+                }
                 void nodeWorkbench.handle(clientId, msg);
                 break;
             case "prompt":
@@ -754,7 +759,7 @@ wss.on("connection", (ws) => {
                 void cs.checkComponentUpdates(msg.requestId);
                 break;
             case "update_component":
-                if (service.quiesceInfo().quiesced || service.activeConversations() || service.pendingMessages()) {
+                if (service.quiesceInfo().quiesced || service.activeConversations() || nodeWorkbench.activeAgents() || service.pendingMessages()) {
                     send({ type: "component_updates", requestId: msg.requestId, cwd: cs.cwd, phase: "error", items: [], error: "请等待所有任务结束后再更新扩展" });
                 }
                 else {
@@ -1009,7 +1014,7 @@ httpServer.listen(PORT, HOST, () => {
 scheduleUploadCleanup();
 // Local control socket (status / quiesce / unquiesce) — same data dir the
 // CLI uses, so `pi-harness server status|quiesce|unquiesce` just works.
-const stopControl = startControlServer({ service, dataDir: DATA_DIR, port: PORT });
+const stopControl = startControlServer({ service, dataDir: DATA_DIR, port: PORT, additionalActiveConversations: () => nodeWorkbench.activeAgents() });
 let shuttingDown = false;
 async function shutdown() {
     if (shuttingDown)
@@ -1021,6 +1026,7 @@ async function shutdown() {
     nodeWorkbench.dispose();
     pluginMgr.dispose();
     await service.disposeAll();
+    await shutdownDocumentRuntime();
     wss.close();
     httpServer.close();
     process.exit(0);

package/dist/server/native-tools.js

@@ -1,4 +1,6 @@
 import { createPlanExtension } from "./plan/extension.js";
+import { createPdfMarkdownExtension } from "./document-conversion/extension.js";
+import { createOkfExtension } from "./okf/extension.js";
 import { SettingsManager, createCodemodeExtension, createMcpExtension, createToolSearchExtension } from "@earendil-works/pi-coding-agent";
 const runOverrides = new WeakMap();
 export function setConversationRunSettings(settings, values) {
@@ -21,6 +23,8 @@ export function conversationSettings(cwd, agentDir) {
 export function nativeToolExtensions() {
     return [
         { name: "pi-harness-plan", replaceable: true, factory: createPlanExtension() },
+        { name: "pi-harness-pdf-markdown", replaceable: true, factory: createPdfMarkdownExtension() },
+        { name: "pi-harness-okf", replaceable: true, factory: createOkfExtension() },
         { name: "codemode", builtin: true, replaceable: true, factory: createCodemodeExtension() },
         { name: "tool-search", builtin: true, replaceable: true, factory: createToolSearchExtension() },
         { name: "mcp", builtin: true, replaceable: true, factory: createMcpExtension() },