@harness-mix/cli 0.2.1 → 0.2.2

package/CHANGELOG.md

@@ -1,5 +1,9 @@
 # Changelog
 
+## 0.2.2 — 2026-09-18
+
+- Aligns all six `@harness-mix/native-*` runtime packages at 0.2.2 with the CLI and pins `optionalDependencies` to the same version. 0.2.1 shipped with pins still at 0.1.11, so a fresh install's postinstall could overwrite the bundled fresh Shim binaries with the old-contract 0.1.11 ones; supersedes 0.2.1. Native binaries are rebuilt from unchanged Rust sources.
+
 ## 0.2.1 — 2026-09-18
 
 - Turn transcripts now match Codex's native three-stage experience: opening remarks and inter-tool commentary stream live as progress-phase agent messages alongside command rows while the turn runs, and on completion Codex Desktop folds every progress segment and tool item under the elapsed-time bar, leaving only the final-phase conclusion visible. The previous buffer-and-reclassify-as-reasoning approach (which hid narration while running) is removed.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@harness-mix/cli",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "license": "(Apache-2.0 OR MIT)",
   "description": "Harness Mix native Codex UI bridge for Codex, Pi, Claude Code, DeepSeek Harness, Antigravity, CodeBuddy, Kiro CLI, Cursor CLI and other native coding harnesses.",
   "keywords": [
@@ -182,11 +182,11 @@
     "zod": "4.4.3"
   },
   "optionalDependencies": {
-    "@harness-mix/native-win32-x64": "0.1.11",
-    "@harness-mix/native-win32-arm64": "0.1.11",
-    "@harness-mix/native-darwin-x64": "0.1.11",
-    "@harness-mix/native-darwin-arm64": "0.1.11",
-    "@harness-mix/native-linux-x64": "0.1.11",
-    "@harness-mix/native-linux-arm64": "0.1.11"
+    "@harness-mix/native-win32-x64": "0.2.2",
+    "@harness-mix/native-win32-arm64": "0.2.2",
+    "@harness-mix/native-darwin-x64": "0.2.2",
+    "@harness-mix/native-darwin-arm64": "0.2.2",
+    "@harness-mix/native-linux-x64": "0.2.2",
+    "@harness-mix/native-linux-arm64": "0.2.2"
   }
 }

package/src/main/host/runtime.js

