@harness-mix/cli 0.1.3

package/src/main/adapters/grok.js

@@ -0,0 +1,277 @@
+const { execFile } = require('node:child_process');
+const { randomUUID } = require('node:crypto');
+const { JsonlProcess, cliSpawn } = require('../host/jsonl');
+
+const textOf = content => Array.isArray(content) ? content.map(c => c.text ?? c.content?.text ?? '').filter(Boolean).join('\n') : content?.text || '';
+function catalog(session) {
+  const options = session.state.configOptions || [];
+  const modelConfig = options.find(o => o.category === 'model');
+  const modeConfig = options.find(o => o.category === 'mode');
+  const nativeModels = session.state.models?.availableModels || [];
+  const models = modelConfig ? (modelConfig.options || []).filter(o => o.value).map(o => ({ id: o.value, name: o.name, isDefault: o.value === modelConfig.currentValue }))
+    : nativeModels.map(m => ({ id: m.modelId, name: m.name || m.modelId, isDefault: m.modelId === session.state.models?.currentModelId }));
+  const current = nativeModels.find(m => m.modelId === session.state.models?.currentModelId);
+  return { models,
+    thinkingLevels: (current?._meta?.reasoningEfforts || []).map(e => ({ id: e.id, label: e.label || e.id })),
+    permissionModes: modeConfig ? (modeConfig.options || []).map(o => ({ id: o.value, label: o.name, description: o.description, default: o.value === modeConfig.currentValue }))
+      : (session.state.modes?.availableModes || []).map(m => ({ id: m.id, label: m.name, default: m.id === session.state.modes.currentModeId })),
+  };
+}
+
+function grokAdapter() {
+  const id = 'grok', name = 'Grok', bin = process.env.HARNESS_MIX_GROK_EXECUTABLE || (process.platform === 'win32' ? 'grok.exe' : 'grok'), args = ['agent', 'stdio'], executable = true, images = true, fork = true, thinking = true, permissions = false;
+  const manifest = { id, name, icon: `${id}-color.svg`, aliases: [id], capabilities: { collaborationTools: true, streaming: true, thinking: true, tools: true, approvals: true,
+    questions: false, models: true, thinkingLevels: thinking, permissionModes: permissions, resume: true, fork, forkFromMessage: false,
+    compaction: true, usage: true, contextUsage: false, attachments: images } };
+  const command = argv => executable ? { command: bin, args: argv } : cliSpawn(bin, argv);
+  function create() {
+    const adapter = {
+      async inspect() {
+        const cli = command(['--version']);
+        return new Promise(resolve => execFile(cli.command, cli.args, { windowsHide: true, timeout: 10000 }, (error, out) => resolve({ available: !error, detail: error ? `${name} CLI 不可用` : out.trim() })));
+      },
+      async describe() { return { models: null, thinkingLevels: [], permissionModes: [] }; },
+      async open({ thread, emit, diagnostic = () => {}, collaboration }) {
+        const cli = command(args);
+        const session = { cwd: thread.cwd, nativeSessionId: null, collaborationEnabled: !!collaboration, state: { configOptions: [], models: null, modes: null, commands: [], usage: undefined, loading: true }, pendingApprovals: new Map(), tools: new Map(), emit };
+        session.process = new JsonlProcess(cli.command, cli.args, { cwd: thread.cwd }, {
+          onDiagnostic: diagnostic,
+          onExit: error => { for (const pending of session.pendingApprovals.values()) pending.reject(error); session.pendingApprovals.clear(); },
+          onRequest: request => {
+            if (request.method !== 'session/request_permission') throw new Error(`Unsupported ACP client request: ${request.method}`);
+            const requestId = randomUUID();
+            return new Promise((resolve, reject) => {
+              const options = request.params.options || [];
+              session.pendingApprovals.set(requestId, { resolve, reject, options });
+              emit({ kind: 'approval', requestId, method: 'select', title: request.params.toolCall?.title || 'Native tool permission', options: options.map(o => ({ id: o.optionId, label: o.name, kind: o.kind.startsWith('reject') ? 'reject' : undefined })) });
+            });
+          },
+          onEvent: event => {
+            if (event.method === '_x.ai/models/update') { session.state.models = event.params; return; }
+            const isSessionEvent = event.method === 'session/update'
+              || event.method === '_x.ai/session/update'
+              || event.method === 'x.ai/session_notification'
+              || event.method === '_x.ai/session_notification';
+            if (!isSessionEvent) return;
+            if (session.nativeSessionId && event.params?.sessionId && event.params.sessionId !== session.nativeSessionId) return;
+            const u = event.params?.update || event.params;
+            if (!u || typeof u !== 'object') return;
+            if (!session.state.loading && u.usage) {
+              session.state.usage = projectUsage(u.usage);
+              emit({ kind: 'usage', usage: session.state.usage });
+            }
+            const compactEvent = parseGrokCompactionUpdate(u);
+            if (compactEvent) {
+              if (compactEvent.type === 'started') {
+                emit({ kind: 'compaction', state: 'running', ...compactEvent });
+              } else if (compactEvent.type === 'completed') {
+                if (compactEvent.tokensAfter != null) {
+                  session.state.usage = {
+                    ...(session.state.usage || {}),
+                    tokens: compactEvent.tokensAfter,
+                    totalTokens: compactEvent.tokensAfter,
+                    inputTokens: compactEvent.tokensAfter,
+                    ...(compactEvent.contextWindowTokens != null ? { contextWindow: compactEvent.contextWindowTokens } : {}),
+                  };
+                  emit({ kind: 'usage', usage: session.state.usage });
+                }
+                emit({ kind: 'compaction', state: 'completed', ...compactEvent });
+              }
+              return;
+            }
+            if (u.sessionUpdate === 'compaction_checkpoint') return;
+            if (u.sessionUpdate === 'config_option_update') session.state.configOptions = u.configOptions;
+            if (u.sessionUpdate === 'available_commands_update') session.state.commands = u.availableCommands || [];
+            if (u.sessionUpdate === 'current_mode_update' && session.state.modes) session.state.modes.currentModeId = u.currentModeId;
+            if (session.state.loading) return;
+            if (u.sessionUpdate === 'agent_message_chunk') emit({ kind: 'text-delta', text: textOf(u.content) });
+            if (u.sessionUpdate === 'agent_thought_chunk') emit({ kind: 'thinking-delta', text: textOf(u.content) });
+            if (u.sessionUpdate === 'tool_call' || u.sessionUpdate === 'tool_call_update') {
+              const tool = { ...session.tools.get(u.toolCallId), ...u };
+              session.tools.set(u.toolCallId, tool);
+              emit({ kind: 'tool', toolCallId: tool.toolCallId, title: tool.title || tool.kind || 'tool', state: tool.status === 'completed' ? 'completed' : tool.status === 'failed' ? 'error' : 'running', input: tool.rawInput, output: textOf(tool.content) || tool.rawOutput });
+              const changes = (tool.content || []).filter(c => c.type === 'diff').map(c => ({ path: c.path, before: c.oldText ?? '', after: c.newText, changeType: c.oldText == null ? 'added' : 'modified', complete: true }));
+              if (tool.status === 'completed' && changes.length) emit({ kind: 'file-change', source: 'native', changes });
+            }
+            if (u.sessionUpdate === 'plan') emit({ kind: 'plan', entries: u.entries });
+            if (u.sessionUpdate === 'usage_update') {
+              session.state.usage = { tokens: u.used, contextWindow: u.size, ...(u.cost?.currency === 'USD' ? { cost: u.cost.amount } : {}) };
+              emit({ kind: 'usage', usage: session.state.usage });
+            }
+          },
+        });
+        try {
+          const init = await session.process.request('initialize', { protocolVersion: 1, clientCapabilities: { fs: { readTextFile: false, writeTextFile: false }, terminal: false }, clientInfo: { name: 'harness-mix', version: '0.1.0' } });
+          session.state.agentCapabilities = init.agentCapabilities;
+          session.state.commands = init._meta?.availableCommands || [];
+          // L1 会话级注入：Grok 原生协议的 session/new 自带 mcpServers 槽（ACP 形态 stdio 定义）
+          const mcpServers = collaboration ? [{ name: 'harness-mix', command: collaboration.command, args: collaboration.args, env: Object.entries(collaboration.env).map(([envName, value]) => ({ name: envName, value })) }] : [];
+          const result = await session.process.request(thread.restore ? 'session/load' : 'session/new', { cwd: thread.cwd, mcpServers, ...(thread.restore ? { sessionId: thread.nativeSessionId } : {}) });
+          session.nativeSessionId = result.sessionId || thread.nativeSessionId;
+          session.state.configOptions = result.configOptions || result._meta?.['x.ai/sessionConfig']?.options || [];
+          session.state.models = result.models || init._meta?.modelState;
+          session.state.modes = result.modes;
+          session.state.loading = false;
+          const models = catalog(session).models;
+          session.model = models.find(m => m.isDefault) || models[0];
+          if (thread.options?.model) await adapter.setModel(session, thread.options.model);
+          if (thread.options?.thinking) await adapter.setThinkingLevel(session, thread.options.thinking);
+          if (thread.options?.permissionMode) await adapter.setPermissionMode(session, thread.options.permissionMode);
+          emit({ kind: 'session', nativeSessionId: session.nativeSessionId, model: session.model });
+          return session;
+        } catch (error) { session.process.stop(); throw error; }
+      },
+      async describeFor(session) { return catalog(session); },
+      // Grok catalogs and vendor events remain owned by its native stdio process.
+      async listModelsFor(session) { return catalog(session).models; },
+      async send(session, text, hooks, attachments) {
+        if (typeof text === 'string' && /^\/compact(?:\s+([\s\S]*))?$/.test(text.trim())) {
+          const match = /^\/compact(?:\s+([\s\S]*))?$/.exec(text.trim());
+          const userContext = match && match[1] ? match[1].trim() : undefined;
+          await doGrokCompact(session, userContext, hooks);
+          return;
+        }
+        const prompt = [...(text ? [{ type: 'text', text }] : []), ...(attachments?.images || []).map(i => ({ type: 'image', data: i.data, mimeType: i.mime }))];
+        const result = await session.process.request('session/prompt', { sessionId: session.nativeSessionId, prompt });
+        if (result._meta?.usage) { session.state.usage = projectUsage(result._meta.usage); hooks.emit({ kind: 'usage', usage: session.state.usage }); }
+        hooks.emit({ kind: 'completed', finalAnswer: result.stopReason !== 'cancelled', nativeRef: { checkpointId: result._meta?.promptId } });
+      },
+      async cancel(session) { session.process.notify('session/cancel', { sessionId: session.nativeSessionId }); },
+      async respond(session, requestId, response) {
+        const pending = session.pendingApprovals.get(requestId);
+        if (!pending) throw new Error('Unknown native approval');
+        const selected = response.optionId ?? response.value;
+        const option = pending.options.find(o => o.optionId === selected);
+        if (!response.cancelled && !option) throw new Error('Select an option offered by Grok');
+        pending.resolve({ outcome: response.cancelled ? { outcome: 'cancelled' } : { outcome: 'selected', optionId: option.optionId } });
+        session.pendingApprovals.delete(requestId);
+      },
+      async setModel(session, model) {
+        const config = session.state.configOptions.find(c => c.category === 'model');
+        if (config) {
+          const result = await session.process.request('session/set_config_option', { sessionId: session.nativeSessionId, configId: config.id, value: model.id });
+          session.state.configOptions = result.configOptions || session.state.configOptions;
+        } else await session.process.request('session/set_model', { sessionId: session.nativeSessionId, modelId: model.id });
+        if (session.state.models) session.state.models.currentModelId = model.id;
+        session.model = model; return model;
+      },
+      async setThinkingLevel(session, level) {
+        if (!catalog(session).thinkingLevels.some(l => l.id === level)) throw new Error('Native reasoning level unavailable');
+        await session.process.request('session/set_mode', { sessionId: session.nativeSessionId, modeId: level });
+      },
+      async setPermissionMode(session, mode) {
+        if (!catalog(session).permissionModes.some(m => m.id === mode)) throw new Error('Native permission mode unavailable');
+        const config = session.state.configOptions.find(c => c.category === 'mode');
+        if (config) {
+          const result = await session.process.request('session/set_config_option', { sessionId: session.nativeSessionId, configId: config.id, value: mode });
+          session.state.configOptions = result.configOptions || session.state.configOptions;
+        } else await session.process.request('session/set_mode', { sessionId: session.nativeSessionId, modeId: mode });
+      },
+      async listCommands(session) {
+        const nativeCommands = (session?.state.commands || []).map(c => ({ id: c.name, label: '/' + c.name, description: c.description, action: 'insert' }));
+        const hasCompact = nativeCommands.some(c => c.id === 'compact');
+        return [
+          ...nativeCommands,
+          ...(hasCompact ? [] : [{ id: 'compact', label: '/compact', description: '由 Grok 原生压缩当前会话上下文', action: 'execute' }]),
+        ];
+      },
+      async executeCommand(session, id, hooks, args) {
+        if (id === 'compact') {
+          await doGrokCompact(session, args?.userContext || args?.text, hooks);
+          return;
+        }
+        await adapter.send(session, '/' + id, hooks);
+      },
+      async getContextUsage(session) { return session.state.usage; },
+      async fork(source, context) {
+        if (!fork || context.message) throw new Error('Native ACP does not support this fork boundary');
+        const probe = await adapter.open({ thread: { ...source, restore: true }, emit: () => {}, diagnostic: context.diagnostic });
+        try {
+          const result = await probe.process.request('_x.ai/session/fork', { sourceSessionId: source.nativeSessionId, sourceCwd: source.cwd, newCwd: source.cwd });
+          return { session: await adapter.open({ thread: { ...source, nativeSessionId: result.newSessionId, restore: true }, emit: context.emit, diagnostic: context.diagnostic }) };
+        } finally { await adapter.close(probe); }
+      },
+      async close(session) { session.process.stop(); },
+    };
+    return adapter;
+  }
+  return { manifest, create };
+}
+function projectUsage(u) {
+  const fields = { inputTokens: ['inputTokens', 'input_tokens'], outputTokens: ['outputTokens', 'output_tokens'], reasoningOutputTokens: ['reasoningTokens', 'reasoning_tokens'], cacheRead: ['cachedReadTokens', 'cached_read_tokens'], cacheWrite: ['cacheCreationTokens', 'cache_creation_tokens'] };
+  return Object.fromEntries(Object.entries(fields).flatMap(([key, names]) => { const value = names.map(n => u[n]).find(Number.isFinite); return value === undefined ? [] : [[key, value]]; }));
+}
+function parseGrokCompactionUpdate(update) {
+  if (!update || typeof update !== 'object' || typeof update.sessionUpdate !== 'string') return null;
+  const tokensUsed = update.tokensUsed ?? update.tokens_used;
+  const contextWindowTokens = update.contextWindowTokens ?? update.contextWindow ?? update.context_window;
+  const tokensBefore = update.tokensBefore ?? update.tokens_before;
+  const tokensAfter = update.tokensAfter ?? update.tokens_after;
+  if (update.sessionUpdate === 'auto_compact_started') {
+    return {
+      type: 'started',
+      ...(tokensUsed != null ? { tokensUsed } : {}),
+      ...(contextWindowTokens != null ? { contextWindowTokens } : {}),
+    };
+  }
+  if (update.sessionUpdate === 'auto_compact_completed') {
+    return {
+      type: 'completed',
+      outcome: 'succeeded',
+      ...(tokensBefore != null ? { tokensBefore } : {}),
+      ...(tokensAfter != null ? { tokensAfter } : {}),
+      ...(contextWindowTokens != null ? { contextWindowTokens } : {}),
+    };
+  }
+  if (update.sessionUpdate === 'auto_compact_failed') {
+    return {
+      type: 'completed',
+      outcome: 'failed',
+      errorMessage: update.errorMessage ?? update.error_message ?? update.message,
+    };
+  }
+  if (update.sessionUpdate === 'auto_compact_cancelled') {
+    return { type: 'completed', outcome: 'cancelled' };
+  }
+  return null;
+}
+async function doGrokCompact(session, userContext, hooks) {
+  const params = {
+    sessionId: session.nativeSessionId,
+    ...(userContext ? { userContext } : {}),
+  };
+  let result;
+  try {
+    result = await session.process.request('x.ai/compact_conversation', params);
+  } catch (err) {
+    if (err.message && (err.message.includes('Method not found') || err.message.includes('-32601') || err.message.includes('not supported') || err.message.includes('Unsupported'))) {
+      result = await session.process.request('_x.ai/compact_conversation', params);
+    } else {
+      throw err;
+    }
+  }
+  const tokensBefore = result?.tokensBefore ?? result?.tokens_before;
+  const tokensAfter = result?.tokensAfter ?? result?.tokens_after;
+  const contextWindowTokens = result?.contextWindowTokens ?? result?.context_window;
+  if (tokensAfter != null) {
+    session.state.usage = {
+      ...(session.state.usage || {}),
+      tokens: tokensAfter,
+      totalTokens: tokensAfter,
+      inputTokens: tokensAfter,
+      ...(contextWindowTokens != null ? { contextWindow: contextWindowTokens } : {}),
+    };
+    hooks?.emit?.({ kind: 'usage', usage: session.state.usage });
+  }
+  const outcome = result?.outcome ?? (result?.aborted ? 'cancelled' : result?.success === false ? 'failed' : 'succeeded');
+  hooks?.emit?.({
+    kind: 'compaction',
+    state: 'completed',
+    outcome,
+    ...(tokensBefore != null ? { tokensBefore } : {}),
+    ...(tokensAfter != null ? { tokensAfter } : {}),
+    ...(contextWindowTokens != null ? { contextWindowTokens } : {}),
+  });
+  hooks?.emit?.({ kind: 'completed', finalAnswer: outcome !== 'cancelled' });
+}
+module.exports = { ...grokAdapter(), projectUsage, parseGrokCompactionUpdate, doGrokCompact };

