chatccc 0.2.10 → 0.2.11

package/src/adapters/codex-adapter.ts

@@ -0,0 +1,294 @@
+// =============================================================================
+// codex-adapter.ts — OpenAI Codex CLI 适配器
+// =============================================================================
+// 通过 codex exec --json 与 Codex CLI 交互。
+// - createSession: 生成 UUID sessionId，记录 cwd，不创建 Codex 线程（延迟到首次 prompt）
+// - prompt: 首次调用用 codex exec 创建线程，后续用 codex exec resume 恢复
+// - getSessionInfo: 从持久化映射读取 cwd / threadId
+// =============================================================================
+
+import { spawn, type ChildProcess } from "node:child_process";
+import { createInterface } from "node:readline";
+import { randomUUID } from "node:crypto";
+
+import type {
+  ToolAdapter,
+  UnifiedBlock,
+  UnifiedStreamMessage,
+  CreateSessionResult,
+  SessionInfo,
+} from "./adapter-interface.ts";
+import {
+  defaultCodexSessionMetaStore,
+  type CodexSessionMetaStore,
+} from "./codex-session-meta-store.ts";
+
+// ---------------------------------------------------------------------------
+// 命令与参数
+// ---------------------------------------------------------------------------
+
+/** 可通过 CHATCCC_CODEX_COMMAND 环境变量自定义 Codex 可执行文件路径 */
+function detectCodexCommand(): string {
+  return process.env.CHATCCC_CODEX_COMMAND?.trim() || "codex";
+}
+const CODEX_COMMAND = detectCodexCommand();
+
+/** exec 模式共用参数：JSONL 输出、绕过沙盒和确认、跳过 git 仓库检查 */
+const CODEX_BASE_ARGS = [
+  "exec",
+  "--json",
+  "--dangerously-bypass-approvals-and-sandbox",
+  "--skip-git-repo-check",
+];
+
+/** codex 模型 */
+function resolveCodexModel(): string | null {
+  const m = process.env.CHATCCC_CODEX_MODEL?.trim();
+  return m && m !== "default" ? m : null;
+}
+
+/** codex 努力程度（映射为 -c model_reasoning_effort=<value>） */
+function resolveCodexEffort(): string | null {
+  const e = process.env.CHATCCC_CODEX_EFFORT?.trim();
+  return e && e !== "default" ? e : null;
+}
+
+// ---------------------------------------------------------------------------
+// 类型：Codex JSONL 消息行
+// ---------------------------------------------------------------------------
+
+interface CodexItem {
+  id?: string;
+  type?: string;
+  text?: string;
+  command?: string;
+  aggregated_output?: string;
+  exit_code?: number | null;
+  status?: string;
+}
+
+interface CodexEvent {
+  type: string;
+  thread_id?: string;
+  item?: CodexItem;
+  usage?: {
+    input_tokens?: number;
+    cached_input_tokens?: number;
+    output_tokens?: number;
+    reasoning_output_tokens?: number;
+  };
+}
+
+// ---------------------------------------------------------------------------
+// normalizeCodexMessage — Codex 事件 → UnifiedStreamMessage | null
+// ---------------------------------------------------------------------------
+
+export function normalizeCodexMessage(
+  msg: CodexEvent,
+): UnifiedStreamMessage | null {
+  // agent_message 文本回复
+  if (
+    msg.type === "item.completed" &&
+    msg.item?.type === "agent_message" &&
+    msg.item.text
+  ) {
+    return {
+      type: "assistant",
+      blocks: [{ type: "text", text: msg.item.text }],
+    };
+  }
+
+  // command_execution 工具调用开始
+  if (
+    msg.type === "item.started" &&
+    msg.item?.type === "command_execution" &&
+    msg.item.command
+  ) {
+    return {
+      type: "assistant",
+      blocks: [
+        {
+          type: "tool_use",
+          name: "Bash",
+          input: { command: msg.item.command },
+        },
+      ],
+    };
+  }
+
+  // command_execution 工具调用完成
+  if (
+    msg.type === "item.completed" &&
+    msg.item?.type === "command_execution"
+  ) {
+    const exitCode = msg.item.exit_code;
+    return {
+      type: "assistant",
+      blocks: [
+        {
+          type: "tool_result",
+          tool_use_id: msg.item.id ?? "",
+          content: msg.item.aggregated_output ?? "",
+          is_error: exitCode != null && exitCode !== 0 ? true : undefined,
+        },
+      ],
+    };
+  }
+
+  // thread.started / turn.started / turn.completed → 不映射为用户可见消息
+  return null;
+}
+
+// ---------------------------------------------------------------------------
+// 子进程辅助函数
+// ---------------------------------------------------------------------------
+
+function spawnCodex(
+  args: string[],
+  cwd?: string,
+  stdinText?: string,
+): ChildProcess {
+  const allArgs = [...args];
+  const model = resolveCodexModel();
+  if (model) {
+    // 把 -m 插在 exec 后面、其他参数前面
+    const execIdx = allArgs.indexOf("exec");
+    allArgs.splice(execIdx + 1, 0, "-m", model);
+  }
+  const effort = resolveCodexEffort();
+  if (effort) {
+    allArgs.push("-c", `model_reasoning_effort="${effort}"`);
+  }
+
+  const proc = spawn(CODEX_COMMAND, allArgs, {
+    cwd,
+    stdio: [stdinText !== undefined ? "pipe" : "ignore", "pipe", "pipe"],
+    windowsHide: true,
+    shell: true,
+  });
+
+  let stderr = "";
+  proc.stderr!.on("data", (chunk: Buffer) => {
+    stderr += chunk.toString();
+  });
+  proc.on("close", (code) => {
+    if (code !== 0 && stderr.trim()) {
+      console.error(
+        `[Codex stderr] exit=${code}: ${stderr.trim().slice(0, 2000)}`,
+      );
+    }
+  });
+
+  if (stdinText !== undefined) {
+    proc.stdin!.write(stdinText);
+    proc.stdin!.end();
+  }
+  return proc;
+}
+
+async function* readJsonLines(
+  proc: ChildProcess,
+  signal?: AbortSignal,
+): AsyncGenerator<CodexEvent> {
+  const rl = createInterface({ input: proc.stdout!, crlfDelay: Infinity });
+  for await (const line of rl) {
+    if (signal?.aborted) break;
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+    try {
+      yield JSON.parse(trimmed) as CodexEvent;
+    } catch {
+      // 非 JSON 行静默跳过（如 "Reading prompt from stdin..."）
+    }
+  }
+}
+
+// ---------------------------------------------------------------------------
+// 适配器实现
+// ---------------------------------------------------------------------------
+
+class CodexAdapter implements ToolAdapter {
+  readonly displayName = "Codex";
+  readonly sessionDescPrefix = "Codex Session:";
+  private metaStore: CodexSessionMetaStore;
+
+  constructor(metaStore: CodexSessionMetaStore) {
+    this.metaStore = metaStore;
+  }
+
+  // createSession: 生成 sessionId，记录 cwd，不创建 Codex 线程（延迟到首次 prompt）
+  async createSession(cwd: string): Promise<CreateSessionResult> {
+    const sessionId = randomUUID();
+    await this.metaStore.set(sessionId, { cwd });
+    return { sessionId };
+  }
+
+  async *prompt(
+    sessionId: string,
+    userText: string,
+    cwd: string,
+    signal?: AbortSignal,
+  ): AsyncIterable<UnifiedStreamMessage> {
+    let meta = await this.metaStore.get(sessionId);
+    const threadId = meta?.threadId;
+    const isFirstPrompt = !threadId;
+
+    // 首次 prompt: codex exec 创建新线程
+    // 后续 prompt: codex exec resume 恢复已有线程（resume 不接受 -C，cwd 继承自原线程）
+    const args = isFirstPrompt
+      ? [...CODEX_BASE_ARGS, "-C", cwd, "-"]
+      : [...CODEX_BASE_ARGS, "resume", threadId, "-"];
+
+    const proc = spawnCodex(args, cwd, userText);
+
+    try {
+      for await (const raw of readJsonLines(proc, signal)) {
+        if (signal?.aborted) break;
+
+        // 首次 prompt 时从 thread.started 事件学习 threadId
+        if (
+          isFirstPrompt &&
+          raw.type === "thread.started" &&
+          raw.thread_id
+        ) {
+          void this.metaStore
+            .setThreadId(sessionId, raw.thread_id)
+            .catch(() => {});
+        }
+
+        const normalized = normalizeCodexMessage(raw);
+        if (normalized) yield normalized;
+      }
+    } finally {
+      proc.kill();
+    }
+  }
+
+  async getSessionInfo(
+    sessionId: string,
+  ): Promise<SessionInfo | undefined> {
+    const meta = await this.metaStore.get(sessionId);
+    if (!meta) return undefined;
+    return { sessionId, cwd: meta.cwd };
+  }
+
+  async closeSession(_sessionId: string): Promise<void> {
+    // no-op：子进程由 prompt 的 finally 自动 kill
+  }
+}
+
+// ---------------------------------------------------------------------------
+// 工厂函数
+// ---------------------------------------------------------------------------
+
+export interface CreateCodexAdapterOptions {
+  metaStore?: CodexSessionMetaStore;
+}
+
+export function createCodexAdapter(
+  options: CreateCodexAdapterOptions = {},
+): ToolAdapter {
+  return new CodexAdapter(
+    options.metaStore ?? defaultCodexSessionMetaStore,
+  );
+}

