chatccc 0.2.33 → 0.2.35

package/package.json

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

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

@@ -0,0 +1,55 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import { getPlatform, setPlatform, getTenantAccessToken, getChatInfo, createGroupChat, updateChatInfo, sendTextReply, sendCardReply, extractSessionInfo, formatDelayNotice, reportPermissionResults, verifyAllPermissions, addReaction, recallMessage, updateCardMessage, setChatAvatar, sendRestartCard } from "../feishu-platform.ts";
+import type { FeishuPlatform } from "../feishu-platform.ts";
+
+const realPlatform = getPlatform();
+
+describe("feishu-platform", () => {
+  it("默认使用真实实现", () => {
+    expect(realPlatform).toBeDefined();
+    expect(typeof realPlatform.getTenantAccessToken).toBe("function");
+    expect(typeof realPlatform.sendTextReply).toBe("function");
+  });
+
+  it("setPlatform 可替换实现，包装函数委托到新实现", async () => {
+    const mock: FeishuPlatform = {
+      getTenantAccessToken: async () => "mock_token",
+      sendTextReply: async () => true,
+      sendCardReply: async () => true,
+      sendImageReply: async () => true,
+      sendFileReply: async () => true,
+      addReaction: async () => {},
+      recallMessage: async () => false,
+      updateCardMessage: async () => true,
+      createGroupChat: async () => "mock_chat",
+      updateChatInfo: async () => {},
+      getChatInfo: async () => ({ name: "x", description: "y" }),
+      setChatAvatar: async () => {},
+      getOrDownloadImage: async () => "/tmp/img.png",
+      verifyAllPermissions: async () => [],
+      reportPermissionResults: realPlatform.reportPermissionResults,
+      extractSessionInfo: realPlatform.extractSessionInfo,
+      extractSessionId: realPlatform.extractSessionId,
+      formatDelayNotice: realPlatform.formatDelayNotice,
+      sendRestartCard: async () => {},
+    };
+
+    setPlatform(mock);
+    try {
+      expect(await getTenantAccessToken()).toBe("mock_token");
+      expect(await sendTextReply("t", "c", "hi")).toBe(true);
+      expect(await createGroupChat("t", "g", [])).toBe("mock_chat");
+      expect(await getChatInfo("t", "mock_chat")).toEqual({ name: "x", description: "y" });
+      const perms = await verifyAllPermissions("t");
+      expect(perms).toEqual([]);
+    } finally {
+      // 恢复到真实实现，避免影响后续测试
+      setPlatform(realPlatform);
+    }
+  });
+
+  it("恢复真实实现后函数正常工作", async () => {
+    setPlatform(realPlatform);
+    expect(getPlatform()).toBe(realPlatform);
+  });
+});

package/src/__tests__/sim-agent.test.ts

