zen-gitsync 2.18.8 → 2.18.9

package/src/ui/server/routes/workbench/taskRunner.codebuddy.test.js

@@ -0,0 +1,275 @@
+// Copyright 2026 xz333221
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+// codebuddy 执行器（CodeBuddy Code CLI）的回归测试（2026-10-12）。
+//
+// 钉住的口径（全部来自当天实测，CLI 2.164.0）：
+//   1. 白名单 / 归一化里有 codebuddy（config.js 与 taskRunner 两份清单一致）
+//   2. spawn argv：-p + stream-json + -y + **--port 0**（避开桌面版占用的 62443）
+//      + 续聊时 --resume <id>；**不出现** --verbose（cbc 不需要，claude 才需要）
+//   3. 子进程环境：DISABLE_AUTOUPDATER / CODEBUDDY_CODE_DISABLE_BACKGROUND_TASKS
+//      必须带上（丢了不会报错，只会某天任务跑到一半被自动更新换掉二进制）；
+//      桌面版注入的五个前缀族 + 单键必须剥掉 —— CODEBUDDY_HOST 与
+//      CODEBUDDY_FORCE_LITE_WB_BUNDLE 是 2026-10-12 实测的两个认证杀手
+//      （后者命中桌面版专属 lite-wb bundle 分流）；官方认证通道
+//      CODEBUDDY_API_KEY / CODEBUDDY_BASE_URL 必须放行
+//   4. 事件映射：init → session_id；assistant 的 text/thinking/tool_use 分派；
+//      user 里的 tool_result 回指；cbc 特有的 system/status、ai-title、result 一律忽略
+//   5. 工具调用是"先 tool_use(running)、后 user(tool_result)"两条，不是一次性终态
+//      （runExternalTurn 的 announced 补 start 机制就是为后者准备的，两条式直接命中）
+//
+// 隔离策略同 taskRunner.opencode.test.js：import taskRunner.js 之前把
+// USERPROFILE/HOME 指向 mkdtemp 沙箱（taskRunner → jobStore import 时就会 hydrate）。
+
+import { test } from 'node:test';
+import assert from 'node:assert/strict';
+import path from 'node:path';
+import os from 'node:os';
+import { mkdtempSync } from 'node:fs';
+import { fileURLToPath, pathToFileURL } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const projectRoot = path.resolve(__dirname, '../../../../..');
+
+// ---- 环境隔离:必须在 import taskRunner.js 之前完成 ----
+const sandbox = mkdtempSync(path.join(os.tmpdir(), 'zen-taskrunner-cb-test-'));
+process.env.USERPROFILE = sandbox;
+process.env.HOME = sandbox;
+delete process.env.HOMEDRIVE;
+delete process.env.HOMEPATH;
+
+const {
+  createCodebuddyEventHandler,
+  buildCodebuddyArgs,
+  buildCodebuddyEnv,
+  normalizeTaskExecutor,
+  TASK_EXECUTORS,
+} = await import(
+  pathToFileURL(path.join(projectRoot, 'src/ui/server/routes/workbench/taskRunner.js')).href
+);
+
+/** 可断言的 appendOutput/appendThinking 收集器 */
+function makeSink() {
+  const sink = { output: [], thinking: [] };
+  sink.appendOutput = (t) => { if (t) sink.output.push(t); };
+  sink.appendThinking = (t) => { if (t) sink.thinking.push(t); };
+  return sink;
+}
+
+/** tracker 探针：只记 handler 喂了哪些 record（不碰真 tracker 的落盘/推送） */
+function makeTrackerSpy() {
+  const records = [];
+  return {
+    records,
+    record: (r) => records.push(r),
+    flush: () => {},
+  };
+}
+
+test('normalizeTaskExecutor：codebuddy 在白名单里，非法值回落 claude', () => {
+  assert.deepEqual(TASK_EXECUTORS, ['claude', 'opencode', 'codex', 'codebuddy']);
+  assert.equal(normalizeTaskExecutor('codebuddy'), 'codebuddy');
+  assert.equal(normalizeTaskExecutor('CodeBuddy'), 'codebuddy');
+  assert.equal(normalizeTaskExecutor('codebuddy '), 'codebuddy');
+  // 历史默认不能变：老配置/老 job 缺 executor 时仍落在 claude
+  assert.equal(normalizeTaskExecutor(undefined), 'claude');
+  assert.equal(normalizeTaskExecutor('cursor'), 'claude');
+});
+
+test('buildCodebuddyArgs：基础 argv 带 -p/stream-json/-y/--port 0，不带 --verbose', () => {
+  const args = buildCodebuddyArgs('');
+  assert.deepEqual(args, ['-p', '--output-format', 'stream-json', '-y', '--port', '0']);
+  // claude 的 stream-json 必须配 --verbose，cbc 不需要 —— 多传一个少传一个都是坑，
+  // 这里双向钉住：不许出现 verbose，也不许漏掉 port 0
+  assert.ok(!args.includes('--verbose'));
+  assert.equal(args[args.indexOf('--port') + 1], '0');
+  // 不传模型：跟随 CLI 自己的配置（与另三家同一口径）
+  assert.ok(!args.includes('--model'));
+});
+
+test('buildCodebuddyArgs：有续聊 id 时 --resume 在前', () => {
+  const args = buildCodebuddyArgs('sess-abc');
+  assert.deepEqual(args.slice(0, 2), ['--resume', 'sess-abc']);
+  assert.ok(args.includes('-p'));
+});
+
+test('buildCodebuddyEnv：禁自动更新 + 禁后台任务 + LANG，前缀级剥掉桌面版注入变量', () => {
+  // 模拟"g gui 在 WorkBuddy 终端里被拉起"：父进程带着桌面版整套注入变量。
+  // 覆盖五个前缀族 + 单键，每族挑代表；逐键断言剥离不留死角。
+  const had = {};
+  const pollution = {
+    // ★ 两个实测认证杀手
+    CODEBUDDY_HOST: 'workbuddy-desktop',
+    CODEBUDDY_FORCE_LITE_WB_BUNDLE: '1',
+    CODEBUDDY_FORCE_HEADLESS_BUNDLE: '1',
+    // 其余 CODEBUDDY_* 家族代表（认证辅助 / 网关 / 设备指纹 / 配置目录 / 会话追踪）
+    CODEBUDDY_API_KEY_HELPER_DISABLED: '1',
+    CODEBUDDY_GATEWAY_PASSWORD: 'secret',
+    CODEBUDDY_QIMEI36: 'device-fp',
+    CODEBUDDY_CONFIG_DIR: 'C:\\Users\\xuze\\.workbuddy',
+    CODEBUDDY_MCP_CONFIG: '{"mcpServers":{}}',
+    CODEBUDDY_SESSION_ID: 'some-session',
+    CODEBUDDY_CURRENT_MODEL_ID: 'some-model',
+    // WORKBUDDY_* / CLIENT_INFO_* / ACC_* / TENCENT_DOCS_LOCAL_* 族代表
+    WORKBUDDY_PAC_RPC_TOKEN: 'secret',
+    WORKBUDDY_PRODUCT_NAME: 'WorkBuddy',
+    CLIENT_INFO_PRODUCT_NAME: 'WorkBuddy',
+    CLIENT_INFO_MACHINE_ID: 'machine-id',
+    ACC_PRODUCT_CONFIG_PATH: 'C:\\Temp\\acc-product-config-v3.json',
+    TENCENT_DOCS_LOCAL_MCP: 'http://127.0.0.1:39099/mcp',
+    TENCENT_DOCS_LOCAL_SERVER: 'http://127.0.0.1:39099',
+    // 单键族：遥测追踪 / 沙箱 / 网关 / 运行时路径
+    BAGGAGE: 'codebuddy.session_id=xxx',
+    TRACEPARENT: '00-abc-def-01',
+    SANDBOX_CENTER_IPC_ADDRESS: '\\\\.\\pipe\\WorkBuddy_SandboxCenter_x',
+    SERVER__PORT: '52710',
+    EXEPATH: 'C:\\Users\\xuze\\AppData\\Local\\Programs\\WorkBuddy\\resources\\vendor\\PortableGit\\bin',
+    ELECTRON_RUN_AS_NODE: '1',
+    // 反例：用户合法认证通道（官方文档 headless 认证）必须保留
+    CODEBUDDY_API_KEY: 'user-key',
+    CODEBUDDY_BASE_URL: 'https://example.com/api',
+    // 反例：用户自己永久设置的变量不在剥离范围
+    DB_HOST: '192.168.3.44',
+  };
+  for (const [k, v] of Object.entries(pollution)) { had[k] = process.env[k]; process.env[k] = v; }
+  try {
+    const env = buildCodebuddyEnv();
+    // ★ 两个杀手必须剥掉：带上任一 CLI 会跑桌面版 bundle / 找桌面版凭据 → Authentication
+    //   required（2026-10-12 逐变量二分 + 日志取证）。这两条测试就是那道防线。
+    assert.equal(env.CODEBUDDY_HOST, undefined);
+    assert.equal(env.CODEBUDDY_FORCE_LITE_WB_BUNDLE, undefined);
+    assert.equal(env.CODEBUDDY_FORCE_HEADLESS_BUNDLE, undefined);
+    for (const k of ['CODEBUDDY_API_KEY_HELPER_DISABLED', 'CODEBUDDY_GATEWAY_PASSWORD',
+      'CODEBUDDY_QIMEI36', 'CODEBUDDY_CONFIG_DIR', 'CODEBUDDY_MCP_CONFIG',
+      'CODEBUDDY_SESSION_ID', 'CODEBUDDY_CURRENT_MODEL_ID']) {
+      assert.equal(env[k], undefined, `${k} 应被 CODEBUDDY_ 前缀剥掉`);
+    }
+    for (const k of ['WORKBUDDY_PAC_RPC_TOKEN', 'WORKBUDDY_PRODUCT_NAME',
+      'CLIENT_INFO_PRODUCT_NAME', 'CLIENT_INFO_MACHINE_ID', 'ACC_PRODUCT_CONFIG_PATH',
+      'TENCENT_DOCS_LOCAL_MCP', 'TENCENT_DOCS_LOCAL_SERVER',
+      'BAGGAGE', 'TRACEPARENT', 'SANDBOX_CENTER_IPC_ADDRESS', 'SERVER__PORT',
+      'EXEPATH', 'ELECTRON_RUN_AS_NODE']) {
+      assert.equal(env[k], undefined, `${k} 应被剥掉`);
+    }
+    // 用户合法认证通道放行（白名单）
+    assert.equal(env.CODEBUDDY_API_KEY, 'user-key');
+    assert.equal(env.CODEBUDDY_BASE_URL, 'https://example.com/api');
+    // 用户自己的变量不受影响
+    assert.equal(env.DB_HOST, '192.168.3.44');
+    // 自己的三个设定仍在（且顺序上是在剥离之后设置的 —— 先设会被前缀规则误伤）
+    assert.equal(env.DISABLE_AUTOUPDATER, '1');
+    assert.equal(env.CODEBUDDY_CODE_DISABLE_BACKGROUND_TASKS, '1');
+    assert.equal(env.LANG, 'zh_CN.UTF-8');
+  } finally {
+    for (const [k, v] of Object.entries(had)) {
+      if (v === undefined) delete process.env[k]; else process.env[k] = v;
+    }
+  }
+});
+
+test('codebuddy 事件：init 落 session_id，text/thinking/tool_use 分派', () => {
+  const job = {};
+  const sink = makeSink();
+  const tracker = makeTrackerSpy();
+  const handle = createCodebuddyEventHandler(job, sink.appendOutput, sink.appendThinking, tracker);
+
+  handle({ type: 'system', subtype: 'init', session_id: 'cbc-sess-1', apiKeySource: 'www.workbuddy.cn', tools: [] });
+  handle({ type: 'assistant', message: { content: [{ type: 'text', text: '你好' }] } });
+  handle({ type: 'assistant', message: { content: [{ type: 'thinking', thinking: '先想想' }] } });
+  handle({ type: 'assistant', message: { content: [{ type: 'tool_use', id: 'tu-1', name: 'Bash', input: { command: 'ls' } }] } });
+
+  assert.equal(job.claudeSessionId, 'cbc-sess-1');
+  assert.deepEqual(sink.output, ['你好']);
+  assert.deepEqual(sink.thinking, ['先想想']);
+  assert.equal(tracker.records.length, 1);
+  assert.deepEqual(tracker.records[0], { id: 'tu-1', name: 'Bash', input: { command: 'ls' }, status: 'running' });
+});
+
+test('codebuddy 事件：user 里的 tool_result 回指 tool_use_id，is_error 映射 error', () => {
+  const job = {};
+  const sink = makeSink();
+  const tracker = makeTrackerSpy();
+  const handle = createCodebuddyEventHandler(job, sink.appendOutput, sink.appendThinking, tracker);
+
+  handle({ type: 'user', message: { content: [{ type: 'tool_result', tool_use_id: 'tu-1', content: 'a.txt\nb.txt' }] } });
+  handle({ type: 'user', message: { content: [{ type: 'tool_result', tool_use_id: 'tu-2', is_error: true, content: 'boom' }] } });
+
+  assert.equal(tracker.records.length, 2);
+  assert.equal(tracker.records[0].id, 'tu-1');
+  assert.equal(tracker.records[0].status, 'done');
+  assert.match(String(tracker.records[0].output), /a\.txt/);
+  assert.equal(tracker.records[1].status, 'error');
+  assert.match(String(tracker.records[1].error), /boom/);
+  // tool_result 是回指，不当正文吐出来
+  assert.deepEqual(sink.output, []);
+});
+
+test('codebuddy 事件：cbc 特有事件（system/status、ai-title、result）一律忽略', () => {
+  const job = {};
+  const sink = makeSink();
+  const tracker = makeTrackerSpy();
+  const handle = createCodebuddyEventHandler(job, sink.appendOutput, sink.appendThinking, tracker);
+
+  handle({ type: 'system', subtype: 'status', status: 'compacting', session_id: 's' });
+  handle({ type: 'ai-title', title: '某个标题' });
+  handle({ type: 'result', subtype: 'success', is_error: false, session_id: 's', usage: {} });
+  // 未知/畸形事件也不能抛错（NDJSON 分行解析里抛错会打死整轮对话）
+  handle(null);
+  handle('not-an-object');
+  handle({ type: 'assistant' });
+  handle({ type: 'assistant', message: { content: 'string-not-array' } });
+  handle({ type: 'user', message: { content: 'plain user prompt' } });
+
+  assert.deepEqual(sink.output, []);
+  assert.deepEqual(sink.thinking, []);
+  assert.equal(tracker.records.length, 0);
+  assert.equal(job.claudeSessionId, undefined);
+});
+
+test('codebuddy 事件：工具调用是两条式（running → tool_result），不是一次性终态', () => {
+  const job = {};
+  const sink = makeSink();
+  const tracker = makeTrackerSpy();
+  const handle = createCodebuddyEventHandler(job, sink.appendOutput, sink.appendThinking, tracker);
+
+  // 实测序列（2026-10-12）：Glob running → Glob 结果 → Read running → Read 结果 → 正文
+  handle({ type: 'assistant', message: { content: [{ type: 'tool_use', id: 'call_1', name: 'Glob', input: { pattern: '**/a.txt' } }] } });
+  handle({ type: 'user', message: { content: [{ type: 'tool_result', tool_use_id: 'call_1', content: [{ type: 'text', text: '["a.txt"]' }] }] } });
+  handle({ type: 'assistant', message: { content: [{ type: 'tool_use', id: 'call_2', name: 'Read', input: { file_path: 'a.txt' } }] } });
+  handle({ type: 'user', message: { content: [{ type: 'tool_result', tool_use_id: 'call_2', content: [{ type: 'text', text: 'hello' }] }] } });
+  handle({ type: 'assistant', message: { content: [{ type: 'text', text: '读完了' }] } });
+
+  assert.deepEqual(tracker.records.map(r => [r.id, r.status]), [
+    ['call_1', 'running'],
+    ['call_1', 'done'],
+    ['call_2', 'running'],
+    ['call_2', 'done'],
+  ]);
+  // tool_result.content 是块数组时抽文本（与 claude 的 extractToolText 同口径）
+  assert.match(String(tracker.records[1].output), /a\.txt/);
+  assert.deepEqual(sink.output, ['读完了']);
+});
+
+test('codebuddy 事件：init 重复推送（实测出现过两条）只认第一条', () => {
+  const job = {};
+  const sink = makeSink();
+  const handle = createCodebuddyEventHandler(job, sink.appendOutput, sink.appendThinking, makeTrackerSpy());
+
+  handle({ type: 'system', subtype: 'init', session_id: 'cbc-sess-x' });
+  handle({ type: 'system', subtype: 'init', session_id: 'cbc-sess-x' });
+
+  assert.equal(job.claudeSessionId, 'cbc-sess-x');
+  assert.deepEqual(sink.output, []);
+});