package/src/main/adapters/hermes.js

@@ -0,0 +1,24 @@
+// Hermes Agent Adapter：`hermes acp`（Nous Research，ACP over stdio）。
+// 实现共享自 ACP 家族工厂（见 acp.js）。能力按官方文档声明面逐项标注：
+// 已文档化：会话持久化/恢复/Fork、流式回答与思考、工具、审批、模型选择。
+// 图片输入：上游 server.py 在 initialize 报告 PromptCapabilities(image=True) 并转发图片块
+// （PR #18030、commit 7e2af0c）；acp.js 在发送时按 initialize 实际值动态防护，旧版本会明确报错而非静默丢弃。
+// 未文档化（不声明）：提问、压缩、Usage。
+const { acpAdapter } = require("./acp");
+
+module.exports = acpAdapter({
+  id: "hermes",
+  name: "Hermes",
+  // Windows 上为 uv/pip 生成的 hermes.exe 启动器；可用 HARNESS_MIX_HERMES_EXECUTABLE 覆盖
+  bin: process.env.HARNESS_MIX_HERMES_EXECUTABLE || (process.platform === 'win32' ? 'hermes.exe' : 'hermes'),
+  args: ["acp"],
+  executable: true,
+  images: true,
+  fork: true,
+  thinking: false,
+  permissions: false,
+  questions: false,
+  compaction: false,
+  usage: false,
+  contextUsage: false,
+});

