@youweichen/pi-harness 1.0.0 → 1.1.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2026 xing-shuyin
+Copyright (c) 2026 Youwei Chen
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

package/dist/server/agent-service.js

@@ -504,7 +504,7 @@ export class ClientSession {
      * (the model choice is client-wide), so later conversations reuse the
      * instance created with the first one.
      */
-    makeRuntimeFactory() {
+    makeRuntimeFactory(refreshResources = false, state) {
         return async ({ cwd, sessionManager }) => {
             const services = await createAgentSessionServices({
                 cwd,
@@ -513,7 +513,12 @@ export class ClientSession {
                 settingsManager: conversationSettings(cwd, this.agentDir),
                 resourceLoaderOptions: { extensionFactories: nativeToolExtensions() },
             });
-            const created = await createAgentSessionFromServices({ services, sessionManager });
+            // A second native reload invalidates the process-wide extension factory cache.
+            if (refreshResources) {
+                await services.resourceLoader.reload();
+                refreshResources = false;
+            }
+            const created = await createAgentSessionFromServices({ services, sessionManager, model: state?.model, thinkingLevel: state?.thinkingLevel });
             return { ...created, services, diagnostics: services.diagnostics };
         };
     }
@@ -1366,6 +1371,7 @@ export class ClientSession {
         cwd: () => this.cwd,
         getSession: () => this.session,
         startNewSession: () => this.startNewSession(),
+        restartSession: (conversationId) => this.restartSession(conversationId),
         treeCommand: async (name, args, context) => {
             const conv = this.conv;
             if (conv.id !== context.conversationId)
@@ -1523,13 +1529,17 @@ export class ClientSession {
             onAccepted?.(ok);
         };
         try {
+            if (this.restartingSession)
+                throw new Error("当前会话正在重启，请稍后重试。");
             if (!["tree", "fork"].includes(parseSlash(text)?.name ?? ""))
                 await conv.tree?.waitForVerification();
             const s = conv.session;
-            await flushPromptReload(s);
-            const promptReloadError = promptReloadStatus(s).reloadError;
-            if (promptReloadError)
-                throw new Error(`Native prompt reload failed: ${promptReloadError}`);
+            if (parseSlash(text)?.name !== "restart") {
+                await flushPromptReload(s);
+                const promptReloadError = promptReloadStatus(s).reloadError;
+                if (promptReloadError)
+                    throw new Error(`Native prompt reload failed: ${promptReloadError}`);
+            }
             if (this.conv !== conv || conv.session !== s)
                 throw new Error("Conversation changed");
             const extensionCommand = text.startsWith("/") && s.extensionRunner.getCommand(text.slice(1).split(" ", 1)[0]);
@@ -1841,8 +1851,59 @@ export class ClientSession {
             });
         }
     }
+    restartingSession = false;
+    /** Recreate only this conversation's native runtime; retain its exact branch and PTYs. */
+    async restartSession(conversationId) {
+        const conv = this.conv;
+        if (conv.id !== conversationId || this.switchingWorkspace || this.creatingConversation)
+            throw new Error("对话正在切换或重启，请稍后重试。");
+        if (this.quiesceBlocked())
+            throw new Error("服务暂停接收新操作。");
+        conv.tree?.assertWritable();
+        if (!conv.session.isIdle || isRecovering(conv.recovery))
+            throw new Error("请先停止当前任务，再重启会话。");
+        this.restartingSession = true;
+        let replacement;
+        try {
+            const previous = conv.runtime, model = conv.session.model, thinking = conv.session.thinkingLevel;
+            replacement = await createAgentSessionRuntime(this.makeRuntimeFactory(true, { model, thinkingLevel: thinking }), {
+                cwd: conv.cwd, agentDir: this.agentDir, sessionManager: conv.session.sessionManager,
+            });
+            if (this.disposed || this.conv !== conv)
+                throw new Error("对话已切换。");
+            await previous.dispose();
+            conv.unsubscribe?.();
+            conv.unsubscribe = undefined;
+            conv.tree?.dispose();
+            conv.tree = undefined;
+            conv.runtime = replacement;
+            replacement = undefined;
+            conv.recovery = {};
+            conv.treeProjectionRevision = undefined;
+            conv.uiMessageCache.clear();
+            conv.lastMessagesSig = "";
+            await this.bindSession(conv);
+            await this.pushSlashCommands();
+            this.pushSettings();
+            this.emitConversations();
+            this.flushSnapshot(true);
+            this.emit({ type: "notice", conversationId: conv.id, level: "info", text: "当前会话已重启，历史记录已保留。" });
+        }
+        finally {
+            try {
+                await replacement?.dispose();
+            }
+            finally {
+                this.restartingSession = false;
+            }
+        }
+    }
     /** /new delegates session creation and history persistence to the SDK; the Web slot is reused. */
     async startNewSession() {
+        if (this.restartingSession) {
+            this.emitNotice("warning", "当前会话正在重启，请稍后重试。");
+            return;
+        }
         if (this.conv.tree?.busy) {
             this.emitNotice("warning", "等待当前切换完成。");
             return;
@@ -1876,6 +1937,10 @@ export class ClientSession {
         void this.pushSlashCommands();
     }
     async newChat(fresh = false, wiki = false) {
+        if (this.restartingSession) {
+            this.emitNotice("warning", "当前会话正在重启，请稍后重试。");
+            return false;
+        }
         if (this.conv.tree?.busy) {
             this.emitNotice("warning", "等待当前切换完成。");
             return false;
@@ -2058,6 +2123,10 @@ export class ClientSession {
     }
     /** Switch the ACTIVE conversation without interrupting any other chat. */
     async switchConversation(id) {
+        if (this.restartingSession) {
+            this.emitNotice("warning", "当前会话正在重启，请稍后重试。");
+            return;
+        }
         if (this.conv.tree?.busy) {
             this.emitNotice("warning", "等待当前切换完成。");
             return;
@@ -2286,6 +2355,10 @@ export class ClientSession {
      * user opened history while it was streaming.
      */
     async switchSession(path) {
+        if (this.restartingSession) {
+            this.emitNotice("warning", "当前会话正在重启，请稍后重试。");
+            return;
+        }
         if (this.conv.tree?.busy) {
             this.emitNotice("warning", "等待当前切换完成。");
             return;
@@ -2553,8 +2626,15 @@ export class ClientSession {
     }
     cwdQueue = null;
     cwdSwitchRunning = false;
-    get switchingWorkspace() { return this.cwdSwitchRunning; }
+    get switchingWorkspace() { return this.cwdSwitchRunning || this.restartingSession; }
     async setCwd(path, id, source) {
+        if (this.restartingSession) {
+            if (id)
+                this.emit({ type: "cwd_result", requestId: id, cwd: this.cwd, ok: false, error: "当前会话正在重启，请稍后重试。" });
+            else
+                this.emitNotice("warning", "当前会话正在重启，请稍后重试。");
+            return;
+        }
         if (this.conv.tree?.busy) {
             this.emitNotice("warning", "等待当前切换完成。");
             return;

package/dist/server/control-socket.js

@@ -87,6 +87,7 @@ export function startControlServer(opts) {
                 switch (req.cmd) {
                     case "status":
                         resp = { ok: true, ...service.serviceStatus() };
+                        resp.activeConversations = (resp.activeConversations ?? 0) + (opts.additionalActiveConversations?.() ?? 0);
                         break;
                     case "quiesce":
                         service.quiesce();

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

@@ -615,7 +615,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 +628,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 +758,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 +1013,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)

package/dist/server/node-agent.js

@@ -0,0 +1,262 @@
+/** Native Pi RPC over one SSH exec channel. No local model or terminal injection. */
+import { randomUUID } from "node:crypto";
+import { StringDecoder } from "node:string_decoder";
+import { serializeMessage } from "./serialize.js";
+const MAX_RECORD = 16 * 1024 * 1024;
+const quote = (value) => `'${value.replace(/'/g, `'\\''`)}'`;
+export function nodeAgentCommand(cwd) {
+    if (!cwd.startsWith("/") || /[\0\r\n]/.test(cwd) || cwd.length > 4096)
+        throw new Error("Invalid remote working directory");
+    return `sh -lc ${quote(`cd ${quote(cwd)} && exec pi --mode rpc`)}`;
+}
+export class NodeAgent {
+    stream;
+    changed;
+    id = randomUUID();
+    buffer = "";
+    decoder = new StringDecoder("utf8");
+    stderr = "";
+    seq = 0;
+    revision = 0;
+    dialogTimers = new Map();
+    timer;
+    pending = new Map();
+    state;
+    constructor(stream, cwd, changed) {
+        this.stream = stream;
+        this.changed = changed;
+        this.state = { id: this.id, cwd, phase: "starting", running: false, messages: [], tools: [], models: [], dialogs: [] };
+        stream.on("data", (data) => this.receive(this.decoder.write(Buffer.isBuffer(data) ? data : Buffer.from(data))));
+        stream.stderr.on("data", data => { this.stderr = (this.stderr + data.toString()).slice(-8000); });
+        stream.on("error", (error) => this.finish(error.message));
+        stream.on("close", () => this.finish(this.stderr || "Remote Pi exited"));
+    }
+    get busy() { return this.state.phase !== "closed" && (this.state.phase === "starting" || this.state.running || this.pending.size > 0 || this.state.dialogs.length > 0); }
+    snapshot() { return this.state; }
+    publish(immediate = false) {
+        if (this.timer) {
+            if (!immediate)
+                return;
+            clearTimeout(this.timer);
+            this.timer = undefined;
+        }
+        if (immediate)
+            this.changed(this.state);
+        else
+            this.timer = setTimeout(() => { this.timer = undefined; this.changed(this.state); }, 60);
+    }
+    set(patch, immediate = false) { this.state = { ...this.state, ...patch }; this.publish(immediate); }
+    finish(error) {
+        if (this.state.phase === "closed")
+            return;
+        for (const task of this.pending.values()) {
+            clearTimeout(task.timer);
+            task.reject(new Error(error || "Remote Pi closed"));
+        }
+        this.pending.clear();
+        for (const timer of this.dialogTimers.values())
+            clearTimeout(timer);
+        this.dialogTimers.clear();
+        this.set({ phase: "closed", running: false, dialogs: [], error }, true);
+    }
+    close() {
+        this.finish();
+        try {
+            this.stream.signal("TERM");
+        }
+        catch { /* SSH may already be gone. */ }
+        this.stream.end();
+        this.stream.destroy();
+    }
+    receive(chunk) {
+        if (this.state.phase === "closed")
+            return;
+        this.buffer += chunk;
+        let index;
+        while ((index = this.buffer.indexOf("\n")) >= 0) {
+            const line = this.buffer.slice(0, index);
+            this.buffer = this.buffer.slice(index + 1);
+            if (line.length > MAX_RECORD) {
+                this.finish("Remote Pi response exceeds 16 MiB");
+                this.close();
+                return;
+            }
+            if (!line.trim())
+                continue;
+            try {
+                this.event(JSON.parse(line));
+            }
+            catch (error) {
+                this.finish(`Invalid remote Pi RPC response: ${error.message}`);
+                this.close();
+                return;
+            }
+        }
+        if (this.buffer.length > MAX_RECORD) {
+            this.finish("Remote Pi response exceeds 16 MiB");
+            this.close();
+        }
+    }
+    request(type, fields = {}) {
+        if (this.state.phase === "closed")
+            return Promise.reject(new Error("Remote Pi is not running"));
+        if (this.pending.size >= 32)
+            return Promise.reject(new Error("Too many pending remote commands"));
+        const id = randomUUID();
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => { this.pending.delete(id); reject(new Error(`Remote Pi ${type} timed out`)); }, 30000);
+            this.pending.set(id, { resolve, reject, timer });
+            try {
+                this.stream.write(JSON.stringify({ ...fields, id, type }) + "\n");
+            }
+            catch (error) {
+                clearTimeout(timer);
+                this.pending.delete(id);
+                reject(error);
+            }
+        });
+    }
+    async start() {
+        try {
+            await this.refresh();
+            const available = await this.request("get_available_models");
+            this.set({ phase: "ready", models: (available.models ?? []).map((m) => ({ id: String(m.id), provider: String(m.provider), name: String(m.name ?? m.id) })) }, true);
+        }
+        catch (error) {
+            this.finish(`${error.message}${this.stderr ? `\n${this.stderr}` : ""}`);
+            this.close();
+            throw error;
+        }
+    }
+    retainMessages(messages) {
+        let bytes = 0, start = messages.length;
+        while (start > 0 && messages.length - start < 200) {
+            const size = Buffer.byteLength(JSON.stringify(messages[start - 1]));
+            if (start < messages.length && bytes + size > 4 * 1024 * 1024)
+                break;
+            bytes += size;
+            start--;
+        }
+        return messages.slice(start);
+    }
+    async refresh() {
+        const revision = this.revision;
+        const state = await this.request("get_state");
+        if (typeof state.sessionId !== "string" || typeof state.isStreaming !== "boolean")
+            throw new Error("Remote Pi must support the native 1.0.4 RPC protocol");
+        const history = await this.request("get_messages");
+        const messages = (history.messages ?? []).slice(-200).map((m, index) => serializeMessage(m, index)).filter((m) => !!m);
+        if (this.revision !== revision)
+            return;
+        this.seq = messages.length;
+        this.set({ sessionId: state.sessionId, sessionFile: state.sessionFile, model: state.model ? { id: String(state.model.id), provider: String(state.model.provider), name: String(state.model.name ?? state.model.id) } : undefined, thinkingLevel: state.thinkingLevel, running: state.isStreaming || state.isCompacting, messages: this.retainMessages(messages) });
+    }
+    async prompt(text, queue) {
+        if (this.state.phase !== "ready")
+            throw new Error("Remote Pi is not ready");
+        if (!text.trim() || text.length > 200000)
+            throw new Error("Invalid remote prompt");
+        this.set({ error: undefined });
+        await this.request("prompt", { message: text, ...(queue ? { streamingBehavior: queue } : {}) });
+    }
+    async abort() { await this.request("abort"); }
+    async newSession() {
+        if (this.state.running || this.state.dialogs.length)
+            throw new Error("Stop the remote task first");
+        const result = await this.request("new_session");
+        if (result.cancelled)
+            return;
+        this.set({ tools: [], streamingMessage: undefined });
+        await this.refresh();
+    }
+    async model(provider, modelId) {
+        if (this.state.running)
+            throw new Error("Stop the remote task first");
+        if (!this.state.models.some(m => m.id === modelId && m.provider === provider))
+            throw new Error("Unknown remote model");
+        await this.request("set_model", { provider, modelId });
+        await this.refresh();
+    }
+    dialog(id, response) {
+        const dialog = this.state.dialogs.find(d => d.id === id);
+        if (!dialog)
+            throw new Error("Remote dialog expired");
+        if (!response.cancelled && dialog.method === "select" && !dialog.options?.includes(response.value ?? ""))
+            throw new Error("Invalid remote selection");
+        if (response.value && response.value.length > 200000)
+            throw new Error("Remote response too large");
+        clearTimeout(this.dialogTimers.get(id));
+        this.dialogTimers.delete(id);
+        this.stream.write(JSON.stringify({ type: "extension_ui_response", id, ...response }) + "\n");
+        this.set({ dialogs: this.state.dialogs.filter(d => d.id !== id) });
+    }
+    event(event) {
+        if (!event || typeof event.type !== "string")
+            throw new Error("Missing RPC record type");
+        if (event.type === "response") {
+            const task = this.pending.get(event.id);
+            if (!task)
+                return;
+            clearTimeout(task.timer);
+            this.pending.delete(event.id);
+            if (event.success)
+                task.resolve(event.data ?? {});
+            else
+                task.reject(new Error(String(event.error ?? "Remote Pi command failed")));
+            return;
+        }
+        if (["agent_start", "compaction_start", "auto_retry_start"].includes(event.type)) {
+            this.revision++;
+            this.set({ running: true, error: undefined, tools: [] });
+        }
+        if (event.type === "agent_settled") {
+            this.set({ running: false });
+            void this.refresh().catch(error => this.set({ error: error.message }));
+        }
+        if (event.type === "message_start" && event.message?.role === "assistant")
+            this.set({ streamingMessage: serializeMessage(event.message, this.seq) ?? undefined });
+        if (event.type === "message_update") {
+            const delta = event.assistantMessageEvent, current = this.state.streamingMessage;
+            if (!current || !delta || !Number.isInteger(delta.contentIndex) || delta.contentIndex < 0 || delta.contentIndex > 4096)
+                return;
+            const content = [...current.content], index = delta.contentIndex, previous = content[index];
+            if (delta.type === "text_delta")
+                content[index] = { type: "text", text: (String(previous && "text" in previous ? previous.text ?? "" : "") + String(delta.delta ?? "")).slice(-200000) };
+            else if (delta.type === "thinking_delta")
+                content[index] = { type: "thinking", thinking: (String(previous && "thinking" in previous ? previous.thinking ?? "" : "") + String(delta.delta ?? "")).slice(-200000) };
+            else if (delta.type === "toolcall_start")
+                content[index] = { type: "toolCall", id: String(delta.id), name: String(delta.toolName), argumentsText: "" };
+            else if (delta.type === "toolcall_delta" && previous?.type === "toolCall")
+                content[index] = { ...previous, argumentsText: (String(previous.argumentsText ?? "") + String(delta.delta ?? "")).slice(0, 20000) };
+            else
+                return;
+            this.set({ streamingMessage: { ...current, content: content.filter(Boolean) } });
+        }
+        if (event.type === "message_end") {
+            this.revision++;
+            const message = serializeMessage(event.message, this.seq++);
+            if (message)
+                this.set({ messages: this.retainMessages([...this.state.messages, message]), ...(event.message.role === "assistant" ? { streamingMessage: undefined } : {}) });
+        }
+        if (event.type === "tool_execution_start" || event.type === "tool_execution_end") {
+            const tools = this.state.tools.filter(t => t.id !== event.toolCallId);
+            tools.push({ id: String(event.toolCallId), name: String(event.toolName), running: event.type === "tool_execution_start", isError: !!event.isError });
+            this.set({ tools: tools.slice(-256) });
+        }
+        if (event.type === "extension_ui_request") {
+            if (["select", "confirm", "input", "editor"].includes(event.method)) {
+                if (this.state.dialogs.length >= 32) {
+                    this.stream.write(JSON.stringify({ type: "extension_ui_response", id: event.id, cancelled: true }) + "\n");
+                    return;
+                }
+                if (typeof event.timeout === "number" && event.timeout >= 0 && event.timeout <= 2147483647)
+                    this.dialogTimers.set(String(event.id), setTimeout(() => { this.dialogTimers.delete(String(event.id)); this.set({ dialogs: this.state.dialogs.filter(d => d.id !== event.id) }); }, event.timeout));
+                this.set({ dialogs: [...this.state.dialogs, { id: String(event.id), method: event.method, title: String(event.title ?? ""), message: String(event.message ?? ""), options: Array.isArray(event.options) ? event.options.map(String) : undefined, prefill: typeof event.prefill === "string" ? event.prefill : undefined }] }, true);
+            }
+            if (event.method === "notify")
+                this.set({ notice: String(event.message ?? "").slice(0, 8000) });
+            if (event.method === "set_editor_text")
+                this.set({ editorText: { id: String(event.id), text: String(event.text ?? "").slice(0, 200000) } });
+        }
+    }
+}

package/dist/server/node-workbench.js

@@ -1,4 +1,5 @@
 /** Built-in SSH node workbench. All remote operations are scoped by node and client. */
+import { NodeAgent, nodeAgentCommand } from "./node-agent.js";
 import { execFile } from "node:child_process";
 import { randomUUID, createHash } from "node:crypto";
 import { readFileSync, writeFileSync, mkdirSync, renameSync } from "node:fs";
@@ -68,8 +69,9 @@ export class NodeWorkbench {
         for (const sink of this.sinks.get(clientId) ?? [])
             sink(msg);
     }
+    activeAgents() { return [...this.connections.values()].filter(connection => connection.agentStarting || connection.agent?.busy).length; }
     state(clientId) {
-        return { sources: this.sources, nodes: this.nodes.map((node) => ({ ...node, auth: node.localAuth ?? node.auth, unsupported: unsupportedOptions(node), hasSecret: this.secrets.has(`node:${node.id}:secret`) || this.transientSecrets.has(identity(clientId, node.id)), fingerprint: node.fingerprint })), connections: [...this.connections.values()].filter((c) => c.clientId === clientId).map((c) => ({ nodeId: c.nodeId, connectedAt: c.connectedAt, latencyMs: c.connectedAt ? c.connectedAt - c.startedAt : undefined, status: c.ready ? "connected" : "connecting", terminals: [...c.terminals.values()].map((t) => ({ id: t.id, conversationId: t.conversationId, busy: t.busy, output: t.buffer })) })) };
+        return { sources: this.sources, nodes: this.nodes.map((node) => ({ ...node, auth: node.localAuth ?? node.auth, unsupported: unsupportedOptions(node), hasSecret: this.secrets.has(`node:${node.id}:secret`) || this.transientSecrets.has(identity(clientId, node.id)), fingerprint: node.fingerprint })), connections: [...this.connections.values()].filter((c) => c.clientId === clientId).map((c) => ({ nodeId: c.nodeId, connectedAt: c.connectedAt, latencyMs: c.connectedAt ? c.connectedAt - c.startedAt : undefined, status: c.ready ? "connected" : "connecting", agent: c.agent?.snapshot(), terminals: [...c.terminals.values()].map((t) => ({ id: t.id, conversationId: t.conversationId, busy: t.busy, output: t.buffer })) })) };
     }
     attach(clientId, sink) {
         let set = this.sinks.get(clientId);
@@ -93,6 +95,43 @@ export class NodeWorkbench {
             throw new Error("终端身份已过期");
         return t;
     }
+    agent(clientId, req) {
+        const agent = this.connection(clientId, req.nodeId).agent;
+        if (!agent || agent.id !== req.conversationId)
+            throw new Error("远端 Agent 会话身份已过期");
+        return agent;
+    }
+    async startAgent(clientId, req) {
+        const connection = this.connection(clientId, req.nodeId);
+        if (connection.agentStarting)
+            throw new Error("远端 Agent 正在启动");
+        if (connection.agent && connection.agent.snapshot().phase !== "closed")
+            return connection.agent.snapshot();
+        const cwd = safePath(req.payload?.cwd ?? this.node(req.nodeId).defaultDir);
+        connection.agentStarting = true;
+        try {
+            const stream = await new Promise((resolve, reject) => connection.client.exec(nodeAgentCommand(cwd), (error, stream) => error ? reject(error) : resolve(stream)));
+            try {
+                this.ensureCurrent(connection);
+            }
+            catch (error) {
+                stream.signal("TERM");
+                stream.end();
+                throw error;
+            }
+            const agent = new NodeAgent(stream, cwd, state => {
+                if (connection.agent?.id === state.id && this.connections.get(identity(clientId, connection.nodeId)) === connection)
+                    this.emit(clientId, "agent_state", { agent: state }, { nodeId: connection.nodeId, conversationId: state.id });
+            });
+            connection.agent = agent;
+            this.broadcastState();
+            await agent.start();
+            return agent.snapshot();
+        }
+        finally {
+            connection.agentStarting = false;
+        }
+    }
     async handle(clientId, req) {
         try {
             const p = req.payload ?? {};
@@ -308,6 +347,27 @@ export class NodeWorkbench {
                 case "disconnect":
                     this.disconnect(clientId, req.nodeId);
                     break;
+                case "agent_start":
+                    result = { agent: await this.startAgent(clientId, req) };
+                    break;
+                case "agent_prompt":
+                    await this.agent(clientId, req).prompt(field(p.text, "消息", 200000), p.queue === "steer" || p.queue === "followUp" ? p.queue : undefined);
+                    break;
+                case "agent_abort":
+                    await this.agent(clientId, req).abort();
+                    break;
+                case "agent_new":
+                    await this.agent(clientId, req).newSession();
+                    break;
+                case "agent_model":
+                    await this.agent(clientId, req).model(field(p.provider, "服务商"), field(p.modelId, "模型"));
+                    break;
+                case "agent_close":
+                    this.agent(clientId, req).close();
+                    break;
+                case "agent_dialog":
+                    this.agent(clientId, req).dialog(field(p.id, "对话框"), { cancelled: p.cancelled === true, confirmed: p.confirmed === true, value: typeof p.value === "string" ? p.value : undefined });
+                    break;
                 case "terminal_open":
                     result = await this.openTerminal(clientId, req);
                     break;
@@ -549,6 +609,7 @@ export class NodeWorkbench {
             t.pending?.reject(new Error("SSH 已断开"));
             this.emit(c.clientId, "terminal_exit", {}, { nodeId: c.nodeId, terminalId: t.id, conversationId: t.conversationId });
         }
+        c.agent?.close();
         c.terminals.clear();
         c.client.end();
         this.broadcastState();