package/src/ui/server/routes/workbench/taskRunner.js

@@ -15,10 +15,13 @@
 // 任务执行引擎：spawn 本地 agent CLI 跑子任务，流式收集输出，更新 job 状态。
 // 拆分自原 routes/workbench.js 1108-1564 行。
 //
-// 支持三种执行器（executor）：
-//   - claude   —— claude -p --output-format stream-json（默认，历史行为）
-//   - opencode —— opencode run --format json --auto（sst/opencode CLI，跟随其自身默认模型）
-//   - codex    —— codex exec --json（OpenAI Codex CLI，跟随其自身配置；2026-09-27 加入）
+// 支持四种执行器（executor）：
+//   - claude    —— claude -p --output-format stream-json（默认，历史行为）
+//   - opencode  —— opencode run --format json --auto（sst/opencode CLI，跟随其自身默认模型）
+//   - codex     —— codex exec --json（OpenAI Codex CLI，跟随其自身配置；2026-09-27 加入）
+//   - codebuddy —— codebuddy -p --output-format stream-json -y --port 0
+//                  （腾讯 CodeBuddy Code CLI，即 WorkBuddy 桌面版的智能体引擎；
+//                   2026-10-12 加入，协议与 claude 的 stream-json 逐字段对齐）
 //
 // 核心 API：
 //   - launchClaudeInNewWindow(cwd, prompt, resumeSessionId)  spawn claude，返回 {pid, child}
