mu-agent-bridge 1.0.73 → 1.0.78

package/plugins/zcode/dist/src-ts/plugins/workbuddy/cli-client.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findCli = findCli;
+exports.callCli = callCli;
+const node_child_process_1 = require("node:child_process");
+const node_fs_1 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
+const node_util_1 = require("node:util");
+const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+function findCli(configured) {
+    if (configured)
+        return (0, node_fs_1.existsSync)((0, node_path_1.resolve)(configured)) ? (0, node_path_1.resolve)(configured) : undefined;
+    const roots = [process.env.CODEBUDDY_NPM_DIR, (0, node_path_1.join)(process.env.APPDATA ?? (0, node_path_1.join)((0, node_os_1.homedir)(), "AppData", "Roaming"), "npm", "node_modules", "@tencent-ai", "codebuddy-code"), (0, node_path_1.join)((0, node_os_1.homedir)(), ".npm", "node_modules", "@tencent-ai", "codebuddy-code")];
+    return roots.filter((root) => Boolean(root)).map((root) => (0, node_path_1.join)(root, "bin", "codebuddy")).find(node_fs_1.existsSync);
+}
+async function callCli(cliPath, text, sessionId, timeoutMs, model) {
+    const id = (sessionId.replace(/[^A-Za-z0-9_-]/g, "-").replace(/^-+|-+$/g, "") || "wb").slice(0, 80);
+    const args = [cliPath, "-p", text, "--session-id", id, "--output-format", "text"];
+    if (model)
+        args.push("--model", model);
+    let stdout;
+    let stderr;
+    try {
+        ({ stdout, stderr } = await execFileAsync(process.execPath, args, { cwd: (0, node_path_1.dirname)((0, node_path_1.dirname)(cliPath)), timeout: timeoutMs, maxBuffer: 4 * 1024 * 1024, encoding: "utf8", windowsHide: true }));
+    }
+    catch (error) {
+        const failure = error;
+        if (failure.killed)
+            throw new Error("CodeBuddy 回复超时");
+        throw new Error(`CodeBuddy 调用失败：${failure.stderr?.trim().slice(-300) || failure.message}`);
+    }
+    if (/Authentication required\. Please use \/login command to sign in to your account/.test(`${stdout}\n${stderr}`))
+        throw new Error("CodeBuddy CLI 尚未登录，请先执行 /login");
+    const reply = stdout.split(/\r?\n/).filter((line) => !(line.startsWith("[") && line.slice(0, 40).includes("]["))).join("\n").trim();
+    if (!reply)
+        throw new Error("CodeBuddy 无输出");
+    return reply;
+}

package/plugins/zcode/dist/src-ts/plugins/workbuddy/desktop-launch.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.launchWorkbuddyDesktop = launchWorkbuddyDesktop;
+const node_child_process_1 = require("node:child_process");
+function launchWorkbuddyDesktop(executable, args, profileDirectory, port) {
+    // WorkBuddy 会覆盖 Chromium 的用户目录参数，必须使用它自己的环境变量隔离实例。
+    const env = { ...process.env, WORKBUDDY_USER_DATA_DIR: profileDirectory, WORKBUDDY_REMOTE_DEBUGGING_PORT: String(port) };
+    delete env.ELECTRON_RUN_AS_NODE;
+    return (0, node_child_process_1.spawn)(executable, [...args, "--lang=zh-CN", "--accept-lang=zh-CN,zh"], { env, detached: true, stdio: "ignore", windowsHide: false });
+}

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

