@hangox/mg-cli 1.0.7 → 1.0.9

package/dist/index.js

@@ -26,6 +26,7 @@ var MAX_RETRY_COUNT = 3;
 var ConnectionType = /* @__PURE__ */ ((ConnectionType2) => {
   ConnectionType2["CONSUMER"] = "consumer";
   ConnectionType2["PROVIDER"] = "provider";
+  ConnectionType2["CHROME_EXTENSION"] = "chrome_extension";
   return ConnectionType2;
 })(ConnectionType || {});
 var MessageType = /* @__PURE__ */ ((MessageType2) => {
@@ -40,6 +41,9 @@ var MessageType = /* @__PURE__ */ ((MessageType2) => {
   MessageType2["EXPORT_IMAGE"] = "export_image";
   MessageType2["EXECUTE_CODE"] = "execute_code";
   MessageType2["GET_ALL_PAGES"] = "get_all_pages";
+  MessageType2["LIST_EXTENSIONS"] = "list_extensions";
+  MessageType2["OPEN_PAGE"] = "open_page";
+  MessageType2["NAVIGATE_TO_NODE"] = "navigate_to_node";
   MessageType2["GET_SERVER_STATUS"] = "get_server_status";
   MessageType2["RESPONSE"] = "response";
   MessageType2["ERROR"] = "error";
@@ -65,6 +69,7 @@ var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
   ErrorCode2["SERVER_START_FAILED"] = "E015";
   ErrorCode2["SERVER_ALREADY_RUNNING"] = "E016";
   ErrorCode2["CONNECTION_LOST"] = "E017";
+  ErrorCode2["NO_EXTENSION_CONNECTED"] = "E018";
   ErrorCode2["UNKNOWN_ERROR"] = "E099";
   return ErrorCode2;
 })(ErrorCode || {});
@@ -86,6 +91,7 @@ var ErrorNames = {
   ["E015" /* SERVER_START_FAILED */]: "SERVER_START_FAILED",
   ["E016" /* SERVER_ALREADY_RUNNING */]: "SERVER_ALREADY_RUNNING",
   ["E017" /* CONNECTION_LOST */]: "CONNECTION_LOST",
+  ["E018" /* NO_EXTENSION_CONNECTED */]: "NO_EXTENSION_CONNECTED",
   ["E099" /* UNKNOWN_ERROR */]: "UNKNOWN_ERROR"
 };
 var ErrorMessages = {
@@ -106,6 +112,7 @@ var ErrorMessages = {
   ["E015" /* SERVER_START_FAILED */]: "\u81EA\u52A8\u542F\u52A8 Server \u5931\u8D25",
   ["E016" /* SERVER_ALREADY_RUNNING */]: "Server \u5DF2\u5728\u8FD0\u884C\u4E2D",
   ["E017" /* CONNECTION_LOST */]: "\u8FDE\u63A5\u65AD\u5F00",
+  ["E018" /* NO_EXTENSION_CONNECTED */]: "\u6CA1\u6709 Chrome \u6269\u5C55\u8FDE\u63A5\u5230 Server\u3002\u8BF7\u786E\u4FDD\u6D4F\u89C8\u5668\u5DF2\u6253\u5F00\u5E76\u5B89\u88C5\u4E86 MG Plugin",
   ["E099" /* UNKNOWN_ERROR */]: "\u672A\u77E5\u9519\u8BEF"
 };
 var MGError = class extends Error {
@@ -489,6 +496,12 @@ function extractSpaceInfo(node) {
     width: roundToOneDecimal(typeof node.width === "number" ? node.width : 0),
     height: roundToOneDecimal(typeof node.height === "number" ? node.height : 0)
   };
+  if (typeof node.absoluteX === "number") {
+    result.absoluteX = roundToOneDecimal(node.absoluteX);
+  }
+  if (typeof node.absoluteY === "number") {
+    result.absoluteY = roundToOneDecimal(node.absoluteY);
+  }
   if (node.children && Array.isArray(node.children) && node.children.length > 0) {
     result.children = node.children.map((child) => extractSpaceInfo(child));
   }
@@ -584,6 +597,12 @@ var ConnectionManager = class {
   providers = /* @__PURE__ */ new Map();
   /** Consumer 连接 */
   consumers = /* @__PURE__ */ new Map();
+  /** Chrome 扩展连接（按扩展 ID 索引） */
+  chromeExtensions = /* @__PURE__ */ new Map();
+  /** 扩展序号映射（扩展 ID → 序号） */
+  extensionIndexMap = /* @__PURE__ */ new Map();
+  /** 下一个可用的扩展序号 */
+  nextExtensionIndex = 1;
   /** 所有连接（按 ID 索引） */
   allConnections = /* @__PURE__ */ new Map();
   /** 心跳检查定时器 */
@@ -678,6 +697,16 @@ var ConnectionManager = class {
     } else if (connectionInfo.type === "consumer" /* CONSUMER */) {
       this.consumers.delete(connectionId);
       this.logger.info(`Consumer \u65AD\u5F00: ${connectionId}`);
+    } else if (connectionInfo.type === "chrome_extension" /* CHROME_EXTENSION */) {
+      for (const [extensionId, extWs] of this.chromeExtensions) {
+        if (extWs.connectionId === connectionId) {
+          const index = this.extensionIndexMap.get(extensionId);
+          this.chromeExtensions.delete(extensionId);
+          this.extensionIndexMap.delete(extensionId);
+          this.logger.info(`Chrome \u6269\u5C55\u65AD\u5F00: ${extensionId} (\u5E8F\u53F7: #${index})`);
+          break;
+        }
+      }
     }
   }
   /**
@@ -731,6 +760,7 @@ var ConnectionManager = class {
     return {
       providers: providerCount,
       consumers: this.consumers.size,
+      extensions: this.chromeExtensions.size,
       total: this.allConnections.size
     };
   }
@@ -740,6 +770,48 @@ var ConnectionManager = class {
   getConnectedPageUrls() {
     return Array.from(this.providers.keys());
   }
+  /**
+   * 添加 Chrome 扩展连接
+   */
+  addChromeExtension(ws, extensionId) {
+    const managedWs = this.addConnection(ws, "chrome_extension" /* CHROME_EXTENSION */);
+    const index = this.nextExtensionIndex++;
+    this.extensionIndexMap.set(extensionId, index);
+    this.chromeExtensions.set(extensionId, managedWs);
+    this.logger.info(`Chrome \u6269\u5C55\u8FDE\u63A5: ${extensionId} (\u5206\u914D\u5E8F\u53F7: #${index})`);
+    return managedWs;
+  }
+  /**
+   * 根据序号查找扩展
+   */
+  findExtensionByIndex(index) {
+    for (const [extensionId, extIndex] of this.extensionIndexMap) {
+      if (extIndex === index) {
+        return this.chromeExtensions.get(extensionId);
+      }
+    }
+    return void 0;
+  }
+  /**
+   * 获取第一个扩展
+   */
+  getFirstExtension() {
+    return this.chromeExtensions.values().next().value;
+  }
+  /**
+   * 获取所有扩展信息
+   */
+  getAllExtensions() {
+    const result = [];
+    for (const [extensionId, ws] of this.chromeExtensions) {
+      const index = this.extensionIndexMap.get(extensionId);
+      if (index !== void 0) {
+        result.push({ index, extensionId, ws });
+      }
+    }
+    result.sort((a, b) => a.index - b.index);
+    return result;
+  }
   /**
    * 关闭所有连接
    */
@@ -751,6 +823,8 @@ var ConnectionManager = class {
     }
     this.providers.clear();
     this.consumers.clear();
+    this.chromeExtensions.clear();
+    this.extensionIndexMap.clear();
     this.allConnections.clear();
   }
 };
@@ -868,6 +942,24 @@ var RequestHandler = class {
       this.logger.error(`\u53D1\u9001\u9519\u8BEF\u54CD\u5E94\u5931\u8D25: ${requestId}`, err);
     }
   }
+  /**
+   * 注册待处理请求（供外部使用，如 OPEN_PAGE）
+   * @param requestId 请求 ID
+   * @param consumer 发起请求的 Consumer
+   * @param sendCallback 发送请求的回调函数
+   */
+  registerPendingRequest(requestId, consumer, sendCallback) {
+    const timer = setTimeout(() => {
+      this.handleTimeout(requestId);
+    }, REQUEST_TIMEOUT);
+    this.pendingRequests.set(requestId, {
+      id: requestId,
+      consumer,
+      timer,
+      timestamp: Date.now()
+    });
+    sendCallback();
+  }
   /**
    * 清理特定连接的所有待处理请求
    */
@@ -922,6 +1014,13 @@ function getVersion() {
     return cachedVersion;
   }
 }
