chatccc 0.2.180 → 0.2.181

package/README.md

@@ -144,12 +144,12 @@ npm install -g chatccc
 chatccc
 ```
 
-要求 Node.js >= 20。安装完成后，在任意目录执行 `chatccc` 即可启动。配置、日志和状态文件会保存在用户目录的 `.chatccc` 下：
-
-- Windows：`C:\Users\<用户名>\.chatccc\`
-- macOS / Linux：`~/.chatccc/`
-
-旧版本留在仓库或包目录下的 `config.json`、`logs/`、`state/` 会在首次启动时自动迁移到用户目录。
+要求 Node.js >= 20。安装完成后，在任意目录执行 `chatccc` 即可启动。配置、日志和状态文件会保存在用户目录的 `.chatccc` 下：
+
+- Windows：`C:\Users\<用户名>\.chatccc\`
+- macOS / Linux：`~/.chatccc/`
+
+旧版本留在仓库或包目录下的 `config.json`、`logs/`、`state/` 会在首次启动时自动迁移到用户目录。
 
 首次启动时，如果还没有有效配置，ChatCCC 会自动打开本地 Web 配置向导（默认 `http://127.0.0.1:18080`）。
 
@@ -202,7 +202,7 @@ chatccc
 # 在微信里找到机器人，发送 /new 开始对话
 ```
 
-微信登录信息会保存到 `~/.chatccc/state/ilink-auth.json`。token 过期后重新扫码即可。
+微信登录信息会保存到 `~/.chatccc/state/ilink-auth.json`。token 过期后重新扫码即可。
 
 ### 3. AI 工具配置
 
@@ -239,7 +239,7 @@ Codex 的默认模型和推理强度可继续由 `~/.codex/config.toml` 管理
 
 ### 4. `config.json`
 
-`~/.chatccc/config.json` 不存在时，ChatCCC 会从 `config.sample.json` 复制一份。常用结构如下：
+`~/.chatccc/config.json` 不存在时，ChatCCC 会从 `config.sample.json` 复制一份。常用结构如下：
 
 ```json
 {
@@ -247,32 +247,32 @@ Codex 的默认模型和推理强度可继续由 `~/.codex/config.toml` 管理
     "appId": "cli_xxxxxxxxxxxx",
     "appSecret": "xxxxxxxxxxxxxxxxxxxxxxxxxx"
   },
