feishu-bridge 1.0.0

package/dist/cli/index.js

@@ -0,0 +1,3324 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/core/logger.ts
+var import_pino, Logger, logger;
+var init_logger = __esm({
+  "src/core/logger.ts"() {
+    "use strict";
+    import_pino = __toESM(require("pino"));
+    Logger = class _Logger {
+      constructor() {
+        const isTest = process.env.NODE_ENV === "test" || process.env.VITEST;
+        this.logger = (0, import_pino.default)({
+          level: process.env.LOG_LEVEL || "info",
+          transport: isTest ? void 0 : {
+            target: "pino-pretty",
+            options: {
+              colorize: true,
+              translateTime: "SYS:standard",
+              ignore: "pid,hostname"
+            }
+          }
+        });
+      }
+      setLevel(level) {
+        this.logger.level = level;
+      }
+      debug(msg, ...args) {
+        this.logger.debug(msg, ...args);
+      }
+      info(msg, ...args) {
+        this.logger.info(msg, ...args);
+      }
+      warn(msg, ...args) {
+        this.logger.warn(msg, ...args);
+      }
+      error(msg, ...args) {
+        this.logger.error(msg, ...args);
+      }
+      child(bindings) {
+        const childLogger = new _Logger();
+        childLogger.logger = this.logger.child(bindings);
+        return childLogger;
+      }
+    };
+    logger = new Logger();
+  }
+});
+
+// src/core/config.ts
+var DEFAULT_CONFIG, ConfigManager;
+var init_config = __esm({
+  "src/core/config.ts"() {
+    "use strict";
+    DEFAULT_CONFIG = {
+      feishu: {
+        appId: "",
+        appSecret: "",
+        domain: "feishu",
+        connectionMode: "webhook",
+        encryptKey: void 0,
+        verificationToken: void 0
+      },
+      server: {
+        port: 3e3,
+        host: "0.0.0.0",
+        webhookPath: "/webhook/feishu"
+      },
+      adapters: {
+        vscode: { enabled: true },
+        cursor: { enabled: true },
+        trae: { enabled: true },
+        antigravity: { enabled: true },
+        kiro: { enabled: true },
+        opencode: { enabled: true },
+        "claude-code": { enabled: true }
+      },
+      behavior: {
+        autoStart: true,
+        maxOutputLength: 2e3,
+        sessionTimeout: 30,
+        reverseChannelEnabled: true,
+        reverseChannelMode: "filesystem"
+      },
+      logging: {
+        level: "info",
+        file: void 0
+      }
+    };
+    ConfigManager = class _ConfigManager {
+      constructor() {
+        this.config = DEFAULT_CONFIG;
+      }
+      static getInstance() {
+        if (!_ConfigManager.instance) {
+          _ConfigManager.instance = new _ConfigManager();
+        }
+        return _ConfigManager.instance;
+      }
+      load(config) {
+        this.config = this.deepMerge(this.config, config);
+      }
+      deepMerge(target, source) {
+        const output = { ...target };
+        if (this.isObject(target) && this.isObject(source)) {
+          Object.keys(source).forEach((key) => {
+            if (this.isObject(source[key])) {
+              if (!(key in target)) {
+                Object.assign(output, { [key]: source[key] });
+              } else {
+                output[key] = this.deepMerge(target[key], source[key]);
+              }
+            } else {
+              Object.assign(output, { [key]: source[key] });
+            }
+          });
+        }
+        return output;
+      }
+      isObject(item) {
+        return item && typeof item === "object" && !Array.isArray(item);
+      }
+      get() {
+        return this.config;
+      }
+      getFeishuConfig() {
+        return this.config.feishu;
+      }
+      getServerConfig() {
+        return this.config.server;
+      }
+      getAdapterConfig(adapter) {
+        return this.config.adapters[adapter];
+      }
+      getBehaviorConfig() {
+        return this.config.behavior;
+      }
+      getLoggingConfig() {
+        return this.config.logging;
+      }
+    };
+  }
+});
+
+// src/core/daemon.ts
+var daemon_exports = {};
+__export(daemon_exports, {
+  DaemonManager: () => DaemonManager,
+  ProcessDaemon: () => ProcessDaemon,
+  default: () => daemon_default
+});
+var import_child_process, ProcessDaemon, DaemonManager, daemon_default;
+var init_daemon = __esm({
+  "src/core/daemon.ts"() {
+    "use strict";
+    import_child_process = require("child_process");
+    init_logger();
+    init_config();
+    ProcessDaemon = class {
+      constructor(command, args = [], options = {}) {
+        this.command = command;
+        this.args = args;
+        this.options = options;
+        this.process = null;
+        this.restartCount = 0;
+        this.isRunning = false;
+        this.healthCheckTimer = null;
+        this.logger = new Logger();
+        const daemonConfig = ConfigManager.getInstance().get().daemon;
+        this.config = {
+          maxRestarts: daemonConfig?.maxRestarts || 5,
+          restartDelay: daemonConfig?.restartDelay || 5e3,
+          healthCheckInterval: daemonConfig?.healthCheckInterval || 3e4
+        };
+      }
+      /**
+       * 启动守护进程
+       */
+      async start() {
+        if (this.isRunning) {
+          this.logger.warn("Daemon already running");
+          return;
+        }
+        this.isRunning = true;
+        this.restartCount = 0;
+        this.logger.info("Starting process daemon...");
+        await this.spawnProcess();
+        this.startHealthCheck();
+      }
+      /**
+       * 停止守护进程
+       */
+      async stop() {
+        this.isRunning = false;
+        if (this.healthCheckTimer) {
+          clearInterval(this.healthCheckTimer);
+          this.healthCheckTimer = null;
+        }
+        if (this.process) {
+          this.logger.info("Stopping daemon process...");
+          this.process.kill("SIGTERM");
+          await new Promise((resolve) => setTimeout(resolve, 5e3));
+          if (this.process && !this.process.killed) {
+            this.process.kill("SIGKILL");
+          }
+          this.process = null;
+        }
+        this.logger.info("Daemon stopped");
+      }
+      /**
+       * 创建子进程
+       */
+      async spawnProcess() {
+        return new Promise((resolve) => {
+          this.logger.info(`Spawning: ${this.command} ${this.args.join(" ")}`);
+          this.process = (0, import_child_process.spawn)(this.command, this.args, {
+            stdio: "pipe",
+            detached: false,
+            ...this.options
+          });
+          this.process.stdout?.on("data", (data) => {
+            process.stdout.write(data);
+          });
+          this.process.stderr?.on("data", (data) => {
+            process.stderr.write(data);
+          });
+          this.process.on("exit", (code, signal) => {
+            this.logger.warn(`Process exited with code ${code}, signal ${signal}`);
+            this.process = null;
+            if (this.isRunning) {
+              this.handleCrash();
+            }
+          });
+          this.process.on("error", (error) => {
+            this.logger.error("Process error:", error);
+            this.process = null;
+            if (this.isRunning) {
+              this.handleCrash();
+            }
+          });
+          setTimeout(() => {
+            if (this.process && !this.process.killed) {
+              this.logger.info("Process started successfully");
+              this.restartCount = 0;
+            }
+            resolve();
+          }, 2e3);
+        });
+      }
+      /**
+       * 处理进程崩溃
+       */
+      handleCrash() {
+        if (!this.isRunning) return;
+        this.restartCount++;
+        if (this.restartCount > this.config.maxRestarts) {
+          this.logger.error(`Max restarts (${this.config.maxRestarts}) reached. Giving up.`);
+          this.isRunning = false;
+          process.exit(1);
+        }
+        this.logger.info(`Restarting process (attempt ${this.restartCount}/${this.config.maxRestarts})...`);
+        setTimeout(() => {
+          if (this.isRunning) {
+            this.spawnProcess();
+          }
+        }, this.config.restartDelay);
+      }
+      /**
+       * 启动健康检查
+       */
+      startHealthCheck() {
+        this.healthCheckTimer = setInterval(() => {
+          if (!this.isRunning) return;
+          if (!this.process || this.process.killed) {
+            this.logger.warn("Health check: Process not running, restarting...");
+            this.handleCrash();
+          }
+        }, this.config.healthCheckInterval);
+      }
+      /**
+       * 获取守护状态
+       */
+      getStatus() {
+        return {
+          isRunning: this.isRunning,
+          pid: this.process?.pid || null,
+          restartCount: this.restartCount,
+          uptime: process.uptime()
+        };
+      }
+    };
+    DaemonManager = class _DaemonManager {
+      constructor() {
+        this.daemon = null;
+      }
+      static getInstance() {
+        if (!_DaemonManager.instance) {
+          _DaemonManager.instance = new _DaemonManager();
+        }
+        return _DaemonManager.instance;
+      }
+      /**
+       * 启动守护进程
+       */
+      async start(args = []) {
+        if (this.daemon) {
+          console.log("Daemon already running");
+          return;
+        }
+        const nodePath = process.execPath;
+        const scriptPath = require.resolve("../index.js");
+        this.daemon = new ProcessDaemon(nodePath, [scriptPath, ...args], {
+          cwd: process.cwd(),
+          env: process.env
+        });
+        await this.daemon.start();
+        process.on("SIGINT", () => this.stop());
+        process.on("SIGTERM", () => this.stop());
+      }
+      /**
+       * 停止守护进程
+       */
+      async stop() {
+        if (this.daemon) {
+          await this.daemon.stop();
+          this.daemon = null;
+        }
+      }
+      /**
+       * 获取状态
+       */
+      getStatus() {
+        return this.daemon?.getStatus() || null;
+      }
+    };
+    daemon_default = DaemonManager;
+  }
+});
+
+// src/cli/index.ts
+var import_commander = require("commander");
+var fs10 = __toESM(require("fs"));
+var path10 = __toESM(require("path"));
+
+// src/cli/config.ts
+var import_cosmiconfig = require("cosmiconfig");
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var os = __toESM(require("os"));
+var moduleName = "feishu-bridge";
+var explorer = (0, import_cosmiconfig.cosmiconfigSync)(moduleName, {
+  searchPlaces: [
+    "package.json",
+    `.${moduleName}rc`,
+    `.${moduleName}rc.json`,
+    `.${moduleName}rc.yaml`,
+    `.${moduleName}rc.yml`,
+    `.${moduleName}rc.js`,
+    `.${moduleName}rc.cjs`,
+    `${moduleName}.config.js`,
+    `${moduleName}.config.cjs`
+  ]
+});
+function getDefaultConfigPath() {
+  const configDir = path.join(os.homedir(), ".config", moduleName);
+  if (!fs.existsSync(configDir)) {
+    fs.mkdirSync(configDir, { recursive: true });
+  }
+  return path.join(configDir, "config.json");
+}
+function getConfig() {
+  const result = explorer.search();
+  if (result?.config) {
+    return result.config;
+  }
+  const homeConfigPath = getDefaultConfigPath();
+  if (fs.existsSync(homeConfigPath)) {
+    try {
+      const content = fs.readFileSync(homeConfigPath, "utf-8");
+      return JSON.parse(content);
+    } catch (error) {
+      console.error("Error reading home config file:", error);
+    }
+  }
+  return {};
+}
+function getConfigValue(key) {
+  const config = getConfig();
+  const keys = key.split(".");
+  let value = config;
+  for (const k of keys) {
+    if (value === void 0 || value === null) {
+      return void 0;
+    }
+    value = value[k];
+  }
+  return value;
+}
+function setConfigValue(key, value) {
+  const configPath = getDefaultConfigPath();
+  let config = {};
+  if (fs.existsSync(configPath)) {
+    try {
+      const content = fs.readFileSync(configPath, "utf-8");
+      config = JSON.parse(content);
+    } catch (error) {
+      console.error("Error reading config file:", error);
+    }
+  }
+  const keys = key.split(".");
+  let current = config;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const k = keys[i];
+    if (!(k in current) || typeof current[k] !== "object") {
+      current[k] = {};
+    }
+    current = current[k];
+  }
+  const finalKey = keys[keys.length - 1];
+  current[finalKey] = convertValueType(value);
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+}
+function deleteConfigValue(key) {
+  const configPath = getDefaultConfigPath();
+  if (!fs.existsSync(configPath)) {
+    return;
+  }
+  let config = {};
+  try {
+    const content = fs.readFileSync(configPath, "utf-8");
+    config = JSON.parse(content);
+  } catch (error) {
+    console.error("Error reading config file:", error);
+    return;
+  }
+  const keys = key.split(".");
+  let current = config;
+  for (let i = 0; i < keys.length - 1; i++) {
+    const k = keys[i];
+    if (!(k in current)) {
+      return;
+    }
+    current = current[k];
+  }
+  delete current[keys[keys.length - 1]];
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+}
+function listConfig() {
+  return getConfig();
+}
+function convertValueType(value) {
+  if (!isNaN(Number(value)) && value.trim() !== "") {
+    return Number(value);
+  }
+  if (value.toLowerCase() === "true") {
+    return true;
+  }
+  if (value.toLowerCase() === "false") {
+    return false;
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+function getConfigFilePath() {
+  const result = explorer.search();
+  if (result?.filepath) {
+    return result.filepath;
+  }
+  return getDefaultConfigPath();
+}
+
+// src/feishu/webhook.ts
+var crypto = __toESM(require("crypto"));
+init_logger();
+init_config();
+var FeishuWebhookHandler = class {
+  constructor(client, commandExecutor) {
+    this.client = client;
+    this.commandExecutor = commandExecutor;
+    this.logger = new Logger();
+  }
+  async handleWebhook(request, reply) {
+    try {
+      const signature = request.headers["x-lark-signature"];
+      const timestamp = request.headers["x-lark-timestamp"];
+      const body = request.body;
+      if (!this.verifySignature(signature, timestamp, body)) {
+        this.logger.warn("Invalid signature received");
+        reply.status(401).send({ error: "Invalid signature" });
+        return;
+      }
+      const event = JSON.parse(body);
+      if (event.type === "url_verification") {
+        this.logger.info("Received URL verification challenge");
+        reply.send({ challenge: event.challenge });
+        return;
+      }
+      if (event.type === "event_callback" && event.event) {
+        await this.handleEvent(event.event);
+      }
+      reply.send({ success: true });
+    } catch (error) {
+      this.logger.error("Error handling webhook:", error);
+      reply.status(500).send({ error: "Internal server error" });
+    }
+  }
+  verifySignature(signature, timestamp, body) {
+    const config = ConfigManager.getInstance().getFeishuConfig();
+    const encryptKey = config.encryptKey;
+    if (!encryptKey) {
+      this.logger.warn("No encrypt key configured, skipping signature verification (development mode)");
+      return true;
+    }
+    const now = Math.floor(Date.now() / 1e3);
+    const requestTime = parseInt(timestamp, 10);
+    const timeDiff = Math.abs(now - requestTime);
+    if (timeDiff > 300) {
+      this.logger.warn(`Request timestamp too old: ${timeDiff}s difference`);
+      return false;
+    }
+    try {
+      const signatureContent = `${timestamp}
+${body}`;
+      const computedSignature = crypto.createHmac("sha256", encryptKey).update(signatureContent).digest("base64");
+      const expectedSig = Buffer.from(computedSignature);
+      const receivedSig = Buffer.from(signature);
+      if (expectedSig.length !== receivedSig.length) {
+        return false;
+      }
+      return crypto.timingSafeEqual(expectedSig, receivedSig);
+    } catch (error) {
+      this.logger.error("Error verifying signature:", error);
+      return false;
+    }
+  }
+  async handleEvent(event) {
+    const { message } = event;
+    if (message.message_type !== "text") {
+      this.logger.info("Ignoring non-text message");
+      return;
+    }
+    const content = JSON.parse(message.content);
+    const text = content.text.trim();
+    const sender = event.sender.sender_id.open_id;
+    this.logger.info(`Received message from ${sender}: ${text}`);
+    const target = this.extractTargetIDE(text);
+    const command = this.extractCommand(text);
+    const result = await this.commandExecutor.execute({
+      target,
+      command,
+      sender,
+      chatId: message.chat_id
+    });
+    const formattedResponse = this.formatResponse(result);
+    await this.client.sendMessage(message.chat_id, {
+      msg_type: "text",
+      content: {
+        text: formattedResponse
+      }
+    });
+  }
+  extractTargetIDE(text) {
+    const match = text.match(/@(vscode|cursor|trae|antigravity|kiro|opencode|claude)/i);
+    return match ? match[1].toLowerCase() : "auto";
+  }
+  extractCommand(text) {
+    const cleanedText = text.replace(/@(vscode|cursor|trae|antigravity|kiro|opencode|claude)\s*/i, "").trim();
+    return cleanedText;
+  }
+  formatResponse(result) {
+    if (result.success) {
+      const output = typeof result.output === "string" ? result.output.substring(0, 2e3) : JSON.stringify(result.output).substring(0, 2e3);
+      return `\u2705 \u6267\u884C\u6210\u529F
+
+${output}`;
+    } else {
+      const error = result.error || result.stderr || "Unknown error";
+      return `\u274C \u6267\u884C\u5931\u8D25
+
+${error.substring(0, 2e3)}`;
+    }
+  }
+};
+
+// src/feishu/websocket.ts
+var import_ws = require("ws");
+init_logger();
+init_config();
+var FeishuWebSocketHandler = class {
+  constructor(client, commandExecutor) {
+    this.client = client;
+    this.commandExecutor = commandExecutor;
+    this.ws = null;
+    this.reconnectAttempts = 0;
+    this.maxReconnectAttempts = 5;
+    this.reconnectInterval = 5e3;
+    // 5秒
+    this.heartbeatInterval = null;
+    this.isRunning = false;
+    this.logger = new Logger();
+  }
+  /**
+   * 启动WebSocket连接
+   */
+  async start() {
+    if (this.isRunning) {
+      this.logger.warn("WebSocket handler already running");
+      return;
+    }
+    this.isRunning = true;
+    this.reconnectAttempts = 0;
+    await this.connect();
+  }
+  /**
+   * 停止WebSocket连接
+   */
+  async stop() {
+    this.isRunning = false;
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.logger.info("WebSocket handler stopped");
+  }
+  /**
+   * 建立WebSocket连接
+   */
+  async connect() {
+    try {
+      const config = ConfigManager.getInstance().getFeishuConfig();
+      const wsUrl = config.domain === "feishu" ? "wss://ws.feishu.cn/passport/" : "wss://ws.larksuite.com/passport/";
+      this.logger.info(`Connecting to WebSocket: ${wsUrl}`);
+      this.ws = new import_ws.WebSocket(wsUrl, {
+        headers: {
+          "Authorization": `Bearer ${await this.getAccessToken()}`
+        }
+      });
+      this.setupWebSocketHandlers();
+    } catch (error) {
+      this.logger.error("Failed to connect WebSocket:", error);
+      this.handleReconnect();
+    }
+  }
+  /**
+   * 设置WebSocket事件处理器
+   */
+  setupWebSocketHandlers() {
+    if (!this.ws) return;
+    this.ws.on("open", () => {
+      this.logger.info("WebSocket connected");
+      this.reconnectAttempts = 0;
+      this.startHeartbeat();
+    });
+    this.ws.on("message", (data) => {
+      this.handleMessage(data.toString());
+    });
+    this.ws.on("close", (code, reason) => {
+      this.logger.info(`WebSocket closed: ${code} - ${reason.toString()}`);
+      this.stopHeartbeat();
+      if (this.isRunning) {
+        this.handleReconnect();
+      }
+    });
+    this.ws.on("error", (error) => {
+      this.logger.error("WebSocket error:", error);
+    });
+    this.ws.on("ping", () => {
+      this.ws?.pong();
+    });
+  }
+  /**
+   * 处理收到的消息
+   */
+  async handleMessage(data) {
+    try {
+      const event = JSON.parse(data);
+      this.logger.debug("Received WebSocket message:", event);
+      if (event.type === "url_verification") {
+        this.logger.info("Received URL verification challenge via WebSocket");
+        return;
+      }
+      if (event.type === "event_callback" && event.event) {
+        await this.handleEvent(event.event);
+      }
+    } catch (error) {
+      this.logger.error("Error handling WebSocket message:", error);
+    }
+  }
+  /**
+   * 处理事件
+   */
+  async handleEvent(event) {
+    const { message } = event;
+    if (!message || message.message_type !== "text") {
+      this.logger.debug("Ignoring non-text message");
+      return;
+    }
+    try {
+      const content = JSON.parse(message.content);
+      const text = content.text.trim();
+      const sender = event.sender?.sender_id?.open_id;
+      if (!sender) {
+        this.logger.warn("Missing sender ID");
+        return;
+      }
+      this.logger.info(`Received message from ${sender}: ${text}`);
+      const target = this.extractTargetIDE(text);
+      const command = this.extractCommand(text);
+      const result = await this.commandExecutor.execute({
+        target,
+        command,
+        sender,
+        chatId: message.chat_id
+      });
+      await this.client.sendMessage(message.chat_id, {
+        msg_type: "text",
+        content: {
+          text: this.formatResponse(result)
+        }
+      });
+    } catch (error) {
+      this.logger.error("Error processing event:", error);
+    }
+  }
+  /**
+   * 启动心跳保活
+   */
+  startHeartbeat() {
+    this.heartbeatInterval = setInterval(() => {
+      if (this.ws?.readyState === import_ws.WebSocket.OPEN) {
+        this.ws.ping();
+      }
+    }, 3e4);
+  }
+  /**
+   * 停止心跳
+   */
+  stopHeartbeat() {
+    if (this.heartbeatInterval) {
+      clearInterval(this.heartbeatInterval);
+      this.heartbeatInterval = null;
+    }
+  }
+  /**
+   * 处理重连
+   */
+  handleReconnect() {
+    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+      this.logger.error(`Max reconnection attempts (${this.maxReconnectAttempts}) reached`);
+      return;
+    }
+    this.reconnectAttempts++;
+    const delay = this.reconnectInterval * this.reconnectAttempts;
+    this.logger.info(`Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts}/${this.maxReconnectAttempts})`);
+    setTimeout(() => {
+      if (this.isRunning) {
+        this.connect();
+      }
+    }, delay);
+  }
+  /**
+   * 获取访问令牌
+   */
+  async getAccessToken() {
+    const config = ConfigManager.getInstance().getFeishuConfig();
+    const response = await fetch(
+      `https://open.${config.domain === "lark" ? "larksuite" : "feishu"}.cn/open-apis/auth/v3/tenant_access_token/internal`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          app_id: config.appId,
+          app_secret: config.appSecret
+        })
+      }
+    );
+    const data = await response.json();
+    if (data.code !== 0) {
+      throw new Error(`Failed to get access token: ${data.msg}`);
+    }
+    return data.tenant_access_token;
+  }
+  /**
+   * 提取目标IDE
+   */
+  extractTargetIDE(text) {
+    const match = text.match(/@(vscode|cursor|trae|antigravity|kiro|opencode|claude)/i);
+    return match ? match[1].toLowerCase() : "auto";
+  }
+  /**
+   * 提取命令
+   */
+  extractCommand(text) {
+    return text.replace(/@(vscode|cursor|trae|antigravity|kiro|opencode|claude)\s*/i, "").trim();
+  }
+  /**
+   * 格式化响应
+   */
+  formatResponse(result) {
+    if (result.success) {
+      const output = typeof result.output === "string" ? result.output.substring(0, 2e3) : JSON.stringify(result.output).substring(0, 2e3);
+      return `\u2705 \u6267\u884C\u6210\u529F
+
+${output}`;
+    } else {
+      const error = result.error || result.stderr || "Unknown error";
+      return `\u274C \u6267\u884C\u5931\u8D25
+
+${error.substring(0, 2e3)}`;
+    }
+  }
+};
+
+// src/feishu/client.ts
+init_logger();
+var FeishuClient = class {
+  constructor(config) {
+    this.accessToken = null;
+    this.tokenExpireTime = 0;
+    this.appId = config.appId;
+    this.appSecret = config.appSecret;
+    this.domain = config.domain;
+    this.baseUrl = this.domain === "feishu" ? "https://open.feishu.cn/open-apis" : "https://open.larksuite.com/open-apis";
+    this.logger = new Logger();
+  }
+  /**
+   * 获取访问令牌
+   */
+  async getAccessToken() {
+    const now = Date.now();
+    if (this.accessToken && now < this.tokenExpireTime) {
+      return this.accessToken;
+    }
+    try {
+      const response = await fetch(`${this.baseUrl}/auth/v3/tenant_access_token/internal`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json; charset=utf-8"
+        },
+        body: JSON.stringify({
+          app_id: this.appId,
+          app_secret: this.appSecret
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to get access token: ${response.status} ${response.statusText}`);
+      }
+      const data = await response.json();
+      if (data.code !== 0) {
+        throw new Error(`Failed to get access token: ${data.msg}`);
+      }
+      this.accessToken = data.data.tenant_access_token;
+      this.tokenExpireTime = now + (data.data.expire - 300) * 1e3;
+      this.logger.info("Access token refreshed successfully");
+      return this.accessToken;
+    } catch (error) {
+      this.logger.error("Error getting access token:", error);
+      throw error;
+    }
+  }
+  /**
+   * 发送消息到指定聊天
+   */
+  async sendMessage(chatId, message) {
+    try {
+      const token = await this.getAccessToken();
+      const response = await fetch(`${this.baseUrl}/im/v1/messages?receive_id_type=chat_id`, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${token}`,
+          "Content-Type": "application/json; charset=utf-8"
+        },
+        body: JSON.stringify({
+          receive_id: chatId,
+          ...message
+        })
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to send message: ${response.status} ${response.statusText}`);
+      }
+      const data = await response.json();
+      if (data.code !== 0) {
+        throw new Error(`Failed to send message: ${data.msg}`);
+      }
+      this.logger.info(`Message sent successfully to chat ${chatId}`);
+      return data.data;
+    } catch (error) {
+      this.logger.error("Error sending message:", error);
+      throw error;
+    }
+  }
+  /**
+   * 获取用户信息
+   */
+  async getUserInfo(userId) {
+    try {
+      const token = await this.getAccessToken();
+      const response = await fetch(`${this.baseUrl}/contact/v3/users/${userId}`, {
+        method: "GET",
+        headers: {
+          "Authorization": `Bearer ${token}`,
+          "Content-Type": "application/json; charset=utf-8"
+        }
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to get user info: ${response.status} ${response.statusText}`);
+      }
+      const data = await response.json();
+      if (data.code !== 0) {
+        throw new Error(`Failed to get user info: ${data.msg}`);
+      }
+      return data.data;
+    } catch (error) {
+      this.logger.error("Error getting user info:", error);
+      throw error;
+    }
+  }
+};
+
+// src/commands/executor.ts
+init_logger();
+var CommandExecutor = class {
+  constructor(adapters, sessionManager) {
+    this.adapters = adapters;
+    this.sessionManager = sessionManager;
+    this.logger = new Logger();
+  }
+  async execute(request) {
+    try {
+      this.logger.info(`Executing command for target: ${request.target}, command: ${request.command}`);
+      const session = this.sessionManager.getSession(request.sender);
+      let adapterName = request.target.toLowerCase();
+      if (adapterName === "auto") {
+        adapterName = this.detectBestAdapter();
+      }
+      const adapter = this.adapters.get(adapterName);
+      if (!adapter) {
+        throw new Error(`Adapter not found for target: ${adapterName}`);
+      }
+      if (!await adapter.checkAvailability()) {
+        throw new Error(`Adapter ${adapterName} is not available`);
+      }
+      const executionContext = {
+        workspaceRoot: session?.workspaceRoot,
+        chatId: request.chatId,
+        senderId: request.sender
+      };
+      let result;
+      if (this.isGenerateCommand(request.command)) {
+        const description = this.extractDescription(request.command);
+        result = await adapter.generateCode(description);
+      } else if (this.isRunCommand(request.command)) {
+        const command = this.extractRunCommand(request.command);
+        const executionResult = await adapter.runProgram(command, executionContext.workspaceRoot);
+        result = executionResult.stdout || executionResult.stderr;
+      } else {
+        result = await adapter.sendCommand(request.command, executionContext);
+      }
+      this.sessionManager.updateSession(request.sender, {
+        lastCommand: request.command,
+        lastResult: result,
+        lastUsedAdapter: adapterName
+      });
+      return {
+        success: true,
+        output: result
+      };
+    } catch (error) {
+      this.logger.error("Error executing command:", error);
+      return {
+        success: false,
+        output: "",
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  detectBestAdapter() {
+    for (const [name, adapter] of this.adapters) {
+      if (adapter.isAvailable) {
+        return name;
+      }
+    }
+    return "vscode";
+  }
+  isGenerateCommand(command) {
+    return /\b(generate|create|make|build|implement|write|develop|add|new)\b/i.test(command);
+  }
+  isRunCommand(command) {
+    return /\b(run|execute|start|launch|test|debug|build)\b/i.test(command);
+  }
+  extractDescription(command) {
+    const match = command.match(/\b(generate|create|make|build|implement|write|develop|add|new)\b\s+(.*)/i);
+    return match ? match[2] : command;
+  }
+  extractRunCommand(command) {
+    const match = command.match(/\b(run|execute|start|launch|test|debug|build)\b\s+(.*)/i);
+    return match ? match[2] : command;
+  }
+};
+
+// src/session/manager.ts
+init_logger();
+var SessionManager = class {
+  // 会话超时时间（毫秒）
+  constructor(sessionTimeoutMinutes = 30) {
+    this.sessions = /* @__PURE__ */ new Map();
+    this.logger = new Logger();
+    this.sessionTimeout = sessionTimeoutMinutes * 60 * 1e3;
+    setInterval(() => {
+      this.cleanupExpiredSessions();
+    }, this.sessionTimeout);
+  }
+  /**
+   * 获取会话，如果不存在则创建新会话
+   */
+  getSession(userId) {
+    const session = this.sessions.get(userId);
+    if (session) {
+      if (Date.now() - session.lastActive > this.sessionTimeout) {
+        this.logger.info(`Session for user ${userId} expired, removing`);
+        this.sessions.delete(userId);
+        return null;
+      }
+      session.lastActive = Date.now();
+      return session;
+    }
+    return null;
+  }
+  /**
+   * 创建新会话
+   */
+  createSession(userId, initialData) {
+    const now = Date.now();
+    const session = {
+      userId,
+      createdAt: now,
+      lastActive: now,
+      workspaceRoot: initialData?.workspaceRoot,
+      context: initialData?.context,
+      lastCommand: initialData?.lastCommand,
+      lastResult: initialData?.lastResult,
+      lastUsedAdapter: initialData?.lastUsedAdapter
+    };
+    this.sessions.set(userId, session);
+    this.logger.info(`Created new session for user ${userId}`);
+    return session;
+  }
+  /**
+   * 更新会话数据
+   */
+  updateSession(userId, update) {
+    let session = this.sessions.get(userId);
+    if (!session) {
+      session = this.createSession(userId);
+    }
+    session.lastActive = Date.now();
+    if (update.workspaceRoot !== void 0) session.workspaceRoot = update.workspaceRoot;
+    if (update.context !== void 0) session.context = { ...session.context, ...update.context };
+    if (update.lastCommand !== void 0) session.lastCommand = update.lastCommand;
+    if (update.lastResult !== void 0) session.lastResult = update.lastResult;
+    if (update.lastUsedAdapter !== void 0) session.lastUsedAdapter = update.lastUsedAdapter;
+    this.sessions.set(userId, session);
+    this.logger.debug(`Updated session for user ${userId}`);
+    return session;
+  }
+  /**
+   * 删除会话
+   */
+  removeSession(userId) {
+    const removed = this.sessions.delete(userId);
+    if (removed) {
+      this.logger.info(`Removed session for user ${userId}`);
+    }
+    return removed;
+  }
+  /**
+   * 清理会话数据
+   */
+  clearAllSessions() {
+    const count = this.sessions.size;
+    this.sessions.clear();
+    this.logger.info(`Cleared all ${count} sessions`);
+  }
+  /**
+   * 获取所有活跃会话数量
+   */
+  getActiveSessionCount() {
+    return this.sessions.size;
+  }
+  /**
+   * 清理过期会话
+   */
+  cleanupExpiredSessions() {
+    const now = Date.now();
+    let expiredCount = 0;
+    for (const [userId, session] of this.sessions) {
+      if (now - session.lastActive > this.sessionTimeout) {
+        this.sessions.delete(userId);
+        expiredCount++;
+        this.logger.info(`Cleaned up expired session for user ${userId}`);
+      }
+    }
+    if (expiredCount > 0) {
+      this.logger.info(`Cleaned up ${expiredCount} expired sessions`);
+    }
+  }
+};
+
+// src/adapters/base.ts
+init_logger();
+var BaseIDEAdapter = class {
+  constructor() {
+    this.reverseChannel = null;
+    this.logger = new Logger().child({ adapter: this.type });
+  }
+  get isAvailable() {
+    return this.checkAvailabilitySync();
+  }
+  /**
+   * 设置反向通信通道
+   * 允许适配器主动向飞书发送消息
+   */
+  setReverseChannel(channel) {
+    this.reverseChannel = channel;
+    this.logger.info(`Reverse channel set for ${this.type} adapter`);
+  }
+  /**
+   * 发送消息到飞书
+   * 供子类调用以主动推送消息
+   */
+  async sendToFeishu(content, context, type = "message") {
+    if (!this.reverseChannel) {
+      this.logger.warn("Reverse channel not available, cannot send message to Feishu");
+      return false;
+    }
+    if (!context?.chatId) {
+      this.logger.warn("No chatId in context, cannot send message to Feishu");
+      return false;
+    }
+    try {
+      await this.reverseChannel.sendToFeishu({
+        type,
+        content,
+        chatId: context.chatId,
+        senderId: context.senderId,
+        timestamp: Date.now()
+      });
+      return true;
+    } catch (error) {
+      this.logger.error("Error sending message to Feishu:", error);
+      return false;
+    }
+  }
+  /**
+   * 发送文件系统消息（无需反向通道实例）
+   * 通过写入文件的方式让Bridge代为发送
+   */
+  async sendFileSystemMessage(content, context, type = "message") {
+    if (!this.reverseChannel) {
+      this.logger.warn("Reverse channel not available for file system message");
+      return;
+    }
+    await this.reverseChannel.sendFileSystemMessage(
+      this.type,
+      content,
+      context?.chatId
+    );
+  }
+  buildCodePrompt(description, options) {
+    let prompt = description;
+    if (options) {
+      if (options.language) {
+        prompt += `
+Language: ${options.language}`;
+      }
+      if (options.framework) {
+        prompt += `
+Framework: ${options.framework}`;
+      }
+      if (options.style) {
+        prompt += `
+Style: ${options.style}`;
+      }
+    }
+    return prompt;
+  }
+};
+
+// src/adapters/vscode.ts
+var import_execa = require("execa");
+var fs2 = __toESM(require("fs"));
+var os2 = __toESM(require("os"));
+var path2 = __toESM(require("path"));
+var VSCodeAdapter = class extends BaseIDEAdapter {
+  constructor() {
+    super(...arguments);
+    this.type = "vscode";
+    this.vscodePath = null;
+  }
+  checkAvailabilitySync() {
+    if (process.env.VSCODE_PID || process.env.VSCODE_CWD) {
+      return true;
+    }
+    this.vscodePath = this.findVSCodeExecutable();
+    return !!this.vscodePath;
+  }
+  findVSCodeExecutable() {
+    const platform5 = os2.platform();
+    const possiblePaths = [];
+    if (platform5 === "darwin") {
+      possiblePaths.push(
+        "/Applications/Visual Studio Code.app/Contents/Resources/app/bin/code",
+        "/Applications/Visual Studio Code - Insiders.app/Contents/Resources/app/bin/code",
+        "/usr/local/bin/code",
+        path2.join(os2.homedir(), "Applications/Visual Studio Code.app/Contents/Resources/app/bin/code")
+      );
+    } else if (platform5 === "win32") {
+      possiblePaths.push(
+        path2.join(process.env.LOCALAPPDATA || "", "Programs/Microsoft VS Code/bin/code.cmd"),
+        path2.join(process.env.ProgramFiles || "", "Microsoft VS Code/bin/code.cmd"),
+        path2.join(process.env.ProgramFiles || "", "Microsoft VS Code/bin/code.exe"),
+        "C:\\Program Files\\Microsoft VS Code\\bin\\code.cmd"
+      );
+    } else {
+      possiblePaths.push(
+        "/usr/bin/code",
+        "/usr/local/bin/code",
+        "/usr/share/code/bin/code",
+        path2.join(os2.homedir(), ".local/bin/code"),
+        "/snap/bin/code"
+      );
+    }
+    for (const vscodePath of possiblePaths) {
+      if (fs2.existsSync(vscodePath)) {
+        return vscodePath;
+      }
+    }
+    try {
+      if (platform5 === "win32") {
+        const result = import_execa.execa.sync("where", ["code"], { reject: false });
+        if (result.stdout) {
+          const lines = result.stdout.split("\n").map((l) => l.trim()).filter((l) => l);
+          if (lines.length > 0) return lines[0];
+        }
+      } else {
+        const result = import_execa.execa.sync("which", ["code"], { reject: false });
+        if (result.stdout) {
+          return result.stdout.trim();
+        }
+      }
+    } catch {
+    }
+    return null;
+  }
+  async checkAvailability() {
+    return this.checkAvailabilitySync();
+  }
+  async sendCommand(command, context) {
+    try {
+      this.logger.info(`Sending command to VS Code: ${command}`);
+      if (this.vscodePath) {
+        try {
+          const result = await (0, import_execa.execa)(this.vscodePath, [
+            "--command",
+            "feishuBridge.execute",
+            "--args",
+            JSON.stringify({ command })
+          ], {
+            timeout: 3e4,
+            reject: false
+          });
+          if (!result.failed) {
+            return result.stdout || "Command executed successfully";
+          }
+        } catch (cliError) {
+          this.logger.debug("VS Code CLI failed, trying file system method");
+        }
+      }
+      return await this.sendViaFileSystem(command, context);
+    } catch (error) {
+      this.logger.error(`Error executing VS Code command:`, error);
+      throw new Error(`VS Code command failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async sendViaFileSystem(command, context) {
+    const tempDir = path2.join(os2.tmpdir(), "feishu-bridge", "vscode");
+    if (!fs2.existsSync(tempDir)) {
+      fs2.mkdirSync(tempDir, { recursive: true });
+    }
+    const instructionFile = path2.join(tempDir, `cmd_${Date.now()}.json`);
+    const responseFile = path2.join(tempDir, `resp_${Date.now()}.txt`);
+    const instruction = {
+      type: "command",
+      command,
+      context,
+      timestamp: Date.now(),
+      responseFile
+    };
+    fs2.writeFileSync(instructionFile, JSON.stringify(instruction, null, 2));
+    const maxWait = 3e4;
+    const checkInterval = 500;
+    let waited = 0;
+    while (waited < maxWait) {
+      if (fs2.existsSync(responseFile)) {
+        const response = fs2.readFileSync(responseFile, "utf-8");
+        try {
+          fs2.unlinkSync(instructionFile);
+          fs2.unlinkSync(responseFile);
+        } catch {
+        }
+        return response;
+      }
+      await new Promise((resolve) => setTimeout(resolve, checkInterval));
+      waited += checkInterval;
+    }
+    try {
+      fs2.unlinkSync(instructionFile);
+    } catch {
+    }
+    return `Command queued for VS Code. File: ${instructionFile}`;
+  }
+  async getAIResponse(prompt, context) {
+    try {
+      this.logger.info(`Getting AI response from VS Code for prompt: ${prompt}`);
+      if (this.vscodePath) {
+        try {
+          const result = await (0, import_execa.execa)(this.vscodePath, [
+            "--command",
+            "github.copilot.generateCode",
+            "--args",
+            JSON.stringify({ prompt })
+          ], {
+            timeout: 6e4,
+            reject: false
+          });
+          if (!result.failed && result.stdout) {
+            return result.stdout;
+          }
+        } catch (cliError) {
+          this.logger.debug("VS Code AI CLI failed, using file system");
+        }
+      }
+      return await this.sendAIRequestViaFileSystem(prompt, context);
+    } catch (error) {
+      this.logger.error(`Error getting VS Code AI response:`, error);
+      throw error;
+    }
+  }
+  async sendAIRequestViaFileSystem(prompt, context) {
+    const tempDir = path2.join(os2.tmpdir(), "feishu-bridge", "vscode");
+    if (!fs2.existsSync(tempDir)) {
+      fs2.mkdirSync(tempDir, { recursive: true });
+    }
+    const instructionFile = path2.join(tempDir, `ai_${Date.now()}.json`);
+    const responseFile = path2.join(tempDir, `ai_resp_${Date.now()}.txt`);
+    const instruction = {
+      type: "ai_request",
+      prompt,
+      context,
+      timestamp: Date.now(),
+      responseFile
+    };
+    fs2.writeFileSync(instructionFile, JSON.stringify(instruction, null, 2));
+    const maxWait = 12e4;
+    const checkInterval = 1e3;
+    let waited = 0;
+    while (waited < maxWait) {
+      if (fs2.existsSync(responseFile)) {
+        const response = fs2.readFileSync(responseFile, "utf-8");
+        try {
+          fs2.unlinkSync(instructionFile);
+          fs2.unlinkSync(responseFile);
+        } catch {
+        }
+        return response;
+      }
+      await new Promise((resolve) => setTimeout(resolve, checkInterval));
+      waited += checkInterval;
+    }
+    try {
+      fs2.unlinkSync(instructionFile);
+    } catch {
+    }
+    return `AI request queued for VS Code. File: ${instructionFile}`;
+  }
+  async generateCode(description, options) {
+    const fullPrompt = this.buildCodePrompt(description, options);
+    return this.getAIResponse(fullPrompt);
+  }
+  async runProgram(command, cwd) {
+    try {
+      const result = await import_execa.execa.command(command, {
+        cwd: cwd || process.cwd(),
+        shell: true,
+        timeout: 6e4,
+        // 60秒超时
+        reject: false
+      });
+      return {
+        stdout: result.stdout,
+        stderr: result.stderr,
+        exitCode: result.exitCode || 0,
+        success: result.exitCode === 0,
+        output: result.stdout,
+        error: result.failed ? result.stderr : void 0
+      };
+    } catch (error) {
+      this.logger.error(`Error running program in VS Code:`, error);
+      return {
+        stdout: "",
+        stderr: error instanceof Error ? error.message : String(error),
+        exitCode: 1,
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+};
+
+// src/adapters/cursor.ts
+var import_execa2 = require("execa");
+var fs3 = __toESM(require("fs"));
+var path3 = __toESM(require("path"));
+var os3 = __toESM(require("os"));
+var CursorAdapter = class extends BaseIDEAdapter {
+  constructor() {
+    super(...arguments);
+    this.type = "cursor";
+    this.cursorPath = null;
+  }
+  checkAvailabilitySync() {
+    if (process.env.CURSOR_SHELL || process.env.CURSOR_PID) {
+      return true;
+    }
+    this.cursorPath = this.findCursorExecutable();
+    return !!this.cursorPath;
+  }
+  findCursorExecutable() {
+    const platform5 = os3.platform();
+    const possiblePaths = [];
+    if (platform5 === "darwin") {
+      possiblePaths.push(
+        "/Applications/Cursor.app/Contents/MacOS/Cursor",
+        "/usr/local/bin/cursor",
+        path3.join(os3.homedir(), "Applications/Cursor.app/Contents/MacOS/Cursor")
+      );
+    } else if (platform5 === "win32") {
+      possiblePaths.push(
+        path3.join(process.env.LOCALAPPDATA || "", "Programs/Cursor/Cursor.exe"),
+        path3.join(process.env.PROGRAMFILES || "", "Cursor/Cursor.exe"),
+        "C:\\Program Files\\Cursor\\Cursor.exe"
+      );
+    } else {
+      possiblePaths.push(
+        "/usr/bin/cursor",
+        "/usr/local/bin/cursor",
+        "/opt/cursor/cursor",
+        path3.join(os3.homedir(), ".local/bin/cursor")
+      );
+    }
+    for (const cursorPath of possiblePaths) {
+      if (fs3.existsSync(cursorPath)) {
+        return cursorPath;
+      }
+    }
+    try {
+      if (platform5 === "win32") {
+        const result = import_execa2.execa.sync("where", ["cursor"], { reject: false });
+        if (result.stdout) {
+          const lines = result.stdout.split("\n").map((l) => l.trim()).filter((l) => l);
+          if (lines.length > 0) return lines[0];
+        }
+      } else {
+        const result = import_execa2.execa.sync("which", ["cursor"], { reject: false });
+        if (result.stdout) {
+          return result.stdout.trim();
+        }
+      }
+    } catch {
+    }
+    return null;
+  }
+  async checkAvailability() {
+    return this.checkAvailabilitySync();
+  }
+  async sendCommand(command, context) {
+    try {
+      this.logger.info(`Sending command to Cursor: ${command}`);
+      if (this.cursorPath) {
+        try {
+          const result = await (0, import_execa2.execa)(this.cursorPath, [
+            "--command",
+            "workbench.action.executeCommand",
+            "--args",
+            JSON.stringify({ command })
+          ], {
+            timeout: 3e4,
+            reject: false
+          });
+          if (!result.failed) {
+            return `Cursor executed: ${command}
+${result.stdout}`;
+          }
+        } catch (cliError) {
+          this.logger.debug("Cursor CLI failed, trying alternative methods");
+        }
+      }
+      return await this.sendViaFileSystem(command, context);
+    } catch (error) {
+      this.logger.error(`Error executing Cursor command:`, error);
+      throw new Error(`Cursor command failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async sendViaFileSystem(command, context) {
+    const tempDir = path3.join(os3.tmpdir(), "feishu-bridge", "cursor");
+    if (!fs3.existsSync(tempDir)) {
+      fs3.mkdirSync(tempDir, { recursive: true });
+    }
+    const instructionFile = path3.join(tempDir, `instruction_${Date.now()}.json`);
+    const responseFile = path3.join(tempDir, `response_${Date.now()}.txt`);
+    const instruction = {
+      type: "command",
+      command,
+      context,
+      timestamp: Date.now(),
+      responseFile
+    };
+    fs3.writeFileSync(instructionFile, JSON.stringify(instruction, null, 2));
+    const maxWait = 3e4;
+    const checkInterval = 500;
+    let waited = 0;
+    while (waited < maxWait) {
+      if (fs3.existsSync(responseFile)) {
+        const response = fs3.readFileSync(responseFile, "utf-8");
+        try {
+          fs3.unlinkSync(instructionFile);
+          fs3.unlinkSync(responseFile);
+        } catch {
+        }
+        return response;
+      }
+      await new Promise((resolve) => setTimeout(resolve, checkInterval));
+      waited += checkInterval;
+    }
+    try {
+      fs3.unlinkSync(instructionFile);
+    } catch {
+    }
+    return `Command sent to Cursor workspace (file: ${instructionFile}). No response received within ${maxWait}ms. Make sure Cursor is running with Feishu Bridge extension.`;
+  }
+  async getAIResponse(prompt, context) {
+    try {
+      this.logger.info(`Getting AI response from Cursor for prompt: ${prompt}`);
+      const tempDir = path3.join(os3.tmpdir(), "feishu-bridge", "cursor");
+      if (!fs3.existsSync(tempDir)) {
+        fs3.mkdirSync(tempDir, { recursive: true });
+      }
+      const instructionFile = path3.join(tempDir, `ai_request_${Date.now()}.json`);
+      const responseFile = path3.join(tempDir, `ai_response_${Date.now()}.txt`);
+      const instruction = {
+        type: "ai_request",
+        prompt,
+        context,
+        timestamp: Date.now(),
+        responseFile
+      };
+      fs3.writeFileSync(instructionFile, JSON.stringify(instruction, null, 2));
+      const maxWait = 6e4;
+      const checkInterval = 500;
+      let waited = 0;
+      while (waited < maxWait) {
+        if (fs3.existsSync(responseFile)) {
+          const response = fs3.readFileSync(responseFile, "utf-8");
+          try {
+            fs3.unlinkSync(instructionFile);
+            fs3.unlinkSync(responseFile);
+          } catch {
+          }
+          return response;
+        }
+        await new Promise((resolve) => setTimeout(resolve, checkInterval));
+        waited += checkInterval;
+      }
+      try {
+        fs3.unlinkSync(instructionFile);
+      } catch {
+      }
+      return `AI request sent to Cursor (file: ${instructionFile}). No response received within ${maxWait}ms.`;
+    } catch (error) {
+      this.logger.error(`Error getting Cursor AI response:`, error);
+      throw error;
+    }
+  }
+  async generateCode(description, options) {
+    const fullPrompt = this.buildCodePrompt(description, options);
+    return this.getAIResponse(fullPrompt);
+  }
+  async runProgram(command, cwd) {
+    try {
+      const result = await import_execa2.execa.command(command, {
+        cwd: cwd || process.cwd(),
+        shell: true,
+        timeout: 6e4,
+        reject: false
+      });
+      return {
+        stdout: result.stdout,
+        stderr: result.stderr,
+        exitCode: result.exitCode || 0,
+        success: result.exitCode === 0,
+        output: result.stdout,
+        error: result.failed ? result.stderr : void 0
+      };
+    } catch (error) {
+      this.logger.error(`Error running program in Cursor:`, error);
+      return {
+        stdout: "",
+        stderr: error instanceof Error ? error.message : String(error),
+        exitCode: 1,
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+};
+
+// src/adapters/trae.ts
+var import_execa3 = require("execa");
+var fs4 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
+var os4 = __toESM(require("os"));
+var TraeAdapter = class extends BaseIDEAdapter {
+  constructor() {
+    super(...arguments);
+    this.type = "trae";
+    this.traePath = null;
+  }
+  checkAvailabilitySync() {
+    if (process.env.TRAE_SESSION || process.env.TRAE_PID) {
+      return true;
+    }
+    this.traePath = this.findTraeExecutable();
+    return !!this.traePath;
+  }
+  findTraeExecutable() {
+    const platform5 = os4.platform();
+    const possiblePaths = [];
+    if (platform5 === "darwin") {
+      possiblePaths.push(
+        "/Applications/Trae.app/Contents/MacOS/Trae",
+        "/usr/local/bin/trae",
+        path4.join(os4.homedir(), "Applications/Trae.app/Contents/MacOS/Trae")
+      );
+    } else if (platform5 === "win32") {
+      possiblePaths.push(
+        path4.join(process.env.LOCALAPPDATA || "", "Programs", "Trae", "Trae.exe"),
+        "C:\\Program Files\\Trae\\Trae.exe"
+      );
+    } else {
+      possiblePaths.push(
+        "/usr/bin/trae",
+        "/usr/local/bin/trae",
+        "/opt/trae/trae",
+        path4.join(os4.homedir(), ".local/bin/trae")
+      );
+    }
+    for (const p of possiblePaths) {
+      if (fs4.existsSync(p)) {
+        return p;
+      }
+    }
+    try {
+      if (platform5 === "win32") {
+        const result = import_execa3.execa.sync("where", ["trae"], { reject: false });
+        if (result.stdout) {
+          const lines = result.stdout.split("\n").map((l) => l.trim()).filter((l) => l);
+          if (lines.length > 0) return lines[0];
+        }
+      } else {
+        const result = import_execa3.execa.sync("which", ["trae"], { reject: false });
+        if (result.stdout) {
+          return result.stdout.trim();
+        }
+      }
+    } catch {
+    }
+    return null;
+  }
+  async checkAvailability() {
+    return this.checkAvailabilitySync();
+  }
+  async sendCommand(command, context) {
+    try {
+      this.logger.info(`Sending command to Trae: ${command}`);
+      if (this.traePath) {
+        try {
+          const result = await (0, import_execa3.execa)(this.traePath, [
+            "--executeCommand",
+            command
+          ], {
+            timeout: 3e4,
+            reject: false,
+            cwd: context?.workspaceRoot
+          });
+          if (!result.failed) {
+            return result.stdout || "Command executed";
+          }
+        } catch (cliError) {
+          this.logger.debug("Trae CLI failed, using file system");
+        }
+      }
+      return await this.sendViaFileSystem(command, context);
+    } catch (error) {
+      this.logger.error(`Error executing Trae command:`, error);
+      throw new Error(`Trae command failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async sendViaFileSystem(command, context) {
+    const tempDir = path4.join(os4.tmpdir(), "feishu-bridge", "trae");
+    if (!fs4.existsSync(tempDir)) {
+      fs4.mkdirSync(tempDir, { recursive: true });
+    }
+    const instructionFile = path4.join(tempDir, `cmd_${Date.now()}.json`);
+    const responseFile = path4.join(tempDir, `resp_${Date.now()}.txt`);
+    const instruction = {
+      type: "command",
+      command,
+      context,
+      timestamp: Date.now(),
+      responseFile
+    };
+    fs4.writeFileSync(instructionFile, JSON.stringify(instruction, null, 2));
+    const maxWait = 3e4;
+    const checkInterval = 500;
+    let waited = 0;
+    while (waited < maxWait) {
+      if (fs4.existsSync(responseFile)) {
+        const response = fs4.readFileSync(responseFile, "utf-8");
+        try {
+          fs4.unlinkSync(instructionFile);
+          fs4.unlinkSync(responseFile);
+        } catch {
+        }
+        return response;
+      }
+      await new Promise((resolve) => setTimeout(resolve, checkInterval));
+      waited += checkInterval;
+    }
+    try {
+      fs4.unlinkSync(instructionFile);
+    } catch {
+    }
+    return `Command queued for Trae. File: ${instructionFile}`;
+  }
+  async getAIResponse(prompt, context) {
+    try {
+      this.logger.info(`Getting AI response from Trae for prompt: ${prompt}`);
+      if (this.traePath) {
+        try {
+          const result = await (0, import_execa3.execa)(this.traePath, [
+            "--ai",
+            prompt
+          ], {
+            timeout: 6e4,
+            reject: false,
+            cwd: context?.workspaceRoot
+          });
+          if (!result.failed && result.stdout) {
+            return result.stdout;
+          }
+        } catch (cliError) {
+          this.logger.debug("Trae AI CLI failed, using file system");
+        }
+      }
+      return await this.sendAIRequestViaFileSystem(prompt, context);
+    } catch (error) {
+      this.logger.error(`Error getting Trae AI response:`, error);
+      throw error;
+    }
+  }
+  async sendAIRequestViaFileSystem(prompt, context) {
+    const tempDir = path4.join(os4.tmpdir(), "feishu-bridge", "trae");
+    if (!fs4.existsSync(tempDir)) {
+      fs4.mkdirSync(tempDir, { recursive: true });
+    }
+    const instructionFile = path4.join(tempDir, `ai_${Date.now()}.json`);
+    const responseFile = path4.join(tempDir, `ai_resp_${Date.now()}.txt`);
+    const instruction = {
+      type: "ai_request",
+      prompt,
+      context,
+      timestamp: Date.now(),
+      responseFile
+    };
+    fs4.writeFileSync(instructionFile, JSON.stringify(instruction, null, 2));
+    const maxWait = 12e4;
+    const checkInterval = 1e3;
+    let waited = 0;
+    while (waited < maxWait) {
+      if (fs4.existsSync(responseFile)) {
+        const response = fs4.readFileSync(responseFile, "utf-8");
+        try {
+          fs4.unlinkSync(instructionFile);
+          fs4.unlinkSync(responseFile);
+        } catch {
+        }
+        return response;
+      }
+      await new Promise((resolve) => setTimeout(resolve, checkInterval));
+      waited += checkInterval;
+    }
+    try {
+      fs4.unlinkSync(instructionFile);
+    } catch {
+    }
+    return `AI request queued for Trae. File: ${instructionFile}`;
+  }
+  async generateCode(description, options) {
+    const fullPrompt = this.buildCodePrompt(description, options);
+    return this.getAIResponse(fullPrompt);
+  }
+  async runProgram(command, cwd) {
+    try {
+      const result = await import_execa3.execa.command(command, {
+        cwd: cwd || process.cwd(),
+        shell: true,
+        timeout: 6e4,
+        reject: false
+      });
+      return {
+        stdout: result.stdout,
+        stderr: result.stderr,
+        exitCode: result.exitCode || 0,
+        success: result.exitCode === 0,
+        output: result.stdout,
+        error: result.failed ? result.stderr : void 0
+      };
+    } catch (error) {
+      this.logger.error(`Error running program in Trae:`, error);
+      return {
+        stdout: "",
+        stderr: error instanceof Error ? error.message : String(error),
+        exitCode: 1,
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+};
+
+// src/adapters/antigravity.ts
+var import_execa4 = require("execa");
+var fs5 = __toESM(require("fs"));
+var path5 = __toESM(require("path"));
+var os5 = __toESM(require("os"));
+var AntigravityAdapter = class extends BaseIDEAdapter {
+  constructor() {
+    super(...arguments);
+    this.type = "antigravity";
+    this.antigravityPath = null;
+  }
+  checkAvailabilitySync() {
+    if (process.env.ANTIGRAVITY_SESSION) {
+      return true;
+    }
+    this.antigravityPath = this.findAntigravityExecutable();
+    return !!this.antigravityPath;
+  }
+  findAntigravityExecutable() {
+    try {
+      const result = import_execa4.execa.sync("which", ["antigravity"], { reject: false });
+      if (result.stdout) return result.stdout.trim();
+    } catch {
+    }
+    const possiblePaths = [
+      "/usr/local/bin/antigravity",
+      "/usr/bin/antigravity",
+      path5.join(os5.homedir(), ".local/bin/antigravity")
+    ];
+    for (const p of possiblePaths) {
+      if (fs5.existsSync(p)) return p;
+    }
+    return null;
+  }
+  async checkAvailability() {
+    return this.checkAvailabilitySync();
+  }
+  async sendCommand(command, context) {
+    try {
+      this.logger.info(`Sending command to Antigravity: ${command}`);
+      if (this.antigravityPath) {
+        try {
+          const result = await (0, import_execa4.execa)(this.antigravityPath, ["execute", command], {
+            timeout: 3e4,
+            reject: false,
+            cwd: context?.workspaceRoot
+          });
+          if (!result.failed) {
+            return result.stdout || "Command executed";
+          }
+        } catch (cliError) {
+          this.logger.debug("Antigravity CLI failed, using file system");
+        }
+      }
+      return await this.sendViaFileSystem(command, context);
+    } catch (error) {
+      this.logger.error(`Error executing Antigravity command:`, error);
+      throw new Error(`Antigravity command failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async sendViaFileSystem(command, context) {
+    const tempDir = path5.join(os5.tmpdir(), "feishu-bridge", "antigravity");
+    if (!fs5.existsSync(tempDir)) {
+      fs5.mkdirSync(tempDir, { recursive: true });
+    }
+    const instructionFile = path5.join(tempDir, `cmd_${Date.now()}.json`);
+    const responseFile = path5.join(tempDir, `resp_${Date.now()}.txt`);
+    const instruction = {
+      type: "command",
+      command,
+      context,
+      timestamp: Date.now(),
+      responseFile
+    };
+    fs5.writeFileSync(instructionFile, JSON.stringify(instruction, null, 2));
+    const maxWait = 3e4;
+    const checkInterval = 500;
+    let waited = 0;
+    while (waited < maxWait) {
+      if (fs5.existsSync(responseFile)) {
+        const response = fs5.readFileSync(responseFile, "utf-8");
+        try {
+          fs5.unlinkSync(instructionFile);
+          fs5.unlinkSync(responseFile);
+        } catch {
+        }
+        return response;
+      }
+      await new Promise((resolve) => setTimeout(resolve, checkInterval));
+      waited += checkInterval;
+    }
+    try {
+      fs5.unlinkSync(instructionFile);
+    } catch {
+    }
+    return `Command queued for Antigravity. File: ${instructionFile}`;
+  }
+  async getAIResponse(prompt, context) {
+    try {
+      this.logger.info(`Getting AI response from Antigravity for prompt: ${prompt}`);
+      if (this.antigravityPath) {
+        try {
+          const result = await (0, import_execa4.execa)(this.antigravityPath, ["ask", prompt], {
+            timeout: 6e4,
+            reject: false,
+            cwd: context?.workspaceRoot
+          });
+          if (!result.failed && result.stdout) {
+            return result.stdout;
+          }
+        } catch (cliError) {
+          this.logger.debug("Antigravity AI CLI failed, using file system");
+        }
+      }
+      return await this.sendAIRequestViaFileSystem(prompt, context);
+    } catch (error) {
+      this.logger.error(`Error getting Antigravity AI response:`, error);
+      throw error;
+    }
+  }
+  async sendAIRequestViaFileSystem(prompt, context) {
+    const tempDir = path5.join(os5.tmpdir(), "feishu-bridge", "antigravity");
+    if (!fs5.existsSync(tempDir)) {
+      fs5.mkdirSync(tempDir, { recursive: true });
+    }
+    const instructionFile = path5.join(tempDir, `ai_${Date.now()}.json`);
+    const responseFile = path5.join(tempDir, `ai_resp_${Date.now()}.txt`);
+    const instruction = {
+      type: "ai_request",
+      prompt,
+      context,
+      timestamp: Date.now(),
+      responseFile
+    };
+    fs5.writeFileSync(instructionFile, JSON.stringify(instruction, null, 2));
+    const maxWait = 12e4;
+    const checkInterval = 1e3;
+    let waited = 0;
+    while (waited < maxWait) {
+      if (fs5.existsSync(responseFile)) {
+        const response = fs5.readFileSync(responseFile, "utf-8");
+        try {
+          fs5.unlinkSync(instructionFile);
+          fs5.unlinkSync(responseFile);
+        } catch {
+        }
+        return response;
+      }
+      await new Promise((resolve) => setTimeout(resolve, checkInterval));
+      waited += checkInterval;
+    }
+    try {
+      fs5.unlinkSync(instructionFile);
+    } catch {
+    }
+    return `AI request queued for Antigravity. File: ${instructionFile}`;
+  }
+  async generateCode(description, options) {
+    const fullPrompt = this.buildCodePrompt(description, options);
+    return this.getAIResponse(fullPrompt);
+  }
+  async runProgram(command, cwd) {
+    try {
+      const result = await import_execa4.execa.command(command, {
+        cwd: cwd || process.cwd(),
+        shell: true,
+        timeout: 6e4,
+        reject: false
+      });
+      return {
+        stdout: result.stdout,
+        stderr: result.stderr,
+        exitCode: result.exitCode || 0,
+        success: result.exitCode === 0,
+        output: result.stdout,
+        error: result.failed ? result.stderr : void 0
+      };
+    } catch (error) {
+      this.logger.error(`Error running program in Antigravity:`, error);
+      return {
+        stdout: "",
+        stderr: error instanceof Error ? error.message : String(error),
+        exitCode: 1,
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+};
+
+// src/adapters/kiro.ts
+var import_execa5 = require("execa");
+var fs6 = __toESM(require("fs"));
+var path6 = __toESM(require("path"));
+var os6 = __toESM(require("os"));
+var KiroAdapter = class extends BaseIDEAdapter {
+  constructor() {
+    super(...arguments);
+    this.type = "kiro";
+    this.kiroPath = null;
+  }
+  checkAvailabilitySync() {
+    if (process.env.KIRO_SESSION) {
+      return true;
+    }
+    this.kiroPath = this.findKiroExecutable();
+    return !!this.kiroPath;
+  }
+  findKiroExecutable() {
+    try {
+      const result = import_execa5.execa.sync("which", ["kiro"], { reject: false });
+      if (result.stdout) return result.stdout.trim();
+    } catch {
+    }
+    const possiblePaths = [
+      "/usr/local/bin/kiro",
+      "/usr/bin/kiro",
+      path6.join(os6.homedir(), ".local/bin/kiro")
+    ];
+    for (const p of possiblePaths) {
+      if (fs6.existsSync(p)) return p;
+    }
+    return null;
+  }
+  async checkAvailability() {
+    return this.checkAvailabilitySync();
+  }
+  async sendCommand(command, context) {
+    try {
+      this.logger.info(`Sending command to Kiro: ${command}`);
+      if (this.kiroPath) {
+        try {
+          const result = await (0, import_execa5.execa)(this.kiroPath, ["execute", command], {
+            timeout: 3e4,
+            reject: false,
+            cwd: context?.workspaceRoot
+          });
+          if (!result.failed) {
+            return result.stdout || "Command executed";
+          }
+        } catch (cliError) {
+          this.logger.debug("Kiro CLI failed, using file system");
+        }
+      }
+      return await this.sendViaFileSystem(command, context);
+    } catch (error) {
+      this.logger.error(`Error executing Kiro command:`, error);
+      throw new Error(`Kiro command failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async sendViaFileSystem(command, context) {
+    const tempDir = path6.join(os6.tmpdir(), "feishu-bridge", "kiro");
+    if (!fs6.existsSync(tempDir)) {
+      fs6.mkdirSync(tempDir, { recursive: true });
+    }
+    const instructionFile = path6.join(tempDir, `cmd_${Date.now()}.json`);
+    const responseFile = path6.join(tempDir, `resp_${Date.now()}.txt`);
+    const instruction = {
+      type: "command",
+      command,
+      context,
+      timestamp: Date.now(),
+      responseFile
+    };
+    fs6.writeFileSync(instructionFile, JSON.stringify(instruction, null, 2));
+    const maxWait = 3e4;
+    const checkInterval = 500;
+    let waited = 0;
+    while (waited < maxWait) {
+      if (fs6.existsSync(responseFile)) {
+        const response = fs6.readFileSync(responseFile, "utf-8");
+        try {
+          fs6.unlinkSync(instructionFile);
+          fs6.unlinkSync(responseFile);
+        } catch {
+        }
+        return response;
+      }
+      await new Promise((resolve) => setTimeout(resolve, checkInterval));
+      waited += checkInterval;
+    }
+    try {
+      fs6.unlinkSync(instructionFile);
+    } catch {
+    }
+    return `Command queued for Kiro. File: ${instructionFile}`;
+  }
+  async getAIResponse(prompt, context) {
+    try {
+      this.logger.info(`Getting AI response from Kiro for prompt: ${prompt}`);
+      if (this.kiroPath) {
+        try {
+          const result = await (0, import_execa5.execa)(this.kiroPath, ["ask", prompt], {
+            timeout: 6e4,
+            reject: false,
+            cwd: context?.workspaceRoot
+          });
+          if (!result.failed && result.stdout) {
+            return result.stdout;
+          }
+        } catch (cliError) {
+          this.logger.debug("Kiro AI CLI failed, using file system");
+        }
+      }
+      return await this.sendAIRequestViaFileSystem(prompt, context);
+    } catch (error) {
+      this.logger.error(`Error getting Kiro AI response:`, error);
+      throw error;
+    }
+  }
+  async sendAIRequestViaFileSystem(prompt, context) {
+    const tempDir = path6.join(os6.tmpdir(), "feishu-bridge", "kiro");
+    if (!fs6.existsSync(tempDir)) {
+      fs6.mkdirSync(tempDir, { recursive: true });
+    }
+    const instructionFile = path6.join(tempDir, `ai_${Date.now()}.json`);
+    const responseFile = path6.join(tempDir, `ai_resp_${Date.now()}.txt`);
+    const instruction = {
+      type: "ai_request",
+      prompt,
+      context,
+      timestamp: Date.now(),
+      responseFile
+    };
+    fs6.writeFileSync(instructionFile, JSON.stringify(instruction, null, 2));
+    const maxWait = 12e4;
+    const checkInterval = 1e3;
+    let waited = 0;
+    while (waited < maxWait) {
+      if (fs6.existsSync(responseFile)) {
+        const response = fs6.readFileSync(responseFile, "utf-8");
+        try {
+          fs6.unlinkSync(instructionFile);
+          fs6.unlinkSync(responseFile);
+        } catch {
+        }
+        return response;
+      }
+      await new Promise((resolve) => setTimeout(resolve, checkInterval));
+      waited += checkInterval;
+    }
+    try {
+      fs6.unlinkSync(instructionFile);
+    } catch {
+    }
+    return `AI request queued for Kiro. File: ${instructionFile}`;
+  }
+  async generateCode(description, options) {
+    const fullPrompt = this.buildCodePrompt(description, options);
+    return this.getAIResponse(fullPrompt);
+  }
+  async runProgram(command, cwd) {
+    try {
+      const result = await import_execa5.execa.command(command, {
+        cwd: cwd || process.cwd(),
+        shell: true,
+        timeout: 6e4,
+        reject: false
+      });
+      return {
+        stdout: result.stdout,
+        stderr: result.stderr,
+        exitCode: result.exitCode || 0,
+        success: result.exitCode === 0,
+        output: result.stdout,
+        error: result.failed ? result.stderr : void 0
+      };
+    } catch (error) {
+      this.logger.error(`Error running program in Kiro:`, error);
+      return {
+        stdout: "",
+        stderr: error instanceof Error ? error.message : String(error),
+        exitCode: 1,
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+};
+
+// src/adapters/opencode.ts
+var net = __toESM(require("net"));
+var fs7 = __toESM(require("fs"));
+var os7 = __toESM(require("os"));
+var path7 = __toESM(require("path"));
+var OpenCodeAdapter = class extends BaseIDEAdapter {
+  constructor() {
+    super(...arguments);
+    this.type = "opencode";
+  }
+  checkAvailabilitySync() {
+    return !!process.env.OPENCODE_SESSION || fs7.existsSync(path7.join(os7.homedir(), ".opencode", "session")) || this.checkOpenCodeProcess();
+  }
+  checkOpenCodeProcess() {
+    try {
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async checkAvailability() {
+    return this.checkAvailabilitySync();
+  }
+  async sendCommand(command, context) {
+    try {
+      this.logger.info(`Sending command to OpenCode: ${command}`);
+      const socketPath = this.getSocketPath();
+      if (socketPath && fs7.existsSync(socketPath)) {
+        return await this.sendViaSocket({
+          type: "command",
+          command,
+          sessionId: this.sessionId,
+          context
+        });
+      } else {
+        return `OpenCode processed command: ${command}`;
+      }
+    } catch (error) {
+      this.logger.error(`Error executing OpenCode command:`, error);
+      throw error;
+    }
+  }
+  getSocketPath() {
+    const possiblePaths = [
+      path7.join(os7.tmpdir(), "opencode.sock"),
+      path7.join(os7.homedir(), ".opencode", "socket"),
+      process.env.OPENCODE_SOCKET || ""
+    ];
+    for (const socketPath of possiblePaths) {
+      if (socketPath && fs7.existsSync(socketPath)) {
+        return socketPath;
+      }
+    }
+    return null;
+  }
+  sendViaSocket(data) {
+    return new Promise((resolve, reject) => {
+      const socketPath = this.getSocketPath();
+      if (!socketPath) {
+        reject(new Error("No OpenCode socket available"));
+        return;
+      }
+      const client = net.createConnection(socketPath);
+      let response = "";
+      client.on("data", (data2) => {
+        response += data2.toString();
+      });
+      client.on("end", () => {
+        try {
+          const parsed = JSON.parse(response);
+          resolve(parsed.result || response);
+        } catch (e) {
+          resolve(response);
+        }
+      });
+      client.on("error", (err) => {
+        reject(err);
+      });
+      client.write(JSON.stringify(data));
+      setTimeout(() => {
+        client.destroy();
+        reject(new Error("OpenCode command timeout"));
+      }, 3e4);
+    });
+  }
+  async getAIResponse(prompt, context) {
+    try {
+      this.logger.info(`Getting AI response from OpenCode for prompt: ${prompt}`);
+      return await this.sendCommand(`/ask ${prompt}`, context);
+    } catch (error) {
+      this.logger.error(`Error getting OpenCode AI response:`, error);
+      throw error;
+    }
+  }
+  async generateCode(description, options) {
+    const fullPrompt = this.buildCodePrompt(description, options);
+    return this.getAIResponse(fullPrompt);
+  }
+  async runProgram(command, cwd) {
+    try {
+      const result = await this.sendCommand(`/run ${command}`, { workspaceRoot: cwd });
+      return {
+        stdout: result,
+        stderr: "",
+        exitCode: 0,
+        success: true,
+        output: result
+      };
+    } catch (error) {
+      this.logger.error(`Error running program in OpenCode:`, error);
+      return {
+        stdout: "",
+        stderr: error instanceof Error ? error.message : String(error),
+        exitCode: 1,
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+};
+
+// src/adapters/claude-code.ts
+var import_execa6 = require("execa");
+var fs8 = __toESM(require("fs"));
+var path8 = __toESM(require("path"));
+var os8 = __toESM(require("os"));
+var ClaudeCodeAdapter = class extends BaseIDEAdapter {
+  constructor() {
+    super(...arguments);
+    this.type = "claude";
+    this.claudePath = null;
+  }
+  checkAvailabilitySync() {
+    if (process.env.CLAUDE_CODE_SESSION) {
+      return true;
+    }
+    this.claudePath = this.findClaudeExecutable();
+    return !!this.claudePath;
+  }
+  findClaudeExecutable() {
+    const platform5 = os8.platform();
+    try {
+      const result = import_execa6.execa.sync("claude", ["--version"], { reject: false });
+      if (result.exitCode === 0) {
+        return "claude";
+      }
+    } catch {
+    }
+    const possiblePaths = [];
+    if (platform5 === "darwin") {
+      possiblePaths.push(
+        "/usr/local/bin/claude",
+        "/opt/homebrew/bin/claude",
+        path8.join(os8.homedir(), ".local/bin/claude")
+      );
+    } else if (platform5 === "win32") {
+      possiblePaths.push(
+        path8.join(os8.homedir(), "AppData", "Local", "Programs", "claude", "claude.exe"),
+        "C:\\Program Files\\Claude\\claude.exe"
+      );
+    } else {
+      possiblePaths.push(
+        "/usr/bin/claude",
+        "/usr/local/bin/claude",
+        path8.join(os8.homedir(), ".local/bin/claude"),
+        path8.join(os8.homedir(), ".npm-global/bin/claude")
+      );
+    }
+    for (const p of possiblePaths) {
+      if (fs8.existsSync(p)) {
+        return p;
+      }
+    }
+    return null;
+  }
+  async checkAvailability() {
+    return this.checkAvailabilitySync();
+  }
+  async sendCommand(command, context) {
+    try {
+      this.logger.info(`Sending command to Claude Code: ${command}`);
+      if (this.claudePath) {
+        try {
+          const result = await (0, import_execa6.execa)(this.claudePath, [
+            "execute",
+            "--command",
+            command
+          ], {
+            timeout: 3e4,
+            reject: false,
+            cwd: context?.workspaceRoot
+          });
+          if (!result.failed) {
+            return result.stdout || "Command executed successfully";
+          }
+        } catch (cliError) {
+          this.logger.debug("Claude CLI failed, trying file system method");
+        }
+      }
+      return await this.sendViaFileSystem(command, context);
+    } catch (error) {
+      this.logger.error(`Error executing Claude Code command:`, error);
+      throw new Error(`Claude Code command failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  async sendViaFileSystem(command, context) {
+    const tempDir = path8.join(os8.tmpdir(), "feishu-bridge", "claude");
+    if (!fs8.existsSync(tempDir)) {
+      fs8.mkdirSync(tempDir, { recursive: true });
+    }
+    const instructionFile = path8.join(tempDir, `cmd_${Date.now()}.json`);
+    const responseFile = path8.join(tempDir, `resp_${Date.now()}.txt`);
+    const instruction = {
+      type: "command",
+      command,
+      context,
+      timestamp: Date.now(),
+      responseFile
+    };
+    fs8.writeFileSync(instructionFile, JSON.stringify(instruction, null, 2));
+    const maxWait = 3e4;
+    const checkInterval = 500;
+    let waited = 0;
+    while (waited < maxWait) {
+      if (fs8.existsSync(responseFile)) {
+        const response = fs8.readFileSync(responseFile, "utf-8");
+        try {
+          fs8.unlinkSync(instructionFile);
+          fs8.unlinkSync(responseFile);
+        } catch {
+        }
+        return response;
+      }
+      await new Promise((resolve) => setTimeout(resolve, checkInterval));
+      waited += checkInterval;
+    }
+    try {
+      fs8.unlinkSync(instructionFile);
+    } catch {
+    }
+    return `Command queued for Claude Code. File: ${instructionFile}`;
+  }
+  async getAIResponse(prompt, context) {
+    try {
+      this.logger.info(`Getting AI response from Claude Code for prompt: ${prompt}`);
+      if (this.claudePath) {
+        try {
+          const result = await (0, import_execa6.execa)(this.claudePath, [
+            "ask",
+            "--prompt",
+            prompt
+          ], {
+            timeout: 6e4,
+            reject: false,
+            cwd: context?.workspaceRoot
+          });
+          if (!result.failed && result.stdout) {
+            return result.stdout;
+          }
+        } catch (cliError) {
+          this.logger.debug("Claude ask CLI failed, using file system");
+        }
+      }
+      return await this.sendAIRequestViaFileSystem(prompt, context);
+    } catch (error) {
+      this.logger.error(`Error getting Claude Code AI response:`, error);
+      throw error;
+    }
+  }
+  async sendAIRequestViaFileSystem(prompt, context) {
+    const tempDir = path8.join(os8.tmpdir(), "feishu-bridge", "claude");
+    if (!fs8.existsSync(tempDir)) {
+      fs8.mkdirSync(tempDir, { recursive: true });
+    }
+    const instructionFile = path8.join(tempDir, `ai_${Date.now()}.json`);
+    const responseFile = path8.join(tempDir, `ai_resp_${Date.now()}.txt`);
+    const instruction = {
+      type: "ai_request",
+      prompt,
+      context,
+      timestamp: Date.now(),
+      responseFile
+    };
+    fs8.writeFileSync(instructionFile, JSON.stringify(instruction, null, 2));
+    const maxWait = 12e4;
+    const checkInterval = 1e3;
+    let waited = 0;
+    while (waited < maxWait) {
+      if (fs8.existsSync(responseFile)) {
+        const response = fs8.readFileSync(responseFile, "utf-8");
+        try {
+          fs8.unlinkSync(instructionFile);
+          fs8.unlinkSync(responseFile);
+        } catch {
+        }
+        return response;
+      }
+      await new Promise((resolve) => setTimeout(resolve, checkInterval));
+      waited += checkInterval;
+    }
+    try {
+      fs8.unlinkSync(instructionFile);
+    } catch {
+    }
+    return `AI request queued. File: ${instructionFile}`;
+  }
+  async generateCode(description, options) {
+    const fullPrompt = this.buildCodePrompt(description, options);
+    return this.getAIResponse(fullPrompt);
+  }
+  async runProgram(command, cwd) {
+    try {
+      const result = await import_execa6.execa.command(command, {
+        cwd: cwd || process.cwd(),
+        shell: true,
+        timeout: 6e4,
+        reject: false
+      });
+      return {
+        stdout: result.stdout,
+        stderr: result.stderr,
+        exitCode: result.exitCode || 0,
+        success: result.exitCode === 0,
+        output: result.stdout,
+        error: result.failed ? result.stderr : void 0
+      };
+    } catch (error) {
+      this.logger.error(`Error running program in Claude Code:`, error);
+      return {
+        stdout: "",
+        stderr: error instanceof Error ? error.message : String(error),
+        exitCode: 1,
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+};
+
+// src/core/bridge.ts
+init_config();
+
+// src/core/health.ts
+init_config();
+var HealthMonitor = class {
+  constructor(server, sessionManager, adapters) {
+    this.server = server;
+    this.sessionManager = sessionManager;
+    this.adapters = adapters;
+    this.requestCount = { total: 0, successful: 0, failed: 0 };
+    this.startTime = Date.now();
+    this.setupRoutes();
+  }
+  /**
+   * 设置健康检查路由
+   */
+  setupRoutes() {
+    this.server.get("/health", this.handleHealth.bind(this));
+    this.server.get("/health/ready", this.handleReadiness.bind(this));
+    this.server.get("/health/live", this.handleLiveness.bind(this));
+    this.server.get("/metrics", this.handleMetrics.bind(this));
+  }
+  /**
+   * 处理健康检查请求
+   */
+  async handleHealth(_request, reply) {
+    const status = await this.getHealthStatus();
+    const statusCode = status.status === "healthy" ? 200 : status.status === "degraded" ? 200 : 503;
+    reply.status(statusCode).send(status);
+  }
+  /**
+   * 处理就绪检查
+   */
+  async handleReadiness(_request, reply) {
+    const config = ConfigManager.getInstance().get();
+    const isReady = config.feishu.appId && config.feishu.appSecret;
+    if (isReady) {
+      reply.status(200).send({
+        ready: true,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    } else {
+      reply.status(503).send({
+        ready: false,
+        message: "Configuration incomplete",
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+  }
+  /**
+   * 处理存活检查
+   */
+  async handleLiveness(_request, reply) {
+    reply.status(200).send({
+      alive: true,
+      uptime: process.uptime(),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+  /**
+   * 处理指标请求
+   */
+  async handleMetrics(_request, reply) {
+    const metrics = await this.getMetrics();
+    const prometheusFormat = this.toPrometheusFormat(metrics);
+    reply.header("Content-Type", "text/plain; version=0.0.4").send(prometheusFormat);
+  }
+  /**
+   * 获取健康状态
+   */
+  async getHealthStatus() {
+    const config = ConfigManager.getInstance().get();
+    const adapterStatuses = {};
+    let availableAdapters = 0;
+    for (const [name, adapter] of this.adapters) {
+      try {
+        const isAvailable = await adapter.checkAvailability();
+        adapterStatuses[name] = isAvailable;
+        if (isAvailable) availableAdapters++;
+      } catch (error) {
+        adapterStatuses[name] = false;
+      }
+    }
+    const totalAdapters = this.adapters.size;
+    const feishuConfigured = !!(config.feishu.appId && config.feishu.appSecret);
+    let status = "healthy";
+    if (!feishuConfigured) {
+      status = "unhealthy";
+    } else if (availableAdapters === 0 && totalAdapters > 0) {
+      status = "degraded";
+    }
+    return {
+      status,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      version: process.env.npm_package_version || "1.0.0",
+      checks: {
+        feishu: {
+          status: feishuConfigured ? "ok" : "error",
+          message: feishuConfigured ? void 0 : "App ID or Secret not configured"
+        },
+        adapters: {
+          status: availableAdapters > 0 ? "ok" : "error",
+          available: availableAdapters,
+          total: totalAdapters,
+          details: adapterStatuses
+        },
+        session: {
+          status: "ok",
+          activeSessions: this.sessionManager.getActiveSessionCount()
+        }
+      }
+    };
+  }
+  /**
+   * 获取指标数据
+   */
+  async getMetrics() {
+    const memUsage = process.memoryUsage();
+    const adapterMetrics = {};
+    for (const [name, adapter] of this.adapters) {
+      try {
+        const isAvailable = await adapter.checkAvailability();
+        adapterMetrics[name] = {
+          available: isAvailable,
+          lastCheck: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      } catch (error) {
+        adapterMetrics[name] = {
+          available: false,
+          lastCheck: (/* @__PURE__ */ new Date()).toISOString()
+        };
+      }
+    }
+    return {
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      uptime: process.uptime(),
+      memory: {
+        used: Math.round(memUsage.heapUsed / 1024 / 1024),
+        // MB
+        total: Math.round(memUsage.heapTotal / 1024 / 1024),
+        external: Math.round(memUsage.external / 1024 / 1024)
+      },
+      sessions: {
+        active: this.sessionManager.getActiveSessionCount(),
+        total: 0
+        // 可以通过SessionManager扩展获取
+      },
+      requests: { ...this.requestCount },
+      adapters: adapterMetrics
+    };
+  }
+  /**
+   * 转换为Prometheus格式
+   */
+  toPrometheusFormat(metrics) {
+    const lines = [];
+    lines.push("# HELP feishu_bridge_uptime_seconds Process uptime in seconds");
+    lines.push("# TYPE feishu_bridge_uptime_seconds gauge");
+    lines.push(`feishu_bridge_uptime_seconds ${metrics.uptime}`);
+    lines.push("# HELP feishu_bridge_memory_usage_mb Memory usage in MB");
+    lines.push("# TYPE feishu_bridge_memory_usage_mb gauge");
+    lines.push(`feishu_bridge_memory_usage_mb{type="used"} ${metrics.memory.used}`);
+    lines.push(`feishu_bridge_memory_usage_mb{type="total"} ${metrics.memory.total}`);
+    lines.push(`feishu_bridge_memory_usage_mb{type="external"} ${metrics.memory.external}`);
+    lines.push("# HELP feishu_bridge_active_sessions Number of active sessions");
+    lines.push("# TYPE feishu_bridge_active_sessions gauge");
+    lines.push(`feishu_bridge_active_sessions ${metrics.sessions.active}`);
+    lines.push("# HELP feishu_bridge_requests_total Total number of requests");
+    lines.push("# TYPE feishu_bridge_requests_total counter");
+    lines.push(`feishu_bridge_requests_total ${metrics.requests.total}`);
+    lines.push("# HELP feishu_bridge_requests_successful Total successful requests");
+    lines.push("# TYPE feishu_bridge_requests_successful counter");
+    lines.push(`feishu_bridge_requests_successful ${metrics.requests.successful}`);
+    lines.push("# HELP feishu_bridge_requests_failed Total failed requests");
+    lines.push("# TYPE feishu_bridge_requests_failed counter");
+    lines.push(`feishu_bridge_requests_failed ${metrics.requests.failed}`);
+    lines.push("# HELP feishu_bridge_adapter_available Adapter availability (1=available, 0=unavailable)");
+    lines.push("# TYPE feishu_bridge_adapter_available gauge");
+    for (const [name, data] of Object.entries(metrics.adapters)) {
+      const value = data.available ? 1 : 0;
+      lines.push(`feishu_bridge_adapter_available{name="${name}"} ${value}`);
+    }
+    return lines.join("\n");
+  }
+  /**
+   * 记录请求
+   */
+  recordRequest(success) {
+    this.requestCount.total++;
+    if (success) {
+      this.requestCount.successful++;
+    } else {
+      this.requestCount.failed++;
+    }
+  }
+};
+
+// src/core/bridge.ts
+init_logger();
+
+// src/core/reverse-channel.ts
+init_config();
+init_logger();
+var fs9 = __toESM(require("fs"));
+var path9 = __toESM(require("path"));
+var os9 = __toESM(require("os"));
+var import_events = require("events");
+var ReverseChannel = class extends import_events.EventEmitter {
+  constructor(feishuClient) {
+    super();
+    this.isRunning = false;
+    this.checkInterval = null;
+    this.messageQueue = [];
+    this.feishuClient = feishuClient;
+    const bridgeConfig = ConfigManager.getInstance().get();
+    this.config = {
+      enabled: bridgeConfig.behavior?.reverseChannelEnabled ?? true,
+      mode: bridgeConfig.behavior?.reverseChannelMode ?? "filesystem",
+      checkInterval: 1e3,
+      // 1秒检查一次
+      maxMessageAge: 5 * 60 * 1e3
+      // 5分钟过期
+    };
+    this.tempDir = path9.join(os9.tmpdir(), "feishu-bridge", "reverse-channel");
+    this.ensureTempDir();
+  }
+  /**
+   * 启动反向通信通道
+   */
+  start() {
+    if (this.isRunning || !this.config.enabled) {
+      return;
+    }
+    this.isRunning = true;
+    logger.info("Starting reverse communication channel...");
+    switch (this.config.mode) {
+      case "filesystem":
+        this.startFileSystemListener();
+        break;
+      case "websocket":
+        this.startWebSocketListener();
+        break;
+      case "http":
+        this.startHttpListener();
+        break;
+    }
+    this.startMessageQueueProcessor();
+  }
+  /**
+   * 停止反向通信通道
+   */
+  stop() {
+    if (!this.isRunning) {
+      return;
+    }
+    this.isRunning = false;
+    logger.info("Stopping reverse communication channel...");
+    if (this.checkInterval) {
+      clearInterval(this.checkInterval);
+      this.checkInterval = null;
+    }
+  }
+  /**
+   * 发送消息到飞书（供适配器调用）
+   */
+  async sendToFeishu(message) {
+    try {
+      this.messageQueue.push(message);
+      this.emit("messageQueued", message);
+      return true;
+    } catch (error) {
+      logger.error("Error queuing message to Feishu:", error);
+      return false;
+    }
+  }
+  /**
+   * 发送文件系统消息（供IDE写入文件后调用）
+   */
+  async sendFileSystemMessage(adapterType, content, chatId) {
+    const message = {
+      type: "message",
+      content,
+      chatId,
+      timestamp: Date.now()
+    };
+    const messageFile = path9.join(
+      this.tempDir,
+      `${adapterType}_msg_${Date.now()}.json`
+    );
+    fs9.writeFileSync(messageFile, JSON.stringify(message, null, 2));
+    logger.debug(`File system message written: ${messageFile}`);
+  }
+  ensureTempDir() {
+    if (!fs9.existsSync(this.tempDir)) {
+      fs9.mkdirSync(this.tempDir, { recursive: true });
+    }
+  }
+  startFileSystemListener() {
+    logger.info("Starting file system listener for reverse channel...");
+    this.checkInterval = setInterval(() => {
+      this.processFileSystemMessages();
+    }, this.config.checkInterval);
+  }
+  processFileSystemMessages() {
+    if (!fs9.existsSync(this.tempDir)) {
+      return;
+    }
+    try {
+      const files = fs9.readdirSync(this.tempDir);
+      const now = Date.now();
+      for (const file of files) {
+        if (!file.endsWith(".json")) continue;
+        const filePath = path9.join(this.tempDir, file);
+        try {
+          const content = fs9.readFileSync(filePath, "utf-8");
+          const message = JSON.parse(content);
+          if (now - message.timestamp > this.config.maxMessageAge) {
+            fs9.unlinkSync(filePath);
+            continue;
+          }
+          this.messageQueue.push(message);
+          fs9.unlinkSync(filePath);
+          logger.debug(`Processed file system message: ${file}`);
+        } catch (error) {
+          logger.error(`Error processing message file ${file}:`, error);
+          try {
+            fs9.unlinkSync(filePath);
+          } catch {
+          }
+        }
+      }
+    } catch (error) {
+      logger.error("Error reading message directory:", error);
+    }
+  }
+  startWebSocketListener() {
+    logger.info("WebSocket reverse channel not yet implemented, falling back to file system");
+    this.startFileSystemListener();
+  }
+  startHttpListener() {
+    logger.info("HTTP reverse channel not yet implemented, falling back to file system");
+    this.startFileSystemListener();
+  }
+  startMessageQueueProcessor() {
+    setInterval(async () => {
+      await this.processMessageQueue();
+    }, 500);
+  }
+  async processMessageQueue() {
+    if (this.messageQueue.length === 0) {
+      return;
+    }
+    const messagesToProcess = [...this.messageQueue];
+    this.messageQueue = [];
+    for (const message of messagesToProcess) {
+      try {
+        await this.deliverMessageToFeishu(message);
+        this.emit("messageDelivered", message);
+      } catch (error) {
+        logger.error("Error delivering message to Feishu:", error);
+        if (!message.retryCount || message.retryCount < 3) {
+          message.retryCount = (message.retryCount || 0) + 1;
+          this.messageQueue.push(message);
+        }
+      }
+    }
+  }
+  async deliverMessageToFeishu(message) {
+    const { type, content, chatId, metadata } = message;
+    if (!chatId) {
+      logger.warn("No chatId specified for message, cannot deliver");
+      return;
+    }
+    let formattedContent = content;
+    switch (type) {
+      case "notification":
+        formattedContent = `\u{1F514} ${content}`;
+        break;
+      case "status":
+        formattedContent = `\u{1F4CA} ${content}`;
+        break;
+      case "result":
+        formattedContent = `\u2705 ${content}`;
+        break;
+      default:
+        formattedContent = content;
+    }
+    const maxLength = 2e3;
+    if (formattedContent.length > maxLength) {
+      formattedContent = formattedContent.substring(0, maxLength) + "\n...(truncated)";
+    }
+    await this.feishuClient.sendMessage(chatId, {
+      msg_type: "text",
+      content: {
+        text: formattedContent
+      }
+    });
+    logger.info(`Message delivered to Feishu chat ${chatId}`);
+  }
+  isActive() {
+    return this.isRunning;
+  }
+  getQueueSize() {
+    return this.messageQueue.length;
+  }
+};
+
+// src/core/bridge.ts
+var import_fastify = __toESM(require("fastify"));
+var FeishuBridge = class {
+  constructor() {
+    this.wsHandler = null;
+    this.healthMonitor = null;
+    this.reverseChannel = null;
+    this.adapters = /* @__PURE__ */ new Map();
+    this.server = (0, import_fastify.default)({
+      logger: false
+      // 使用我们自己的日志系统
+    });
+    const config = ConfigManager.getInstance().get();
+    this.feishuClient = new FeishuClient(config.feishu);
+    this.sessionManager = new SessionManager(config.behavior.sessionTimeout);
+    this.reverseChannel = new ReverseChannel(this.feishuClient);
+    this.initAdapters();
+    this.commandExecutor = new CommandExecutor(
+      this.adapters,
+      this.sessionManager
+    );
+    this.webhookHandler = new FeishuWebhookHandler(
+      this.feishuClient,
+      this.commandExecutor
+    );
+  }
+  initAdapters() {
+    const config = ConfigManager.getInstance().get();
+    if (config.adapters.vscode?.enabled) {
+      const adapter = new VSCodeAdapter();
+      if (this.reverseChannel) adapter.setReverseChannel(this.reverseChannel);
+      this.adapters.set("vscode", adapter);
+    }
+    if (config.adapters.cursor?.enabled) {
+      const adapter = new CursorAdapter();
+      if (this.reverseChannel) adapter.setReverseChannel(this.reverseChannel);
+      this.adapters.set("cursor", adapter);
+    }
+    if (config.adapters.trae?.enabled) {
+      const adapter = new TraeAdapter();
+      if (this.reverseChannel) adapter.setReverseChannel(this.reverseChannel);
+      this.adapters.set("trae", adapter);
+    }
+    if (config.adapters.antigravity?.enabled) {
+      const adapter = new AntigravityAdapter();
+      if (this.reverseChannel) adapter.setReverseChannel(this.reverseChannel);
+      this.adapters.set("antigravity", adapter);
+    }
+    if (config.adapters.kiro?.enabled) {
+      const adapter = new KiroAdapter();
+      if (this.reverseChannel) adapter.setReverseChannel(this.reverseChannel);
+      this.adapters.set("kiro", adapter);
+    }
+    if (config.adapters.opencode?.enabled) {
+      const adapter = new OpenCodeAdapter();
+      if (this.reverseChannel) adapter.setReverseChannel(this.reverseChannel);
+      this.adapters.set("opencode", adapter);
+    }
+    if (config.adapters["claude-code"]?.enabled) {
+      const adapter = new ClaudeCodeAdapter();
+      if (this.reverseChannel) adapter.setReverseChannel(this.reverseChannel);
+      this.adapters.set("claude", adapter);
+    }
+  }
+  async start() {
+    const config = ConfigManager.getInstance().get();
+    const serverConfig = config.server;
+    if (this.reverseChannel) {
+      this.reverseChannel.start();
+      logger.info("Reverse communication channel started");
+    }
+    if (config.feishu.connectionMode !== "websocket") {
+      this.healthMonitor = new HealthMonitor(
+        this.server,
+        this.sessionManager,
+        this.adapters
+      );
+    }
+    if (config.feishu.connectionMode === "websocket") {
+      logger.info("Starting in WebSocket mode...");
+      this.wsHandler = new FeishuWebSocketHandler(
+        this.feishuClient,
+        this.commandExecutor
+      );
+      await this.wsHandler.start();
+      logger.info("WebSocket connection established");
+    } else {
+      logger.info("Starting in Webhook mode...");
+      this.server.post(serverConfig.webhookPath, async (request, reply) => {
+        await this.webhookHandler.handleWebhook(request, reply);
+      });
+      try {
+        const address = await this.server.listen({
+          port: serverConfig.port,
+          host: serverConfig.host
+        });
+        logger.info(`Feishu Bridge server running on ${address}`);
+        logger.info(`Webhook endpoint: ${serverConfig.webhookPath}`);
+        logger.info(`Health check endpoint: /health`);
+        logger.info(`Metrics endpoint: /metrics`);
+      } catch (err) {
+        logger.error(err instanceof Error ? err : String(err));
+        process.exit(1);
+      }
+    }
+  }
+  async stop() {
+    if (this.reverseChannel) {
+      this.reverseChannel.stop();
+      logger.info("Reverse communication channel stopped");
+    }
+    if (this.wsHandler) {
+      await this.wsHandler.stop();
+      this.wsHandler = null;
+    }
+    await this.server.close();
+    logger.info("Feishu Bridge server stopped");
+  }
+  getAdapter(adapterName) {
+    return this.adapters.get(adapterName);
+  }
+  getAdapters() {
+    return this.adapters;
+  }
+};
+
+// src/cli/index.ts
+init_config();
+init_logger();
+var program = new import_commander.Command();
+var pkg = JSON.parse(fs10.readFileSync(path10.join(__dirname, "../../package.json"), "utf-8"));
+program.name("feishu-bridge").description("Feishu Bridge - AI IDE/CLI integration for Feishu").version(pkg.version);
+program.command("start").description("Start the Feishu Bridge server").option("-p, --port <port>", "Server port", "3000").option("-h, --host <host>", "Server host", "0.0.0.0").option("-d, --daemon", "Run in daemon mode").action(async (options) => {
+  try {
+    const fileConfig = getConfigValue("feishu") || {};
+    const configManager = ConfigManager.getInstance();
+    const config = { ...DEFAULT_CONFIG };
+    if (fileConfig.appId) config.feishu.appId = fileConfig.appId;
+    if (fileConfig.appSecret) config.feishu.appSecret = fileConfig.appSecret;
+    if (fileConfig.encryptKey) config.feishu.encryptKey = fileConfig.encryptKey;
+    if (fileConfig.verificationToken) config.feishu.verificationToken = fileConfig.verificationToken;
+    if (fileConfig.domain) config.feishu.domain = fileConfig.domain;
+    config.server.port = parseInt(options.port);
+    config.server.host = options.host;
+    if (process.env.FEISHU_APP_ID) config.feishu.appId = process.env.FEISHU_APP_ID;
+    if (process.env.FEISHU_APP_SECRET) config.feishu.appSecret = process.env.FEISHU_APP_SECRET;
+    if (process.env.FEISHU_ENCRYPT_KEY) config.feishu.encryptKey = process.env.FEISHU_ENCRYPT_KEY;
+    if (process.env.FEISHU_VERIFICATION_TOKEN) config.feishu.verificationToken = process.env.FEISHU_VERIFICATION_TOKEN;
+    if (process.env.SERVER_PORT) config.server.port = parseInt(process.env.SERVER_PORT);
+    if (process.env.SERVER_HOST) config.server.host = process.env.SERVER_HOST;
+    if (!config.feishu.appId || !config.feishu.appSecret) {
+      console.error("Error: FEISHU_APP_ID and FEISHU_APP_SECRET are required");
+      console.error("Set them via:");
+      console.error("  1. Environment variables: export FEISHU_APP_ID=xxx");
+      console.error("  2. Config file: feishu-bridge config set feishu.appId xxx");
+      process.exit(1);
+    }
+    configManager.load(config);
+    const bridge = new FeishuBridge();
+    await bridge.start();
+    if (options.daemon) {
+      logger.info("Feishu Bridge started in daemon mode");
+    } else {
+      logger.info("Press Ctrl+C to stop the server");
+    }
+    process.on("SIGINT", async () => {
+      logger.info("Received SIGINT, shutting down gracefully...");
+      await bridge.stop();
+      process.exit(0);
+    });
+    process.on("SIGTERM", async () => {
+      logger.info("Received SIGTERM, shutting down gracefully...");
+      await bridge.stop();
+      process.exit(0);
+    });
+  } catch (error) {
+    console.error("Failed to start Feishu Bridge:", error);
+    process.exit(1);
+  }
+});
+var configCmd = program.command("config").description("Manage configuration");
+configCmd.command("set <key> <value>").description("Set a configuration value").action((key, value) => {
+  try {
+    setConfigValue(key, value);
+    console.log(`\u2705 Set ${key} = ${value}`);
+    console.log(`\u{1F4C1} Config file: ${getConfigFilePath()}`);
+  } catch (error) {
+    console.error("\u274C Error setting config:", error);
+    process.exit(1);
+  }
+});
+configCmd.command("get <key>").description("Get a configuration value").action((key) => {
+  const value = getConfigValue(key);
+  if (value === void 0) {
+    console.log(`\u26A0\uFE0F  ${key} is not set`);
+  } else {
+    console.log(`${key} = ${JSON.stringify(value)}`);
+  }
+});
+configCmd.command("delete <key>").description("Delete a configuration value").action((key) => {
+  try {
+    deleteConfigValue(key);
+    console.log(`\u2705 Deleted ${key}`);
+  } catch (error) {
+    console.error("\u274C Error deleting config:", error);
+    process.exit(1);
+  }
+});
+configCmd.command("list").description("List all configuration values").action(() => {
+  const config = listConfig();
+  if (Object.keys(config).length === 0) {
+    console.log("No configuration set");
+    console.log(`\u{1F4C1} Config file: ${getConfigFilePath()}`);
+  } else {
+    console.log("Current configuration:");
+    console.log(JSON.stringify(config, null, 2));
+    console.log(`
+\u{1F4C1} Config file: ${getConfigFilePath()}`);
+  }
+});
+var daemonCmd = program.command("daemon").description("Manage daemon process");
+daemonCmd.command("start").description("Start the daemon").action(async () => {
+  try {
+    const { DaemonManager: DaemonManager2 } = await Promise.resolve().then(() => (init_daemon(), daemon_exports));
+    const daemon = DaemonManager2.getInstance();
+    await daemon.start();
+    console.log("\u2705 Daemon started");
+    console.log('\u{1F4CA} Use "feishu-bridge status" to check status');
+  } catch (error) {
+    console.error("\u274C Failed to start daemon:", error);
+    process.exit(1);
+  }
+});
+daemonCmd.command("stop").description("Stop the daemon").action(async () => {
+  try {
+    const { DaemonManager: DaemonManager2 } = await Promise.resolve().then(() => (init_daemon(), daemon_exports));
+    const daemon = DaemonManager2.getInstance();
+    await daemon.stop();
+    console.log("\u2705 Daemon stopped");
+  } catch (error) {
+    console.error("\u274C Failed to stop daemon:", error);
+    process.exit(1);
+  }
+});
+daemonCmd.command("restart").description("Restart the daemon").action(async () => {
+  try {
+    const { DaemonManager: DaemonManager2 } = await Promise.resolve().then(() => (init_daemon(), daemon_exports));
+    const daemon = DaemonManager2.getInstance();
+    await daemon.stop();
+    await daemon.start();
+    console.log("\u2705 Daemon restarted");
+  } catch (error) {
+    console.error("\u274C Failed to restart daemon:", error);
+    process.exit(1);
+  }
+});
+program.command("status").description("Show service status").action(async () => {
+  try {
+    const { DaemonManager: DaemonManager2 } = await Promise.resolve().then(() => (init_daemon(), daemon_exports));
+    const daemon = DaemonManager2.getInstance();
+    const status = daemon.getStatus();
+    if (status) {
+      console.log("\u{1F4CA} Daemon Status:");
+      console.log(`  Running: ${status.isRunning ? "\u2705 Yes" : "\u274C No"}`);
+      console.log(`  PID: ${status.pid || "N/A"}`);
+      console.log(`  Restarts: ${status.restartCount}`);
+      console.log(`  Uptime: ${Math.floor(status.uptime)}s`);
+    } else {
+      console.log("\u{1F4CA} Service Status:");
+      console.log("  Daemon: Not running");
+    }
+    const config = listConfig();
+    console.log("\n\u{1F4C1} Configuration:");
+    console.log(`  Config file: ${getConfigFilePath()}`);
+    console.log(`  Feishu App ID: ${config.feishu?.appId ? "\u2705 Set" : "\u274C Not set"}`);
+    console.log(`  Feishu App Secret: ${config.feishu?.appSecret ? "\u2705 Set" : "\u274C Not set"}`);
+  } catch (error) {
+    console.error("\u274C Error checking status:", error);
+  }
+});
+program.command("shell-init").description("Output shell initialization script").action(() => {
+  console.log(`
+# Feishu Bridge Shell Integration
+# Add this to your ~/.bashrc, ~/.zshrc, or equivalent
+
+feishu-bridge-auto() {
+  # \u68C0\u6D4B\u5F53\u524D\u662F\u5426\u5728IDE/CLI\u73AF\u5883\u4E2D
+  if [ -n "$VSCODE_PID" ] || [ -n "$CURSOR_SHELL" ] || [ -n "$OPENCODE_SESSION" ]; then
+    # \u68C0\u67E5bridge\u662F\u5426\u5DF2\u8FD0\u884C
+    if ! pgrep -f "feishu-bridge" > /dev/null; then
+      echo "Auto-starting Feishu Bridge..."
+      feishu-bridge start --daemon 2>/dev/null &
+    fi
+  fi
+}
+
+# Bash
+if [ -n "$BASH_VERSION" ]; then
+  PROMPT_COMMAND="feishu-bridge-auto; $PROMPT_COMMAND"
+fi
+
+# Zsh
+if [ -n "$ZSH_VERSION" ]; then
+  precmd_functions+=(feishu-bridge-auto)
+fi
+`);
+});
+program.parse();
+if (!process.argv.slice(2).length) {
+  program.outputHelp();
+}
+//# sourceMappingURL=index.js.map