feishu-bridge 1.0.7 → 1.0.9

package/dist/cli/index.js

@@ -111,7 +111,8 @@ var init_config = __esm({
         maxOutputLength: 2e3,
         sessionTimeout: 30,
         reverseChannelEnabled: true,
-        reverseChannelMode: "filesystem"
+        reverseChannelMode: "websocket"
+        // 默认使用WebSocket模式
       },
       logging: {
         level: "info",
@@ -761,24 +762,28 @@ init_config();
 var Lark = __toESM(require("@larksuiteoapi/node-sdk"));
 var FeishuWebSocketHandler = class {
   constructor(client, commandExecutor, adapters) {
-    this.client = client;
     this.commandExecutor = commandExecutor;
     this.adapters = adapters;
     this.wsClient = null;
     this.eventDispatcher = null;
     this.isRunning = false;
+    this.client = client;
     this.logger = new Logger();
     this.messageRouter = new MessageRouter(adapters);
+    this.logger.info(`WebSocket handler created with client`);
+    console.log("\u{1F50D} DEBUG - WebSocket handler constructor - client:", {
+      hasAppId: !!client,
+      appId: client.appId,
+      baseUrl: client.baseUrl
+    });
   }
-  /**
-   * 启动WebSocket连接
-   */
   async start() {
     if (this.isRunning) {
       this.logger.warn("WebSocket handler already running");
       return;
     }
     const config = ConfigManager.getInstance().getFeishuConfig();
+    this.logger.info(`WebSocket config - appId: ${config.appId ? "\u2705 Set" : "\u274C Empty"}, domain: ${config.domain}`);
     try {
       this.logger.info("Creating Feishu WebSocket client...");
       this.wsClient = new Lark.WSClient({
@@ -788,74 +793,55 @@ var FeishuWebSocketHandler = class {
         loggerLevel: Lark.LoggerLevel.info
       });
       this.eventDispatcher = new Lark.EventDispatcher({
-        encryptKey: config.encryptKey,
-        verificationToken: config.verificationToken
+        encryptKey: config.encryptKey || "",
+        verificationToken: config.verificationToken || ""
       });
       this.registerEventHandlers();
-      this.wsClient.on("message", async (event) => {
-        await this.handleEvent(event);
-      });
-      this.wsClient.on("error", (error) => {
-        this.logger.error("WebSocket error:", error);
-      });
-      this.wsClient.on("close", () => {
-        this.logger.info("WebSocket connection closed");
-        if (this.isRunning) {
-          this.logger.info("Attempting to reconnect...");
-          setTimeout(() => this.start(), 5e3);
-        }
-      });
+      this.logger.info("Starting WebSocket connection...");
+      await this.wsClient.start({ eventDispatcher: this.eventDispatcher });
       this.isRunning = true;
-      this.logger.info("Feishu WebSocket handler started successfully");
+      this.logger.info("\u2705 Feishu WebSocket connected successfully!");
     } catch (error) {
-      this.logger.error("Failed to start WebSocket handler:", error);
+      console.error("\u274C WebSocket ERROR:", error);
+      this.logger.error("\u274C Failed to start WebSocket handler:", error);
       throw error;
     }
   }
-  /**
-   * 停止WebSocket连接
-   */
-  async stop() {
-    this.isRunning = false;
-    if (this.wsClient) {
-      this.wsClient.close();
-      this.wsClient = null;
-    }
-    this.logger.info("WebSocket handler stopped");
-  }
-  /**
-   * 注册事件处理器
-   */
   registerEventHandlers() {
     if (!this.eventDispatcher) return;
-    this.eventDispatcher.on("im.message.receive_v1", async (event) => {
-      await this.handleMessageEvent(event);
-    });
-    this.eventDispatcher.on("im.chat.member.bot.added_v1", (event) => {
-      this.logger.info("Bot added to chat:", event);
-    });
-    this.eventDispatcher.on("im.chat.member.bot.deleted_v1", (event) => {
-      this.logger.info("Bot removed from chat:", event);
-    });
-  }
-  /**
-   * 处理事件
-   */
-  async handleEvent(event) {
-    try {
-      if (this.eventDispatcher) {
-        await this.eventDispatcher.dispatch(event);
+    this.logger.info("Registering event handlers...");
+    this.eventDispatcher.register({
+      "im.message.receive_v1": async (event) => {
+        this.logger.info("\u{1F4E8} Event received: im.message.receive_v1");
+        this.logger.info("Event data:", JSON.stringify(event, null, 2));
+        await this.handleMessageEvent(event);
+      },
+      "im.message.message_read_v1": (event) => {
+        this.logger.debug("Message read:", event);
+      },
+      "im.chat.member.bot.added_v1": (event) => {
+        this.logger.info("Bot added to chat:", event);
+      },
+      "im.chat.member.bot.deleted_v1": (event) => {
+        this.logger.info("Bot removed from chat:", event);
       }
-    } catch (error) {
-      this.logger.error("Error dispatching event:", error);
-    }
+    });
   }
-  /**
-   * 处理消息事件
-   */
   async handleMessageEvent(event) {
+    this.logger.info("\u{1F504} handleMessageEvent called");
+    this.logger.info("Event:", JSON.stringify(event, null, 2));
+    console.log("\u{1F50D} DEBUG - handleMessageEvent - this.client:", {
+      exists: !!this.client,
+      appId: this.client?.appId,
+      baseUrl: this.client?.baseUrl
+    });
     const { message, sender } = event;
-    if (!message || message.message_type !== "text") {
+    if (!message) {
+      this.logger.warn("No message in event");
+      return;
+    }
+    this.logger.info(`Message type: ${message.message_type}`);
+    if (message.message_type !== "text") {
       this.logger.debug("Ignoring non-text message");
       return;
     }
@@ -867,7 +853,7 @@ var FeishuWebSocketHandler = class {
         this.logger.warn("Missing sender ID");
         return;
       }
-      this.logger.info(`Received message from ${senderId}: ${text}`);
+      this.logger.info(`\u{1F4E8} Received message from ${senderId}: ${text}`);
       const route = await this.messageRouter.route(text);
       if (route.type === "error") {
         await this.client.sendMessage(message.chat_id, {
@@ -885,7 +871,7 @@ var FeishuWebSocketHandler = class {
       }
       if (route.type === "direct" && route.target) {
         const command = this.messageRouter.extractCommand(text);
-        this.logger.info(`Executing command for ${route.target}: ${command}`);
+        this.logger.info(`\u{1F3AF} Routing to ${route.target}: ${command}`);
         await this.client.sendMessage(message.chat_id, {
           msg_type: "text",
           content: { text: `\u23F3 \u6B63\u5728\u6267\u884C: ${command}` }
@@ -902,20 +888,17 @@ var FeishuWebSocketHandler = class {
         });
       }
     } catch (error) {
-      this.logger.error("Error processing message event:", error);
+      this.logger.error("Error processing event:", error);
       try {
         await this.client.sendMessage(message.chat_id, {
           msg_type: "text",
-          content: { text: `\u274C \u5904\u7406\u6D88\u606F\u65F6\u51FA\u9519: ${error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"}` }
+          content: { text: `\u274C \u5904\u7406\u6D88\u606F\u65F6\u51FA\u9519` }
         });
       } catch (sendError) {
         this.logger.error("Failed to send error message:", sendError);
       }
     }
   }
-  /**
-   * 格式化响应
-   */
   formatResponse(result) {
     if (result.success) {
       const output = typeof result.output === "string" ? result.output.substring(0, 2e3) : JSON.stringify(result.output).substring(0, 2e3);
@@ -929,6 +912,14 @@ ${output}`;
 ${error.substring(0, 2e3)}`;
     }
   }
+  async stop() {
+    this.isRunning = false;
+    if (this.wsClient) {
+      this.wsClient.close();
+      this.wsClient = null;
+    }
+    this.logger.info("WebSocket handler stopped");
+  }
 };
 
 // src/feishu/client.ts
@@ -937,20 +928,33 @@ var FeishuClient = class {
   constructor(config) {
     this.accessToken = null;
     this.tokenExpireTime = 0;
+    console.log("\u{1F50D} DEBUG - FeishuClient constructor called with:", {
+      hasAppId: !!config.appId,
+      appIdLength: config.appId?.length,
+      hasSecret: !!config.appSecret,
+      domain: config.domain
+    });
     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();
+    console.log("\u{1F50D} DEBUG - FeishuClient this.appId after assignment:", this.appId);
+    this.logger.info(`FeishuClient initialized with appId: ${this.appId ? "\u2705" : "\u274C Empty"}`);
   }
   /**
    * 获取访问令牌
    */
   async getAccessToken() {
+    console.log("\u{1F50D} DEBUG - getAccessToken called");
+    console.log("\u{1F50D} DEBUG - this.appId:", this.appId);
+    console.log("\u{1F50D} DEBUG - this.baseUrl:", this.baseUrl);
     const now = Date.now();
     if (this.accessToken && now < this.tokenExpireTime) {
+      console.log("\u{1F50D} DEBUG - Using cached token");
       return this.accessToken;
     }
+    console.log("\u{1F50D} DEBUG - Fetching new token from:", `${this.baseUrl}/auth/v3/tenant_access_token/internal`);
     try {
       const response = await fetch(`${this.baseUrl}/auth/v3/tenant_access_token/internal`, {
         method: "POST",
@@ -974,6 +978,9 @@ var FeishuClient = class {
       this.logger.info("Access token refreshed successfully");
       return this.accessToken;
     } catch (error) {
+      console.error("\u274C getAccessToken ERROR:", error);
+      console.error("\u274C this.appId:", this.appId);
+      console.error("\u274C this.baseUrl:", this.baseUrl);
       this.logger.error("Error getting access token:", error);
       throw error;
     }
@@ -982,6 +989,16 @@ var FeishuClient = class {
    * 发送消息到指定聊天
    */
   async sendMessage(chatId, message) {
+    console.log("\u{1F50D}\u{1F50D}\u{1F50D} CRITICAL DEBUG - sendMessage ENTER");
+    console.log("\u{1F50D}\u{1F50D}\u{1F50D} this.appId:", this.appId);
+    console.log("\u{1F50D}\u{1F50D}\u{1F50D} this.appSecret:", this.appSecret ? "***" + this.appSecret.slice(-4) : "EMPTY");
+    console.log("\u{1F50D}\u{1F50D}\u{1F50D} this.baseUrl:", this.baseUrl);
+    console.log("\u{1F50D}\u{1F50D}\u{1F50D} chatId:", chatId);
+    console.log("\u{1F50D}\u{1F50D}\u{1F50D} message:", JSON.stringify(message));
+    if (!this.appId || !this.baseUrl) {
+      console.error("\u274C\u274C\u274C FATAL: this.appId or this.baseUrl is empty in sendMessage!");
+      throw new Error(`Invalid client state: appId=${this.appId}, baseUrl=${this.baseUrl}`);
+    }
     try {
       const token = await this.getAccessToken();
       const response = await fetch(`${this.baseUrl}/im/v1/messages?receive_id_type=chat_id`, {
@@ -1047,11 +1064,28 @@ var CommandExecutor = class {
   }
   async execute(request) {
     try {
-      this.logger.info(`Executing command for target: ${request.target}, command: ${request.command}`);
+      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();
+      if (adapterName === "auto" || adapterName === "") {
+        const available = this.getAvailableAdapters();
+        if (available.length === 0) {
+          throw new Error("\u672A\u627E\u5230\u4EFB\u4F55\u53EF\u7528\u7684\u5DE5\u5177\uFF0C\u8BF7\u786E\u4FDD\u5DF2\u6253\u5F00IDE\u6216\u542F\u52A8CLI");
+        }
+        if (available.length === 1) {
+          adapterName = available[0];
+        } else {
+          const availableList = available.map((a) => `@${a}`).join(", ");
+          throw new Error(
+            `\u8BF7\u6307\u5B9A\u8981\u4F7F\u7528\u7684\u5DE5\u5177
+
+\u53EF\u7528\u5DE5\u5177: ${availableList}
+
+\u4F8B\u5982\uFF1A@opencode /help`
+          );
+        }
       }
       const adapter = this.adapters.get(adapterName);
       if (!adapter) {
@@ -1071,7 +1105,10 @@ var CommandExecutor = class {
         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);
+        const executionResult = await adapter.runProgram(
+          command,
+          executionContext.workspaceRoot
+        );
         result = executionResult.stdout || executionResult.stderr;
       } else {
         result = await adapter.sendCommand(request.command, executionContext);
@@ -1095,25 +1132,64 @@ var CommandExecutor = class {
     }
   }
   detectBestAdapter() {
-    for (const [name, adapter] of this.adapters) {
-      if (adapter.isAvailable) {
+    const cliAdapters = ["opencode", "claude", "gemini"];
+    const ideAdapters = ["vscode", "cursor", "trae", "antigravity", "kiro"];
+    for (const name of cliAdapters) {
+      const adapter = this.adapters.get(name);
+      if (adapter && adapter.isAvailable) {
+        return name;
+      }
+    }
+    for (const name of ideAdapters) {
+      const adapter = this.adapters.get(name);
+      if (adapter && adapter.isAvailable) {
         return name;
       }
     }
     return "vscode";
   }
+  /**
+   * 获取所有可用的适配器列表
+   */
+  getAvailableAdapters() {
+    const available = [];
+    for (const [name, adapter] of this.adapters) {
+      if (adapter.isAvailable) {
+        available.push(name);
+      }
+    }
+    return available;
+  }
+  /**
+   * 获取适配器使用提示
+   */
+  getAdapterHint(currentAdapter) {
+    const available = this.getAvailableAdapters();
+    if (available.length <= 1) {
+      return "";
+    }
+    return `
+
+\u{1F4A1} \u5F53\u524D\u53EF\u7528\u5DE5\u5177: ${available.join(", ")}`;
+  }
   isGenerateCommand(command) {
-    return /\b(generate|create|make|build|implement|write|develop|add|new)\b/i.test(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);
+    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);
+    const match = command.match(
+      /\b(run|execute|start|launch|test|debug|build)\b\s+(.*)/i
+    );
     return match ? match[2] : command;
   }
 };
@@ -2362,6 +2438,7 @@ var OpenCodeAdapter = class extends BaseIDEAdapter {
     this.ideType = "opencode";
     this.ideName = "OpenCode";
     this.useSocket = false;
+    this.useHttp = false;
     this.messageId = 0;
     this.pendingMessages = /* @__PURE__ */ new Map();
   }
@@ -2395,19 +2472,40 @@ var OpenCodeAdapter = class extends BaseIDEAdapter {
   }
   getSocketPath() {
     const possiblePaths = [
+      // Windows: temp directory
       path7.join(os7.tmpdir(), "opencode.sock"),
       path7.join(os7.tmpdir(), "opencode-bridge.sock"),
+      // Unix socket locations
       path7.join(os7.homedir(), ".opencode", "socket"),
-      process.env.OPENCODE_SOCKET
+      // Environment variable override
+      process.env.OPENCODE_SOCKET,
+      // Windows named pipe format
+      "\\\\.\\pipe\\opencode"
     ].filter(Boolean);
     for (const socketPath of possiblePaths) {
-      if (fs7.existsSync(socketPath)) {
-        return socketPath;
+      try {
+        if (fs7.existsSync(socketPath)) {
+          return socketPath;
+        }
+      } catch {
+        if (socketPath.startsWith("\\\\.\\pipe\\")) {
+          return socketPath;
+        }
       }
     }
     return null;
   }
   async activate() {
+    try {
+      const httpConnected = await this.connectHttp();
+      if (httpConnected) {
+        this.useHttp = true;
+        this.logger.info("OpenCode HTTP\u6A21\u5F0F\u5DF2\u8FDE\u63A5");
+        return;
+      }
+    } catch (error) {
+      this.logger.warn(`HTTP\u8FDE\u63A5\u5931\u8D25: ${error}`);
+    }
     const socketPath = this.getSocketPath();
     if (socketPath) {
       try {
@@ -2416,13 +2514,16 @@ var OpenCodeAdapter = class extends BaseIDEAdapter {
         this.logger.info(`OpenCode Socket\u6A21\u5F0F\u5DF2\u8FDE\u63A5: ${socketPath}`);
         return;
       } catch (error) {
-        this.logger.warn(`Socket\u8FDE\u63A5\u5931\u8D25\uFF0C\u5C06\u4F7F\u7528CLI\u6A21\u5F0F: ${error}`);
+        this.logger.warn(`Socket\u8FDE\u63A5\u5931\u8D25: ${error}`);
       }
     }
-    if (!this.checkCLIExists()) {
-      throw new Error("OpenCode\u672A\u5B89\u88C5\uFF0C\u8BF7\u5148\u8FD0\u884C: npm install -g opencode");
+    if (this.checkCLIExists()) {
+      this.logger.info("OpenCode CLI\u6A21\u5F0F\u5C31\u7EEA");
+      return;
     }
-    this.logger.info("OpenCode CLI\u6A21\u5F0F\u5C31\u7EEA");
+    throw new Error(
+      "OpenCode\u672A\u5B89\u88C5\u6216\u4E0D\u53EF\u7528\u3002\u8BF7\u786E\u4FDDOpenCode\u6B63\u5728\u8FD0\u884C\u6216\u8FD0\u884C: npm install -g opencode"
+    );
   }
   async deactivate() {
     if (this.socketClient) {
@@ -2442,6 +2543,30 @@ var OpenCodeAdapter = class extends BaseIDEAdapter {
       this.setupSocketListener();
     });
   }
+  /**
+   * HTTP方式连接（OpenCode 1.1.53 使用HTTP协议）
+   */
+  async connectHttp() {
+    const port = process.env.OPENCODE_PORT || "26178";
+    const host = process.env.OPENCODE_HOST || "127.0.0.1";
+    try {
+      this.logger.info(`Trying HTTP connection to OpenCode at ${host}:${port}`);
+      const response = await fetch(`http://${host}:${port}/api/ping`, {
+        method: "GET",
+        headers: {
+          "Content-Type": "application/json"
+        }
+      });
+      if (response.ok) {
+        this.logger.info("HTTP connection to OpenCode successful");
+        return true;
+      }
+      return false;
+    } catch (error) {
+      this.logger.warn(`HTTP connection failed: ${error}`);
+      return false;
+    }
+  }
   setupSocketListener() {
     if (!this.socketClient) return;
     let buffer = "";
@@ -2542,7 +2667,9 @@ var OpenCodeAdapter = class extends BaseIDEAdapter {
   }
   async getAIResponse(prompt, context) {
     try {
-      this.logger.info(`Getting AI response from OpenCode for prompt: ${prompt.substring(0, 100)}...`);
+      this.logger.info(
+        `Getting AI response from OpenCode for prompt: ${prompt.substring(0, 100)}...`
+      );
       return await this.sendCommand(prompt, context);
     } catch (error) {
       this.logger.error(`Error getting OpenCode AI response:`, error);
@@ -2585,6 +2712,31 @@ var OpenCodeAdapter = class extends BaseIDEAdapter {
     const content = await this.getAIResponse(prompt);
     return { content, model: "claude-3-5-sonnet" };
   }
+  /**
+   * 发送进度更新到飞书
+   * 允许长时间任务在执行过程中推送进度信息
+   */
+  async sendProgressUpdate(progress, context) {
+    return this.sendToFeishu(progress, context, "progress");
+  }
+  /**
+   * 发送状态更新到飞书
+   */
+  async sendStatusUpdate(status, context) {
+    return this.sendToFeishu(status, context, "status");
+  }
+  /**
+   * 发送通知到飞书
+   */
+  async sendNotification(notification, context) {
+    return this.sendToFeishu(notification, context, "notification");
+  }
+  /**
+   * 发送最终结果到飞书
+   */
+  async sendResult(result, context) {
+    return this.sendToFeishu(result, context, "result");
+  }
 };
 
 // src/adapters/claude-code.ts
@@ -3151,22 +3303,255 @@ init_logger();
 var fs9 = __toESM(require("fs"));
 var path9 = __toESM(require("path"));
 var os9 = __toESM(require("os"));
+var http = __toESM(require("http"));
 var import_events = require("events");
+var import_ws = __toESM(require("ws"));
+var WebSocketManager = class extends import_events.EventEmitter {
+  constructor(config) {
+    super();
+    this.wss = null;
+    this.clients = /* @__PURE__ */ new Map();
+    this.isRunning = false;
+    this.config = config;
+  }
+  start() {
+    return new Promise((resolve, reject) => {
+      if (this.isRunning) {
+        resolve();
+        return;
+      }
+      try {
+        this.wss = new import_ws.WebSocketServer({
+          port: this.config.port,
+          host: this.config.host
+        });
+        this.wss.on("listening", () => {
+          this.isRunning = true;
+          logger.info(
+            `WebSocket server listening on ${this.config.host}:${this.config.port}`
+          );
+          this.emit("listening");
+          resolve();
+        });
+        this.wss.on(
+          "connection",
+          (ws, req) => {
+            const clientId = `${req.socket.remoteAddress}:${req.socket.remotePort}`;
+            logger.info(`WebSocket client connected: ${clientId}`);
+            this.clients.set(clientId, ws);
+            this.emit("connection", clientId, ws);
+            ws.on("message", (data) => {
+              try {
+                const message = JSON.parse(data.toString());
+                this.emit("message", clientId, message);
+              } catch (error) {
+                logger.error("Invalid WebSocket message format:", error);
+                ws.send(JSON.stringify({ error: "Invalid message format" }));
+              }
+            });
+            ws.on("close", () => {
+              logger.info(`WebSocket client disconnected: ${clientId}`);
+              this.clients.delete(clientId);
+              this.emit("disconnect", clientId);
+            });
+            ws.on("error", (error) => {
+              logger.error(`WebSocket error for client ${clientId}:`, error);
+              this.emit("error", clientId, error);
+            });
+            ws.send(
+              JSON.stringify({
+                type: "connected",
+                message: "Connected to Feishu Bridge reverse channel",
+                timestamp: Date.now()
+              })
+            );
+          }
+        );
+        this.wss.on("error", (error) => {
+          logger.error("WebSocket server error:", error);
+          this.emit("error", error);
+          reject(error);
+        });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  }
+  stop() {
+    return new Promise((resolve) => {
+      if (!this.isRunning || !this.wss) {
+        resolve();
+        return;
+      }
+      this.clients.forEach((ws, clientId) => {
+        ws.close();
+        logger.debug(`Closed WebSocket connection: ${clientId}`);
+      });
+      this.clients.clear();
+      this.wss.close(() => {
+        this.isRunning = false;
+        logger.info("WebSocket server stopped");
+        this.emit("closed");
+        resolve();
+      });
+    });
+  }
+  broadcast(message) {
+    const messageStr = JSON.stringify(message);
+    this.clients.forEach((ws, clientId) => {
+      if (ws.readyState === import_ws.default.OPEN) {
+        ws.send(messageStr);
+      }
+    });
+  }
+  sendToClient(clientId, message) {
+    const ws = this.clients.get(clientId);
+    if (ws && ws.readyState === import_ws.default.OPEN) {
+      ws.send(JSON.stringify(message));
+      return true;
+    }
+    return false;
+  }
+  getClientCount() {
+    return this.clients.size;
+  }
+  isActive() {
+    return this.isRunning;
+  }
+};
+var HttpManager = class extends import_events.EventEmitter {
+  constructor(config) {
+    super();
+    this.server = null;
+    this.isRunning = false;
+    this.config = config;
+  }
+  start() {
+    return new Promise((resolve, reject) => {
+      if (this.isRunning) {
+        resolve();
+        return;
+      }
+      this.server = http.createServer((req, res) => {
+        res.setHeader("Access-Control-Allow-Origin", "*");
+        res.setHeader("Access-Control-Allow-Methods", "POST, GET, OPTIONS");
+        res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+        if (req.method === "OPTIONS") {
+          res.writeHead(200);
+          res.end();
+          return;
+        }
+        if (req.url === "/health" && req.method === "GET") {
+          res.writeHead(200, { "Content-Type": "application/json" });
+          res.end(
+            JSON.stringify({
+              status: "healthy",
+              mode: "http-reverse-channel",
+              timestamp: Date.now()
+            })
+          );
+          return;
+        }
+        if (req.url === "/message" && req.method === "POST") {
+          let body = "";
+          req.on("data", (chunk) => {
+            body += chunk.toString();
+          });
+          req.on("end", () => {
+            try {
+              const message = JSON.parse(body);
+              this.emit("message", message);
+              res.writeHead(200, { "Content-Type": "application/json" });
+              res.end(
+                JSON.stringify({
+                  success: true,
+                  message: "Message received",
+                  timestamp: Date.now()
+                })
+              );
+            } catch (error) {
+              logger.error("Invalid HTTP message format:", error);
+              res.writeHead(400, { "Content-Type": "application/json" });
+              res.end(
+                JSON.stringify({
+                  success: false,
+                  error: "Invalid message format"
+                })
+              );
+            }
+          });
+          return;
+        }
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Not found" }));
+      });
+      this.server.listen(this.config.port, this.config.host, () => {
+        this.isRunning = true;
+        logger.info(
+          `HTTP reverse channel server listening on ${this.config.host}:${this.config.port}`
+        );
+        this.emit("listening");
+        resolve();
+      });
+      this.server.on("error", (error) => {
+        logger.error("HTTP server error:", error);
+        this.emit("error", error);
+        reject(error);
+      });
+    });
+  }
+  stop() {
+    return new Promise((resolve) => {
+      if (!this.isRunning || !this.server) {
+        resolve();
+        return;
+      }
+      this.server.close(() => {
+        this.isRunning = false;
+        logger.info("HTTP server stopped");
+        this.emit("closed");
+        resolve();
+      });
+    });
+  }
+  isActive() {
+    return this.isRunning;
+  }
+};
 var ReverseChannel = class extends import_events.EventEmitter {
   constructor(feishuClient) {
     super();
     this.isRunning = false;
     this.checkInterval = null;
     this.messageQueue = [];
+    // 模式特定的管理器
+    this.wsManager = null;
+    this.httpManager = null;
+    // 健康检查
+    this.healthCheckTimer = null;
+    this.reconnectAttempts = 0;
+    this.isReconnecting = false;
     this.feishuClient = feishuClient;
     const bridgeConfig = ConfigManager.getInstance().get();
     this.config = {
       enabled: bridgeConfig.behavior?.reverseChannelEnabled ?? true,
-      mode: bridgeConfig.behavior?.reverseChannelMode ?? "filesystem",
+      mode: bridgeConfig.behavior?.reverseChannelMode ?? "websocket",
+      // 默认改为WebSocket
       checkInterval: 1e3,
-      // 1秒检查一次
-      maxMessageAge: 5 * 60 * 1e3
-      // 5分钟过期
+      maxMessageAge: 5 * 60 * 1e3,
+      // WebSocket默认配置
+      websocketPort: bridgeConfig.server?.port ? bridgeConfig.server.port + 1 : 3001,
+      websocketHost: bridgeConfig.server?.host || "0.0.0.0",
+      // HTTP默认配置
+      httpPort: bridgeConfig.server?.port ? bridgeConfig.server.port + 2 : 3002,
+      httpHost: bridgeConfig.server?.host || "0.0.0.0",
+      // 健康检查配置
+      healthCheckInterval: 3e4,
+      // 30秒
+      autoReconnect: true,
+      reconnectDelay: 5e3,
+      // 5秒
+      maxReconnectAttempts: 10
     };
     this.tempDir = path9.join(os9.tmpdir(), "feishu-bridge", "reverse-channel");
     this.ensureTempDir();
@@ -3174,46 +3559,223 @@ var ReverseChannel = class extends import_events.EventEmitter {
   /**
    * 启动反向通信通道
    */
-  start() {
+  async start() {
     if (this.isRunning || !this.config.enabled) {
       return;
     }
     this.isRunning = true;
-    logger.info("Starting reverse communication channel...");
+    this.reconnectAttempts = 0;
+    logger.info(
+      `Starting reverse communication channel in ${this.config.mode} mode...`
+    );
+    try {
+      await this.startByMode();
+      this.startHealthCheck();
+      this.startMessageQueueProcessor();
+      this.emit("started");
+    } catch (error) {
+      logger.error("Failed to start reverse channel:", error);
+      this.isRunning = false;
+      throw error;
+    }
+  }
+  /**
+   * 根据模式启动对应服务
+   */
+  async startByMode() {
     switch (this.config.mode) {
+      case "websocket":
+        await this.startWebSocketServer();
+        break;
+      case "http":
+        await this.startHttpServer();
+        break;
       case "filesystem":
         this.startFileSystemListener();
         break;
+      default:
+        throw new Error(`Unknown reverse channel mode: ${this.config.mode}`);
+    }
+  }
+  /**
+   * 启动WebSocket服务器
+   */
+  async startWebSocketServer() {
+    this.wsManager = new WebSocketManager({
+      port: this.config.websocketPort,
+      host: this.config.websocketHost
+    });
+    this.wsManager.on("message", (clientId, message) => {
+      logger.debug(`Received WebSocket message from ${clientId}:`, message);
+      if (this.isValidMessage(message)) {
+        const messageId = message.id || `${clientId}_${Date.now()}`;
+        this.messageQueue.push({
+          ...message,
+          timestamp: message.timestamp || Date.now(),
+          id: messageId
+        });
+        this.emit("messageReceived", message);
+        this.wsManager?.sendToClient(clientId, {
+          type: "ack",
+          originalId: messageId,
+          timestamp: Date.now()
+        });
+      } else {
+        this.wsManager?.sendToClient(clientId, {
+          type: "error",
+          error: "Invalid message format",
+          timestamp: Date.now()
+        });
+      }
+    });
+    this.wsManager.on("error", (error) => {
+      logger.error("WebSocket manager error:", error);
+      this.handleConnectionError();
+    });
+    await this.wsManager.start();
+  }
+  /**
+   * 启动HTTP服务器
+   */
+  async startHttpServer() {
+    this.httpManager = new HttpManager({
+      port: this.config.httpPort,
+      host: this.config.httpHost
+    });
+    this.httpManager.on("message", (message) => {
+      logger.debug("Received HTTP message:", message);
+      if (this.isValidMessage(message)) {
+        this.messageQueue.push({
+          ...message,
+          timestamp: message.timestamp || Date.now()
+        });
+        this.emit("messageReceived", message);
+      }
+    });
+    this.httpManager.on("error", (error) => {
+      logger.error("HTTP manager error:", error);
+      this.handleConnectionError();
+    });
+    await this.httpManager.start();
+  }
+  /**
+   * 验证消息格式
+   */
+  isValidMessage(message) {
+    return message && typeof message === "object" && typeof message.content === "string" && (message.chatId || message.chatId === void 0);
+  }
+  /**
+   * 处理连接错误
+   */
+  handleConnectionError() {
+    if (!this.config.autoReconnect || this.isReconnecting) {
+      return;
+    }
+    this.isReconnecting = true;
+    this.reconnectAttempts++;
+    if (this.reconnectAttempts > this.config.maxReconnectAttempts) {
+      logger.error(
+        `Max reconnect attempts (${this.config.maxReconnectAttempts}) reached. Giving up.`
+      );
+      this.emit("reconnectFailed");
+      this.isReconnecting = false;
+      return;
+    }
+    logger.info(
+      `Attempting to reconnect (${this.reconnectAttempts}/${this.config.maxReconnectAttempts})...`
+    );
+    setTimeout(async () => {
+      try {
+        await this.restart();
+        this.reconnectAttempts = 0;
+        logger.info("Reconnection successful");
+        this.emit("reconnected");
+      } catch (error) {
+        logger.error("Reconnection failed:", error);
+      } finally {
+        this.isReconnecting = false;
+      }
+    }, this.config.reconnectDelay);
+  }
+  /**
+   * 重启服务
+   */
+  async restart() {
+    await this.stopInternal();
+    await this.startByMode();
+  }
+  /**
+   * 启动健康检查
+   */
+  startHealthCheck() {
+    this.healthCheckTimer = setInterval(() => {
+      this.performHealthCheck();
+    }, this.config.healthCheckInterval);
+  }
+  /**
+   * 执行健康检查
+   */
+  performHealthCheck() {
+    let isHealthy = false;
+    switch (this.config.mode) {
       case "websocket":
-        this.startWebSocketListener();
+        isHealthy = this.wsManager?.isActive() ?? false;
         break;
       case "http":
-        this.startHttpListener();
+        isHealthy = this.httpManager?.isActive() ?? false;
         break;
+      case "filesystem":
+        isHealthy = this.isRunning;
+        break;
+    }
+    if (!isHealthy && this.config.autoReconnect && !this.isReconnecting) {
+      logger.warn("Health check failed, triggering reconnection...");
+      this.handleConnectionError();
     }
-    this.startMessageQueueProcessor();
+    this.emit("healthCheck", { healthy: isHealthy, mode: this.config.mode });
   }
   /**
    * 停止反向通信通道
    */
-  stop() {
-    if (!this.isRunning) {
-      return;
-    }
+  async stop() {
+    await this.stopInternal();
+    this.emit("stopped");
+  }
+  /**
+   * 内部停止方法
+   */
+  async stopInternal() {
     this.isRunning = false;
     logger.info("Stopping reverse communication channel...");
+    if (this.healthCheckTimer) {
+      clearInterval(this.healthCheckTimer);
+      this.healthCheckTimer = null;
+    }
     if (this.checkInterval) {
       clearInterval(this.checkInterval);
       this.checkInterval = null;
     }
+    if (this.wsManager) {
+      await this.wsManager.stop();
+      this.wsManager = null;
+    }
+    if (this.httpManager) {
+      await this.httpManager.stop();
+      this.httpManager = null;
+    }
   }
   /**
    * 发送消息到飞书（供适配器调用）
    */
   async sendToFeishu(message) {
     try {
-      this.messageQueue.push(message);
-      this.emit("messageQueued", message);
+      const queuedMessage = {
+        ...message,
+        id: `local_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+        timestamp: message.timestamp || Date.now()
+      };
+      this.messageQueue.push(queuedMessage);
+      this.emit("messageQueued", queuedMessage);
       return true;
     } catch (error) {
       logger.error("Error queuing message to Feishu:", error);
@@ -3223,9 +3785,9 @@ var ReverseChannel = class extends import_events.EventEmitter {
   /**
    * 发送文件系统消息（供IDE写入文件后调用）
    */
-  async sendFileSystemMessage(adapterType, content, chatId) {
+  async sendFileSystemMessage(adapterType, content, chatId, type = "message") {
     const message = {
-      type: "message",
+      type,
       content,
       chatId,
       timestamp: Date.now()
@@ -3265,7 +3827,10 @@ var ReverseChannel = class extends import_events.EventEmitter {
             fs9.unlinkSync(filePath);
             continue;
           }
-          this.messageQueue.push(message);
+          this.messageQueue.push({
+            ...message,
+            id: `fs_${file}`
+          });
           fs9.unlinkSync(filePath);
           logger.debug(`Processed file system message: ${file}`);
         } catch (error) {
@@ -3280,14 +3845,6 @@ var ReverseChannel = class extends import_events.EventEmitter {
       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();
@@ -3305,19 +3862,25 @@ var ReverseChannel = class extends import_events.EventEmitter {
         this.emit("messageDelivered", message);
       } catch (error) {
         logger.error("Error delivering message to Feishu:", error);
-        if (!message.retryCount || message.retryCount < 3) {
+        if ((message.retryCount || 0) < 3) {
           message.retryCount = (message.retryCount || 0) + 1;
           this.messageQueue.push(message);
+        } else {
+          this.emit("messageFailed", message, error);
         }
       }
     }
   }
   async deliverMessageToFeishu(message) {
-    const { type, content, chatId, metadata } = message;
+    const { type, content, chatId, metadata, media } = message;
     if (!chatId) {
       logger.warn("No chatId specified for message, cannot deliver");
       return;
     }
+    if (media) {
+      await this.deliverMediaMessage(chatId, media, content);
+      return;
+    }
     let formattedContent = content;
     switch (type) {
       case "notification":
@@ -3329,6 +3892,9 @@ var ReverseChannel = class extends import_events.EventEmitter {
       case "result":
         formattedContent = `\u2705 ${content}`;
         break;
+      case "progress":
+        formattedContent = `\u23F3 ${content}`;
+        break;
       default:
         formattedContent = content;
     }
@@ -3344,12 +3910,41 @@ var ReverseChannel = class extends import_events.EventEmitter {
     });
     logger.info(`Message delivered to Feishu chat ${chatId}`);
   }
+  /**
+   * 发送富媒体消息
+   */
+  async deliverMediaMessage(chatId, media, caption) {
+    logger.info(`Delivering media message to ${chatId}: ${media.type}`);
+    await this.feishuClient.sendMessage(chatId, {
+      msg_type: "text",
+      content: {
+        text: `${caption || ""}
+[${media.type}: ${media.filename || "unnamed"}]`
+      }
+    });
+  }
+  // 公共API
   isActive() {
     return this.isRunning;
   }
   getQueueSize() {
     return this.messageQueue.length;
   }
+  getMode() {
+    return this.config.mode;
+  }
+  getWebSocketPort() {
+    return this.config.websocketPort;
+  }
+  getHttpPort() {
+    return this.config.httpPort;
+  }
+  getConnectedClients() {
+    if (this.config.mode === "websocket" && this.wsManager) {
+      return this.wsManager.getClientCount();
+    }
+    return 0;
+  }
 };
 
 // src/skills/builtin/feishu.ts
@@ -3368,14 +3963,17 @@ var FeishuSkills = class {
       return this.accessToken;
     }
     const config = ConfigManager.getInstance().getFeishuConfig();
-    const response = await fetch(`${this.baseUrl}/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 response = await fetch(
+      `${this.baseUrl}/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}`);
@@ -3390,10 +3988,7 @@ var FeishuSkills = class {
       description: "\u53D1\u9001\u6D88\u606F\u5230\u6307\u5B9A\u4F1A\u8BDD",
       trigger: /发送消息|发信息|发消息/,
       riskLevel: "low",
-      examples: [
-        "\u53D1\u9001\u6D88\u606F\u7ED9\u5F20\u4E09\uFF1A\u4E0B\u5348\u5F00\u4F1A",
-        "\u53D1\u4FE1\u606F\u5230\u6D4B\u8BD5\u7FA4\uFF1A\u9879\u76EE\u5DF2\u90E8\u7F72"
-      ],
+      examples: ["\u53D1\u9001\u6D88\u606F\u7ED9\u5F20\u4E09\uFF1A\u4E0B\u5348\u5F00\u4F1A", "\u53D1\u4FE1\u606F\u5230\u6D4B\u8BD5\u7FA4\uFF1A\u9879\u76EE\u5DF2\u90E8\u7F72"],
       execute: async (context) => {
         try {
           const { content } = this.parseMessageArgs(context.message);
@@ -3403,7 +3998,10 @@ var FeishuSkills = class {
           });
           return { success: true, content: "\u2705 \u6D88\u606F\u5DF2\u53D1\u9001" };
         } catch (error) {
-          return { success: false, content: `\u274C \u53D1\u9001\u5931\u8D25: ${error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"}` };
+          return {
+            success: false,
+            content: `\u274C \u53D1\u9001\u5931\u8D25: ${error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"}`
+          };
         }
       }
     };
@@ -3422,46 +4020,57 @@ var FeishuSkills = class {
         try {
           const { title, startTime, endTime, description } = this.parseEventArgs(context.message);
           const token = await this.getAccessToken();
-          const response = await fetch(`${this.baseUrl}/calendar/v4/calendars/primary/events`, {
-            method: "POST",
-            headers: {
-              "Authorization": `Bearer ${token}`,
-              "Content-Type": "application/json"
-            },
-            body: JSON.stringify({
-              summary: title,
-              description,
-              start_time: {
-                timestamp: Math.floor(startTime / 1e3).toString(),
-                timezone: "Asia/Shanghai"
-              },
-              end_time: {
-                timestamp: Math.floor(endTime / 1e3).toString(),
-                timezone: "Asia/Shanghai"
+          const response = await fetch(
+            `${this.baseUrl}/calendar/v4/calendars/primary/events`,
+            {
+              method: "POST",
+              headers: {
+                Authorization: `Bearer ${token}`,
+                "Content-Type": "application/json"
               },
-              attendee_ability: "can_see_others",
-              free_busy_status: "busy"
-            })
-          });
+              body: JSON.stringify({
+                summary: title,
+                description,
+                start_time: {
+                  timestamp: Math.floor(startTime / 1e3).toString(),
+                  timezone: "Asia/Shanghai"
+                },
+                end_time: {
+                  timestamp: Math.floor(endTime / 1e3).toString(),
+                  timezone: "Asia/Shanghai"
+                },
+                attendee_ability: "can_see_others",
+                free_busy_status: "busy"
+              })
+            }
+          );
           const data = await response.json();
           if (data.code !== 0) {
             throw new Error(data.msg || "\u521B\u5EFA\u65E5\u7A0B\u5931\u8D25");
           }
           const eventLink = data.data?.event_link || "";
+          const linkText = eventLink ? `
+
+\u{1F517} ${eventLink}` : "";
           return {
             success: true,
             content: `\u2705 \u65E5\u7A0B\u5DF2\u521B\u5EFA
 
 \u{1F4C5} ${title}
-\u{1F550} ${this.formatDateTime(startTime)} - ${this.formatDateTime(endTime)}
-
-\u{1F517} ${eventLink}`,
-            actions: [
-              { label: "\u67E5\u770B\u65E5\u7A0B", action: "view_calendar", url: eventLink }
-            ]
+\u{1F550} ${this.formatDateTime(startTime)} - ${this.formatDateTime(endTime)}${linkText}`,
+            actions: eventLink ? [
+              {
+                label: "\u67E5\u770B\u65E5\u7A0B",
+                action: "view_calendar",
+                data: { url: eventLink }
+              }
+            ] : []
           };
         } catch (error) {
-          return { success: false, content: `\u274C \u521B\u5EFA\u65E5\u7A0B\u5931\u8D25: ${error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"}` };
+          return {
+            success: false,
+            content: `\u274C \u521B\u5EFA\u65E5\u7A0B\u5931\u8D25: ${error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"}`
+          };
         }
       }
     };
@@ -3472,10 +4081,7 @@ var FeishuSkills = class {
       description: "\u521B\u5EFA\u98DE\u4E66\u4E91\u6587\u6863",
       trigger: /创建文档|新建文档|生成文档/,
       riskLevel: "low",
-      examples: [
-        "\u521B\u5EFA\u6587\u6863\uFF1A\u9879\u76EE\u9700\u6C42\u6587\u6863",
-        "\u65B0\u5EFA\u6587\u6863\uFF1A\u4F1A\u8BAE\u7EAA\u8981"
-      ],
+      examples: ["\u521B\u5EFA\u6587\u6863\uFF1A\u9879\u76EE\u9700\u6C42\u6587\u6863", "\u65B0\u5EFA\u6587\u6863\uFF1A\u4F1A\u8BAE\u7EAA\u8981"],
       execute: async (context) => {
         try {
           const { title } = this.parseDocArgs(context.message);
@@ -3483,7 +4089,7 @@ var FeishuSkills = class {
           const response = await fetch(`${this.baseUrl}/docx/v1/documents`, {
             method: "POST",
             headers: {
-              "Authorization": `Bearer ${token}`,
+              Authorization: `Bearer ${token}`,
               "Content-Type": "application/json"
             },
             body: JSON.stringify({ title })
@@ -3492,22 +4098,30 @@ var FeishuSkills = class {
           if (data.code !== 0) {
             throw new Error(data.msg || "\u521B\u5EFA\u6587\u6863\u5931\u8D25");
           }
-          const documentId = data.data?.document?.document_id;
+          const documentId = data.data?.document?.document_id || "";
           const domain = ConfigManager.getInstance().getFeishuConfig().domain === "lark" ? "larksuite.com" : "feishu.cn";
-          const documentUrl = `https://${domain}/docx/${documentId}`;
+          const documentUrl = documentId ? `https://${domain}/docx/${documentId}` : "";
+          const urlText = documentUrl ? `
+
+\u{1F517} ${documentUrl}` : "";
           return {
             success: true,
             content: `\u2705 \u6587\u6863\u5DF2\u521B\u5EFA
 
-\u{1F4C4} ${title}
-
-\u{1F517} ${documentUrl}`,
-            actions: [
-              { label: "\u6253\u5F00\u6587\u6863", action: "open_doc", url: documentUrl }
-            ]
+\u{1F4C4} ${title}${urlText}`,
+            actions: documentUrl ? [
+              {
+                label: "\u6253\u5F00\u6587\u6863",
+                action: "open_doc",
+                data: { url: documentUrl }
+              }
+            ] : []
           };
         } catch (error) {
-          return { success: false, content: `\u274C \u521B\u5EFA\u6587\u6863\u5931\u8D25: ${error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"}` };
+          return {
+            success: false,
+            content: `\u274C \u521B\u5EFA\u6587\u6863\u5931\u8D25: ${error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"}`
+          };
         }
       }
     };
@@ -3519,7 +4133,10 @@ var FeishuSkills = class {
       trigger: /上传文件|发送文件|传文件/,
       riskLevel: "low",
       execute: async (context) => {
-        return { success: true, content: "\u{1F4CE} \u6587\u4EF6\u4E0A\u4F20\u529F\u80FD\u9700\u8981\u6587\u4EF6\u8DEF\u5F84\uFF0C\u8BF7\u4F7F\u7528\uFF1A\u4E0A\u4F20\u6587\u4EF6 /path/to/file" };
+        return {
+          success: true,
+          content: "\u{1F4CE} \u6587\u4EF6\u4E0A\u4F20\u529F\u80FD\u9700\u8981\u6587\u4EF6\u8DEF\u5F84\uFF0C\u8BF7\u4F7F\u7528\uFF1A\u4E0A\u4F20\u6587\u4EF6 /path/to/file"
+        };
       }
     };
   }
@@ -3532,7 +4149,9 @@ var FeishuSkills = class {
       requireConfirm: true,
       execute: async (context) => {
         try {
-          const { title, content } = this.parseAnnouncementArgs(context.message);
+          const { title, content } = this.parseAnnouncementArgs(
+            context.message
+          );
           await this.client.sendMessage(context.chatId, {
             msg_type: "text",
             content: { text: `\u{1F4E2} **${title}**
@@ -3541,7 +4160,10 @@ ${content}` }
           });
           return { success: true, content: "\u2705 \u516C\u544A\u5DF2\u53D1\u9001" };
         } catch (error) {
-          return { success: false, content: `\u274C \u53D1\u5E03\u516C\u544A\u5931\u8D25: ${error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"}` };
+          return {
+            success: false,
+            content: `\u274C \u53D1\u5E03\u516C\u544A\u5931\u8D25: ${error instanceof Error ? error.message : "\u672A\u77E5\u9519\u8BEF"}`
+          };
         }
       }
     };
@@ -3553,9 +4175,13 @@ ${content}` }
   }
   parseEventArgs(message) {
     const now = /* @__PURE__ */ new Date();
-    const titleMatch = message.match(/日程[：:]\s*(.+?)(?=(明天|今天|后天|时间|地点|$))/i);
+    const titleMatch = message.match(
+      /日程[：:]\s*(.+?)(?=(明天|今天|后天|时间|地点|$))/i
+    );
     const title = titleMatch ? titleMatch[1].trim() : "\u65B0\u65E5\u7A0B";
-    const timeMatch = message.match(/(明天|今天|后天)?\s*(上午|下午|晚上)?\s*(\d{1,2})[:点时]?(\d{0,2})?/);
+    const timeMatch = message.match(
+      /(明天|今天|后天)?\s*(上午|下午|晚上)?\s*(\d{1,2})[:点时]?(\d{0,2})?/
+    );
     let startTime = new Date(now.getTime() + 60 * 60 * 1e3);
     if (timeMatch) {
       const day = timeMatch[1];
@@ -3569,7 +4195,12 @@ ${content}` }
       startTime.setHours(hour, minute, 0, 0);
     }
     const endTime = new Date(startTime.getTime() + 60 * 60 * 1e3);
-    return { title, startTime: startTime.getTime(), endTime: endTime.getTime(), description: "" };
+    return {
+      title,
+      startTime: startTime.getTime(),
+      endTime: endTime.getTime(),
+      description: ""
+    };
   }
   parseDocArgs(message) {
     const match = message.match(/文档[：:]\s*(.+?)(?=(内容|文件夹|$))/i);
@@ -3986,16 +4617,28 @@ function initializeSkills(registry, feishuClient, getAdapter) {
 var import_fastify = __toESM(require("fastify"));
 var FeishuBridge = class {
   constructor() {
+    this.feishuClient = null;
+    this.webhookHandler = null;
     this.wsHandler = null;
+    this.commandExecutor = null;
+    this.sessionManager = null;
     this.healthMonitor = null;
     this.reverseChannel = null;
     this.adapters = /* @__PURE__ */ new Map();
+    this.skillRegistry = null;
     this.server = (0, import_fastify.default)({
       logger: false
       // 使用我们自己的日志系统
     });
+  }
+  /**
+   * 初始化桥接器（在配置加载完成后调用）
+   */
+  initialize() {
     const config = ConfigManager.getInstance().get();
+    logger.info(`Initializing FeishuBridge with appId: ${config.feishu.appId}`);
     this.feishuClient = new FeishuClient(config.feishu);
+    logger.info("FeishuClient created successfully");
     this.sessionManager = new SessionManager(config.behavior.sessionTimeout);
     this.reverseChannel = new ReverseChannel(this.feishuClient);
     this.initAdapters();
@@ -4058,11 +4701,23 @@ var FeishuBridge = class {
     }
   }
   async start() {
+    this.initialize();
     const config = ConfigManager.getInstance().get();
     const serverConfig = config.server;
     if (this.reverseChannel) {
-      this.reverseChannel.start();
-      logger.info("Reverse communication channel started");
+      await this.reverseChannel.start();
+      logger.info(
+        `Reverse communication channel started in ${this.reverseChannel.getMode()} mode`
+      );
+      if (this.reverseChannel.getMode() === "websocket") {
+        logger.info(
+          `WebSocket reverse channel port: ${this.reverseChannel.getWebSocketPort()}`
+        );
+      } else if (this.reverseChannel.getMode() === "http") {
+        logger.info(
+          `HTTP reverse channel port: ${this.reverseChannel.getHttpPort()}`
+        );
+      }
     }
     if (config.feishu.connectionMode !== "websocket") {
       this.healthMonitor = new HealthMonitor(
@@ -4102,7 +4757,7 @@ var FeishuBridge = class {
   }
   async stop() {
     if (this.reverseChannel) {
-      this.reverseChannel.stop();
+      await this.reverseChannel.stop();
       logger.info("Reverse communication channel stopped");
     }
     if (this.wsHandler) {
@@ -4124,7 +4779,9 @@ var FeishuBridge = class {
 init_config();
 init_logger();
 var program = new import_commander.Command();
-var pkg = JSON.parse(fs10.readFileSync(path10.join(__dirname, "../../package.json"), "utf-8"));
+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 {
@@ -4133,22 +4790,33 @@ program.command("start").description("Start the Feishu Bridge server").option("-
     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.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.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(
+        "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");
+      console.error(
+        "  2. Config file: feishu-bridge config set feishu.appId xxx"
+      );
       process.exit(1);
     }
     configManager.load(config);
@@ -4268,38 +4936,61 @@ program.command("status").description("Show service status").action(async () =>
     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"}`);
+    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
+  const hookPath = path10.join(__dirname, "../../scripts/hook.sh");
+  if (fs10.existsSync(hookPath)) {
+    console.log(fs10.readFileSync(hookPath, "utf-8"));
+  } else {
+    console.log(`# Feishu Bridge Shell Hook
+# Auto-starts Feishu Bridge when IDE/CLI is detected
+# Add this to ~/.bashrc or ~/.zshrc
 
-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-auto-start() {
+  local ide=""
+  
+  # \u68C0\u6D4BIDE\u73AF\u5883
+  if [[ -n "$OPENCODE_SESSION" ]]; then
+    ide="opencode"
+  elif [[ -n "$CLAUDE_CODE_SESSION" ]]; then
+    ide="claude-code"
+  elif [[ -n "$VSCODE_PID" ]]; then
+    ide="vscode"
+  elif [[ -n "$CURSOR_PID" ]]; then
+    ide="cursor"
+  elif [[ -n "$TRAE_PID" ]]; then
+    ide="trae"
+  fi
+  
+  # \u5982\u679C\u68C0\u6D4B\u5230IDE\uFF0C\u542F\u52A8\u670D\u52A1
+  if [[ -n "$ide" ]]; then
+    if ! pgrep -f "feishu-bridge" > /dev/null 2>&1; then
       feishu-bridge start --daemon 2>/dev/null &
+      echo "Feishu Bridge started for $ide"
     fi
   fi
 }
 
-# Bash
-if [ -n "$BASH_VERSION" ]; then
-  PROMPT_COMMAND="feishu-bridge-auto; $PROMPT_COMMAND"
+# Bash: Run before each prompt
+if [[ -n "$BASH_VERSION" ]]; then
+  PROMPT_COMMAND="feishu-bridge-auto-start; $PROMPT_COMMAND"
 fi
 
-# Zsh
-if [ -n "$ZSH_VERSION" ]; then
-  precmd_functions+=(feishu-bridge-auto)
+# Zsh: Run before each prompt
+if [[ -n "$ZSH_VERSION" ]]; then
+  precmd_functions+=(feishu-bridge-auto-start)
 fi
 `);
+  }
 });
 program.parse();
 if (!process.argv.slice(2).length) {