chatccc 0.2.33 → 0.2.35

package/src/feishu-platform.ts

@@ -0,0 +1,134 @@
+/**
+ * feishu-platform.ts — 可替换的飞书 API 实现层
+ *
+ * 默认情况下所有函数直接委托给 feishu-api.ts（真实飞书 API）。
+ * 在 --simulate 模式下通过 setPlatform() 整体替换为 SimulatedPlatform。
+ *
+ * 设计：每个导出函数都是一个"通过 _impl 代理"的包装器，
+ * 消费者不需要感知底层是真实飞书还是模拟实现。
+ */
+
+import * as realApi from "./feishu-api.ts";
+
+// ---------------------------------------------------------------------------
+// 平台接口：覆盖 feishu-api.ts 的所有公开导出函数签名
+// ---------------------------------------------------------------------------
+
+export interface FeishuPlatform {
+  getTenantAccessToken: typeof realApi.getTenantAccessToken;
+  sendTextReply: typeof realApi.sendTextReply;
+  sendCardReply: typeof realApi.sendCardReply;
+  sendRawCard: typeof realApi.sendRawCard;
+  sendImageReply: typeof realApi.sendImageReply;
+  sendFileReply: typeof realApi.sendFileReply;
+  addReaction: typeof realApi.addReaction;
+  recallMessage: typeof realApi.recallMessage;
+  updateCardMessage: typeof realApi.updateCardMessage;
+  createGroupChat: typeof realApi.createGroupChat;
+  updateChatInfo: typeof realApi.updateChatInfo;
+  getChatInfo: typeof realApi.getChatInfo;
+  setChatAvatar: typeof realApi.setChatAvatar;
+  getOrDownloadImage: typeof realApi.getOrDownloadImage;
+  verifyAllPermissions: typeof realApi.verifyAllPermissions;
+  reportPermissionResults: typeof realApi.reportPermissionResults;
+  extractSessionInfo: typeof realApi.extractSessionInfo;
+  extractSessionId: typeof realApi.extractSessionId;
+  formatDelayNotice: typeof realApi.formatDelayNotice;
+  sendRestartCard: typeof realApi.sendRestartCard;
+}
+
+let _impl: FeishuPlatform = realApi;
+
+/** 替换当前平台实现（模拟模式入口） */
+export function setPlatform(impl: FeishuPlatform): void {
+  _impl = impl;
+}
+
+/** 获取当前平台实现（仅供诊断/测试） */
+export function getPlatform(): FeishuPlatform {
+  return _impl;
+}
+
+// ---------------------------------------------------------------------------
+// 包装器：每个函数直接委托到 _impl，签名与原函数完全一致
+// ---------------------------------------------------------------------------
+
+export function getTenantAccessToken(): ReturnType<typeof realApi.getTenantAccessToken> {
+  return _impl.getTenantAccessToken();
+}
+
+export function sendTextReply(...args: Parameters<typeof realApi.sendTextReply>): ReturnType<typeof realApi.sendTextReply> {
+  return _impl.sendTextReply(...args);
+}
+
+export function sendCardReply(...args: Parameters<typeof realApi.sendCardReply>): ReturnType<typeof realApi.sendCardReply> {
+  return _impl.sendCardReply(...args);
+}
+
+export function sendRawCard(...args: Parameters<typeof realApi.sendRawCard>): ReturnType<typeof realApi.sendRawCard> {
+  return _impl.sendRawCard(...args);
+}
+
+export function sendImageReply(...args: Parameters<typeof realApi.sendImageReply>): ReturnType<typeof realApi.sendImageReply> {
+  return _impl.sendImageReply(...args);
+}
+
+export function sendFileReply(...args: Parameters<typeof realApi.sendFileReply>): ReturnType<typeof realApi.sendFileReply> {
+  return _impl.sendFileReply(...args);
+}
+
+export function addReaction(...args: Parameters<typeof realApi.addReaction>): ReturnType<typeof realApi.addReaction> {
+  return _impl.addReaction(...args);
+}
+
+export function recallMessage(...args: Parameters<typeof realApi.recallMessage>): ReturnType<typeof realApi.recallMessage> {
+  return _impl.recallMessage(...args);
+}
+
+export function updateCardMessage(...args: Parameters<typeof realApi.updateCardMessage>): ReturnType<typeof realApi.updateCardMessage> {
+  return _impl.updateCardMessage(...args);
+}
+
+export function createGroupChat(...args: Parameters<typeof realApi.createGroupChat>): ReturnType<typeof realApi.createGroupChat> {
+  return _impl.createGroupChat(...args);
+}
+
+export function updateChatInfo(...args: Parameters<typeof realApi.updateChatInfo>): ReturnType<typeof realApi.updateChatInfo> {
+  return _impl.updateChatInfo(...args);
+}
+
+export function getChatInfo(...args: Parameters<typeof realApi.getChatInfo>): ReturnType<typeof realApi.getChatInfo> {
+  return _impl.getChatInfo(...args);
+}
+
+export function setChatAvatar(...args: Parameters<typeof realApi.setChatAvatar>): ReturnType<typeof realApi.setChatAvatar> {
+  return _impl.setChatAvatar(...args);
+}
+
+export function getOrDownloadImage(...args: Parameters<typeof realApi.getOrDownloadImage>): ReturnType<typeof realApi.getOrDownloadImage> {
+  return _impl.getOrDownloadImage(...args);
+}
+
+export function verifyAllPermissions(...args: Parameters<typeof realApi.verifyAllPermissions>): ReturnType<typeof realApi.verifyAllPermissions> {
+  return _impl.verifyAllPermissions(...args);
+}
+
+export function reportPermissionResults(...args: Parameters<typeof realApi.reportPermissionResults>): ReturnType<typeof realApi.reportPermissionResults> {
+  return _impl.reportPermissionResults(...args);
+}
+
+export function extractSessionInfo(...args: Parameters<typeof realApi.extractSessionInfo>): ReturnType<typeof realApi.extractSessionInfo> {
+  return _impl.extractSessionInfo(...args);
+}
+
+export function extractSessionId(...args: Parameters<typeof realApi.extractSessionId>): ReturnType<typeof realApi.extractSessionId> {
+  return _impl.extractSessionId(...args);
+}
+
+export function formatDelayNotice(...args: Parameters<typeof realApi.formatDelayNotice>): ReturnType<typeof realApi.formatDelayNotice> {
+  return _impl.formatDelayNotice(...args);
+}
+
+export function sendRestartCard(...args: Parameters<typeof realApi.sendRestartCard>): ReturnType<typeof realApi.sendRestartCard> {
+  return _impl.sendRestartCard(...args);
+}