@@ -0,0 +1,174 @@
+import { describe, it, expect, afterAll, beforeEach } from "vitest";
+import { unlink } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+import { createSimAgent } from "../sim-agent.ts";
+import { simStore, setMessageHandler } from "../sim-store.ts";
+
+const MESSAGES_FILE = join(homedir(), ".chatccc", "sim", "messages.jsonl");
+
+describe("SimAgent", () => {
+  beforeEach(() => {
+    simStore.reset();
+    setMessageHandler(async () => {});
+  });
+
+  afterAll(async () => {
+    try { await unlink(MESSAGES_FILE); } catch { /* ok */ }
+  });
+
+  it("createSimAgent 绑定已有用户账户", () => {
+    const a = createSimAgent("sim_user_001");
+    expect(a.userId).toBe("sim_user_001");
+    expect(a.account.name).toBe("Developer");
+  });
+
+  it("createSimAgent 不存在用户抛出错误", () => {
+    expect(() => createSimAgent("nonexistent")).toThrow('Account "nonexistent" not found');
+  });
+
+  it("createSimAgent bot 账户抛出错误", () => {
+    expect(() => createSimAgent("bot")).toThrow('is not a user account');
+  });
+
+  it("createP2pWithBot 创建后用户能看到", () => {
+    const a = createSimAgent("sim_user_001");
+    const chatId = a.createP2pWithBot();
+    expect(chatId).toBe("p2p_sim_user_001_bot");
+    const chats = a.listChats();
+    expect(chats.some((c) => c.type === "p2p")).toBe(true);
+  });
+
+  it("sendMessage 将消息发送到指定群", async () => {
+    let receivedText = "";
+    let receivedChatId = "";
+    setMessageHandler(async (text, chatId) => {
+      receivedText = text;
+      receivedChatId = chatId;
+      simStore.sendReply(chatId, "text", `echo: ${text}`);
+    });
+
+    const a = createSimAgent("sim_user_001");
+    await a.sendMessage("sim_default", "你好");
+
+    expect(receivedText).toBe("你好");
+    expect(receivedChatId).toBe("sim_default");
+  });
+
+  it("sendMessage 非成员发送消息抛出错误", async () => {
+    simStore.registerAccount({ id: "alice_test", kind: "user", name: "Alice" });
+    const a = createSimAgent("alice_test");
+    await expect(a.sendMessage("sim_default", "hello"))
+      .rejects.toThrow('is not a member');
+  });
+
+  it("on message 订阅收到 bot 回复", async () => {
+    setMessageHandler(async (text, chatId) => {
+      simStore.sendReply(chatId, "text", `reply to: ${text}`);
+    });
+
+    const a = createSimAgent("sim_user_001");
+    let received: { chatId: string; content: string } | null = null;
+    a.on("message", (chatId, msg) => {
+      received = { chatId, content: msg.content };
+    });
+
+    await a.sendMessage("sim_default", "ping");
+    await new Promise((r) => setTimeout(r, 50));
+
+    expect(received).not.toBeNull();
+    expect(received!.content).toBe("reply to: ping");
+  });
+
+  it("waitForReply 等待 bot 回复", async () => {
+    setMessageHandler(async (text, chatId) => {
+      setTimeout(() => {
+        simStore.sendReply(chatId, "text", `async reply: ${text}`);
+      }, 10);
+    });
+
+    const a = createSimAgent("sim_user_001");
+    const replyPromise = a.waitForReply("sim_default", 5000);
+    await a.sendMessage("sim_default", "hello");
+
+    const reply = await replyPromise;
+    expect(reply).not.toBeNull();
+    expect(reply!.content).toBe("async reply: hello");
+    expect(reply!.senderId).toBe("bot");
+  });
+
+  it("waitForReply 超时返回 null", async () => {
+    setMessageHandler(async () => {});
+
+    const a = createSimAgent("sim_user_001");
+    const reply = await a.waitForReply("sim_default", 100);
+    expect(reply).toBeNull();
+  });
+
+  it("getMessages 获取消息历史", async () => {
+    setMessageHandler(async (text, chatId) => {
+      simStore.sendReply(chatId, "text", `echo: ${text}`);
+    });
+
+    const a = createSimAgent("sim_user_001");
+    await a.sendMessage("sim_default", "msg1");
+    await a.sendMessage("sim_default", "msg2");
+    await new Promise((r) => setTimeout(r, 50));
+
+    const msgs = a.getMessages("sim_default");
+    expect(msgs.length).toBe(4); // 2 user + 2 bot
+    expect(msgs[0].senderId).toBe("sim_user_001");
+    expect(msgs[0].content).toBe("msg1");
+    expect(msgs[1].senderId).toBe("bot");
+    expect(msgs[1].content).toBe("echo: msg1");
+  });
+
+  it("on invited_to_group 收到拉群通知", () => {
+    simStore.registerAccount({ id: "new_user", kind: "user", name: "New" });
+    const a = createSimAgent("new_user");
+    let invitedChatId = "";
+    let invitedUserId = "";
+    a.on("invited_to_group", (chatId, userId) => {
+      invitedChatId = chatId;
+      invitedUserId = userId;
+    });
+
+    simStore.createGroupChat("新群", ["new_user"]);
+    expect(invitedChatId).toMatch(/^sim_/);
+    expect(invitedUserId).toBe("new_user");
+  });
+
+  it("off 取消消息订阅", async () => {
+    setMessageHandler(async (text, chatId) => {
+      simStore.sendReply(chatId, "text", `echo: ${text}`);
+    });
+
+    const a = createSimAgent("sim_user_001");
+    let count = 0;
+    const handler = () => { count++; };
+    a.on("message", handler);
+
+    await a.sendMessage("sim_default", "test1");
+    await new Promise((r) => setTimeout(r, 30));
+    // sendMessage 产生 2 条消息（recordMessage + sendReply）
+    const countBeforeOff = count;
+    expect(countBeforeOff).toBe(2);
+
+    a.off("message", handler);
+
+    await a.sendMessage("sim_default", "test2");
+    await new Promise((r) => setTimeout(r, 30));
+
+    // off 后不应再增加
+    expect(count).toBe(countBeforeOff);
+  });
+
+  it("listChats 返回用户会话列表", () => {
+    const a = createSimAgent("sim_user_001");
+    const chats = a.listChats();
+    expect(chats.length).toBeGreaterThanOrEqual(1);
+    expect(chats.some((c) => c.id === "sim_default")).toBe(true);
+    expect(chats.some((c) => c.type === "p2p")).toBe(true);
+  });
+});

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