+var DEV_VERSION = "9.9.9";
+function isVersionMatch(version1, version2) {
+  if (version1 === DEV_VERSION || version2 === DEV_VERSION) {
+    return true;
+  }
+  return version1 === version2;
+}
 
 // src/server/websocket-server.ts
 var MGServer = class {
@@ -1040,12 +1139,22 @@ var MGServer = class {
    */
   handleRegister(ws, message) {
     const { connectionType, pageUrl, pageId } = message.data;
-    const managedWs = this.connectionManager.addConnection(
-      ws,
-      connectionType,
-      pageUrl,
-      pageId
-    );
+    const extensionId = message.data.extensionId;
+    let managedWs;
+    let extensionIndex;
+    if (connectionType === "chrome_extension" /* CHROME_EXTENSION */ && extensionId) {
+      managedWs = this.connectionManager.addChromeExtension(ws, extensionId);
+      const exts = this.connectionManager.getAllExtensions();
+      const ext = exts.find((e) => e.extensionId === extensionId);
+      extensionIndex = ext?.index;
+    } else {
+      managedWs = this.connectionManager.addConnection(
+        ws,
+        connectionType,
+        pageUrl,
+        pageId
+      );
+    }
     const ack = {
       id: message.id || "",
       type: "register_ack" /* REGISTER_ACK */,
@@ -1053,7 +1162,8 @@ var MGServer = class {
       data: {
         connectionId: managedWs.connectionId,
         pageUrl,
-        serverVersion: getVersion()
+        serverVersion: getVersion(),
+        ...extensionIndex !== void 0 && { extensionIndex }
       }
     };
     ws.send(JSON.stringify(ack));
@@ -1070,6 +1180,15 @@ var MGServer = class {
       case "get_server_status" /* GET_SERVER_STATUS */:
         this.handleGetServerStatus(ws, message);
         break;
+      case "list_extensions" /* LIST_EXTENSIONS */:
+        this.handleListExtensions(ws, message);
+        break;
+      case "open_page" /* OPEN_PAGE */:
+        this.handleOpenPage(ws, message);
+        break;
+      case "navigate_to_node" /* NAVIGATE_TO_NODE */:
+        this.handleNavigateToNode(ws, message);
+        break;
       case "response" /* RESPONSE */:
       case "error" /* ERROR */:
         this.requestHandler.handleResponse(message);
@@ -1102,6 +1221,13 @@ var MGServer = class {
       connectedAt: info.connectedAt.toISOString(),
       lastActiveAt: info.lastActiveAt.toISOString()
     }));
+    const extensions = this.connectionManager.getAllExtensions();
+    const connectedExtensions = extensions.map((ext) => ({
+      index: ext.index,
+      extensionId: ext.extensionId,
+      connectedAt: ext.ws.connectionInfo.connectedAt.toISOString(),
+      lastActiveAt: ext.ws.connectionInfo.lastActiveAt.toISOString()
+    }));
     const uptimeMs = this.startedAt ? Date.now() - this.startedAt.getTime() : 0;
     const statusData = {
       running: this.isRunning,
@@ -1111,7 +1237,8 @@ var MGServer = class {
       uptime: formatDuration(uptimeMs),
       version: getVersion(),
       stats,
-      connectedPages
+      connectedPages,
+      connectedExtensions
     };
     const response = {
       id: message.id || "",
@@ -1122,6 +1249,156 @@ var MGServer = class {
     ws.send(JSON.stringify(response));
     this.logger.info("\u8FD4\u56DE Server \u72B6\u6001\u4FE1\u606F");
   }
+  /**
+   * 处理扩展列表查询
+   */
+  handleListExtensions(ws, message) {
+    const extensions = this.connectionManager.getAllExtensions();
+    const extensionList = extensions.map((ext) => ({
+      index: ext.index,
+      extensionId: ext.extensionId,
+      connectedAt: ext.ws.connectionInfo.connectedAt.toISOString(),
+      lastActiveAt: ext.ws.connectionInfo.lastActiveAt.toISOString()
+    }));
+    const response = {
+      id: message.id || "",
+      type: "response" /* RESPONSE */,
+      success: true,
+      data: {
+        extensions: extensionList,
+        totalCount: extensionList.length
+      }
+    };
+    ws.send(JSON.stringify(response));
+    this.logger.info(`\u8FD4\u56DE\u6269\u5C55\u5217\u8868\uFF0C\u5171 ${extensionList.length} \u4E2A\u6269\u5C55`);
+  }
+  /**
+   * 处理打开页面请求
+   */
+  handleOpenPage(ws, message) {
+    const params = message.params;
+    const requestId = message.id || "";
+    if (!params?.url) {
+      const errorResponse = {
+        id: requestId,
+        type: "error" /* ERROR */,
+        success: false,
+        error: {
+          code: "E011" /* INVALID_PARAMS */,
+          name: "INVALID_PARAMS",
+          message: "\u7F3A\u5C11 url \u53C2\u6570"
+        }
+      };
+      ws.send(JSON.stringify(errorResponse));
+      return;
+    }
+    const targetIndex = params.extensionIndex || 1;
+    const targetExtension = this.connectionManager.findExtensionByIndex(targetIndex);
+    if (!targetExtension) {
+      const errorResponse = {
+        id: requestId,
+        type: "error" /* ERROR */,
+        success: false,
+        error: {
+          code: "E018" /* NO_EXTENSION_CONNECTED */,
+          name: "NO_EXTENSION_CONNECTED",
+          message: targetIndex === 1 ? "\u6CA1\u6709 Chrome \u6269\u5C55\u8FDE\u63A5\u5230 Server\u3002\u8BF7\u786E\u4FDD\u6D4F\u89C8\u5668\u5DF2\u6253\u5F00\u5E76\u5B89\u88C5\u4E86 MG Plugin" : `\u672A\u627E\u5230\u5E8F\u53F7\u4E3A #${targetIndex} \u7684\u6269\u5C55\u5B9E\u4F8B`
+        }
+      };
+      ws.send(JSON.stringify(errorResponse));
+      this.logger.warn(`\u672A\u627E\u5230\u6269\u5C55\u5B9E\u4F8B #${targetIndex}`);
+      return;
+    }
+    const forwardMessage = {
+      id: requestId,
+      type: "open_page" /* OPEN_PAGE */,
+      params: { url: params.url }
+    };
+    this.requestHandler.registerPendingRequest(requestId, ws, () => {
+      try {
+        targetExtension.send(JSON.stringify(forwardMessage));
+        this.logger.info(`\u8F6C\u53D1 OPEN_PAGE \u8BF7\u6C42\u5230\u6269\u5C55 #${targetIndex}: ${params.url}`);
+      } catch (error) {
+        this.logger.error(`\u8F6C\u53D1\u8BF7\u6C42\u5931\u8D25: ${error}`);
+        const errorResponse = {
+          id: requestId,
+          type: "error" /* ERROR */,
+          success: false,
+          error: {
+            code: "E001" /* CONNECTION_FAILED */,
+            name: "CONNECTION_FAILED",
+            message: "\u8F6C\u53D1\u8BF7\u6C42\u5931\u8D25"
+          }
+        };
+        ws.send(JSON.stringify(errorResponse));
+      }
+    });
+  }
+  /**
+   * 处理节点导航请求
+   */
+  handleNavigateToNode(ws, message) {
+    const params = message.params;
+    const requestId = message.id || "";
+    if (!params?.pageUrl || !params?.nodeId) {
+      const errorResponse = {
+        id: requestId,
+        type: "error" /* ERROR */,
+        success: false,
+        error: {
+          code: "E011" /* INVALID_PARAMS */,
+          name: "INVALID_PARAMS",
+          message: "\u7F3A\u5C11 pageUrl \u6216 nodeId \u53C2\u6570"
+        }
+      };
+      ws.send(JSON.stringify(errorResponse));
+      return;
+    }
+    const targetIndex = params.extensionIndex || 1;
+    const targetExtension = this.connectionManager.findExtensionByIndex(targetIndex);
+    if (!targetExtension) {
+      const errorResponse = {
+        id: requestId,
+        type: "error" /* ERROR */,
+        success: false,
+        error: {
+          code: "E018" /* NO_EXTENSION_CONNECTED */,
+          name: "NO_EXTENSION_CONNECTED",
+          message: targetIndex === 1 ? "\u6CA1\u6709 Chrome \u6269\u5C55\u8FDE\u63A5\u5230 Server\u3002\u8BF7\u786E\u4FDD\u6D4F\u89C8\u5668\u5DF2\u6253\u5F00\u5E76\u5B89\u88C5\u4E86 MG Plugin" : `\u672A\u627E\u5230\u5E8F\u53F7\u4E3A #${targetIndex} \u7684\u6269\u5C55\u5B9E\u4F8B`
+        }
+      };
+      ws.send(JSON.stringify(errorResponse));
+      this.logger.warn(`\u672A\u627E\u5230\u6269\u5C55\u5B9E\u4F8B #${targetIndex}`);
+      return;
+    }
+    const forwardMessage = {
+      id: requestId,
+      type: "navigate_to_node" /* NAVIGATE_TO_NODE */,
+      params: {
+        pageUrl: params.pageUrl,
+        nodeId: params.nodeId
+      }
+    };
+    this.requestHandler.registerPendingRequest(requestId, ws, () => {
+      try {
+        targetExtension.send(JSON.stringify(forwardMessage));
+        this.logger.info(`\u8F6C\u53D1 NAVIGATE_TO_NODE \u8BF7\u6C42\u5230\u6269\u5C55 #${targetIndex}: ${params.pageUrl} -> ${params.nodeId}`);
+      } catch (error) {
+        this.logger.error(`\u8F6C\u53D1\u8BF7\u6C42\u5931\u8D25: ${error}`);
+        const errorResponse = {
+          id: requestId,
+          type: "error" /* ERROR */,
+          success: false,
+          error: {
+            code: "E001" /* CONNECTION_FAILED */,
+            name: "CONNECTION_FAILED",
+            message: "\u8F6C\u53D1\u8BF7\u6C42\u5931\u8D25"
+          }
+        };
+        ws.send(JSON.stringify(errorResponse));
+      }
+    });
+  }
   /**
    * 停止服务器
    */
@@ -1168,6 +1445,247 @@ var MGServer = class {
 function createServer(options) {
   return new MGServer(options);
 }
+
+// src/cli/client.ts
+import WebSocket2 from "ws";
+
+// src/server/daemon.ts
+import { spawn } from "child_process";
+import { fileURLToPath as fileURLToPath2 } from "url";
+import { dirname as dirname4, join as join3 } from "path";
+function isServerRunning() {
+  const info = readServerInfo();
+  if (!info) {
+    return { running: false, info: null };
+  }
+  if (!isProcessRunning(info.pid)) {
+    deleteServerInfo();
+    return { running: false, info: null };
+  }
+  return { running: true, info };
+}
+async function startServerDaemon(port) {
+  const { running, info } = isServerRunning();
+  if (running && info) {
+    throw new MGError(
+      "E016" /* SERVER_ALREADY_RUNNING */,
+      `Server \u5DF2\u5728\u8FD0\u884C\u4E2D (PID: ${info.pid}, \u7AEF\u53E3: ${info.port})`
+    );
+  }
+  ensureConfigDir();
+  const currentFile = fileURLToPath2(import.meta.url);
+  const currentDir = dirname4(currentFile);
+  const serverScript = join3(currentDir, "daemon-runner.js");
+  const args = ["--foreground"];
+  if (port) {
+    args.push("--port", String(port));
+  }
+  const child = spawn(process.execPath, [serverScript, ...args], {
+    detached: true,
+    stdio: "ignore",
+    env: {
+      ...process.env,
+      MG_DAEMON: "1"
+    }
+  });
+  child.unref();
+  const startTime = Date.now();
+  while (Date.now() - startTime < SERVER_START_TIMEOUT) {
+    await new Promise((resolve2) => setTimeout(resolve2, 200));
+    const { running: running2, info: info2 } = isServerRunning();
+    if (running2 && info2) {
+      return info2;
+    }
+  }
+  throw new MGError("E015" /* SERVER_START_FAILED */, "Server \u542F\u52A8\u8D85\u65F6");
+}
+
+// src/cli/client.ts
+var MGClient = class {
+  ws = null;
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  /**
+   * 连接到 Server
+   */
+  async connect() {
+    const serverInfo = readServerInfo();
+    if (serverInfo) {
+      if (isProcessRunning(serverInfo.pid)) {
+        const currentVersion = getVersion();
+        if (!isVersionMatch(currentVersion, serverInfo.version)) {
+          console.warn(`\u26A0\uFE0F \u7248\u672C\u4E0D\u5339\u914D: CLI ${currentVersion} vs Server ${serverInfo.version}`);
+          console.warn("\u63D0\u793A: \u5982\u9700\u5BF9\u9F50\u7248\u672C\uFF0C\u8BF7\u624B\u52A8\u8FD0\u884C `npx -y @hangox/mg-cli@latest server restart`");
+        }
+        try {
+          await this.tryConnect(serverInfo.port);
+          return;
+        } catch {
+        }
+      }
+    }
+    for (let port = PORT_RANGE_START; port <= PORT_RANGE_END; port++) {
+      try {
+        await this.tryConnect(port);
+        return;
+      } catch {
+      }
+    }
+    if (!this.options.noAutoStart) {
+      console.log("Server \u672A\u8FD0\u884C\uFF0C\u6B63\u5728\u81EA\u52A8\u542F\u52A8...");
+      try {
+        const info = await startServerDaemon();
+        console.log(`Server \u5DF2\u542F\u52A8\uFF0C\u7AEF\u53E3: ${info.port}`);
+        await this.waitForServer(info.port);
+        return;
+      } catch (error) {
+        throw new MGError(
+          "E015" /* SERVER_START_FAILED */,
+          `\u81EA\u52A8\u542F\u52A8 Server \u5931\u8D25: ${error instanceof Error ? error.message : error}`
+        );
+      }
+    }
+    throw new MGError("E001" /* CONNECTION_FAILED */, ErrorMessages["E001" /* CONNECTION_FAILED */]);
+  }
+  /**
+   * 尝试连接指定端口
+   */
+  tryConnect(port) {
+    return new Promise((resolve2, reject) => {
+      const ws = new WebSocket2(`ws://localhost:${port}`);
+      const timer = setTimeout(() => {
+        ws.close();
+        reject(new Error("\u8FDE\u63A5\u8D85\u65F6"));
+      }, PORT_SCAN_TIMEOUT);
+      ws.on("open", () => {
+        clearTimeout(timer);
+        this.ws = ws;
+        this.register();
+        resolve2();
+      });
+      ws.on("error", (error) => {
+        clearTimeout(timer);
+        reject(error);
+      });
+    });
+  }
+  /**
+   * 等待 Server 就绪
+   */
+  async waitForServer(port) {
+    const startTime = Date.now();
+    const interval = 500;
+    while (Date.now() - startTime < SERVER_START_TIMEOUT) {
+      try {
+        await this.tryConnect(port);
+        return;
+      } catch {
+        await new Promise((r) => setTimeout(r, interval));
+      }
+    }
+    throw new Error("\u7B49\u5F85 Server \u542F\u52A8\u8D85\u65F6");
+  }
+  /**
+   * 注册为 Consumer
+   */
+  register() {
+    if (!this.ws) return;
+    const message = {
+      type: "register" /* REGISTER */,
+      data: {
+        connectionType: "consumer" /* CONSUMER */
+      },
+      timestamp: Date.now()
+    };
+    this.ws.send(JSON.stringify(message));
+  }
+  /**
+   * 发送请求并等待响应
+   */
+  async request(type, params, pageUrl) {
+    if (!this.ws) {
+      throw new MGError("E001" /* CONNECTION_FAILED */, "\u672A\u8FDE\u63A5\u5230 Server");
+    }
+    const requestId = generateId();
+    const message = {
+      id: requestId,
+      type,
+      params,
+      pageUrl,
+      timestamp: Date.now()
+    };
+    return new Promise((resolve2, reject) => {
+      const timer = setTimeout(() => {
+        reject(new MGError("E012" /* REQUEST_TIMEOUT */, ErrorMessages["E012" /* REQUEST_TIMEOUT */]));
+      }, REQUEST_TIMEOUT);
+      const messageHandler = (data) => {
+        try {
+          const response = JSON.parse(data.toString());
+          if (response.id === requestId) {
+            clearTimeout(timer);
+            this.ws?.off("message", messageHandler);
+            if (response.success) {
+              resolve2(response.data);
+            } else {
+              const error = response.error;
+              reject(
+                new MGError(
+                  error?.code || "E099" /* UNKNOWN_ERROR */,
+                  error?.message || "\u672A\u77E5\u9519\u8BEF"
+                )
+              );
+            }
+          }
+        } catch {
+        }
+      };
+      this.ws.on("message", messageHandler);
+      this.ws.send(JSON.stringify(message));
+    });
+  }
+  /**
+   * 带重试的请求
+   */
+  async requestWithRetry(type, params, pageUrl) {
+    if (this.options.noRetry) {
+      return this.request(type, params, pageUrl);
+    }
+    let lastError = null;
+    for (let attempt = 0; attempt <= MAX_RETRY_COUNT; attempt++) {
+      try {
+        return await this.request(type, params, pageUrl);
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (error instanceof MGError) {
+          const retryable = ["E017" /* CONNECTION_LOST */, "E012" /* REQUEST_TIMEOUT */];
+          if (!retryable.includes(error.code)) {
+            throw error;
+          }
+        }
+        if (attempt < MAX_RETRY_COUNT) {
+          const delay = RETRY_INTERVALS[attempt] || RETRY_INTERVALS[RETRY_INTERVALS.length - 1];
+          await new Promise((r) => setTimeout(r, delay));
+          try {
+            await this.connect();
+          } catch {
+          }
+        }
+      }
+    }
+    throw lastError || new MGError("E099" /* UNKNOWN_ERROR */, "\u8BF7\u6C42\u5931\u8D25");
+  }
+  /**
+   * 关闭连接
+   */
+  close() {
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+  }
+};
 export {
   CONFIG_DIR,
   ConnectionManager,
@@ -1187,6 +1705,7 @@ export {
   Logger,
   MAX_PORT_ATTEMPTS,
   MAX_RETRY_COUNT,
+  MGClient,
   MGError,
   MGServer,
   MessageType,