package/src/index.ts

@@ -24,7 +24,7 @@
 
 import { spawn } from "node:child_process";
 import { readdir, stat } from "node:fs/promises";
-import { createServer, type Server } from "node:http";
+import { createServer, type IncomingMessage, type Server, type ServerResponse } from "node:http";
 import { resolve, dirname } from "node:path";
 
 import { WSClient, EventDispatcher } from "@larksuiteoapi/node-sdk";
@@ -47,6 +47,7 @@ import {
   PID_FILE,
   PROJECT_ROOT,
   USE_LOCAL,
+  USE_SIMULATE,
   appendChatLog,
   explainMissingFeishuCredentialsAndExit,
   fileLog,
@@ -71,6 +72,7 @@ import {
   getTenantAccessToken,
   recallMessage,
   sendCardReply,
+  sendRawCard,
   sendTextReply,
   setChatAvatar,
   updateCardMessage,
@@ -79,12 +81,15 @@ import {
   sendRestartCard,
   verifyAllPermissions,
   reportPermissionResults,
-} from "./feishu-api.ts";
+  setPlatform,
+} from "./feishu-platform.ts";
 import { buildHelpCard, buildStatusCard, buildProgressCard, buildCdContent, buildCdCard, buildSessionsCard } from "./cards.ts";
 import { updateCardKitCard } from "./cardkit.ts";
 import { handleAgentImageRequest } from "./agent-image-rpc.ts";
 import { handleAgentFileRequest } from "./agent-file-rpc.ts";
 import { handleAgentGrantsRequest } from "./agent-grants-rpc.ts";
+import { SimulatedPlatform, SIM_DEFAULT_CHAT_ID } from "./sim-platform.ts";
+import { setMessageHandler } from "./sim-store.ts";
 import { formatGitResult, gitResultHeaderTemplate, runGitCommand } from "./git-command.ts";
 import {
   MAX_PROCESSED,
@@ -251,6 +256,53 @@ function parseCardAction(data: unknown): CardActionResult | null {
 
 let broadcastToRelay: (data: unknown) => void = () => {};
 
+// ---------------------------------------------------------------------------
+// Simulate mode: inject message via HTTP
+// ---------------------------------------------------------------------------
+
+async function handleSimInjectMessage(req: IncomingMessage, res: ServerResponse): Promise<boolean> {
+  const url = new URL(req.url ?? "/", "http://127.0.0.1");
+  if (url.pathname !== "/api/sim/inject-message") return false;
+  if (req.method !== "POST") {
+    res.writeHead(405, { "Content-Type": "application/json; charset=utf-8" });
+    res.end(JSON.stringify({ ok: false, error: "Method not allowed, use POST" }));
+    return true;
+  }
+
+  const chunks: Buffer[] = [];
+  for await (const chunk of req) { chunks.push(Buffer.from(chunk)); }
+  const body = Buffer.concat(chunks).toString("utf-8");
+  let parsed: { text?: string; chat_id?: string; open_id?: string; chat_type?: string };
+  try { parsed = JSON.parse(body); } catch {
+    res.writeHead(400, { "Content-Type": "application/json; charset=utf-8" });
+    res.end(JSON.stringify({ ok: false, error: "Invalid JSON body" }));
+    return true;
+  }
+
+  const text = parsed.text;
+  if (!text) {
+    res.writeHead(400, { "Content-Type": "application/json; charset=utf-8" });
+    res.end(JSON.stringify({ ok: false, error: "Missing 'text' field" }));
+    return true;
+  }
+
+  const chatId = parsed.chat_id || SIM_DEFAULT_CHAT_ID;
+  const openId = parsed.open_id || "sim_user_001";
+  const chatType = parsed.chat_type || "group";
+
+  console.log(`[${ts()}] [SIM:INJECT] chat=${chatId} text="${text.slice(0, 80)}"`);
+  appendChatLog(chatId, openId, text);
+
+  // Fire and forget: process command, respond 202 immediately
+  handleCommand(text, chatId, openId, Date.now(), chatType).catch((err) =>
+    console.error(`[${ts()}] [SIM:INJECT] handleCommand error: ${(err as Error).message}`)
+  );
+
+  res.writeHead(202, { "Content-Type": "application/json; charset=utf-8" });
+  res.end(JSON.stringify({ ok: true, chat_id: chatId }));
+  return true;
+}
+
 // ---------------------------------------------------------------------------
 // Command handler
 // ---------------------------------------------------------------------------
@@ -351,17 +403,9 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
       // /cd 无参数：展示卡片（含最近使用路径按钮）
       const recentDirs = await getRecentDirs();
       const card = buildCdCard(targetDir, withStats, recentDirs, sessionCwd);
-      const resp = await fetch(`${BASE_URL}/im/v1/messages?receive_id_type=chat_id`, {
-        method: "POST",
-        headers: {
-          Authorization: `Bearer ${cdToken}`,
-          "Content-Type": "application/json",
-        },
-        body: JSON.stringify({ receive_id: chatId, msg_type: "interactive", content: card }),
-      });
-      const respData: Record<string, any> = await resp.json().catch(() => ({}));
-      console.log(`[${ts()}] [CD] card sent, code=${respData.code}, msgId=${respData.data?.message_id ?? "N/A"}, recentDirs=${recentDirs.length}`);
-      logTrace(tid, "DONE", { outcome: "cd_card", code: respData.code, msgId: respData.data?.message_id });
+      const ok = await sendRawCard(cdToken, chatId, card);
+      console.log(`[${ts()}] [CD] card sent, ok=${ok}, recentDirs=${recentDirs.length}`);
+      logTrace(tid, "DONE", { outcome: "cd_card", ok });
     } else {
       // /cd <path>：切换目录，发送文本卡片
       const content = buildCdContent(targetDir, withStats, isUpdate, sessionCwd);
@@ -437,6 +481,9 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
       return;
     }
 
+    // 让新群的默认工作目录继承当前会话的 cwd
+    await setDefaultCwd(cwd, newChatId);
+
     const adapter = getAdapterForTool(tool);
     await sendCardReply(
       freshToken, newChatId, `${toolLabel} Session Ready`,
@@ -537,17 +584,9 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
           statusText.push(`**上下文 Token 数:** ~${status.lastContextTokens.toLocaleString()}`);
         }
         const card = buildStatusCard(statusText.join("\n"), isActive ? "blue" : "green");
-        const statusResp = await fetch(`${BASE_URL}/im/v1/messages?receive_id_type=chat_id`, {
-          method: "POST",
-          headers: {
-            Authorization: `Bearer ${freshToken}`,
-            "Content-Type": "application/json",
-          },
-          body: JSON.stringify({ receive_id: chatId, msg_type: "interactive", content: card }),
-        });
-        const statusRespData: Record<string, any> = await statusResp.json().catch(() => ({}));
-        console.log(`[${ts()}] [STATUS] card sent, code=${statusRespData.code}, msgId=${statusRespData.data?.message_id ?? "N/A"}`);
-        logTrace(tid, "DONE", { outcome: "status", code: statusRespData.code });
+        const ok = await sendRawCard(freshToken, chatId, card);
+        console.log(`[${ts()}] [STATUS] card sent, ok=${ok}`);
+        logTrace(tid, "DONE", { outcome: "status", ok });
         return;
       }
 
@@ -564,17 +603,9 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
           tool: s.tool,
         }));
         const card = buildSessionsCard(cardData);