package/src/adapters/codex-session-meta-store.ts

@@ -0,0 +1,131 @@
+// =============================================================================
+// codex-session-meta-store.ts — Codex 会话 sessionId → meta 持久化映射
+// =============================================================================
+// Codex CLI 没有 SDK 可查询会话元数据，ChatCCC 内部维护 sessionId → { cwd, threadId } 映射。
+// threadId 在首次 prompt 时才生成（Codex 不支持"空会话"创建），存储用于后续 resume。
+// =============================================================================
+
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+
+import { PROJECT_ROOT } from "../config.ts";
+
+export const CODEX_SESSION_META_FILE = join(
+  PROJECT_ROOT,
+  ".claude",
+  "codex-session-meta.json",
+);
+
+export interface CodexSessionMeta {
+  cwd: string;
+  threadId?: string;
+}
+
+export interface CodexSessionMetaStore {
+  get(sessionId: string): Promise<CodexSessionMeta | undefined>;
+  set(sessionId: string, partial: Partial<CodexSessionMeta>): Promise<void>;
+  /**
+   * 只更新 threadId（高频操作：prompt 首次调用时写入）。
+   * 与 set 的区别：不重新读写完整文件，内联到已有的 load→merge→save 流程。
+   */
+  setThreadId(sessionId: string, threadId: string): Promise<void>;
+}
+
+interface RawEntry {
+  cwd?: string;
+  threadId?: string;
+}
+
+function isNonEmptyString(v: unknown): v is string {
+  return typeof v === "string" && v.length > 0;
+}
+
+function parseEntry(raw: unknown): RawEntry | null {
+  if (raw && typeof raw === "object" && !Array.isArray(raw)) {
+    const obj = raw as Record<string, unknown>;
+    const out: RawEntry = {};
+    if (isNonEmptyString(obj.cwd)) out.cwd = obj.cwd;
+    if (isNonEmptyString(obj.threadId)) out.threadId = obj.threadId;
+    return out;
+  }
+  return null;
+}
+
+export function createCodexSessionMetaStore(
+  filePath: string = CODEX_SESSION_META_FILE,
+): CodexSessionMetaStore {
+  let cache: Record<string, RawEntry> | null = null;
+
+  async function load(): Promise<Record<string, RawEntry>> {
+    if (cache) return cache;
+    try {
+      const raw = await readFile(filePath, "utf-8");
+      const parsed = JSON.parse(raw);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        const out: Record<string, RawEntry> = {};
+        for (const [k, v] of Object.entries(parsed as Record<string, unknown>)) {
+          const entry = parseEntry(v);
+          if (entry) out[k] = entry;
+        }
+        cache = out;
+        return out;
+      }
+    } catch {
+      // 文件不存在或损坏
+    }
+    cache = {};
+    return cache;
+  }
+
+  async function save(map: Record<string, RawEntry>): Promise<void> {
+    try {
+      await mkdir(dirname(filePath), { recursive: true });
+      await writeFile(filePath, JSON.stringify(map, null, 2), "utf-8");
+    } catch (err) {
+      console.error(
+        `[codex-session-meta] failed to persist ${filePath}: ${(err as Error).message}`,
+      );
+    }
+  }
+
+  return {
+    async get(sessionId: string): Promise<CodexSessionMeta | undefined> {
+      const map = await load();
+      const entry = map[sessionId];
+      if (!entry || !isNonEmptyString(entry.cwd)) return undefined;
+      return entry.threadId
+        ? { cwd: entry.cwd, threadId: entry.threadId }
+        : { cwd: entry.cwd };
+    },
+
+    async set(
+      sessionId: string,
+      partial: Partial<CodexSessionMeta>,
+    ): Promise<void> {
+      const map = await load();
+      const existing = map[sessionId] ?? {};
+      const merged: RawEntry = { ...existing };
+      if (isNonEmptyString(partial.cwd)) merged.cwd = partial.cwd;
+      if (isNonEmptyString(partial.threadId)) merged.threadId = partial.threadId;
+
+      if (existing.cwd === merged.cwd && existing.threadId === merged.threadId) return;
+
+      map[sessionId] = merged;
+      await save(map);
+    },
+
+    async setThreadId(
+      sessionId: string,
+      threadId: string,
+    ): Promise<void> {
+      const map = await load();
+      const existing = map[sessionId] ?? {};
+      if (existing.threadId === threadId) return;
+      const merged: RawEntry = { ...existing, threadId };
+      map[sessionId] = merged;
+      await save(map);
+    },
+  };
+}
+
+export const defaultCodexSessionMetaStore = createCodexSessionMetaStore();

