chatccc 0.2.10 → 0.2.11

package/README.md

@@ -1,6 +1,6 @@
 # ChatCCC
 
-**飞书聊天控制 Claude Code / Cursor，未来支持 Codex**
+**飞书（Lark）聊天控制 Claude Code / Cursor / Codex**
 
 ---
 
@@ -8,13 +8,13 @@
 
 传统的 Claude Code（尤其是使用第三方 API 的，如 DeepSeek），需要坐在电脑桌前才能用。**离开电脑就没法用了。**
 
-ChatCCC 把 Claude Code 和 Cursor Agent 接入了飞书群聊：
+ChatCCC 把 Claude Code、Cursor Agent、Codex (OpenAI) 接入了飞书群聊：
 
-- **手机上也能用 Claude Code / Cursor** —— 在飞书群里发消息就等于在终端输入指令，AI 的思考和回复会流式展示在群卡片里
+- **手机上也能用 Claude Code / Cursor / Codex** —— 在飞书群里发消息就等于在终端输入指令，AI 的思考和回复会流式展示在群卡片里
 - **多会话并行** —— 一个群就是一个 AI 会话，完全隔离、互不干扰，并行工作效率更高
-- **多工具切换** —— `/new claude` 创建 Claude Code 会话，`/new cursor` 创建 Cursor 会话，各取所长
+- **多工具切换** —— `/new claude` 创建 Claude Code 会话，`/new cursor` 创建 Cursor 会话，`/new codex` 创建 Codex 会话，各取所长
 
-一句话：**在任何设备上打开飞书，就能让 Claude Code 或 Cursor 帮你写代码、排查问题、分析项目。**
+一句话：**在任何设备上打开飞书，就能让 Claude Code / Cursor / Codex 帮你写代码、排查问题、分析项目。**
 
 <p align="center">
   <img src="images/img_readme_0.jpg" alt="飞书群聊中使用 ChatCCC" width="280" />
@@ -29,7 +29,7 @@ ChatCCC 把 Claude Code 和 Cursor Agent 接入了飞书群聊：
 - **一群一会话，心智最简单** —— `/new` 直接建一个新飞书群，群本身就是 AI 会话上下文。换会话就是换群，没有 thread / 子话题概念，手机端切换最直观
 - **零配置成本** —— 只用 `.env`，没有 TOML、没有 Web 后台。`npm i -g chatccc` 后 `cd` 到项目目录直接 `chatccc` 就跑
 - **群里能跑 git** —— `/git status`、`/git pull`、`/git log` 在飞书群里直接执行 stdout/stderr 回发，不用回电脑
-- **代码极简易改** —— 纯 TypeScript 实现，核心只有 20 多个文件，统一 `ToolAdapter` 接口屏蔽 Claude / Cursor 差异，看得懂、改得动
+- **代码极简易改** —— 纯 TypeScript 实现，核心只有 20 多个文件，统一 `ToolAdapter` 接口屏蔽 Claude / Cursor / Codex 差异，看得懂、改得动
 
 ---
 
@@ -112,18 +112,55 @@ CHATCCC_CURSOR_COMMAND=/path/to/agent
 
 > **说明**：只使用 Claude Code（`/new claude` 或 `/new`）的用户无需安装 Cursor CLI。
 