-        const sessionsResp = await fetch(`${BASE_URL}/im/v1/messages?receive_id_type=chat_id`, {
-          method: "POST",
-          headers: {
-            Authorization: `Bearer ${freshToken}`,
-            "Content-Type": "application/json",
-          },
-          body: JSON.stringify({ receive_id: chatId, msg_type: "interactive", content: card }),
-        });
-        const sessionsRespData: Record<string, any> = await sessionsResp.json().catch(() => ({}));
-        console.log(`[${ts()}] [SESSIONS] card sent, code=${sessionsRespData.code}, count=${allSessions.length}`);
-        logTrace(tid, "DONE", { outcome: "sessions", code: sessionsRespData.code, count: allSessions.length });
+        const ok = await sendRawCard(freshToken, chatId, card);
+        console.log(`[${ts()}] [SESSIONS] card sent, ok=${ok}, count=${allSessions.length}`);
+        logTrace(tid, "DONE", { outcome: "sessions", ok, count: allSessions.length });
         return;
       }
 
@@ -757,21 +788,13 @@ async function handleCommand(text: string, chatId: string, openId: string, msgTi
   logTrace(tid, "SEND", { method: "help_card", chatId });
   const replyToken = await getTenantAccessToken();
   const card = buildHelpCard(text);
-  const helpResp = await fetch(`${BASE_URL}/im/v1/messages?receive_id_type=chat_id`, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${replyToken}`,
-      "Content-Type": "application/json",
-    },
-    body: JSON.stringify({ receive_id: chatId, msg_type: "interactive", content: card }),
-  });
-  const helpData = (await helpResp.json().catch(() => ({}))) as { code: number; msg?: string; data?: { message_id?: string } };
-  if (helpData.code !== 0) {
-    console.error(`[${ts()}] [SEND] help_card FAIL: chatId=${chatId} code=${helpData.code} msg="${helpData.msg ?? ""}"`);
-    logTrace(tid, "DONE", { outcome: "help_card_fail", code: helpData.code, msg: helpData.msg });
+  const ok = await sendRawCard(replyToken, chatId, card);
+  if (!ok) {
+    console.error(`[${ts()}] [SEND] help_card FAIL: chatId=${chatId}`);
+    logTrace(tid, "DONE", { outcome: "help_card_fail" });
   } else {
-    console.log(`[${ts()}] [SEND] help_card OK: chatId=${chatId} msgId=${helpData.data?.message_id ?? "N/A"}`);
-    logTrace(tid, "DONE", { outcome: "help_card_sent", msgId: helpData.data?.message_id });
+    console.log(`[${ts()}] [SEND] help_card OK: chatId=${chatId}`);
+    logTrace(tid, "DONE", { outcome: "help_card_sent" });
   }
 }
 
@@ -1053,6 +1076,55 @@ async function main(): Promise<void> {
   // server.close）——只负责诊断与默认致命退出，不替代清理逻辑。
   installCrashLogging({ flush: () => fileLog.flush() });
 
+  // 模拟模式：独立端口 18079，不与 SDK 实例冲突，不走飞书凭证/权限/WSClient
+  if (USE_SIMULATE) {
+    const SIM_PORT = 18079;
+    console.log("\n[Simulate] 模拟飞书环境模式");
+    setPlatform(SimulatedPlatform);
+    console.log("  已切换到 SimulatedPlatform（零飞书依赖）");
+    appendStartupTrace("main: simulate mode", { port: SIM_PORT });
+
+    // 注册消息处理器，让 SimAgent.sendMessage() 能进程内触发 handleCommand
+    setMessageHandler(
+      (text, chatId, openId, _ts, chatType, traceId) =>
+        handleCommand(text, chatId, openId, Date.now(), chatType, traceId),
+    );
+
+    setExtraApiHandler(async (req, res) => {
+      const injected = await handleSimInjectMessage(req, res);
+      if (injected) return true;
+      return (await handleAgentGrantsRequest(req, res)) || (await handleAgentImageRequest(req, res)) || (await handleAgentFileRequest(req, res));
+    });
+
+    const simServer = createServer(createUiRouter());
+    await new Promise<void>((resolveListen, rejectListen) => {
+      const onError = (err: NodeJS.ErrnoException): void => {
+        simServer.removeListener("listening", onListening);
+        rejectListen(err);
+      };
+      const onListening = (): void => {
+        simServer.removeListener("error", onError);
+        resolveListen();
+      };
+      simServer.once("error", onError);
+      simServer.once("listening", onListening);
+      simServer.listen(SIM_PORT, "127.0.0.1");
+    }).catch((err: NodeJS.ErrnoException) => {
+      console.error(`\n[启动] 监听失败：端口 ${SIM_PORT}（${err.code ?? "?"} — ${err.message}）`);
+      process.exit(1);
+    });
+
+    console.log(`\n${"=".repeat(60)}`);
+    console.log(`  ChatCCC — 模拟飞书环境模式`);
+    console.log(`${"=".repeat(60)}`);
+    console.log(`  发送消息: POST http://127.0.0.1:${SIM_PORT}/api/sim/inject-message`);
+    console.log(`  消息日志: ~/.chatccc/sim/messages.jsonl`);
+    console.log(`${"=".repeat(60)}\n`);
+
+    installShutdownHandlers(simServer);
+    return;
+  }
+
   if (Number.isNaN(CHATCCC_PORT) || CHATCCC_PORT < 1 || CHATCCC_PORT > 65535) {
     console.error("\n[启动] 预检失败: config.json 的 port 字段不是有效端口号（1–65535）。");
     console.error(`  当前配置: ${CHATCCC_PORT}`);

package/src/session.ts

@@ -25,7 +25,7 @@ import {
   sendCardKitMessage,
   updateCardKitCard,
 } from "./cardkit.ts";
-import { sendTextReply, setChatAvatar } from "./feishu-api.ts";
+import { sendTextReply, setChatAvatar } from "./feishu-platform.ts";
 import { logTrace } from "./trace.ts";
 import type { UnifiedBlock } from "./adapters/adapter-interface.ts";
 import type { ToolAdapter } from "./adapters/adapter-interface.ts";

package/src/sim-agent.ts

@@ -0,0 +1,156 @@
+/**
+ * sim-agent.ts — SimAgent: 模拟飞书用户的编程接口
+ *
+ * SimAgent 代表一个模拟飞书用户，提供纯代码 API：
+ * - sendMessage(): 发送消息给 bot
+ * - on("message"): 订阅 bot 和其他人的回复
+ * - on("invited_to_group"): 当被拉入群时收到通知
+ * - waitForReply(): Promise 模式等待 bot 回复
+ * - getMessages(): 查看会话历史消息
+ *
+ * 不依赖 UI，进程内直接调用，适合用于自动化测试和 Agent 编程。
+ */
+
+import { simStore, dispatchMessage, SIM_DEFAULT_CHAT_ID } from "./sim-store.ts";
+import type { SimAccount, SimMessage } from "./sim-store.ts";
+
+// ---------------------------------------------------------------------------
+// 类型
+// ---------------------------------------------------------------------------
+
+export type MessageEventCallback = (chatId: string, msg: SimMessage) => void;
+export type InvitedToGroupCallback = (chatId: string, userId: string) => void;
+
+export interface SimAgent {
+  /** 绑定的用户 ID */
+  userId: string;
+
+  /** 绑定的账户信息 */
+  account: SimAccount;
+
+  /**
+   * 发送文本消息。
+   * chatId 默认 sim_default；p2p 私聊需指定。
+   */
+  sendMessage(chatId: string, text: string): Promise<void>;
+
+  /** 创建与 bot 的私聊，返回 p2p chatId */
+  createP2pWithBot(): string;
+
+  /** 获取用户在指定会话中的消息历史 */
+  getMessages(chatId: string): SimMessage[];
+
+  /** 获取用户所属的所有会话 */
+  listChats(): { id: string; name: string; type: "p2p" | "group" }[];
+
+  // ---- 事件订阅 ----
+  /** 订阅消息事件（所有该用户所在群的消息） */
+  on(event: "message", handler: MessageEventCallback): void;
+  /** 订阅被拉入群事件 */
+  on(event: "invited_to_group", handler: InvitedToGroupCallback): void;
+  /** 取消订阅 */
+  off(event: string, handler: (...args: any[]) => void): void;
+
+  // ---- Promise 模式 ----
+  /**
+   * 等待指定会话的下一条 bot 回复。
+   * 超时返回 null（默认 30 秒）。
+   */
+  waitForReply(chatId: string, timeoutMs?: number): Promise<SimMessage | null>;
+}
+
+// ---------------------------------------------------------------------------
+// 实现
+// ---------------------------------------------------------------------------
+
+export function createSimAgent(userId: string): SimAgent {
+  const account = simStore.getAccount(userId);
+  if (!account) throw new Error(`Account "${userId}" not found. Register it in simStore first.`);
+  if (account.kind !== "user") throw new Error(`Account "${userId}" is not a user account.`);
+
+  // 确保用户有至少一个会话（bot 私聊自动创建）
+  simStore.createP2pChat(userId);
+
+  const agent: SimAgent = {
+    userId,
+    account,
+
+    async sendMessage(chatId, text) {
+      const chat = simStore.getChat(chatId);
+      if (!chat) throw new Error(`Chat "${chatId}" not found`);
+      if (!chat.memberIds.includes(userId)) {
+        throw new Error(`User "${userId}" is not a member of chat "${chatId}"`);
+      }
+      await dispatchMessage(text, chatId, userId, chat.type === "p2p" ? "p2p" : "group");
+    },
+
+    createP2pWithBot() {
+      const chat = simStore.createP2pChat(userId);
+      return chat.id;
+    },
+
+    getMessages(chatId) {
+      return simStore.getMessages(chatId, userId);
+    },
+
+    listChats() {
+      return simStore.getChatsForUser(userId).map((c) => ({
+        id: c.id,
+        name: c.name,
+        type: c.type,
+      }));
+    },
+
+    on(event, handler) {
+      if (event === "message") {
+        const filteredHandler = (payload: { chatId: string; message: SimMessage }) => {
+          // 只推送给该用户所在群的消息
+          const chat = simStore.getChat(payload.chatId);
+          if (chat && chat.memberIds.includes(userId)) {
+            handler(payload.chatId, payload.message);
+          }
+        };
+        // 保存映射以便 off 能移除
+        (handler as any).__filtered = filteredHandler;
+        simStore.on("message", filteredHandler);
+      } else if (event === "invited_to_group") {
+        const filteredHandler = (payload: { chatId: string; userId: string }) => {
+          if (payload.userId === userId) {
+            handler(payload.chatId, payload.userId);
+          }
+        };
+        (handler as any).__filtered = filteredHandler;
+        simStore.on("member_added", filteredHandler);
+      }
+    },
+
+    off(event, handler) {
+      const filtered = (handler as any).__filtered;
+      if (event === "message" && filtered) {
+        simStore.off("message", filtered);
+      } else if (event === "invited_to_group" && filtered) {
+        simStore.off("member_added", filtered);
+      }
+    },
+
+    waitForReply(chatId, timeoutMs = 30000) {
+      return new Promise((resolve) => {
+        const timer = setTimeout(() => {
+          agent.off("message", onMessage);
+          resolve(null);
+        }, timeoutMs);
+
+        const onMessage = (cid: string, msg: SimMessage) => {
+          if (cid === chatId && msg.senderId === "bot") {
+            clearTimeout(timer);
+            agent.off("message", onMessage);
+            resolve(msg);
+          }
+        };
+        agent.on("message", onMessage);
+      });
+    },
+  };
+
+  return agent;
+}