-  "platforms": {
-    "feishu": { "enabled": true, "platformType": "feishu" },
-    "ilink": { "enabled": true, "reuseTokenOnStart": true }
-  },
-  "port": 18080,
-  "gitTimeoutSeconds": 180,
-  "allowInterrupt": false,
-  "claude": {
-    "enabled": false,
-    "defaultAgent": true,
-    "model": "claude-sonnet-4-6",
-    "subagentModel": "",
-    "effort": "",
-    "apiKey": "",
-    "baseUrl": "",
-    "maxTurn": 0
-  },
-  "cursor": {
-    "enabled": false,
-    "defaultAgent": false,
-    "path": "",
-    "model": "",
-    "avatarBatteryMode": "apiPercent",
-    "onDemandMonthlyBudget": 1000
-  },
-  "codex": {
+  "platforms": {
+    "feishu": { "enabled": true, "platformType": "feishu" },
+    "ilink": { "enabled": true, "reuseTokenOnStart": true }
+  },
+  "port": 18080,
+  "gitTimeoutSeconds": 180,
+  "allowInterrupt": false,
+  "claude": {
+    "enabled": false,
+    "defaultAgent": true,
+    "model": "claude-sonnet-4-6",
+    "subagentModel": "",
+    "effort": "",
+    "apiKey": "",
+    "baseUrl": "",
+    "maxTurn": 0
+  },
+  "cursor": {
+    "enabled": false,
+    "defaultAgent": false,
+    "path": "",
+    "model": "",
+    "avatarBatteryMode": "apiPercent",
+    "onDemandMonthlyBudget": 1000
+  },
+  "codex": {
     "enabled": false,
     "defaultAgent": false,
     "path": "",
@@ -285,21 +285,21 @@ Codex 的默认模型和推理强度可继续由 `~/.codex/config.toml` 管理
 | 字段 | 说明 |
 | --- | --- |
 | `feishu.appId` / `feishu.appSecret` | 飞书应用凭证 |
-| `platforms.feishu.enabled` | 是否启用飞书 |
-| `platforms.feishu.platformType` | 飞书平台类型，默认 `feishu` |
-| `platforms.ilink.enabled` | 是否启用微信 iLink |
-| `platforms.ilink.reuseTokenOnStart` | 启动时是否复用已有微信登录 token |
-| `port` | 本地 Web 配置面板和中继服务端口 |
-| `gitTimeoutSeconds` | `/git` 命令超时时间，默认 180 秒 |
-| `allowInterrupt` | 是否允许新消息中断正在运行的任务；默认 false |
-| `*.enabled` | 是否启用对应 AI Agent |
-| `*.defaultAgent` | `/new` 未指定 Agent 时使用哪个工具 |
-| `cursor.path` / `codex.path` | CLI 可执行文件路径；留空时自动探测或使用 PATH |
-| `cursor.avatarBatteryMode` | Cursor 头像电量显示来源：`apiPercent` 或 `onDemandUse` |
-| `cursor.onDemandMonthlyBudget` | `avatarBatteryMode=onDemandUse` 时用于计算电量的月预算 |
-| `claude.model` / `claude.subagentModel` / `claude.effort` | 选填；设置后传给 Claude Agent SDK，留空以 `~/.claude/settings.json` 为准 |
-| `claude.apiKey` / `claude.baseUrl` | 选填；设置后传给 Claude Agent SDK，留空以 `~/.claude/settings.json` 为准 |
-| `claude.maxTurn` | 选填；Claude 最大对话轮数，默认 0（无限制），可在 Web UI 编辑 |
+| `platforms.feishu.enabled` | 是否启用飞书 |
+| `platforms.feishu.platformType` | 飞书平台类型，默认 `feishu` |
+| `platforms.ilink.enabled` | 是否启用微信 iLink |
+| `platforms.ilink.reuseTokenOnStart` | 启动时是否复用已有微信登录 token |
+| `port` | 本地 Web 配置面板和中继服务端口 |
+| `gitTimeoutSeconds` | `/git` 命令超时时间，默认 180 秒 |
+| `allowInterrupt` | 是否允许新消息中断正在运行的任务；默认 false |
+| `*.enabled` | 是否启用对应 AI Agent |
+| `*.defaultAgent` | `/new` 未指定 Agent 时使用哪个工具 |
+| `cursor.path` / `codex.path` | CLI 可执行文件路径；留空时自动探测或使用 PATH |
+| `cursor.avatarBatteryMode` | Cursor 头像电量显示来源：`apiPercent` 或 `onDemandUse` |
+| `cursor.onDemandMonthlyBudget` | `avatarBatteryMode=onDemandUse` 时用于计算电量的月预算 |
+| `claude.model` / `claude.subagentModel` / `claude.effort` | 选填；设置后传给 Claude Agent SDK，留空以 `~/.claude/settings.json` 为准 |
+| `claude.apiKey` / `claude.baseUrl` | 选填；设置后传给 Claude Agent SDK，留空以 `~/.claude/settings.json` 为准 |
+| `claude.maxTurn` | 选填；Claude 最大对话轮数，默认 0（无限制），可在 Web UI 编辑 |
 
 > **权限控制**：普通消息以 `bypassPermissions` 模式运行，跳过 Agent 操作确认。使用 `/plan` 或 `/ask` 前缀时，ChatCCC 自动切换为只读模式：Claude SDK 仅放行 Read + stop-stuck-loop 网络请求，Codex 使用 `--sandbox read-only`，Cursor 使用 `--mode plan/ask`。请只在可信环境中使用。
 
@@ -315,26 +315,26 @@ Codex 的默认模型和推理强度可继续由 `~/.codex/config.toml` 管理
 | --- | --- |
 | `/new` | 使用默认 Agent 创建新会话 |
 | `/new claude` | 创建 Claude Code 会话 |
-| `/new cursor` | 创建 Cursor 会话 |
-| `/new codex` | 创建 Codex 会话 |
-| `/newh` | 重置当前会话，保留工作目录 |
-| `/model` | 查看或切换当前会话的模型 |
-| `/stop` | 停止当前回复 |
-| `/cancel` | 取消当前会话里排队等待处理的消息 |
-| `/state` | 查看当前会话状态 |
-| `/cd` | 查看或设置当前会话工作目录 |
-| `/sessions` | 查看所有会话状态 |
-| `/session <数字>` | 将当前群聊切换到 `/sessions` 列表中的指定会话 |
-| `/usage` | 查看当前会话对应 Agent 的用量；Codex 显示 5h/周用量，Cursor 显示当前周期用量 |
-| `/git <子命令>` | 在当前会话工作目录执行 `git ...` 并回传输出 |
-| `/abd<内容>` | 去掉 `/abd` 前缀后把内容发给 Agent，并在消息末尾追加第一性原理需求澄清提示 |
-| `/plan <内容>` | 只读计划模式：仅允许读文件和 stop-stuck-loop 请求，不执行任何写操作 |
-| `/ask <内容>` | 只读问答模式：与 /plan 相同，仅允许读文件和 stop-stuck-loop 请求 |
-| `/restart` | 重启机器人进程 |
-| `/update` | 更新 npm 全局包并重启（仅限 `npm install -g chatccc` 安装的全局进程） |
-| `/deleteg` | 解散当前飞书会话群；Agent 会话记录保留 |
-
-> **模型切换**：`/model` 查看当前会话 Agent 的可选模型清单，`/model <名称>` 模糊匹配切换，`/model clear` 恢复默认。可选模型来自当前 Agent 的配置：Claude 使用 `claude.model` / `claude.subagentModel`，Cursor 使用 `cursor.model`，Codex 使用 `codex.model`。
+| `/new cursor` | 创建 Cursor 会话 |
+| `/new codex` | 创建 Codex 会话 |
+| `/newh` | 重置当前会话，保留工作目录 |
+| `/model` | 查看或切换当前会话的模型 |
+| `/stop` | 停止当前回复 |
+| `/cancel` | 取消当前会话里排队等待处理的消息 |
+| `/state` | 查看当前会话状态 |
+| `/cd` | 查看或设置当前会话工作目录 |
+| `/sessions` | 查看所有会话状态 |
+| `/session <数字>` | 将当前群聊切换到 `/sessions` 列表中的指定会话 |
+| `/usage` | 查看当前会话对应 Agent 的用量；Codex 显示 5h/周用量，Cursor 显示当前周期用量 |
+| `/git <子命令>` | 在当前会话工作目录执行 `git ...` 并回传输出 |
+| `/abd<内容>` | 去掉 `/abd` 前缀后把内容发给 Agent，并在消息末尾追加第一性原理需求澄清提示 |
+| `/plan <内容>` | 只读计划模式：仅允许读文件和 stop-stuck-loop 请求，不执行任何写操作 |
+| `/ask <内容>` | 只读问答模式：与 /plan 相同，仅允许读文件和 stop-stuck-loop 请求 |
+| `/restart` | 重启机器人进程 |
+| `/update` | 更新 npm 全局包并重启（仅限 `npm install -g chatccc` 安装的全局进程） |
+| `/deleteg` | 解散当前飞书会话群；Agent 会话记录保留 |
+
+> **模型切换**：`/model` 查看当前会话 Agent 的可选模型清单，`/model <名称>` 模糊匹配切换，`/model clear` 恢复默认。可选模型来自当前 Agent 的配置：Claude 使用 `claude.model` / `claude.subagentModel`，Cursor 使用 `cursor.model`，Codex 使用 `codex.model`。
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "chatccc",
-  "version": "0.2.180",
+  "version": "0.2.181",
   "description": "Feishu bot bridge for Claude Code",
   "license": "Apache-2.0",
   "type": "module",

package/src/__tests__/card-plain-text.test.ts

@@ -16,11 +16,11 @@ describe("cardJsonToPlainText", () => {
     expect(text).toContain("/new");
     expect(text).toContain("/new cursor");
     expect(text).toContain("/new codex");
-    expect(text).toContain("/restart");
-    expect(text).toContain("/update");
-    expect(text).toContain("/cd");
-    expect(text).toContain("/abd");
-  });
+    expect(text).toContain("/restart");
+    expect(text).toContain("/update");
+    expect(text).toContain("/cd");
+    expect(text).toContain("/abd");
+  });
 
   it("converts status cards from v1 card format", () => {
     const text = cardJsonToPlainText(buildStatusCard("status body", "green"));

package/src/__tests__/cards.test.ts

@@ -1,16 +1,18 @@
 import { describe, it, expect } from "vitest";
-import {
-  buildProgressCard,
-  buildHelpCard,
+import {
+  buildProgressCard,
+  buildHelpCard,
   buildCdContent,
   buildCdCard,
   buildSessionsCard,
   buildStatusCard,
+  buildCodexUsageCard,
+  buildCodexResetConfirmCard,
   buildButtons,
   truncateContent,
-  getToolEmoji,
-} from "../cards.ts";
-import { ABD_HELP_LINE } from "../shared-prefix.ts";
+  getToolEmoji,
+} from "../cards.ts";
+import { ABD_HELP_LINE } from "../shared-prefix.ts";
 
 // ---------------------------------------------------------------------------
 // truncateContent
@@ -152,22 +154,23 @@ describe("buildHelpCard", () => {
     expect(parsed.elements[0].text.content).toContain("你好");
   });
 
-  it("includes action buttons", () => {
-    const card = buildHelpCard("test");
-    const parsed = JSON.parse(card);
-    const action = parsed.elements[2];
-    expect(action.tag).toBe("action");
-    expect(action.actions).toHaveLength(7);
-  });
-
-  it("adds ABD prefix help as the final help line", () => {
-    const card = buildHelpCard("test");
-    const parsed = JSON.parse(card);
-    const lines = parsed.elements[1].text.content.split("\n");
-
-    expect(lines.at(-1)).toBe(ABD_HELP_LINE);
-  });
-});
+  it("includes action buttons", () => {
+    const card = buildHelpCard("test");
+    const parsed = JSON.parse(card);
+    const action = parsed.elements[2];
+    expect(action.tag).toBe("action");
+    expect(action.actions).toHaveLength(7);
+  });
+
+  it("adds ABD prefix help as the final help line", () => {
+    const card = buildHelpCard("test");
+    const parsed = JSON.parse(card);
+    const lines = parsed.elements[1].text.content.split("\n");
+
+    expect(lines).toContain("发送 **/usage** 查看 Codex 5h/周用量，以及查询/使用主动重置卡");
+    expect(lines.at(-1)).toBe(ABD_HELP_LINE);
+  });
+});
 
 // ---------------------------------------------------------------------------
 // buildCdContent