@@ -0,0 +1,77 @@
+import { describe, it, expect, afterAll } from "vitest";
+import { unlink } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+import { SimulatedPlatform, SIM_DEFAULT_CHAT_ID } from "../sim-platform.ts";
+
+const MESSAGES_FILE = join(homedir(), ".chatccc", "sim", "messages.jsonl");
+
+describe("SimulatedPlatform", () => {
+  afterAll(async () => {
+    // 清理测试消息文件
+    try { await unlink(MESSAGES_FILE); } catch { /* ok */ }
+  });
+
+  it("getTenantAccessToken 返回固定 token", async () => {
+    const token = await SimulatedPlatform.getTenantAccessToken();
+    expect(token).toBe("sim_token");
+  });
+
+  it("createGroupChat 创建群并返回 sim_xxx ID", async () => {
+    const chatId = await SimulatedPlatform.createGroupChat("t", "测试群", ["u1"]);
+    expect(chatId).toMatch(/^sim_[0-9a-f]{8}$/);
+    const info = await SimulatedPlatform.getChatInfo("t", chatId);
+    expect(info.name).toBe("测试群");
+  });
+
+  it("getChatInfo 默认群存在", async () => {
+    const info = await SimulatedPlatform.getChatInfo("t", SIM_DEFAULT_CHAT_ID);
+    expect(info.name).toBe("默认模拟会话");
+  });
+
+  it("updateChatInfo 更新群信息", async () => {
+    const chatId = await SimulatedPlatform.createGroupChat("t", "原群名", ["u1"]);
+    await SimulatedPlatform.updateChatInfo("t", chatId, "新群名", "Claude Session: abc123");
+    const info = await SimulatedPlatform.getChatInfo("t", chatId);
+    expect(info.name).toBe("新群名");
+    expect(info.description).toContain("Claude Session");
+  });
+
+  it("sendTextReply 返回 true", async () => {
+    const ok = await SimulatedPlatform.sendTextReply("t", "ch1", "你好");
+    expect(ok).toBe(true);
+  });
+
+  it("sendCardReply 返回 true", async () => {
+    const ok = await SimulatedPlatform.sendCardReply("t", "ch1", "标题", "内容", "blue");
+    expect(ok).toBe(true);
+  });
+
+  it("verifyAllPermissions 全部通过", async () => {
+    const results = await SimulatedPlatform.verifyAllPermissions("t");
+    expect(results.length).toBe(5);
+    expect(results.every((r) => r.ok)).toBe(true);
+  });
+
+  it("addReaction 无异常", async () => {
+    await expect(SimulatedPlatform.addReaction("t", "msg1")).resolves.toBeUndefined();
+  });
+
+  it("setChatAvatar 无异常", async () => {
+    await expect(SimulatedPlatform.setChatAvatar("t", "ch1", "claude", "busy")).resolves.toBeUndefined();
+  });
+
+  it("纯函数 extractSessionInfo 正常工作", () => {
+    const result = SimulatedPlatform.extractSessionInfo("Claude Code Session: a1b2c3d4-e5f6-7890-abcd-ef1234567890");
+    expect(result).toEqual({ sessionId: "a1b2c3d4-e5f6-7890-abcd-ef1234567890", tool: "claude" });
+  });
+
+  it("纯函数 formatDelayNotice 正常工作", () => {
+    const notice = SimulatedPlatform.formatDelayNotice(Date.now() - 20 * 60 * 1000, "测试消息");
+    expect(notice).toBeDefined();
+    expect(notice).toContain("延迟送达");
+    // 近期消息不触发
+    expect(SimulatedPlatform.formatDelayNotice(Date.now(), "test")).toBeNull();
+  });
+});