package/src/main/adapters/index.js

@@ -0,0 +1,32 @@
+const pi = require("./pi");
+const dsh = require("./dsh");
+const claude = require("./claude");
+const codex = require("./codex");
+const antigravity = require("./antigravity");
+const opencode = require('./opencode');
+const grok = require('./grok');
+const omp = require('./omp');
+const openclaw = require('./openclaw');
+const hermes = require('./hermes');
+const qoder = require('./qoder');
+const codebuddy = require('./codebuddy');
+const zcode = require('./zcode');
+const trae = require('./trae');
+const kiro = require('./kiro');
+const cursor = require('./cursor');
+
+/**
+ * Adapter 注册表（借鉴 codex-host 插件结构：Manifest + 工厂 + Adapter + Session）。
+ * 新增 Harness 时：实现同形状模块并加入此列表，Renderer 无需改动协议。
+ */
+const REGISTRY = [antigravity, pi, omp, dsh, claude, codex, opencode, grok, openclaw, hermes, qoder, codebuddy, zcode, trae, kiro, cursor];
+
+function buildAdapters(emit) {
+  return REGISTRY.map(({ manifest, create }) => {
+    const adapter = create(emit);
+    adapter.manifest = manifest;
+    return adapter;
+  });
+}
+
+module.exports = { buildAdapters };

