chatccc 0.2.181 → 0.2.183

package/src/__tests__/orchestrator.test.ts

@@ -65,8 +65,8 @@ vi.mock("../cursor-usage.ts", () => ({
 }));
 
 import { handleCommand } from "../orchestrator.ts";
-import {
-  _clearAdapterCacheForTest,
+import {
+  _clearAdapterCacheForTest,
   _resetSessionRegistryFileForTest,
   _resetSessionToolsFileForTest,
   _setAdapterForToolForTest,
@@ -74,10 +74,10 @@ import {
   _setSessionToolsFileForTest,
   loadSessionRegistryForBinding,
   recordSessionRegistry,
-  resetState,
-} from "../session.ts";
-import { activePrompts, resetBindingState } from "../session-chat-binding.ts";
-import { ABD_APPEND_PROMPT } from "../shared-prefix.ts";
+  resetState,
+} from "../session.ts";
+import { activePrompts, resetBindingState } from "../session-chat-binding.ts";
+import { ABD_APPEND_PROMPT } from "../shared-prefix.ts";
 
 function mockPlatform(kind: "wechat" | "feishu" = "wechat"): PlatformAdapter {
   return {
@@ -129,12 +129,12 @@ describe("handleCommand WeChat processing ack", () => {
     mockStreamStates.clear();
     mockGetCodexUsageSummary.mockReset();
     mockGetCursorUsageSummary.mockReset();
-    mockGetCodexUsageSummary.mockResolvedValue({
-      fiveHour: { usedPercent: 0, remainingPercent: 100, resetAtEpochSeconds: null, resetAfterSeconds: null },
-      weekly: { usedPercent: 0, remainingPercent: 100, resetAtEpochSeconds: null, resetAfterSeconds: null },
-      rateLimitResetCreditsAvailable: null,
-      rateLimitResetCredits: null,
-    });
+    mockGetCodexUsageSummary.mockResolvedValue({
+      fiveHour: { usedPercent: 0, remainingPercent: 100, resetAtEpochSeconds: null, resetAfterSeconds: null },
+      weekly: { usedPercent: 0, remainingPercent: 100, resetAtEpochSeconds: null, resetAfterSeconds: null },
+      rateLimitResetCreditsAvailable: null,
+      rateLimitResetCredits: null,
+    });
     mockGetCursorUsageSummary.mockResolvedValue({
       billingCycleStart: "1779357999000",
       billingCycleEnd: "1782036399000",
@@ -200,8 +200,8 @@ describe("handleCommand WeChat processing ack", () => {
     expect(platform.sendCard).not.toHaveBeenCalled();
   });
 
-  it("sends the WeChat processing ack after the busy check for normal prompts", async () => {
-    const platform = mockPlatform();
+  it("sends the WeChat processing ack after the busy check for normal prompts", async () => {
+    const platform = mockPlatform();
     await recordSessionRegistry({
       chatId: "wx-chat",
       sessionId: "sid-wechat",
@@ -211,44 +211,44 @@ describe("handleCommand WeChat processing ack", () => {
     });
 
     await handleCommand(platform, "继续说明", "wx-chat", "wx-user", Date.now(), "p2p");
-
-    expect(platform.sendText).toHaveBeenCalledWith("wx-chat", "生成中...");
-  });
-
-  it("treats /abd as a shared prompt prefix in an existing session", async () => {
-    const platform = mockPlatform();
-    const prompt = vi.fn(async function* (_sessionId: string, userText: string) {
-      yield {
-        type: "assistant" as const,
-        blocks: [{ type: "text" as const, text: "done" }],
-      };
-    });
-    _setAdapterForToolForTest("claude", {
-      displayName: "Claude",
-      sessionDescPrefix: "Claude Session:",
-      createSession: vi.fn(async () => ({ sessionId: "sid-wechat" })),
-      prompt,
-      getSessionInfo: async (sessionId: string): Promise<SessionInfo> => ({
-        sessionId,
-        cwd: "F:\\repo",
-      }),
-      closeSession: async () => {},
-    });
-    await recordSessionRegistry({
-      chatId: "wx-chat",
-      sessionId: "sid-wechat",
-      tool: "claude",
-      chatName: "ready-session",
-      running: false,
-    });
-
-    await handleCommand(platform, "/abd帮我分析", "wx-chat", "wx-user", Date.now(), "p2p");
-
-    expect(platform.sendText).toHaveBeenCalledWith("wx-chat", "生成中...");
-    const userText = prompt.mock.calls[0][1];
-    expect(userText).toContain(`[User message]\n帮我分析\n\n---\n${ABD_APPEND_PROMPT}\n[/User message]`);
-    expect(userText).not.toContain("/abd");
-  });
+
+    expect(platform.sendText).toHaveBeenCalledWith("wx-chat", "生成中...");
+  });
+
+  it("treats /abd as a shared prompt prefix in an existing session", async () => {
+    const platform = mockPlatform();
+    const prompt = vi.fn(async function* (_sessionId: string, userText: string) {
+      yield {
+        type: "assistant" as const,
+        blocks: [{ type: "text" as const, text: "done" }],
+      };
+    });
+    _setAdapterForToolForTest("claude", {
+      displayName: "Claude",
+      sessionDescPrefix: "Claude Session:",
+      createSession: vi.fn(async () => ({ sessionId: "sid-wechat" })),
+      prompt,
+      getSessionInfo: async (sessionId: string): Promise<SessionInfo> => ({
+        sessionId,
+        cwd: "F:\\repo",
+      }),
+      closeSession: async () => {},
+    });
+    await recordSessionRegistry({
+      chatId: "wx-chat",
+      sessionId: "sid-wechat",
+      tool: "claude",
+      chatName: "ready-session",
+      running: false,
+    });
+
+    await handleCommand(platform, "/abd帮我分析", "wx-chat", "wx-user", Date.now(), "p2p");
+
+    expect(platform.sendText).toHaveBeenCalledWith("wx-chat", "生成中...");
+    const userText = prompt.mock.calls[0][1];
+    expect(userText).toContain(`[User message]\n帮我分析\n\n---\n${ABD_APPEND_PROMPT}\n[/User message]`);
+    expect(userText).not.toContain("/abd");
+  });
 
   it("does not send the stopped success text until the running prompt really exits", async () => {
     const platform = mockPlatform();
@@ -270,7 +270,7 @@ describe("handleCommand WeChat processing ack", () => {
     expect(platform.sendText).not.toHaveBeenCalledWith("wx-chat", "会话已停止。");
   });
 
-  it("cleans stale Feishu p2p binding, creates a group, and sends the private message as first prompt", async () => {
+  it("cleans stale Feishu p2p binding, creates a group, and sends the private message as first prompt", async () => {
     const platform = mockPlatform("feishu");
     const prompt = vi.fn(async function* (_sessionId: string, userText: string) {
       yield {
@@ -315,40 +315,40 @@ describe("handleCommand WeChat processing ack", () => {
 
     const registry = await loadSessionRegistryForBinding();
     expect(registry["feishu-p2p"]).toBeUndefined();
-    expect(registry["feishu-group"]?.sessionId).toBe("sid-feishu-new");
-  });
-
-  it("auto-creates a Feishu group for /abd private messages and sends the transformed prompt", async () => {
-    const platform = mockPlatform("feishu");
-    const prompt = vi.fn(async function* (_sessionId: string, userText: string) {
-      yield {
-        type: "assistant" as const,
-        blocks: [{ type: "text" as const, text: "done" }],
-      };
-    });
-    _setAdapterForToolForTest("claude", {
-      displayName: "Claude",
-      sessionDescPrefix: "Claude Session:",
-      createSession: vi.fn(async () => ({ sessionId: "sid-feishu-abd" })),
-      prompt,
-      getSessionInfo: async (sessionId: string): Promise<SessionInfo> => ({
-        sessionId,
-        cwd: "F:\\repo",
-      }),
-      closeSession: async () => {},
-    });
-
-    await handleCommand(platform, "/abd帮我看一下日志", "feishu-p2p", "ou-user", Date.now(), "p2p");
-
-    expect(platform.createGroup).toHaveBeenCalledWith(expect.stringContaining("帮我看一下日志"), ["ou-user"]);
-    expect(platform.createGroup).not.toHaveBeenCalledWith(expect.stringContaining("---"), expect.anything());
-    const updateCall = vi.mocked(platform.updateChatInfo).mock.calls[0];
-    expect(updateCall[1]).not.toContain("---");
-    expect(updateCall[1]).not.toContain(ABD_APPEND_PROMPT);
-    const userText = prompt.mock.calls[0][1];
-    expect(userText).toContain(`[User message]\n帮我看一下日志\n\n---\n${ABD_APPEND_PROMPT}\n[/User message]`);
-    expect(userText).not.toContain("/abd");
-  });
+    expect(registry["feishu-group"]?.sessionId).toBe("sid-feishu-new");
+  });
+
+  it("auto-creates a Feishu group for /abd private messages and sends the transformed prompt", async () => {
+    const platform = mockPlatform("feishu");
+    const prompt = vi.fn(async function* (_sessionId: string, userText: string) {
+      yield {
+        type: "assistant" as const,
+        blocks: [{ type: "text" as const, text: "done" }],
+      };
+    });
+    _setAdapterForToolForTest("claude", {
+      displayName: "Claude",
+      sessionDescPrefix: "Claude Session:",
+      createSession: vi.fn(async () => ({ sessionId: "sid-feishu-abd" })),
+      prompt,
+      getSessionInfo: async (sessionId: string): Promise<SessionInfo> => ({
+        sessionId,
+        cwd: "F:\\repo",
+      }),
+      closeSession: async () => {},
+    });
+
+    await handleCommand(platform, "/abd帮我看一下日志", "feishu-p2p", "ou-user", Date.now(), "p2p");
+
+    expect(platform.createGroup).toHaveBeenCalledWith(expect.stringContaining("帮我看一下日志"), ["ou-user"]);
+    expect(platform.createGroup).not.toHaveBeenCalledWith(expect.stringContaining("---"), expect.anything());
+    const updateCall = vi.mocked(platform.updateChatInfo).mock.calls[0];
+    expect(updateCall[1]).not.toContain("---");
+    expect(updateCall[1]).not.toContain(ABD_APPEND_PROMPT);
+    const userText = prompt.mock.calls[0][1];
+    expect(userText).toContain(`[User message]\n帮我看一下日志\n\n---\n${ABD_APPEND_PROMPT}\n[/User message]`);
+    expect(userText).not.toContain("/abd");
+  });
 
   it("cleans stale Feishu p2p binding but keeps valid commands from auto-creating a group", async () => {
     const platform = mockPlatform("feishu");
@@ -370,35 +370,35 @@ describe("handleCommand WeChat processing ack", () => {
 
   it("handles /usage without creating a new Feishu group", async () => {
     const platform = mockPlatform("feishu");
-    mockGetCodexUsageSummary.mockResolvedValue({
-      fiveHour: { usedPercent: 37, remainingPercent: 63, resetAtEpochSeconds: 1781528212, resetAfterSeconds: 10349 },
-      weekly: { usedPercent: 12, remainingPercent: 88, resetAtEpochSeconds: 1781842926, resetAfterSeconds: 325063 },
-      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" },
-      ],
-    });
-
-    await handleCommand(platform, "/usage", "feishu-p2p", "ou-user", Date.now(), "p2p");
-
-    expect(platform.createGroup).not.toHaveBeenCalled();
-    expect(platform.sendCard).not.toHaveBeenCalled();
-    expect(platform.sendRawCard).toHaveBeenCalledTimes(1);
-    const card = JSON.parse(vi.mocked(platform.sendRawCard).mock.calls[0][1]);
-    expect(card.header.title.content).toBe("Codex Usage");
-    expect(card.elements[0].text.content).toContain("2026-07-12");
-    expect(card.elements[0].text.content).toContain("2026-07-18");
-    expect(card.elements[0].text.content).toContain("**主动重置:** 剩余 2 次");
-    expect(card.elements[0].text.content).toContain("**5h:** 已用 37%，剩余 63%，重置:");
-    expect(card.elements[0].text.content).toContain("约 2小时52分钟后");
-    expect(card.elements[0].text.content).toContain("[███████░░░░░░░░░░░░░]");
-    expect(card.elements[0].text.content).toContain("**周:** 已用 12%，剩余 88%，重置:");
-    expect(card.elements[0].text.content).toContain("约 3天18小时17分钟后");
-    expect(card.elements[0].text.content).toContain("[██░░░░░░░░░░░░░░░░░░]");
-    expect(card.elements[2].actions[0].text.content).toBe("发起重置");
-    expect(card.elements[2].actions[0].value).toEqual({ action: "codex_reset_request", availableCount: 2 });
-  });
+    mockGetCodexUsageSummary.mockResolvedValue({
+      fiveHour: { usedPercent: 37, remainingPercent: 63, resetAtEpochSeconds: 1781528212, resetAfterSeconds: 10349 },
+      weekly: { usedPercent: 12, remainingPercent: 88, resetAtEpochSeconds: 1781842926, resetAfterSeconds: 325063 },
+      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" },
+      ],
+    });
+
+    await handleCommand(platform, "/usage", "feishu-p2p", "ou-user", Date.now(), "p2p");
+
+    expect(platform.createGroup).not.toHaveBeenCalled();
+    expect(platform.sendCard).not.toHaveBeenCalled();
+    expect(platform.sendRawCard).toHaveBeenCalledTimes(1);
+    const card = JSON.parse(vi.mocked(platform.sendRawCard).mock.calls[0][1]);
+    expect(card.header.title.content).toBe("Codex Usage");
+    expect(card.elements[0].text.content).toContain("2026-07-12");
+    expect(card.elements[0].text.content).toContain("2026-07-18");
+    expect(card.elements[0].text.content).toContain("**主动重置:** 剩余 2 次");
+    expect(card.elements[0].text.content).toContain("**5h:** 已用 37%，剩余 63%，重置:");
+    expect(card.elements[0].text.content).toContain("约 2小时52分钟后");
+    expect(card.elements[0].text.content).toContain("[███████░░░░░░░░░░░░░]");
+    expect(card.elements[0].text.content).toContain("**周:** 已用 12%，剩余 88%，重置:");
+    expect(card.elements[0].text.content).toContain("约 3天18小时17分钟后");
+    expect(card.elements[0].text.content).toContain("[██░░░░░░░░░░░░░░░░░░]");
+    expect(card.elements[2].actions[0].text.content).toBe("发起重置");
+    expect(card.elements[2].actions[0].value).toEqual({ action: "codex_reset_request", availableCount: 2 });
+  });
 
   it("handles /usage as Cursor usage in Cursor chats", async () => {
     const platform = mockPlatform("feishu");
@@ -438,7 +438,7 @@ describe("handleCommand WeChat processing ack", () => {
     expect(codexPlatform.sendCard).toHaveBeenCalledWith(
       "feishu-group",
       "Codex Session Ready",
-      expect.stringContaining("发送 **/usage** 查看 Codex 5h/周用量，以及查询/使用主动重置卡。"),
+      expect.stringContaining("发送 **/usage** 查看 Codex 5h/周用量，以及查询/使用主动重置卡。"),
       "green",
     );
 

package/src/__tests__/shared-prefix.test.ts

@@ -1,36 +1,36 @@
-import { describe, expect, it } from "vitest";
-
-import {
-  ABD_APPEND_PROMPT,
-  applySharedPrefix,
-} from "../shared-prefix.ts";
-
-describe("applySharedPrefix", () => {
-  it("leaves normal messages unchanged", () => {
-    expect(applySharedPrefix("帮我分析")).toEqual({
-      matched: false,
-      text: "帮我分析",
-      body: "帮我分析",
-    });
-  });
-
-  it("removes /abd without requiring a space", () => {
-    const result = applySharedPrefix("/abd帮我分析");
-
-    expect(result.matched).toBe(true);
-    expect(result.body).toBe("帮我分析");
-    expect(result.text).toBe(`帮我分析\n\n---\n${ABD_APPEND_PROMPT}`);
-  });
-
-  it("removes whitespace after /abd", () => {
-    const result = applySharedPrefix("/abd   帮我分析");
-
-    expect(result.text).toBe(`帮我分析\n\n---\n${ABD_APPEND_PROMPT}`);
-  });
-
-  it("keeps the appendix when the user body is empty", () => {
-    const result = applySharedPrefix("/abd   ");
-
-    expect(result.text).toBe(`---\n${ABD_APPEND_PROMPT}`);
-  });
-});
+import { describe, expect, it } from "vitest";
+
+import {
+  ABD_APPEND_PROMPT,
+  applySharedPrefix,
+} from "../shared-prefix.ts";
+
+describe("applySharedPrefix", () => {
+  it("leaves normal messages unchanged", () => {
+    expect(applySharedPrefix("帮我分析")).toEqual({
+      matched: false,
+      text: "帮我分析",
+      body: "帮我分析",
+    });
+  });
+
+  it("removes /abd without requiring a space", () => {
+    const result = applySharedPrefix("/abd帮我分析");
+
+    expect(result.matched).toBe(true);
+    expect(result.body).toBe("帮我分析");
+    expect(result.text).toBe(`帮我分析\n\n---\n${ABD_APPEND_PROMPT}`);
+  });
+
+  it("removes whitespace after /abd", () => {
+    const result = applySharedPrefix("/abd   帮我分析");
+
+    expect(result.text).toBe(`帮我分析\n\n---\n${ABD_APPEND_PROMPT}`);
+  });
+
+  it("keeps the appendix when the user body is empty", () => {
+    const result = applySharedPrefix("/abd   ");
+
+    expect(result.text).toBe(`---\n${ABD_APPEND_PROMPT}`);
+  });
+});

package/src/cards.ts

@@ -1,10 +1,10 @@
-// ---------------------------------------------------------------------------
-// Button helpers
-// ---------------------------------------------------------------------------
-
-import { ABD_HELP_LINE } from "./shared-prefix.ts";
-
-export interface ButtonDef {
+// ---------------------------------------------------------------------------
+// Button helpers
+// ---------------------------------------------------------------------------
+
+import { ABD_HELP_LINE } from "./shared-prefix.ts";
+
+export interface ButtonDef {
   text: string;
   value: string;
   type?: "primary" | "default" | "danger";
@@ -137,11 +137,11 @@ export function buildHelpCard(
     "发送 **/newh** 重置当前会话（沿用当前工作目录，不切换）",
     "发送 **/plan** 以规划模式提问（只读，不执行写操作）",
     "发送 **/ask** 以问答模式提问（只读，不执行写操作）",
-    "发送 **/usage** 查看 Codex 5h/周用量，以及查询/使用主动重置卡",
-    "发送 **/restart** 重启 ChatCCC 进程",
-    "发送 **/update** 更新并重启（仅 npm 全局安装可用）",
-    ABD_HELP_LINE,
-  ].join("\n");
+    "发送 **/usage** 查看 Codex 5h/周用量，以及查询/使用主动重置卡",
+    "发送 **/restart** 重启 ChatCCC 进程",
+    "发送 **/update** 更新并重启（仅 npm 全局安装可用）",
+    ABD_HELP_LINE,
+  ].join("\n");
   return JSON.stringify({
     config: { wide_screen_mode: true },
     header: { template: "blue", title: { content: "ChatCCC", tag: "plain_text" } },
@@ -410,11 +410,11 @@ export function buildQueueFullCard(): string {
 }
 
 // 状态卡片（带关闭按钮）
-export function buildStatusCard(statusText: string, template = "blue"): string {
-  return JSON.stringify({
-    config: { wide_screen_mode: true },
-    header: { template, title: { content: "会话状态", tag: "plain_text" } },
-    elements: [
+export function buildStatusCard(statusText: string, template = "blue"): string {
+  return JSON.stringify({
+    config: { wide_screen_mode: true },
+    header: { template, title: { content: "会话状态", tag: "plain_text" } },
+    elements: [
       { tag: "div", text: { tag: "lark_md", content: statusText } },
       { tag: "hr" },
       {
@@ -426,78 +426,78 @@ export function buildStatusCard(statusText: string, template = "blue"): string {
           value: { action: "close" },
         }],
       },
-    ],
-  });
-}
-
-export function buildCodexUsageCard(content: string, resetCreditsAvailable: number | null): string {
-  const elements: object[] = [
-    { tag: "div", text: { tag: "lark_md", content } },
-  ];
-  if (resetCreditsAvailable !== null && resetCreditsAvailable > 0) {
-    elements.push({ tag: "hr" });
-    elements.push({
-      tag: "action",
-      actions: [{
-        tag: "button",
-        text: { tag: "plain_text", content: "发起重置" },
-        type: "primary",
-        value: { action: "codex_reset_request", availableCount: resetCreditsAvailable },
-      }],
-    });
-  }
-
-  return JSON.stringify({
-    config: { wide_screen_mode: true },
-    header: { template: "blue", title: { content: "Codex Usage", tag: "plain_text" } },
-    elements,
-  });
-}
-
-export function buildCodexResetConfirmCard(params: {
-  availableCount: number;
-  parentMessageId: string;
-  requestId: string;
-}): string {
-  const valueBase = {
-    parentMessageId: params.parentMessageId,
-    requestId: params.requestId,
-  };
-  return JSON.stringify({
-    config: { wide_screen_mode: true },
-    header: { template: "yellow", title: { content: "确认 Codex 主动重置", tag: "plain_text" } },
-    elements: [
-      {
-        tag: "div",
-        text: {
-          tag: "lark_md",
-          content: `当前可用主动重置次数：**${params.availableCount}**。\n\n确认后会消耗 1 次主动重置，并重置当前可重置的 Codex 用量窗口。`,
-        },
-      },
-      { tag: "hr" },
-      {
-        tag: "action",
-        actions: [
-          {
-            tag: "button",
-            text: { tag: "plain_text", content: "是，发起重置" },
-            type: "danger",
-            value: { action: "codex_reset_confirm", decision: "yes", ...valueBase },
-          },
-          {
-            tag: "button",
-            text: { tag: "plain_text", content: "否" },
-            type: "default",
-            value: { action: "codex_reset_confirm", decision: "no", ...valueBase },
-          },
-        ],
-      },
-    ],
-  });
-}
-
-/** 模型切换卡片（/model 命令，飞书专用，含切换按钮） */
-export function buildModelCard(
+    ],
+  });
+}
+
+export function buildCodexUsageCard(content: string, resetCreditsAvailable: number | null): string {
+  const elements: object[] = [
+    { tag: "div", text: { tag: "lark_md", content } },
+  ];
+  if (resetCreditsAvailable !== null && resetCreditsAvailable > 0) {
+    elements.push({ tag: "hr" });
+    elements.push({
+      tag: "action",
+      actions: [{
+        tag: "button",
+        text: { tag: "plain_text", content: "发起重置" },
+        type: "primary",
+        value: { action: "codex_reset_request", availableCount: resetCreditsAvailable },
+      }],
+    });
+  }
+
+  return JSON.stringify({
+    config: { wide_screen_mode: true },
+    header: { template: "blue", title: { content: "Codex Usage", tag: "plain_text" } },
+    elements,
+  });
+}
+
+export function buildCodexResetConfirmCard(params: {
+  availableCount: number;
+  parentMessageId: string;
+  requestId: string;
+}): string {
+  const valueBase = {
+    parentMessageId: params.parentMessageId,
+    requestId: params.requestId,
+  };
+  return JSON.stringify({
+    config: { wide_screen_mode: true },
+    header: { template: "yellow", title: { content: "确认 Codex 主动重置", tag: "plain_text" } },
+    elements: [
+      {
+        tag: "div",
+        text: {
+          tag: "lark_md",
+          content: `当前可用主动重置次数：**${params.availableCount}**。\n\n确认后会消耗 1 次主动重置，并重置当前可重置的 Codex 用量窗口。`,
+        },
+      },
+      { tag: "hr" },
+      {
+        tag: "action",
+        actions: [
+          {
+            tag: "button",
+            text: { tag: "plain_text", content: "是，发起重置" },
+            type: "danger",
+            value: { action: "codex_reset_confirm", decision: "yes", ...valueBase },
+          },
+          {
+            tag: "button",
+            text: { tag: "plain_text", content: "否" },
+            type: "default",
+            value: { action: "codex_reset_confirm", decision: "no", ...valueBase },
+          },
+        ],
+      },
+    ],
+  });
+}
+
+/** 模型切换卡片（/model 命令，飞书专用，含切换按钮） */
+export function buildModelCard(
   currentModel: string,
   models: string[],
   tool?: string,

package/src/codex-reset-actions.ts

@@ -14,8 +14,10 @@ interface PendingCodexResetRequest {
 export interface CodexResetActionDeps {
   getTenantAccessToken(): Promise<string>;
   sendRawCard(token: string, chatId: string, cardJson: string): Promise<boolean>;
+  sendTextReply(token: string, chatId: string, text: string): Promise<boolean>;
   sendCardReply(token: string, chatId: string, title: string, content: string, template?: string): Promise<boolean>;
   updateCardMessage(token: string, messageId: string, content: string): Promise<boolean>;
+  recallMessage(token: string, messageId: string): Promise<boolean>;
   consumeCodexRateLimitResetCredit(redeemRequestId: string): Promise<CodexResetConsumeResult>;
   createRequestId?: () => string;
 }
@@ -38,7 +40,13 @@ function eventMessageId(raw: Record<string, unknown>): string {
     ? raw.open_message_id
     : typeof (raw.context as Record<string, unknown> | undefined)?.open_message_id === "string"
       ? (raw.context as Record<string, string>).open_message_id
-      : "";
+      : typeof raw.message_id === "string"
+        ? raw.message_id
+        : typeof (raw.context as Record<string, unknown> | undefined)?.message_id === "string"
+          ? (raw.context as Record<string, string>).message_id
+          : typeof (raw.message as Record<string, unknown> | undefined)?.message_id === "string"
+            ? (raw.message as Record<string, string>).message_id
+            : "";
 }
 
 function eventChatId(raw: Record<string, unknown>): string {
@@ -124,7 +132,12 @@ async function handleResetConfirmation(
   const token = await deps.getTenantAccessToken();
   const confirmMessageId = eventMessageId(raw);
   if (confirmMessageId) {
-    await deps.updateCardMessage(token, confirmMessageId, collapsedCard());
+    const collapsed = await deps.updateCardMessage(token, confirmMessageId, collapsedCard());
+    console.log(`[Codex Reset] collapse confirmation card ${collapsed ? "OK" : "FAILED"}: messageId=${confirmMessageId}`);
+    const recalled = await deps.recallMessage(token, confirmMessageId);
+    console.log(`[Codex Reset] recall confirmation card ${recalled ? "OK" : "FAILED"}: messageId=${confirmMessageId}`);
+  } else {
+    console.error("[Codex Reset] missing confirmation card message id; cannot collapse");
   }
 
   const pending = pendingCodexResetRequests.get(requestId);
@@ -132,22 +145,22 @@ async function handleResetConfirmation(
   if (!chatId) return true;
 
   if (!pending || pending.status !== "pending" || pending.parentMessageId !== parentMessageId) {
-    await deps.sendCardReply(token, chatId, "Codex 主动重置", "这张确认卡片已经失效或已处理。", "yellow");
+    await deps.sendTextReply(token, chatId, "Codex 主动重置：这张确认卡片已经失效或已处理。");
     return true;
   }
   pending.status = "handled";
 
   if (decision === "no") {
-    await deps.sendCardReply(token, chatId, "Codex 主动重置", "用户取消了重置。", "grey");
+    await deps.sendTextReply(token, chatId, "Codex 主动重置：用户取消了重置。");
     return true;
   }
 
   try {
     const result = await deps.consumeCodexRateLimitResetCredit(requestId);
     const message = resetResultMessage(result);
-    await deps.sendCardReply(token, chatId, "Codex 主动重置", message.content, message.template);
+    await deps.sendTextReply(token, chatId, `Codex 主动重置：${message.content}`);
   } catch (err) {
-    await deps.sendCardReply(token, chatId, "Codex 主动重置", `重置失败：${(err as Error).message}`, "red");
+    await deps.sendTextReply(token, chatId, `Codex 主动重置失败：${(err as Error).message}`);
   }
   return true;
 }