@@ -216,11 +219,32 @@ function attachPromptStdin(child, promptText, resolve, reject) {
 }
 
 // ── 执行器（executor） ──────────────────────────────────────────────────
-// 工作台任务默认由 claude CLI 执行；opencode（2026-09-20）、codex（2026-09-27）
-// 作为可选执行器。三者都用「stdin 喂 prompt + stdout 结构化 JSON 事件流」的同构形态，
-// 差异只在协议：claude 是 stream-json，opencode 是 --format json 的事件 NDJSON，
-// codex 是 exec --json 的 thread/item 事件 NDJSON。
-export const TASK_EXECUTORS = ['claude', 'opencode', 'codex'];
+// 工作台任务默认由 claude CLI 执行；opencode（2026-09-20）、codex（2026-09-27）、
+// codebuddy（2026-10-12）作为可选执行器。四者都用「stdin 喂 prompt + stdout 结构化
+// JSON 事件流」的同构形态，差异只在协议：claude / codebuddy 是 stream-json，
+// opencode 是 --format json 的事件 NDJSON，codex 是 exec --json 的 thread/item 事件 NDJSON。
+//
+// ⚠️ 这份清单与 src/config.js 的 TASK_EXECUTORS 是**同一份口径的两处书写**——
+// 历史上为此吵过（见 agentEngines.js 文件头）：config.js 那份是"配置/归一化"的
+// 真相源，本文件这份服务"运行时分发"。两边不一致的失效方式是 normalize 放行、
+// 这里查无此人 → 静默回落 claude。加第五家时两处都要改，taskRunner.*.test.js 有钉子。
+export const TASK_EXECUTORS = ['claude', 'opencode', 'codex', 'codebuddy'];
+
+/** 执行器 → launcher。runSingleSubtask 与 runExternalTurn 共用这一张表。 */
+export const EXECUTOR_LAUNCHERS = {
+  claude: launchClaudeInNewWindow,
+  opencode: launchOpencodeRun,
+  codex: launchCodexExec,
+  codebuddy: launchCodebuddyPrint,
+};
+
+/** 执行器 → NDJSON 事件处理器工厂。 */
+export const EXECUTOR_HANDLERS = {
+  claude: createClaudeEventHandler,
+  opencode: createOpencodeEventHandler,
+  codex: createCodexEventHandler,
+  codebuddy: createCodebuddyEventHandler,
+};
 
 /** 非法/缺省的 executor 一律回落 'claude'（历史行为的兼容兜底）。
  *  body.executor 来自网络，做一次 trim + 小写归一，与 config.js 同名函数同语义。 */