@@ -444,6 +447,49 @@ describe("buildStatusCard", () => {
   });
 });
 
+// ---------------------------------------------------------------------------
+// buildCodexUsageCard / buildCodexResetConfirmCard
+// ---------------------------------------------------------------------------
+
+describe("Codex usage reset cards", () => {
+  it("shows the reset button only when reset credits are available", () => {
+    const card = buildCodexUsageCard("Codex 用量", 2);
+    const parsed = JSON.parse(card);
+    const action = parsed.elements.find((element: any) => element.tag === "action");
+    expect(action.actions[0].text.content).toBe("发起重置");
+    expect(action.actions[0].value).toEqual({ action: "codex_reset_request", availableCount: 2 });
+
+    const noCreditCard = buildCodexUsageCard("Codex 用量", 0);
+    const noCreditParsed = JSON.parse(noCreditCard);
+    expect(noCreditParsed.elements.some((element: any) => element.tag === "action")).toBe(false);
+  });
+
+  it("builds yes/no confirmation buttons tied to the parent usage card", () => {
+    const card = buildCodexResetConfirmCard({
+      availableCount: 2,
+      parentMessageId: "usage-message",
+      requestId: "request-1",
+    });
+    const parsed = JSON.parse(card);
+    const action = parsed.elements.find((element: any) => element.tag === "action");
+
+    expect(action.actions[0].text.content).toBe("是，发起重置");
+    expect(action.actions[0].value).toEqual({
+      action: "codex_reset_confirm",
+      decision: "yes",
+      parentMessageId: "usage-message",
+      requestId: "request-1",
+    });
+    expect(action.actions[1].text.content).toBe("否");
+    expect(action.actions[1].value).toEqual({
+      action: "codex_reset_confirm",
+      decision: "no",
+      parentMessageId: "usage-message",
+      requestId: "request-1",
+    });
+  });
+});
+
 // ---------------------------------------------------------------------------
 // buildButtons
 // ---------------------------------------------------------------------------