package/src/cards.ts

@@ -108,16 +108,25 @@ export function buildProgressCard(
   });
 }
 
-export function buildHelpCard(userText: string): string {
+export function buildHelpCard(userText: string, opts: { greeting?: string } = {}): string {
+  const greeting = opts.greeting ?? `你发送了: ${userText}`;
+  const lines = [
+    "发送 **/new** 创建新会话（默认 Claude Code）",
+    "发送 **/new claude** 创建新 Claude 对话",
+    "发送 **/new cursor** 创建新 Cursor 会话",
+    "发送 **/new codex** 创建新 Codex 会话",
+    "发送 **/forget** 重置当前会话（保留工作目录，同一群内继续）",
+  ].join("\n");
   return JSON.stringify({
     config: { wide_screen_mode: true },
     header: { template: "blue", title: { content: "ChatCCC", tag: "plain_text" } },
     elements: [
-      { tag: "div", text: { tag: "lark_md", content: `你发送了: ${userText}` } },
-      { tag: "div", text: { tag: "lark_md", content: "发送 **/new** 创建新会话（默认 Claude Code）\n发送 **/new claude** 创建新 Claude 对话\n发送 **/new cursor** 创建新 Cursor 会话（启动需要多等几秒）" } },
+      { tag: "div", text: { tag: "lark_md", content: greeting } },
+      { tag: "div", text: { tag: "lark_md", content: lines } },
       buildButtons([
         { text: "新建 Claude Code 会话（/new claude）", value: JSON.stringify({ cmd: "new" }), type: "primary" },
         { text: "新建 Cursor 会话（/new cursor）", value: JSON.stringify({ cmd: "new cursor" }), type: "primary" },
+        { text: "新建 Codex 会话（/new codex）", value: JSON.stringify({ cmd: "new codex" }), type: "primary" },
         { text: "重启 ChatCCC（/restart）", value: JSON.stringify({ cmd: "restart" }), type: "danger" },
         { text: "切换工作路径（/cd）", value: JSON.stringify({ cmd: "cd" }), type: "default" },
       ]),
@@ -247,18 +256,20 @@ export function buildSessionsCard(sessions: Array<{
   model: string;
   tool: string;
 }>): string {
-  // 按 tool 分组排序：Claude Code 在前，Cursor 在后
-  const claudeCodeSessions = sessions.filter(s => s.tool !== "cursor");
+  // 按 tool 分组排序：Claude Code 在前，Cursor 其次，Codex 最后
+  const claudeCodeSessions = sessions.filter(s => s.tool !== "cursor" && s.tool !== "codex");
   const cursorSessions = sessions.filter(s => s.tool === "cursor");
+  const codexSessions = sessions.filter(s => s.tool === "codex");
   const hasClaudeCode = claudeCodeSessions.length > 0;
   const hasCursor = cursorSessions.length > 0;
+  const hasCodex = codexSessions.length > 0;
 
   if (sessions.length === 0) {
     return JSON.stringify({
       config: { wide_screen_mode: true },
       header: { template: "blue", title: { content: "所有会话", tag: "plain_text" } },
       elements: [
-        { tag: "div", text: { tag: "lark_md", content: "当前没有会话记录。\n\n使用 **/new**（默认 Claude Code）、**/new claude** 或 **/new cursor** 创建新会话。" } },
+        { tag: "div", text: { tag: "lark_md", content: "当前没有会话记录。\n\n使用 **/new**（默认 Claude Code）、**/new claude**、**/new cursor** 或 **/new codex** 创建新会话。" } },
         { tag: "hr" },
         { tag: "action", actions: [{ tag: "button", text: { tag: "plain_text", content: "收起" }, type: "default", value: { action: "close" } }] },
       ],
@@ -274,7 +285,7 @@ export function buildSessionsCard(sessions: Array<{
       const secs = s.elapsedSeconds % 60;
       extra = ` | 本轮: ${mins}分${secs}秒`;
     }
-    const toolLabel = s.tool === "cursor" ? "Cursor" : "Claude Code";
+    const toolLabel = s.tool === "cursor" ? "Cursor" : s.tool === "codex" ? "Codex" : "Claude Code";
     return `**${i + 1}.** \`${shortId}\` ${status} | 工具: ${toolLabel} | 轮数: ${s.turnCount} | ${s.model}${extra}`;
   };
 
@@ -296,12 +307,22 @@ export function buildSessionsCard(sessions: Array<{
     }
   }
 
+  if (hasCodex) {
+    if (hasClaudeCode || hasCursor) lines.push("", "**Codex 会话:**", "");
+    else lines.push("**Codex 会话:**", "");
+    for (const s of codexSessions) {
+      lines.push(formatSession(s, idx++));
+    }
+  }
+
   return JSON.stringify({
     config: { wide_screen_mode: true },
     header: { template: "blue", title: { content: "所有会话", tag: "plain_text" } },
     elements: [
       { tag: "div", text: { tag: "lark_md", content: lines.join("\n") } },
       { tag: "hr" },
+      { tag: "div", text: { tag: "lark_md", content: "在会话群内发送 **/forget** 可重置当前会话（创建新 Session，保留工作目录和群聊）。" } },
+      { tag: "hr" },
       {
         tag: "action",
         actions: [{

package/src/config.ts

@@ -364,15 +364,19 @@ export function explainMissingFeishuCredentialsAndExit(): never {
 export const CLAUDE_SESSION_PREFIX = "Claude Code Session:";
 /** 群描述中用于识别 Cursor 会话的前缀 */
 export const CURSOR_SESSION_PREFIX = "Cursor Session:";
+/** 群描述中用于识别 Codex 会话的前缀 */
+export const CODEX_SESSION_PREFIX = "Codex Session:";
 
 /** 根据 tool 名称返回对应的群描述前缀 */
 export function sessionPrefixForTool(tool: string): string {
   if (tool === "cursor") return CURSOR_SESSION_PREFIX;
+  if (tool === "codex") return CODEX_SESSION_PREFIX;
   return CLAUDE_SESSION_PREFIX;
 }
 
 /** 根据 tool 名称返回用于状态展示的标签 */
 export function toolDisplayName(tool: string): string {
   if (tool === "cursor") return "Cursor";
+  if (tool === "codex") return "Codex";
   return "Claude Code";
 }