opencode-feishu-bot 0.1.0

package/dist/index.js

@@ -0,0 +1,4034 @@
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+
+// package.json
+var require_package = __commonJS((exports, module) => {
+  module.exports = {
+    name: "opencode-feishu-bot",
+    version: "0.1.0",
+    description: "飞书机器人，用于与 OpenCode AI 编程助手交互",
+    type: "module",
+    main: "./dist/index.js",
+    types: "./dist/index.d.ts",
+    exports: {
+      ".": {
+        types: "./dist/index.d.ts",
+        import: "./dist/index.js",
+        default: "./dist/index.js"
+      }
+    },
+    bin: {
+      "opencode-feishu-bot": "./bin/cli.js"
+    },
+    files: [
+      "dist",
+      "bin"
+    ],
+    scripts: {
+      start: "bun run src/index.ts",
+      dev: "bun --watch src/index.ts",
+      build: "bun run build:clean && bun run build:js && bun run build:types && bun run build:assets",
+      "build:clean": "rm -rf dist",
+      "build:js": "bun build ./src/index.ts --outdir ./dist --target node --format esm --packages external",
+      "build:types": "bunx tsc -p tsconfig.build.json",
+      "build:assets": "mkdir -p dist/database && cp src/database/schema.sql dist/database/",
+      test: "bun test",
+      "test:watch": "bun test --watch",
+      prepublishOnly: "bun run build",
+      prepack: "bun run build"
+    },
+    keywords: [
+      "feishu",
+      "lark",
+      "飞书",
+      "opencode",
+      "ai",
+      "chatbot",
+      "bot"
+    ],
+    author: "",
+    license: "MIT",
+    repository: {
+      type: "git",
+      url: "git+https://github.com/kylin1020/opencode-feishu-bot.git"
+    },
+    bugs: {
+      url: "https://github.com/kylin1020/opencode-feishu-bot/issues"
+    },
+    homepage: "https://github.com/kylin1020/opencode-feishu-bot#readme",
+    engines: {
+      bun: ">=1.2.0"
+    },
+    devDependencies: {
+      "@types/bun": "latest",
+      typescript: "^5"
+    },
+    peerDependencies: {
+      typescript: "^5"
+    },
+    peerDependenciesMeta: {
+      typescript: {
+        optional: true
+      }
+    },
+    dependencies: {
+      "@larksuiteoapi/node-sdk": "^1.58.0",
+      "@opencode-ai/sdk": "^1.1.47",
+      zod: "^4.3.6"
+    }
+  };
+});
+
+// src/config.ts
+import { z } from "zod";
+var envSchema = z.object({
+  FEISHU_APP_ID: z.string().min(1, "必须提供 FEISHU_APP_ID"),
+  FEISHU_APP_SECRET: z.string().min(1, "必须提供 FEISHU_APP_SECRET"),
+  ADMIN_USER_IDS: z.string().default(""),
+  DATABASE_PATH: z.string().default("./data/bot.db"),
+  LOG_LEVEL: z.enum(["debug", "info", "warn", "error"]).default("info"),
+  ALLOW_ALL_USERS: z.preprocess((v) => v === undefined ? true : v !== "false", z.boolean()).default(true),
+  PROJECTS: z.string().default(""),
+  MENU_SERVER_URL: z.string().optional(),
+  AVAILABLE_MODELS: z.string().default(""),
+  DEFAULT_MODEL: z.string().optional()
+});
+function loadConfig(overrides) {
+  const result = envSchema.safeParse(process.env);
+  if (!result.success) {
+    const errors = result.error.issues.map((e) => `${String(e.path.join("."))}: ${e.message}`).join(`
+`);
+    throw new Error(`配置验证失败:
+${errors}`);
+  }
+  const config = result.data;
+  if (overrides?.model) {
+    config.DEFAULT_MODEL = overrides.model;
+  }
+  if (overrides?.logLevel) {
+    config.LOG_LEVEL = overrides.logLevel;
+  }
+  return config;
+}
+function getAdminUserIds(config) {
+  return config.ADMIN_USER_IDS.split(",").map((id) => id.trim()).filter((id) => id.length > 0);
+}
+function getDefaultProjectPath(override) {
+  return override || process.cwd();
+}
+function getDefaultModel(config) {
+  return config.DEFAULT_MODEL;
+}
+function getProjects(config) {
+  if (!config.PROJECTS.trim()) {
+    return [];
+  }
+  return config.PROJECTS.split(",").map((item) => {
+    const [path, name] = item.split(":").map((s) => s.trim());
+    if (!path)
+      return null;
+    return { path, name: name || path };
+  }).filter((item) => item !== null);
+}
+function getAvailableModels(config) {
+  if (!config.AVAILABLE_MODELS.trim()) {
+    return [];
+  }
+  const models = [];
+  for (const item of config.AVAILABLE_MODELS.split(",")) {
+    const trimmed = item.trim();
+    if (!trimmed)
+      continue;
+    const lastColonIndex = trimmed.lastIndexOf(":");
+    if (lastColonIndex === -1) {
+      models.push({ id: trimmed });
+    } else {
+      const id = trimmed.slice(0, lastColonIndex).trim();
+      const name = trimmed.slice(lastColonIndex + 1).trim();
+      if (id) {
+        models.push(name ? { id, name } : { id });
+      }
+    }
+  }
+  return models;
+}
+function filterModels(allModels, configuredModels) {
+  if (configuredModels.length === 0) {
+    return allModels;
+  }
+  const result = [];
+  for (const configured of configuredModels) {
+    const found = allModels.find((m) => m.id === configured.id);
+    if (found) {
+      result.push(configured.name ? { ...found, name: configured.name } : found);
+    }
+  }
+  return result;
+}
+
+// src/cli.ts
+var ARG_DEFS = {
+  model: {
+    short: "m",
+    long: "model",
+    description: "设置默认模型 (格式: provider/model)",
+    hasValue: true,
+    envVar: "DEFAULT_MODEL"
+  },
+  project: {
+    short: "p",
+    long: "project",
+    description: "设置默认项目目录",
+    hasValue: true
+  },
+  logLevel: {
+    short: "l",
+    long: "log-level",
+    description: "日志级别 (debug|info|warn|error)",
+    hasValue: true,
+    envVar: "LOG_LEVEL"
+  },
+  help: {
+    short: "h",
+    long: "help",
+    description: "显示帮助信息",
+    hasValue: false
+  },
+  version: {
+    short: "v",
+    long: "version",
+    description: "显示版本号",
+    hasValue: false
+  },
+  listModels: {
+    long: "list-models",
+    description: "列出可用模型并退出",
+    hasValue: false
+  }
+};
+function parseArgs(args = process.argv.slice(2)) {
+  const options = {};
+  let i = 0;
+  while (i < args.length) {
+    const arg = args[i];
+    if (!arg || !arg.startsWith("-") && !arg.startsWith("--")) {
+      i++;
+      continue;
+    }
+    let key;
+    let value;
+    if (arg.startsWith("--")) {
+      const longArg = arg.slice(2);
+      const eqIndex = longArg.indexOf("=");
+      if (eqIndex >= 0) {
+        const longName = longArg.slice(0, eqIndex);
+        value = longArg.slice(eqIndex + 1);
+        key = findKeyByLong(longName);
+      } else {
+        key = findKeyByLong(longArg);
+        const def = key ? ARG_DEFS[key] : undefined;
+        const nextArg = args[i + 1];
+        if (def?.hasValue && nextArg && !nextArg.startsWith("-")) {
+          value = args[++i];
+        }
+      }
+    } else if (arg.startsWith("-")) {
+      const shortArg = arg.slice(1);
+      key = findKeyByShort(shortArg);
+      const def = key ? ARG_DEFS[key] : undefined;
+      const nextArg = args[i + 1];
+      if (def?.hasValue && nextArg && !nextArg.startsWith("-")) {
+        value = args[++i];
+      }
+    }
+    if (key) {
+      const def = ARG_DEFS[key];
+      if (def.hasValue) {
+        options[key] = value;
+      } else {
+        options[key] = true;
+      }
+    }
+    i++;
+  }
+  return options;
+}
+function findKeyByLong(long) {
+  for (const [key, def] of Object.entries(ARG_DEFS)) {
+    if (def.long === long) {
+      return key;
+    }
+  }
+  return;
+}
+function findKeyByShort(short) {
+  for (const [key, def] of Object.entries(ARG_DEFS)) {
+    if (def.short === short) {
+      return key;
+    }
+  }
+  return;
+}
+function formatHelp() {
+  const lines = [
+    "OpenCode 飞书机器人",
+    "",
+    "用法: opencode-feishu-bot [选项]",
+    "",
+    "选项:"
+  ];
+  for (const [, def] of Object.entries(ARG_DEFS)) {
+    const shortPart = def.short ? `-${def.short}, ` : "    ";
+    const longPart = `--${def.long}`;
+    const valuePart = def.hasValue ? " <value>" : "";
+    lines.push(`  ${shortPart}${longPart}${valuePart}`);
+    lines.push(`        ${def.description}`);
+  }
+  lines.push("");
+  lines.push("环境变量:");
+  lines.push("  FEISHU_APP_ID        飞书应用 ID (必需)");
+  lines.push("  FEISHU_APP_SECRET    飞书应用密钥 (必需)");
+  lines.push("  DEFAULT_MODEL        默认模型 (可被 --model 覆盖)");
+  lines.push("  AVAILABLE_MODELS     可用模型列表 (逗号分隔)");
+  lines.push("  PROJECTS             预配置项目列表");
+  lines.push("  DATABASE_PATH        数据库路径 (默认: ./data/bot.db)");
+  lines.push("  LOG_LEVEL            日志级别 (默认: info)");
+  lines.push("");
+  lines.push("示例:");
+  lines.push("  # 使用指定模型启动");
+  lines.push("  opencode-feishu-bot --model anthropic/claude-sonnet-4-20250514");
+  lines.push("");
+  lines.push("  # 指定项目目录启动");
+  lines.push("  opencode-feishu-bot -p /path/to/project");
+  lines.push("");
+  lines.push("  # 列出可用模型");
+  lines.push("  opencode-feishu-bot --list-models");
+  return lines.join(`
+`);
+}
+function getVersion() {
+  try {
+    const pkg = require_package();
+    return pkg.version || "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+function isValidLogLevel(level) {
+  return ["debug", "info", "warn", "error"].includes(level);
+}
+
+// src/utils/logger.ts
+var LOG_LEVELS = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var currentLevel = "info";
+function setLogLevel(level) {
+  currentLevel = level;
+}
+function shouldLog(level) {
+  return LOG_LEVELS[level] >= LOG_LEVELS[currentLevel];
+}
+function formatMessage(level, message, data) {
+  const timestamp = new Date().toISOString();
+  const prefix = `[${timestamp}] [${level.toUpperCase()}]`;
+  if (data !== undefined) {
+    return `${prefix} ${message} ${JSON.stringify(data)}`;
+  }
+  return `${prefix} ${message}`;
+}
+var logger = {
+  debug(message, data) {
+    if (shouldLog("debug")) {
+      console.debug(formatMessage("debug", message, data));
+    }
+  },
+  info(message, data) {
+    if (shouldLog("info")) {
+      console.info(formatMessage("info", message, data));
+    }
+  },
+  warn(message, data) {
+    if (shouldLog("warn")) {
+      console.warn(formatMessage("warn", message, data));
+    }
+  },
+  error(message, data) {
+    if (shouldLog("error")) {
+      console.error(formatMessage("error", message, data));
+    }
+  }
+};
+
+// src/database/index.ts
+import { Database } from "bun:sqlite";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { mkdirSync, existsSync } from "node:fs";
+var __dirname2 = dirname(fileURLToPath(import.meta.url));
+
+class BotDatabase {
+  db;
+  dedupWindowMs;
+  constructor(dbPath, dedupWindowMs = 5 * 60 * 1000) {
+    if (dbPath !== ":memory:") {
+      const dir = dirname(dbPath);
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+      }
+    }
+    this.db = new Database(dbPath);
+    this.dedupWindowMs = dedupWindowMs;
+    this.initialize();
+  }
+  initialize() {
+    const schemaPath = join(__dirname2, "schema.sql");
+    const schema = readFileSync(schemaPath, "utf-8");
+    this.db.exec(schema);
+  }
+  getSession(chatId) {
+    const stmt = this.db.prepare("SELECT * FROM user_sessions WHERE chat_id = ?");
+    return stmt.get(chatId) ?? null;
+  }
+  upsertSession(chatId, sessionId, projectPath) {
+    const stmt = this.db.prepare(`
+      INSERT INTO user_sessions (chat_id, session_id, project_path, updated_at)
+      VALUES (?, ?, ?, CURRENT_TIMESTAMP)
+      ON CONFLICT(chat_id) DO UPDATE SET
+        session_id = excluded.session_id,
+        project_path = excluded.project_path,
+        updated_at = CURRENT_TIMESTAMP
+    `);
+    stmt.run(chatId, sessionId, projectPath);
+  }
+  deleteSession(chatId) {
+    const stmt = this.db.prepare("DELETE FROM user_sessions WHERE chat_id = ?");
+    const result = stmt.run(chatId);
+    return result.changes > 0;
+  }
+  isUserWhitelisted(userId) {
+    const stmt = this.db.prepare("SELECT COUNT(*) as count FROM user_whitelist WHERE user_id = ?");
+    const result = stmt.get(userId);
+    return (result?.count ?? 0) > 0;
+  }
+  addToWhitelist(userId, addedBy) {
+    try {
+      const stmt = this.db.prepare(`
+        INSERT INTO user_whitelist (user_id, added_by)
+        VALUES (?, ?)
+        ON CONFLICT(user_id) DO NOTHING
+      `);
+      const result = stmt.run(userId, addedBy);
+      return result.changes > 0;
+    } catch {
+      return false;
+    }
+  }
+  removeFromWhitelist(userId) {
+    const stmt = this.db.prepare("DELETE FROM user_whitelist WHERE user_id = ?");
+    const result = stmt.run(userId);
+    return result.changes > 0;
+  }
+  getWhitelistedUsers() {
+    const stmt = this.db.prepare("SELECT * FROM user_whitelist");
+    return stmt.all();
+  }
+  getProjectPath(chatId) {
+    const stmt = this.db.prepare("SELECT * FROM project_mappings WHERE chat_id = ?");
+    const result = stmt.get(chatId);
+    return result?.project_path ?? null;
+  }
+  setProjectPath(chatId, projectPath) {
+    const stmt = this.db.prepare(`
+      INSERT INTO project_mappings (chat_id, project_path, updated_at)
+      VALUES (?, ?, CURRENT_TIMESTAMP)
+      ON CONFLICT(chat_id) DO UPDATE SET
+        project_path = excluded.project_path,
+        updated_at = CURRENT_TIMESTAMP
+    `);
+    stmt.run(chatId, projectPath);
+  }
+  isEventProcessed(eventId) {
+    const stmt = this.db.prepare("SELECT COUNT(*) as count FROM event_dedup WHERE event_id = ?");
+    const result = stmt.get(eventId);
+    return (result?.count ?? 0) > 0;
+  }
+  markEventProcessed(eventId) {
+    if (this.isEventProcessed(eventId)) {
+      return false;
+    }
+    const stmt = this.db.prepare("INSERT INTO event_dedup (event_id) VALUES (?)");
+    stmt.run(eventId);
+    return true;
+  }
+  cleanupOldEvents() {
+    const cutoff = new Date(Date.now() - this.dedupWindowMs).toISOString();
+    const stmt = this.db.prepare("DELETE FROM event_dedup WHERE processed_at < ?");
+    const result = stmt.run(cutoff);
+    return result.changes;
+  }
+  saveMessageMapping(userMessageId, chatId) {
+    const stmt = this.db.prepare(`
+      INSERT OR REPLACE INTO message_mappings (user_message_id, chat_id)
+      VALUES (?, ?)
+    `);
+    stmt.run(userMessageId, chatId);
+  }
+  updateBotMessageId(userMessageId, botMessageId) {
+    const stmt = this.db.prepare(`
+      UPDATE message_mappings SET bot_message_id = ? WHERE user_message_id = ?
+    `);
+    stmt.run(botMessageId, userMessageId);
+  }
+  getMessageMapping(userMessageId) {
+    const stmt = this.db.prepare("SELECT * FROM message_mappings WHERE user_message_id = ?");
+    return stmt.get(userMessageId) ?? null;
+  }
+  deleteMessageMapping(userMessageId) {
+    const stmt = this.db.prepare("DELETE FROM message_mappings WHERE user_message_id = ?");
+    const result = stmt.run(userMessageId);
+    return result.changes > 0;
+  }
+  getMessageMappingsAfter(userMessageId, chatId) {
+    const targetMapping = this.getMessageMapping(userMessageId);
+    if (!targetMapping) {
+      return [];
+    }
+    const stmt = this.db.prepare(`
+      SELECT * FROM message_mappings 
+      WHERE chat_id = ? AND created_at >= ?
+      ORDER BY created_at ASC
+    `);
+    return stmt.all(chatId, targetMapping.created_at);
+  }
+  deleteMessageMappings(userMessageIds) {
+    if (userMessageIds.length === 0)
+      return 0;
+    const placeholders = userMessageIds.map(() => "?").join(",");
+    const stmt = this.db.prepare(`DELETE FROM message_mappings WHERE user_message_id IN (${placeholders})`);
+    const result = stmt.run(...userMessageIds);
+    return result.changes;
+  }
+  deleteMessageMappingsByChatId(chatId) {
+    const stmt = this.db.prepare("DELETE FROM message_mappings WHERE chat_id = ?");
+    const result = stmt.run(chatId);
+    return result.changes;
+  }
+  cleanupOldMessageMappings(maxAgeMs = 24 * 60 * 60 * 1000) {
+    const cutoff = new Date(Date.now() - maxAgeMs).toISOString();
+    const stmt = this.db.prepare("DELETE FROM message_mappings WHERE created_at < ?");
+    const result = stmt.run(cutoff);
+    return result.changes;
+  }
+  createSessionChat(chatId, sessionId, ownerId, projectPath) {
+    const stmt = this.db.prepare(`
+      INSERT INTO session_chats (chat_id, session_id, owner_id, project_path)
+      VALUES (?, ?, ?, ?)
+    `);
+    stmt.run(chatId, sessionId, ownerId, projectPath);
+  }
+  getSessionChat(chatId) {
+    const stmt = this.db.prepare("SELECT * FROM session_chats WHERE chat_id = ?");
+    return stmt.get(chatId) ?? null;
+  }
+  getSessionChatsByOwner(ownerId) {
+    const stmt = this.db.prepare("SELECT * FROM session_chats WHERE owner_id = ? ORDER BY created_at DESC");
+    return stmt.all(ownerId);
+  }
+  updateSessionChatTitle(chatId, title) {
+    const stmt = this.db.prepare(`
+      UPDATE session_chats 
+      SET title = ?, title_set = TRUE, updated_at = CURRENT_TIMESTAMP 
+      WHERE chat_id = ?
+    `);
+    stmt.run(title, chatId);
+  }
+  deleteSessionChat(chatId) {
+    const stmt = this.db.prepare("DELETE FROM session_chats WHERE chat_id = ?");
+    const result = stmt.run(chatId);
+    return result.changes > 0;
+  }
+  isSessionChat(chatId) {
+    const stmt = this.db.prepare("SELECT COUNT(*) as count FROM session_chats WHERE chat_id = ?");
+    const result = stmt.get(chatId);
+    return (result?.count ?? 0) > 0;
+  }
+  close() {
+    this.db.close();
+  }
+}
+var defaultDb = null;
+function initializeDatabase(dbPath) {
+  if (defaultDb) {
+    defaultDb.close();
+  }
+  defaultDb = new BotDatabase(dbPath);
+  return defaultDb;
+}
+
+// src/feishu/client.ts
+import * as Lark from "@larksuiteoapi/node-sdk";
+class FeishuClient {
+  client;
+  wsClient;
+  appId;
+  appSecret;
+  messageHandler = null;
+  botAddedHandler = null;
+  messageRecalledHandler = null;
+  botRemovedHandler = null;
+  botMenuHandler = null;
+  userLeftChatHandler = null;
+  chatDisbandedHandler = null;
+  cardActionHandler = null;
+  isConnected = false;
+  constructor(config) {
+    this.appId = config.appId;
+    this.appSecret = config.appSecret;
+    const baseConfig = {
+      appId: config.appId,
+      appSecret: config.appSecret,
+      domain: config.domain ?? Lark.Domain.Feishu
+    };
+    this.client = new Lark.Client(baseConfig);
+    this.wsClient = new Lark.WSClient({
+      appId: config.appId,
+      appSecret: config.appSecret,
+      loggerLevel: Lark.LoggerLevel.error
+    });
+  }
+  onMessage(handler) {
+    this.messageHandler = handler;
+  }
+  onBotAdded(handler) {
+    this.botAddedHandler = handler;
+  }
+  onMessageRecalled(handler) {
+    this.messageRecalledHandler = handler;
+  }
+  onBotRemoved(handler) {
+    this.botRemovedHandler = handler;
+  }
+  onBotMenu(handler) {
+    this.botMenuHandler = handler;
+  }
+  onUserLeftChat(handler) {
+    this.userLeftChatHandler = handler;
+  }
+  onChatDisbanded(handler) {
+    this.chatDisbandedHandler = handler;
+  }
+  onCardAction(handler) {
+    this.cardActionHandler = handler;
+  }
+  async start() {
+    if (this.isConnected) {
+      logger.warn("飞书客户端已连接");
+      return;
+    }
+    const eventDispatcher = new Lark.EventDispatcher({}).register({
+      "im.message.receive_v1": async (data) => {
+        try {
+          await this.handleMessageEvent(data);
+        } catch (error) {
+          logger.error("处理消息事件时出错", error);
+        }
+      },
+      "im.chat.member.bot.added_v1": async (data) => {
+        try {
+          await this.handleBotAddedEvent(data);
+        } catch (error) {
+          logger.error("处理机器人进群事件时出错", error);
+        }
+      },
+      "im.message.recalled_v1": async (data) => {
+        try {
+          await this.handleMessageRecalledEvent(data);
+        } catch (error) {
+          logger.error("处理消息撤回事件时出错", error);
+        }
+      },
+      "im.chat.member.bot.deleted_v1": async (data) => {
+        try {
+          await this.handleBotRemovedEvent(data);
+        } catch (error) {
+          logger.error("处理机器人移出群事件时出错", error);
+        }
+      },
+      "application.bot.menu_v6": async (data) => {
+        try {
+          await this.handleBotMenuEvent(data);
+        } catch (error) {
+          logger.error("处理菜单点击事件时出错", error);
+        }
+      },
+      "im.chat.member.user.deleted_v1": async (data) => {
+        try {
+          await this.handleUserLeftChatEvent(data);
+        } catch (error) {
+          logger.error("处理用户退群事件时出错", error);
+        }
+      },
+      "im.chat.disbanded_v1": async (data) => {
+        try {
+          await this.handleChatDisbandedEvent(data);
+        } catch (error) {
+          logger.error("处理群解散事件时出错", error);
+        }
+      },
+      "card.action.trigger": async (data) => {
+        try {
+          await this.handleCardActionEvent(data);
+        } catch (error) {
+          logger.error("处理卡片交互事件时出错", error);
+        }
+      }
+    });
+    await this.wsClient.start({ eventDispatcher });
+    this.isConnected = true;
+    logger.info("飞书 WebSocket 已连接");
+  }
+  async handleMessageEvent(rawData) {
+    const data = this.extractEventData(rawData);
+    if (!data) {
+      logger.warn("无效的消息事件结构");
+      return;
+    }
+    const { header, event } = data;
+    if (!event?.message || !event?.sender) {
+      logger.warn("无效的消息事件：缺少 message 或 sender");
+      return;
+    }
+    const chatType = event.message.chat_type;
+    const mentions = event.message.mentions?.map((m) => ({
+      key: m.key ?? "",
+      id: m.id?.open_id ?? "",
+      name: m.name ?? ""
+    }));
+    const messageEvent = {
+      eventId: header?.event_id ?? "",
+      messageId: event.message.message_id ?? "",
+      chatId: event.message.chat_id ?? "",
+      chatType,
+      senderId: event.sender.sender_id?.open_id ?? "",
+      senderType: event.sender.sender_type ?? "",
+      messageType: event.message.message_type ?? "",
+      content: event.message.content ?? "",
+      createTime: event.message.create_time ?? "",
+      mentions
+    };
+    if (this.messageHandler) {
+      await this.messageHandler(messageEvent);
+    }
+  }
+  async handleBotAddedEvent(rawData) {
+    if (!rawData || typeof rawData !== "object") {
+      logger.warn("无效的机器人进群事件结构");
+      return;
+    }
+    const data = rawData;
+    const eventId = data.event_id ?? "";
+    const chatId = data.chat_id ?? "";
+    const operatorId = data.operator_id?.open_id ?? "";
+    const chatName = data.name ?? data.i18n_names?.zh_cn;
+    if (!chatId) {
+      logger.warn("机器人进群事件缺少 chat_id");
+      return;
+    }
+    const event = { eventId, chatId, operatorId, chatName };
+    if (this.botAddedHandler) {
+      await this.botAddedHandler(event);
+    }
+  }
+  async handleMessageRecalledEvent(rawData) {
+    if (!rawData || typeof rawData !== "object") {
+      logger.warn("无效的消息撤回事件结构");
+      return;
+    }
+    const data = rawData;
+    const eventId = data.event_id ?? "";
+    const messageId = data.message_id ?? "";
+    const chatId = data.chat_id ?? "";
+    const recallTime = data.recall_time ?? "";
+    const recallType = data.recall_type ?? "message_owner";
+    if (!messageId) {
+      logger.warn("消息撤回事件缺少 message_id");
+      return;
+    }
+    const event = { eventId, messageId, chatId, recallTime, recallType };
+    if (this.messageRecalledHandler) {
+      await this.messageRecalledHandler(event);
+    }
+  }
+  async handleBotRemovedEvent(rawData) {
+    if (!rawData || typeof rawData !== "object") {
+      logger.warn("无效的机器人移出群事件结构");
+      return;
+    }
+    const data = rawData;
+    const eventId = data.event_id ?? "";
+    const chatId = data.chat_id ?? "";
+    const operatorId = data.operator_id?.open_id ?? "";
+    if (!chatId) {
+      logger.warn("机器人移出群事件缺少 chat_id");
+      return;
+    }
+    const event = { eventId, chatId, operatorId };
+    if (this.botRemovedHandler) {
+      await this.botRemovedHandler(event);
+    }
+  }
+  async handleBotMenuEvent(rawData) {
+    if (!rawData || typeof rawData !== "object") {
+      logger.warn("无效的菜单点击事件结构");
+      return;
+    }
+    const data = rawData;
+    const eventId = data.event_id ?? "";
+    const eventKey = data.event_key ?? "";
+    const timestamp = data.timestamp ?? "";
+    const operator = data.operator;
+    const operatorId = operator?.operator_id?.open_id ?? "";
+    const operatorName = operator?.operator_name;
+    if (!eventKey) {
+      logger.warn("菜单点击事件缺少 event_key");
+      return;
+    }
+    const event = {
+      eventId,
+      eventKey,
+      operatorId,
+      operatorName,
+      timestamp
+    };
+    if (this.botMenuHandler) {
+      await this.botMenuHandler(event);
+    }
+  }
+  async handleUserLeftChatEvent(rawData) {
+    if (!rawData || typeof rawData !== "object") {
+      logger.warn("无效的用户退群事件结构");
+      return;
+    }
+    const data = rawData;
+    const eventId = data.event_id ?? "";
+    const chatId = data.chat_id ?? "";
+    const operatorId = data.operator_id?.open_id ?? "";
+    const chatName = data.name ?? data.i18n_names?.zh_cn;
+    const rawUsers = data.users;
+    const users = rawUsers?.map((u) => ({
+      userId: u.user_id?.open_id ?? "",
+      name: u.name
+    })) ?? [];
+    if (!chatId) {
+      logger.warn("用户退群事件缺少 chat_id");
+      return;
+    }
+    const event = { eventId, chatId, operatorId, users, chatName };
+    if (this.userLeftChatHandler) {
+      await this.userLeftChatHandler(event);
+    }
+  }
+  async handleChatDisbandedEvent(rawData) {
+    if (!rawData || typeof rawData !== "object") {
+      logger.warn("无效的群解散事件结构");
+      return;
+    }
+    const data = rawData;
+    const eventId = data.event_id ?? "";
+    const chatId = data.chat_id ?? "";
+    const operatorId = data.operator_id?.open_id ?? "";
+    const chatName = data.name ?? data.i18n_names?.zh_cn;
+    if (!chatId) {
+      logger.warn("群解散事件缺少 chat_id");
+      return;
+    }
+    const event = { eventId, chatId, operatorId, chatName };
+    if (this.chatDisbandedHandler) {
+      await this.chatDisbandedHandler(event);
+    }
+  }
+  async handleCardActionEvent(rawData) {
+    if (!rawData || typeof rawData !== "object") {
+      logger.warn("无效的卡片交互事件结构");
+      return;
+    }
+    const data = rawData;
+    const eventId = data.event_id ?? "";
+    const operatorId = data.operator_id?.open_id ?? "";
+    const openChatId = data.open_chat_id ?? undefined;
+    const openMessageId = data.open_message_id ?? undefined;
+    const actionData = data.action;
+    if (!actionData) {
+      logger.warn("卡片交互事件缺少 action");
+      return;
+    }
+    const event = {
+      eventId,
+      operatorId,
+      chatId: openChatId,
+      messageId: openMessageId,
+      action: {
+        tag: actionData.tag ?? "",
+        value: actionData.value ?? {},
+        option: actionData.option
+      }
+    };
+    if (this.cardActionHandler) {
+      await this.cardActionHandler(event);
+    }
+  }
+  extractEventData(rawData) {
+    if (!rawData || typeof rawData !== "object") {
+      return null;
+    }
+    const data = rawData;
+    let header = data.header;
+    let event = data.event;
+    if (!event && data.message) {
+      const senderData = data.sender;
+      const messageData = data.message;
+      event = {
+        sender: senderData,
+        message: messageData
+      };
+      header = { event_id: data.event_id };
+    }
+    return { header, event };
+  }
+  async sendMessage(chatId, content, msgType = "text") {
+    try {
+      const response = await this.client.im.v1.message.create({
+        params: { receive_id_type: "chat_id" },
+        data: {
+          receive_id: chatId,
+          msg_type: msgType,
+          content
+        }
+      });
+      if (response.code !== 0) {
+        logger.error("发送消息失败", { code: response.code, msg: response.msg });
+        return null;
+      }
+      return response.data?.message_id ?? null;
+    } catch (error) {
+      logger.error("发送消息时出错", error);
+      return null;
+    }
+  }
+  async sendMessageToUser(userId, content, msgType = "text") {
+    try {
+      const response = await this.client.im.v1.message.create({
+        params: { receive_id_type: "open_id" },
+        data: {
+          receive_id: userId,
+          msg_type: msgType,
+          content
+        }
+      });
+      if (response.code !== 0) {
+        logger.error("发送用户消息失败", { code: response.code, msg: response.msg });
+        return null;
+      }
+      return response.data?.message_id ?? null;
+    } catch (error) {
+      logger.error("发送用户消息时出错", error);
+      return null;
+    }
+  }
+  async sendCardToUser(userId, card) {
+    const content = JSON.stringify(card);
+    return this.sendMessageToUser(userId, content, "interactive");
+  }
+  async sendTextMessage(chatId, text) {
+    const content = JSON.stringify({ text });
+    return this.sendMessage(chatId, content, "text");
+  }
+  async sendCard(chatId, card) {
+    const content = JSON.stringify(card);
+    return this.sendMessage(chatId, content, "interactive");
+  }
+  async updateCard(messageId, card) {
+    try {
+      const response = await this.client.im.v1.message.patch({
+        path: { message_id: messageId },
+        data: {
+          content: JSON.stringify(card)
+        }
+      });
+      if (response.code !== 0) {
+        const isRateLimited = response.code === 230020;
+        if (!isRateLimited) {
+          logger.error("更新卡片失败", { code: response.code, msg: response.msg });
+        }
+        return { success: false, rateLimited: isRateLimited };
+      }
+      return { success: true };
+    } catch (error) {
+      const axiosError = error;
+      const isRateLimited = axiosError?.response?.data?.code === 230020;
+      if (!isRateLimited) {
+        logger.error("更新卡片时出错", error);
+      }
+      return { success: false, rateLimited: isRateLimited };
+    }
+  }
+  async deleteMessage(messageId) {
+    try {
+      const response = await this.client.im.v1.message.delete({
+        path: { message_id: messageId }
+      });
+      if (response.code !== 0) {
+        logger.error("撤回消息失败", { code: response.code, msg: response.msg });
+        return false;
+      }
+      return true;
+    } catch (error) {
+      logger.error("撤回消息时出错", error);
+      return false;
+    }
+  }
+  async createChat(name, userIds) {
+    try {
+      const response = await this.client.im.v1.chat.create({
+        params: {
+          user_id_type: "open_id",
+          set_bot_manager: true
+        },
+        data: {
+          name,
+          user_id_list: userIds,
+          chat_type: "private",
+          join_message_visibility: "only_owner",
+          leave_message_visibility: "only_owner",
+          membership_approval: "no_approval_required"
+        }
+      });
+      if (response.code !== 0) {
+        logger.error("创建群失败", { code: response.code, msg: response.msg });
+        return null;
+      }
+      const chatId = response.data?.chat_id;
+      if (!chatId) {
+        logger.error("创建群成功但未返回 chat_id");
+        return null;
+      }
+      return { chatId };
+    } catch (error) {
+      logger.error("创建群时出错", error);
+      return null;
+    }
+  }
+  async updateChatName(chatId, name) {
+    try {
+      const response = await this.client.im.v1.chat.update({
+        path: { chat_id: chatId },
+        data: { name }
+      });
+      if (response.code !== 0) {
+        logger.error("更新群名失败", { code: response.code, msg: response.msg });
+        return false;
+      }
+      return true;
+    } catch (error) {
+      logger.error("更新群名时出错", error);
+      return false;
+    }
+  }
+  async deleteChat(chatId) {
+    try {
+      const response = await this.client.im.v1.chat.delete({
+        path: { chat_id: chatId }
+      });
+      if (response.code !== 0) {
+        logger.error("解散群失败", { code: response.code, msg: response.msg });
+        return false;
+      }
+      return true;
+    } catch (error) {
+      logger.error("解散群时出错", error);
+      return false;
+    }
+  }
+  async getChatInfo(chatId) {
+    try {
+      const response = await this.client.im.v1.chat.get({
+        path: { chat_id: chatId },
+        params: { user_id_type: "open_id" }
+      });
+      if (response.code !== 0) {
+        logger.error("获取群信息失败", { code: response.code, msg: response.msg });
+        return null;
+      }
+      return {
+        name: response.data?.name,
+        userCount: response.data?.user_count ? parseInt(response.data.user_count, 10) : undefined
+      };
+    } catch (error) {
+      logger.error("获取群信息时出错", error);
+      return null;
+    }
+  }
+  async pinMessage(messageId) {
+    try {
+      const response = await this.client.im.v1.pin.create({
+        data: { message_id: messageId }
+      });
+      if (response.code !== 0) {
+        logger.error("置顶消息失败", { code: response.code, msg: response.msg, messageId });
+        return false;
+      }
+      logger.info("置顶消息成功", { messageId });
+      return true;
+    } catch (error) {
+      logger.error("置顶消息时出错", { messageId, error });
+      return false;
+    }
+  }
+  async unpinMessage(messageId) {
+    try {
+      const response = await this.client.im.v1.pin.delete({
+        path: { message_id: messageId }
+      });
+      if (response.code !== 0) {
+        logger.error("取消置顶失败", { code: response.code, msg: response.msg, messageId });
+        return false;
+      }
+      return true;
+    } catch (error) {
+      logger.error("取消置顶时出错", { messageId, error });
+      return false;
+    }
+  }
+  async createChatMenu(chatId, menuTree) {
+    try {
+      const response = await this.client.im.v1.chatMenuTree.create({
+        path: { chat_id: chatId },
+        data: { menu_tree: menuTree }
+      });
+      if (response.code !== 0) {
+        logger.error("创建群聊菜单失败", { code: response.code, msg: response.msg, chatId });
+        return false;
+      }
+      logger.info("创建群聊菜单成功", { chatId });
+      return true;
+    } catch (error) {
+      logger.error("创建群聊菜单时出错", { chatId, error });
+      return false;
+    }
+  }
+  async deleteChatMenu(chatId, menuIds) {
+    try {
+      const response = await this.client.im.v1.chatMenuTree.delete({
+        path: { chat_id: chatId },
+        data: {
+          chat_menu_top_level_ids: menuIds
+        }
+      });
+      if (response.code !== 0) {
+        logger.error("删除群聊菜单失败", { code: response.code, msg: response.msg, chatId });
+        return false;
+      }
+      return true;
+    } catch (error) {
+      logger.error("删除群聊菜单时出错", { chatId, error });
+      return false;
+    }
+  }
+  async getChatMenu(chatId) {
+    try {
+      const response = await this.client.im.v1.chatMenuTree.get({
+        path: { chat_id: chatId }
+      });
+      if (response.code !== 0) {
+        logger.error("获取群聊菜单失败", { code: response.code, msg: response.msg, chatId });
+        return null;
+      }
+      return response.data?.menu_tree ?? null;
+    } catch (error) {
+      logger.error("获取群聊菜单时出错", { chatId, error });
+      return null;
+    }
+  }
+  async getMessageImage(messageId, imageKey) {
+    const maxRetries = 3;
+    for (let attempt = 1;attempt <= maxRetries; attempt++) {
+      try {
+        const tokenResponse = await fetch("https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            app_id: this.appId,
+            app_secret: this.appSecret
+          })
+        });
+        const tokenData = await tokenResponse.json();
+        if (!tokenData.tenant_access_token) {
+          logger.error("获取 access token 失败", { code: tokenData.code, msg: tokenData.msg });
+          return null;
+        }
+        const url = `https://open.feishu.cn/open-apis/im/v1/messages/${messageId}/resources/${imageKey}?type=image`;
+        const response = await fetch(url, {
+          method: "GET",
+          headers: { Authorization: `Bearer ${tokenData.tenant_access_token}` }
+        });
+        if (!response.ok) {
+          logger.error("图片请求失败", { status: response.status, messageId, imageKey });
+          return null;
+        }
+        const arrayBuffer = await response.arrayBuffer();
+        const data = Buffer.from(arrayBuffer);
+        const contentType = response.headers.get("content-type") || "image/png";
+        return { data, mimeType: contentType };
+      } catch (error) {
+        if (attempt === maxRetries) {
+          logger.error("获取消息图片失败", { messageId, imageKey, error });
+          return null;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 1000 * attempt));
+      }
+    }
+    return null;
+  }
+  getApiClient() {
+    return this.client;
+  }
+  isReady() {
+    return this.isConnected;
+  }
+  async stop() {
+    this.isConnected = false;
+    logger.info("飞书客户端已停止");
+  }
+}
+function parseTextContent(content) {
+  try {
+    const parsed = JSON.parse(content);
+    return parsed.text ?? "";
+  } catch {
+    return "";
+  }
+}
+function parseImageContent(content) {
+  try {
+    const parsed = JSON.parse(content);
+    return parsed.image_key ?? null;
+  } catch {
+    return null;
+  }
+}
+function cleanMentionsFromText(text, mentions) {
+  if (!mentions || mentions.length === 0)
+    return text;
+  let cleaned = text;
+  for (const mention of mentions) {
+    if (mention.key) {
+      cleaned = cleaned.replace(new RegExp(`@${mention.key}\\s*`, "g"), "");
+    }
+  }
+  return cleaned.trim();
+}
+function createFeishuClient(config) {
+  return new FeishuClient(config);
+}
+
+// src/opencode/client.ts
+import { createOpencode } from "@opencode-ai/sdk";
+class OpencodeWrapper {
+  client = null;
+  serverCloseFn = null;
+  serverUrl = null;
+  directory;
+  constructor(config) {
+    this.directory = config.directory;
+  }
+  async start() {
+    if (this.client) {
+      logger.warn("OpenCode 已启动");
+      return this.serverUrl;
+    }
+    logger.info("正在启动 OpenCode 服务器...");
+    const { client, server } = await createOpencode({
+      port: 0
+    });
+    this.client = client;
+    this.serverUrl = server.url;
+    this.serverCloseFn = server.close;
+    logger.info("OpenCode 服务器已启动", { url: this.serverUrl });
+    return this.serverUrl;
+  }
+  stop() {
+    if (this.serverCloseFn) {
+      logger.info("正在停止 OpenCode 服务器...");
+      this.serverCloseFn();
+      this.serverCloseFn = null;
+      this.client = null;
+      this.serverUrl = null;
+      logger.info("OpenCode 服务器已停止");
+    }
+  }
+  getServerUrl() {
+    return this.serverUrl;
+  }
+  isStarted() {
+    return this.client !== null;
+  }
+  ensureClient() {
+    if (!this.client) {
+      throw new Error("OpenCode 未启动，请先调用 start()");
+    }
+    return this.client;
+  }
+  async createSession() {
+    const client = this.ensureClient();
+    const response = await client.session.create({
+      query: { directory: this.directory }
+    });
+    if (!response.data) {
+      throw new Error("创建会话失败：未返回数据");
+    }
+    return response.data.id;
+  }
+  async sendPrompt(sessionId, prompt, images) {
+    const client = this.ensureClient();
+    const parts = [
+      { type: "text", text: prompt }
+    ];
+    if (images && images.length > 0) {
+      for (const image of images) {
+        const base64Data = image.data.toString("base64");
+        const dataUrl = `data:${image.mimeType};base64,${base64Data}`;
+        parts.push({
+          type: "file",
+          mime: image.mimeType,
+          url: dataUrl,
+          filename: image.filename
+        });
+      }
+    }
+    await client.session.promptAsync({
+      path: { id: sessionId },
+      query: { directory: this.directory },
+      body: { parts }
+    });
+  }
+  async abortSession(sessionId) {
+    try {
+      const client = this.ensureClient();
+      await client.session.abort({
+        path: { id: sessionId },
+        query: { directory: this.directory }
+      });
+      return true;
+    } catch (error) {
+      logger.error("中止会话失败", error);
+      return false;
+    }
+  }
+  async subscribeToEvents(sessionId, callback) {
+    const client = this.ensureClient();
+    const abortController = new AbortController;
+    const eventResult = await client.event.subscribe({
+      query: { directory: this.directory }
+    });
+    const processEvents = async () => {
+      try {
+        for await (const eventData of eventResult.stream) {
+          if (abortController.signal.aborted)
+            break;
+          const event = eventData;
+          if (!event || !event.type)
+            continue;
+          const properties = "properties" in event ? event.properties : {};
+          const eventInfo = properties;
+          const info = eventInfo.info;
+          const part = eventInfo.part;
+          const eventSessionId = eventInfo.sessionID ?? part?.sessionID ?? info?.id ?? info?.sessionID;
+          if (eventSessionId === sessionId || !eventSessionId) {
+            callback({
+              type: event.type,
+              properties
+            });
+          }
+        }
+      } catch (error) {
+        if (!abortController.signal.aborted) {
+          logger.error("事件流错误", { sessionId, error });
+        }
+      }
+    };
+    processEvents();
+    return () => {
+      abortController.abort();
+    };
+  }
+  async getSessionStatus(sessionId) {
+    try {
+      const client = this.ensureClient();
+      const response = await client.session.status({
+        query: { directory: this.directory }
+      });
+      const data = response.data;
+      if (data && data[sessionId]) {
+        return data[sessionId] === "busy" ? "busy" : "idle";
+      }
+      return "unknown";
+    } catch (error) {
+      logger.error("获取会话状态失败", error);
+      return "unknown";
+    }
+  }
+  getClient() {
+    return this.client;
+  }
+  async executeCommand(sessionId, command, args = "") {
+    try {
+      const client = this.ensureClient();
+      await client.session.command({
+        path: { id: sessionId },
+        query: { directory: this.directory },
+        body: {
+          command,
+          arguments: args
+        }
+      });
+      return true;
+    } catch (error) {
+      logger.error("执行命令失败", { command, error });
+      return false;
+    }
+  }
+  async listCommands() {
+    try {
+      const client = this.ensureClient();
+      const response = await client.command.list({
+        query: { directory: this.directory }
+      });
+      return response.data ?? [];
+    } catch (error) {
+      logger.error("获取命令列表失败", error);
+      return [];
+    }
+  }
+  async listModels() {
+    try {
+      const client = this.ensureClient();
+      const response = await client.config.providers({
+        query: { directory: this.directory }
+      });
+      const models = [];
+      const data = response.data;
+      if (data?.providers) {
+        for (const provider of data.providers) {
+          if (provider.models) {
+            for (const [modelKey, model] of Object.entries(provider.models)) {
+              models.push({
+                id: `${provider.id}/${model.id}`,
+                name: model.name,
+                providerId: provider.id
+              });
+            }
+          }
+        }
+      }
+      return models;
+    } catch (error) {
+      logger.error("获取模型列表失败", error);
+      return [];
+    }
+  }
+  async getSession(sessionId) {
+    try {
+      const client = this.ensureClient();
+      const response = await client.session.get({
+        path: { id: sessionId },
+        query: { directory: this.directory }
+      });
+      return response.data;
+    } catch (error) {
+      logger.error("获取会话信息失败", error);
+      return null;
+    }
+  }
+  async getSessionMessages(sessionId) {
+    try {
+      const client = this.ensureClient();
+      const response = await client.session.messages({
+        path: { id: sessionId },
+        query: { directory: this.directory }
+      });
+      return response.data ?? [];
+    } catch (error) {
+      logger.error("获取会话消息失败", error);
+      return [];
+    }
+  }
+  async replyQuestion(requestId, answers) {
+    if (!this.serverUrl) {
+      logger.error("回复问题失败：服务器未启动");
+      return false;
+    }
+    try {
+      const url = new URL(`/question/${encodeURIComponent(requestId)}/reply`, this.serverUrl);
+      if (this.directory) {
+        url.searchParams.set("directory", this.directory);
+      }
+      const response = await fetch(url.toString(), {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ answers })
+      });
+      return response.ok;
+    } catch (error) {
+      logger.error("回复问题失败", error);
+      return false;
+    }
+  }
+  async rejectQuestion(requestId) {
+    if (!this.serverUrl) {
+      logger.error("拒绝问题失败：服务器未启动");
+      return false;
+    }
+    try {
+      const url = new URL(`/question/${encodeURIComponent(requestId)}/reject`, this.serverUrl);
+      if (this.directory) {
+        url.searchParams.set("directory", this.directory);
+      }
+      const response = await fetch(url.toString(), {
+        method: "POST"
+      });
+      return response.ok;
+    } catch (error) {
+      logger.error("拒绝问题失败", error);
+      return false;
+    }
+  }
+}
+function createOpencodeWrapper(config) {
+  return new OpencodeWrapper(config);
+}
+function extractTextFromPart(part) {
+  if (!part || typeof part !== "object")
+    return null;
+  const p = part;
+  if (p.synthetic || p.ignored)
+    return null;
+  if (p.type === "text" && typeof p.text === "string") {
+    return p.text;
+  }
+  if (p.type === "reasoning" && typeof p.text === "string") {
+    return `[思考中] ${p.text}`;
+  }
+  return null;
+}
+function extractToolCallFromPart(part) {
+  if (!part || typeof part !== "object")
+    return null;
+  const p = part;
+  if (p.type === "tool" && typeof p.tool === "string") {
+    const stateObj = p.state;
+    return {
+      name: p.tool,
+      state: stateObj?.status ?? "pending",
+      title: stateObj?.title,
+      input: stateObj?.input,
+      output: stateObj?.output,
+      error: stateObj?.error
+    };
+  }
+  return null;
+}
+
+// src/feishu/formatter.ts
+import { resolve, isAbsolute } from "node:path";
+var MAX_CARD_CONTENT_LENGTH = 28000;
+var TRUNCATION_SUFFIX = `
+
+... (内容已截断)`;
+function createCard(content, title, template) {
+  const truncatedContent = truncateContent(content);
+  const card = {
+    config: { wide_screen_mode: true },
+    elements: [{
+      tag: "markdown",
+      content: truncatedContent
+    }]
+  };
+  if (title) {
+    card.header = {
+      title: { tag: "plain_text", content: title },
+      template: template ?? "blue"
+    };
+  }
+  return card;
+}
+function isPathKey(key) {
+  const lowerKey = key.toLowerCase();
+  return lowerKey.includes("path") || lowerKey.includes("file") || lowerKey === "workdir";
+}
+function ensureAbsolutePath(value) {
+  if (isAbsolute(value)) {
+    return value;
+  }
+  return resolve(process.cwd(), value);
+}
+function formatToolInput(input) {
+  const lines = [];
+  for (const [key, value] of Object.entries(input)) {
+    if (value === undefined || value === null)
+      continue;
+    let displayValue;
+    if (typeof value === "string") {
+      let processedValue = value;
+      if (isPathKey(key) && value.trim()) {
+        processedValue = ensureAbsolutePath(value);
+      }
+      displayValue = processedValue.length > 100 ? processedValue.slice(0, 100) + "..." : processedValue;
+    } else {
+      displayValue = JSON.stringify(value);
+      if (displayValue.length > 100) {
+        displayValue = displayValue.slice(0, 100) + "...";
+      }
+    }
+    lines.push(`**${key}**: \`${displayValue}\``);
+  }
+  return lines.join(`
+`);
+}
+function escapeCodeBlockContent(text) {
+  return text.replace(/```/g, "` ` `");
+}
+function getStatusEmoji(status) {
+  switch (status.toLowerCase()) {
+    case "running":
+    case "pending":
+      return "⏳";
+    case "completed":
+    case "complete":
+    case "success":
+      return "✅";
+    case "error":
+    case "failed":
+      return "❌";
+    default:
+      return "\uD83D\uDD27";
+  }
+}
+function truncateContent(content) {
+  if (content.length <= MAX_CARD_CONTENT_LENGTH) {
+    return content;
+  }
+  const availableLength = MAX_CARD_CONTENT_LENGTH - TRUNCATION_SUFFIX.length;
+  return content.slice(0, availableLength) + TRUNCATION_SUFFIX;
+}
+function groupConsecutiveParts(parts) {
+  const groups = [];
+  for (const part of parts) {
+    const lastGroup = groups[groups.length - 1];
+    if (lastGroup && lastGroup.type === part.type) {
+      lastGroup.parts.push(part);
+    } else {
+      groups.push({
+        type: part.type,
+        parts: [part]
+      });
+    }
+  }
+  return groups;
+}
+function estimateElementSize(element) {
+  return JSON.stringify(element).length;
+}
+var MAX_CARD_SIZE = 25000;
+var MAX_REASONING_LENGTH = 3000;
+var MAX_TOOL_OUTPUT_LENGTH = 5000;
+function buildStreamingCardsV2(parts, isComplete, title) {
+  const groups = groupConsecutiveParts(parts);
+  const cards = [];
+  let currentElements = [];
+  let currentSize = 0;
+  let cardIndex = 0;
+  let reasoningIndex = 0;
+  const createCard2 = (elements, isFinal) => {
+    const template = isFinal && isComplete ? "green" : "wathet";
+    const headerTitle = title ?? (isFinal && isComplete ? "响应完成" : "处理中...");
+    const cardTitle = cardIndex > 0 ? `${headerTitle} (续${cardIndex})` : headerTitle;
+    return {
+      schema: "2.0",
+      header: {
+        title: { tag: "plain_text", content: cardTitle },
+        template
+      },
+      body: { elements }
+    };
+  };
+  const flushCard = () => {
+    if (currentElements.length > 0) {
+      cards.push(createCard2(currentElements, false));
+      cardIndex++;
+      currentElements = [];
+      currentSize = 0;
+    }
+  };
+  const addElement = (element) => {
+    const elementSize = estimateElementSize(element);
+    if (currentSize + elementSize > MAX_CARD_SIZE && currentElements.length > 0) {
+      flushCard();
+    }
+    currentElements.push(element);
+    currentSize += elementSize;
+  };
+  for (const group of groups) {
+    switch (group.type) {
+      case "reasoning": {
+        reasoningIndex++;
+        const reasoningTexts = group.parts.map((p) => p.text).filter((t) => !!t);
+        if (reasoningTexts.length === 0)
+          break;
+        let combinedText = reasoningTexts.join(`
+
+`);
+        if (combinedText.length > MAX_REASONING_LENGTH) {
+          combinedText = combinedText.slice(0, MAX_REASONING_LENGTH) + `
+... (思考内容已截断)`;
+        }
+        const panelTitle = groups.filter((g) => g.type === "reasoning").length > 1 ? `\uD83D\uDCAD 思考过程 ${reasoningIndex}` : "\uD83D\uDCAD 思考过程";
+        addElement({
+          tag: "collapsible_panel",
+          expanded: false,
+          header: {
+            title: { tag: "plain_text", content: panelTitle }
+          },
+          elements: [{
+            tag: "markdown",
+            content: "```\n" + escapeCodeBlockContent(combinedText) + "\n```"
+          }]
+        });
+        break;
+      }
+      case "tool-call": {
+        for (const tool of group.parts) {
+          if (!tool.name)
+            continue;
+          const emoji = getStatusEmoji(tool.state ?? "pending");
+          const toolElements = [];
+          if (tool.input && Object.keys(tool.input).length > 0) {
+            const inputLines = formatToolInput(tool.input);
+            if (inputLines) {
+              toolElements.push({
+                tag: "markdown",
+                content: inputLines
+              });
+            }
+          }
+          if (tool.error) {
+            toolElements.push({
+              tag: "markdown",
+              content: `**错误：**
+\`\`\`
+${escapeCodeBlockContent(tool.error)}
+\`\`\``
+            });
+          } else if (tool.output) {
+            let outputText = tool.output;
+            if (outputText.length > MAX_TOOL_OUTPUT_LENGTH) {
+              outputText = outputText.slice(0, MAX_TOOL_OUTPUT_LENGTH) + `
+... (输出已截断)`;
+            }
+            toolElements.push({
+              tag: "markdown",
+              content: "```\n" + escapeCodeBlockContent(outputText) + "\n```"
+            });
+          }
+          const panelTitle = tool.title || tool.name;
+          addElement({
+            tag: "collapsible_panel",
+            expanded: false,
+            header: {
+              title: { tag: "plain_text", content: `${emoji} ${panelTitle}` }
+            },
+            elements: toolElements.length > 0 ? toolElements : [{
+              tag: "markdown",
+              content: "*执行中...*"
+            }]
+          });
+        }
+        break;
+      }
+      case "text": {
+        const textContents = group.parts.map((p) => p.text).filter((t) => !!t);
+        if (textContents.length === 0)
+          break;
+        if (currentElements.length > 0) {
+          addElement({ tag: "hr" });
+        }
+        const combinedText = textContents.join(`
+
+`);
+        addElement({
+          tag: "markdown",
+          content: truncateContent(combinedText)
+        });
+        break;
+      }
+    }
+  }
+  if (currentElements.length === 0) {
+    currentElements.push({
+      tag: "markdown",
+      content: isComplete ? "（无内容）" : "..."
+    });
+  }
+  cards.push(createCard2(currentElements, true));
+  return { cards, hasMore: false };
+}
+function buildStreamingCard(content, isComplete, title) {
+  const template = isComplete ? "green" : "wathet";
+  const headerTitle = title ?? (isComplete ? "响应完成" : "处理中...");
+  return createCard(content, headerTitle, template);
+}
+
+// src/feishu/streamer.ts
+var DEFAULT_THROTTLE_MS = 500;
+var MIN_THROTTLE_MS = 500;
+var RATE_LIMIT_RETRY_DELAY_MS = 600;
+var MAX_RETRIES = 2;
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+
+class CardStreamer {
+  client;
+  chatId;
+  messageIds = [];
+  buffer = "";
+  orderedParts = [];
+  lastUpdateTimePerMessage = new Map;
+  throttleMs;
+  pendingUpdate = null;
+  isComplete = false;
+  title;
+  useV2 = false;
+  isUpdating = false;
+  hasPendingData = false;
+  constructor(client, chatId, config) {
+    this.client = client;
+    this.chatId = chatId;
+    this.throttleMs = Math.max(config?.throttleMs ?? DEFAULT_THROTTLE_MS, MIN_THROTTLE_MS);
+  }
+  setTitle(title) {
+    this.title = title;
+  }
+  async start() {
+    if (this.messageIds.length > 0)
+      return;
+    const cards = this.useV2 ? buildStreamingCardsV2([], false, this.title ?? "思考中...").cards : [buildStreamingCard("", false, this.title ?? "思考中...")];
+    const card = cards[0];
+    if (!card)
+      return;
+    try {
+      const messageId = await this.client.sendCard(this.chatId, card);
+      if (messageId) {
+        this.messageIds.push(messageId);
+        this.lastUpdateTimePerMessage.set(messageId, Date.now());
+      } else {
+        logger.error("创建初始卡片消息失败");
+      }
+    } catch (error) {
+      logger.error("发送初始卡片时出错", error);
+    }
+  }
+  async append(content) {
+    this.buffer += content;
+    await this.scheduleUpdate();
+  }
+  async setContent(content) {
+    this.buffer = content;
+    this.useV2 = false;
+    await this.scheduleUpdate();
+  }
+  async setOrderedParts(parts) {
+    this.orderedParts = parts;
+    this.useV2 = true;
+    await this.scheduleUpdate();
+  }
+  async setParts(parts) {
+    this.orderedParts = parts.map((p) => ({
+      type: p.type,
+      text: p.text,
+      name: p.name,
+      state: p.state,
+      title: p.title,
+      input: p.input,
+      output: p.output,
+      error: p.error
+    }));
+    this.useV2 = true;
+    await this.scheduleUpdate();
+  }
+  async scheduleUpdate() {
+    this.hasPendingData = true;
+    if (this.isUpdating) {
+      return;
+    }
+    if (this.pendingUpdate) {
+      return;
+    }
+    this.pendingUpdate = setTimeout(async () => {
+      this.pendingUpdate = null;
+      await this.flush();
+    }, this.throttleMs);
+  }
+  async flush() {
+    if (!this.buffer && this.orderedParts.length === 0)
+      return;
+    if (this.isUpdating) {
+      this.hasPendingData = true;
+      return;
+    }
+    this.isUpdating = true;
+    this.hasPendingData = false;
+    try {
+      if (this.useV2) {
+        const result = buildStreamingCardsV2(this.orderedParts, this.isComplete, this.title);
+        await this.syncCards(result.cards);
+      } else {
+        const card = buildStreamingCard(this.buffer, this.isComplete, this.title);
+        await this.syncCards([card]);
+      }
+    } catch (error) {
+      logger.error("刷新卡片时出错", error);
+    } finally {
+      this.isUpdating = false;
+      if (this.hasPendingData && !this.isComplete) {
+        this.pendingUpdate = setTimeout(async () => {
+          this.pendingUpdate = null;
+          await this.flush();
+        }, this.throttleMs);
+      }
+    }
+  }
+  async updateCardWithRateLimit(messageId, card) {
+    const lastUpdate = this.lastUpdateTimePerMessage.get(messageId) ?? 0;
+    const timeSinceLastUpdate = Date.now() - lastUpdate;
+    if (timeSinceLastUpdate < this.throttleMs) {
+      const waitTime = this.throttleMs - timeSinceLastUpdate;
+      await sleep(waitTime);
+    }
+    for (let retry = 0;retry <= MAX_RETRIES; retry++) {
+      const result = await this.client.updateCard(messageId, card);
+      if (result.success) {
+        this.lastUpdateTimePerMessage.set(messageId, Date.now());
+        return true;
+      }
+      if (result.rateLimited && retry < MAX_RETRIES) {
+        logger.debug("卡片更新触发频率限制，等待重试", { messageId, retry });
+        await sleep(RATE_LIMIT_RETRY_DELAY_MS);
+        continue;
+      }
+      if (!result.rateLimited) {
+        logger.warn("更新卡片失败", { messageId });
+      }
+      return false;
+    }
+    return false;
+  }
+  async syncCards(cards) {
+    for (let i = 0;i < cards.length; i++) {
+      const card = cards[i];
+      if (!card)
+        continue;
+      const existingMessageId = this.messageIds[i];
+      if (existingMessageId) {
+        await this.updateCardWithRateLimit(existingMessageId, card);
+      } else {
+        const messageId = await this.client.sendCard(this.chatId, card);
+        if (messageId) {
+          this.messageIds.push(messageId);
+          this.lastUpdateTimePerMessage.set(messageId, Date.now());
+        } else {
+          logger.error("创建续卡片失败", { index: i });
+        }
+      }
+    }
+    while (this.messageIds.length > cards.length) {
+      const extraMessageId = this.messageIds.pop();
+      if (extraMessageId) {
+        this.lastUpdateTimePerMessage.delete(extraMessageId);
+        await this.client.deleteMessage(extraMessageId);
+      }
+    }
+  }
+  async complete() {
+    this.isComplete = true;
+    if (this.pendingUpdate) {
+      clearTimeout(this.pendingUpdate);
+      this.pendingUpdate = null;
+    }
+    while (this.isUpdating) {
+      await sleep(50);
+    }
+    await this.flush();
+  }
+  async sendError(errorMessage) {
+    this.isComplete = true;
+    if (this.pendingUpdate) {
+      clearTimeout(this.pendingUpdate);
+      this.pendingUpdate = null;
+    }
+    while (this.isUpdating) {
+      await sleep(50);
+    }
+    const card = {
+      config: { wide_screen_mode: true },
+      header: {
+        title: { tag: "plain_text", content: "错误" },
+        template: "red"
+      },
+      elements: [{
+        tag: "markdown",
+        content: `**发生错误：**
+\`\`\`
+${errorMessage}
+\`\`\``
+      }]
+    };
+    try {
+      if (this.messageIds.length === 0) {
+        const messageId = await this.client.sendCard(this.chatId, card);
+        if (messageId) {
+          this.messageIds.push(messageId);
+        }
+      } else {
+        const firstMessageId = this.messageIds[0];
+        if (firstMessageId) {
+          await this.updateCardWithRateLimit(firstMessageId, card);
+        }
+        for (let i = 1;i < this.messageIds.length; i++) {
+          const msgId = this.messageIds[i];
+          if (msgId) {
+            await this.client.deleteMessage(msgId);
+          }
+        }
+        this.messageIds = this.messageIds.slice(0, 1);
+      }
+    } catch (error) {
+      logger.error("发送错误卡片时出错", error);
+    }
+  }
+  getMessageId() {
+    return this.messageIds[0] ?? null;
+  }
+  getMessageIds() {
+    return [...this.messageIds];
+  }
+  getContent() {
+    return this.buffer;
+  }
+  reset() {
+    this.messageIds = [];
+    this.buffer = "";
+    this.orderedParts = [];
+    this.lastUpdateTimePerMessage.clear();
+    this.isComplete = false;
+    this.title = undefined;
+    this.useV2 = false;
+    this.isUpdating = false;
+    this.hasPendingData = false;
+    if (this.pendingUpdate) {
+      clearTimeout(this.pendingUpdate);
+      this.pendingUpdate = null;
+    }
+  }
+}
+function createCardStreamer(client, chatId, config) {
+  return new CardStreamer(client, chatId, config);
+}
+
+// src/feishu/question-card.ts
+function createHeader(title, color = "blue") {
+  return {
+    template: color,
+    title: { tag: "plain_text", content: title }
+  };
+}
+function createMarkdown(content) {
+  return {
+    tag: "markdown",
+    content
+  };
+}
+function createDivider() {
+  return { tag: "hr" };
+}
+function createQuestionCard(request) {
+  const elements = [];
+  const firstQuestion = request.questions[0];
+  const headerTitle = firstQuestion?.header || "\uD83E\uDD14 请选择";
+  request.questions.forEach((q, questionIndex) => {
+    if (questionIndex > 0) {
+      elements.push(createDivider());
+    }
+    elements.push(createMarkdown(`**${q.question}**`));
+    if (q.options && q.options.length > 0) {
+      const descriptions = q.options.filter((opt) => opt.description).map((opt) => `• **${opt.label}**: ${opt.description}`).join(`
+`);
+      if (descriptions) {
+        elements.push(createMarkdown(descriptions));
+      }
+      const useDropdown = q.multiple === true || q.options.length > 3;
+      if (useDropdown) {
+        const options = q.options.map((opt) => ({
+          text: { tag: "plain_text", content: opt.label },
+          value: opt.label
+        }));
+        elements.push({
+          tag: "action",
+          actions: [
+            {
+              tag: "select_static",
+              placeholder: { tag: "plain_text", content: q.multiple ? "选择答案（可多选）" : "选择答案" },
+              value: {
+                action: "question_answer",
+                requestId: request.id,
+                questionIndex
+              },
+              options
+            }
+          ]
+        });
+      } else {
+        const buttons = q.options.map((opt) => ({
+          tag: "button",
+          text: { tag: "plain_text", content: opt.label },
+          type: "default",
+          value: {
+            action: "question_answer",
+            requestId: request.id,
+            questionIndex,
+            answerLabel: opt.label
+          }
+        }));
+        elements.push({
+          tag: "action",
+          actions: buttons
+        });
+      }
+    }
+  });
+  elements.push(createDivider());
+  elements.push(createMarkdown("\uD83D\uDCAC 或直接发送消息输入自定义答案"));
+  return {
+    config: { wide_screen_mode: true },
+    header: createHeader(headerTitle, "orange"),
+    elements
+  };
+}
+function createAnsweredCard(question, answer) {
+  return {
+    config: { wide_screen_mode: true },
+    header: createHeader("✅ 已回答", "green"),
+    elements: [
+      createMarkdown(`**问题**: ${question}`),
+      createMarkdown(`**答案**: ${answer}`)
+    ]
+  };
+}
+function createQuestionErrorCard(message) {
+  return {
+    config: { wide_screen_mode: true },
+    header: createHeader("❌ 操作失败", "red"),
+    elements: [
+      createMarkdown(message)
+    ]
+  };
+}
+
+// src/session/manager.ts
+class SessionManager {
+  db;
+  feishuClient;
+  opencodeClient;
+  config;
+  activeSessions = new Map;
+  messageQueue = new Map;
+  pendingQuestions = new Map;
+  constructor(db, feishuClient, opencodeClient, config) {
+    this.db = db;
+    this.feishuClient = feishuClient;
+    this.opencodeClient = opencodeClient;
+    this.config = config;
+  }
+  async handleMessage(event) {
+    const { chatId, senderId, eventId, messageId, content, messageType, mentions, chatType } = event;
+    if (this.db.isEventProcessed(eventId)) {
+      return;
+    }
+    this.db.markEventProcessed(eventId);
+    if (!this.isUserAuthorized(senderId)) {
+      await this.sendUnauthorizedMessage(chatId);
+      return;
+    }
+    const supportedTypes = ["text", "image", "post", "file"];
+    if (!supportedTypes.includes(messageType)) {
+      logger.warn("不支持的消息类型", { messageType, chatId });
+      await this.feishuClient.sendTextMessage(chatId, `暂不支持该消息类型 (${messageType})，目前支持：文本、图片、富文本`);
+      return;
+    }
+    let text = "";
+    let images = [];
+    if (messageType === "text") {
+      text = parseTextContent(content);
+      text = cleanMentionsFromText(text, mentions);
+      if (!text.trim()) {
+        return;
+      }
+    } else if (messageType === "image") {
+      const imageKey = parseImageContent(content);
+      if (!imageKey) {
+        await this.feishuClient.sendTextMessage(chatId, "无法解析图片内容");
+        return;
+      }
+      const imageData = await this.feishuClient.getMessageImage(messageId, imageKey);
+      if (!imageData) {
+        await this.feishuClient.sendTextMessage(chatId, "获取图片失败，请重试");
+        return;
+      }
+      images = [{
+        data: imageData.data,
+        mimeType: imageData.mimeType,
+        filename: `${imageKey}.${imageData.mimeType.split("/")[1] || "png"}`
+      }];
+      text = "请分析这张图片";
+    } else if (messageType === "post") {
+      const result = await this.parsePostContent(content, messageId);
+      text = result.text;
+      images = result.images;
+      if (!text.trim() && images.length === 0) {
+        return;
+      }
+      if (!text.trim() && images.length > 0) {
+        text = "请分析这些图片";
+      }
+    } else if (messageType === "file") {
+      await this.feishuClient.sendTextMessage(chatId, "暂不支持文件消息，请直接发送图片或文本");
+      return;
+    }
+    const sessionChat = this.db.getSessionChat(chatId);
+    const isSessionChat = sessionChat !== null;
+    if (chatType === "group" && !isSessionChat) {
+      return;
+    }
+    const pendingQuestion = this.pendingQuestions.get(chatId);
+    if (pendingQuestion && messageType === "text") {
+      await this.handleQuestionTextAnswer(chatId, text, pendingQuestion);
+      return;
+    }
+    try {
+      this.db.saveMessageMapping(messageId, chatId);
+    } catch (e) {
+      logger.error("保存消息映射失败", e);
+    }
+    await this.queueMessage(chatId, async () => {
+      await this.processMessage(chatId, senderId, messageId, text, images, isSessionChat ? sessionChat : undefined);
+    });
+  }
+  async queueMessage(chatId, handler) {
+    const existingPromise = this.messageQueue.get(chatId) ?? Promise.resolve();
+    const newPromise = existingPromise.then(async () => {
+      try {
+        await handler();
+      } catch (error) {
+        logger.error("处理队列消息时出错", error);
+      }
+    });
+    this.messageQueue.set(chatId, newPromise);
+    await newPromise;
+  }
+  async processMessage(chatId, senderId, userMessageId, text, images, sessionChat) {
+    const streamer = createCardStreamer(this.feishuClient, chatId);
+    streamer.setTitle("思考中...");
+    await streamer.start();
+    let sessionId;
+    if (sessionChat) {
+      sessionId = sessionChat.session_id;
+    } else {
+      sessionId = await this.getOrCreateSession(chatId);
+    }
+    const activeSession = {
+      sessionId,
+      chatId,
+      userMessageId,
+      streamer,
+      unsubscribe: null,
+      parts: [],
+      firstTextSkipped: false
+    };
+    this.activeSessions.set(chatId, activeSession);
+    try {
+      const unsubscribe = await this.opencodeClient.subscribeToEvents(sessionId, (event) => this.handleOpencodeEvent(chatId, event));
+      activeSession.unsubscribe = unsubscribe;
+      await this.opencodeClient.sendPrompt(sessionId, text, images.length > 0 ? images : undefined);
+    } catch (error) {
+      logger.error("发送提示时出错", { chatId, sessionId, error });
+      await streamer.sendError(error instanceof Error ? error.message : "未知错误");
+      this.cleanupSession(chatId);
+    }
+  }
+  async setSessionChatTitle(chatId, title, sessionId) {
+    const maxLength = 60;
+    const shortId = sessionId.replace(/^ses_/, "").slice(0, 8);
+    const prefix = `o-${shortId}-`;
+    const availableLength = maxLength - prefix.length;
+    const truncatedTitle = title.length > availableLength ? title.slice(0, availableLength - 3) + "..." : title;
+    const chatName = `${prefix}${truncatedTitle}`;
+    const success = await this.feishuClient.updateChatName(chatId, chatName);
+    if (success) {
+      this.db.updateSessionChatTitle(chatId, title);
+    }
+  }
+  async handleOpencodeEvent(chatId, event) {
+    const session = this.activeSessions.get(chatId);
+    if (!session)
+      return;
+    const { streamer, parts } = session;
+    const properties = event.properties;
+    switch (event.type) {
+      case "message.part.updated": {
+        const part = properties.part;
+        if (!part)
+          break;
+        const partId = part.id;
+        const formattedPart = this.formatPart(part);
+        if (!formattedPart)
+          break;
+        if (formattedPart.type === "text" && !session.firstTextSkipped) {
+          session.firstTextSkipped = true;
+          break;
+        }
+        const existingIndex = parts.findIndex((p) => p.id === partId);
+        if (existingIndex >= 0) {
+          parts[existingIndex] = { ...formattedPart, id: partId };
+        } else {
+          parts.push({ ...formattedPart, id: partId });
+        }
+        await streamer.setParts(parts);
+        const botMessageId = streamer.getMessageId();
+        if (botMessageId && session.userMessageId) {
+          this.db.updateBotMessageId(session.userMessageId, botMessageId);
+        }
+        break;
+      }
+      case "session.idle": {
+        const info = properties.info;
+        const sessionInfo = info;
+        if (sessionInfo?.sessionID === session.sessionId) {
+          await streamer.complete();
+          this.cleanupSession(chatId);
+        }
+        break;
+      }
+      case "session.error": {
+        const errorInfo = properties;
+        const errorMessage = errorInfo.error?.message ?? "发生未知错误";
+        logger.error("会话错误", { chatId, error: errorMessage });
+        await streamer.sendError(errorMessage);
+        this.cleanupSession(chatId);
+        break;
+      }
+      case "message.updated": {
+        const info = properties.info;
+        if (info?.error) {
+          const error = info.error;
+          const errorMessage = error.data?.message ?? "消息处理错误";
+          logger.error("消息错误", { chatId, error: errorMessage });
+          await streamer.sendError(errorMessage);
+          this.cleanupSession(chatId);
+        }
+        break;
+      }
+      case "session.updated": {
+        const info = properties.info;
+        if (info?.id === session.sessionId && info?.title) {
+          const sessionChat = this.db.getSessionChat(chatId);
+          if (sessionChat) {
+            await this.setSessionChatTitle(chatId, info.title, session.sessionId);
+          }
+        }
+        break;
+      }
+      case "question.asked": {
+        const questionRequest = properties;
+        if (questionRequest?.id && questionRequest?.questions?.length > 0) {
+          await this.handleQuestionAsked(chatId, questionRequest);
+        }
+        break;
+      }
+    }
+  }
+  formatPart(part) {
+    const textResult = extractTextFromPart(part);
+    if (textResult !== null) {
+      return {
+        type: part.type,
+        text: textResult.startsWith("[思考中]") ? textResult.replace("[思考中] ", "") : textResult
+      };
+    }
+    const toolResult = extractToolCallFromPart(part);
+    if (toolResult !== null) {
+      return {
+        type: "tool-call",
+        name: toolResult.name,
+        state: toolResult.state,
+        title: toolResult.title,
+        input: toolResult.input,
+        output: toolResult.output,
+        error: toolResult.error
+      };
+    }
+    return null;
+  }
+  async handleQuestionAsked(chatId, request) {
+    const card = createQuestionCard(request);
+    const messageId = await this.feishuClient.sendCard(chatId, card);
+    if (messageId) {
+      this.pendingQuestions.set(chatId, {
+        requestId: request.id,
+        messageId,
+        questions: request.questions,
+        chatId
+      });
+      logger.info("收到问题请求", { chatId, requestId: request.id, questionCount: request.questions.length });
+    }
+  }
+  async handleQuestionTextAnswer(chatId, text, pending) {
+    const answers = pending.questions.map(() => [text]);
+    const success = await this.opencodeClient.replyQuestion(pending.requestId, answers);
+    if (success) {
+      const firstQuestion = pending.questions[0]?.question || "问题";
+      const answeredCard = createAnsweredCard(firstQuestion, text);
+      await this.feishuClient.updateCard(pending.messageId, answeredCard);
+      logger.info("文字回答问题", { chatId, requestId: pending.requestId, answer: text });
+    } else {
+      await this.feishuClient.sendTextMessage(chatId, "提交答案失败，请重试");
+    }
+    this.pendingQuestions.delete(chatId);
+  }
+  async handleQuestionAnswer(chatId, requestId, questionIndex, answerLabel, messageId) {
+    const pending = this.pendingQuestions.get(chatId);
+    if (!pending || pending.requestId !== requestId) {
+      return false;
+    }
+    const answers = pending.questions.map((_, idx) => idx === questionIndex ? [answerLabel] : []);
+    const success = await this.opencodeClient.replyQuestion(requestId, answers);
+    if (success && messageId) {
+      const firstQuestion = pending.questions[0]?.question || "问题";
+      const answeredCard = createAnsweredCard(firstQuestion, answerLabel);
+      await this.feishuClient.updateCard(messageId, answeredCard);
+    }
+    this.pendingQuestions.delete(chatId);
+    logger.info("卡片回答问题", { chatId, requestId, questionIndex, answerLabel });
+    return success;
+  }
+  getPendingQuestion(chatId) {
+    return this.pendingQuestions.get(chatId);
+  }
+  async parsePostContent(content, messageId) {
+    let text = "";
+    const images = [];
+    try {
+      const parsed = JSON.parse(content);
+      let postContent = parsed.content;
+      if (!postContent && Array.isArray(parsed)) {
+        postContent = parsed;
+      }
+      if (!postContent && parsed.zh_cn?.content) {
+        postContent = parsed.zh_cn.content;
+      }
+      if (!postContent && parsed.en_us?.content) {
+        postContent = parsed.en_us.content;
+      }
+      if (!postContent) {
+        logger.warn("富文本消息格式异常", { content: content.substring(0, 200) });
+        return { text, images };
+      }
+      for (const paragraph of postContent) {
+        if (!Array.isArray(paragraph))
+          continue;
+        for (const element of paragraph) {
+          if (element.tag === "text") {
+            text += element.text || "";
+          } else if (element.tag === "img") {
+            const imageKey = element.image_key;
+            if (imageKey) {
+              const imageData = await this.feishuClient.getMessageImage(messageId, imageKey);
+              if (imageData) {
+                images.push({
+                  data: imageData.data,
+                  mimeType: imageData.mimeType,
+                  filename: `${imageKey}.${imageData.mimeType.split("/")[1] || "png"}`
+                });
+              }
+            }
+          }
+        }
+        text += `
+`;
+      }
+      text = text.trim();
+    } catch (e) {
+      logger.error("解析富文本消息失败", { error: e });
+    }
+    return { text, images };
+  }
+  async getOrCreateSession(chatId) {
+    const existingSession = this.db.getSession(chatId);
+    if (existingSession) {
+      return existingSession.session_id;
+    }
+    const projectPath = this.db.getProjectPath(chatId) ?? this.config.defaultProjectPath;
+    const sessionId = await this.opencodeClient.createSession();
+    this.db.upsertSession(chatId, sessionId, projectPath);
+    return sessionId;
+  }
+  cleanupSession(chatId) {
+    const session = this.activeSessions.get(chatId);
+    if (session) {
+      if (session.unsubscribe) {
+        session.unsubscribe();
+      }
+      this.activeSessions.delete(chatId);
+    }
+  }
+  isUserAuthorized(userId) {
+    if (this.config.allowAllUsers) {
+      return true;
+    }
+    if (this.config.adminUserIds.includes(userId)) {
+      return true;
+    }
+    return this.db.isUserWhitelisted(userId);
+  }
+  async sendUnauthorizedMessage(chatId) {
+    await this.feishuClient.sendTextMessage(chatId, "你没有权限使用此机器人。请联系管理员申请访问权限。");
+  }
+  async createNewSession(chatId) {
+    this.cleanupSession(chatId);
+    this.db.deleteSession(chatId);
+    const projectPath = this.db.getProjectPath(chatId) ?? this.config.defaultProjectPath;
+    const sessionId = await this.opencodeClient.createSession();
+    this.db.upsertSession(chatId, sessionId, projectPath);
+    return sessionId;
+  }
+  async switchProject(chatId, projectPath) {
+    this.db.setProjectPath(chatId, projectPath);
+    this.db.deleteSession(chatId);
+    this.cleanupSession(chatId);
+  }
+  async abortCurrentSession(chatId) {
+    const session = this.activeSessions.get(chatId);
+    if (!session) {
+      return false;
+    }
+    const result = await this.opencodeClient.abortSession(session.sessionId);
+    if (result) {
+      this.cleanupSession(chatId);
+    }
+    return result;
+  }
+  isAdmin(userId) {
+    return this.config.adminUserIds.includes(userId);
+  }
+  getActiveSessionCount() {
+    return this.activeSessions.size;
+  }
+  getDefaultProjectPath() {
+    return this.config.defaultProjectPath;
+  }
+  async handleMessageRecall(userMessageId) {
+    const mapping = this.db.getMessageMapping(userMessageId);
+    if (!mapping) {
+      return { aborted: false, botMessagesDeleted: 0 };
+    }
+    const { chat_id: chatId } = mapping;
+    const messagesToRecall = this.db.getMessageMappingsAfter(userMessageId, chatId);
+    let aborted = false;
+    const activeSession = this.activeSessions.get(chatId);
+    if (activeSession) {
+      aborted = await this.opencodeClient.abortSession(activeSession.sessionId);
+      this.cleanupSession(chatId);
+    }
+    let botMessagesDeleted = 0;
+    for (const msg of messagesToRecall) {
+      if (msg.bot_message_id) {
+        const deleted = await this.feishuClient.deleteMessage(msg.bot_message_id);
+        if (deleted)
+          botMessagesDeleted++;
+      }
+    }
+    const userMessageIds = messagesToRecall.map((m) => m.user_message_id);
+    this.db.deleteMessageMappings(userMessageIds);
+    logger.info("处理消息撤回", {
+      userMessageId,
+      aborted,
+      botMessagesDeleted,
+      totalMessagesRecalled: messagesToRecall.length
+    });
+    return { aborted, botMessagesDeleted };
+  }
+  cleanupChatData(chatId) {
+    this.cleanupSession(chatId);
+    this.db.deleteSession(chatId);
+    this.db.deleteMessageMappingsByChatId(chatId);
+    logger.info("清理聊天数据", { chatId });
+  }
+  async getOrCreateUserSession(userId) {
+    const chatId = `user:${userId}`;
+    const existingSession = this.db.getSession(chatId);
+    if (existingSession) {
+      return existingSession.session_id;
+    }
+    const projectPath = this.db.getProjectPath(chatId) ?? this.config.defaultProjectPath;
+    const sessionId = await this.opencodeClient.createSession();
+    this.db.upsertSession(chatId, sessionId, projectPath);
+    return sessionId;
+  }
+  async createNewUserSession(userId) {
+    const chatId = `user:${userId}`;
+    this.cleanupSession(chatId);
+    this.db.deleteSession(chatId);
+    const projectPath = this.db.getProjectPath(chatId) ?? this.config.defaultProjectPath;
+    const sessionId = await this.opencodeClient.createSession();
+    this.db.upsertSession(chatId, sessionId, projectPath);
+    return sessionId;
+  }
+  async getUserSessionInfo(userId) {
+    const chatId = `user:${userId}`;
+    const session = this.db.getSession(chatId);
+    if (!session) {
+      return null;
+    }
+    const isActive = this.activeSessions.has(chatId);
+    return {
+      sessionId: session.session_id,
+      projectPath: session.project_path,
+      isActive
+    };
+  }
+  async switchUserProject(userId, projectPath) {
+    const chatId = `user:${userId}`;
+    this.db.setProjectPath(chatId, projectPath);
+    this.db.deleteSession(chatId);
+    this.cleanupSession(chatId);
+  }
+  async createSessionChat(userId, projectPath) {
+    const sessionId = await this.opencodeClient.createSession();
+    const shortId = sessionId.replace(/^ses_/, "").slice(0, 8);
+    const chatName = `o-${shortId}`;
+    const result = await this.feishuClient.createChat(chatName, [userId]);
+    if (!result) {
+      return null;
+    }
+    try {
+      this.db.createSessionChat(result.chatId, sessionId, userId, projectPath);
+      logger.info("创建会话群", { chatId: result.chatId, sessionId, userId });
+    } catch (e) {
+      logger.error("保存会话群到数据库失败", e);
+      return null;
+    }
+    return { chatId: result.chatId, sessionId };
+  }
+  async cleanupSessionChat(chatId) {
+    const sessionChat = this.db.getSessionChat(chatId);
+    if (!sessionChat) {
+      return;
+    }
+    this.cleanupSession(chatId);
+    this.db.deleteSessionChat(chatId);
+    this.db.deleteMessageMappingsByChatId(chatId);
+    logger.info("清理会话群", { chatId, sessionId: sessionChat.session_id });
+  }
+  async handleUserLeftSessionChat(chatId) {
+    const sessionChat = this.db.getSessionChat(chatId);
+    if (!sessionChat)
+      return;
+    this.cleanupSession(chatId);
+    this.db.deleteSessionChat(chatId);
+    this.db.deleteMessageMappingsByChatId(chatId);
+    this.pendingQuestions.delete(chatId);
+    const deleted = await this.feishuClient.deleteChat(chatId);
+    if (!deleted) {
+      logger.debug("群聊可能已自动删除", { chatId });
+    }
+    logger.info("用户退出，清理会话群", { chatId, sessionId: sessionChat.session_id });
+  }
+  getSessionChat(chatId) {
+    return this.db.getSessionChat(chatId);
+  }
+  getUserSessionChats(userId) {
+    return this.db.getSessionChatsByOwner(userId);
+  }
+  cleanup() {
+    for (const chatId of this.activeSessions.keys()) {
+      this.cleanupSession(chatId);
+    }
+    this.messageQueue.clear();
+  }
+}
+function createSessionManager(db, feishuClient, opencodeClient, config) {
+  return new SessionManager(db, feishuClient, opencodeClient, config);
+}
+
+// src/feishu/menu.ts
+function createHeader2(title, color = "blue") {
+  return {
+    template: color,
+    title: { tag: "plain_text", content: title }
+  };
+}
+function createDivider2() {
+  return { tag: "hr" };
+}
+function createMarkdown2(content) {
+  return {
+    tag: "markdown",
+    content
+  };
+}
+function createProjectSelectCard(projects, description, currentProject) {
+  const elements = [];
+  if (projects.length === 0) {
+    elements.push(createMarkdown2("*暂无配置项目，请在 .env 中配置 PROJECTS*"));
+    return {
+      config: { wide_screen_mode: true },
+      header: createHeader2("\uD83C\uDD95 新建会话"),
+      elements
+    };
+  }
+  if (description) {
+    elements.push(createMarkdown2(description));
+    elements.push(createDivider2());
+  }
+  const projectList = projects.map((p, i) => `**${i + 1}.** \`${p.name}\` - ${p.path}`).join(`
+`);
+  elements.push(createMarkdown2(`**可用项目：**
+` + projectList));
+  elements.push(createDivider2());
+  elements.push(createMarkdown2("发送指令创建会话：\n`/new <编号>` 例如：`/new 1`"));
+  if (currentProject) {
+    elements.push(createDivider2());
+    elements.push(createMarkdown2(`当前项目：\`${currentProject}\``));
+  }
+  return {
+    config: { wide_screen_mode: true },
+    header: createHeader2("\uD83C\uDD95 新建会话"),
+    elements
+  };
+}
+function createModelSelectCard(models, currentModel) {
+  const elements = [];
+  if (models.length === 0) {
+    elements.push(createMarkdown2("*暂无可用模型*"));
+    return {
+      config: { wide_screen_mode: true },
+      header: createHeader2("\uD83D\uDD04 切换模型"),
+      elements
+    };
+  }
+  if (currentModel) {
+    elements.push(createMarkdown2(`当前模型：\`${currentModel}\``));
+  }
+  const options = models.map((m) => ({
+    text: { tag: "plain_text", content: m.name },
+    value: m.id
+  }));
+  elements.push({
+    tag: "action",
+    actions: [
+      {
+        tag: "select_static",
+        placeholder: { tag: "plain_text", content: "选择模型" },
+        value: { action: "switch_model" },
+        options
+      }
+    ]
+  });
+  return {
+    config: { wide_screen_mode: true },
+    header: createHeader2("\uD83D\uDD04 切换模型"),
+    elements
+  };
+}
+function createStatusCard(status) {
+  const lines = [
+    `**会话 ID**: \`${status.sessionId}\``,
+    `**项目路径**: \`${status.projectPath}\``,
+    status.model ? `**当前模型**: \`${status.model}\`` : null,
+    status.messageCount !== undefined ? `**消息数量**: ${status.messageCount}` : null,
+    `**状态**: ${status.isActive ? "\uD83D\uDFE2 活跃" : "⚪ 空闲"}`
+  ].filter(Boolean);
+  return {
+    config: { wide_screen_mode: true },
+    header: createHeader2("\uD83D\uDCCA 会话状态", "green"),
+    elements: [createMarkdown2(lines.join(`
+`))]
+  };
+}
+function createSuccessCard(title, message) {
+  return {
+    config: { wide_screen_mode: true },
+    header: createHeader2(title, "green"),
+    elements: [createMarkdown2(message)]
+  };
+}
+function createSessionChatCreatedCard(chatId, sessionId, projectPath) {
+  const chatName = `o-${sessionId}`;
+  const chatLink = `https://applink.feishu.cn/client/chat/open?openChatId=${chatId}`;
+  return {
+    config: { wide_screen_mode: true },
+    header: createHeader2("✅ 会话群已创建", "green"),
+    elements: [
+      createMarkdown2(`**群名称**: ${chatName}
+**项目**: \`${projectPath}\``),
+      {
+        tag: "action",
+        actions: [
+          {
+            tag: "button",
+            text: { tag: "plain_text", content: "进入会话群" },
+            type: "primary",
+            url: chatLink
+          }
+        ]
+      }
+    ]
+  };
+}
+function createErrorCard(title, message) {
+  return {
+    config: { wide_screen_mode: true },
+    header: createHeader2(title, "red"),
+    elements: [createMarkdown2(message)]
+  };
+}
+function createSessionChatWelcomeCard(info) {
+  const shortSessionId = info.sessionId.replace(/^ses_/, "").slice(0, 8);
+  const elements = [];
+  elements.push(createMarkdown2(`**当前状态**
+` + `- \uD83D\uDCC1 工作目录：\`${info.projectPath}\`
+` + `- \uD83D\uDD11 会话 ID：\`${shortSessionId}\``));
+  elements.push(createDivider2());
+  const actions = [];
+  if (info.projects.length > 0) {
+    const projectOptions = info.projects.map((p) => ({
+      text: { tag: "plain_text", content: `${p.name}` },
+      value: p.path
+    }));
+    actions.push({
+      tag: "select_static",
+      placeholder: { tag: "plain_text", content: "\uD83D\uDCC2 切换项目" },
+      value: { action: "switch_project_in_chat", chatId: info.chatId },
+      options: projectOptions
+    });
+  }
+  if (info.models.length > 0) {
+    const modelOptions = info.models.map((m) => ({
+      text: { tag: "plain_text", content: m.name },
+      value: m.id
+    }));
+    actions.push({
+      tag: "select_static",
+      placeholder: { tag: "plain_text", content: info.currentModel ? `\uD83E\uDD16 ${info.currentModel}` : "\uD83E\uDD16 切换模型" },
+      value: { action: "switch_model", chatId: info.chatId },
+      options: modelOptions
+    });
+  }
+  if (actions.length > 0) {
+    elements.push({
+      tag: "action",
+      actions
+    });
+  }
+  if (info.projects.length === 0) {
+    elements.push(createMarkdown2("\uD83D\uDCA1 切换目录：`/switch_project <路径>`"));
+  }
+  elements.push(createDivider2());
+  elements.push({
+    tag: "note",
+    elements: [{ tag: "plain_text", content: "⚡ 发送任何消息即可开始对话" }]
+  });
+  return {
+    config: { wide_screen_mode: true },
+    header: createHeader2("\uD83C\uDF89 会话群已就绪", "green"),
+    elements
+  };
+}
+function createProjectSwitchedCard(projectName, projectPath, sessionId) {
+  const shortSessionId = sessionId.replace(/^ses_/, "").slice(0, 8);
+  return {
+    config: { wide_screen_mode: true },
+    header: createHeader2("✅ 项目已切换", "green"),
+    elements: [
+      createMarkdown2(`**${projectName}**
+` + `- \uD83D\uDCC1 路径：\`${projectPath}\`
+` + `- \uD83D\uDD11 新会话：\`${shortSessionId}\``)
+    ]
+  };
+}
+
+// src/commands/parser.ts
+var COMMAND_PREFIX = "/";
+var COMMANDS = {
+  new: {
+    name: "new",
+    description: "创建新会话（从预配置项目中选择）",
+    usage: "/new <项目编号>",
+    adminOnly: false
+  },
+  model: {
+    name: "model",
+    description: "切换 AI 模型",
+    usage: "/model <编号或模型ID>",
+    adminOnly: false
+  },
+  compact: {
+    name: "compact",
+    description: "压缩当前会话上下文",
+    usage: "/compact",
+    adminOnly: false
+  },
+  clear: {
+    name: "clear",
+    description: "清除历史，创建新会话",
+    usage: "/clear",
+    adminOnly: false
+  },
+  switch_project: {
+    name: "switch_project",
+    description: "切换到不同的项目目录",
+    usage: "/switch_project <路径>",
+    adminOnly: false
+  },
+  new_session: {
+    name: "new_session",
+    description: "创建新的 OpenCode 会话",
+    usage: "/new_session",
+    adminOnly: false
+  },
+  help: {
+    name: "help",
+    description: "显示可用命令",
+    usage: "/help",
+    adminOnly: false
+  },
+  abort: {
+    name: "abort",
+    description: "中止当前运行的任务",
+    usage: "/abort",
+    adminOnly: false
+  },
+  status: {
+    name: "status",
+    description: "显示当前会话状态",
+    usage: "/status",
+    adminOnly: false
+  },
+  whitelist_add: {
+    name: "whitelist_add",
+    description: "将用户添加到白名单",
+    usage: "/whitelist_add <用户ID>",
+    adminOnly: true
+  },
+  whitelist_remove: {
+    name: "whitelist_remove",
+    description: "从白名单移除用户",
+    usage: "/whitelist_remove <用户ID>",
+    adminOnly: true
+  },
+  whitelist_list: {
+    name: "whitelist_list",
+    description: "列出所有白名单用户",
+    usage: "/whitelist_list",
+    adminOnly: true
+  }
+};
+function isCommand(text) {
+  return text.trim().startsWith(COMMAND_PREFIX);
+}
+function parseCommand(text) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith(COMMAND_PREFIX)) {
+    return null;
+  }
+  const withoutPrefix = trimmed.slice(COMMAND_PREFIX.length);
+  const parts = withoutPrefix.split(/\s+/);
+  const command = parts[0]?.toLowerCase() ?? "";
+  const args = parts.slice(1);
+  const rawArgs = withoutPrefix.slice(command.length).trim();
+  if (!command) {
+    return null;
+  }
+  return {
+    command,
+    args,
+    rawArgs
+  };
+}
+function getCommand(name) {
+  return COMMANDS[name] ?? null;
+}
+function getAvailableCommands(isAdmin) {
+  return Object.values(COMMANDS).filter((cmd) => !cmd.adminOnly || isAdmin);
+}
+function formatHelpMessage(isAdmin) {
+  const commands = getAvailableCommands(isAdmin);
+  let message = `**可用命令：**
+
+`;
+  for (const cmd of commands) {
+    message += `\`${cmd.usage}\`
+${cmd.description}
+
+`;
+  }
+  return message;
+}
+function formatCommandError(message) {
+  return `**命令错误：** ${message}`;
+}
+function formatCommandSuccess(message) {
+  return `**成功：** ${message}`;
+}
+
+// src/commands/handler.ts
+class CommandHandler {
+  db;
+  feishuClient;
+  sessionManager;
+  opencodeClient;
+  projects;
+  availableModels;
+  cachedModels = null;
+  constructor(db, feishuClient, sessionManager, opencodeClient, config) {
+    this.db = db;
+    this.feishuClient = feishuClient;
+    this.sessionManager = sessionManager;
+    this.opencodeClient = opencodeClient;
+    this.projects = config.projects;
+    this.availableModels = config.availableModels;
+  }
+  async getModels() {
+    if (!this.cachedModels) {
+      this.cachedModels = await this.opencodeClient.listModels();
+    }
+    const allModels = this.cachedModels.map((m) => ({ id: m.id, name: m.name }));
+    return filterModels(allModels, this.availableModels);
+  }
+  async handleIfCommand(text, context) {
+    if (!isCommand(text)) {
+      return { success: true, message: "", handled: false };
+    }
+    const parsed = parseCommand(text);
+    if (!parsed) {
+      return {
+        success: false,
+        message: formatCommandError("无效的命令格式"),
+        handled: true
+      };
+    }
+    const command = getCommand(parsed.command);
+    if (!command) {
+      return {
+        success: false,
+        message: formatCommandError(`未知命令：${parsed.command}`),
+        handled: true
+      };
+    }
+    if (command.adminOnly && !context.isAdmin) {
+      return {
+        success: false,
+        message: formatCommandError("此命令需要管理员权限"),
+        handled: true
+      };
+    }
+    const result = await this.executeCommand(parsed.command, parsed.args, parsed.rawArgs, context);
+    if (result.message) {
+      await this.feishuClient.sendTextMessage(context.chatId, result.message);
+    }
+    return result;
+  }
+  async executeCommand(command, args, rawArgs, context) {
+    try {
+      switch (command) {
+        case "help":
+          return this.handleHelp(context);
+        case "switch_project":
+          return await this.handleSwitchProject(rawArgs, context);
+        case "new_session":
+          return await this.handleNewSession(context);
+        case "abort":
+          return await this.handleAbort(context);
+        case "status":
+          return await this.handleStatus(context);
+        case "new":
+          return await this.handleNew(args, context);
+        case "model":
+          return await this.handleModel(args, rawArgs, context);
+        case "compact":
+          return await this.handleCompact(context);
+        case "clear":
+          return await this.handleClear(context);
+        case "whitelist_add":
+          return await this.handleWhitelistAdd(args, context);
+        case "whitelist_remove":
+          return await this.handleWhitelistRemove(args, context);
+        case "whitelist_list":
+          return await this.handleWhitelistList(context);
+        default:
+          return {
+            success: false,
+            message: formatCommandError(`命令未实现：${command}`),
+            handled: true
+          };
+      }
+    } catch (error) {
+      logger.error("命令执行错误", { command, error });
+      return {
+        success: false,
+        message: formatCommandError(error instanceof Error ? error.message : "未知错误"),
+        handled: true
+      };
+    }
+  }
+  handleHelp(context) {
+    const message = formatHelpMessage(context.isAdmin);
+    return { success: true, message, handled: true };
+  }
+  async handleSwitchProject(path, context) {
+    if (!path.trim()) {
+      return {
+        success: false,
+        message: formatCommandError("请提供项目路径。用法：/switch_project <路径>"),
+        handled: true
+      };
+    }
+    await this.sessionManager.switchProject(context.chatId, path.trim());
+    return {
+      success: true,
+      message: formatCommandSuccess(`已切换到项目：${path.trim()}
+下次发消息时将创建新会话。`),
+      handled: true
+    };
+  }
+  async handleNewSession(context) {
+    const sessionId = await this.sessionManager.createNewSession(context.chatId);
+    return {
+      success: true,
+      message: formatCommandSuccess(`新会话已创建：${sessionId.slice(0, 8)}...`),
+      handled: true
+    };
+  }
+  async handleAbort(context) {
+    const aborted = await this.sessionManager.abortCurrentSession(context.chatId);
+    if (aborted) {
+      return {
+        success: true,
+        message: formatCommandSuccess("当前任务已中止"),
+        handled: true
+      };
+    } else {
+      return {
+        success: false,
+        message: formatCommandError("没有正在运行的任务"),
+        handled: true
+      };
+    }
+  }
+  async handleStatus(context) {
+    const session = this.db.getSession(context.chatId);
+    const projectPath = this.db.getProjectPath(context.chatId);
+    const activeCount = this.sessionManager.getActiveSessionCount();
+    let message = `**会话状态：**
+
+`;
+    if (session) {
+      message += `会话 ID：\`${session.session_id.slice(0, 8)}...\`
+`;
+      message += `项目：\`${session.project_path}\`
+`;
+      message += `创建时间：${session.created_at}
+`;
+    } else {
+      message += `无活动会话
+`;
+    }
+    if (projectPath) {
+      message += `
+配置的项目：\`${projectPath}\`
+`;
+    }
+    message += `
+活动会话数（所有用户）：${activeCount}`;
+    return { success: true, message, handled: true };
+  }
+  async handleWhitelistAdd(args, context) {
+    const userId = args[0];
+    if (!userId) {
+      return {
+        success: false,
+        message: formatCommandError("请提供用户 ID。用法：/whitelist_add <用户ID>"),
+        handled: true
+      };
+    }
+    const added = this.db.addToWhitelist(userId, context.userId);
+    if (added) {
+      return {
+        success: true,
+        message: formatCommandSuccess(`用户 ${userId} 已添加到白名单`),
+        handled: true
+      };
+    } else {
+      return {
+        success: false,
+        message: formatCommandError("用户已在白名单中"),
+        handled: true
+      };
+    }
+  }
+  async handleWhitelistRemove(args, context) {
+    const userId = args[0];
+    if (!userId) {
+      return {
+        success: false,
+        message: formatCommandError("请提供用户 ID。用法：/whitelist_remove <用户ID>"),
+        handled: true
+      };
+    }
+    const removed = this.db.removeFromWhitelist(userId);
+    if (removed) {
+      return {
+        success: true,
+        message: formatCommandSuccess(`用户 ${userId} 已从白名单移除`),
+        handled: true
+      };
+    } else {
+      return {
+        success: false,
+        message: formatCommandError("用户不在白名单中"),
+        handled: true
+      };
+    }
+  }
+  async handleWhitelistList(context) {
+    const users = this.db.getWhitelistedUsers();
+    if (users.length === 0) {
+      return {
+        success: true,
+        message: "**白名单：** 无用户",
+        handled: true
+      };
+    }
+    let message = `**白名单用户：**
+
+`;
+    for (const user of users) {
+      message += `- \`${user.user_id}\`（由 ${user.added_by} 于 ${user.added_at} 添加）
+`;
+    }
+    return { success: true, message, handled: true };
+  }
+  async handleNew(args, context) {
+    if (this.projects.length === 0) {
+      const sessionChat2 = this.sessionManager.getSessionChat(context.chatId);
+      if (sessionChat2) {
+        const sessionId = await this.sessionManager.createNewSession(context.chatId);
+        return {
+          success: true,
+          message: formatCommandSuccess(`已创建新会话
+会话 ID：${sessionId.slice(0, 8)}...`),
+          handled: true
+        };
+      }
+      const loadingMsgId2 = await this.feishuClient.sendTextMessage(context.chatId, "正在创建会话群，请稍候...");
+      const defaultPath = this.sessionManager.getDefaultProjectPath();
+      const result2 = await this.sessionManager.createSessionChat(context.userId, defaultPath);
+      if (loadingMsgId2) {
+        await this.feishuClient.deleteMessage(loadingMsgId2);
+      }
+      if (!result2) {
+        return {
+          success: false,
+          message: formatCommandError("创建会话群失败，请检查机器人权限"),
+          handled: true
+        };
+      }
+      const welcomeCard2 = createSessionChatWelcomeCard({
+        sessionId: result2.sessionId,
+        projectPath: defaultPath,
+        projects: this.projects,
+        chatId: result2.chatId,
+        models: await this.getModels()
+      });
+      await this.feishuClient.sendCard(result2.chatId, welcomeCard2);
+      const card2 = createSessionChatCreatedCard(result2.chatId, result2.sessionId, defaultPath);
+      await this.feishuClient.sendCard(context.chatId, card2);
+      return {
+        success: true,
+        message: "",
+        handled: true
+      };
+    }
+    const indexStr = args[0];
+    if (!indexStr) {
+      const projectList = this.projects.map((p, i) => `${i + 1}. ${p.name} - ${p.path}`).join(`
+`);
+      return {
+        success: false,
+        message: formatCommandError(`请提供项目编号。
+
+可用项目：
+${projectList}
+
+用法：/new <编号>`),
+        handled: true
+      };
+    }
+    const index = parseInt(indexStr, 10);
+    if (isNaN(index) || index < 1 || index > this.projects.length) {
+      return {
+        success: false,
+        message: formatCommandError(`无效的项目编号。请输入 1-${this.projects.length} 之间的数字`),
+        handled: true
+      };
+    }
+    const project = this.projects[index - 1];
+    if (!project) {
+      return {
+        success: false,
+        message: formatCommandError(`项目不存在`),
+        handled: true
+      };
+    }
+    const sessionChat = this.sessionManager.getSessionChat(context.chatId);
+    if (sessionChat) {
+      await this.sessionManager.switchProject(context.chatId, project.path);
+      const sessionId = await this.sessionManager.createNewSession(context.chatId);
+      return {
+        success: true,
+        message: formatCommandSuccess(`已切换到项目 "${project.name}"
+会话 ID：${sessionId.slice(0, 8)}...`),
+        handled: true
+      };
+    }
+    const loadingMsgId = await this.feishuClient.sendTextMessage(context.chatId, "正在创建会话群，请稍候...");
+    const result = await this.sessionManager.createSessionChat(context.userId, project.path);
+    if (loadingMsgId) {
+      await this.feishuClient.deleteMessage(loadingMsgId);
+    }
+    if (!result) {
+      return {
+        success: false,
+        message: formatCommandError("创建会话群失败，请检查机器人权限"),
+        handled: true
+      };
+    }
+    const welcomeCard = createSessionChatWelcomeCard({
+      sessionId: result.sessionId,
+      projectPath: project.path,
+      projects: this.projects,
+      chatId: result.chatId,
+      models: await this.getModels()
+    });
+    await this.feishuClient.sendCard(result.chatId, welcomeCard);
+    const card = createSessionChatCreatedCard(result.chatId, result.sessionId, project.path);
+    await this.feishuClient.sendCard(context.chatId, card);
+    return {
+      success: true,
+      message: "",
+      handled: true
+    };
+  }
+  async handleModel(args, rawArgs, context) {
+    const models = await this.getModels();
+    if (models.length === 0) {
+      return {
+        success: false,
+        message: formatCommandError("没有可用的模型"),
+        handled: true
+      };
+    }
+    const arg = rawArgs.trim();
+    if (!arg) {
+      const modelList = models.map((m, i) => `${i + 1}. ${m.name} - ${m.id}`).join(`
+`);
+      return {
+        success: false,
+        message: formatCommandError(`请提供模型编号或 ID。
+
+可用模型：
+${modelList}
+
+用法：/model <编号或ID>`),
+        handled: true
+      };
+    }
+    let selectedModel;
+    const index = parseInt(arg, 10);
+    if (!isNaN(index) && index >= 1 && index <= models.length) {
+      selectedModel = models[index - 1];
+    } else {
+      selectedModel = models.find((m) => m.id === arg || m.id.endsWith(`/${arg}`));
+    }
+    if (!selectedModel) {
+      return {
+        success: false,
+        message: formatCommandError(`未找到模型：${arg}`),
+        handled: true
+      };
+    }
+    const session = this.db.getSession(context.chatId);
+    if (!session) {
+      return {
+        success: false,
+        message: formatCommandError("请先发送消息创建会话"),
+        handled: true
+      };
+    }
+    const success = await this.opencodeClient.executeCommand(session.session_id, "model", selectedModel.id);
+    if (success) {
+      return {
+        success: true,
+        message: formatCommandSuccess(`已切换到模型：${selectedModel.name}`),
+        handled: true
+      };
+    } else {
+      return {
+        success: false,
+        message: formatCommandError("切换模型失败"),
+        handled: true
+      };
+    }
+  }
+  async handleCompact(context) {
+    const session = this.db.getSession(context.chatId);
+    if (!session) {
+      return {
+        success: false,
+        message: formatCommandError("没有活动会话"),
+        handled: true
+      };
+    }
+    const success = await this.opencodeClient.executeCommand(session.session_id, "compact");
+    if (success) {
+      return {
+        success: true,
+        message: formatCommandSuccess("上下文已压缩"),
+        handled: true
+      };
+    } else {
+      return {
+        success: false,
+        message: formatCommandError("压缩上下文失败"),
+        handled: true
+      };
+    }
+  }
+  async handleClear(context) {
+    const sessionId = await this.sessionManager.createNewSession(context.chatId);
+    return {
+      success: true,
+      message: formatCommandSuccess(`历史已清除，新会话：${sessionId.slice(0, 8)}...`),
+      handled: true
+    };
+  }
+}
+function createCommandHandler(db, feishuClient, sessionManager, opencodeClient, config) {
+  return new CommandHandler(db, feishuClient, sessionManager, opencodeClient, config);
+}
+
+// src/utils/reconnect.ts
+var DEFAULT_CONFIG = {
+  maxRetries: 10,
+  initialDelayMs: 1000,
+  maxDelayMs: 30000,
+  backoffMultiplier: 2
+};
+
+class ReconnectionManager {
+  config;
+  retryCount = 0;
+  isConnected = false;
+  shouldReconnect = true;
+  connectFn;
+  disconnectFn;
+  reconnectTimeout = null;
+  constructor(connectFn, disconnectFn, config) {
+    this.connectFn = connectFn;
+    this.disconnectFn = disconnectFn;
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  async connect() {
+    this.shouldReconnect = true;
+    await this.attemptConnection();
+  }
+  async attemptConnection() {
+    try {
+      await this.connectFn();
+      this.isConnected = true;
+      this.retryCount = 0;
+      logger.info("连接已建立");
+    } catch (error) {
+      this.isConnected = false;
+      logger.error("连接失败", error);
+      await this.scheduleReconnect();
+    }
+  }
+  async scheduleReconnect() {
+    if (!this.shouldReconnect) {
+      logger.info("重连已禁用，不进行重试");
+      return;
+    }
+    if (this.retryCount >= this.config.maxRetries) {
+      logger.error("已达最大重试次数，放弃重连", { retryCount: this.retryCount });
+      return;
+    }
+    const delay = this.calculateDelay();
+    this.retryCount++;
+    logger.info("计划重连", {
+      retryCount: this.retryCount,
+      delayMs: delay,
+      maxRetries: this.config.maxRetries
+    });
+    this.reconnectTimeout = setTimeout(async () => {
+      this.reconnectTimeout = null;
+      await this.attemptConnection();
+    }, delay);
+  }
+  calculateDelay() {
+    const delay = this.config.initialDelayMs * Math.pow(this.config.backoffMultiplier, this.retryCount);
+    return Math.min(delay, this.config.maxDelayMs);
+  }
+  async disconnect() {
+    this.shouldReconnect = false;
+    if (this.reconnectTimeout) {
+      clearTimeout(this.reconnectTimeout);
+      this.reconnectTimeout = null;
+    }
+    if (this.isConnected && this.disconnectFn) {
+      try {
+        await this.disconnectFn();
+      } catch (error) {
+        logger.error("断开连接时出错", error);
+      }
+    }
+    this.isConnected = false;
+    this.retryCount = 0;
+    logger.info("已断开连接");
+  }
+  onDisconnect() {
+    if (this.isConnected) {
+      this.isConnected = false;
+      logger.warn("连接丢失，计划重连");
+      this.scheduleReconnect();
+    }
+  }
+  getStatus() {
+    return {
+      isConnected: this.isConnected,
+      retryCount: this.retryCount
+    };
+  }
+}
+function createReconnectionManager(connectFn, disconnectFn, config) {
+  return new ReconnectionManager(connectFn, disconnectFn, config);
+}
+
+class GlobalErrorHandler {
+  static instance = null;
+  handlers = [];
+  static getInstance() {
+    if (!GlobalErrorHandler.instance) {
+      GlobalErrorHandler.instance = new GlobalErrorHandler;
+    }
+    return GlobalErrorHandler.instance;
+  }
+  register(handler) {
+    this.handlers.push(handler);
+    return () => {
+      const index = this.handlers.indexOf(handler);
+      if (index >= 0) {
+        this.handlers.splice(index, 1);
+      }
+    };
+  }
+  handle(error) {
+    logger.error("全局错误", error);
+    for (const handler of this.handlers) {
+      try {
+        handler(error);
+      } catch (handlerError) {
+        logger.error("错误处理器出错", handlerError);
+      }
+    }
+  }
+  setupProcessHandlers() {
+    process.on("uncaughtException", (error) => {
+      logger.error("未捕获的异常", error);
+      this.handle(error);
+    });
+    process.on("unhandledRejection", (reason) => {
+      const error = reason instanceof Error ? reason : new Error(String(reason));
+      logger.error("未处理的 Promise 拒绝", error);
+      this.handle(error);
+    });
+  }
+}
+function setupGlobalErrorHandling() {
+  const handler = GlobalErrorHandler.getInstance();
+  handler.setupProcessHandlers();
+  return handler;
+}
+
+// src/feishu/welcome.ts
+function createWelcomeCard(info, chatName) {
+  const greeting = chatName ? `已加入「${chatName}」` : "你好！";
+  const elements = [
+    {
+      tag: "markdown",
+      content: `我是 OpenCode AI 编程助手，可以帮助你完成编程任务。
+
+**当前状态**
+- 工作目录：\`${info.projectPath}\`
+- 活跃会话：${info.activeSessionCount} 个
+${info.version ? `- 版本：${info.version}` : ""}`
+    },
+    { tag: "hr" },
+    {
+      tag: "markdown",
+      content: `**常用命令**
+\`/help\` - 显示帮助信息
+\`/status\` - 查看当前状态
+\`/new_session\` - 创建新会话
+\`/switch_project <路径>\` - 切换项目目录
+\`/abort\` - 中止当前任务`
+    },
+    { tag: "hr" },
+    {
+      tag: "note",
+      elements: [{ tag: "plain_text", content: "直接发送消息即可开始对话" }]
+    }
+  ];
+  return {
+    config: { wide_screen_mode: true },
+    header: {
+      title: { tag: "plain_text", content: greeting },
+      template: "blue"
+    },
+    elements
+  };
+}
+
+// src/events/handler.ts
+function setupEventHandlers(config) {
+  const { feishuClient, sessionManager, opencodeClient, projects, availableModels } = config;
+  const getFilteredModels = async () => {
+    const allModels = await opencodeClient.listModels();
+    const mapped = allModels.map((m) => ({ id: m.id, name: m.name }));
+    return filterModels(mapped, availableModels);
+  };
+  feishuClient.onBotAdded(async (event) => {
+    logger.info("机器人被添加到群聊", { chatId: event.chatId, chatName: event.chatName });
+    const botInfo = {
+      projectPath: sessionManager.getDefaultProjectPath(),
+      activeSessionCount: sessionManager.getActiveSessionCount()
+    };
+    const card = createWelcomeCard(botInfo, event.chatName);
+    await feishuClient.sendCard(event.chatId, card);
+  });
+  feishuClient.onMessageRecalled(async (event) => {
+    logger.info("消息被撤回", { messageId: event.messageId, chatId: event.chatId });
+    const result = await sessionManager.handleMessageRecall(event.messageId);
+    if (result.aborted || result.botMessagesDeleted > 0) {
+      logger.info("撤回处理完成", { ...result, messageId: event.messageId });
+    }
+  });
+  feishuClient.onBotRemoved(async (event) => {
+    logger.info("机器人被移出群聊", { chatId: event.chatId });
+    const sessionChat = sessionManager.getSessionChat(event.chatId);
+    if (sessionChat) {
+      await sessionManager.cleanupSessionChat(event.chatId);
+    } else {
+      sessionManager.cleanupChatData(event.chatId);
+    }
+  });
+  feishuClient.onUserLeftChat(async (event) => {
+    logger.info("用户退出群聊", { chatId: event.chatId, users: event.users });
+    await sessionManager.handleUserLeftSessionChat(event.chatId);
+  });
+  feishuClient.onChatDisbanded(async (event) => {
+    logger.info("群聊被解散", { chatId: event.chatId });
+    await sessionManager.cleanupSessionChat(event.chatId);
+  });
+  feishuClient.onBotMenu(async (event) => {
+    logger.info("菜单点击", { eventKey: event.eventKey, operatorId: event.operatorId });
+    const userId = event.operatorId;
+    if (!userId) {
+      logger.warn("菜单事件缺少操作者 ID");
+      return;
+    }
+    try {
+      switch (event.eventKey) {
+        case "new_session": {
+          if (projects.length === 0) {
+            const defaultPath = sessionManager.getDefaultProjectPath();
+            const loadingCard = createSuccessCard("正在创建...", "正在创建会话群，请稍候...");
+            const loadingMsgId = await feishuClient.sendCardToUser(userId, loadingCard);
+            const result = await sessionManager.createSessionChat(userId, defaultPath);
+            if (result) {
+              const models = await getFilteredModels();
+              const welcomeCard = createSessionChatWelcomeCard({
+                sessionId: result.sessionId,
+                projectPath: defaultPath,
+                projects,
+                chatId: result.chatId,
+                models
+              });
+              await feishuClient.sendCard(result.chatId, welcomeCard);
+              const successCard = createSessionChatCreatedCard(result.chatId, result.sessionId, defaultPath);
+              if (loadingMsgId) {
+                await feishuClient.updateCard(loadingMsgId, successCard);
+              } else {
+                await feishuClient.sendCardToUser(userId, successCard);
+              }
+            } else {
+              const errorCard = createErrorCard("创建失败", "创建会话群时发生错误，请稍后重试");
+              if (loadingMsgId) {
+                await feishuClient.updateCard(loadingMsgId, errorCard);
+              } else {
+                await feishuClient.sendCardToUser(userId, errorCard);
+              }
+            }
+            break;
+          }
+          if (event.chatId) {
+            const sessionChat = sessionManager.getSessionChat(event.chatId);
+            if (sessionChat) {
+              const card = createProjectSelectCard(projects, "切换项目后将创建新会话");
+              await feishuClient.sendMessage(event.chatId, JSON.stringify(card), "interactive");
+            } else {
+              const card = createProjectSelectCard(projects);
+              await feishuClient.sendCardToUser(userId, card);
+            }
+          } else {
+            const card = createProjectSelectCard(projects);
+            await feishuClient.sendCardToUser(userId, card);
+          }
+          break;
+        }
+        case "switch_model": {
+          const models = await getFilteredModels();
+          const card = createModelSelectCard(models);
+          if (event.chatId) {
+            await feishuClient.sendCard(event.chatId, card);
+          } else {
+            await feishuClient.sendCardToUser(userId, card);
+          }
+          break;
+        }
+        case "compact": {
+          const sessionId = await sessionManager.getOrCreateUserSession(userId);
+          if (sessionId) {
+            const success = await opencodeClient.executeCommand(sessionId, "compact");
+            const card = success ? createSuccessCard("压缩上下文", "上下文已成功压缩") : createErrorCard("压缩失败", "执行 compact 命令时发生错误");
+            await feishuClient.sendCardToUser(userId, card);
+          }
+          break;
+        }
+        case "clear_history": {
+          await sessionManager.createNewUserSession(userId);
+          const card = createSuccessCard("清除历史", "会话历史已清除，已创建新会话");
+          await feishuClient.sendCardToUser(userId, card);
+          break;
+        }
+        case "show_status": {
+          const session = await sessionManager.getUserSessionInfo(userId);
+          if (session) {
+            const status = {
+              sessionId: session.sessionId,
+              projectPath: session.projectPath,
+              isActive: session.isActive
+            };
+            const card = createStatusCard(status);
+            await feishuClient.sendCardToUser(userId, card);
+          } else {
+            const card = createErrorCard("无会话", "当前没有活跃的会话");
+            await feishuClient.sendCardToUser(userId, card);
+          }
+          break;
+        }
+        case "show_cost": {
+          const card = createErrorCard("功能开发中", "费用统计功能正在开发中");
+          await feishuClient.sendCardToUser(userId, card);
+          break;
+        }
+        default:
+          logger.warn("未知的菜单事件", { eventKey: event.eventKey });
+      }
+    } catch (error) {
+      logger.error("处理菜单事件时出错", error);
+      const card = createErrorCard("操作失败", `处理菜单操作时发生错误: ${error instanceof Error ? error.message : "未知错误"}`);
+      await feishuClient.sendCardToUser(userId, card);
+    }
+  });
+  feishuClient.onCardAction(async (event) => {
+    const actionType = event.action.value?.action;
+    logger.info("卡片交互", { action: actionType, operatorId: event.operatorId });
+    if (!event.operatorId) {
+      logger.warn("卡片交互事件缺少操作者 ID");
+      return;
+    }
+    try {
+      switch (actionType) {
+        case "switch_model": {
+          const modelId = event.action.option;
+          if (!modelId) {
+            logger.warn("切换模型未选择模型");
+            return;
+          }
+          const chatId = event.chatId;
+          if (!chatId) {
+            logger.warn("切换模型缺少 chatId");
+            return;
+          }
+          const sessionChat = sessionManager.getSessionChat(chatId);
+          let sessionId = null;
+          if (sessionChat) {
+            sessionId = sessionChat.session_id;
+          } else {
+            sessionId = await sessionManager.getOrCreateUserSession(event.operatorId);
+          }
+          if (!sessionId) {
+            logger.error("获取会话失败");
+            return;
+          }
+          const success = await opencodeClient.executeCommand(sessionId, "model", modelId);
+          if (event.messageId) {
+            const card = success ? createSuccessCard("切换成功", `已切换到模型：\`${modelId}\``) : createErrorCard("切换失败", "切换模型时发生错误");
+            await feishuClient.updateCard(event.messageId, card);
+          }
+          break;
+        }
+        case "question_answer": {
+          const chatId = event.chatId;
+          if (!chatId) {
+            logger.warn("问题回答缺少 chatId");
+            return;
+          }
+          const { requestId, questionIndex, answerLabel } = event.action.value;
+          const selectedOption = event.action.option || answerLabel;
+          if (!requestId || questionIndex === undefined || !selectedOption) {
+            logger.warn("问题回答缺少必要参数", { requestId, questionIndex, selectedOption });
+            return;
+          }
+          const success = await sessionManager.handleQuestionAnswer(chatId, requestId, questionIndex, selectedOption, event.messageId);
+          if (!success && event.messageId) {
+            const errorCard = createQuestionErrorCard("问题已过期或不存在");
+            await feishuClient.updateCard(event.messageId, errorCard);
+          }
+          break;
+        }
+        case "switch_project_in_chat": {
+          const chatId = event.chatId || event.action.value?.chatId;
+          const projectPath = event.action.option;
+          if (!chatId || !projectPath) {
+            logger.warn("切换项目缺少必要参数", { chatId, projectPath });
+            return;
+          }
+          const sessionChat = sessionManager.getSessionChat(chatId);
+          if (!sessionChat) {
+            logger.warn("切换项目：非会话群", { chatId });
+            return;
+          }
+          await sessionManager.switchProject(chatId, projectPath);
+          const newSessionId = await sessionManager.createNewSession(chatId);
+          const project = projects.find((p) => p.path === projectPath);
+          const projectName = project?.name || projectPath;
+          const card = createProjectSwitchedCard(projectName, projectPath, newSessionId);
+          await feishuClient.sendCard(chatId, card);
+          break;
+        }
+        case "new_session_in_chat": {
+          const chatId = event.chatId || event.action.value?.chatId;
+          if (!chatId) {
+            logger.warn("新建会话缺少 chatId");
+            return;
+          }
+          const sessionChat = sessionManager.getSessionChat(chatId);
+          if (!sessionChat) {
+            logger.warn("新建会话：非会话群", { chatId });
+            return;
+          }
+          const newSessionId = await sessionManager.createNewSession(chatId);
+          const shortId = newSessionId.replace(/^ses_/, "").slice(0, 8);
+          const card = createSuccessCard("✅ 新会话已创建", `会话 ID：\`${shortId}\`
+
+发送消息开始新对话`);
+          await feishuClient.sendCard(chatId, card);
+          break;
+        }
+        case "show_status_in_chat": {
+          const chatId = event.chatId || event.action.value?.chatId;
+          if (!chatId) {
+            logger.warn("显示状态缺少 chatId");
+            return;
+          }
+          const sessionChat = sessionManager.getSessionChat(chatId);
+          if (!sessionChat) {
+            const card2 = createErrorCard("无会话", "当前没有活跃的会话");
+            await feishuClient.sendCard(chatId, card2);
+            return;
+          }
+          const status = {
+            sessionId: sessionChat.session_id,
+            projectPath: sessionChat.project_path,
+            isActive: true
+          };
+          const card = createStatusCard(status);
+          await feishuClient.sendCard(chatId, card);
+          break;
+        }
+        default:
+          logger.debug("未处理的卡片交互", { action: actionType });
+      }
+    } catch (error) {
+      logger.error("处理卡片交互时出错", error);
+    }
+  });
+}
+
+// src/index.ts
+async function listAvailableModels() {
+  const tempClient = createOpencodeWrapper({});
+  try {
+    await tempClient.start();
+    const models = await tempClient.listModels();
+    console.log(`
+可用模型列表：
+`);
+    models.forEach((model, index) => {
+      console.log(`  ${index + 1}. ${model.name}`);
+      console.log(`     ID: ${model.id}`);
+      console.log("");
+    });
+    console.log(`共 ${models.length} 个模型
+`);
+  } finally {
+    tempClient.stop();
+  }
+}
+async function main() {
+  const cliOptions = parseArgs();
+  if (cliOptions.help) {
+    console.log(formatHelp());
+    process.exit(0);
+  }
+  if (cliOptions.version) {
+    console.log(`v${getVersion()}`);
+    process.exit(0);
+  }
+  if (cliOptions.listModels) {
+    await listAvailableModels();
+    process.exit(0);
+  }
+  setupGlobalErrorHandling();
+  const logLevel = cliOptions.logLevel && isValidLogLevel(cliOptions.logLevel) ? cliOptions.logLevel : undefined;
+  const config = loadConfig({
+    model: cliOptions.model,
+    logLevel
+  });
+  setLogLevel(config.LOG_LEVEL);
+  logger.info("正在启动飞书 OpenCode 机器人...");
+  const db = initializeDatabase(config.DATABASE_PATH);
+  logger.info("数据库已初始化", { path: config.DATABASE_PATH });
+  const feishuClient = createFeishuClient({
+    appId: config.FEISHU_APP_ID,
+    appSecret: config.FEISHU_APP_SECRET
+  });
+  const defaultProjectPath = getDefaultProjectPath(cliOptions.project);
+  const defaultModel = getDefaultModel(config);
+  const opencodeClient = createOpencodeWrapper({
+    directory: defaultProjectPath
+  });
+  const opencodeUrl = await opencodeClient.start();
+  const adminUserIds = getAdminUserIds(config);
+  const sessionManager = createSessionManager(db, feishuClient, opencodeClient, {
+    defaultProjectPath,
+    adminUserIds,
+    allowAllUsers: config.ALLOW_ALL_USERS
+  });
+  const projects = getProjects(config);
+  const availableModels = getAvailableModels(config);
+  const commandHandler = createCommandHandler(db, feishuClient, sessionManager, opencodeClient, { projects, availableModels });
+  setupEventHandlers({
+    feishuClient,
+    sessionManager,
+    opencodeClient,
+    projects,
+    availableModels
+  });
+  feishuClient.onMessage(async (event) => {
+    logger.debug("收到消息", {
+      chatId: event.chatId,
+      senderId: event.senderId,
+      messageType: event.messageType
+    });
+    const text = parseTextContent(event.content);
+    if (isCommand(text)) {
+      const result = await commandHandler.handleIfCommand(text, {
+        chatId: event.chatId,
+        userId: event.senderId,
+        isAdmin: sessionManager.isAdmin(event.senderId)
+      });
+      if (result.handled) {
+        return;
+      }
+    }
+    await sessionManager.handleMessage(event);
+  });
+  const reconnectionManager = createReconnectionManager(async () => {
+    await feishuClient.start();
+  }, async () => {
+    await feishuClient.stop();
+  }, {
+    maxRetries: 10,
+    initialDelayMs: 1000,
+    maxDelayMs: 30000
+  });
+  await reconnectionManager.connect();
+  logger.info("飞书 OpenCode 机器人启动成功");
+  logger.info("配置信息", {
+    appId: config.FEISHU_APP_ID.substring(0, 8) + "...",
+    opencodeUrl,
+    defaultProject: defaultProjectPath,
+    defaultModel: defaultModel || "(未设置)",
+    adminCount: adminUserIds.length
+  });
+  const shutdown = async (signal) => {
+    logger.info(`收到 ${signal} 信号，正在关闭...`);
+    sessionManager.cleanup();
+    await reconnectionManager.disconnect();
+    opencodeClient.stop();
+    db.close();
+    logger.info("关闭完成");
+    process.exit(0);
+  };
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+}
+main().catch((error) => {
+  logger.error("致命错误", error);
+  process.exit(1);
+});