@@ -390,6 +414,274 @@ export function launchCodexExec(cwd, promptText, resumeSessionId) {
   });
 }
 
+// ── codebuddy 执行器（2026-10-12 加入） ────────────────────────────────────
+// CodeBuddy Code CLI（`codebuddy` / `cbc`，npm 包 @tencent-ai/codebuddy-code）就是
+// WorkBuddy 桌面版内置的智能体引擎。把它接进来 = 工作台/对话面板可以直接调度
+// "WorkBuddy 同款引擎"（同一套工具集、Skills、权限模型），账号体系也是同一个
+// （都走腾讯账号；CLI 侧首次要在终端扫码登录一次，写 ~/.codebuddy）。
+//
+// ⚠️ 与桌面版**不共享任何运行时身份**：桌面版给它自己的子进程注入一整套变量
+// （CODEBUDDY_HOST=workbuddy-desktop / CONFIG_DIR / MCP_CONFIG / 会话追踪 id…），
+// 这套变量继承过来会让 CLI 以"桌面版子进程"身份运行 —— 实测直接认证失败。
+// 全部在 buildCodebuddyEnv 里剥掉，CLI 固定以独立模式读自己的 ~/.codebuddy，
+// 行为可复现，不随 g gui 被谁拉起而变。
+//
+// 实测口径（2026-10-12，CLI 2.164.0，本机与官方文档双向核对）：
+//
+//   codebuddy -p --output-format stream-json -y --port 0 [--resume <sessionId>]
+//     - prompt 从 stdin 喂（-p 无位置参数时读 stdin，与 claude 的 `-p -` 同效，
+//       顺带避开 Windows 命令行 32K 上限）
+//     - --output-format stream-json  NDJSON 事件流，**协议与 claude 逐字段对齐**
+//       （官方文档原话"对齐 Anthropic Claude Code v2.1.88"）：
+//         system/init（带 session_id / tools / model / permissionMode）
+//         assistant（message.content 里的 text / thinking / tool_use 块）
+//         user（message.content 里的 tool_result 块，回指 tool_use_id）
+//         result（终态，带 is_error / errors / usage / total_cost_usd）
+//       另有 system/status、ai-title 等 cbc 特有事件，handler 一律忽略。
+//     - -y        非交互免批准。init 事件回传 permissionMode: 'bypassPermissions'
+//                 （不给 -y 时写操作会被拦，和另三家一个性质）
+//     - --port 0  **每次 spawn 必须显式传**。CLI 每次运行会自带一个引擎服务器，
+//                 默认端口写死 62443 —— 而 WorkBuddy 桌面版常驻就占着 62443，
+//                 不传端口（或传固定值）会 EADDRINUSE 直接退出。0 = 让 OS 选空闲
+//                 端口，实测并发两个任务各起各的互不冲突。
+//     - --resume  续接会话，id 取自上一轮 init 事件的 session_id（落 job.claudeSessionId）
+//     - 不传 --model：模型跟随 CLI 自己的配置（与另三家同一口径，探测见 executorModels.js）
+//     - 不需要 --verbose：claude 的 stream-json 必须配 --verbose，cbc 不用
+//       （实测不带 --verbose 事件流完整）。
+//
+// 登录态：CLI 读 ~/.codebuddy 下的凭据。**首次使用前要先在终端跑一次
+// `codebuddy` 扫码登录**（微信），之后 headless 才能过认证；也可以用
+// CODEBUDDY_API_KEY（+可选 CODEBUDDY_BASE_URL）环境变量认证。读不到凭据时
+// 会话照常起，但模型调用返回 "Authentication required"，表现是一轮秒退的
+// error_during_execution —— 这种失败由 result 事件如实带出，不静默。
+// （另见 buildCodebuddyEnv：桌面版注入的 CODEBUDDY_CONFIG_DIR 会被删掉。）
+
+/**
+ * Windows 下把 codebuddy 解析成可直接 spawn 的目标。
+ *
+ * 三种安装形态都见过（2026-10-12）：
+ *   1. npm 全局（`npm i -g @tencent-ai/codebuddy-code`）—— PATH 上是 .cmd shim，
+ *      shim 实质是 `node <prefix>\node_modules\@tencent-ai\codebuddy-code\bin\codebuddy`。
+ *      Node 23+ 拒绝直接 spawn .cmd（EINVAL），所以像 claude 一样解析到 node + bin 脚本。
+ *   2. 原生二进制安装（install.ps1 → %USERPROFILE%\AppData\Local\codebuddy\bin）——
+ *      PATH 上直接是 codebuddy.exe，优先用（少一层 node 包装，杀进程树也更干净）。
+ *   3. 手动放 PATH 的其它形态 —— 兜底交给 PATH。
+ */
+function resolveCodebuddyExe() {
+  try {
+    const lines = execFileSync('where', ['codebuddy'], { encoding: 'utf8', windowsHide: true })
+      .split(/\r?\n/).map(s => s.trim()).filter(Boolean);
+    // 独立安装优先：PATH 上直接就是原生 exe
+    const directExe = lines.find(s => /\.exe$/i.test(s));
+    if (directExe && fs.existsSync(directExe)) return { exe: directExe, prefixArgs: [] };
+    const cmdShim = lines.find(s => /\.cmd$/i.test(s));
+    if (cmdShim) {
+      const prefix = path.dirname(cmdShim);
+      const binJs = path.join(prefix, 'node_modules', '@tencent-ai', 'codebuddy-code', 'bin', 'codebuddy');
+      if (fs.existsSync(binJs)) return { exe: process.execPath, prefixArgs: [binJs] };
+    }
+  } catch { /* fallback */ }
+  return { exe: 'codebuddy', prefixArgs: [] };
+}
+
+/**
+ * WorkBuddy 桌面版注入给**它自己子进程**的环境变量，一个都不能让 codebuddy 子进程继承。
+ *
+ * ★ 两个实测确认的认证杀手（2026-10-12 逐变量二分 + CLI 日志取证）：
+ *   1. `CODEBUDDY_HOST=workbuddy-desktop` —— 带上它，CLI 认为自己是"桌面版引擎
+ *      的子进程"，转而去找桌面版凭据（`auth/workbuddy-desktop.info`，其解密密钥
+ *      只存在于桌面版运行时），拿不到就报 "Authentication required"（日志：
+ *      AtRestEncryption missing-key → AuthRefresh failed）。而用户明明在
+ *      ~/.codebuddy 登录过。
+ *   2. `CODEBUDDY_FORCE_LITE_WB_BUNDLE=1`（+配套 FORCE_HEADLESS_BUNDLE）——
+ *      bin/codebuddy 里**专为桌面版宿主准备的 bundle 分流通道**（CLI 源码注释
+ *      原话："宿主（workbuddy-server 起 sidecar / prewarm）在 spawn cbc 前设
+ *      CODEBUDDY_FORCE_LITE_WB_BUNDLE=1，直接命中 codebuddy-lite-wb.js"）。
+ *      命中后跑的是 lite-wb 裁剪包，强绑定桌面版身份，同样认证失败
+ *      （日志 ProcessExit 调用栈落在 codebuddy-lite-wb.mjs）。
+ *
+ * 剥离策略：**前缀级 + 认证白名单**。桌面版实测注入 54 个 CODEBUDDY_* 变量
+ * （外加 WORKBUDDY_* / CLIENT_INFO_* / ACC_* / TENCENT_DOCS_LOCAL_* 各家族），
+ * 逐个人肉枚举是在打地鼠 —— FORCE_* 这对杀手就是枚举清单时代漏掉的。
+ *
+ * 判据（为什么这些前缀可以整族剥、为什么"全环境白名单"方向又是错的）：
+ *   看"用户在自己的终端里跑 codebuddy 时环境里有没有它"。桌面版在拉起 g gui
+ *   或它的 sidecar 时注入的这几族变量，用户正常场景**全部不存在**；剥掉它们
+ *   只是把子进程环境对齐到"用户终端里的 codebuddy"，不引入任何新偏差。
+ *   而 DB_* / pw / IMG_LIB 这类用户自己永久设置的变量不在这里剥。
+ *   （反向的"只保留必需变量"白名单同样错：HTTP(S)_PROXY / NODE_EXTRA_CA_CERTS
+ *   这类网络变量是合法继承项，一刀切会把用户的代理环境也切没。）
+ */
+const CODEBUDDY_DESKTOP_ENV_PREFIXES = Object.freeze([
+  'CODEBUDDY_',          // 运行时开关全家（认证白名单见 CODEBUDDY_ENV_KEEP）
+  'WORKBUDDY_',          // 桌面版自家命名空间（含 PAC_RPC_TOKEN 等内部令牌）
+  'CLIENT_INFO_',        // 桌面版客户端身份（PRODUCT_NAME=WorkBuddy / MACHINE_ID / UA 后缀）
+  'ACC_',                // 产品配置注入（ACC_PRODUCT_CONFIG_PATH → workbuddy 产品 json）
+  'TENCENT_DOCS_LOCAL_', // 腾讯文档本地 MCP 地址注入
+]);
+
+/**
+ * 前缀剥离里**必须放行**的例外：官方文档的 headless 认证通道。
+ * 用户在终端里显式设置它们属于正当配置，g gui 继承用户环境 = 继承用户意图。
+ * 只放行有文档背书的这两个（其余几百个 CODEBUDDY_* 开关一律剥，理由见上）。
+ */
+const CODEBUDDY_ENV_KEEP = Object.freeze([
+  'CODEBUDDY_API_KEY',
+  'CODEBUDDY_BASE_URL',
+]);
+
+/**
+ * 不属于任何前缀、但同样只在桌面版会话里出现的单键（逐个人工核对过）。
+ * 归入同一份剥离清单，测试里逐键钉住。
+ */
+const CODEBUDDY_DESKTOP_ENV_KEYS = Object.freeze([
+  // 遥测 / 链路追踪：会把子会话的 trace 挂到桌面版那次会话下
+  'BAGGAGE', 'TRACEPARENT',
+  // 桌面版遥测 SDK 标记
+  'GALILEO_ENABLE', 'GALILEO_SDK_READY',
+  // 桌面版沙箱中心管道 / 网关服务地址（SERVER__PORT 与 SERVICE_PROXY_URL 同端口同源）
+  'SANDBOX_CENTER_IPC_ADDRESS', 'SERVER__HOST', 'SERVER__PORT',
+  // 桌面版运行时路径与 Electron 标记（EXEPATH=桌面版 PortableGit；GENIE_TRASH_DIR=桌面版垃圾箱）
+  'EXEPATH', 'GENIE_TRASH_DIR', 'ELECTRON_RUN_AS_NODE', 'ORIGINAL_XDG_CURRENT_DESKTOP',
+]);
+
+/**
+ * codebuddy 子进程环境。四个刻意为之的取舍：
+ *   - LANG=zh_CN.UTF-8：与另三家一致（CLI 的提示词/输出跟随 locale）。
+ *   - DISABLE_AUTOUPDATER=1：执行器场景**不允许 CLI 自我更新** —— 任务跑到一半
+ *     二进制被换掉，轻则行为漂移重则进程被杀。用户想更新自己跑 `codebuddy update`。
+ *   - CODEBUDDY_CODE_DISABLE_BACKGROUND_TASKS=1：-p 单发模式进程随首个 result
+ *     结束，收不了后台任务的跨轮回推事件（官方文档对 SDK query() 单发用法也是
+ *     这么处理的）。禁掉之后模型的 run_in_background 参数从工具 schema 里隐藏，
+ *     不会出现"派了后台任务然后永远等不到通知"。
+ *   - **剥掉桌面版注入的前缀族**（见上方注释的两个杀手 —— 不剥 CODEBUDDY_HOST
+ *     或 CODEBUDDY_FORCE_LITE_WB_BUNDLE 都会直接认证失败，2026-10-12 实测）。
+ * （导出仅为回归测试可见：taskRunner.codebuddy.test.js 钉住剥/留两侧的边界）
+ */
+export function buildCodebuddyEnv() {
+  const env = { ...process.env };
+  const keep = new Set(CODEBUDDY_ENV_KEEP);
+  for (const key of Object.keys(env)) {
+    if (keep.has(key)) continue;
+    if (CODEBUDDY_DESKTOP_ENV_KEYS.includes(key)) { delete env[key]; continue; }
+    if (CODEBUDDY_DESKTOP_ENV_PREFIXES.some((p) => key.startsWith(p))) delete env[key];
+  }
+  // 自己的三项在**剥离之后**设置：CODEBUDDY_CODE_DISABLE_BACKGROUND_TASKS 本身
+  // 命中 CODEBUDDY_ 前缀，若像从前那样先合并进来会被剥离循环顺手删掉。
+  env.LANG = 'zh_CN.UTF-8';
+  env.DISABLE_AUTOUPDATER = '1';
+  env.CODEBUDDY_CODE_DISABLE_BACKGROUND_TASKS = '1';
+  return env;
+}
+
+/**
+ * codebuddy 的 spawn argv（纯函数，抽出来为了能**真的跑断言**而不用 spawn 进程 ——
+ * 与 fileOpen.js 的 buildOpencodeArgs / buildCodexArgs 同一个理由。
+ *
+ * 口径见上方大注释。`--port 0` 是实测出来的必须项：CLI 自带引擎服务器占固定端口
+ * 62443，与 WorkBuddy 桌面版冲突，0 让 OS 选空闲端口（并发任务互不打架）。
+ */
+export function buildCodebuddyArgs(resumeSessionId) {
+  const args = [];
+  if (resumeSessionId) {
+    args.push('--resume', String(resumeSessionId));
+  }
+  args.push(
+    '-p',
+    '--output-format', 'stream-json',
+    '-y',
+    '--port', '0'
+  );
+  return args;
+}
+
+/** spawn codebuddy 跑一个 prompt（非交互），返回 { pid, child }（参数口径见上方注释）。 */
+export async function launchCodebuddyPrint(cwd, promptText, resumeSessionId) {
+  const args = buildCodebuddyArgs(resumeSessionId);
+  const { exe, prefixArgs } = resolveCodebuddyExe();
+  const spawnArgs = [...prefixArgs, ...args];
+  return new Promise((resolve, reject) => {
+    let child;
+    if (process.platform === 'win32') {
+      child = spawn(exe, spawnArgs, {
+        cwd,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        windowsHide: false,
+        env: buildCodebuddyEnv()
+      });
+    } else {
+      child = spawn(exe, spawnArgs, {
+        cwd,
+        detached: true,
+        stdio: ['pipe', 'pipe', 'pipe'],
+        env: buildCodebuddyEnv()
+      });
+    }
+    attachPromptStdin(child, promptText, resolve, reject);
+  });
+}
+
+/**
+ * codebuddy stream-json 事件处理器。
+ *
+ * **协议与 claude 逐字段对齐**（2026-10-12 实测：init/assistant/user/result 四种
+ * 事件、content 块的 text/thinking/tool_use、user 事件里的 tool_result 回指，
+ * 全部同构；工具调用同样是"先 tool_use(running)、后 user(tool_result)"两条）。
+ * 所以这里刻意**另写一份**而不是直接复用 createClaudeEventHandler：
+ * 对齐是实测结论、不是合同 —— cbc 还多出 system/status、ai-title 等自有事件，
+ * 将来协议分叉时在这里修，不会顺带改坏 claude 那条链路（本仓库对"同一份口径
+ * 多处实现"的失效方式有惨痛记忆：不报错，只是悄悄少一半数据）。
+ *
+ * 已知被忽略的事件：system/status、system/task_*（后台任务，已被
+ * CODEBUDDY_CODE_DISABLE_BACKGROUND_TASKS 禁用）、ai-title、result。
+ * （导出仅为回归测试可见：taskRunner.codebuddy.test.js）
+ */
+export function createCodebuddyEventHandler(job, appendOutput, appendThinking, toolCalls) {
+  const tracker = toolCalls || createToolCallTracker(job);
+  return (evt) => {
+    if (!evt || typeof evt !== 'object') return;
+    // init：session_id 落 job.claudeSessionId（--resume 续接用）
+    if (evt.type === 'system' && evt.subtype === 'init' && typeof evt.session_id === 'string') {
+      if (!job.claudeSessionId || job.claudeSessionId !== evt.session_id) {
+        job.claudeSessionId = evt.session_id;
+        publish('job:update', job);
+      }
+      return;
+    }
+    // 工具结果：与 claude 完全同构 —— user 事件的 content 是块数组，
+    // 里面才是 tool_result（用户自己那条 prompt 的 content 是字符串，不会走到这）
+    if (evt.type === 'user') {
+      const ublocks = evt.message?.content;
+      if (Array.isArray(ublocks)) {
+        for (const b of ublocks) {
+          if (b && b.type === 'tool_result' && b.tool_use_id) {
+            const text = extractToolText(b.content);
+            tracker.record({
+              id: b.tool_use_id,
+              status: b.is_error ? 'error' : 'done',
+              output: text,
+              error: b.is_error ? (text || '工具执行失败') : ''
+            });
+          }
+        }
+      }
+      return;
+    }
+    if (evt.type !== 'assistant') return;
+    const blocks = evt.message?.content;
+    if (!Array.isArray(blocks)) return;
+    for (const b of blocks) {
+      if (b.type === 'text' && typeof b.text === 'string') {
+        appendOutput(b.text);
+      } else if (b.type === 'thinking' && typeof b.thinking === 'string') {
+        appendThinking(b.thinking);
+      } else if (b.type === 'tool_use') {
+        tracker.record({ id: b.id, name: b.name, input: b.input, status: 'running' });
+      }
+    }
+  };
+}
+
 // ── 工具调用（tool_use）收集 ──────────────────────────────────────────────
 // 为什么要有这一层：job.output 只承载「模型说的话」。工具调用（读了哪个文件、跑了什么命令、
 // 拿到了什么结果）原本在两个事件处理器里被整段丢掉，于是前端只剩「思考 + 正文」两块，
