@harness-mix/cli 0.2.0 → 0.2.1

package/scripts/pi-cancel-race-test.cjs

@@ -0,0 +1,102 @@
+// Pi 家族 adapter 的「取消竞态」单元测试（不起原生进程、不走模型）：
+// Pi RPC 的 prompt 在 preflight 完成后才 ack，期间 abort 没有活动 run 可停，会落空；
+// 修复后：cancel 落在 prompt in-flight 窗口时，ack 之后必须补发一发 abort，
+// 把刚启动的 run 真正停掉，避免用户看不见的僵尸运行。
+const { piFamily } = require('../src/main/adapters/pi-family');
+
+let passed = 0;
+let failed = 0;
+function test(name, fn) {
+  Promise.resolve()
+    .then(fn)
+    .then(() => { passed++; console.log('ok', name); })
+    .catch((error) => { failed++; console.error('FAIL', name, '-', error.message); process.exitCode = 1; });
+}
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+function fakeSession({ preflightMs = 50, failFirst = null } = {}) {
+  const calls = [];
+  let promptAttempts = 0;
+  return {
+    calls,
+    get aborts() { return calls.filter((c) => c.type === 'abort').length; },
+    get prompts() { return calls.filter((c) => c.type === 'prompt'); },
+    process: {
+      harnessMixAnswer: undefined,
+      async command(payload) {
+        calls.push(payload);
+        if (payload.type === 'prompt') {
+          promptAttempts += 1;
+          if (failFirst && promptAttempts === 1) throw new Error(failFirst);
+          // 模拟 preflight：ack 之前的异步窗口（此时原生侧尚无 active run）
+          await sleep(preflightMs);
+          return {};
+        }
+        if (payload.type === 'abort') return {};
+        return {};
+      },
+    },
+  };
+}
+
+const adapter = piFamily({ id: 'pi', name: 'Pi', icon: '', bin: 'pi', packageHint: '' }).create(() => {});
+const hooks = { emit() {} };
+
+// 1) cancel 落在 preflight 窗口：ack 后必须补发第二发 abort
+test('cancel during prompt preflight re-issues abort after ack', async () => {
+  const session = fakeSession({ preflightMs: 60 });
+  const pending = adapter.send(session, 'hello', hooks);
+  await sleep(10); // prompt 已发出、ack 未回（in-flight）
+  await adapter.cancel(session); // 第一发 abort（原生侧落空）
+  await pending;
+  await sleep(10); // 补发是 fire-and-forget，等它落盘
+  if (session.aborts !== 2) throw new Error(`expected 2 aborts (cancel + re-abort after ack), got ${session.aborts}`);
+});
+
+// 2) 正常路径：send 已完成后再 cancel，不应多补 abort
+test('cancel after prompt ack does not re-abort', async () => {
+  const session = fakeSession({ preflightMs: 5 });
+  await adapter.send(session, 'hello', hooks);
+  await adapter.cancel(session);
+  await sleep(10);
+  if (session.aborts !== 1) throw new Error(`expected exactly 1 abort, got ${session.aborts}`);
+});
+
+// 3) 无 cancel：不应多任何 abort
+test('plain send issues no abort', async () => {
+  const session = fakeSession({ preflightMs: 5 });
+  await adapter.send(session, 'hello', hooks);
+  await sleep(10);
+  if (session.aborts !== 0) throw new Error(`expected 0 aborts, got ${session.aborts}`);
+});
+
+// 4) already processing → followUp 排队路径上 cancel：ack 后同样补停
+test('cancel during followUp-queue retry also re-aborts after ack', async () => {
+  const session = fakeSession({ preflightMs: 60, failFirst: 'Agent is already processing. Specify streamingBehavior...' });
+  const pending = adapter.send(session, 'hello', hooks);
+  await sleep(10);
+  await adapter.cancel(session);
+  await pending;
+  await sleep(10);
+  if (session.prompts.length !== 2) throw new Error(`expected prompt retry as followUp, got ${session.prompts.length} prompts`);
+  if (session.prompts[1].streamingBehavior !== 'followUp') throw new Error('retry must use streamingBehavior followUp');
+  if (session.aborts !== 2) throw new Error(`expected 2 aborts (cancel + re-abort after ack), got ${session.aborts}`);
+});
+
+// 5) preflight 失败（ack 拒绝）后 cancel 标志不残留、不误伤后续 send
+test('failed preflight clears in-flight state; later send unaffected', async () => {
+  const session = fakeSession({ failFirst: 'Authentication failed for "kimi-coding"' });
+  await adapter.send(session, 'hello', hooks).catch(() => {});
+  await adapter.cancel(session); // 此时已无 in-flight
+  await sleep(10);
+  if (session.aborts !== 1) throw new Error(`expected exactly 1 abort, got ${session.aborts}`);
+  await adapter.send(session, 'again', hooks); // 第二次 send 走 preflight 成功
+  await sleep(10);
+  if (session.aborts !== 1) throw new Error(`stale cancel flag leaked into later send (aborts=${session.aborts})`);
+});
+
+process.on('beforeExit', () => {
+  console.log(`pi-cancel-race: ${passed} passed${failed ? `, ${failed} failed` : ''}`);
+  if (failed) process.exitCode = 1;
+});