package/src/main/adapters/kiro-history.js

@@ -0,0 +1,43 @@
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const os = require('node:os');
+const same = (a, b) => process.platform === 'win32' ? a.toLowerCase() === b.toLowerCase() : a === b;
+
+// Only an intact completed native turn is a supported fork boundary. Compacted
+// or rewritten histories require a separate lineage implementation.
+async function latestKiroCheckpoint(cwd, sessionId) {
+  if (!/^[A-Za-z0-9][A-Za-z0-9_-]{0,199}$/.test(sessionId || '')) throw new Error('Invalid Kiro session identity');
+  const root = path.resolve(process.env.KIRO_HOME || path.join(os.homedir(), '.kiro'), 'sessions');
+  const dirs = await fs.readdir(root, { withFileTypes: true });
+  const found = [];
+  for (const dir of dirs.filter(d => d.isDirectory() && !d.isSymbolicLink() && d.name !== 'cli').slice(0, 2000)) {
+    const location = path.join(root, dir.name, sessionId);
+    try { await fs.access(path.join(location, 'session.json')); found.push(location); } catch (e) { if (e.code !== 'ENOENT') throw e; }
+  }
+  if (found.length !== 1) throw new Error('Kiro native history missing or ambiguous');
+  async function read(name) {
+    const file = path.join(found[0], name), real = await fs.realpath(file);
+    if (!same(real, file)) throw new Error('Kiro history path redirected');
+    const stat = await fs.stat(file);
+    if (!stat.isFile() || stat.size > 32 * 1024 * 1024) throw new Error('Kiro history oversized');
+    const body = await fs.readFile(file, 'utf8'), after = await fs.stat(file);
+    if (stat.size !== after.size || stat.mtimeMs !== after.mtimeMs) throw new Error('Kiro history changed during inspection');
+    return body;
+  }
+  const meta = JSON.parse(await read('session.json'));
+  if (meta.id !== sessionId || !Array.isArray(meta.workspacePaths) || !meta.workspacePaths.length) throw new Error('Kiro history identity missing');
+  const canonical = await fs.realpath(cwd);
+  if (!same(await fs.realpath(meta.workspacePaths[0]), canonical)) throw new Error('Kiro history workspace mismatch');
+  const rows = (await read('messages.jsonl')).split(/\r?\n/).filter(l => l.trim()).map(l => JSON.parse(l));
+  const seen = new Set(); let checkpoint = null;
+  for (const row of rows) {
+    if (typeof row.id !== 'string' || !row.id || seen.has(row.id) || typeof row.payload?.type !== 'string') throw new Error('Invalid Kiro history record');
+    seen.add(row.id);
+    if (row.payload.type === 'tombstone' || row.payload.operationType === 'Summary') throw new Error('Compacted Kiro fork history is not supported');
+    if (row.payload.type === 'user') checkpoint = null;
+    if (row.payload.type === 'turn_end') checkpoint = row.id;
+  }
+  if (!checkpoint) throw new Error('Kiro has no completed native fork checkpoint');
+  return checkpoint;
+}
+module.exports = { latestKiroCheckpoint };