+#### Codex CLI（使用 Codex 会话时需要）
+
+ChatCCC **不捆绑** Codex CLI，需要用户自行安装：
+
+```bash
+npm install -g @openai/codex
+```
+
+安装后需登录 OpenAI 账号：
+
+```bash
+codex login
+```
+
+验证是否已安装：
+
+```bash
+codex --version
+```
+
+Codex 会话的模型和努力程度由 `config.toml`（`~/.codex/config.toml`）决定，也可通过环境变量指定：
+
+```env
+# 不设置或设为 default 时由 codex config.toml 决定
+CHATCCC_CODEX_MODEL=default
+
+# 不设置或设为 default 时由 codex config.toml 决定（通过 -c model_reasoning_effort 传递）
+CHATCCC_CODEX_EFFORT=default
+```
+
+也可通过环境变量指定自定义 Codex 可执行文件路径：
+
+```env
+CHATCCC_CODEX_COMMAND=/path/to/codex
+```
+
+> **说明**：只使用 Claude Code 或 Cursor 的用户无需安装 Codex CLI。
+
 ### 2. 创建飞书应用
 
 打开 [飞书开放平台](https://open.feishu.cn)，创建一个**企业自建应用**。
 
 **添加应用能力**：开启「机器人」功能。
 
-**权限配置（重要）**（在「权限管理」中按前缀搜索，**将以下三类前缀开头的权限全部开通**）：
+**权限配置（重要）**（在「权限管理」中按前缀搜索，**将以下两类前缀开头的权限全部开通**）：
 
 | 前缀 | 用途（简要） |
 | ---- | ------------ |
-| `im:message` | 收发与读取消息、以机器人身份发言、与会话相关的消息能力等 |
-| `im:chat` | 创建与管理群聊、与会话绑定、群成员与聊天场景相关能力等 |
+| `im:` | 收发消息、创建与管理群聊、以机器人身份发言等（请将此前缀下所有权限全部开通） |
 | `cardkit:` | 群卡片展示、流式更新、卡片按钮与交互回调相关能力等 |
 
 控制台中同一前缀下往往有多条子权限，请逐项勾选开通，避免遗漏导致收不到消息或卡片异常。
@@ -182,6 +219,19 @@ CHATCCC_CURSOR_MODEL=claude-opus-4-7-max
 # CHATCCC_CURSOR_ARGS=-p --force --output-format stream-json --stream-partial-output
 ```
 
+Codex CLI 模型与努力程度（仅 Codex 会话相关，省略或 `default` 时不传对应参数）：
+
+```env
+# Codex 会话使用的模型；不设置或设为 default 时由 codex config.toml 决定
+CHATCCC_CODEX_MODEL=default
+
+# Codex 会话的努力程度（low/medium/high）；不设置或设为 default 时由 codex config.toml 决定
+CHATCCC_CODEX_EFFORT=default
+
+# 也可指定自定义 Codex 可执行文件路径
+# CHATCCC_CODEX_COMMAND=/path/to/codex
+```
+
 #### 注意！第三方 API（如 DeepSeek）与鉴权 403
 
 若你通过 **Anthropic 兼容网关**（例如 DeepSeek 的 `/anthropic` 端点）调用模型，除了官方 Claude 以外，需要配置 **`ANTHROPIC_API_KEY`**（API 密钥）与 **`ANTHROPIC_BASE_URL`**（写入系统环境变量，见下表）。
@@ -237,7 +287,7 @@ CHATCCC_GIT_TIMEOUT_SECONDS=600
 
 ### 5. 开始使用
 
-在飞书中找到你的机器人，发送 `/new`（默认 Claude Code）或 `/new claude` / `/new cursor`，机器人会自动创建一个群聊并把 AI 会话绑定到该群。之后直接在群里发消息就能对话。
+在飞书中找到你的机器人，发送 `/new`（默认 Claude Code）或 `/new claude` / `/new cursor` / `/new codex`，机器人会自动创建一个群聊并把 AI 会话绑定到该群。之后直接在群里发消息就能对话。
 
 ### 可用指令
 
@@ -247,10 +297,12 @@ CHATCCC_GIT_TIMEOUT_SECONDS=600
 | `/new`          | 创建新的 Claude Code 会话（默认）    |
 | `/new claude`   | 创建新的 Claude Code 会话          |
 | `/new cursor`   | 创建新的 Cursor 会话               |
+| `/new codex`    | 创建新的 Codex 会话（OpenAI）         |
 | `/stop`         | 停止当前正在生成的回复                  |
 | `/status`       | 查看当前会话的状态（轮数、模型、上下文 token 等） |
 | `/cd`           | 查看/切换工作目录                    |
 | `/sessions`     | 查看所有会话状态                    |
+| `/forget`       | 重置当前会话（创建新 Session，保留工作目录，同一群内继续） |
 | `/git <子命令>` | 在**当前会话工作目录**执行 `git ...` 并把 stdout/stderr 回发到群里（仅会话群内可用，超时见 `CHATCCC_GIT_TIMEOUT_SECONDS`） |
 | `/restart`      | 重启机器人进程                      |
 
@@ -259,4 +311,4 @@ CHATCCC_GIT_TIMEOUT_SECONDS=600
 
 ## 技术栈
 
-TypeScript / Node.js >= 20 / tsx / Anthropic Claude Agent SDK / Cursor Agent CLI / 飞书 WebSocket API / CardKit
+TypeScript / Node.js >= 20 / tsx / Anthropic Claude Agent SDK / Cursor Agent CLI / Codex CLI (OpenAI) / 飞书 WebSocket API / CardKit

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chatccc",
-  "version": "0.2.10",
+  "version": "0.2.11",
   "description": "Feishu bot bridge for Claude Code",
   "license": "Apache-2.0",
   "type": "module",
@@ -24,12 +24,15 @@
     "demo:create-group:local": "tsx --env-file=.env src/index.ts --local",
     "demo:permission-check": "tsx --env-file=.env demo/permission_check.ts",
     "demo:claude-hi": "tsx --env-file=.env demo/claude_say_hi.ts",
+    "demo:codex-hi": "tsx --env-file=.env demo/codex_say_hi.ts",
     "test": "vitest run",
     "test:watch": "vitest"
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "0.2.133",
     "@larksuiteoapi/node-sdk": "^1.59.0",
+    "nodemailer": "^8.0.7",
+    "sharp": "^0.34.5",
     "tsx": "^4.0.0",
     "ws": "^8.18.0"
   },

package/src/__tests__/cards.test.ts

@@ -151,7 +151,7 @@ describe("buildHelpCard", () => {
     const parsed = JSON.parse(card);
     const action = parsed.elements[2];
     expect(action.tag).toBe("action");
-    expect(action.actions).toHaveLength(4);
+    expect(action.actions).toHaveLength(5);
   });
 });
 

package/src/__tests__/codex-adapter.test.ts

@@ -0,0 +1,305 @@
+import { describe, it, expect } from "vitest";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  normalizeCodexMessage,
+  createCodexAdapter,
+  type CreateCodexAdapterOptions,
+} from "../adapters/codex-adapter.ts";
+import type { UnifiedStreamMessage } from "../adapters/adapter-interface.ts";
+import {
+  type CodexSessionMeta,
+  type CodexSessionMetaStore,
+} from "../adapters/codex-session-meta-store.ts";
+import { accumulateBlockContent, pickFinalReply, type AccumulatorState } from "../session.ts";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+function readFixture(name: string): unknown[] {
+  const raw = readFileSync(join(__dirname, "fixtures", name), "utf-8");
+  return raw
+    .split(/\r?\n/)
+    .filter(Boolean)
+    .map((line) => JSON.parse(line));
+}
+
+// 进程内内存版 meta store
+function createInMemoryMetaStore(
+  initial: Record<string, CodexSessionMeta> = {},
+): CodexSessionMetaStore & { snapshot(): Record<string, CodexSessionMeta> } {
+  const map = new Map<string, CodexSessionMeta>(Object.entries(initial));
+  return {
+    async get(sid) {
+      return map.get(sid);
+    },
+    async set(sid, partial) {
+      const existing = map.get(sid) ?? { cwd: "" };
+      const merged: CodexSessionMeta = { ...existing, ...partial };
+      if (typeof merged.cwd !== "string" || merged.cwd.length === 0) return;
+      map.set(sid, merged);
+    },
+    async setThreadId(sid, threadId) {
+      const existing = map.get(sid);
+      if (existing) {
+        map.set(sid, { ...existing, threadId });
+      }
+    },
+    snapshot() {
+      return Object.fromEntries(map);
+    },
+  };
+}
+
+// ---------------------------------------------------------------------------
+// normalizeCodexMessage — 核心映射逻辑测试（纯函数）
+// ---------------------------------------------------------------------------
+
+describe("normalizeCodexMessage", () => {
+  it("normalizes agent_message into assistant text block", () => {
+    const result = normalizeCodexMessage({
+      type: "item.completed",
+      item: { id: "item_0", type: "agent_message", text: "hello" },
+    });
+    expect(result).not.toBeNull();
+    expect(result!.type).toBe("assistant");
+    expect(result!.blocks).toEqual([{ type: "text", text: "hello" }]);
+  });
+
+  it("normalizes command_execution start into tool_use block", () => {
+    const result = normalizeCodexMessage({
+      type: "item.started",
+      item: {
+        id: "item_0",
+        type: "command_execution",
+        command: "powershell.exe -Command ls",
+        status: "in_progress",
+      },
+    });
+    expect(result).not.toBeNull();
+    expect(result!.type).toBe("assistant");
+    expect(result!.blocks).toEqual([
+      { type: "tool_use", name: "Bash", input: { command: "powershell.exe -Command ls" } },
+    ]);
+  });
+
+  it("normalizes command_execution completion as tool_result (success)", () => {
+    const result = normalizeCodexMessage({
+      type: "item.completed",
+      item: {
+        id: "item_0",
+        type: "command_execution",
+        command: "ls",
+        aggregated_output: "file1\nfile2\n",
+        exit_code: 0,
+        status: "completed",
+      },
+    });
+    expect(result).not.toBeNull();
+    expect(result!.blocks).toEqual([
+      {
+        type: "tool_result",
+        tool_use_id: "item_0",
+        content: "file1\nfile2\n",
+        is_error: undefined,
+      },
+    ]);
+  });
+
+  it("normalizes command_execution completion as tool_result (error)", () => {
+    const result = normalizeCodexMessage({
+      type: "item.completed",
+      item: {
+        id: "item_err",
+        type: "command_execution",
+        command: "nonexistent",
+        aggregated_output: "command not found",
+        exit_code: 127,
+        status: "completed",
+      },
+    });
+    expect(result).not.toBeNull();
+    expect(result!.blocks).toEqual([
+      {
+        type: "tool_result",
+        tool_use_id: "item_err",
+        content: "command not found",
+        is_error: true,
+      },
+    ]);
+  });
+
+  it("returns null for thread.started events", () => {
+    expect(
+      normalizeCodexMessage({
+        type: "thread.started",
+        thread_id: "abc-123",
+      }),
+    ).toBeNull();
+  });
+
+  it("returns null for turn.started events", () => {
+    expect(normalizeCodexMessage({ type: "turn.started" })).toBeNull();
+  });
+
+  it("returns null for turn.completed events", () => {
+    expect(
+      normalizeCodexMessage({
+        type: "turn.completed",
+        usage: { input_tokens: 100, output_tokens: 50 },
+      }),
+    ).toBeNull();
+  });
+
+  it("returns null for unknown event types", () => {
+    expect(normalizeCodexMessage({ type: "unknown" })).toBeNull();
+    expect(normalizeCodexMessage({} as Parameters<typeof normalizeCodexMessage>[0])).toBeNull();
+  });
+
+  it("returns null for agent_message with empty text", () => {
+    const result = normalizeCodexMessage({
+      type: "item.completed",
+      item: { id: "item_0", type: "agent_message", text: "" },
+    });
+    expect(result).toBeNull();
+  });
+
+  it("returns null for command_execution start without command text", () => {
+    const result = normalizeCodexMessage({
+      type: "item.started",
+      item: { id: "item_0", type: "command_execution", status: "in_progress" },
+    });
+    expect(result).toBeNull();
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Fixture 端到端测试
+// ---------------------------------------------------------------------------
+
+describe("Codex stream fixtures", () => {
+  it("simple text: 流结束后 pickFinalReply 返回正确文本", () => {
+    const lines = readFixture("codex_simple_text.jsonl");
+    const state: AccumulatorState = {
+      accumulatedContent: "",
+      finalText: "",
+      finalCompleteText: "",
+      chunkCount: 0,
+    };
+    for (const raw of lines) {
+      const normalized = normalizeCodexMessage(
+        raw as Parameters<typeof normalizeCodexMessage>[0],
+      );
+      if (!normalized) continue;
+      for (const block of normalized.blocks) {
+        accumulateBlockContent(block, state);
+      }
+    }
+
+    expect(pickFinalReply(state)).toBe("hello");
+  });
+
+  it("with tool: 流结束后 pickFinalReply 返回最终文本（不含工具输出在 finalText 中）", () => {
+    const lines = readFixture("codex_with_tool.jsonl");
+    const state: AccumulatorState = {
+      accumulatedContent: "",
+      finalText: "",
+      finalCompleteText: "",
+      chunkCount: 0,
+    };
+    for (const raw of lines) {
+      const normalized = normalizeCodexMessage(
+        raw as Parameters<typeof normalizeCodexMessage>[0],
+      );
+      if (!normalized) continue;
+      for (const block of normalized.blocks) {
+        accumulateBlockContent(block, state);
+      }
+    }
+
+    // finalText 应该只包含最终的 agent_message
+    expect(pickFinalReply(state)).toBe("tool_test");
+    // accumulatedContent 包含工具调用信息
+    expect(state.accumulatedContent).toContain("Bash");
+    expect(state.accumulatedContent).toContain("tool_test");
+  });
+
+  it("with tool: 只映射 agent_message 和 command_execution，不映射元事件", () => {
+    const lines = readFixture("codex_with_tool.jsonl");
+    const messages: UnifiedStreamMessage[] = [];
+    for (const raw of lines) {
+      const normalized = normalizeCodexMessage(
+        raw as Parameters<typeof normalizeCodexMessage>[0],
+      );
+      if (normalized) messages.push(normalized);
+    }
+
+    // 应有: tool_use + tool_result + text = 3 条消息
+    expect(messages.length).toBe(3);
+    expect(messages[0].blocks[0].type).toBe("tool_use");
+    expect(messages[1].blocks[0].type).toBe("tool_result");
+    expect(messages[2].blocks[0].type).toBe("text");
+  });
+});
+
+// ---------------------------------------------------------------------------
+// createCodexAdapter — 工厂函数测试
+// ---------------------------------------------------------------------------
+
+describe("createCodexAdapter", () => {
+  it("returns adapter with correct displayName and sessionDescPrefix", () => {
+    const adapter = createCodexAdapter();
+    expect(adapter.displayName).toBe("Codex");
+    expect(adapter.sessionDescPrefix).toBe("Codex Session:");
+  });
+
+  it("closeSession does not throw", async () => {
+    const adapter = createCodexAdapter();
+    await expect(adapter.closeSession("any-id")).resolves.toBeUndefined();
+  });
+
+  it("getSessionInfo: store 中无该 sessionId 时返回 undefined", async () => {
+    const store = createInMemoryMetaStore();
+    const adapter = createCodexAdapter({ metaStore: store });
+    const info = await adapter.getSessionInfo("unknown-sid");
+    expect(info).toBeUndefined();
+  });
+
+  it("getSessionInfo: store 有 cwd 时返回 cwd，无 threadId", async () => {
+    const store = createInMemoryMetaStore({
+      "sid-known": { cwd: "F:/proj/Foo" },
+    });
+    const adapter = createCodexAdapter({ metaStore: store });
+    const info = await adapter.getSessionInfo("sid-known");
+    expect(info).toEqual({ sessionId: "sid-known", cwd: "F:/proj/Foo" });
+  });
+
+  it("getSessionInfo: 有 cwd + threadId 时一并返回", async () => {
+    const store = createInMemoryMetaStore({
+      "sid-known": { cwd: "F:/proj/Foo", threadId: "thread-123" },
+    });
+    const adapter = createCodexAdapter({ metaStore: store });
+    const info = await adapter.getSessionInfo("sid-known");
+    expect(info).toEqual({
+      sessionId: "sid-known",
+      cwd: "F:/proj/Foo",
+    });
+  });
+
+  it("getSessionInfo: 不同 sessionId 互不影响", async () => {
+    const store = createInMemoryMetaStore({
+      "sid-A": { cwd: "/a", threadId: "tA" },
+      "sid-B": { cwd: "/b" },
+    });
+    const adapter = createCodexAdapter({ metaStore: store });
+    expect(await adapter.getSessionInfo("sid-A")).toEqual({
+      sessionId: "sid-A",
+      cwd: "/a",
+    });
+    expect(await adapter.getSessionInfo("sid-B")).toEqual({
+      sessionId: "sid-B",
+      cwd: "/b",
+    });
+    expect(await adapter.getSessionInfo("sid-C")).toBeUndefined();
+  });
+});

package/src/__tests__/fixtures/codex_simple_text.jsonl

@@ -0,0 +1,4 @@
+{"type":"thread.started","thread_id":"019e15c7-t001-7901-b92c-9a4371e07750"}
+{"type":"turn.started"}
+{"type":"item.completed","item":{"id":"item_0","type":"agent_message","text":"hello"}}
+{"type":"turn.completed","usage":{"input_tokens":12964,"cached_input_tokens":11136,"output_tokens":5,"reasoning_output_tokens":0}}

package/src/__tests__/fixtures/codex_with_tool.jsonl

@@ -0,0 +1,6 @@
+{"type":"thread.started","thread_id":"019e15c8-t002-7441-9bfb-eec7b1ef4c4c"}
+{"type":"turn.started"}
+{"type":"item.started","item":{"id":"item_0","type":"command_execution","command":"powershell.exe -Command echo tool_test","aggregated_output":"","exit_code":null,"status":"in_progress"}}
+{"type":"item.completed","item":{"id":"item_0","type":"command_execution","command":"powershell.exe -Command echo tool_test","aggregated_output":"tool_test\r\n","exit_code":0,"status":"completed"}}
+{"type":"item.completed","item":{"id":"item_1","type":"agent_message","text":"tool_test"}}
+{"type":"turn.completed","usage":{"input_tokens":26021,"cached_input_tokens":22272,"output_tokens":52,"reasoning_output_tokens":0}}