@@ -26,7 +26,7 @@ const { createWorkspace, inspectWorkspace, reviewWorkspace, applyWorkspace, remo
  * 仍由其原生程序维护，Adapter 只负责原生协议接入与事件转换。
  */
 class HostRuntime {
-  constructor({ dataDirectory, observer = null, stuckTurnMs = 15 * 60 * 1000, stuckSweepMs = 60 * 1000 }) {
+  constructor({ dataDirectory, observer = null, stuckTurnMs = 15 * 60 * 1000, stuckSweepMs = 60 * 1000, delegationTimeoutMs = 30 * 60 * 1000 }) {
     this.store = new ThreadStore(dataDirectory);
     this.threads = [];
     this.sessions = new Map(); // threadId -> { adapter, ...session }
@@ -41,9 +41,14 @@ class HostRuntime {
     this.reviewTasks = new Set();
     this.openings = new Map();
     this.sending = new Set();
-    // send 进行中被 cancel 的线程：Turn 尚未开始或 prompt 尚未投递时 abort 无从生效，
-    // 由 #send 在 Turn 启动后/投递前据此结算取消，避免用户看不见的僵尸运行
-    this.cancelRequests = new Set();
+    // threadId -> 在途 send 的票据：cancel 会提前放锁让新发送进入，
+    // 旧 send 退出时凭票据比对，避免其 finally 误删新发送的锁
+    this.sendTickets = new Map();
+    this.sendTicketSeq = 0;
+    // send 进行中被 cancel 的线程（threadId -> 被取消 send 的票据）：Turn 尚未开始或
+    // prompt 尚未投递时 abort 无从生效，由 #send 在 Turn 启动后/投递前据此结算取消，
+    // 避免用户看不见的僵尸运行；票据不匹配的陈旧登记属上一代发送，由 #send 入口清理
+    this.cancelRequests = new Map();
     this.switching = new Set();
     // 同目录并发会话警告的去重记录：threadId -> 上次提醒时间
     this.concurrentCwdNotified = new Map();
@@ -52,6 +57,8 @@ class HostRuntime {
     // 即按超时结算，让 UI 停转、审查快照收尾。等待用户审批的回合属合法静默。
     this.turnActivity = new Map();
     this.stuckTurnMs = stuckTurnMs;
+    // /delegate 委派等待子任务结算的上限（对齐协作编排的 30 分钟），注入以便测试
+    this.delegationTimeoutMs = delegationTimeoutMs;
     this.watchdogTimer = setInterval(() => this.#sweepStuckTurns(), stuckSweepMs);
     this.watchdogTimer.unref?.();
     // 跨 Harness 协作：parentThreadId -> { childId, toolCallId, cancelled }
@@ -320,14 +327,26 @@ class HostRuntime {
     // Reserve before opening a native session: two submissions can otherwise both
     // pass isRunning() while awaiting the same opening promise.
     if (this.sending.has(threadId)) throw new Error('任务正在执行，请先停止或等待完成');
+    const ticket = ++this.sendTicketSeq;
     this.sending.add(threadId);
-    try { return await this.#send(threadId, text, { commandId, attachments, delegateOf, collaborationOf, isolated, turnPermissions }); }
-    finally { this.sending.delete(threadId); this.cancelRequests.delete(threadId); }
+    this.sendTickets.set(threadId, ticket);
+    try { return await this.#send(threadId, text, { commandId, attachments, delegateOf, collaborationOf, isolated, turnPermissions, ticket }); }
+    // cancel() 会提前放锁并让新发送进入：仅当票据仍归本次发送时才回收，否则
+    // 这里的 delete 会误删新发送的锁，使第三个发送与在途发送并发撞车
+    finally {
+      if (this.sendTickets.get(threadId) === ticket) {
+        this.sending.delete(threadId);
+        this.sendTickets.delete(threadId);
+        this.cancelRequests.delete(threadId);
+      }
+    }
   }
 
-  async #send(threadId, text, { commandId, attachments, delegateOf, collaborationOf, isolated, turnPermissions }) {
+  async #send(threadId, text, { commandId, attachments, delegateOf, collaborationOf, isolated, turnPermissions, ticket }) {
     const thread = this.#requireThread(threadId);
     if (this.execution.isRunning(thread.id)) throw new Error("任务正在执行，请先停止或等待完成");
+    // 清理上一代发送遗留的取消登记（票据不匹配说明属于已结算的旧 send）
+    if (this.cancelRequests.get(threadId) !== ticket) this.cancelRequests.delete(threadId);
     const prepared = this.#prepareAttachments(thread, attachments);
     const typed = typeof text === "string" ? text.trim() : "";
     if (!typed && !prepared.images.length && !prepared.texts.length) throw new Error("请输入消息");
@@ -430,7 +449,10 @@ class HostRuntime {
     delete thread.errorKind;
     this.execution.turnStarted(thread, displayPrompt);
     // 会话打开/prompt 组装期间用户已按停止（cancel 时 Turn 尚未开始，原生侧无从 abort）：直接结算取消，不再投递
-    if (this.cancelRequests.delete(thread.id)) this.#applyEvent({ threadId, event: { kind: 'completed', stopReason: 'cancelled' } });
+    if (this.cancelRequests.get(thread.id) === ticket) {
+      this.cancelRequests.delete(thread.id);
+      this.#applyEvent({ threadId, event: { kind: 'completed', stopReason: 'cancelled' } });
+    }
     this.turnActivity.set(thread.id, Date.now());
     const message = thread.messages.at(-1);
     if (hasConcurrentTurn) message.concurrent = true;
@@ -548,12 +570,23 @@ class HostRuntime {
     let answer = '';
     try {
       await this.send(child.id, task, { delegateOf: parent.id });
-      // Adapter 返回≠原生 Turn 完全结算，兜底等待至子任务真正空闲
-      const grace = Date.now() + 30_000;
-      while (this.execution.isRunning(child.id) && Date.now() < grace) await new Promise(resolve => setTimeout(resolve, 100));
-      const lastTurn = this.execution.lastTurn(child.id);
-      if (lastTurn?.status === 'error') failure = new Error(lastTurn.error || '子任务执行失败');
-      else answer = this.#turnFinalText(child.id);
+      // Adapter 返回≠原生 Turn 完全结算（Pi 等非阻塞适配器收到 prompt ack 即返回，实际
+      // 执行由异步流驱动），有界等待至子任务真正空闲——对齐协作编排的 30 分钟上限，
+      // 超时主动取消子任务；已 wedge 的子任务由看门狗（stuckTurnMs）提前按 error 结算。
+      const until = Date.now() + this.delegationTimeoutMs;
+      while (this.execution.isRunning(child.id) && !delegation?.cancelled) {
+        if (Date.now() > until) {
+          await this.cancel(child.id);
+          failure = new Error(`子任务超过 ${Math.round(this.delegationTimeoutMs / 60000)} 分钟未结算，已自动取消`);
+          break;
+        }
+        await new Promise(resolve => setTimeout(resolve, 100));
+      }
+      if (!failure) {
+        const lastTurn = this.execution.lastTurn(child.id);
+        if (lastTurn?.status === 'error') failure = new Error(lastTurn.error || '子任务执行失败');
+        else answer = this.#turnFinalText(child.id);
+      }
     } catch (error) { failure = error; }
     const cancelled = delegation?.cancelled;
     this.delegations.delete(parent.id);
@@ -615,8 +648,8 @@ class HostRuntime {
 
   async cancel(threadId) {
     const thread = this.threads.find(t => t.id === threadId);
-    // send 进行中（会话恢复 / prompt 尚未投递）时 abort 可能落空：登记取消请求，由 #send 在投递前结算
-    if (this.sending.has(threadId)) this.cancelRequests.add(threadId);
+    // send 进行中（会话恢复 / prompt 尚未投递）时 abort 可能落空：按票据登记取消请求，由 #send 在投递前结算
+    if (this.sending.has(threadId)) this.cancelRequests.set(threadId, this.sendTickets.get(threadId));
     // If this thread is a collaboration child task, mark the collaboration job as cancelled immediately
     const childJob = [...this.collaboration.jobs.values()].find(j => j.childId === threadId && j.status === 'running');
     if (childJob) {
@@ -625,7 +658,9 @@ class HostRuntime {
     }
     // Record the user's cancellation immediately so UI and Core become idle without waiting on subtasks
     if (thread && this.execution.isRunning(thread.id)) this.#applyEvent({ threadId, event: { kind: 'completed', stopReason: 'cancelled' } });
+    // 立即放锁让用户可以重发；同时作废旧 send 的票据，其 finally 不得误删新发送的锁
     this.sending.delete(threadId);
+    this.sendTickets.delete(threadId);
     // Cancel child collaboration tasks with a hard timeout to prevent child hangs
     try {
       await Promise.race([
@@ -765,6 +800,8 @@ class HostRuntime {
     } else this.sessions.set(thread.id, attachSession(adapter, session, thread.id));
     await this.#save();
     this.#broadcast();
+    // 与 createThread 同一契约：通知 Desktop 侧边栏实时挂载分支会话（protocol.js 据此发 thread/started）
+    for (const listener of this.listeners) listener({ type: 'thread-created', thread });
     return thread;
   }
 
@@ -1179,6 +1216,11 @@ class HostRuntime {
       const last = this.turnActivity.get(thread.id) ?? this.execution.lastTurn(thread.id)?.createdAt ?? now;
       if (now - last < this.stuckTurnMs) continue;
       this.turnActivity.delete(thread.id);
+      // 级联取消原生会话：仅结算 Turn 而不 abort，原生进程（死循环脚本/挂起的长连接）会
+      // 常驻后台，下一次发送直接撞上原生侧的会话占用报错（如 Pi 的 already processing），
+      // 该 Thread 永久无法恢复。fire-and-forget 不阻塞扫描；迟到事件由 execution.apply 忽略。
+      const session = this.sessions.get(thread.id);
+      if (session) void Promise.race([session.adapter.cancel(session), new Promise(r => setTimeout(r, 2000))]).catch(() => {});
       this.#applyEvent({ threadId: thread.id, event: { kind: 'error', timestamp: now,
         message: `原生会话超过 ${Math.round(this.stuckTurnMs / 60000)} 分钟未产生任何事件，判定为卡死并已自动结算。如原生进程仍在运行，可手动取消或开启新回合。` } });
     }

package/src/main/native/protocol.js

@@ -1154,7 +1154,11 @@ class NativeProtocol {
     const pending = this.approvals.get(message.id);
     if (!pending) return false;
     if (message.error) throw new Error(message.error.message || 'Approval UI error');
-    const answer = message.result?.answers?.[pending.requestId]?.answers?.[0];
+    // Desktop 的 answers 为 string[]：多选提问（如 ACP/OpenCode multiple）勾选多项时
+    // 只取 [0] 会无声吞掉其余选项，且 opencode 对 multiple 题执行 JSON.parse(response.value)，
+    // 单值字符串会直接抛 SyntaxError——多答案 JSON 编码全量保留，单答案维持原字符串。
+    const rawAnswers = message.result?.answers?.[pending.requestId]?.answers;
+    const answer = Array.isArray(rawAnswers) && rawAnswers.length > 1 ? JSON.stringify(rawAnswers) : (rawAnswers?.[0] ?? '');
     const decision = message.result?.decision;
     const response = pending.item.type === 'question' ? { value: answer || '' } : pending.item.method === 'select' ? { value: answer || '' } : { confirmed: decision === 'accept' || decision === 'acceptForSession' };
     await this.runtime.respondApproval(pending.threadId, pending.requestId, response);