package/scripts/stuck-turn-test.cjs

@@ -0,0 +1,73 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs/promises');
+const os = require('node:os');
+const path = require('node:path');
+const { HostRuntime } = require('../src/main/host/runtime');
+
+const sleep = ms => new Promise(resolve => setTimeout(resolve, ms));
+async function until(fn) {
+  for (let i = 0; i < 300; i++) { if (fn()) return; await sleep(10); }
+  throw new Error('timed out');
+}
+
+// 卡死回合看门狗：原生 Harness wedge（零事件）时回合必须按超时自动结算；
+// 活跃回合与等待审批的合法静默回合不得被误杀。
+(async () => {
+  const directory = await fs.mkdtemp(path.join(os.tmpdir(), 'hm-stuck-turn-'));
+  const root = path.join(directory, 'workspace');
+  await fs.mkdir(root);
+
+  const rt = new HostRuntime({ dataDirectory: directory, stuckTurnMs: 300, stuckSweepMs: 50 });
+  await rt.store.load();
+
+  const emits = new Map();
+  const adapter = {
+    manifest: { id: 'test-harness', name: 'Test', capabilities: {} },
+    async open(input) { emits.set(input.thread.id, input.emit); return {}; },
+    async send(session) {},
+    async cancel(session) {},
+    async close() {},
+  };
+  rt.adapters.set(adapter.manifest.id, adapter);
+  rt.status[adapter.manifest.id] = { available: true };
+
+  try {
+    // 1. 持续有事件的活跃回合：看门狗不得误伤
+    const active = await rt.createThread({ harnessId: 'test-harness', cwd: root });
+    await rt.send(active.id, 'keep emitting');
+    const emitActive = emits.get(active.id);
+    for (let i = 0; i < 8; i++) { emitActive({ kind: 'text-delta', text: '.' }); await sleep(80); }
+    assert.equal(rt.execution.isRunning(active.id), true, 'active turn must survive the watchdog');
+    emitActive({ kind: 'completed', finalAnswer: true });
+    await until(() => active.status === 'ready' && !active.reviewPending);
+
+    // 2. 等待用户审批的回合是合法静默：超过阈值也不得结算
+    const approval = await rt.createThread({ harnessId: 'test-harness', cwd: root });
+    await rt.send(approval.id, 'needs approval');
+    const emitApproval = emits.get(approval.id);
+    emitApproval({ kind: 'approval', requestId: 'r1', method: 'confirm', title: 'Allow?' });
+    await sleep(700);
+    assert.equal(rt.execution.isRunning(approval.id), true, 'approval-waiting turn is legitimate silence and must survive');
+    emitApproval({ kind: 'interaction-responded', requestId: 'r1' });
+    emitApproval({ kind: 'completed', finalAnswer: true });
+    await until(() => approval.status === 'ready' && !approval.reviewPending);
+
+    // 3. 零事件 wedge 回合：超时后自动按错误结算，UI 不再永远转圈
+    const stuck = await rt.createThread({ harnessId: 'test-harness', cwd: root });
+    await rt.send(stuck.id, 'wedged session');
+    await until(() => stuck.status === 'error');
+    assert.match(stuck.error, /卡死/);
+    const turn = rt.execution.lastTurn(stuck.id);
+    assert.equal(turn.status, 'error');
+    await until(() => !stuck.reviewPending);
+    const open = rt.core.getItemsForTurn(turn.id).filter(item => !['completed', 'error', 'cancelled'].includes(item.status));
+    assert.equal(open.length, 0, 'watchdog settlement finalizes every open item');
+
+    console.log('stuck-turn-test: active/approval-waiting turns survive; wedged zero-event turn auto-settles and finalizes items');
+  } finally {
+    await rt.close();
+  }
+})().catch(error => {
+  console.error(error);
+  process.exitCode = 1;
+});

