mu-agent-bridge 1.0.71 → 1.0.78

package/plugins/workbuddy/dist/src-ts/plugins/workbuddy/index.js

@@ -8,6 +8,7 @@ const promises_1 = require("node:fs/promises");
 const node_os_1 = require("node:os");
 const node_path_1 = require("node:path");
 const agent_1 = require("../../agent");
+const agent_2 = require("../../agent");
 const attachments_1 = require("../../attachments");
 const plugin_1 = require("../../plugin");
 const cdp_client_1 = require("./cdp-client");
@@ -16,9 +17,9 @@ const session_history_1 = require("./session-history");
 const desktop_launch_1 = require("../desktop-launch");
 const desktop_launch_2 = require("./desktop-launch");
 exports.workbuddyManifest = {
-    id: "workbuddy", version: "1.1.32", displayName: "WorkBuddy", type: "agent",
+    id: "workbuddy", version: "1.1.35", displayName: "WorkBuddy", type: "agent",
     entry: "dist/index.js", apiVersion: "1", process: "in-process",
-    capabilities: ["chat", "health"], configSchema: "config.schema.json",
+    capabilities: ["chat", "health", "model-provider"], configSchema: "config.schema.json",
 };
 function extractExpertQuery(task) {
     const text = task.normalize("NFKC");
@@ -40,13 +41,19 @@ function findExecutable(configured) {
 class WorkbuddyPlugin {
     options;
     manifest = exports.workbuddyManifest;
+    get modelProvider() {
+        if (this.transport === "cli" || (this.transport !== "cdp" && this.cliPath) || !this.client?.createTask || !this.client.complete)
+            return undefined;
+        return { complete: (request) => this.completeModelProvider(request) };
+    }
     client;
     process;
     reconnect;
     cliPath;
     model;
     transport = "auto";
-    timeoutMs = 3_600_000;
+    replyTimeoutLimitMs;
+    timeoutMs = cdp_client_1.WORKBUDDY_MAX_WAIT_MS;
     queue = Promise.resolve();
     pending = 0;
     activeSessionId;
@@ -70,6 +77,7 @@ class WorkbuddyPlugin {
     sessionHistory;
     constructor(options = {}) {
         this.options = options;
+        this.replyTimeoutLimitMs = options.replyTimeoutLimitMs ?? cdp_client_1.WORKBUDDY_MAX_WAIT_MS;
     }
     get attachmentInput() { return Boolean(this.client?.attachmentInput && this.client.complete && this.transport !== "cli" && (!this.cliPath || this.transport === "cdp")); }
     async activate(context) {
@@ -77,7 +85,7 @@ class WorkbuddyPlugin {
         if (config.transport !== undefined && !["auto", "cli", "cdp"].includes(String(config.transport)))
             throw new Error("transport 只能是 auto、cli 或 cdp");
         this.transport = config.transport ?? "auto";
-        this.timeoutMs = typeof config.timeoutMs === "number" && config.timeoutMs > 0 ? config.timeoutMs : 3_600_000;
+        this.timeoutMs = Math.min(typeof config.timeoutMs === "number" && config.timeoutMs > 0 ? config.timeoutMs : 3_600_000, this.replyTimeoutLimitMs);
         this.model = typeof config.model === "string" && config.model.trim() ? config.model : undefined;
         this.cliPath = (0, cli_client_1.findCli)(typeof config.cliPath === "string" ? config.cliPath : undefined);
         this.failure = undefined;
@@ -231,31 +239,92 @@ class WorkbuddyPlugin {
             return { status: "ready", details: { transport: "cdp" } };
         if (this.transport !== "cdp" && this.cliPath && (0, node_fs_1.existsSync)(this.cliPath))
             return { status: "ready", details: { transport: "cli" } };
-        return { status: "failed", message: this.failure ?? "WorkBuddy 未连接", details: { transport: this.transport } };
+        return { status: "failed", message: this.failure ?? "WorkBuddy CDP 未连接；桌面升级后请在后台使用“重启桌面”恢复连接", details: { transport: this.transport } };
     }
     async handle(request) {
         if (!request.task.trim())
             throw new Error("消息内容不能为空");
         (0, attachments_1.validateAttachments)(request.attachments);
         const run = this.enqueue(async () => {
+            request.signal?.throwIfAborted();
             try {
-                return await this.complete(request);
+                const response = await this.complete(request);
+                await this.synchronizeSession();
+                return response;
             }
-            finally {
-                if (this.activeSessionId && this.desktopSessionValid && this.client?.conversationId) {
-                    try {
-                        this.activeDesktopConversationId = await this.client.conversationId();
-                        await this.persistKnownSessions();
-                    }
-                    catch (error) {
-                        this.dailyPointsLogger?.warn("WorkBuddy 会话状态同步失败，已保留本轮回复", { stage: "完成后读取会话标识或保存映射", error: error instanceof Error ? error.message : String(error) });
-                    }
-                }
+            catch (error) {
+                // 失败时桌面可能已切换，保留原绑定并要求重新校验或恢复。
+                this.desktopSessionValid = false;
+                throw error;
             }
         });
         const response = await run;
         return { ...response, sessionId: request.sessionId ?? response.sessionId };
     }
+    async synchronizeSession() {
+        if (this.activeSessionId && this.desktopSessionValid && this.client?.conversationId) {
+            try {
+                const conversationId = await this.client.conversationId();
+                if (this.activeDesktopConversationId && conversationId !== this.activeDesktopConversationId) {
+                    this.desktopSessionValid = false;
+                    throw new Error("WorkBuddy 桌面任务已切换，已保留原会话绑定");
+                }
+                this.activeDesktopConversationId = conversationId;
+                if (this.activeDesktopConversationId)
+                    this.sessionBindings.set(this.activeSessionId, { conversationId: this.activeDesktopConversationId, expert: this.activeExpert });
+                await this.persistKnownSessions();
+            }
+            catch (error) {
+                this.dailyPointsLogger?.warn("WorkBuddy 会话状态同步失败，已保留本轮回复", { stage: "完成后读取会话标识或保存映射", error: error instanceof Error ? error.message : String(error) });
+            }
+        }
+    }
+    async completeModelProvider(request) {
+        let stage = "WorkBuddy 模型排队（queue）";
+        try {
+            request.signal.throwIfAborted();
+            const run = this.enqueue(async () => {
+                request.signal.throwIfAborted();
+                const client = this.client;
+                if (!client?.connected() || !client.complete)
+                    throw new Error("WorkBuddy CDP 未连接，模型请求不会启动或重启桌面");
+                const availability = await client.historyAvailability?.();
+                if (availability?.waiting || availability?.generating || availability?.draft)
+                    throw new Error("WorkBuddy 当前有用户草稿、待确认操作或正在生成回复，模型请求未切换会话");
+                stage = "连接 WorkBuddy 模型（connect）";
+                const previous = { sessionId: this.activeSessionId, conversationId: await client.conversationId?.(), expert: this.activeExpert, expertSession: this.expertSession, valid: this.desktopSessionValid };
+                try {
+                    stage = "等待 WorkBuddy 模型生成（generate）";
+                    const response = await this.complete({ task: request.prompt, sessionId: request.sessionId, timeoutMs: request.timeoutMs, signal: request.signal }, true);
+                    return { text: response.text };
+                }
+                finally {
+                    await this.synchronizeSession();
+                    if (client.connected()) {
+                        if (previous.conversationId) {
+                            if (!client.activateConversation)
+                                throw new Error("WorkBuddy 无法恢复用户原会话");
+                            await client.activateConversation(previous.conversationId, true);
+                        }
+                        else if (client.conversationId)
+                            await client.createTask();
+                    }
+                    this.activeSessionId = previous.sessionId;
+                    this.activeDesktopConversationId = previous.conversationId;
+                    this.activeExpert = previous.expert;
+                    this.expertSession = previous.expertSession;
+                    this.desktopSessionValid = previous.valid;
+                    await this.persistKnownSessions();
+                }
+            });
+            return await (0, agent_1.abortable)(run, request.signal);
+        }
+        catch (error) {
+            if (error instanceof agent_2.AgentOperationError)
+                throw error;
+            throw new agent_2.AgentOperationError("WORKBUDDY_MODEL_FAILED", stage, error);
+        }
+    }
     async controlSession(request) {
         if (this.pending)
             throw new Error("WorkBuddy 当前忙，无法创建新会话");
@@ -277,17 +346,20 @@ class WorkbuddyPlugin {
             return { text: "WorkBuddy 已创建新会话", sessionId };
         });
     }
-    async complete(request) {
+    async complete(request, modelRequest = false) {
         let stage = "连接 WorkBuddy 桌面";
         try {
-            const timeout = request.timeoutMs ?? this.timeoutMs;
-            const expert = extractExpertQuery(request.task);
+            const timeout = Math.min(request.timeoutMs ?? this.timeoutMs, this.replyTimeoutLimitMs);
+            const expert = modelRequest || this.options.expertSelection === false ? undefined : extractExpertQuery(request.task);
             const usesCli = Boolean(this.cliPath && this.transport !== "cdp" && !expert);
             const hasAttachments = Array.isArray(request.attachments) && request.attachments.length > 0;
             if (hasAttachments && !this.attachmentInput)
                 throw new Error("WorkBuddy 当前传输不支持附件输入");
-            if (!usesCli && !this.client?.connected())
+            if (!usesCli && !this.client?.connected()) {
+                if (modelRequest)
+                    throw new Error("WorkBuddy CDP 已断开，模型请求不会启动或重启桌面");
                 await this.reconnect?.();
+            }
             const pendingInteractionSessionId = this.client?.pendingInteractionSessionId?.();
             if (!usesCli && pendingInteractionSessionId && pendingInteractionSessionId !== request.sessionId)
                 throw new Error("WorkBuddy 正在等待另一个会话的选择");
@@ -299,7 +371,7 @@ class WorkbuddyPlugin {
                 throw new Error("WorkBuddy 桌面任务状态未知，请先创建新会话");
             stage = "准备或恢复 WorkBuddy 会话";
             if (!usesCli)
-                await this.ensureSession(request.sessionId);
+                await this.ensureSession(request.sessionId, modelRequest);
             stage = "执行 WorkBuddy 桌面任务";
             if (expert) {
                 if (!this.client?.connected())
@@ -312,7 +384,7 @@ class WorkbuddyPlugin {
                 this.expertSession = true;
                 try {
                     if (this.client.complete)
-                        return await this.client.complete({ ...request, timeoutMs: timeout }, select, false);
+                        return await this.client.complete({ ...request, timeoutMs: timeout }, select, false, request.sessionId ? this.activeDesktopConversationId ?? null : undefined);
                     return { text: await this.client.direct(request.task, timeout, select) };
                 }
                 catch (error) {
@@ -332,7 +404,7 @@ class WorkbuddyPlugin {
                 this.activeExpert = null;
             try {
                 if (this.client.complete)
-                    return await this.client.complete({ ...request, timeoutMs: timeout }, undefined, reset);
+                    return await this.client.complete({ ...request, timeoutMs: timeout }, undefined, reset, request.sessionId ? this.activeDesktopConversationId ?? null : undefined);
                 return { text: await this.client.direct(request.task, timeout, undefined, reset) };
             }
             catch (error) {
@@ -342,12 +414,12 @@ class WorkbuddyPlugin {
             }
         }
         catch (error) {
-            if (error instanceof agent_1.AgentOperationError || error?.stage)
+            if (error instanceof agent_2.AgentOperationError || error?.stage)
                 throw error;
-            throw new agent_1.AgentOperationError("WORKBUDDY_TASK_FAILED", stage, error);
+            throw new agent_2.AgentOperationError("WORKBUDDY_TASK_FAILED", stage, error);
         }
     }
-    async ensureSession(sessionId) {
+    async ensureSession(sessionId, modelRequest = false) {
         if (!sessionId)
             return;
         if (!this.client?.connected())
@@ -370,7 +442,7 @@ class WorkbuddyPlugin {
             }
             if (!this.client.activateConversation)
                 throw new Error("WorkBuddy 不支持恢复旧 WorkBuddy 会话");
-            await this.client.activateConversation(conversationId);
+            await this.client.activateConversation(conversationId, modelRequest);
             this.activeSessionId = sessionId;
             this.activeDesktopConversationId = conversationId;
             this.activeExpert = binding?.expert;
@@ -462,22 +534,33 @@ class WorkbuddyPlugin {
         const profile = (0, node_path_1.join)(dataDir ?? (0, node_path_1.join)((0, node_os_1.homedir)(), ".agent-bridge", "workbuddy"), "desktop");
         const launch = (file, args) => (0, desktop_launch_2.launchWorkbuddyDesktop)(file, args, profile, port);
         const timeoutMs = typeof config.startupTimeoutMs === "number" ? config.startupTimeoutMs : 30_000;
+        const connectOrLaunch = async () => {
+            try {
+                await this.client.connect();
+                return;
+            }
+            catch (first) {
+                if (config.autoStart === false || this.options.client)
+                    throw first;
+                if (!executable)
+                    throw new Error("未找到 WorkBuddy.exe，请配置 executablePath");
+                logger.info(`WorkBuddy CDP ${port} 不可用，启动带调试参数的桥接实例`);
+                await (0, desktop_launch_1.launchManagedAndWait)(executable, [`--remote-debugging-port=${port}`], profile, () => this.client.connect(), timeoutMs, child => { this.process = child; }, launch);
+            }
+        };
         this.reconnect = async () => {
-            // 请求恢复只重连 socket，页面错误不能触发桌面进程重启。
-            await this.client.connect();
+            try {
+                await this.client.connect();
+            }
+            catch (error) {
+                const failure = error;
+                // 只有调试端口拒绝连接才重新启动；页面或协议错误不得触碰桌面进程。
+                if (failure.code !== "ECONNREFUSED" && failure.cause?.code !== "ECONNREFUSED")
+                    throw error;
+                await connectOrLaunch();
+            }
         };
-        try {
-            await this.client.connect();
-            return;
-        }
-        catch (first) {
-            if (config.autoStart === false || this.options.client)
-                throw first;
-            if (!executable)
-                throw new Error("未找到 WorkBuddy.exe，请配置 executablePath");
-            logger.info(`WorkBuddy 已启动，等待 CDP ${port}`);
-            await (0, desktop_launch_1.launchManagedAndWait)(executable, [`--remote-debugging-port=${port}`], profile, () => this.client.connect(), timeoutMs, child => { this.process = child; }, launch);
-        }
+        await connectOrLaunch();
     }
 }
 exports.WorkbuddyPlugin = WorkbuddyPlugin;

package/plugins/workbuddy/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-bridge-workbuddy",
-  "version": "1.1.32",
+  "version": "1.1.35",
   "description": "mu-agent-bridge 的 WorkBuddy 桌面端插件。",
   "keywords": [
     "mu-agent-bridge-plugin",

package/plugins/workbuddy/plugin.json

@@ -1,6 +1,6 @@
 {
   "id": "workbuddy",
-  "version": "1.1.32",
+  "version": "1.1.35",
   "type": "agent",
   "displayName": "WorkBuddy",
   "entry": "dist/src-ts/plugins/workbuddy/index.js",
@@ -8,7 +8,8 @@
   "process": "in-process",
   "capabilities": [
     "chat",
-    "health"
+    "health",
+    "model-provider"
   ],
   "configSchema": "config.schema.json",
   "clientDownloadUrl": "https://www.workbuddy.ai/"

package/plugins/zcode/config.schema.json

@@ -0,0 +1,13 @@
+{
+  "type": "object",
+  "properties": {
+    "aid": { "type": "string", "description": "关联的 AID" },
+    "autoStart": { "type": "boolean", "default": true, "description": "CDP 端口拒绝连接时自动发现并启动 ZCode" },
+    "executablePath": { "type": "string", "description": "可选的 ZCode.exe 路径，留空时从注册表、开始菜单和安装目录自动发现" },
+    "startupArgs": { "type": "array", "items": { "type": "string" }, "default": [], "description": "附加启动参数；CDP 地址和端口由插件自动传入" },
+    "startupTimeoutMs": { "type": "integer", "minimum": 1, "default": 30000, "description": "启动后等待 CDP 就绪的时间（毫秒）" },
+    "cdpPort": { "type": "integer", "minimum": 1, "maximum": 65535, "default": 9231, "description": "ZCode CDP 端口" },
+    "timeoutMs": { "type": "integer", "minimum": 1, "default": 3600000, "description": "单次回复等待时间（毫秒）" }
+  },
+  "additionalProperties": false
+}

package/plugins/zcode/dist/src-ts/agent.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentOperationError = exports.AgentError = void 0;
+exports.abortable = abortable;
+exports.errorDetails = errorDetails;
+async function abortable(promise, signal) {
+    if (!signal)
+        return promise;
+    if (signal.aborted) {
+        // promise 已在调用方启动，先观察其拒绝，避免预取消时产生未处理拒绝。
+        void promise.catch(() => undefined);
+        signal.throwIfAborted();
+    }
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        const cleanup = () => signal.removeEventListener("abort", abort);
+        const abort = () => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            reject(signal.reason);
+        };
+        signal.addEventListener("abort", abort, { once: true });
+        promise.then((value) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            resolve(value);
+        }, (error) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
+            reject(error);
+        });
+    });
+}
+class AgentError extends Error {
+    constructor(message, options) {
+        super(message, options);
+        this.name = "AgentError";
+    }
+}
+exports.AgentError = AgentError;
+/** 保留底层错误码，避免只留下 fetch failed 或超时这类表层提示。 */
+function errorDetails(error) {
+    const parts = [];
+    const seen = new Set();
+    for (let current = error; current && !seen.has(current) && seen.size < 5;) {
+        seen.add(current);
+        const value = current;
+        const message = typeof value.message === "string" ? value.message : String(current);
+        parts.push(`${message}${value.code ? `（${String(value.code)}）` : ""}`);
+        current = value.cause;
+    }
+    return parts.join("；原因：") || String(error);
+}
+class AgentOperationError extends AgentError {
+    code;
+    stage;
+    constructor(code, stage, cause) {
+        super(`${code}：${stage}失败：${errorDetails(cause)}`, { cause });
+        this.code = code;
+        this.stage = stage;
+    }
+}
+exports.AgentOperationError = AgentOperationError;

package/plugins/zcode/dist/src-ts/attachments.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_TOTAL_ATTACHMENT_BYTES = exports.MAX_ATTACHMENTS = exports.MAX_ATTACHMENT_BYTES = void 0;
+exports.detectImageContentType = detectImageContentType;
+exports.attachmentFilename = attachmentFilename;
+exports.validateAttachment = validateAttachment;
+exports.validateAttachments = validateAttachments;
+exports.asAttachments = asAttachments;
+exports.MAX_ATTACHMENT_BYTES = 32 * 1024 * 1024;
+exports.MAX_ATTACHMENTS = 8;
+exports.MAX_TOTAL_ATTACHMENT_BYTES = 64 * 1024 * 1024;
+function detectImageContentType(data) {
+    if (data.length >= 8 && data.slice(0, 8).every((value, index) => value === [137, 80, 78, 71, 13, 10, 26, 10][index]))
+        return "image/png";
+    if (data.length >= 3 && data[0] === 0xff && data[1] === 0xd8 && data[2] === 0xff)
+        return "image/jpeg";
+    if (data.length >= 12 && String.fromCharCode(...data.slice(0, 4)) === "RIFF" && String.fromCharCode(...data.slice(8, 12)) === "WEBP")
+        return "image/webp";
+    return undefined;
+}
+function attachmentFilename(filename) {
+    if (typeof filename !== "string" || /[\u0000-\u001f\u007f]/.test(filename))
+        throw new Error("附件文件名无效");
+    const name = filename.split(/[\\/]/).pop() ?? "";
+    if (!name.trim() || name === "." || name === "..")
+        throw new Error("附件文件名无效");
+    return name;
+}
+function validateAttachment(item) {
+    if (!item || !(item.data instanceof Uint8Array) || item.data.byteLength === 0)
+        throw new Error("附件内容不能为空");
+    if (item.data.byteLength > exports.MAX_ATTACHMENT_BYTES)
+        throw new Error("单个附件不能超过 32 MiB");
+    attachmentFilename(item.filename);
+    if (item.kind !== "image" && item.kind !== "file")
+        throw new Error("附件类型无效");
+    if (typeof item.contentType !== "string" || !/^[A-Za-z0-9!#$&^_.+-]+\/[A-Za-z0-9!#$&^_.+-]+$/.test(item.contentType))
+        throw new Error("附件 MIME 类型无效");
+    if (item.kind === "image") {
+        const detected = detectImageContentType(item.data);
+        if (!detected || detected !== item.contentType.toLowerCase())
+            throw new Error("图片内容与 MIME 类型不一致");
+    }
+}
+function validateAttachments(items) {
+    if (!items)
+        return;
+    if (!Array.isArray(items))
+        throw new Error("附件列表无效");
+    if (items.length > exports.MAX_ATTACHMENTS)
+        throw new Error("单条消息最多包含 8 个附件");
+    let total = 0;
+    for (const item of items) {
+        validateAttachment(item);
+        total += item.data.byteLength;
+    }
+    if (total > exports.MAX_TOTAL_ATTACHMENT_BYTES)
+        throw new Error("单条消息附件总大小不能超过 64 MiB");
+}
+function asAttachments(images) {
+    return (images ?? []).map((image) => ({ ...image, kind: "image" }));
+}

package/plugins/zcode/dist/src-ts/plugin.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveRuntimePort = resolveRuntimePort;
+function resolveRuntimePort(config, runtime, pluginId, envName, fallback) {
+    const injected = runtime?.ports?.[pluginId];
+    if (typeof injected === "number" && Number.isInteger(injected) && injected > 0)
+        return injected;
+    const configured = config.cdpPort;
+    if (typeof configured === "number" && Number.isInteger(configured) && configured > 0)
+        return configured;
+    const environment = Number(process.env[envName] ?? "");
+    return Number.isInteger(environment) && environment > 0 ? environment : fallback;
+}