package/src/__tests__/sim-store.test.ts

@@ -0,0 +1,214 @@
+import { describe, it, expect, afterAll } from "vitest";
+import { unlink } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+import { SimStore, simStore, SIM_DEFAULT_CHAT_ID } from "../sim-store.ts";
+import type { SimAccount, SimChat, SimMessage } from "../sim-store.ts";
+
+const MESSAGES_FILE = join(homedir(), ".chatccc", "sim", "messages.jsonl");
+
+describe("SimStore", () => {
+  afterAll(async () => {
+    try { await unlink(MESSAGES_FILE); } catch { /* ok */ }
+  });
+
+  // ---- 初始化 ----
+
+  it("默认初始化 bot + 默认用户 + 默认群", () => {
+    const store = new SimStore();
+    expect(store.getAccount("bot")).toBeDefined();
+    expect(store.getAccount("sim_user_001")).toBeDefined();
+    expect(store.getChat("sim_default")).toBeDefined();
+  });
+
+  it("默认群成员包含 bot 和 sim_user_001", () => {
+    const store = new SimStore();
+    const chat = store.getChat("sim_default")!;
+    expect(chat.memberIds).toContain("bot");
+    expect(chat.memberIds).toContain("sim_user_001");
+    expect(chat.type).toBe("group");
+  });
+
+  // ---- 账户管理 ----
+
+  it("registerAccount 注册新用户", () => {
+    const store = new SimStore();
+    store.registerAccount({ id: "alice", kind: "user", name: "Alice" });
+    const a = store.getAccount("alice");
+    expect(a).toBeDefined();
+    expect(a!.name).toBe("Alice");
+    expect(a!.kind).toBe("user");
+  });
+
+  it("registerAccount 重复 id 抛出错误", () => {
+    const store = new SimStore();
+    store.registerAccount({ id: "bob", kind: "user", name: "Bob" });
+    expect(() => store.registerAccount({ id: "bob", kind: "user", name: "Bob2" }))
+      .toThrow('Account "bob" already exists');
+  });
+
+  // ---- 群聊管理 ----
+
+  it("createGroupChat 创建群，bot 自动加入", () => {
+    const store = new SimStore();
+    store.registerAccount({ id: "alice", kind: "user", name: "Alice" });
+    const chat = store.createGroupChat("测试群", ["alice"]);
+    expect(chat.id).toMatch(/^sim_[0-9a-f]{8}$/);
+    expect(chat.name).toBe("测试群");
+    expect(chat.type).toBe("group");
+    expect(chat.memberIds).toContain("bot");
+    expect(chat.memberIds).toContain("alice");
+  });
+
+  it("createGroupChat emit chat_created 和 member_added 事件", () => {
+    const store = new SimStore();
+    store.registerAccount({ id: "alice", kind: "user", name: "Alice" });
+
+    let createdChat: SimChat | null = null;
+    let addedUserId = "";
+    store.on("chat_created", ({ chat }) => { createdChat = chat; });
+    store.on("member_added", ({ userId }) => { addedUserId = userId; });
+
+    store.createGroupChat("测试群", ["alice"]);
+    expect(createdChat).not.toBeNull();
+    expect(createdChat!.name).toBe("测试群");
+    expect(addedUserId).toBe("alice");
+  });
+
+  it("createP2pChat 创建私聊", () => {
+    const store = new SimStore();
+    store.registerAccount({ id: "alice", kind: "user", name: "Alice" });
+    const chat = store.createP2pChat("alice");
+    expect(chat.id).toBe("p2p_alice_bot");
+    expect(chat.type).toBe("p2p");
+    expect(chat.memberIds).toContain("bot");
+    expect(chat.memberIds).toContain("alice");
+  });
+
+  it("createP2pChat 重复调用返回同一个 chat", () => {
+    const store = new SimStore();
+    store.registerAccount({ id: "alice", kind: "user", name: "Alice" });
+    const c1 = store.createP2pChat("alice");
+    const c2 = store.createP2pChat("alice");
+    expect(c1.id).toBe(c2.id);
+  });
+
+  it("getChatsForUser 返回用户所在的所有会话", () => {
+    const store = new SimStore();
+    store.registerAccount({ id: "alice", kind: "user", name: "Alice" });
+    store.createP2pChat("alice");
+    store.createGroupChat("群1", ["alice"]);
+    store.createGroupChat("群2", ["alice"]);
+
+    const chats = store.getChatsForUser("alice");
+    expect(chats.length).toBeGreaterThanOrEqual(2);
+    expect(chats.some((c) => c.type === "p2p")).toBe(true);
+  });
+
+  it("addMember 添加成员并 emit 事件", () => {
+    const store = new SimStore();
+    store.registerAccount({ id: "alice", kind: "user", name: "Alice" });
+    const chat = store.createGroupChat("测试群", []);
+
+    let addedUserId = "";
+    store.on("member_added", ({ userId }) => { addedUserId = userId; });
+
+    store.addMember(chat.id, "alice");
+    expect(chat.memberIds).toContain("alice");
+    expect(addedUserId).toBe("alice");
+  });
+
+  it("updateChatInfo 更新已有群信息", () => {
+    const store = new SimStore();
+    store.registerAccount({ id: "alice", kind: "user", name: "Alice" });
+    const chat = store.createGroupChat("原群名", ["alice"]);
+    store.updateChatInfo(chat.id, "新群名", "Claude Code Session: abc123");
+    expect(chat.name).toBe("新群名");
+    expect(chat.description).toBe("Claude Code Session: abc123");
+  });
+
+  it("updateChatInfo 对不存在的群自动创建", () => {
+    const store = new SimStore();
+    store.updateChatInfo("sim_fake", "新群", "desc");
+    const chat = store.getChat("sim_fake");
+    expect(chat).toBeDefined();
+    expect(chat!.name).toBe("新群");
+  });
+
+  // ---- 消息管理 ----
+
+  it("recordMessage 记录用户消息到 chat 历史", () => {
+    const store = new SimStore();
+    store.registerAccount({ id: "alice", kind: "user", name: "Alice" });
+    const chat = store.createGroupChat("测试群", ["alice"]);
+    store.recordMessage(chat.id, "alice", "text", "你好");
+    expect(chat.messages.length).toBe(1);
+    expect(chat.messages[0].content).toBe("你好");
+    expect(chat.messages[0].senderId).toBe("alice");
+  });
+
+  it("recordMessage emit message 事件", () => {
+    const store = new SimStore();
+    store.registerAccount({ id: "alice", kind: "user", name: "Alice" });
+    const chat = store.createGroupChat("测试群", ["alice"]);
+
+    let emittedMsg: SimMessage | null = null;
+    let emittedChatId = "";
+    store.on("message", ({ chatId, message }) => {
+      emittedChatId = chatId;
+      emittedMsg = message;
+    });
+
+    store.recordMessage(chat.id, "alice", "text", "hello");
+    expect(emittedChatId).toBe(chat.id);
+    expect(emittedMsg!.content).toBe("hello");
+  });
+
+  it("recordMessage 非成员不能看到消息", () => {
+    const store = new SimStore();
+    store.registerAccount({ id: "alice", kind: "user", name: "Alice" });
+    store.registerAccount({ id: "bob", kind: "user", name: "Bob" });
+    const chat = store.createGroupChat("测试群", ["alice"]); // bob 不在群内
+
+    store.recordMessage(chat.id, "alice", "text", "hello");
+    const msgs = store.getMessages(chat.id, "bob"); // bob 请求消息
+    expect(msgs.length).toBe(0);
+  });
+
+  it("recordMessage 成员可以看到消息", () => {
+    const store = new SimStore();
+    store.registerAccount({ id: "alice", kind: "user", name: "Alice" });
+    const chat = store.createGroupChat("测试群", ["alice"]);
+
+    store.recordMessage(chat.id, "alice", "text", "hello");
+    const msgs = store.getMessages(chat.id, "alice");
+    expect(msgs.length).toBe(1);
+    expect(msgs[0].content).toBe("hello");
+  });
+
+  it("sendReply 即使 chat 不存在也能记录并 emit", () => {
+    const store = new SimStore();
+    let emitted = false;
+    store.on("message", () => { emitted = true; });
+
+    const msg = store.sendReply("unknown_chat", "text", "测试");
+    expect(msg.senderId).toBe("bot");
+    expect(emitted).toBe(true);
+  });
+
+  it("sendReply 追加到已有 chat 的消息历史", () => {
+    const store = new SimStore();
+    store.registerAccount({ id: "alice", kind: "user", name: "Alice" });
+    const chat = store.createGroupChat("测试群", ["alice"]);
+
+    store.sendReply(chat.id, "text", "bot reply");
+    expect(chat.messages.length).toBe(1);
+    expect(chat.messages[0].senderId).toBe("bot");
+  });
+
+  it("getMessages 对不存在的 chat 返回空数组", () => {
+    const store = new SimStore();
+    expect(store.getMessages("nonexistent", "alice")).toEqual([]);
+  });
+});