package/src/__tests__/codex-reset-actions.test.ts

@@ -0,0 +1,113 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import {
+  _resetCodexResetRequestsForTest,
+  handleCodexResetCardAction,
+  type CodexResetActionDeps,
+} from "../codex-reset-actions.ts";
+
+function deps(): CodexResetActionDeps & {
+  getTenantAccessToken: ReturnType<typeof vi.fn>;
+  sendRawCard: ReturnType<typeof vi.fn>;
+  sendCardReply: ReturnType<typeof vi.fn>;
+  updateCardMessage: ReturnType<typeof vi.fn>;
+  consumeCodexRateLimitResetCredit: ReturnType<typeof vi.fn>;
+  createRequestId: ReturnType<typeof vi.fn>;
+} {
+  return {
+    getTenantAccessToken: vi.fn(async () => "tenant-token"),
+    sendRawCard: vi.fn(async () => true),
+    sendCardReply: vi.fn(async () => true),
+    updateCardMessage: vi.fn(async () => true),
+    consumeCodexRateLimitResetCredit: vi.fn(async () => ({ code: "reset" as const, windowsReset: 2 })),
+    createRequestId: vi.fn(() => "request-1"),
+  };
+}
+
+function event(value: Record<string, unknown>, messageId: string) {
+  return {
+    event: {
+      open_message_id: messageId,
+      open_chat_id: "chat-1",
+      operator: { open_id: "ou-user" },
+      action: { value },
+    },
+  };
+}
+
+describe("Codex reset card actions", () => {
+  beforeEach(() => {
+    _resetCodexResetRequestsForTest();
+  });
+
+  it("sends a confirmation card tied to the clicked usage card", async () => {
+    const d = deps();
+
+    await expect(handleCodexResetCardAction(
+      event({ action: "codex_reset_request" }, "usage-message"),
+      d,
+    )).resolves.toBe(true);
+
+    expect(d.sendRawCard).toHaveBeenCalledTimes(1);
+    expect(d.sendRawCard.mock.calls[0][1]).toBe("chat-1");
+    const confirmCard = JSON.parse(d.sendRawCard.mock.calls[0][2]);
+    const action = confirmCard.elements.find((element: any) => element.tag === "action");
+    expect(action.actions[0].value).toEqual({
+      action: "codex_reset_confirm",
+      decision: "yes",
+      parentMessageId: "usage-message",
+      requestId: "request-1",
+    });
+  });
+
+  it("consumes a reset credit, sends the result, and collapses the confirmation card when user confirms", async () => {
+    const d = deps();
+    await handleCodexResetCardAction(event({ action: "codex_reset_request" }, "usage-message"), d);
+
+    await expect(handleCodexResetCardAction(
+      event({
+        action: "codex_reset_confirm",
+        decision: "yes",
+        parentMessageId: "usage-message",
+        requestId: "request-1",
+      }, "confirm-message"),
+      d,
+    )).resolves.toBe(true);
+
+    expect(d.consumeCodexRateLimitResetCredit).toHaveBeenCalledWith("request-1");
+    expect(d.updateCardMessage).toHaveBeenCalledTimes(1);
+    expect(d.updateCardMessage.mock.calls[0][1]).toBe("confirm-message");
+    expect(d.sendCardReply).toHaveBeenCalledWith(
+      "tenant-token",
+      "chat-1",
+      "Codex 主动重置",
+      expect.stringContaining("重置成功"),
+      "green",
+    );
+  });
+
+  it("does not consume a reset credit and sends a cancellation message when user declines", async () => {
+    const d = deps();
+    await handleCodexResetCardAction(event({ action: "codex_reset_request" }, "usage-message"), d);
+
+    await expect(handleCodexResetCardAction(
+      event({
+        action: "codex_reset_confirm",
+        decision: "no",
+        parentMessageId: "usage-message",
+        requestId: "request-1",
+      }, "confirm-message"),
+      d,
+    )).resolves.toBe(true);
+
+    expect(d.consumeCodexRateLimitResetCredit).not.toHaveBeenCalled();
+    expect(d.updateCardMessage).toHaveBeenCalledTimes(1);
+    expect(d.sendCardReply).toHaveBeenCalledWith(
+      "tenant-token",
+      "chat-1",
+      "Codex 主动重置",
+      "用户取消了重置。",
+      "grey",
+    );
+  });
+});