package/scripts/workspace-test.cjs

@@ -49,6 +49,15 @@ const { HostRuntime } = require('../src/main/host/runtime');
   await fs.symlink(path.join(directory, 'outside'), path.join(root, 'link'), 'junction');
   await assert.rejects(resolveFile(root, 'link/file.txt'), /不跟随/);
   const empty = diff('', ''); assert.equal(empty.rows.length, 0);
+  // 行尾符幻影：LF 基线 vs CRLF 当前内容（逐行相同）不产生变更，也不进入审查记录
+  const eol = diff('alpha\nbravo\n', 'alpha\r\nbravo\r\n');
+  assert.equal(eol.added, 0); assert.equal(eol.removed, 0);
+  assert.ok(diff('alpha\n', 'alpha\r\nbravo\r\n').added === 1, '真实新增行不受行尾归一化影响');
+  const eolStore = new ReviewStore(path.join(directory, 'eol')), eolId = await eolStore.begin(root);
+  await fs.writeFile(path.join(root, 'dirty.js'), 'user preexisting change\r\nold line\r\n');
+  const eolPreview = await eolStore.preview(eolId);
+  assert.ok(!eolPreview.changes.some(c => c.path === 'dirty.js'), 'CRLF-only flip is not a change');
+  await fs.writeFile(path.join(root, 'dirty.js'), 'user preexisting change\nold line\n');
   const rt = new HostRuntime({ observer: new ParityObserver(), dataDirectory: path.join(directory, 'runtime') });
   const updates = [];
   rt.subscribe(e => { if (e.type === 'turn/diff/updated') updates.push(e); });

package/src/assets/skins/dream-skin/NOTICE.md

