@harness-mix/cli 0.1.3

package/src/main/adapters/claude.js

@@ -0,0 +1,520 @@
+const { execFile } = require("node:child_process");
+const { randomUUID } = require("node:crypto");
+const { cliSpawn } = require("../host/jsonl");
+const { recordNative } = require("../harness-adapter/fixture-recorder");
+
+const manifest = {
+  id: "claude",
+  name: "Claude Code",
+  icon: "claude-color.svg",
+  aliases: ['claude', 'claude-code'],
+  // 完整接入（对齐 codex-host）：官方 Agent SDK query() 常驻双向 stream-json 会话，
+  // 审批/提问经 canUseTool 桥接回 Host，中断/模型/权限模式走原生控制协议。
+  capabilities: { collaborationTools: true, streaming: true, thinking: true, tools: true, approvals: true, questions: true, models: true, thinkingLevels: true, permissionModes: true, resume: true, fork: true, forkFromMessage: true, compaction: true, usage: true, contextUsage: true, attachments: true },
+};
+
+/** Claude Code 原生权限模式（SDK PermissionMode 全集），与其 TUI/Desktop 一致 */
+const CLAUDE_PERMISSION_MODES = [
+  { id: "default", label: "默认（询问）", description: "编辑和其他受保护操作前询问" },
+  { id: "plan", label: "规划模式", description: "探索并制定计划；批准计划后退出规划" },
+  { id: "acceptEdits", label: "接受编辑", description: "允许文件编辑；其他受保护操作前询问" },
+  { id: "auto", label: "自动模式", description: "由 Claude 判断权限请求" },
+  { id: "dontAsk", label: "免询问", description: "跳过权限询问（非绕过检查）" },
+  { id: "bypassPermissions", label: "绕过权限", description: "跳过全部权限检查，谨慎使用", dangerous: true },
+];
+
+function summarizeInput(input) {
+  if (!input || typeof input !== "object") return "";
+  if (input.agent_type && input.task) return `@${input.agent_type}: ${input.task}`.split("\n")[0].slice(0, 120);
+  const value = input.command ?? input.file_path ?? input.pattern ?? input.task ?? input.description ?? Object.values(input)[0];
+  return typeof value === "string" ? value.split("\n")[0].slice(0, 120) : "";
+}
+
+/** Claude stream-json 单行事件 → 统一事件（纯映射，运行时与 fixture 回放共用） */
+function projectEvent(event) {
+  const out = [];
+  if (event.type === "system" && event.subtype === "init" && event.session_id) {
+    out.push({ kind: "session", nativeSessionId: event.session_id });
+  } else if (event.type === "system" && event.subtype === "api_retry") {
+    out.push({ kind: "status", text: `Claude 模型限流（${event.error_status ?? ""}），重试 ${event.attempt}/${event.max_retries}…` });
+  } else if (event.type === 'system' && event.subtype === 'compact_boundary') {
+    out.push({ kind: 'compaction', state: 'completed', outcome: 'succeeded', summary: '上下文已由 Claude Code 压缩。' });
+  } else if (event.type === "assistant" && Array.isArray(event.message?.content)) {
+    for (const block of event.message.content) {
+      if (block.type === "thinking" && block.thinking) out.push({ kind: "thinking-delta", text: block.thinking, nativeRef: { sessionId: event.session_id, itemId: event.message.id } });
+      if (block.type === "text" && block.text) out.push({ kind: "text-delta", text: block.text, nativeRef: { sessionId: event.session_id, itemId: event.message.id } });
+      if (block.type === "tool_use") out.push({ kind: "tool", toolCallId: block.id, title: block.name || "工具", state: "running", detail: summarizeInput(block.input), input: JSON.stringify(block.input ?? {}) });
+    }
+  } else if (event.type === "user" && Array.isArray(event.message?.content)) {
+    const result = event.tool_use_result;
+    if (result?.filePath && typeof result.content === 'string' && (result.type === 'create' || typeof result.originalFile === 'string')) {
+      out.push({ kind: 'file-change', source: 'native', changes: [{ path: result.filePath,
+        before: result.originalFile ?? '', after: result.content, complete: true,
+        changeType: result.type === 'create' ? 'added' : 'modified',
+        nativeRef: { sessionId: event.session_id, toolCallId: event.message.content.find(b => b.tool_use_id)?.tool_use_id },
+      }] });
+    }
+    // 工具结果中的图片 → 统一 artifact 投影（与其他 Harness 对齐）
+    for (const block of event.message.content) {
+      if (block?.type !== "tool_result") continue;
+      const parts = Array.isArray(block.content) ? block.content : [];
+      out.push({ kind: 'tool', toolCallId: block.tool_use_id, state: block.is_error ? 'error' : 'done',
+        output: typeof block.content === 'string' ? block.content : parts.filter(part => part?.type === 'text').map(part => part.text).join('\n') });
+      parts.forEach((part, i) => {
+        if (part?.type === "image" && part.source?.type === "base64" && typeof part.source.data === "string") {
+          out.push({ kind: "artifact", artifact: { id: `${block.tool_use_id ?? "claude"}-img-${i}`, type: "image", name: "图片", mime: part.source.media_type || "image/png", data: part.source.data.length <= 5_000_000 ? part.source.data : undefined } });
+        }
+      });
+    }
+  } else if (event.type === "result") {
+    const usage = usageFromResult(event);
+    if (usage) out.push({ kind: "usage", usage });
+    if (event.is_error || event.subtype !== "success") out.push({ kind: "error", message: event.result || `Claude 执行失败（${event.subtype ?? "error"}）` });
+    out.push({ kind: "completed", finalAnswer: !event.is_error && event.subtype === "success" });
+  }
+  return out.map(mapped => ({ ...mapped, nativeRef: {
+    sessionId: event.session_id, itemId: event.message?.id,
+    ...(mapped.toolCallId ? { toolCallId: mapped.toolCallId } : {}), ...mapped.nativeRef,
+  } }));
+}
+
+function parsePlanLimitWindow(val) {
+  if (!val || typeof val !== "object") return undefined;
+  const utilization = val.utilization;
+  if (typeof utilization !== "number" || !Number.isFinite(utilization) || utilization < 0) return undefined;
+  const utilizationPercent = Math.min(100, Math.max(0, Math.round(utilization * 10000) / 100));
+  const resetsAt = val.resetsAt;
+  const resetsAtUnix = Number.isSafeInteger(resetsAt) && resetsAt >= 0 ? resetsAt : undefined;
+  return { utilizationPercent, ...(resetsAtUnix !== undefined ? { resetsAtUnix } : {}) };
+}
+
+function parseClaudePlanLimitEvent(event) {
+  if (!event || typeof event !== "object" || event.type !== "rate_limit_event") return null;
+  const info = event.rate_limit_info;
+  if (!info || typeof info !== "object") return null;
+  const windows = info.unifiedWindows && typeof info.unifiedWindows === "object" ? info.unifiedWindows : undefined;
+  let fiveHour = parsePlanLimitWindow(windows?.five_hour);
+  let sevenDay = parsePlanLimitWindow(windows?.seven_day);
+  if (!fiveHour && !sevenDay) {
+    const flat = parsePlanLimitWindow(info);
+    if (flat && info.rateLimitType === "five_hour") fiveHour = flat;
+    else if (flat && info.rateLimitType === "seven_day") sevenDay = flat;
+  }
+  if (!fiveHour && !sevenDay) return null;
+  return {
+    ...(fiveHour ? { fiveHour } : {}),
+    ...(sevenDay ? { sevenDay } : {}),
+  };
+}
+
+function projectClaudePlanLimitToCredits(planLimit) {
+  if (!planLimit) return null;
+  const { fiveHour, sevenDay } = planLimit;
+  if (!fiveHour && !sevenDay) return null;
+  const primary = fiveHour ?? sevenDay;
+  const periodType = fiveHour ? "five_hour" : "seven_day";
+  const other = fiveHour && sevenDay ? sevenDay : undefined;
+  return {
+    usedPercent: primary.utilizationPercent,
+    periodType,
+    ...(primary.resetsAtUnix !== undefined ? { resetsAt: new Date(primary.resetsAtUnix * 1000).toISOString() } : {}),
+    ...(other ? {
+      productUsage: [
+        {
+          product: "7-day window",
+          usagePercent: other.utilizationPercent,
+          ...(other.resetsAtUnix !== undefined ? { resetsAt: new Date(other.resetsAtUnix * 1000).toISOString() } : {}),
+        },
+      ],
+    } : {}),
+  };
+}
+
+function applyClaudePlanLimitToUsage(usage, planLimit) {
+  if (!planLimit) return usage;
+  const next = { ...(usage ?? {}) };
+  if (planLimit.fiveHour) {
+    next.planFiveHourUsedPercent = planLimit.fiveHour.utilizationPercent;
+    if (planLimit.fiveHour.resetsAtUnix !== undefined) {
+      next.planFiveHourResetsAtUnix = planLimit.fiveHour.resetsAtUnix;
+    }
+  }
+  if (planLimit.sevenDay) {
+    next.planSevenDayUsedPercent = planLimit.sevenDay.utilizationPercent;
+    if (planLimit.sevenDay.resetsAtUnix !== undefined) {
+      next.planSevenDayResetsAtUnix = planLimit.sevenDay.resetsAtUnix;
+    }
+  }
+  return next;
+}
+
+/** result 事件 → 上下文用量（官方 modelUsage.contextWindow 为权威窗口大小） */
+function usageFromResult(event, planLimit) {
+  const usage = event?.usage;
+  if (!usage || typeof usage !== "object") return undefined;
+  const models = Object.values(event.modelUsage ?? {});
+  const window = models.find((m) => Number.isFinite(m?.contextWindow))?.contextWindow ?? 200_000;
+  const input = usage.input_tokens;
+  const output = usage.output_tokens;
+  const cacheRead = usage.cache_read_input_tokens;
+  const cacheWrite = usage.cache_creation_input_tokens;
+  const cost = event.total_cost_usd ?? event.cost ?? usage.total_cost;
+  const tokens = (input ?? 0) + (cacheRead ?? 0) + (cacheWrite ?? 0);
+  const totalTokens = (input ?? 0) + (output ?? 0) + (cacheRead ?? 0) + (cacheWrite ?? 0);
+  const out = {
+    tokens: tokens || null,
+    contextWindow: window,
+    contextPercent: tokens && window ? (100 * tokens / window) : null,
+    inputTokens: typeof input === "number" ? input : null,
+    outputTokens: typeof output === "number" ? output : null,
+    cachedInputTokens: typeof cacheRead === "number" ? cacheRead : null,
+    cacheWriteInputTokens: typeof cacheWrite === "number" ? cacheWrite : null,
+    totalCostUsd: typeof cost === "number" ? cost : null,
+    totalTokens: totalTokens || null,
+  };
+  return applyClaudePlanLimitToUsage(out, planLimit);
+}
+
+/** canUseTool → Host 审批卡片；AskUserQuestion → 选项提问卡片 */
+function projectApproval(requestId, toolName, input, suggestions) {
+  if (toolName === "AskUserQuestion") {
+    const question = (Array.isArray(input?.questions) ? input.questions : [])[0] ?? {};
+    return {
+      kind: "approval", requestId, method: undefined,
+      title: question.header || question.question || "Claude 提问",
+      message: question.question,
+      options: (Array.isArray(question.options) ? question.options : []).map((o) => ({ id: String(o.label), label: String(o.label), hint: o.description })),
+    };
+  }
+  return {
+    kind: "approval", requestId, method: undefined,
+    title: `${toolName} 请求权限`,
+    message: summarizeInput(input),
+    options: [
+      { id: "allow", label: "允许" },
+      ...(Array.isArray(suggestions) && suggestions.length ? [{ id: "allowAlways", label: "始终允许" }] : []),
+      { id: "deny", label: "拒绝", kind: "reject" },
+    ],
+  };
+}
+
+/** 应答 → SDK PermissionResult */
+function toPermissionResult(pending, response) {
+  const { toolName, input, suggestions } = pending;
+  if (response?.cancelled) return { behavior: "deny", message: "用户取消了请求", interrupt: true };
+  if (toolName === "AskUserQuestion") {
+    const question = (Array.isArray(input?.questions) ? input.questions : [])[0] ?? {};
+    const answer = response?.optionId ?? response?.value;
+    if (answer == null) return { behavior: "deny", message: "用户未作答" };
+    return { behavior: "allow", updatedInput: { ...input, answers: { [question.question ?? "question"]: String(answer) } } };
+  }
+  const choice = response?.optionId ?? (response?.confirmed === false ? "deny" : "allow");
+  if (choice === "deny") return { behavior: "deny", message: "用户拒绝了该操作" };
+  if (choice === "allowAlways" && Array.isArray(suggestions) && suggestions.length) {
+    return { behavior: "allow", updatedInput: input, updatedPermissions: suggestions };
+  }
+  return { behavior: "allow", updatedInput: input };
+}
+
+/** SDK streaming-input 消息队列（保持打开，进程生命周期内可连续推送） */
+class MessageQueue {
+  constructor() { this.items = []; this.waiters = []; this.ended = false; }
+  push(message) {
+    if (this.ended) return;
+    const waiter = this.waiters.shift();
+    if (waiter) waiter({ value: message, done: false });
+    else this.items.push(message);
+  }
+  end() {
+    this.ended = true;
+    for (const waiter of this.waiters.splice(0)) waiter({ value: undefined, done: true });
+  }
+  [Symbol.asyncIterator]() {
+    return {
+      next: () => {
+        if (this.items.length) return Promise.resolve({ value: this.items.shift(), done: false });
+        if (this.ended) return Promise.resolve({ value: undefined, done: true });
+        return new Promise((resolve) => this.waiters.push(resolve));
+      },
+    };
+  }
+}
+
+async function loadSdk() {
+  return import("@anthropic-ai/claude-agent-sdk");
+}
+
+/** 建立一个常驻 SDK 会话（open 与 fork 共用）：构造 query、启动事件泵 */
+function spawnSession(sdk, { cwd, resumeId, newSessionId, permissionMode, modelId, effort, emit, collaboration, onPlanLimit }) {
+  const input = new MessageQueue();
+  const session = {
+    nativeSessionId: resumeId || newSessionId,
+    cwd,
+    collaborationEnabled: !!collaboration,
+    permissionMode,
+    model: undefined,
+    input,
+    query: undefined,
+    pendingApprovals: new Map(),
+    // 注意：runtime 以浅拷贝保存 adapter session（{ adapter, ...session }），
+    // 泵写入的可变状态必须放在共享引用的 state 容器内，拷贝内外才一致。
+    state: { turn: null, crashed: false, lastUsage: undefined, latestPlanLimit: undefined, checkpointId: undefined },
+  };
+
+  session.query = sdk.query({
+    prompt: input,
+    options: {
+      cwd,
+      ...(collaboration ? { mcpServers: { 'harness-mix': collaboration } } : {}),
+      ...(resumeId ? { resume: resumeId } : {}),
+      ...(!resumeId && newSessionId ? { sessionId: newSessionId } : {}),
+      ...(effort ? { effort } : {}),
+      ...(permissionMode ? { permissionMode } : {}),
+      ...(modelId ? { model: modelId } : {}),
+      ...(process.env.HARNESS_MIX_CLAUDE_EXECUTABLE ? { pathToClaudeCodeExecutable: process.env.HARNESS_MIX_CLAUDE_EXECUTABLE } : {}),
+      canUseTool: (toolName, toolInput, { signal, suggestions }) => {
+        const requestId = randomUUID();
+        emit(projectApproval(requestId, toolName, toolInput, suggestions));
+        return new Promise((resolve) => {
+          const onAbort = () => {
+            session.pendingApprovals.delete(requestId);
+            resolve({ behavior: "deny", message: "会话已中断" });
+          };
+          session.pendingApprovals.set(requestId, { resolve, toolName, input: toolInput, suggestions });
+          signal?.addEventListener("abort", onAbort, { once: true });
+        });
+      },
+    },
+  });
+
+  // 事件泵：SDK 消息 → 统一事件投影；result 结算当前回合。
+  // 注意：system/init 在首个用户消息到达时才发出，open() 不等待 init。
+  void (async () => {
+    try {
+      for await (const event of session.query) {
+        recordNative(manifest.id, event);
+        if (event.type === "system" && event.subtype === "init") {
+          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 });
+          continue;
+        }
+        if (event.type === "rate_limit_event") {
+          const limit = parseClaudePlanLimitEvent(event);
+          if (limit) {
+            session.state.latestPlanLimit = limit;
+            if (typeof onPlanLimit === "function") onPlanLimit(limit);
+            const current = session.state.lastUsage || {};
+            session.state.lastUsage = applyClaudePlanLimitToUsage(current, limit);
+            emit({ kind: "usage", usage: session.state.lastUsage });
+          }
+          continue;
+        }
+        if (event.type === "result") {
+          const usage = usageFromResult(event, session.state.latestPlanLimit);
+          if (usage) session.state.lastUsage = usage;
+          session.state.checkpointId = event.user_message_uuid ?? session.state.checkpointId;
+          for (const mapped of projectEvent(event)) {
+            // 结算事件携带原生检查点（assistant uuid），供 fork 边界定位
+            if (mapped.kind === 'completed') mapped.nativeRef = { ...mapped.nativeRef, checkpointId: session.state.checkpointId };
+            emit(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);
+      }
+      // 流正常结束（close）：未结算的回合按取消处理
+      session.state.turn?.resolve();
+      session.state.turn = null;
+    } 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}` });
+    }
+  })();
+  return session;
+}
+
+/** Claude Code Adapter：官方 Agent SDK 常驻会话，能力事件经统一投影落到线程模型 */
+function create() {
+  let adapterLatestPlanLimit = null;
+  const onPlanLimit = (limit) => { adapterLatestPlanLimit = limit; };
+
+  return {
+    manifest,
+
+    credits() {
+      return projectClaudePlanLimitToCredits(adapterLatestPlanLimit);
+    },
+
+    async inspectAccount() {
+      const creds = this.credits();
+      if (!creds) return null;
+      return {
+        label: "Claude Code",
+        plan: "Anthropic Claude",
+        credits: creds,
+      };
+    },
+
+    async inspect() {
+      const result = await new Promise((resolve) => {
+        const { command, args } = cliSpawn("claude", ["--version"]);
+        execFile(command, args, { windowsHide: true }, (error, stdout) => resolve({ ok: !error, stdout }));
+      });
+      try { await loadSdk(); }
+      catch { return { available: false, detail: "缺少 @anthropic-ai/claude-agent-sdk（npm install）" }; }
+      return result.ok
+        ? { available: true, detail: `claude ${String(result.stdout).trim()} · Agent SDK` }
+        : { available: true, detail: "Agent SDK 就绪（内置原生 CLI；未检测到独立 claude 命令）" };
+    },
+
+    async open({ thread, emit, collaboration }) {
+      const sdk = await loadSdk();
+      return spawnSession(sdk, {
+        cwd: thread.cwd,
+        resumeId: thread.restore ? thread.nativeSessionId : undefined,
+        newSessionId: thread.restore ? undefined : thread.nativeSessionId,
+        effort: thread.options?.thinking,
+        permissionMode: thread.options?.permissionMode,
+        modelId: thread.options?.model?.id,
+        emit,
+        collaboration,
+        onPlanLimit,
+      });
+    },
+
+    async send(session, text, _hooks, attachments) {
+      if (!session.query || session.state?.crashed) throw new Error("Claude 原生会话不可用");
+      // stream-json 原生内容块：text + base64 图片块；文本附件由 Host 内联进 text
+      const content = [
+        ...(text ? [{ type: "text", text }] : []),
+        ...(attachments?.images ?? []).map((a) => ({ type: "image", source: { type: "base64", media_type: a.mime, data: a.data } })),
+      ];
+      await new Promise((resolve, reject) => {
+        session.state.turn = { resolve, reject };
+        session.input.push({
+          type: "user",
+          message: { role: "user", content },
+          parent_tool_use_id: null,
+        });
+      });
+    },
+
+    async cancel(session) {
+      // 原生优雅中断；超时后由 Host 走 close 兜底
+      await Promise.race([
+        session.query?.interrupt().catch(() => {}),
+        new Promise((r) => setTimeout(r, 5_000)),
+      ]);
+    },
+
+    async listCommands(session) {
+      const base = [{ id: 'compact', label: '压缩上下文', description: '由 Claude Code 原生压缩当前会话', action: 'execute' }];
+      if (!session?.query) return base;
+      try {
+        const commands = await session.query.supportedCommands();
+        return [
+          ...base,
+          ...commands.filter((c) => c.name !== 'compact').map((c) => ({
+            id: c.name, label: '/' + c.name, description: c.description ?? '', action: 'insert', text: '/' + c.name + ' ',
+          })),
+        ];
+      } catch { return base; }
+    },
+    async executeCommand(session, id, hooks) {
+      if (id !== 'compact') throw new Error('未知 Claude 指令');
+      await this.send(session, '/compact', hooks);
+    },
+    async fork(source, { emit, message }) {
+      const sdk = await loadSdk();
+      const { forkSession, getSessionMessages } = sdk;
+      const history = await getSessionMessages(source.nativeSessionId, { dir: source.cwd });
+      let boundary = message?.coreTurn?.nativeTurnRef?.checkpointId;
+      if (message && !boundary) {
+        const final = message.coreItems?.filter(item => item.phase === 'final').map(item => item.content).join('') || message.text;
+        const matches = history.filter(entry => entry.type === 'assistant' && entry.message?.content?.filter(b => b.type === 'text').map(b => b.text).join('') === final);
+        if (matches.length !== 1) throw new Error('旧回复无法唯一定位原生记录，不能安全分支');
+        boundary = matches[0].uuid;
+      }
+      if (message && !history.some(entry => entry.uuid === boundary)) throw new Error('未找到该回复的 Claude 原生记录');
+      const result = await forkSession(source.nativeSessionId, { dir: source.cwd, upToMessageId: boundary, title: `${source.title} · Fork` });
+      const copied = await getSessionMessages(result.sessionId, { dir: source.cwd });
+      const checkpointMap = Object.fromEntries(copied.map((entry, index) => [history[index].uuid, entry.uuid]));
+      // Fork 出的新原生会话立即拉起常驻进程（resume 到新 sessionId），与 open() 同路径
+      const session = spawnSession(sdk, {
+        cwd: source.cwd,
+        resumeId: result.sessionId,
+        permissionMode: source.options?.permissionMode,
+        emit,
+        onPlanLimit,
+      });
+      return { checkpointMap, session };
+    },
+
+    async listModelsFor(session) {
+      if (!session?.query) return null;
+      try {
+        const models = await session.query.supportedModels();
+        session.models = models.map((m) => ({ id: m.value, name: m.displayName || m.value, description: m.description, resolved: m.resolvedModel, efforts: m.supportedEffortLevels || [] }));
+        return session.models;
+      } catch { return null; }
+    },
+    async setModel(session, model) {
+      await session.query?.setModel(model.id);
+      session.model = { id: model.id, name: model.name ?? model.id };
+      return session.model;
+    },
+    async setPermissionMode(session, mode) {
+      session.permissionMode = mode;
+      await session.query?.setPermissionMode(mode);
+    },
+    async setThinkingLevel(session, level) {
+      const models = await this.listModelsFor(session);
+      const current = models?.find(m => m.id === session.model?.id || m.resolved === session.model?.id);
+      if (!current?.efforts.includes(level)) throw new Error('当前 Claude 模型未声明该思考档位');
+      await session.query.applyFlagSettings({ effortLevel: level });
+    },
+    async describe() {
+      // 目录探测需常驻会话；模型目录在会话打开后经 listModelsFor 获取，这里只声明权限模式
+      return { models: null, thinkingLevels: null, permissionModes: CLAUDE_PERMISSION_MODES };
+    },
+    async describeFor(session) {
+      const models = await this.listModelsFor(session);
+      const current = models?.find(m => m.id === session.model?.id || m.resolved === session.model?.id) || models?.[0];
+      return { models, thinkingLevels: (current?.efforts || []).map(id => ({ id, label: id })), permissionModes: CLAUDE_PERMISSION_MODES };
+    },
+
+    async getContextUsage(session) { return session.state?.lastUsage; },
+
+    async respond(session, requestId, response) {
+      const pending = session.pendingApprovals.get(requestId);
+      if (!pending) return;
+      session.pendingApprovals.delete(requestId);
+      pending.resolve(toPermissionResult(pending, response));
+    },
+
+    async close(session) {
+      for (const pending of session.pendingApprovals?.values() ?? []) {
+        pending.resolve({ behavior: "deny", message: "会话已关闭" });
+      }
+      session.pendingApprovals?.clear();
+      session.input?.end();
+      try { session.query?.close(); } catch { /* already gone */ }
+    },
+  };
+}
+
+module.exports = {
+  manifest,
+  create,
+  projectEvent,
+  CLAUDE_PERMISSION_MODES,
+  parseClaudePlanLimitEvent,
+  projectClaudePlanLimitToCredits,
+  applyClaudePlanLimitToUsage,
+};

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

@@ -0,0 +1,90 @@
+const fs = require('node:fs/promises');
+const path = require('node:path');
+const os = require('node:os');
+const validId = id => typeof id === 'string' && /^[A-Za-z0-9][A-Za-z0-9_-]{0,199}$/.test(id);
+const root = () => path.join(process.env.CODEBUDDY_CONFIG_DIR || path.join(os.homedir(), '.codebuddy'), 'projects');
+const equal = (a, b) => process.platform === 'win32' ? a.toLowerCase() === b.toLowerCase() : a === b;
+async function readFile(file) {
+  const base = await fs.realpath(root());
+  const real = await fs.realpath(file);
+  const relative = path.relative(base, real);
+  if (relative.startsWith('..') || path.isAbsolute(relative) || !equal(path.resolve(file), real)) throw new Error('Native history path was redirected');
+  const stat = await fs.lstat(file);
+  if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 32 * 1024 * 1024) throw new Error('Native history file is unsafe or oversized');
+  const body = await fs.readFile(file, 'utf8');
+  const after = await fs.stat(file);
+  if (stat.size !== after.size || stat.mtimeMs !== after.mtimeMs) throw new Error('Native history changed while reading');
+  return body.split(/\r?\n/).filter(l => l.trim()).map(l => JSON.parse(l));
+}
+function branch(rows) {
+  const byId = new Map(); let leaf;
+  for (const row of rows) {
+    if (!['message', 'reasoning', 'function_call', 'function_call_result'].includes(row.type)) continue;
+    if (typeof row.id !== 'string' || !row.id) throw new Error('Native history has no stable item ID');
+    byId.set(row.id, row); leaf = row.id;
+  }
+  const chain = [], seen = new Set();
+  while (leaf) {
+    if (seen.has(leaf) || !byId.has(leaf)) throw new Error('Native history parent chain is invalid');
+    seen.add(leaf); const row = byId.get(leaf); chain.unshift(row); leaf = row.parentId;
+  }
+  return chain;
+}
+async function readCodeBuddyHistory(cwd, id) {
+  if (!validId(id)) throw new Error('Invalid CodeBuddy native session ID');
+  const dirs = await fs.readdir(root(), { withFileTypes: true });
+  const found = [];
+  for (const dir of dirs.filter(d => d.isDirectory() && !d.isSymbolicLink()).slice(0, 2000)) {
+    const file = path.join(root(), dir.name, id + '.jsonl');
+    try { await fs.access(file); found.push(file); } catch (error) { if (error.code !== 'ENOENT') throw error; }
+  }
+  if (found.length !== 1) throw new Error('Native CodeBuddy history missing or ambiguous');
+  const rows = await readFile(found[0]);
+  const currentCwd = await fs.realpath(cwd);
+  const nativeCwds = [...new Set(rows.map(r => r.cwd).filter(v => typeof v === 'string'))];
+  if (!nativeCwds.length) throw new Error('Native history has no workspace identity');
+  for (const nativeCwd of nativeCwds) if (!equal(await fs.realpath(nativeCwd), currentCwd)) throw new Error('Native history belongs to another workspace');
+  if (rows.some(r => r.sessionId && r.sessionId !== id)) throw new Error('Native history session mismatch');
+  return branch(rows);
+}
+function historyUsage(rows) {
+  const requests = new Map();
+  for (const row of rows) if (row.providerData?.messageId && row.providerData.rawUsage) requests.set(row.providerData.messageId, row.providerData.rawUsage);
+  const result = {};
+  for (const [host, native] of Object.entries({ inputTokens: 'prompt_tokens', outputTokens: 'completion_tokens', totalTokens: 'total_tokens', cacheRead: 'cache_read_input_tokens', cacheWrite: 'cache_creation_input_tokens', reasoningOutputTokens: 'completion_thinking_tokens', totalCredits: 'credit' })) {
+    const values = [...requests.values()].map(r => r[native]);
+    if (values.length && values.every(n => Number.isFinite(n) && n >= 0)) result[host] = values.reduce((a, b) => a + b, 0);
+  }
+  return result;
+}
+function messages(rows) {
+  return rows.filter(r => r.type === 'message' && ['user', 'assistant'].includes(r.role)).map(r => ({ id: r.id, role: r.role,
+    text: typeof r.content === 'string' ? r.content : (r.content || []).filter(c => ['text', 'input_text', 'output_text'].includes(c?.type) && typeof c.text === 'string').map(c => c.text).join('\n'),
+    at: Number.isFinite(r.timestamp) ? r.timestamp : Date.parse(r.timestamp) || 0 }));
+}
+function latestAssistantAfterUser(rows, userMessageId) {
+  const transcript = messages(rows);
+  const exact = userMessageId ? transcript.findIndex(row => row.role === 'user' && row.id === userMessageId) : -1;
+  const lastUser = exact >= 0 ? exact : transcript.findLastIndex(row => row.role === 'user');
+  return transcript.slice(lastUser + 1).findLast(row => row.role === 'assistant')?.text || '';
+}
+async function listCodeBuddyHistory() {
+  let dirs;
+  try { dirs = await fs.readdir(root(), { withFileTypes: true }); } catch (e) { if (e.code === 'ENOENT') return []; throw e; }
+  const found = [];
+  for (const dir of dirs.filter(d => d.isDirectory() && !d.isSymbolicLink()).slice(0, 2000)) {
+    for (const entry of (await fs.readdir(path.join(root(), dir.name), { withFileTypes: true })).filter(f => f.isFile() && f.name.endsWith('.jsonl')).slice(0, 2000)) {
+      const id = entry.name.slice(0, -6);
+      if (!validId(id)) continue;
+      const rows = await readFile(path.join(root(), dir.name, entry.name));
+      const cwd = rows.find(r => typeof r.cwd === 'string')?.cwd;
+      if (!cwd || !path.isAbsolute(cwd)) continue;
+      // Validate before offering a writable import; never trust a filename alone.
+      const chain = await readCodeBuddyHistory(cwd, id), transcript = messages(chain);
+      found.push({ nativeSessionId: id, cwd, title: transcript.find(r => r.role === 'user')?.text.slice(0, 120) || null,
+        updatedAt: (await fs.stat(path.join(root(), dir.name, entry.name))).mtimeMs, running: null });
+    }
+  }
+  return found;
+}
+module.exports = { readCodeBuddyHistory, historyUsage, branch, messages, latestAssistantAfterUser, listCodeBuddyHistory };

package/src/main/adapters/codebuddy.js

@@ -0,0 +1,2 @@
+const { nativeAcp } = require('./native-acp');
+module.exports = nativeAcp({ id: 'codebuddy', name: 'CodeBuddy', aliases: ['workbuddy', 'WorkBuddy'], args: ['--acp'] });