package/src/agent-file-rpc.ts

@@ -3,7 +3,7 @@ import type { IncomingMessage, ServerResponse } from "node:http";
 import { extname, isAbsolute, resolve } from "node:path";
 import { stat } from "node:fs/promises";
 
-import { getTenantAccessToken, sendFileReply, sendTextReply } from "./feishu-api.ts";
+import { getTenantAccessToken, sendFileReply, sendTextReply } from "./feishu-platform.ts";
 import { ts } from "./config.ts";
 import { logTrace } from "./trace.ts";
 import { readUtf8JsonBody } from "./agent-rpc-body.ts";

package/src/agent-image-rpc.ts

@@ -3,7 +3,7 @@ import type { IncomingMessage, ServerResponse } from "node:http";
 import { extname, isAbsolute, resolve } from "node:path";
 import { stat } from "node:fs/promises";
 
-import { getTenantAccessToken, sendImageReply, sendTextReply } from "./feishu-api.ts";
+import { getTenantAccessToken, sendImageReply, sendTextReply } from "./feishu-platform.ts";
 import { ts } from "./config.ts";
 import { logTrace } from "./trace.ts";
 import { readUtf8JsonBody } from "./agent-rpc-body.ts";

package/src/config.ts

@@ -454,6 +454,7 @@ export const config: AppConfig = loadConfig();
 // （前提是导入端在函数体内读，不是在模块顶层读）。
 
 export const USE_LOCAL = process.argv.includes("--local");