@@ -901,10 +1193,10 @@ export function createCodexEventHandler(job, appendOutput, appendThinking, toolC
  * @param {object} [options]
  * @param {string|null} [options.resumeSessionId]
  *        续接历史会话:claude 走 --resume <id>，opencode 走 --session <id>，
- *        codex 走 exec resume <thread_id>。
- *        id 来自上一轮 stream 事件捕获的会话标识(三者都记在 job.claudeSessionId)。
+ *        codex 走 exec resume <thread_id>，codebuddy 走 --resume <session_id>。
+ *        id 来自上一轮 stream 事件捕获的会话标识(四家都记在 job.claudeSessionId)。
  * @param {string} [options.executor]
- *        执行器 'claude' | 'opencode' | 'codex'。缺省回落 'claude'；路由层负责把
+ *        执行器 'claude' | 'opencode' | 'codex' | 'codebuddy'。缺省回落 'claude'；路由层负责把
  *        "body 指定 > 配置默认"先解析好再传进来。
  * @returns {Promise<'done'|'cancelled'|'error'>} 本次运行的终态
  */
@@ -990,8 +1282,8 @@ export async function runSingleSubtask(task, sub, repoPath, branch, options) {
     // 路由层用它保证"用同一个 CLI 续同一个会话"。
     agent: executor,
     // 续接历史会话时先填上,首条协议事件回来后再用真值覆盖(通常等同)。
-    // 字段名保留 claudeSessionId:claude 的 session_id 和 opencode 的 sessionID
-    // 都存这里,语义是"该执行器的会话续接标识"。
+    // 字段名保留 claudeSessionId:claude 的 session_id / opencode 的 sessionID /
+    // codebuddy 的 session_id 都存这里,语义是"该执行器的会话续接标识"。
     claudeSessionId: resumeSessionId,
     // 工具调用流水（{id,name,argsPreview,arguments,result,status,error}[]）。
     // 先给个空数组，前端拿到的 job:update 就有了稳定形态，不用到处判 undefined。
@@ -1013,11 +1305,9 @@ export async function runSingleSubtask(task, sub, repoPath, branch, options) {
   let toolTracker = null;
 
   try {
-    const launcher = executor === 'opencode'
-      ? launchOpencodeRun
-      : executor === 'codex'
-        ? launchCodexExec
-        : launchClaudeInNewWindow;
+    // 查表而不是 if 链：加执行器只改 EXECUTOR_LAUNCHERS 一张表（四家以后 if 链
+    // 已经长得该收了）。查无此人理论上不可能 —— normalizeTaskExecutor 刚夹过一遍。
+    const launcher = EXECUTOR_LAUNCHERS[executor] || launchClaudeInNewWindow;
     const { pid, child } = await launcher(repoPath || process.cwd(), prompt, resumeSessionId);
     job.pid = pid;
     // 保存 child 引用，供 cancel 接口调用 kill
@@ -1074,11 +1364,8 @@ export async function runSingleSubtask(task, sub, repoPath, branch, options) {
       publish('job:toolcalls', { id: job.id, updates });
     });
 
-    const handleEvent = executor === 'opencode'
-      ? createOpencodeEventHandler(job, appendOutput, appendThinking, toolTracker)
-      : executor === 'codex'
-        ? createCodexEventHandler(job, appendOutput, appendThinking, toolTracker)
-        : createClaudeEventHandler(job, appendOutput, appendThinking, toolTracker);
+    const makeHandler = EXECUTOR_HANDLERS[executor] || createClaudeEventHandler;
+    const handleEvent = makeHandler(job, appendOutput, appendThinking, toolTracker);
 
     const handleLine = (line, channel) => {
       const trimmed = line.trim();