zen-gitsync 2.17.16 → 2.17.18

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

@@ -43,9 +43,8 @@ import {
   fsp,
   PROMPTS_FILE,
   TASKS_FILE,
-  CONFIG_FILE,
   JOBS_FILE,
-  ORCHESTRATOR_FILE,
+  TRUTH_FILES,
   IMAGES_DIR,
   MAX_IMAGE_BYTES,
   MAX_ATTACHMENTS_PER_TASK,
@@ -110,6 +109,7 @@ import {
   canonicalProjectPath,
 } from './projectRegistry.js';
 import { buildEnvContextBlock } from './envContext.js';
+import { createJobSettledRefresher } from '../aiContext/jobRefresh.js';
 import { resolveInstructionTarget } from './targetResolver.js';
 import {
   readOrchestrator,
@@ -122,11 +122,24 @@ import {
   buildRunningAgents,
 } from './orchestratorStore.js';
 
+/**
+ * 「任务结束 → 刷快照」的监听器。存成模块级的，是为了在重复装配路由时
+ * 先把上一个摘掉（bus 是模块级单例，否则同一次 job 结束会被刷好几遍）。
+ * @type {((evt: object) => boolean)|null}
+ */
+let jobSettledHandler = null;
+
 /**
  * 解析本次执行用哪个执行器：body.executor 显式指定 > 配置里的全局默认 > 'claude'。
  * 配置读失败一律回落 'claude' —— 执行器选不出来不该挡住任务本身能跑。
+ *
+ * ⚠️ `configManager` **必须从参数传进来**（2026-09-28 修复）：这里是模块作用域，
+ * 而 configManager 只是 registerWorkbenchRoutes 的形参 —— 直接引用会抛
+ * ReferenceError，被下面这个 try 吞掉，表现为"配置里的全局默认执行器**永远不生效**、
+ * 每次都悄悄回落 claude"，且只在日志里留一条看不太出问题的 warn。
+ * 以后往这个函数里加依赖，一律走形参。
  */
-async function resolveExecutor(requested) {
+async function resolveExecutor(requested, configManager) {
   const explicit = normalizeTaskExecutor(requested);
   if (explicit) return explicit;
   try {
@@ -149,8 +162,17 @@ async function resolveExecutor(requested) {
  * @param {() => string} deps.getProjectRoomId
  * @param {import('socket.io').Server} deps.io
  * @param {Object} deps.configManager
+ * @param {() => object|null} [deps.getAiContextSnapshotter]
+ *        工作区状态快照生成器（延迟取值的 getter，见下面 setEnvContextProvider 的注释）
  */
-export function registerWorkbenchRoutes({ app, getCurrentProjectPath, getProjectRoomId, io, configManager }) {
+export function registerWorkbenchRoutes({
+  app,
+  getCurrentProjectPath,
+  getProjectRoomId,
+  io,
+  configManager,
+  getAiContextSnapshotter,
+}) {
   // ════════════════════════════════════════════════════════════════════════
   // §1. AI 生成提示词（基于当前项目）
   // ════════════════════════════════════════════════════════════════════════
@@ -563,7 +585,7 @@ ${subSummaries.map((s, i) => `\n### [${i + 1}] ${s.name} (${s.root})\n${s.summar
     const liveJob = snapshotJobs().find(j => j.taskId === task.id && (j.status === 'running' || j.status === 'pending'));
     if (liveJob) throw new HttpError(400, '该任务已有正在执行的 job');
     const repoPath = resolveTaskRepoPath(task, typeof getCurrentProjectPath === 'function' ? getCurrentProjectPath() : '');
-    const executor = await resolveExecutor(req.body?.executor);
+    const executor = await resolveExecutor(req.body?.executor, configManager);
     const virtualSub = {
       id: `${task.id}__simple`,
       title: task.title,
@@ -1097,45 +1119,69 @@ ${subSummaries.map((s, i) => `\n### [${i + 1}] ${s.name} (${s.root})\n${s.summar
   /**
    * 注册「运行环境上下文」的提供者 —— 执行引擎（taskRunner）拼 prompt 时会回调它。
    *
-   * 为什么在这一层注册：只有这里同时拿得到 configManager（最近目录）与 jobStore
-   * 的 job 快照；taskRunner 两个都没有，放它那儿就得再造一条「读最近目录」的路径，
-   * 也就是又一次口径分叉。
+   * ⚠️ 数据**不再在这里现读**。项目清单 / 各列计数 / 合计口径一律从
+   * aiContext 的 `tasks` 板块拿（collectWorkbenchTasks 的结构化 `data`）。
+   * 以前这里是"读 tasks.json + 最近目录 + buildProjectEntries + summarizeProjectTasks"
+   * 的第二份实现，与 aiContext 那份是同一个口径的两个副本 —— 改一处漏一处不会报错，
+   * 只会让 Agent 在编排台里和智能体页里看到**不同的项目数**。现在只剩一份。
    *
-   * 复用 buildProjectEntries + summarizeProjectTasks（与看板同一套口径），
-   * 但**刻意不走** listProjects：那是给看板用的，会去 spawn git 探状态。
-   * 分支、改动数这类信息 Agent 在自己的 cwd 里一条 git 命令就有，
-   * 不值得为它在这里每次执行都多探一轮。
+   * 拿之前先**强制刷一次 tasks**：这次派发出去的 prompt 必须看到"刚刚"的看板状态
+   *（别的 g ui 实例刚跑完的任务、刚改过状态的任务）。tasks 的 forceTtlMs = 0，是真刷，
+   * 成本与改动前（每次都现读 tasks.json + refreshJobsFromDisk）完全一样。
+   *
+   * 为什么是 getter 而不是直接传 snapshotter：本函数在 registerWorkbenchRoutes 里被调用，
+   * 而快照生成器在服务端入口创建、注册顺序在它之前就已经建好了 —— 但两者是同一次装配，
+   * 用 getter 可以避免"必须记得按某个顺序注册"这种隐性契约。
    */
   setEnvContextProvider(async ({ repoPath } = {}) => {
-    const data = await readJson(TASKS_FILE, { tasks: [] });
-    const tasks = data.tasks || [];
-    // 任务状态同样由执行记录推导：不刷磁盘的话，Agent 看到的会是本进程启动那一刻的
-    // 旧状态（别的 g ui 跑完的任务在它眼里还没完成）。
-    await refreshJobsFromDisk();
+    const snapshotter = typeof getAiContextSnapshotter === 'function' ? getAiContextSnapshotter() : null;
+
+    if (!snapshotter || typeof snapshotter.refreshSections !== 'function') {
+      // 快照生成器没装配上（理论上不会发生）。至少把**不需要取数**的两样递进去：
+      // 用户偏好与真相源路径 —— 前者少一次就会让任务卡在 https 凭据窗口上。
+      return buildEnvContextBlock({ currentProjectPath: repoPath || '', truthFiles: TRUTH_FILES });
+    }
 
-    let recentDirs = [];
     try {
-      if (configManager && typeof configManager.getRecentDirectories === 'function') {
-        recentDirs = (await configManager.getRecentDirectories()) || [];
-      }
+      await snapshotter.refreshSections(['tasks'], { force: true });
+    } catch (err) {
+      // 刷不动就用快照里已有的（哪怕旧一点）—— 上下文是锦上添花，
+      // 不能因为它挂了就让用户的指令执行不了（与 taskRunner.resolveEnvContext 同一条原则）。
+      logger.warn('[workbench] 注入运行环境上下文前刷新 tasks 板块失败，改用现有快照:', err?.message || err);
+    }
+
+    let board = null;
+    try {
+      // 用 getSectionResult 而不是 getSnapshot：后者会顺手把其余过期板块推到后台刷，
+      // 派发任务没理由因此去拉 gh/gitee（只在智能体页聊天时才值得那样做）。
+      board = snapshotter.getSectionResult?.('tasks')?.data || null;
     } catch (err) {
-      // 与 loadBoardPayload 同一处理：读不到最近目录就退化成"只按任务里出现过的项目"
-      logger.warn('[workbench] 注入运行环境上下文时读取最近目录失败，退化为仅按任务路径:', err.message);
+      logger.warn('[workbench] 读取快照里的 tasks 板块失败，本次只注入偏好与真相源路径:', err?.message || err);
     }
 
-    const projects = buildProjectEntries({ recentDirs, tasks });
     return buildEnvContextBlock({
       currentProjectPath: repoPath || '',
-      projects,
-      tasks,
-      jobs: snapshotJobs(),
-      tasksFile: TASKS_FILE,
-      jobsFile: JOBS_FILE,
-      orchestratorFile: ORCHESTRATOR_FILE,
-      configFile: CONFIG_FILE,
+      board,
+      truthFiles: TRUTH_FILES,
     });
   });
 
+  /**
+   * 「工作台任务执行结束」→ 定向刷新快照。
+   *
+   * 挂在 jobStore 的事件总线上（本层已经在消费同一条总线做 SSE 广播）。
+   * 终态判定与去重都在 createJobSettledRefresher 里，见那个文件的头注释。
+   *
+   * `bus.on` 前先 `off` 掉上一个：bus 是模块级单例，重复注册（例如同一进程里
+   * 再次装配路由）会让同一次 job 结束被刷好几遍。
+   */
+  if (jobSettledHandler) bus.off('event', jobSettledHandler);
+  jobSettledHandler = createJobSettledRefresher({
+    getSnapshotter: getAiContextSnapshotter,
+    onError: (err) => logger.warn('[workbench] 任务结束后刷新工作区快照失败:', err?.message || err),
+  });
+  bus.on('event', jobSettledHandler);
+
   app.get('/api/workbench/projects', asyncRoute(async (_req, res) => {
     const payload = await loadBoardPayload();
     res.json({ success: true, ...payload });
@@ -1439,7 +1485,7 @@ ${subSummaries.map((s, i) => `\n### [${i + 1}] ${s.name} (${s.root})\n${s.summar
         attachments: [],
       };
       // 派发控制台可以显式指定执行器；不传则用配置里的全局默认（resolveExecutor 走回落链）
-      const executor = await resolveExecutor(req.body?.executor);
+      const executor = await resolveExecutor(req.body?.executor, configManager);
       runSingleSubtask(task, virtualSub, targetPath, '', { executor }).catch(err => {
         publish('task:error', { taskId: task.id, error: err.message });
       });

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

@@ -0,0 +1,279 @@
+// 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.
+//
+// 外部 CLI 引擎的「一轮对话」执行器。
+//
+// 与内置 g ai 的**根本差别**：谁跑智能体循环。
+//   g ai     ── 服务端跑：streamChatOnce 拿 LLM 流 → 服务端 executeTool → 回灌 → 循环
+//   外部 CLI ── CLI 跑：它有自己的工具集、系统提示词、权限模型。服务端退化成一根管子，
+//               只负责 spawn、把它的 NDJSON 翻译成与 g ai **完全相同**的一组 SSE 事件。
+//
+// 所以这个文件里**没有**任何模型调用、工具执行、安全守卫 —— 那些都是 CLI 自己的事。
+//
+// ⚠️ 两条不重复实现的红线（本仓库 agentParity.test.js 就是为这类分叉立的规矩）：
+//   1. **spawn 与协议解析一律复用 taskRunner.js**，绝不在这里再写一份。
+//      `createClaudeEventHandler` / `createOpencodeEventHandler` / `createCodexEventHandler`
+//      的签名是 `(job, appendOutput, appendThinking, toolCalls)` —— 回调早已抽象好，
+//      这里只是换一组回调（推 SSE 而不是推工作台面板），所以适配层能很薄。
+//   2. **权限档不在这里决定**。taskRunner 的 launcher 已经带死了各自的档位
+//      （claude: --permission-mode bypassPermissions --dangerously-skip-permissions；
+//        opencode: --auto；codex: --dangerously-bypass-approvals-and-sandbox），
+//      与工作台任务执行保持一致。要改档位请改 launcher，别在这儿加参数。
+//
+// 关于 headless 权限（2026-09-28 实测，三家在非交互下的真实行为）：
+//   claude   默认档也能跑，但不放开会挡住写操作；工作台那套是 bypassPermissions。
+//   codex    默认档是只读沙箱（写文件被拦），所以要 --dangerously-bypass-...
+//   opencode **不给 --auto 会卡死**（在等一个永远不会有人回答的交互式批准）。
+//   这正是 AgentView 里没有终端、没人能点"允许"所决定的 —— 必须预设档位。
+
+import { spawn, execFile } from 'child_process';
+import { logger } from './shared.js';
+import { engineLabel } from './agentEngines.js';
+import {
+  createToolCallTracker,
+  createClaudeEventHandler,
+  createOpencodeEventHandler,
+  createCodexEventHandler,
+  launchClaudeInNewWindow,
+  launchOpencodeRun,
+  launchCodexExec,
+} from './taskRunner.js';
+
+/** 引擎 → spawn 实现。复用 taskRunner，不另写（见文件头红线 1）。 */
+export const ENGINE_LAUNCHERS = {
+  claude: launchClaudeInNewWindow,
+  opencode: launchOpencodeRun,
+  codex: launchCodexExec,
+};
+
+/** 引擎 → NDJSON 事件处理器工厂。同样复用 taskRunner。 */
+export const ENGINE_HANDLERS = {
+  claude: createClaudeEventHandler,
+  opencode: createOpencodeEventHandler,
+  codex: createCodexEventHandler,
+};
+
+/** 输出片段最长保留多少字符（与前端 MAX_LOG_DISPLAY 的口径一致，防止会话文件膨胀） */
+const MAX_ACCUM = 400_000;
+
+/**
+ * 杀掉 CLI 进程树。
+ *
+ * 为什么不能只 child.kill()：claude/opencode/codex 都会自己再拉起子进程（它跑的命令、
+ * 它的内部 worker）。只杀父进程的话，用户点了「停止」但机器上还有东西在跑 ——
+ * 表现为"界面停了，文件还在被改"。Windows 上必须 taskkill /T。
+ */
+function killChildTree(child) {
+  if (!child || !child.pid || child.exitCode !== null) return;
+  try {
+    if (process.platform === 'win32') {
+      execFile('taskkill', ['/PID', String(child.pid), '/T', '/F'], { windowsHide: true }, () => {});
+    } else {
+      child.kill('SIGTERM');
+    }
+  } catch { /* 尽力而为：杀不掉也不该让整轮对话抛错 */ }
+}
+
+/**
+ * 跑一轮外部 CLI 引擎的对话。
+ *
+ * @param {object}   args
+ * @param {object}   args.session        会话记录（会被就地更新：messages / engineSessionId）
+ * @param {string}   args.engine         'claude' | 'opencode' | 'codex'
+ * @param {string}   args.userMessage    用户这一轮说的话
+ * @param {string}   args.cwd            工作目录
+ * @param {string}   [args.promptPrefix] 拼在用户消息**前面**的工作区状态块（见 agentRoutes）
+ * @param {string[]} [args.filePaths]    本轮附件落盘的绝对路径，附在用户消息后面
+ * @param {AbortSignal} [args.signal]    用户点「停止」时中止
+ * @param {(evt: object) => void} args.send  SSE 发送器
+ * @param {(child: object) => void} [args.onChild]  spawn 成功后回传，供路由层做中止兜底
+ * @param {object}   [args.launchers]    注入口（单测传假的，避免真 spawn CLI）
+ * @param {object}   [args.handlers]     注入口（同上）
+ * @param {Function} [args.killTree]     杀进程树的实现（单测注入，Windows 上真实现走 taskkill）
+ * @returns {Promise<{aborted: boolean}>}
+ */
+export async function runExternalTurn({
+  session,
+  engine,
+  userMessage,
+  cwd,
+  promptPrefix = '',
+  filePaths = [],
+  signal,
+  send,
+  onChild,
+  launchers = ENGINE_LAUNCHERS,
+  handlers = ENGINE_HANDLERS,
+  killTree = killChildTree,
+} = {}) {
+  const label = engineLabel(engine);
+  const launch = launchers[engine];
+  const makeHandler = handlers[engine];
+  if (typeof launch !== 'function' || typeof makeHandler !== 'function') {
+    send({ type: 'error', error: `未知的外部引擎: ${engine}` });
+    return { aborted: false };
+  }
+
+  if (!Array.isArray(session.messages)) session.messages = [];
+
+  // 附件只传**路径**，内容不进 prompt —— 与 g ai 那条链路同一条口径
+  // （外部 CLI 自己有 read 工具，让它按需读，省 token 也更准）。
+  const attachBlock = (Array.isArray(filePaths) ? filePaths : []).filter(Boolean).length > 0
+    ? `\n\n---\n\n本轮附件已落盘到以下绝对路径，请按需读取：\n${filePaths.filter(Boolean).map(p => `- ${p}`).join('\n')}`
+    : '';
+
+  session.messages.push({ role: 'user', content: userMessage || ' ' });
+
+  // 工作区状态块拼在**用户消息前面**：外部 CLI 都只认自己的约定文件，
+  // 而往项目里写 AGENTS.md / CLAUDE.md 会弄脏用户的工作区（三个引擎实测也不一致：
+  // claude 只读 CLAUDE.md、codex 只读 AGENTS.md、opencode 两个都不读）。
+  // 所以统一走 prompt 前缀 —— 一份实现喂三家，且不碰用户的仓库。
+  const prompt = `${promptPrefix ? `${promptPrefix}\n\n---\n\n` : ''}${userMessage || ''}${attachBlock}`;
+
+  let child;
+  try {
+    const launched = await launch(cwd, prompt, session.engineSessionId || '');
+    child = launched?.child;
+    if (!child) throw new Error('launcher 未返回子进程');
+  } catch (err) {
+    const msg = `${label} 启动失败：${err?.message || err}`;
+    send({ type: 'error', error: msg });
+    return { aborted: false };
+  }
+  if (typeof onChild === 'function') onChild(child);
+
+  // job 只是**载体**：taskRunner 的 handler 与 tracker 都按 job.toolCalls /
+  // job.claudeSessionId 这两个字段工作。用一个轻量对象顶上，任务记录不受影响。
+  const job = { toolCalls: [], claudeSessionId: session.engineSessionId || '' };
+
+  let text = '';
+  const appendText = (t) => {
+    if (typeof t !== 'string' || !t) return;
+    text = text.length > MAX_ACCUM ? text : text + t;
+    send({ type: 'content', delta: t });
+  };
+
+  // 工具调用：tracker 的增量回调直接映射成前端已有的两种事件。
+  // 外部 CLI 都给不出"命令执行中的增量输出"（那是 g ai 服务端执行才有的），
+  // 所以不发 tool_output —— 前端的 toolCall.result 从空开始、tool_result 时一次填满。
+  //
+  // ⚠️ **必须先补一条 tool_call_start**，哪怕这次更新已经是终态：
+  //   claude 会先推 tool_use(running)、再推 tool_result；但 **opencode 与 codex 是
+  //   一次性推一条已完成的事件**（opencode state.status=completed / codex item.completed），
+  //   根本没有 running 阶段。前端收到 tool_result 时是按 toolCallId 去已有列表里 find 的，
+  //   找不到就**静默丢弃** —— 表现是"工具明明跑了，界面上什么都没有"。
+  //   所以这里按 id 记一份"已宣告过"，第一次见到就补 start。
+  const announced = new Set();
+  const tracker = createToolCallTracker(job, (updates) => {
+    for (const u of updates) {
+      if (!u) continue;
+      const id = u.id || '';
+      if (id && !announced.has(id)) {
+        announced.add(id);
+        send({ type: 'tool_call_start', toolCallId: id, name: u.name, argsPreview: u.argsPreview || '' });
+      }
+      if (u.status !== 'running') {
+        send({
+          type: 'tool_result',
+          toolCallId: id,
+          result: u.status === 'error' ? (u.error || u.result || '工具执行失败') : (u.result || ''),
+        });
+      }
+    }
+  });
+
+  const handleEvent = makeHandler(job, appendText, (t) => {
+    // 思考过程：与正文分开推，前端有独立可折叠区域
+    send({ type: 'thinking', delta: t });
+  }, tracker);
+
+  // NDJSON 分行：最后一段可能不完整，留给下一批（与 taskRunner 同一套做法）
+  const lineBuf = { stdout: '', stderr: '' };
+  const handleLine = (line, channel) => {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    if (channel === 'stderr' || !trimmed.startsWith('{')) {
+      // 非 JSON 行：原样贴出来（CLI 的告警 / 老版本输出都是这种）
+      appendText(trimmed + '\n');
+      return;
+    }
+    let evt;
+    try { evt = JSON.parse(trimmed); } catch { return; }
+    handleEvent(evt);
+  };
+  const parseLines = (channel, buf) => {
+    lineBuf[channel] += buf.toString('utf8');
+    const lines = lineBuf[channel].split('\n');
+    lineBuf[channel] = lines.pop() ?? '';
+    for (const line of lines) handleLine(line, channel);
+    tracker.flush?.();
+  };
+  if (child.stdout) child.stdout.on('data', (b) => parseLines('stdout', b));
+  if (child.stderr) child.stderr.on('data', (b) => parseLines('stderr', b));
+
+  // 中止：杀进程树，然后把已完成的部分当成本轮结果落盘（与 g ai 的"已停止"口径一致）
+  let aborted = false;
+  const onAbort = () => {
+    aborted = true;
+    killTree(child);
+  };
+  if (signal) {
+    if (signal.aborted) onAbort();
+    else signal.addEventListener('abort', onAbort, { once: true });
+  }
+
+  await new Promise((resolve) => {
+    let done = false;
+    const finish = () => { if (!done) { done = true; resolve(); } };
+    child.on('close', finish);
+    child.on('error', (err) => {
+      logger.warn(`[agent] ${engine} 子进程出错: ${err?.message || err}`);
+      finish();
+    });
+  });
+  signal?.removeEventListener?.('abort', onAbort);
+
+  // 进程退出时 stdout 里可能残留最后一段没换行的 NDJSON
+  if (lineBuf.stdout.trim()) for (const l of lineBuf.stdout.split('\n')) handleLine(l, 'stdout');
+  if (lineBuf.stderr.trim()) for (const l of lineBuf.stderr.split('\n')) handleLine(l, 'stderr');
+  tracker.flush?.();
+
+  // 落盘：assistant（带 tool_calls）+ 逐条 tool 结果，形状与 g ai 那条链路一致，
+  // 前端 convertSessionToMessages 的合并逻辑不用改就能渲染历史。
+  const calls = Array.isArray(job.toolCalls) ? job.toolCalls : [];
+  const assistantMsg = { role: 'assistant', content: text };
+  if (calls.length > 0) {
+    assistantMsg.tool_calls = calls.map(c => ({
+      id: c.id,
+      type: 'function',
+      function: { name: c.name || 'tool', arguments: c.arguments || '' },
+    }));
+  }
+  session.messages.push(assistantMsg);
+  for (const c of calls) {
+    session.messages.push({
+      role: 'tool',
+      tool_call_id: c.id,
+      name: c.name || 'tool',
+      content: String(c.status === 'error' ? (c.error || c.result || '') : (c.result || '')),
+    });
+  }
+
+  // 续聊标识：三家字段名不同（claude session_id / opencode sessionID / codex thread_id），
+  // 但 taskRunner 的 handler 已经统一落到 job.claudeSessionId 上，这里只做搬运。
+  if (job.claudeSessionId) session.engineSessionId = job.claudeSessionId;
+
+  send({ type: 'done', content: aborted ? `${text}\n\n[已停止]` : text });
+  return { aborted };
+}