+export const USE_SIMULATE = process.argv.includes("--simulate");
 export let APP_ID = config.feishu.appId;
 export let APP_SECRET = config.feishu.appSecret;
 export const BASE_URL = "https://open.feishu.cn/open-apis";

package/src/feishu-api.ts

@@ -794,6 +794,33 @@ export async function sendCardReply(
   }
 }
 
+export async function sendRawCard(
+  token: string,
+  chatId: string,
+  cardJson: string
+): Promise<boolean> {
+  try {
+    const resp = await fetch(`${BASE_URL}/im/v1/messages?receive_id_type=chat_id`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ receive_id: chatId, msg_type: "interactive", content: cardJson }),
+    });
+    const data = (await resp.json().catch(() => ({}))) as { code: number; msg?: string; data?: { message_id?: string } };
+    if (data.code !== 0) {
+      console.error(`[${ts()}] [SEND] raw_card FAIL: chatId=${chatId} code=${data.code} msg="${data.msg ?? ""}"`);
+      return false;
+    }
+    console.log(`[${ts()}] [SEND] raw_card OK: chatId=${chatId} msgId=${data.data?.message_id ?? "N/A"}`);
+    return true;
+  } catch (err) {
+    console.error(`[${ts()}] [SEND] raw_card FAIL: chatId=${chatId} ${(err as Error).message}`);
+    return false;
+  }
+}
+
 // 重启后，向最后有发言的会话发送 "已重启" 卡片（基于 chat_logs 的文件修改时间）
 export async function sendRestartCard(token: string): Promise<void> {
   try {