package/src/main/adapters/kiro.js

@@ -0,0 +1,2 @@
+const { nativeAcp } = require('./native-acp');
+module.exports = nativeAcp({ id: 'kiro-cli', name: 'Kiro', aliases: ['kiro', 'kiro-cli', 'kirocli'], args: ['acp', '--agent-engine', 'v3', '--auth-method', 'cli'] });

package/src/main/adapters/native-acp-command.js

@@ -0,0 +1,47 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const os = require('node:os');
+const { cliSpawn } = require('../host/jsonl');
+
+// Resolve only the named native CLI. In particular, `agent` can belong to Grok.
+function nativeCommand(id, argv) {
+  const cursor = id === 'cursor-cli';
+  const buddy = id === 'codebuddy';
+  const specs = {
+    codebuddy: ['codebuddy', 'HARNESS_MIX_CODEBUDDY_EXECUTABLE', 'https://www.codebuddy.ai/docs/cli/overview'],
+    'cursor-cli': ['cursor-agent', 'HARNESS_MIX_CURSOR_EXECUTABLE', 'https://cursor.com/docs/cli/installation'],
+    'kiro-cli': ['kiro-cli', 'HARNESS_MIX_KIRO_EXECUTABLE', 'https://kiro.dev/docs/cli/'],
+    qoder: ['qodercli', 'HARNESS_MIX_QODER_EXECUTABLE', 'https://docs.qoder.com/cli/acp'],
+    trae: ['traecli', 'HARNESS_MIX_TRAE_EXECUTABLE', 'https://github.com/bytedance/trae-agent'],
+    zcode: ['zcode-acp-server', 'HARNESS_MIX_ZCODE_ACP_EXECUTABLE', 'https://zcode.z.ai/'],
+  };
+  if (!specs[id]) throw new Error(`Unknown native CLI: ${id}`);
+  const [bin, variable, url] = specs[id];
+  const override = process.env[variable] || (buddy ? process.env.HARNESS_MIX_WORKBUDDY_EXECUTABLE : undefined);
+  if (id === 'trae' && !override) throw new Error('Trae 官方仓库未确认 ACP 服务入口；请设置已验证的 HARNESS_MIX_TRAE_EXECUTABLE，不会猜测 traecli acp serve');
+  if (id === 'zcode' && !override) throw new Error('ZCode 原生 CLI 提供 app-server 而非 ACP；需要显式配置 HARNESS_MIX_ZCODE_ACP_EXECUTABLE 指向兼容 ACP 桥接器');
+  const roots = cursor
+    ? [path.join(process.env.LOCALAPPDATA || os.homedir(), 'cursor-agent'), path.join(os.homedir(), '.local', 'bin')]
+    : [path.join(process.env.LOCALAPPDATA || os.homedir(), 'Kiro-Cli'), path.join(os.homedir(), '.kiro', 'bin'), path.join(os.homedir(), '.local', 'bin')];
+  const dirs = [...roots, path.join(process.env.APPDATA || os.homedir(), 'npm'), ...(process.env.PATH || '').split(path.delimiter).filter(Boolean)];
+  const suffixes = process.platform === 'win32' ? ['.exe', '.cmd', '.ps1', ''] : [''];
+  const bundled = buddy ? [path.join(process.env.ProgramFiles || 'C:/Program Files', 'WorkBuddy/resources/app.asar.unpacked/cli/bin/codebuddy'), path.join(process.env.LOCALAPPDATA || os.homedir(), 'Programs/WorkBuddy/resources/app.asar.unpacked/cli/bin/codebuddy')] : [];
+  const bins = id === 'qoder' ? [bin, 'qoder'] : [bin];
+  const found = override || [...dirs.flatMap(dir => bins.flatMap(name => suffixes.map(ext => path.join(dir, name + ext)))), ...bundled].find(file => fs.existsSync(file) && fs.statSync(file).isFile());
+  if (!found || !fs.existsSync(found)) throw new Error(`${bin} 未安装；请从 ${url} 安装并原生登录`);
+  if ((buddy && bundled.includes(found)) || /\.(cjs|mjs|js)$/i.test(found)) return { command: process.execPath, args: [found, ...argv] };
+  if (id === 'qoder' && /\.(cmd|ps1)$/i.test(found)) {
+    const bundle = path.join(path.dirname(found), 'node_modules/@qoder-ai/qodercli/bundle/qodercli.js');
+    if (fs.existsSync(bundle)) return { command: process.execPath, args: [bundle, ...argv] };
+  }
+  if (cursor && /\.(cmd|ps1)$/i.test(found)) {
+    const versions = path.join(path.dirname(found), 'versions');
+    const version = fs.existsSync(versions) && fs.readdirSync(versions).filter(v => /^\d{4}\.\d{2}\.\d{2}-[a-z0-9-]+$/i.test(v)).sort().reverse().find(v => ['node.exe', 'index.js'].every(f => fs.existsSync(path.join(versions, v, f))));
+    if (!version) throw new Error('Cursor launcher 缺少原生 bundle；请重新安装 Cursor CLI');
+    return { command: path.join(versions, version, 'node.exe'), args: [path.join(versions, version, 'index.js'), ...argv] };
+  }
+  if (/\.(cmd|bat)$/i.test(found)) return cliSpawn(found.replace(/\.(cmd|bat)$/i, ''), argv);
+  if (/\.ps1$/i.test(found)) return { command: 'pwsh.exe', args: ['-NoLogo', '-NoProfile', '-File', found, ...argv] };
+  return { command: found, args: argv };
+}
+module.exports = { nativeCommand };