@hangox/mg-cli 1.0.6 → 1.0.8

package/dist/index.js

@@ -34,6 +34,7 @@ var MessageType = /* @__PURE__ */ ((MessageType2) => {
   MessageType2["REGISTER"] = "register";
   MessageType2["REGISTER_ACK"] = "register_ack";
   MessageType2["GET_NODE_BY_ID"] = "get_node_by_id";
+  MessageType2["GET_PAGE_BY_ID"] = "get_page_by_id";
   MessageType2["GET_ALL_NODES"] = "get_all_nodes";
   MessageType2["GET_SELECTION"] = "get_selection";
   MessageType2["EXPORT_IMAGE"] = "export_image";
@@ -225,27 +226,44 @@ function parseMgpLink(link) {
     const queryString = urlPart.slice(questionMarkIndex + 1);
     const params = new URLSearchParams(queryString);
     const encodedNodeId = params.get("nodeId");
-    if (!encodedNodeId) {
+    const encodedPageId = params.get("pageId");
+    if (!encodedNodeId && !encodedPageId) {
       return null;
     }
-    const nodeId = decodeURIComponent(encodedNodeId);
-    if (!/^(\d+:\d+)(\/\d+:\d+)*$/.test(nodeId)) {
+    if (encodedNodeId && encodedPageId) {
       return null;
     }
-    const encodedNodePath = params.get("nodePath");
-    let nodePath;
-    if (encodedNodePath) {
-      const decodedNodePath = decodeURIComponent(encodedNodePath);
-      nodePath = decodedNodePath.split("/").filter(Boolean);
-      if (!nodePath.every((segment) => /^\d+:\d+$/.test(segment))) {
+    if (encodedNodeId) {
+      const nodeId = decodeURIComponent(encodedNodeId);
+      if (!/^(\d+:\d+)(\/\d+:\d+)*$/.test(nodeId)) {
         return null;
       }
+      const encodedNodePath = params.get("nodePath");
+      let nodePath;
+      if (encodedNodePath) {
+        const decodedNodePath = decodeURIComponent(encodedNodePath);
+        nodePath = decodedNodePath.split("/").filter(Boolean);
+        if (!nodePath.every((segment) => /^\d+:\d+$/.test(segment))) {
+          return null;
+        }
+      }
+      return {
+        pageUrl,
+        nodeId,
+        nodePath
+      };
     }
-    return {
-      pageUrl,
-      nodeId,
-      nodePath
-    };
+    if (encodedPageId) {
+      const pageId = decodeURIComponent(encodedPageId);
+      if (!/^\d+:\d+$/.test(pageId)) {
+        return null;
+      }
+      return {
+        pageUrl,
+        pageId
+      };
+    }
+    return null;
   } catch {
     return null;
   }
@@ -260,6 +278,11 @@ function generateMgpLink(pageUrl, nodeId, nodePath) {
   }
   return link;
 }
+function generatePageLink(pageUrl, pageId) {
+  const normalizedUrl = normalizePageUrl(pageUrl);
+  const encodedPageId = encodeURIComponent(pageId);
+  return `mgp://${normalizedUrl}?pageId=${encodedPageId}`;
+}
 function formatFileSize(bytes) {
   if (bytes < 1024) {
     return `${bytes} \u5B57\u8282`;
@@ -557,7 +580,7 @@ function createLogger(options) {
 // src/server/connection-manager.ts
 var ConnectionManager = class {
   logger;
-  /** Provider 连接（按页面 URL 索引） */
+  /** Provider 连接（按页面 URL 索引，支持同 URL 多个连接） */
   providers = /* @__PURE__ */ new Map();
   /** Consumer 连接 */
   consumers = /* @__PURE__ */ new Map();
@@ -593,7 +616,8 @@ var ConnectionManager = class {
    */
   checkHeartbeats() {
     const now = Date.now();
-    for (const [id, ws] of this.allConnections) {
+    const entries = Array.from(this.allConnections.entries());
+    for (const [id, ws] of entries) {
       const lastActive = ws.connectionInfo.lastActiveAt.getTime();
       const elapsed = now - lastActive;
       if (elapsed > HEARTBEAT_TIMEOUT) {
@@ -623,14 +647,10 @@ var ConnectionManager = class {
     managedWs.isAlive = true;
     this.allConnections.set(connectionId, managedWs);
     if (type === "provider" /* PROVIDER */ && pageUrl) {
-      const existing = this.providers.get(pageUrl);
-      if (existing) {
-        this.logger.info(`\u9875\u9762 ${pageUrl} \u5DF2\u6709\u8FDE\u63A5\uFF0C\u66FF\u6362\u4E3A\u65B0\u8FDE\u63A5`);
-        this.removeConnection(existing);
-        existing.close();
-      }
-      this.providers.set(pageUrl, managedWs);
-      this.logger.info(`Provider \u8FDE\u63A5: ${pageUrl}`);
+      const existing = this.providers.get(pageUrl) || [];
+      existing.push(managedWs);
+      this.providers.set(pageUrl, existing);
+      this.logger.info(`Provider \u8FDE\u63A5: ${pageUrl} (\u5F53\u524D\u8BE5\u9875\u9762\u8FDE\u63A5\u6570: ${existing.length})`);
     } else if (type === "consumer" /* CONSUMER */) {
       this.consumers.set(connectionId, managedWs);
       this.logger.info(`Consumer \u8FDE\u63A5: ${connectionId}`);
@@ -644,8 +664,17 @@ var ConnectionManager = class {
     const { connectionId, connectionInfo } = ws;
     this.allConnections.delete(connectionId);
     if (connectionInfo.type === "provider" /* PROVIDER */ && connectionInfo.pageUrl) {
-      this.providers.delete(connectionInfo.pageUrl);
-      this.logger.info(`Provider \u65AD\u5F00: ${connectionInfo.pageUrl}`);
+      const connections = this.providers.get(connectionInfo.pageUrl);
+      if (connections) {
+        const index = connections.findIndex((c) => c.connectionId === connectionId);
+        if (index !== -1) {
+          connections.splice(index, 1);
+          if (connections.length === 0) {
+            this.providers.delete(connectionInfo.pageUrl);
+          }
+        }
+      }
+      this.logger.info(`Provider \u65AD\u5F00: ${connectionInfo.pageUrl} (\u8FDE\u63A5ID: ${connectionId})`);
     } else if (connectionInfo.type === "consumer" /* CONSUMER */) {
       this.consumers.delete(connectionId);
       this.logger.info(`Consumer \u65AD\u5F00: ${connectionId}`);
@@ -659,31 +688,48 @@ var ConnectionManager = class {
     ws.isAlive = true;
   }
   /**
-   * 根据页面 URL 查找 Provider
+   * 根据页面 URL 查找 Provider（返回第一个可用的连接）
    */
   findProviderByPageUrl(pageUrl) {
-    return this.providers.get(pageUrl);
+    const connections = this.providers.get(pageUrl);
+    return connections?.[0];
   }
   /**
    * 获取第一个可用的 Provider
    */
   getFirstProvider() {
-    const iterator = this.providers.values();
-    const first = iterator.next();
-    return first.value;
+    const allConnections = Array.from(this.providers.values());
+    for (const connections of allConnections) {
+      if (connections.length > 0) {
+        return connections[0];
+      }
+    }
+    return void 0;
   }
   /**
    * 获取所有 Provider 信息
    */
   getAllProviders() {
-    return Array.from(this.providers.values()).map((ws) => ws.connectionInfo);
+    const result = [];
+    const allConnections = Array.from(this.providers.values());
+    for (const connections of allConnections) {
+      for (const ws of connections) {
+        result.push(ws.connectionInfo);
+      }
+    }
+    return result;
   }
   /**
    * 获取连接统计
    */
   getStats() {
+    let providerCount = 0;
+    const allConnections = Array.from(this.providers.values());
+    for (const connections of allConnections) {
+      providerCount += connections.length;
+    }
     return {
-      providers: this.providers.size,
+      providers: providerCount,
       consumers: this.consumers.size,
       total: this.allConnections.size
     };
@@ -699,7 +745,8 @@ var ConnectionManager = class {
    */
   closeAll() {
     this.stopHeartbeatCheck();
-    for (const ws of this.allConnections.values()) {
+    const allWs = Array.from(this.allConnections.values());
+    for (const ws of allWs) {
       ws.close();
     }
     this.providers.clear();
@@ -853,24 +900,11 @@ function getVersion() {
   try {
     const currentFile = fileURLToPath(import.meta.url);
     const currentDir = dirname3(currentFile);
-    const versionFilePaths = [
-      join2(currentDir, "..", "VERSION"),
-      // dist/xxx.js -> ../VERSION
-      join2(currentDir, "..", "..", "VERSION")
-      // src/shared/version.ts -> ../../VERSION
-    ];
-    for (const versionFilePath of versionFilePaths) {
-      if (existsSync3(versionFilePath)) {
-        const version = readFileSync2(versionFilePath, "utf-8").trim();
-        if (version) {
-          cachedVersion = version;
-          return cachedVersion;
-        }
-      }
-    }
     const packageJsonPaths = [
       join2(currentDir, "..", "package.json"),
+      // dist/xxx.js -> ../package.json
       join2(currentDir, "..", "..", "package.json")
+      // src/shared/version.ts -> ../../package.json
     ];
     for (const packageJsonPath of packageJsonPaths) {
       if (existsSync3(packageJsonPath)) {
@@ -888,6 +922,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 {
@@ -1134,6 +1175,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,
@@ -1153,6 +1435,7 @@ export {
   Logger,
   MAX_PORT_ATTEMPTS,
   MAX_RETRY_COUNT,
+  MGClient,
   MGError,
   MGServer,
   MessageType,
@@ -1185,6 +1468,7 @@ export {
   formatLogTime,
   generateId,
   generateMgpLink,
+  generatePageLink,
   getCurrentISOTime,
   isDesignPageUrl,
   isProcessRunning,