@@ -0,0 +1,13 @@
+# Codex Dream Skin — bundled preset notice
+
+The `themes/gothic-void-crusade/` preset is redistributed from
+[Fei-Away/Codex-Dream-Skin](https://github.com/Fei-Away/Codex-Dream-Skin)
+(MIT License, see `licenses/codex-dream-skin-MIT.txt`).
+
+| Asset | Origin | License |
+| --- | --- | --- |
+| `themes/gothic-void-crusade/hero.webp` | `macos/presets/preset-gothic-void-crusade/background.jpg` (2560×1440), re-encoded to WebP. Original gothic sci-fi artwork designed and contributed to the source project by [@seansong-ideogram](https://github.com/seansong-ideogram). | MIT (via source repository) |
+| `themes/gothic-void-crusade/theme.json` | Source preset metadata, kept verbatim for provenance. Not read at runtime; the renderer skin definition lives in `src/native-ui/renderer-extension/src/settings/skin-runtime.ts`. | MIT (via source repository) |
+
+Palette and preview focus are taken from the source `theme.json`
+(`colors.background/accent/muted/text`, `art.focusX/focusY`).

package/src/assets/skins/dream-skin/themes/gothic-void-crusade/theme.json

@@ -0,0 +1,34 @@
+{
+  "schemaVersion": 1,
+  "id": "preset-gothic-void-crusade",
+  "name": "Gothic Void Crusade",
+  "brandSubtitle": "CODEX DREAM SKIN",
+  "tagline": "A solemn cathedral-world horizon for focused work.",
+  "projectPrefix": "Select project · ",
+  "projectLabel": "◉  Select project",
+  "statusText": "VOID CRUSADE ONLINE",
+  "quote": "MAKE SOMETHING WONDERFUL",
+  "image": "background.jpg",
+  "appearance": "dark",
+  "art": {
+    "focusX": 0.76,
+    "focusY": 0.45,
+    "safeArea": "left",
+    "taskMode": "ambient"
+  },
+  "colors": {
+    "background": "#0d0d0e",
+    "panel": "#171513",
+    "panelAlt": "#211d18",
+    "accent": "#c8a55a",
+    "accentAlt": "#e3c27a",
+    "secondary": "#74352e",
+    "highlight": "#8a2f27",
+    "text": "#f3ead7",
+    "muted": "#b5a386",
+    "line": "rgba(200, 165, 90, .28)"
+  },
+  "promoTitle": "Codex Dream Skin",
+  "promoSub": "Gothic Void Crusade",
+  "promoUrl": "https://github.com/Fei-Away/Codex-Dream-Skin"
+}

package/src/main/adapters/claude.js

@@ -272,6 +272,9 @@ function spawnSession(sdk, { cwd, resumeId, newSessionId, permissionMode, modelI
     state: { turn: null, crashed: false, lastUsage: undefined, latestPlanLimit: undefined, checkpointId: undefined },
   };
 
+  // Host 侧投影异常绝不能杀死原生事件泵：crashed 只保留给真正的原生流错误。
+  const safeEmit = (mapped) => { try { emit(mapped); } catch { /* host projection must not kill the native pump */ } };
+
   session.query = sdk.query({
     prompt: input,
     options: {
@@ -293,7 +296,7 @@ function spawnSession(sdk, { cwd, resumeId, newSessionId, permissionMode, modelI
           }
         }
         const requestId = randomUUID();
-        emit(projectApproval(requestId, toolName, toolInput, suggestions));
+        safeEmit(projectApproval(requestId, toolName, toolInput, suggestions));
         return new Promise((resolve) => {
           const onAbort = () => {
             session.pendingApprovals.delete(requestId);
@@ -316,7 +319,7 @@ function spawnSession(sdk, { cwd, resumeId, newSessionId, permissionMode, modelI
           session.nativeSessionId = event.session_id;
           session.model = { id: event.model, name: event.model };
           session.permissionMode = event.permissionMode ?? session.permissionMode;
-          emit({ kind: "session", nativeSessionId: event.session_id, model: session.model });
+          safeEmit({ kind: "session", nativeSessionId: event.session_id, model: session.model });
           continue;
         }
         if (event.type === "rate_limit_event") {
@@ -326,7 +329,7 @@ function spawnSession(sdk, { cwd, resumeId, newSessionId, permissionMode, modelI
             if (typeof onPlanLimit === "function") onPlanLimit(limit);
             const current = session.state.lastUsage || {};
             session.state.lastUsage = applyClaudePlanLimitToUsage(current, limit);
-            emit({ kind: "usage", usage: session.state.lastUsage });
+            safeEmit({ kind: "usage", usage: session.state.lastUsage });
           }
           continue;
         }
@@ -337,14 +340,14 @@ function spawnSession(sdk, { cwd, resumeId, newSessionId, permissionMode, modelI
           for (const mapped of projectEvent(event)) {
             // 结算事件携带原生检查点（assistant uuid），供 fork 边界定位
             if (mapped.kind === 'completed') mapped.nativeRef = { ...mapped.nativeRef, checkpointId: session.state.checkpointId };
-            emit(mapped);
+            safeEmit(mapped);
           }
           session.state.turn?.resolve();
           session.state.turn = null;
           continue;
         }
         if (event.type === 'assistant' && event.uuid) session.state.checkpointId = event.uuid;
-        for (const mapped of projectEvent(event)) emit(mapped);
+        for (const mapped of projectEvent(event)) safeEmit(mapped);
       }
       // 流正常结束（close）：未结算的回合按取消处理
       session.state.turn?.resolve();
@@ -352,7 +355,7 @@ function spawnSession(sdk, { cwd, resumeId, newSessionId, permissionMode, modelI
     } catch (error) {
       session.state.crashed = true;
       if (session.state.turn) { session.state.turn.reject(error); session.state.turn = null; }
-      else emit({ kind: "error", message: `Claude 会话中断：${error.message}` });
+      else safeEmit({ kind: "error", message: `Claude 会话中断：${error.message}` });
     }
   })();
   return session;

package/src/main/adapters/pi-family.js

@@ -26,6 +26,15 @@ function sanitizeName(title) {
   return String(title || "").replace(/["&|<>^%]/g, "").trim().slice(0, 40) || "Harness Mix 任务";
 }
 
+// 文件编辑类工具的目标路径（结构化元数据）：Host 用它把全工作区快照收窄为
+// 「本轮真实触碰的文件」，让并发同目录的会话各自只显示自己的改动。
+const FILE_EDIT_TOOLS = new Set(["edit", "write", "multiedit", "multi_edit", "apply_patch"]);
+function editTarget(event) {
+  const tool = String(event.toolName || "").toLowerCase();
+  const target = event.args && typeof event.args.path === "string" ? event.args.path : null;
+  return FILE_EDIT_TOOLS.has(tool) && target ? { path: target } : {};
+}
+
 /** 工具结果里的图片块 → 统一 artifact 事件（各 Harness 返回产物在桌面层对齐呈现；超大图片不入会话存档） */
 function imageArtifacts(content, toolCallId) {
   if (!Array.isArray(content)) return [];
@@ -68,9 +77,11 @@ function piFamily({ id, name, icon, bin, packageHint, aliases }) {
     recordNative(manifest.id, event);
     if (event.type === 'message_update' && event.assistantMessageEvent?.type === 'text_delta' && event.assistantMessageEvent.delta) process.harnessMixAnswer = (process.harnessMixAnswer || '') + event.assistantMessageEvent.delta;
     if (event.type === 'message_end' && event.message?.role === 'assistant') {
-      if (event.message.stopReason === 'error' || event.message.errorMessage) {
-        emit({ kind: 'error', message: event.message.errorMessage || `${name} native model turn failed` });
-      } else if (!process.harnessMixAnswer) {
+      // 失败不在 message_end 定论：紧随其后的 agent_end 携带 willRetry，由它决定投影
+      // 「自动重试中」还是最终错误。若在此直接发 error，Host 会提前把 Turn 结算为失败，
+      // 自动重试成功的事件全被丢弃，用户重发消息还会撞上原生 "Agent is already processing"。
+      const failed = event.message.stopReason === 'error' || event.message.errorMessage;
+      if (!failed && !process.harnessMixAnswer) {
         const answer = Array.isArray(event.message.content) ? event.message.content.filter(block => block?.type === 'text').map(block => block.text || '').join('\n') : '';
         if (answer) emit({ kind: 'text-delta', text: answer });
       }
@@ -137,10 +148,31 @@ function piFamily({ id, name, icon, bin, packageHint, aliases }) {
         // 图片走 RPC 原生 images 字段（base64）；文本附件由 Host 内联进 text
         const images = (attachments?.images ?? []).map((a) => ({ type: 'image', data: a.data, mimeType: a.mime }));
         session.process.harnessMixAnswer = '';
-        await session.process.command({ type: "prompt", message: text, ...(images.length ? { images } : {}) });
+        // Pi 的 prompt 命令在 preflight（扩展 input 钩子、压缩检查等）完成后才 ack；
+        // 此期间 abort 没有活动 run 可停，会落空，消息在 ack 后照常开跑（僵尸运行）。
+        // 用 in-flight 计数 + cancelRequested 标志：ack 之后补一发 abort 把刚启动的 run 真正停掉。
+        session.promptInFlight = (session.promptInFlight || 0) + 1;
+        try {
+          try {
+            await session.process.command({ type: "prompt", message: text, ...(images.length ? { images } : {}) });
+          } catch (error) {
+            // Host 与原生状态偶发分叉（取消竞态、原生运行未收尾）时，按原生协议提示把消息
+            // 排队为 followUp（当前运行结束后处理），而不是把内部错误直接抛给用户。
+            if (!/already processing/i.test(String(error?.message))) throw error;
+            await session.process.command({ type: "prompt", message: text, streamingBehavior: "followUp", ...(images.length ? { images } : {}) });
+          }
+        } finally {
+          session.promptInFlight -= 1;
+          if (session.cancelRequested && !session.promptInFlight) {
+            session.cancelRequested = false;
+            void session.process.command({ type: "abort" }).catch(() => {});
+          }
+        }
       },
 
       async cancel(session) {
+        // prompt 仍在 preflight（ack 未回）时，这发 abort 大概率落空：置标志，由 send() 在 ack 后补停
+        if (session.promptInFlight) session.cancelRequested = true;
         await session.process.command({ type: "abort" });
       },
 
@@ -286,12 +318,12 @@ function piFamily({ id, name, icon, bin, packageHint, aliases }) {
         return null;
       }
       case "tool_execution_start":
-        return { kind: "tool", toolCallId: event.toolCallId, title: event.toolName || "工具", state: "running", detail: firstLine(event.args ? Object.values(event.args)[0] : ""), input: toolText(event.args?.command ?? JSON.stringify(event.args ?? {}, null, 2)) };
+        return { kind: "tool", toolCallId: event.toolCallId, title: event.toolName || "工具", state: "running", detail: firstLine(event.args ? Object.values(event.args)[0] : ""), input: toolText(event.args?.command ?? JSON.stringify(event.args ?? {}, null, 2)), ...editTarget(event) };
       case "tool_execution_update":
-        return { kind: "tool", toolCallId: event.toolCallId, title: event.toolName || "工具", state: "running", detail: summarizeContent(event.partialResult?.content), output: toolText(event.partialResult?.content) };
+        return { kind: "tool", toolCallId: event.toolCallId, title: event.toolName || "工具", state: "running", detail: summarizeContent(event.partialResult?.content), output: toolText(event.partialResult?.content), ...editTarget(event) };
       case "tool_execution_end":
         return [
-          { kind: "tool", toolCallId: event.toolCallId, title: event.toolName || "工具", state: event.isError ? "error" : "done", detail: summarizeContent(event.result?.content), output: toolText(event.result?.content) },
+          { kind: "tool", toolCallId: event.toolCallId, title: event.toolName || "工具", state: event.isError ? "error" : "done", detail: summarizeContent(event.result?.content), output: toolText(event.result?.content), ...editTarget(event) },
           ...imageArtifacts(event.result?.content, event.toolCallId),
         ];
       case "extension_ui_request": {
@@ -336,7 +368,8 @@ function piFamily({ id, name, icon, bin, packageHint, aliases }) {
     }
   }
 
-  return { manifest, create, project };
+  // forwardEvent 暴露给回放/单测（runtime 经由 create().open() 闭包使用同一份实现）
+  return { manifest, create, project, forwardEvent };
 }
 
 module.exports = { piFamily, PI_PERMISSION_MODES };