package/src/__tests__/feishu-avatar.test.ts

@@ -41,7 +41,7 @@ async function writeCodexAuth(homeDir: string): Promise<void> {
   await mkdir(codexDir, { recursive: true });
   await writeFile(
     join(codexDir, "auth.json"),
-    JSON.stringify({ tokens: { access_token: "codex-access-token" } }),
+    JSON.stringify({ tokens: { access_token: "codex-access-token", account_id: "codex-account-id" } }),
     "utf-8",
   );
 }
@@ -52,6 +52,9 @@ function mockAvatarFetch(uploadedNames: string[], usageResponse: Response): void
     if (urlText === "https://chatgpt.com/backend-api/wham/usage") {
       return usageResponse.clone();
     }
+    if (urlText === "https://chatgpt.com/backend-api/wham/rate-limit-reset-credits") {
+      return new Response(JSON.stringify({ credits: [] }), { status: 200 });
+    }
     if (urlText === "https://open.feishu.test/im/v1/images") {
       const form = init?.body as FormData;
       const image = form.get("image") as File;
@@ -100,24 +103,102 @@ describe("Codex avatar usage battery", () => {
     }
   });
 
-  it("returns both 5h and weekly Codex usage windows", async () => {
+  it("returns both usage windows and available reset credit expiries", async () => {
     const homeDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-home-"));
     const userDataDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-data-"));
-    const uploadedNames: string[] = [];
     await writeCodexAuth(homeDir);
-    mockAvatarFetch(uploadedNames, new Response(JSON.stringify({
-      rate_limit: {
-        primary_window: { used_percent: 37, reset_after_seconds: 10349, reset_at: 1781528212 },
-        secondary_window: { used_percent: 12, reset_after_seconds: 325063, reset_at: 1781842926 },
-      },
-    }), { status: 200 }));
+    const fetchMock = vi.fn(async (url: string | URL | Request) => {
+      const urlText = String(url);
+      if (urlText === "https://chatgpt.com/backend-api/wham/usage") {
+        return new Response(JSON.stringify({
+          rate_limit: {
+            primary_window: { used_percent: 37, reset_after_seconds: 10349, reset_at: 1781528212 },
+            secondary_window: { used_percent: 12, reset_after_seconds: 325063, reset_at: 1781842926 },
+          },
+          rate_limit_reset_credits: { available_count: 1 },
+        }), { status: 200 });
+      }
+      if (urlText === "https://chatgpt.com/backend-api/wham/rate-limit-reset-credits") {
+        return new Response(JSON.stringify({
+          available_count: 2,
+          credits: [
+            {
+              status: "available",
+              granted_at: "2026-06-12T04:01:47.770016Z",
+              expires_at: "2026-07-12T04:01:47.770016Z",
+            },
+            {
+              status: "redeemed",
+              granted_at: "2026-06-13T04:01:47.770016Z",
+              expires_at: "2026-07-13T04:01:47.770016Z",
+            },
+            {
+              status: "available",
+              granted_at: "2026-06-18T00:44:23.904386Z",
+              expires_at: "2026-07-18T00:44:23.904386Z",
+            },
+          ],
+        }), { status: 200 });
+      }
+      throw new Error(`unexpected fetch: ${urlText}`);
+    });
+    vi.stubGlobal("fetch", fetchMock);
 
     try {
       const { getCodexUsageSummary } = await loadFeishuApiWithHome(homeDir, userDataDir);
       await expect(getCodexUsageSummary()).resolves.toEqual({
         fiveHour: { usedPercent: 37, remainingPercent: 63, resetAfterSeconds: 10349, resetAtEpochSeconds: 1781528212 },
         weekly: { usedPercent: 12, remainingPercent: 88, resetAfterSeconds: 325063, resetAtEpochSeconds: 1781842926 },
+        rateLimitResetCreditsAvailable: 2,
+        rateLimitResetCredits: [
+          { grantedAt: "2026-06-12T04:01:47.770016Z", expiresAt: "2026-07-12T04:01:47.770016Z" },
+          { grantedAt: "2026-06-18T00:44:23.904386Z", expiresAt: "2026-07-18T00:44:23.904386Z" },
+        ],
+      });
+      expect(fetchMock).toHaveBeenCalledWith(
+        "https://chatgpt.com/backend-api/wham/rate-limit-reset-credits",
+        expect.objectContaining({
+          headers: expect.objectContaining({
+            Authorization: "Bearer codex-access-token",
+            "ChatGPT-Account-ID": "codex-account-id",
+            "OpenAI-Beta": "codex-1",
+            originator: "Codex Desktop",
+          }),
+        }),
+      );
+    } finally {
+      await rm(homeDir, { recursive: true, force: true });
+      await rm(userDataDir, { recursive: true, force: true });
+    }
+  });
+
+  it("consumes a Codex rate-limit reset credit through the WHAM endpoint", async () => {
+    const homeDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-home-"));
+    const userDataDir = await mkdtemp(join(tmpdir(), "chatccc-avatar-data-"));
+    await writeCodexAuth(homeDir);
+    const fetchMock = vi.fn(async () => new Response(JSON.stringify({
+      code: "reset",
+      windows_reset: 2,
+    }), { status: 200 }));
+    vi.stubGlobal("fetch", fetchMock);
+
+    try {
+      const { consumeCodexRateLimitResetCredit } = await loadFeishuApiWithHome(homeDir, userDataDir);
+      await expect(consumeCodexRateLimitResetCredit("request-1")).resolves.toEqual({
+        code: "reset",
+        windowsReset: 2,
       });
+      expect(fetchMock).toHaveBeenCalledWith(
+        "https://chatgpt.com/backend-api/wham/rate-limit-reset-credits/consume",
+        expect.objectContaining({
+          method: "POST",
+          headers: expect.objectContaining({
+            Authorization: "Bearer codex-access-token",
+            "Content-Type": "application/json",
+          }),
+          body: JSON.stringify({ redeem_request_id: "request-1" }),
+        }),
+      );
     } finally {
       await rm(homeDir, { recursive: true, force: true });
       await rm(userDataDir, { recursive: true, force: true });

package/src/__tests__/feishu-platform.test.ts

@@ -1,5 +1,5 @@
 import { describe, it, expect, beforeAll, afterAll } from "vitest";
-import { getPlatform, setPlatform, getTenantAccessToken, getChatInfo, createGroupChat, updateChatInfo, sendTextReply, sendCardReply, sendRawCard, sendPostMessage, extractSessionInfo, formatDelayNotice, reportPermissionResults, verifyAllPermissions, addReaction, recallMessage, updateCardMessage, setChatAvatar, getCodexUsageSummary, disbandChat, sendRestartCard, getMergeForwardMessages } from "../feishu-platform.ts";
+import { getPlatform, setPlatform, getTenantAccessToken, getChatInfo, createGroupChat, updateChatInfo, sendTextReply, sendCardReply, sendRawCard, sendPostMessage, extractSessionInfo, formatDelayNotice, reportPermissionResults, verifyAllPermissions, addReaction, recallMessage, updateCardMessage, setChatAvatar, getCodexUsageSummary, consumeCodexRateLimitResetCredit, disbandChat, sendRestartCard, getMergeForwardMessages } from "../feishu-platform.ts";
 import type { FeishuPlatform } from "../feishu-platform.ts";
 
 const realPlatform = getPlatform();
@@ -26,13 +26,16 @@ describe("feishu-platform", () => {
       createGroupChat: async () => "mock_chat",
       updateChatInfo: async () => {},
       getChatInfo: async () => ({ name: "x", description: "y" }),
-      disbandChat: async () => {},
-      setChatAvatar: async () => {},
-      getCodexUsageSummary: async () => ({
-        fiveHour: { usedPercent: 10, remainingPercent: 90, resetAtEpochSeconds: 1781528212, resetAfterSeconds: 10349 },
-        weekly: { usedPercent: 20, remainingPercent: 80, resetAtEpochSeconds: 1781842926, resetAfterSeconds: 325063 },
-      }),
-      getOrDownloadImage: async () => "/tmp/img.png",
+      disbandChat: async () => {},
+      setChatAvatar: async () => {},
+      getCodexUsageSummary: async () => ({
+        fiveHour: { usedPercent: 10, remainingPercent: 90, resetAtEpochSeconds: 1781528212, resetAfterSeconds: 10349 },
+        weekly: { usedPercent: 20, remainingPercent: 80, resetAtEpochSeconds: 1781842926, resetAfterSeconds: 325063 },
+        rateLimitResetCreditsAvailable: 1,
+        rateLimitResetCredits: [{ grantedAt: null, expiresAt: "2026-07-12T04:01:47.770016Z" }],
+      }),
+      consumeCodexRateLimitResetCredit: async () => ({ code: "reset", windowsReset: 2 }),
+      getOrDownloadImage: async () => "/tmp/img.png",
       verifyAllPermissions: async () => [],
       reportPermissionResults: realPlatform.reportPermissionResults,
       extractSessionInfo: realPlatform.extractSessionInfo,
@@ -50,13 +53,16 @@ describe("feishu-platform", () => {
       expect(await getChatInfo("t", "mock_chat")).toEqual({ name: "x", description: "y" });
       const perms = await verifyAllPermissions("t");
       expect(perms).toEqual([]);
-      const mergeMsgs = await getMergeForwardMessages("t", "om_test");
-      expect(mergeMsgs).toEqual([]);
-      expect(await getCodexUsageSummary()).toEqual({
-        fiveHour: { usedPercent: 10, remainingPercent: 90, resetAtEpochSeconds: 1781528212, resetAfterSeconds: 10349 },
-        weekly: { usedPercent: 20, remainingPercent: 80, resetAtEpochSeconds: 1781842926, resetAfterSeconds: 325063 },
-      });
-    } finally {
+      const mergeMsgs = await getMergeForwardMessages("t", "om_test");
+      expect(mergeMsgs).toEqual([]);
+      expect(await getCodexUsageSummary()).toEqual({
+        fiveHour: { usedPercent: 10, remainingPercent: 90, resetAtEpochSeconds: 1781528212, resetAfterSeconds: 10349 },
+        weekly: { usedPercent: 20, remainingPercent: 80, resetAtEpochSeconds: 1781842926, resetAfterSeconds: 325063 },
+        rateLimitResetCreditsAvailable: 1,
+        rateLimitResetCredits: [{ grantedAt: null, expiresAt: "2026-07-12T04:01:47.770016Z" }],
+      });
+      expect(await consumeCodexRateLimitResetCredit("request-1")).toEqual({ code: "reset", windowsReset: 2 });
+    } finally {
       // 恢复到真实实现，避免影响后续测试
       setPlatform(realPlatform);
     }
@@ -66,4 +72,4 @@ describe("feishu-platform", () => {
     setPlatform(realPlatform);
     expect(getPlatform()).toBe(realPlatform);
   });
-});
+});