@xyit/wellspring 0.0.0-stage → 1.1.0

package/dist/sandbox/plugin-host.js

@@ -0,0 +1,1001 @@
+/*
+ * sandbox 插件进程入口。
+ * 由宿主通过 bwrap/direct backend 启动；stdio 上跑 frame 协议，插件代码只通过 bridge 访问宿主。
+ */
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { Readable } from "node:stream";
+import { pathToFileURL } from "node:url";
+import { emitAfterStep, emitAfterTurn, emitAgentAsyncTaskComplete, emitAgentAsk, emitAgentCallTool, emitAgentQueryTask, emitAgentRead, emitAgentRequestPermission, emitAgentRunAsync, emitAgentRunSync, emitAgentSetGoal, emitAgentSetTasks, emitAgentSubmit, emitBeforeStep, emitBeforeTurn, emitInitHooks, emitOnMessage, emitSessionStart, emitShutdownHooks, emitUserAnswer, listHookKinds, withHookOwner, } from "../api/host/hooks.js";
+import { eventBus } from "../event/event.js";
+import { ensureAccessGuard } from "../plugin/access-guard.js";
+import { ensureHostAlias } from "../plugin/host-alias.js";
+import { setHostBridge } from "./bridge-state.js";
+import { FrameDecoder, encodeMessage, nextRequestId, } from "./protocol.js";
+import { RPC_TIMEOUT_MS } from "./rpc-timeouts.js";
+const rawStdoutWrite = process.stdout.write.bind(process.stdout);
+const rawStderrWrite = process.stderr.write.bind(process.stderr);
+function writeFrame(message) {
+    rawStdoutWrite(encodeMessage(message));
+}
+const pending = new Map();
+function bridgeRequest(method, params, timeoutMs = RPC_TIMEOUT_MS.default) {
+    const id = nextRequestId("child");
+    return new Promise((resolveRequest, rejectRequest) => {
+        // timeoutMs 为 null 时不挂定时器：长任务 RPC（例如 agent.stream）由运行过程自身结束
+        const timer = timeoutMs === null
+            ? null
+            : setTimeout(() => {
+                pending.delete(id);
+                rejectRequest(new Error(`host RPC 超时：${method}`));
+            }, timeoutMs);
+        timer?.unref();
+        const clearTimer = () => {
+            if (timer !== null) {
+                clearTimeout(timer);
+            }
+        };
+        pending.set(id, {
+            resolve: (value) => {
+                clearTimer();
+                resolveRequest(value);
+            },
+            reject: (error) => {
+                clearTimer();
+                rejectRequest(error);
+            },
+            timer,
+        });
+        writeFrame({
+            v: 1,
+            type: "request",
+            id,
+            method,
+            params,
+            ...(timeoutMs === null ? {} : { timeoutMs }),
+        });
+    });
+}
+function bridgeNotify(method, params) {
+    writeFrame({ v: 1, type: "event", method, params });
+}
+let hostSnapshot = null;
+const bridge = {
+    request: bridgeRequest,
+    notify: bridgeNotify,
+    getHostSnapshot: () => {
+        if (hostSnapshot === null) {
+            throw new Error("插件未获得 getHost 权限");
+        }
+        return hostSnapshot;
+    },
+    shutdown: () => {
+        void bridgeRequest("host.shutdown", {}).catch(() => undefined);
+    },
+};
+setHostBridge(bridge);
+ensureHostAlias();
+ensureAccessGuard();
+const HOOK_API_NAME = {
+    message: "onMessage",
+    sessionStart: "onSessionStart",
+    beforeTurn: "beforeTurn",
+    beforeStep: "beforeStep",
+    afterStep: "afterStep",
+    afterTurn: "afterTurn",
+    agentRunSync: "onAgentRunSync",
+    agentRunAsync: "onAgentRunAsync",
+    agentAsyncTaskComplete: "onAgentAsyncTaskComplete",
+    agentCallTool: "onAgentCallTool",
+    agentAsk: "onAgentAsk",
+    agentRead: "onAgentRead",
+    agentQueryTask: "onAgentQueryTask",
+    agentSubmit: "onAgentSubmit",
+    agentSetTasks: "onAgentSetTasks",
+    agentSetGoal: "onAgentSetGoal",
+    agentRequestPermission: "onAgentRequestPermission",
+    userAnswer: "onUserAnswer",
+    init: "onInit",
+    shutdown: "onShutdown",
+};
+let runtime = null;
+const httpHandlers = new Map();
+const agentStreamHandlers = new Map();
+const websocketHandlers = new Map();
+const wsMessages = new Map();
+const wsCloses = new Map();
+function remoteExec() {
+    return {
+        async run(options) {
+            return (await bridgeRequest("host.exec.run", {
+                command: options.command,
+                cwd: options.cwd,
+                env: options.env ?? {},
+                timeoutMs: options.timeoutMs,
+            }));
+        },
+        async poll(sessionId) {
+            return (await bridgeRequest("host.exec.poll", { sessionId }));
+        },
+        async stop(sessionId) {
+            await bridgeRequest("host.exec.stop", { sessionId });
+        },
+    };
+}
+function remotePty() {
+    return {
+        async available() {
+            const result = (await bridgeRequest("host.pty.available", {}));
+            const backend = result.backend === "node-pty" || result.backend === "python-pty"
+                ? result.backend
+                : undefined;
+            return {
+                available: result.available === true,
+                backend,
+                reason: typeof result.reason === "string" ? result.reason : undefined,
+            };
+        },
+        async spawn(options) {
+            return (await bridgeRequest("host.pty.spawn", {
+                file: options.file ?? "",
+                args: options.args ?? [],
+                cwd: options.cwd,
+                env: options.env ?? {},
+                cols: options.cols,
+                rows: options.rows,
+            }));
+        },
+        async poll(sessionId) {
+            return (await bridgeRequest("host.pty.poll", { sessionId }));
+        },
+        async write(sessionId, data) {
+            await bridgeRequest("host.pty.write", { sessionId, data });
+        },
+        async resize(sessionId, cols, rows) {
+            await bridgeRequest("host.pty.resize", { sessionId, cols, rows });
+        },
+        async kill(sessionId) {
+            await bridgeRequest("host.pty.kill", { sessionId });
+        },
+    };
+}
+function remoteAgent() {
+    return {
+        async chat(input) {
+            return await bridgeRequest("host.agent.chat", input, RPC_TIMEOUT_MS.agentChat);
+        },
+        async stream(input, onEvent) {
+            const streamId = nextRequestId("agent-stream");
+            agentStreamHandlers.set(streamId, onEvent);
+            try {
+                // 一轮 Agent 可能跑很久（多步工具调用），不设 RPC 上限
+                return await bridgeRequest("host.agent.stream", { streamId, input }, RPC_TIMEOUT_MS.agentStream);
+            }
+            finally {
+                agentStreamHandlers.delete(streamId);
+            }
+        },
+        async validateWorkspace(path) {
+            return (await bridgeRequest("host.agent.validateWorkspace", {
+                path,
+            }));
+        },
+        async pickDirectory() {
+            return (await bridgeRequest("host.agent.pickDirectory", {}));
+        },
+        async searchWorkspaceFiles(root, query) {
+            return (await bridgeRequest("host.agent.searchWorkspaceFiles", {
+                root,
+                query,
+            }));
+        },
+        async interject(sessionId, message) {
+            return (await bridgeRequest("host.agent.interject", {
+                sessionId,
+                message,
+            }));
+        },
+        async stop(sessionId) {
+            return (await bridgeRequest("host.agent.stop", { sessionId }));
+        },
+        async respondApproval(approvalId, approved) {
+            return (await bridgeRequest("host.agent.respondApproval", {
+                approvalId,
+                approved,
+            }));
+        },
+        async respondAsk(askId, answer) {
+            return (await bridgeRequest("host.agent.respondAsk", {
+                askId,
+                answer,
+            }));
+        },
+    };
+}
+function remoteModels() {
+    return {
+        async state() {
+            return (await bridgeRequest("host.models.state", {}));
+        },
+        async setActive(providerId, model, reasoning) {
+            return (await bridgeRequest("host.models.setActive", {
+                providerId,
+                model,
+                reasoning,
+            }));
+        },
+        async saveProvider(input) {
+            return (await bridgeRequest("host.models.saveProvider", input));
+        },
+        async removeProvider(id) {
+            return (await bridgeRequest("host.models.removeProvider", {
+                id,
+            }));
+        },
+        async fetchModels(id, apiKey) {
+            const payload = { id };
+            if (apiKey !== undefined) {
+                payload["apiKey"] = apiKey;
+            }
+            return (await bridgeRequest("host.models.fetchModels", payload, RPC_TIMEOUT_MS.modelsFetch));
+        },
+        async saveKey(id, apiKey) {
+            return (await bridgeRequest("host.models.saveKey", {
+                id,
+                apiKey,
+            }));
+        },
+        async clearKey(id) {
+            return (await bridgeRequest("host.models.clearKey", { id }));
+        },
+    };
+}
+function remoteNetwork() {
+    return {
+        async state() {
+            return (await bridgeRequest("host.network.state", {}));
+        },
+        async saveProxy(input) {
+            return (await bridgeRequest("host.network.saveProxy", input));
+        },
+    };
+}
+function remotePlugins() {
+    return {
+        async list() {
+            return (await bridgeRequest("host.plugins.list", {}));
+        },
+        async install(input) {
+            return (await bridgeRequest("host.plugins.install", input, RPC_TIMEOUT_MS.pluginsInstall));
+        },
+        async remove(id) {
+            return (await bridgeRequest("host.plugins.remove", { id }));
+        },
+        async enable(id) {
+            return (await bridgeRequest("host.plugins.enable", { id }));
+        },
+        async disable(id) {
+            return (await bridgeRequest("host.plugins.disable", { id }));
+        },
+    };
+}
+function remoteWorkspaces() {
+    return {
+        async list() {
+            return (await bridgeRequest("host.workspaces.list", {}));
+        },
+        async add(input) {
+            return (await bridgeRequest("host.workspaces.add", input));
+        },
+        async remove(id) {
+            return (await bridgeRequest("host.workspaces.remove", {
+                id,
+            }));
+        },
+        async rename(id, name) {
+            return (await bridgeRequest("host.workspaces.rename", {
+                id,
+                name,
+            }));
+        },
+        async touch(id) {
+            return (await bridgeRequest("host.workspaces.touch", {
+                id,
+            }));
+        },
+    };
+}
+function remoteHttp() {
+    return {
+        async createServer(options, handler) {
+            const serverId = nextRequestId("http");
+            httpHandlers.set(serverId, handler);
+            if (typeof options.websocket === "function") {
+                websocketHandlers.set(serverId, options.websocket);
+            }
+            try {
+                const ready = (await bridgeRequest("host.http.createServer", {
+                    serverId,
+                    host: options.host,
+                    port: options.port,
+                    tls: options.tls,
+                    websocket: typeof options.websocket === "function",
+                }));
+                return {
+                    serverId: ready.serverId,
+                    host: ready.host,
+                    port: ready.port,
+                    async close() {
+                        httpHandlers.delete(serverId);
+                        await bridgeRequest("host.http.closeServer", { serverId });
+                    },
+                };
+            }
+            catch (error) {
+                httpHandlers.delete(serverId);
+                throw error;
+            }
+        },
+    };
+}
+function isObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validatePlugin(value) {
+    if (!isObject(value)) {
+        throw new Error("setup() 必须返回 WellspringPlugin 对象");
+    }
+    const id = value["id"];
+    const name = value["name"];
+    const version = value["version"];
+    const status = value["status"];
+    if (typeof id !== "string" || !/^[A-Za-z0-9][A-Za-z0-9._-]{0,63}$/.test(id)) {
+        throw new Error(`插件 id 不合法：${String(id)}`);
+    }
+    if (typeof name !== "string" || name.trim() === "") {
+        throw new Error(`插件 name 不合法：${String(name)}`);
+    }
+    if (typeof version !== "string" || version.trim() === "") {
+        throw new Error(`插件 version 不合法：${String(version)}`);
+    }
+    if (status !== "ok" && status !== "failed") {
+        throw new Error(`插件 status 必须是 ok / failed：${String(status)}`);
+    }
+    return value;
+}
+function createLogger() {
+    const make = (bindings = {}) => {
+        const log = (level) => (first, second) => {
+            const fields = isObject(first) ? first : bindings;
+            const message = isObject(first) ? String(second ?? "") : String(first ?? "");
+            bridgeNotify("host.log", { level, message, fields });
+        };
+        const logger = {
+            trace: log("trace"),
+            debug: log("debug"),
+            info: log("info"),
+            warn: log("warn"),
+            error: log("error"),
+            fatal: log("fatal"),
+            child: (childBindings) => make({ ...bindings, ...childBindings }),
+        };
+        return logger;
+    };
+    return make();
+}
+const logger = createLogger();
+const output = {
+    info: (text) => bridgeNotify("host.output", { kind: "info", text }),
+    warn: (text) => bridgeNotify("host.output", { kind: "warn", text }),
+    error: (text) => bridgeNotify("host.output", { kind: "error", text }),
+    print: (text = "") => bridgeNotify("host.output", { kind: "print", text }),
+};
+function createFileApi(scope) {
+    const call = (method, params = {}) => bridgeRequest(`host.${scope}.${method}`, params);
+    return {
+        root: scope,
+        async readText(path) {
+            const result = (await call("readText", { path }));
+            return result.text;
+        },
+        async readBytes(path) {
+            const result = (await call("readBytes", { path }));
+            if (result.data === null) {
+                return null;
+            }
+            return new Uint8Array(Buffer.from(result.data, "base64"));
+        },
+        async readJson(path) {
+            const result = (await call("readJson", { path }));
+            return result.value;
+        },
+        async writeText(path, text) {
+            await call("writeText", { path, text });
+        },
+        async writeBytes(path, bytes) {
+            await call("writeBytes", {
+                path,
+                data: Buffer.from(bytes).toString("base64"),
+            });
+        },
+        async writeJson(path, value) {
+            await call("writeJson", { path, value });
+        },
+        async list(path = "") {
+            const result = (await call("list", { path }));
+            return result.entries;
+        },
+        async stat(path) {
+            const result = (await call("stat", { path }));
+            return result.stat;
+        },
+        async mkdir(path) {
+            await call("mkdir", { path });
+        },
+        async remove(path) {
+            await call("remove", { path });
+        },
+        async exists(path) {
+            const result = (await call("exists", { path }));
+            return result.exists;
+        },
+    };
+}
+function patchConsole() {
+    const methods = [
+        ["log", "info"],
+        ["info", "info"],
+        ["debug", "debug"],
+        ["warn", "warn"],
+        ["error", "error"],
+        ["trace", "trace"],
+        ["dir", "info"],
+        ["table", "info"],
+    ];
+    for (const [method, level] of methods) {
+        ;
+        console[method] = (...args) => {
+            bridgeNotify("host.console", { level, args: args.map((item) => String(item)) });
+        };
+    }
+    console.assert = (condition, ...args) => {
+        if (!condition) {
+            bridgeNotify("host.console", { level: "error", args: args.map(String) });
+        }
+    };
+}
+function patchProcessStreams() {
+    process.stdout.write = ((chunk) => {
+        bridgeNotify("host.log", { level: "info", message: String(chunk), fields: {} });
+        return true;
+    });
+    process.stderr.write = ((chunk) => {
+        bridgeNotify("host.log", { level: "error", message: String(chunk), fields: {} });
+        return true;
+    });
+}
+function remotePluginData(targetId) {
+    const call = async (method, args) => await bridgeRequest("host.pluginData", { targetId, method, args });
+    return {
+        root: "",
+        async readText(path) {
+            return (await call("readText", [path]));
+        },
+        async readBytes(path) {
+            const value = (await call("readBytes", [path]));
+            return value === null ? null : Uint8Array.from(value);
+        },
+        async readJson(path) {
+            return (await call("readJson", [path]));
+        },
+        async writeText(path, text) {
+            await call("writeText", [path, text]);
+        },
+        async writeBytes(path, bytes) {
+            await call("writeBytes", [path, [...bytes]]);
+        },
+        async writeJson(path, value) {
+            await call("writeJson", [path, value]);
+        },
+        async list(path = "") {
+            return (await call("list", [path]));
+        },
+        async stat(path) {
+            return (await call("stat", [path]));
+        },
+        async mkdir(path) {
+            await call("mkdir", [path]);
+        },
+        async remove(path) {
+            await call("remove", [path]);
+        },
+        async exists(path) {
+            return (await call("exists", [path]));
+        },
+    };
+}
+async function bootstrap(params) {
+    const hostData = params.host;
+    hostSnapshot =
+        hostData === null
+            ? null
+            : {
+                getStatus: () => hostData.status,
+                getOS: () => hostData.os,
+                getPaths: () => hostData.paths,
+                getPlugins: () => hostData.plugins.map((plugin) => ({
+                    id: plugin.id,
+                    name: plugin.name,
+                    version: plugin.version,
+                    deps: plugin.deps,
+                    commands: plugin.commands,
+                    getStatus: () => plugin.status,
+                })),
+            };
+    const pluginId = params.pluginId;
+    const commands = [];
+    const agentTools = [];
+    const api = {
+        apiVersion: 1,
+        plugin: { id: pluginId, name: params.pluginName, version: params.pluginVersion },
+        paths: params.paths,
+        config: params.config,
+        logger,
+        output,
+        pluginDataDir: params.pluginDataDir,
+        pluginConfig: params.pluginConfig,
+        fs: createFileApi("fs"),
+        workspaceFs: createFileApi("workspaceFs"),
+        registerCommand: (command) => {
+            commands.push(command);
+        },
+        registerAgentTool: (tool) => {
+            agentTools.push(tool);
+        },
+        pluginData: async (targetId) => {
+            return remotePluginData(targetId);
+        },
+        capabilities: {
+            async executeCode(input) {
+                // 沙箱自己的命令超时最长 600s，RPC 用更长的上限，避免宿主先放弃等待
+                return await bridgeRequest("host.capabilities.executeCode", input, RPC_TIMEOUT_MS.sandboxExec);
+            },
+            async startBackgroundCode(input) {
+                return await bridgeRequest("host.capabilities.startBackgroundCode", input);
+            },
+            async queryTask(taskId) {
+                return await bridgeRequest("host.capabilities.queryTask", { taskId });
+            },
+            async stopTask(taskId, mode) {
+                return await bridgeRequest("host.capabilities.stopTask", { taskId, mode });
+            },
+            async webSearch(query, count) {
+                return await bridgeRequest("host.capabilities.webSearch", { query, count });
+            },
+            async webFetch(url) {
+                return await bridgeRequest("host.capabilities.webFetch", { url });
+            },
+        },
+        http: remoteHttp(),
+        agent: remoteAgent(),
+        models: remoteModels(),
+        network: remoteNetwork(),
+        plugins: remotePlugins(),
+        workspaces: remoteWorkspaces(),
+        exec: remoteExec(),
+        pty: remotePty(),
+    };
+    const module = (await withHookOwner(pluginId, async () => {
+        return (await import(__rewriteRelativeImportExtension(pathToFileURL(params.pluginEntry).href)));
+    }));
+    if (typeof module.setup !== "function") {
+        throw new Error("入口需要导出 setup() 函数");
+    }
+    let created = null;
+    await withHookOwner(pluginId, async () => {
+        created = validatePlugin(await module.setup());
+        if (created.status !== "ok") {
+            throw new Error(`插件自报状态：${created.status}`);
+        }
+        commands.push(...(created.commands ?? []));
+        agentTools.push(...(created.agentTools ?? []));
+    });
+    if (created === null) {
+        throw new Error("插件未初始化");
+    }
+    const plugin = created;
+    const current = {
+        owner: pluginId,
+        plugin,
+        commands,
+        agentTools,
+        hooks: listHookKinds(pluginId),
+        api,
+        initialized: false,
+    };
+    runtime = current;
+    if (params.deferInit !== true) {
+        await initializeRuntime(current);
+    }
+    return readyOf(current);
+}
+async function initializeRuntime(current) {
+    if (current.initialized) {
+        return;
+    }
+    await withHookOwner(current.owner, async () => {
+        await current.plugin.init?.(current.api);
+    });
+    for (const tool of current.agentTools) {
+        if (typeof tool.name !== "string" || typeof tool.call !== "function") {
+            throw new Error("Agent 工具缺少 name / call");
+        }
+    }
+    current.initialized = true;
+    current.hooks = listHookKinds(current.owner);
+}
+function readyOf(current) {
+    return {
+        plugin: {
+            id: current.plugin.id,
+            name: current.plugin.name,
+            version: current.plugin.version,
+            status: current.plugin.status,
+            deps: [...(current.plugin.deps ?? [])],
+        },
+        commands: current.commands.map((command) => ({
+            name: command.name,
+            summary: command.summary,
+            usage: command.usage,
+            aliases: command.aliases,
+        })),
+        agentTools: current.agentTools.map((tool) => ({
+            name: tool.name,
+            introduction: {
+                params: { ...tool.introduction.params },
+                content: tool.introduction.content,
+            },
+        })),
+        hooks: current.hooks.map((kind) => HOOK_API_NAME[kind]),
+    };
+}
+async function dispatchHook(name, payload) {
+    switch (name) {
+        case "onMessage":
+            await emitOnMessage(payload);
+            return { prompt: payload["prompt"] ?? [] };
+        case "onSessionStart":
+            await emitSessionStart(payload);
+            return { prompt: payload["prompt"] ?? [] };
+        case "beforeTurn":
+            await emitBeforeTurn(payload);
+            return {};
+        case "beforeStep":
+            await emitBeforeStep(payload);
+            return {};
+        case "afterStep":
+            await emitAfterStep(payload);
+            return {};
+        case "afterTurn":
+            await emitAfterTurn(payload);
+            return {};
+        case "onAgentRunSync":
+            await emitAgentRunSync(payload);
+            return {};
+        case "onAgentRunAsync":
+            await emitAgentRunAsync(payload);
+            return {};
+        case "onAgentAsyncTaskComplete":
+            await emitAgentAsyncTaskComplete(payload);
+            return {};
+        case "onAgentCallTool":
+            await emitAgentCallTool(payload);
+            return {};
+        case "onAgentAsk":
+            await emitAgentAsk(payload);
+            return {};
+        case "onAgentRead":
+            await emitAgentRead(payload);
+            return {};
+        case "onAgentQueryTask":
+            await emitAgentQueryTask(payload);
+            return {};
+        case "onAgentSubmit":
+            await emitAgentSubmit(payload);
+            return {};
+        case "onAgentSetTasks":
+            await emitAgentSetTasks(payload);
+            return {};
+        case "onAgentSetGoal":
+            await emitAgentSetGoal(payload);
+            return {};
+        case "onAgentRequestPermission":
+            await emitAgentRequestPermission(payload);
+            return {};
+        case "onUserAnswer":
+            await emitUserAnswer(payload);
+            return {};
+        case "onInit":
+            await emitInitHooks();
+            return {};
+        case "onShutdown":
+            await emitShutdownHooks();
+            return {};
+        default:
+            throw new Error(`未知钩子：${name}`);
+    }
+}
+async function runCommand(request) {
+    if (runtime === null) {
+        throw new Error("插件尚未初始化");
+    }
+    const params = request.params;
+    const command = runtime.commands.find((item) => item.name === params.name);
+    if (command === undefined) {
+        throw new Error(`命令不存在：${params.name}`);
+    }
+    const context = {
+        argv: params.argv,
+        env: {},
+        paths: runtime.api.paths,
+        config: runtime.api.config,
+        logger,
+        output,
+        pluginDataDir: runtime.api.pluginDataDir,
+        pluginConfig: runtime.api.pluginConfig,
+        fs: runtime.api.fs,
+        workspaceFs: runtime.api.workspaceFs,
+        cwd: params.cwd,
+        json: params.json,
+        stdin: Readable.from([params.stdin ?? ""]),
+        stdout: process.stdout,
+        stderr: process.stderr,
+    };
+    const code = await withHookOwner(runtime.owner, async () => await command.run(context));
+    return { exitCode: typeof code === "number" ? code : 0 };
+}
+async function handleHostRequest(request) {
+    try {
+        let result;
+        if (request.method === "plugin.command") {
+            result = await runCommand(request);
+        }
+        else if (request.method === "plugin.agentTool") {
+            if (runtime === null) {
+                throw new Error("插件尚未初始化");
+            }
+            const params = request.params;
+            const tool = runtime.agentTools.find((item) => item.name === params.name);
+            if (tool === undefined) {
+                throw new Error(`Agent 工具不存在：${params.name}`);
+            }
+            result = await withHookOwner(runtime.owner, async () => (await tool.call(params.args)));
+        }
+        else if (request.method === "plugin.init") {
+            if (runtime === null) {
+                throw new Error("插件尚未初始化");
+            }
+            await initializeRuntime(runtime);
+            result = readyOf(runtime);
+        }
+        else if (request.method === "plugin.websocket.connect") {
+            if (runtime === null) {
+                throw new Error("插件尚未初始化");
+            }
+            const params = request.params;
+            const handler = websocketHandlers.get(params.serverId);
+            if (handler === undefined) {
+                throw new Error("WebSocket handler 不存在");
+            }
+            const connectionId = params.connectionId;
+            const socket = {
+                connectionId,
+                async send(data) {
+                    await bridgeRequest("host.websocket.send", { connectionId, data });
+                },
+                async close(code = 1000, reason = "") {
+                    await bridgeRequest("host.websocket.close", {
+                        connectionId,
+                        code,
+                        reason,
+                    });
+                },
+                onMessage(handler) {
+                    const list = wsMessages.get(connectionId) ?? [];
+                    list.push(handler);
+                    wsMessages.set(connectionId, list);
+                },
+                onClose(handler) {
+                    const list = wsCloses.get(connectionId) ?? [];
+                    list.push(handler);
+                    wsCloses.set(connectionId, list);
+                },
+            };
+            await withHookOwner(runtime.owner, async () => handler(socket, params.request));
+            result = {};
+        }
+        else if (request.method === "plugin.websocket.message") {
+            const params = request.params;
+            const text = params.binary
+                ? Buffer.from(params.data, "base64").toString("utf8")
+                : Buffer.from(params.data, "base64").toString("utf8");
+            for (const handler of wsMessages.get(params.connectionId) ?? []) {
+                handler(text);
+            }
+            result = {};
+        }
+        else if (request.method === "plugin.websocket.close") {
+            const params = request.params;
+            for (const handler of wsCloses.get(params.connectionId) ?? []) {
+                handler(params.code, params.reason);
+            }
+            wsMessages.delete(params.connectionId);
+            wsCloses.delete(params.connectionId);
+            result = {};
+        }
+        else if (request.method === "plugin.http") {
+            if (runtime === null) {
+                throw new Error("插件尚未初始化");
+            }
+            const params = request.params;
+            const handler = httpHandlers.get(params.serverId);
+            if (handler === undefined) {
+                throw new Error(`HTTP handler 不存在：${params.serverId}`);
+            }
+            const requestId = params.requestId;
+            let flushed = false;
+            let ended = false;
+            const buffered = [];
+            const flush = () => {
+                if (flushed) {
+                    return;
+                }
+                flushed = true;
+                for (const chunk of buffered) {
+                    bridgeNotify("host.http.stream", { requestId, chunk });
+                }
+                buffered.length = 0;
+                if (ended) {
+                    bridgeNotify("host.http.stream", { requestId, end: true });
+                }
+            };
+            const stream = {
+                write(chunk) {
+                    if (flushed) {
+                        bridgeNotify("host.http.stream", { requestId, chunk });
+                    }
+                    else {
+                        buffered.push(chunk);
+                    }
+                },
+                end() {
+                    if (flushed) {
+                        bridgeNotify("host.http.stream", { requestId, end: true });
+                    }
+                    else {
+                        ended = true;
+                    }
+                },
+            };
+            const response = (await withHookOwner(runtime.owner, async () => handler(params.request, stream)));
+            if (response.stream === true) {
+                setImmediate(flush);
+            }
+            result = response;
+        }
+        else if (request.method === "plugin.hook") {
+            const params = request.params;
+            if (runtime === null) {
+                throw new Error("插件尚未初始化");
+            }
+            result = await withHookOwner(runtime.owner, async () => dispatchHook(params.hook, params.payload));
+        }
+        else if (request.method === "sandbox.ping") {
+            result = { time: Date.now() };
+        }
+        else if (request.method === "sandbox.shutdown") {
+            await emitShutdownHooks();
+            result = {};
+            writeFrame({ v: 1, type: "response", id: request.id, ok: true, result });
+            setTimeout(() => process.exit(0), 10);
+            return;
+        }
+        else {
+            throw new Error(`未知方法：${request.method}`);
+        }
+        writeFrame({ v: 1, type: "response", id: request.id, ok: true, result });
+    }
+    catch (error) {
+        writeFrame({
+            v: 1,
+            type: "response",
+            id: request.id,
+            ok: false,
+            error: {
+                code: request.method === "plugin.hook"
+                    ? "plugin.hook-failed"
+                    : "plugin.command-failed",
+                message: error instanceof Error ? error.message : String(error),
+            },
+        });
+    }
+}
+const configureResolvers = [];
+async function main() {
+    const decoder = new FrameDecoder();
+    process.stdin.on("data", async (chunk) => {
+        for (const message of decoder.push(chunk)) {
+            if (message.type === "response") {
+                const entry = pending.get(message.id);
+                if (entry !== undefined) {
+                    pending.delete(message.id);
+                    if (message.ok) {
+                        entry.resolve(message.result);
+                    }
+                    else {
+                        entry.reject(new Error(message.error?.message ?? "host RPC 失败"));
+                    }
+                }
+                continue;
+            }
+            if (message.type === "event") {
+                /*
+                 * 事件回调出错不能拖垮 stdin 读取
+                 *
+                 * 这里在 data 监听里同步执行插件侧回调；一旦抛出就是未捕获异常，
+                 * 插件可能直接挂掉或丢掉这一帧里剩下的事件——宿主还在跑、界面却再也
+                 * 收不到任何事件，表现就是「服务端一直有日志、页面卡住不动」。
+                 */
+                try {
+                    if (message.method === "sandbox.event") {
+                        const params = message.params;
+                        eventBus.receive(params.name, params.data);
+                    }
+                    else if (message.method === "sandbox.agent.stream") {
+                        const params = message.params;
+                        agentStreamHandlers.get(params.streamId)?.(params.event);
+                    }
+                }
+                catch (error) {
+                    process.stderr.write(`事件处理失败（${message.method}）：${error instanceof Error ? error.message : String(error)}\n`);
+                }
+                continue;
+            }
+            const request = message;
+            if (request.method === "sandbox.configure") {
+                const params = request.params;
+                try {
+                    patchConsole();
+                    patchProcessStreams();
+                    const ready = await bootstrap(params);
+                    writeFrame({ v: 1, type: "response", id: request.id, ok: true, result: ready });
+                }
+                catch (error) {
+                    writeFrame({
+                        v: 1,
+                        type: "response",
+                        id: request.id,
+                        ok: false,
+                        error: {
+                            code: "plugin.init-failed",
+                            message: error instanceof Error ? error.message : String(error),
+                        },
+                    });
+                    setTimeout(() => process.exit(1), 10);
+                }
+                continue;
+            }
+            void handleHostRequest(request);
+        }
+    });
+    process.stdin.resume();
+    await new Promise(() => undefined);
+}
+await main();
+//# sourceMappingURL=plugin-host.js.map