@@ -0,0 +1,567 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WorkbuddyPlugin = exports.workbuddyManifest = void 0;
+exports.extractExpertQuery = extractExpertQuery;
+exports.findExecutable = findExecutable;
+const node_fs_1 = require("node:fs");
+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");
+const cli_client_1 = require("./cli-client");
+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.35", displayName: "WorkBuddy", type: "agent",
+    entry: "dist/index.js", apiVersion: "1", process: "in-process",
+    capabilities: ["chat", "health", "model-provider"], configSchema: "config.schema.json",
+};
+function extractExpertQuery(task) {
+    const text = task.normalize("NFKC");
+    const match = text.match(/^(?:请)?(?:只要|调用|使用|帮我找|找|用|选择|切换到)\s*[“「"]?([^，。！？,!?\n“「"]{2,30}?专家(?:团)?)(?!技能)/)
+        ?? text.match(/^([A-Za-z\u4e00-\u9fff]{2,24}?专家(?:团)?)(?=[，。！,!:：\s]|$)/);
+    return match?.[1]?.trim() || undefined;
+}
+function findExecutable(configured) {
+    if (configured)
+        return (0, node_fs_1.existsSync)((0, node_path_1.resolve)(configured)) ? (0, node_path_1.resolve)(configured) : undefined;
+    const local = process.env.LOCALAPPDATA ?? (0, node_path_1.join)((0, node_os_1.homedir)(), "AppData", "Local");
+    return [
+        (0, node_path_1.join)(local, "Programs", "WorkBuddy", "WorkBuddy.exe"),
+        (0, node_path_1.join)(local, "Programs", "WorkBuddyAI", "WorkBuddyAI.exe"),
+        "D:\\Programs\\WorkBuddy\\WorkBuddy.exe",
+        "D:\\Programs\\WorkBuddyAI\\WorkBuddyAI.exe",
+    ].find(node_fs_1.existsSync);
+}
+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";
+    replyTimeoutLimitMs;
+    timeoutMs = cdp_client_1.WORKBUDDY_MAX_WAIT_MS;
+    queue = Promise.resolve();
+    pending = 0;
+    activeSessionId;
+    /** 重载后待恢复的会话身份。 */
+    recoverableSessionId;
+    recoverableConversationId;
+    sessionBindings = new Map();
+    activeDesktopConversationId;
+    desktopSessionValid = true;
+    knownSessions = new Set();
+    sessionDataDir;
+    sessionWrites = Promise.resolve();
+    dailyPointsTimer;
+    dailyPointsActive = false;
+    dailyPointsDataDir;
+    dailyPointsLogger;
+    failure;
+    expertSession = false;
+    activeExpert;
+    sessionOperations = [];
+    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) {
+        const config = context.config;
+        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 = 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;
+        this.activeSessionId = undefined;
+        this.recoverableSessionId = undefined;
+        this.recoverableConversationId = undefined;
+        this.sessionBindings.clear();
+        this.activeDesktopConversationId = undefined;
+        this.activeExpert = undefined;
+        this.expertSession = false;
+        this.desktopSessionValid = true;
+        this.knownSessions.clear();
+        this.sessionDataDir = context.dataDir;
+        this.dailyPointsDataDir = context.dataDir;
+        this.dailyPointsLogger = context.logger;
+        let savedBinding;
+        if (this.sessionDataDir) {
+            const saved = await this.loadKnownSessions(this.sessionDataDir);
+            for (const sessionId of saved.sessionIds)
+                this.knownSessions.add(sessionId);
+            for (const [sessionId, binding] of Object.entries(saved.bindings ?? {}))
+                this.sessionBindings.set(sessionId, binding);
+            savedBinding = saved.active;
+        }
+        this.sessionOperations = [];
+        this.sessionHistory = new session_history_1.WorkbuddySessionHistoryProvider({
+            scope: `workbuddy:cdp:${(0, plugin_1.resolveRuntimePort)(config, context.runtime, "workbuddy", "WORKBUDDY_CDP_PORT", this.options.cdpPort ?? 9229)}`,
+            supported: () => this.transport !== "cli" && !(this.transport !== "cdp" && this.cliPath) && Boolean(this.client?.connected() && this.client.conversationId && this.client.readHistorySnapshot && this.client.historyAvailability),
+            client: () => this.client,
+            run: async (work) => {
+                if (this.transport === "cli" || (this.transport !== "cdp" && this.cliPath))
+                    return { supported: false, reason: "WorkBuddy CLI 模式不支持原生历史读取" };
+                if (!this.client?.connected() || !this.client.conversationId || !this.client.readHistorySnapshot || !this.client.historyAvailability)
+                    return { supported: false, reason: "WorkBuddy 当前客户端未连接或不提供只读历史接口" };
+                if (this.pending || this.client?.pendingInteractionSessionId?.())
+                    return { supported: false, reason: "WorkBuddy 当前忙或正在等待交互，暂不读取历史" };
+                return this.enqueue(async () => {
+                    if (this.client?.pendingInteractionSessionId?.())
+                        return { supported: false, reason: "WorkBuddy 正在等待交互，暂不读取历史" };
+                    return work();
+                });
+            },
+        });
+        if (this.transport === "cli") {
+            if (!this.cliPath)
+                throw new Error("未找到 CodeBuddy CLI，请配置 cliPath");
+            return;
+        }
+        const port = (0, plugin_1.resolveRuntimePort)(config, context.runtime, "workbuddy", "WORKBUDDY_CDP_PORT", this.options.cdpPort ?? 9229);
+        this.client = this.options.client ?? new cdp_client_1.WorkbuddyCdpClient({ port });
+        try {
+            await this.connectOrStart(config, context.logger, port, context.dataDir);
+        }
+        catch (error) {
+            this.failure = error instanceof Error ? error.message : String(error);
+            this.client.close();
+            this.client = undefined;
+            if (this.transport === "cdp" || !this.cliPath)
+                throw error;
+        }
+        this.sessionOperations = (this.transport === "cdp" || !this.cliPath) && this.client?.createTask ? ["new"] : [];
+        if (savedBinding && this.sessionOperations.length && await this.client?.conversationId?.() === savedBinding.conversationId) {
+            this.activeSessionId = savedBinding.sessionId;
+            this.activeDesktopConversationId = savedBinding.conversationId;
+            this.activeExpert = savedBinding.expert;
+        }
+        else if (savedBinding && this.sessionOperations.length) {
+            this.recoverableSessionId = savedBinding.sessionId;
+            this.recoverableConversationId = savedBinding.conversationId;
+        }
+        if (config.dailyPoints !== false && this.client?.claimDailyPoints) {
+            const hour = typeof config.dailyPointsHour === "number" ? config.dailyPointsHour : 9;
+            const minute = typeof config.dailyPointsMinute === "number" ? config.dailyPointsMinute : 0;
+            if (!Number.isInteger(hour) || hour < 0 || hour > 23 || !Number.isInteger(minute) || minute < 0 || minute > 59)
+                throw new Error("积分领取时间无效");
+            this.scheduleDailyPoints(hour, minute);
+        }
+    }
+    async deactivate(_reason) {
+        this.dailyPointsActive = false;
+        if (this.dailyPointsTimer)
+            clearTimeout(this.dailyPointsTimer);
+        this.dailyPointsTimer = undefined;
+        await this.queue;
+        await this.sessionWrites.catch(() => { });
+        if (_reason !== "reload")
+            await (0, desktop_launch_1.terminateOwnedProcess)(this.process).catch(() => undefined);
+        this.client?.close();
+        this.client = undefined;
+        this.process = undefined;
+        this.reconnect = undefined;
+    }
+    scheduleDailyPoints(hour, minute) {
+        this.dailyPointsActive = true;
+        const now = new Date();
+        const scheduled = new Date(now);
+        scheduled.setHours(hour, minute, 0, 0);
+        const due = scheduled <= now;
+        const arm = () => {
+            if (!this.dailyPointsActive)
+                return;
+            const next = new Date();
+            next.setHours(hour, minute, 0, 0);
+            if (next <= new Date())
+                next.setDate(next.getDate() + 1);
+            this.dailyPointsTimer = setTimeout(() => { void run(); }, Math.max(1, next.getTime() - Date.now()));
+        };
+        const run = async () => {
+            if (!this.dailyPointsDataDir || !this.client?.claimDailyPoints)
+                return;
+            const date = new Date().toLocaleDateString("sv-SE");
+            const file = (0, node_path_1.join)(this.dailyPointsDataDir, "daily-points.json");
+            try {
+                const state = JSON.parse(await (0, promises_1.readFile)(file, "utf8"));
+                if (state.date === date) {
+                    arm();
+                    return;
+                }
+            }
+            catch (error) {
+                if (error.code !== "ENOENT") {
+                    this.dailyPointsLogger?.error("WorkBuddy 每日积分状态读取失败", { error: error instanceof Error ? error.message : String(error) });
+                    arm();
+                    return;
+                }
+            }
+            try {
+                await (0, promises_1.mkdir)(this.dailyPointsDataDir, { recursive: true });
+                const result = await this.enqueue(() => this.client.claimDailyPoints());
+                if (result.clicked.some(label => /(签到|领取(?:积分|奖励)?|收下奖励)/.test(label))) {
+                    await (0, promises_1.writeFile)(file, JSON.stringify({ date }), { mode: 0o600 });
+                }
+                this.dailyPointsLogger?.info("WorkBuddy 每日免费积分领取检查完成", result);
+            }
+            catch (error) {
+                this.dailyPointsLogger?.error("WorkBuddy 每日积分领取失败", { error: error instanceof Error ? error.message : String(error) });
+            }
+            finally {
+                arm();
+            }
+        };
+        if (due) {
+            this.dailyPointsTimer = setTimeout(() => { void run(); }, 1);
+        }
+        else {
+            this.dailyPointsTimer = setTimeout(() => { void run(); }, Math.max(1, scheduled.getTime() - Date.now()));
+        }
+    }
+    async health() {
+        if (this.client?.connected())
+            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 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 {
+                const response = await this.complete(request);
+                await this.synchronizeSession();
+                return response;
+            }
+            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 当前忙，无法创建新会话");
+        if (request.operation !== "new")
+            throw new Error(`WorkBuddy 不支持会话操作：${String(request.operation)}`);
+        const sessionId = request.sessionId?.trim();
+        if (!sessionId)
+            throw new Error("WorkBuddy 新会话缺少 sessionId");
+        if (this.transport === "cli" || (this.transport !== "cdp" && this.cliPath) || !this.client?.createTask)
+            throw new Error("WorkBuddy 当前传输不支持新建会话");
+        if (!this.client.connected())
+            await this.reconnect?.();
+        if (!this.client.connected())
+            throw new Error("WorkBuddy CDP 未连接");
+        return this.enqueue(async () => {
+            if (this.knownSessions.has(sessionId))
+                throw new Error("WorkBuddy 不支持恢复旧 WorkBuddy 会话");
+            await this.createSession(sessionId, request.name);
+            return { text: "WorkBuddy 已创建新会话", sessionId };
+        });
+    }
+    async complete(request, modelRequest = false) {
+        let stage = "连接 WorkBuddy 桌面";
+        try {
+            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 (modelRequest)
+                    throw new Error("WorkBuddy CDP 已断开，模型请求不会启动或重启桌面");
+                await this.reconnect?.();
+            }
+            const pendingInteractionSessionId = this.client?.pendingInteractionSessionId?.();
+            if (!usesCli && pendingInteractionSessionId && pendingInteractionSessionId !== request.sessionId)
+                throw new Error("WorkBuddy 正在等待另一个会话的选择");
+            if (usesCli && request.sessionId)
+                throw new Error("CodeBuddy CLI 会话隔离未验证，不能处理带 sessionId 的请求");
+            if (!usesCli && !request.sessionId && this.activeSessionId)
+                throw new Error("WorkBuddy 已绑定逻辑会话，请使用相同 sessionId 或先执行 /new");
+            if (!usesCli && !request.sessionId && !this.desktopSessionValid)
+                throw new Error("WorkBuddy 桌面任务状态未知，请先创建新会话");
+            stage = "准备或恢复 WorkBuddy 会话";
+            if (!usesCli)
+                await this.ensureSession(request.sessionId, modelRequest);
+            stage = "执行 WorkBuddy 桌面任务";
+            if (expert) {
+                if (!this.client?.connected())
+                    throw new Error(`专家请求需要已连接的 WorkBuddy 桌面端：${expert}`);
+                if (request.sessionId && this.activeExpert !== undefined && this.activeExpert !== expert)
+                    throw new Error("WorkBuddy 切换专家需要先执行 /new，避免丢失当前会话历史");
+                const select = request.sessionId && this.activeExpert === expert ? undefined : expert;
+                if (request.sessionId)
+                    this.activeExpert = expert;
+                this.expertSession = true;
+                try {
+                    if (this.client.complete)
+                        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) {
+                    if (select)
+                        this.desktopSessionValid = false;
+                    throw error;
+                }
+            }
+            if (usesCli)
+                return { text: await (0, cli_client_1.callCli)(this.cliPath, request.task, "local-test", timeout, this.model) };
+            if (!this.client?.connected())
+                throw new Error("WorkBuddy CDP 未连接");
+            const reset = !request.sessionId && this.expertSession;
+            if (!request.sessionId)
+                this.expertSession = false;
+            if (request.sessionId && this.activeExpert === undefined)
+                this.activeExpert = null;
+            try {
+                if (this.client.complete)
+                    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) {
+                if (reset)
+                    this.desktopSessionValid = false;
+                throw error;
+            }
+        }
+        catch (error) {
+            if (error instanceof agent_2.AgentOperationError || error?.stage)
+                throw error;
+            throw new agent_2.AgentOperationError("WORKBUDDY_TASK_FAILED", stage, error);
+        }
+    }
+    async ensureSession(sessionId, modelRequest = false) {
+        if (!sessionId)
+            return;
+        if (!this.client?.connected())
+            throw new Error("WorkBuddy CDP 未连接");
+        if (!this.client.createTask)
+            throw new Error("WorkBuddy 客户端不支持新建会话");
+        if (this.activeSessionId === sessionId && this.desktopSessionValid) {
+            if (this.activeDesktopConversationId && await this.client.conversationId?.() !== this.activeDesktopConversationId) {
+                this.desktopSessionValid = false;
+                throw new Error("WorkBuddy 桌面任务已切换，请先创建新会话");
+            }
+            return;
+        }
+        if (this.knownSessions.has(sessionId)) {
+            const binding = this.sessionBindings.get(sessionId);
+            const conversationId = binding?.conversationId ?? (this.recoverableSessionId === sessionId ? this.recoverableConversationId : undefined);
+            if (!conversationId) {
+                this.dailyPointsLogger?.warn("WorkBuddy 会话缺少桌面绑定，已保留记录且未创建新任务", { sessionId });
+                throw new Error("WorkBuddy 会话缺少桌面任务标识，无法安全恢复上下文；请确认后使用 /new 创建新会话");
+            }
+            if (!this.client.activateConversation)
+                throw new Error("WorkBuddy 不支持恢复旧 WorkBuddy 会话");
+            await this.client.activateConversation(conversationId, modelRequest);
+            this.activeSessionId = sessionId;
+            this.activeDesktopConversationId = conversationId;
+            this.activeExpert = binding?.expert;
+            this.desktopSessionValid = true;
+            this.recoverableSessionId = undefined;
+            this.recoverableConversationId = undefined;
+            return;
+        }
+        await this.createSession(sessionId);
+    }
+    async createSession(sessionId, name) {
+        // 点击失败时桌面可能已经切换，保留逻辑绑定但禁止向未知任务续发。
+        this.desktopSessionValid = false;
+        this.activeSessionId = undefined;
+        this.activeDesktopConversationId = undefined;
+        this.knownSessions.add(sessionId);
+        await this.persistKnownSessions();
+        try {
+            await this.client.createTask(name);
+        }
+        catch (error) {
+            this.knownSessions.delete(sessionId);
+            try {
+                await this.persistKnownSessions();
+            }
+            catch (rollbackError) {
+                throw new AggregateError([error, rollbackError], "WorkBuddy 新任务失败且会话记录回滚失败", { cause: error });
+            }
+            throw error;
+        }
+        this.desktopSessionValid = true;
+        this.expertSession = false;
+        this.activeExpert = undefined;
+        this.activeSessionId = sessionId;
+        this.recoverableSessionId = undefined;
+        this.recoverableConversationId = undefined;
+    }
+    async loadKnownSessions(directory) {
+        try {
+            const parsed = JSON.parse(await (0, promises_1.readFile)((0, node_path_1.join)(directory, "known-sessions.json"), "utf8"));
+            if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+                throw new Error("记录根节点无效");
+            const sessionIds = parsed.sessionIds;
+            if (!Array.isArray(sessionIds) || sessionIds.some((sessionId) => typeof sessionId !== "string" || !sessionId.trim()))
+                throw new Error("sessionIds 无效");
+            const active = parsed.active;
+            if (active !== undefined && (!active || typeof active.sessionId !== "string" || !sessionIds.includes(active.sessionId) || typeof active.conversationId !== "string" || !active.conversationId.trim() || (active.expert !== undefined && active.expert !== null && typeof active.expert !== "string")))
+                throw new Error("活动会话绑定无效");
+            const activeBinding = active;
+            const bindingsValue = parsed.bindings;
+            if (bindingsValue !== undefined && (!bindingsValue || typeof bindingsValue !== "object" || Array.isArray(bindingsValue) || Object.entries(bindingsValue).some(([sessionId, binding]) => !sessionIds.includes(sessionId) || !binding || typeof binding !== "object" || typeof binding.conversationId !== "string" || !binding.conversationId.trim() || (binding.expert !== undefined && binding.expert !== null && typeof binding.expert !== "string"))))
+                throw new Error("会话绑定列表无效");
+            const bindings = (bindingsValue ?? {});
+            if (activeBinding && !bindings[activeBinding.sessionId])
+                bindings[activeBinding.sessionId] = { conversationId: activeBinding.conversationId, expert: activeBinding.expert };
+            return { sessionIds: new Set(sessionIds), ...(activeBinding ? { active: activeBinding } : {}), bindings };
+        }
+        catch (error) {
+            if (error.code === "ENOENT")
+                return { sessionIds: new Set() };
+            if (error instanceof SyntaxError || error instanceof Error)
+                throw new Error(`WorkBuddy 已知会话记录无效：${error.message}`);
+            throw new Error("WorkBuddy 已知会话记录无效");
+        }
+    }
+    async persistKnownSessions() {
+        if (!this.sessionDataDir)
+            return;
+        const write = this.sessionWrites.catch(() => { }).then(async () => {
+            await (0, promises_1.mkdir)(this.sessionDataDir, { recursive: true });
+            const file = (0, node_path_1.join)(this.sessionDataDir, "known-sessions.json");
+            const active = this.desktopSessionValid && this.activeSessionId && this.activeDesktopConversationId ? { sessionId: this.activeSessionId, conversationId: this.activeDesktopConversationId, expert: this.activeExpert } : undefined;
+            if (active)
+                this.sessionBindings.set(active.sessionId, { conversationId: active.conversationId, expert: active.expert });
+            await (0, promises_1.writeFile)(`${file}.tmp`, `${JSON.stringify({ sessionIds: [...this.knownSessions].sort(), active, bindings: Object.fromEntries(this.sessionBindings) })}\n`, { mode: 0o600 });
+            await (0, promises_1.rename)(`${file}.tmp`, file);
+        });
+        this.sessionWrites = write;
+        await write;
+    }
+    enqueue(work) {
+        this.pending++;
+        const run = this.queue.then(work, work);
+        this.queue = run.then(() => { this.pending--; }, () => { this.pending--; });
+        return run;
+    }
+    async connectOrStart(config, logger, port, dataDir) {
+        const executable = findExecutable(typeof config.executablePath === "string" ? config.executablePath : this.options.executablePath);
+        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 () => {
+            try {
+                await this.client.connect();
+            }
+            catch (error) {
+                const failure = error;
+                // 只有调试端口拒绝连接才重新启动；页面或协议错误不得触碰桌面进程。
+                if (failure.code !== "ECONNREFUSED" && failure.cause?.code !== "ECONNREFUSED")
+                    throw error;
+                await connectOrLaunch();
+            }
+        };
+        await connectOrLaunch();
+    }
+}
+exports.WorkbuddyPlugin = WorkbuddyPlugin;
+exports.default = WorkbuddyPlugin;