@hangox/mg-cli 1.0.0 → 1.0.1

package/dist/cli.js

@@ -0,0 +1,1574 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command as Command8 } from "commander";
+
+// src/cli/commands/server.ts
+import { Command } from "commander";
+
+// src/server/daemon.ts
+import { spawn } from "child_process";
+import { fileURLToPath } from "url";
+import { dirname as dirname3, join as join2 } from "path";
+
+// src/shared/utils.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from "fs";
+import { dirname, resolve, isAbsolute } from "path";
+
+// src/shared/constants.ts
+import { homedir } from "os";
+import { join } from "path";
+var DEFAULT_PORT = 9527;
+var PORT_RANGE_START = 9527;
+var PORT_RANGE_END = 9536;
+var PORT_SCAN_TIMEOUT = 500;
+var CONFIG_DIR = join(homedir(), ".mg-plugin");
+var SERVER_INFO_FILE = join(CONFIG_DIR, "server.json");
+var LOG_DIR = join(CONFIG_DIR, "logs");
+var SERVER_LOG_FILE = join(LOG_DIR, "server.log");
+var HEARTBEAT_INTERVAL = 3e4;
+var HEARTBEAT_TIMEOUT = 9e4;
+var REQUEST_TIMEOUT = 3e4;
+var SERVER_START_TIMEOUT = 5e3;
+var RETRY_INTERVALS = [1e3, 2e3, 4e3];
+var MAX_RETRY_COUNT = 3;
+
+// src/shared/utils.ts
+function ensureDir(dir) {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+function ensureConfigDir() {
+  ensureDir(CONFIG_DIR);
+  ensureDir(LOG_DIR);
+}
+function readServerInfo() {
+  try {
+    if (!existsSync(SERVER_INFO_FILE)) {
+      return null;
+    }
+    const content = readFileSync(SERVER_INFO_FILE, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function writeServerInfo(info) {
+  ensureConfigDir();
+  writeFileSync(SERVER_INFO_FILE, JSON.stringify(info, null, 2), "utf-8");
+}
+function deleteServerInfo() {
+  try {
+    if (existsSync(SERVER_INFO_FILE)) {
+      unlinkSync(SERVER_INFO_FILE);
+    }
+  } catch {
+  }
+}
+function isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function killProcess(pid) {
+  try {
+    process.kill(pid, "SIGTERM");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function parseMgpLink(link) {
+  if (!link.startsWith("mgp://")) {
+    return null;
+  }
+  try {
+    const urlPart = link.slice(6);
+    const questionMarkIndex = urlPart.indexOf("?");
+    if (questionMarkIndex === -1) {
+      return null;
+    }
+    const pageUrl = urlPart.slice(0, questionMarkIndex);
+    const queryString = urlPart.slice(questionMarkIndex + 1);
+    const params = new URLSearchParams(queryString);
+    const encodedNodeId = params.get("nodeId");
+    if (!encodedNodeId) {
+      return null;
+    }
+    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
+    };
+  } catch {
+    return null;
+  }
+}
+function formatDuration(ms) {
+  const seconds = Math.floor(ms / 1e3);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  if (days > 0) {
+    return `${days} \u5929 ${hours % 24} \u5C0F\u65F6`;
+  }
+  if (hours > 0) {
+    return `${hours} \u5C0F\u65F6 ${minutes % 60} \u5206\u949F`;
+  }
+  if (minutes > 0) {
+    return `${minutes} \u5206\u949F ${seconds % 60} \u79D2`;
+  }
+  return `${seconds} \u79D2`;
+}
+function generateId() {
+  return `${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+}
+function getCurrentISOTime() {
+  return (/* @__PURE__ */ new Date()).toISOString();
+}
+function formatLogTime(date = /* @__PURE__ */ new Date()) {
+  const year = date.getFullYear();
+  const month = String(date.getMonth() + 1).padStart(2, "0");
+  const day = String(date.getDate()).padStart(2, "0");
+  const hours = String(date.getHours()).padStart(2, "0");
+  const minutes = String(date.getMinutes()).padStart(2, "0");
+  const seconds = String(date.getSeconds()).padStart(2, "0");
+  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
+}
+function extractFileIdFromUrl(url) {
+  const match = url.match(/\/file\/(\d+)/);
+  return match ? match[1] : null;
+}
+function extractFileIdFromMgpLink(link) {
+  if (!link.startsWith("mgp://")) {
+    return null;
+  }
+  return extractFileIdFromUrl(link);
+}
+function extractFileId(input) {
+  const trimmed = input.trim();
+  if (/^\d+$/.test(trimmed)) {
+    return trimmed;
+  }
+  if (trimmed.startsWith("mgp://")) {
+    return extractFileIdFromMgpLink(trimmed);
+  }
+  if (trimmed.startsWith("http://") || trimmed.startsWith("https://")) {
+    return extractFileIdFromUrl(trimmed);
+  }
+  return extractFileIdFromUrl(trimmed);
+}
+
+// src/shared/errors.ts
+var ErrorNames = {
+  ["E001" /* CONNECTION_FAILED */]: "CONNECTION_FAILED",
+  ["E002" /* CONNECTION_TIMEOUT */]: "CONNECTION_TIMEOUT",
+  ["E003" /* NO_PAGE_CONNECTED */]: "NO_PAGE_CONNECTED",
+  ["E004" /* PAGE_NOT_FOUND */]: "PAGE_NOT_FOUND",
+  ["E005" /* NODE_NOT_FOUND */]: "NODE_NOT_FOUND",
+  ["E006" /* NO_SELECTION */]: "NO_SELECTION",
+  ["E007" /* MG_UNAVAILABLE */]: "MG_UNAVAILABLE",
+  ["E008" /* EXPORT_FAILED */]: "EXPORT_FAILED",
+  ["E009" /* FILE_WRITE_FAILED */]: "FILE_WRITE_FAILED",
+  ["E010" /* INVALID_LINK */]: "INVALID_LINK",
+  ["E011" /* INVALID_PARAMS */]: "INVALID_PARAMS",
+  ["E012" /* REQUEST_TIMEOUT */]: "REQUEST_TIMEOUT",
+  ["E013" /* PORT_EXHAUSTED */]: "PORT_EXHAUSTED",
+  ["E014" /* SERVER_DISCOVERY_FAILED */]: "SERVER_DISCOVERY_FAILED",
+  ["E015" /* SERVER_START_FAILED */]: "SERVER_START_FAILED",
+  ["E016" /* SERVER_ALREADY_RUNNING */]: "SERVER_ALREADY_RUNNING",
+  ["E017" /* CONNECTION_LOST */]: "CONNECTION_LOST",
+  ["E099" /* UNKNOWN_ERROR */]: "UNKNOWN_ERROR"
+};
+var ErrorMessages = {
+  ["E001" /* CONNECTION_FAILED */]: "\u65E0\u6CD5\u8FDE\u63A5\u5230 MG Server",
+  ["E002" /* CONNECTION_TIMEOUT */]: "\u8FDE\u63A5\u8D85\u65F6",
+  ["E003" /* NO_PAGE_CONNECTED */]: "\u6CA1\u6709 MasterGo \u9875\u9762\u8FDE\u63A5\u5230 Server",
+  ["E004" /* PAGE_NOT_FOUND */]: "\u672A\u627E\u5230\u5339\u914D\u7684\u9875\u9762",
+  ["E005" /* NODE_NOT_FOUND */]: "\u8282\u70B9\u4E0D\u5B58\u5728",
+  ["E006" /* NO_SELECTION */]: "\u6CA1\u6709\u9009\u4E2D\u4EFB\u4F55\u8282\u70B9",
+  ["E007" /* MG_UNAVAILABLE */]: "mg \u5BF9\u8C61\u4E0D\u53EF\u7528",
+  ["E008" /* EXPORT_FAILED */]: "\u5BFC\u51FA\u56FE\u7247\u5931\u8D25",
+  ["E009" /* FILE_WRITE_FAILED */]: "\u6587\u4EF6\u5199\u5165\u5931\u8D25",
+  ["E010" /* INVALID_LINK */]: "\u65E0\u6548\u7684 mgp:// \u94FE\u63A5\u683C\u5F0F",
+  ["E011" /* INVALID_PARAMS */]: "\u53C2\u6570\u6821\u9A8C\u5931\u8D25",
+  ["E012" /* REQUEST_TIMEOUT */]: "\u8BF7\u6C42\u8D85\u65F6",
+  ["E013" /* PORT_EXHAUSTED */]: "\u6240\u6709\u5907\u9009\u7AEF\u53E3\u5747\u88AB\u5360\u7528",
+  ["E014" /* SERVER_DISCOVERY_FAILED */]: "\u65E0\u6CD5\u53D1\u73B0 Server (\u7AEF\u53E3\u626B\u63CF\u5931\u8D25)",
+  ["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",
+  ["E099" /* UNKNOWN_ERROR */]: "\u672A\u77E5\u9519\u8BEF"
+};
+var MGError = class extends Error {
+  /** 错误码 */
+  code;
+  /** 错误名称 */
+  errorName;
+  /** 额外详情 */
+  details;
+  constructor(code, message, details) {
+    super(message || ErrorMessages[code]);
+    this.name = "MGError";
+    this.code = code;
+    this.errorName = ErrorNames[code];
+    this.details = details;
+  }
+  /** 转换为 JSON 格式 */
+  toJSON() {
+    return {
+      code: this.code,
+      name: this.errorName,
+      message: this.message,
+      details: this.details
+    };
+  }
+  /** 格式化输出 */
+  toString() {
+    return `\u9519\u8BEF [${this.code}]: ${this.message}`;
+  }
+};
+
+// src/server/websocket-server.ts
+import { WebSocketServer } from "ws";
+
+// src/server/logger.ts
+import { appendFileSync, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
+import { dirname as dirname2 } from "path";
+var levelPriority = {
+  ["DEBUG" /* DEBUG */]: 0,
+  ["INFO" /* INFO */]: 1,
+  ["WARN" /* WARN */]: 2,
+  ["ERROR" /* ERROR */]: 3
+};
+var Logger = class {
+  options;
+  constructor(options = {}) {
+    this.options = {
+      console: options.console ?? true,
+      file: options.file ?? false,
+      filePath: options.filePath ?? SERVER_LOG_FILE,
+      minLevel: options.minLevel ?? "INFO" /* INFO */
+    };
+    if (this.options.file) {
+      const dir = dirname2(this.options.filePath);
+      if (!existsSync2(dir)) {
+        mkdirSync2(dir, { recursive: true });
+      }
+    }
+  }
+  /**
+   * 记录日志
+   */
+  log(level, message, ...args) {
+    if (levelPriority[level] < levelPriority[this.options.minLevel]) {
+      return;
+    }
+    const timestamp = formatLogTime();
+    const formattedMessage = `[${timestamp}] [${level}] ${message}`;
+    if (this.options.console) {
+      const consoleMethod = level === "ERROR" /* ERROR */ ? console.error : console.log;
+      if (args.length > 0) {
+        consoleMethod(formattedMessage, ...args);
+      } else {
+        consoleMethod(formattedMessage);
+      }
+    }
+    if (this.options.file) {
+      try {
+        const fileMessage = args.length > 0 ? `${formattedMessage} ${JSON.stringify(args)}
+` : `${formattedMessage}
+`;
+        appendFileSync(this.options.filePath, fileMessage);
+      } catch (error) {
+        if (this.options.console) {
+          console.error("\u65E5\u5FD7\u6587\u4EF6\u5199\u5165\u5931\u8D25:", error);
+        }
+      }
+    }
+  }
+  debug(message, ...args) {
+    this.log("DEBUG" /* DEBUG */, message, ...args);
+  }
+  info(message, ...args) {
+    this.log("INFO" /* INFO */, message, ...args);
+  }
+  warn(message, ...args) {
+    this.log("WARN" /* WARN */, message, ...args);
+  }
+  error(message, ...args) {
+    this.log("ERROR" /* ERROR */, message, ...args);
+  }
+};
+function createLogger(options) {
+  return new Logger(options);
+}
+
+// src/server/connection-manager.ts
+var ConnectionManager = class {
+  logger;
+  /** Provider 连接（按页面 URL 索引） */
+  providers = /* @__PURE__ */ new Map();
+  /** Consumer 连接 */
+  consumers = /* @__PURE__ */ new Map();
+  /** 所有连接（按 ID 索引） */
+  allConnections = /* @__PURE__ */ new Map();
+  /** 心跳检查定时器 */
+  heartbeatTimer = null;
+  constructor(logger) {
+    this.logger = logger;
+  }
+  /**
+   * 启动心跳检查
+   */
+  startHeartbeatCheck(interval = 3e4) {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+    }
+    this.heartbeatTimer = setInterval(() => {
+      this.checkHeartbeats();
+    }, interval);
+  }
+  /**
+   * 停止心跳检查
+   */
+  stopHeartbeatCheck() {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer);
+      this.heartbeatTimer = null;
+    }
+  }
+  /**
+   * 检查所有连接的心跳
+   */
+  checkHeartbeats() {
+    const now = Date.now();
+    for (const [id, ws] of this.allConnections) {
+      const lastActive = ws.connectionInfo.lastActiveAt.getTime();
+      const elapsed = now - lastActive;
+      if (elapsed > HEARTBEAT_TIMEOUT) {
+        this.logger.warn(`\u8FDE\u63A5 ${id} \u5FC3\u8DF3\u8D85\u65F6\uFF0C\u5173\u95ED\u8FDE\u63A5`);
+        this.removeConnection(ws);
+        ws.terminate();
+      }
+    }
+  }
+  /**
+   * 添加连接
+   */
+  addConnection(ws, type, pageUrl, pageId) {
+    const connectionId = generateId();
+    const now = /* @__PURE__ */ new Date();
+    const connectionInfo = {
+      id: connectionId,
+      type,
+      pageUrl,
+      pageId,
+      connectedAt: now,
+      lastActiveAt: now
+    };
+    const managedWs = ws;
+    managedWs.connectionId = connectionId;
+    managedWs.connectionInfo = connectionInfo;
+    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}`);
+    } else if (type === "consumer" /* CONSUMER */) {
+      this.consumers.set(connectionId, managedWs);
+      this.logger.info(`Consumer \u8FDE\u63A5: ${connectionId}`);
+    }
+    return managedWs;
+  }
+  /**
+   * 移除连接
+   */
+  removeConnection(ws) {
+    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}`);
+    } else if (connectionInfo.type === "consumer" /* CONSUMER */) {
+      this.consumers.delete(connectionId);
+      this.logger.info(`Consumer \u65AD\u5F00: ${connectionId}`);
+    }
+  }
+  /**
+   * 更新连接活跃时间
+   */
+  updateLastActive(ws) {
+    ws.connectionInfo.lastActiveAt = /* @__PURE__ */ new Date();
+    ws.isAlive = true;
+  }
+  /**
+   * 根据页面 URL 查找 Provider
+   */
+  findProviderByPageUrl(pageUrl) {
+    return this.providers.get(pageUrl);
+  }
+  /**
+   * 获取第一个可用的 Provider
+   */
+  getFirstProvider() {
+    const iterator = this.providers.values();
+    const first = iterator.next();
+    return first.value;
+  }
+  /**
+   * 获取所有 Provider 信息
+   */
+  getAllProviders() {
+    return Array.from(this.providers.values()).map((ws) => ws.connectionInfo);
+  }
+  /**
+   * 获取连接统计
+   */
+  getStats() {
+    return {
+      providers: this.providers.size,
+      consumers: this.consumers.size,
+      total: this.allConnections.size
+    };
+  }
+  /**
+   * 获取所有已连接的页面 URL
+   */
+  getConnectedPageUrls() {
+    return Array.from(this.providers.keys());
+  }
+  /**
+   * 关闭所有连接
+   */
+  closeAll() {
+    this.stopHeartbeatCheck();
+    for (const ws of this.allConnections.values()) {
+      ws.close();
+    }
+    this.providers.clear();
+    this.consumers.clear();
+    this.allConnections.clear();
+  }
+};
+
+// src/server/request-handler.ts
+var RequestHandler = class {
+  logger;
+  connectionManager;
+  /** 待处理的请求 */
+  pendingRequests = /* @__PURE__ */ new Map();
+  constructor(connectionManager, logger) {
+    this.connectionManager = connectionManager;
+    this.logger = logger;
+  }
+  /**
+   * 处理 Consumer 请求
+   */
+  async handleRequest(consumer, message) {
+    const requestId = message.id || generateId();
+    const { type, pageUrl, params } = message;
+    this.logger.info(`\u6536\u5230\u8BF7\u6C42: ${type} (${requestId})`, { pageUrl });
+    let provider;
+    if (pageUrl) {
+      provider = this.connectionManager.findProviderByPageUrl(pageUrl);
+      if (!provider) {
+        this.sendError(consumer, requestId, "E004" /* PAGE_NOT_FOUND */, `\u672A\u627E\u5230\u9875\u9762: ${pageUrl}`);
+        return;
+      }
+    } else {
+      provider = this.connectionManager.getFirstProvider();
+      if (!provider) {
+        this.sendError(consumer, requestId, "E003" /* NO_PAGE_CONNECTED */, "\u6CA1\u6709\u9875\u9762\u8FDE\u63A5\u5230 Server");
+        return;
+      }
+    }
+    const timer = setTimeout(() => {
+      this.handleTimeout(requestId);
+    }, REQUEST_TIMEOUT);
+    this.pendingRequests.set(requestId, {
+      id: requestId,
+      consumer,
+      timer,
+      timestamp: Date.now()
+    });
+    const forwardMessage = {
+      id: requestId,
+      type,
+      pageUrl: pageUrl || provider.connectionInfo.pageUrl,
+      params,
+      timestamp: Date.now()
+    };
+    try {
+      provider.send(JSON.stringify(forwardMessage));
+      this.logger.info(`\u8BF7\u6C42\u8F6C\u53D1: ${type} -> ${provider.connectionInfo.pageUrl}`);
+    } catch {
+      this.cleanupRequest(requestId);
+      this.sendError(consumer, requestId, "E001" /* CONNECTION_FAILED */, "\u8F6C\u53D1\u8BF7\u6C42\u5931\u8D25");
+    }
+  }
+  /**
+   * 处理 Provider 响应
+   */
+  handleResponse(response) {
+    const { id } = response;
+    const pending = this.pendingRequests.get(id);
+    if (!pending) {
+      this.logger.warn(`\u6536\u5230\u672A\u77E5\u8BF7\u6C42\u7684\u54CD\u5E94: ${id}`);
+      return;
+    }
+    this.cleanupRequest(id);
+    try {
+      pending.consumer.send(JSON.stringify(response));
+      this.logger.info(
+        `\u54CD\u5E94\u8FD4\u56DE: ${id} (${response.success ? "\u6210\u529F" : "\u5931\u8D25"})`
+      );
+    } catch (error) {
+      this.logger.error(`\u54CD\u5E94\u8F6C\u53D1\u5931\u8D25: ${id}`, error);
+    }
+  }
+  /**
+   * 处理请求超时
+   */
+  handleTimeout(requestId) {
+    const pending = this.pendingRequests.get(requestId);
+    if (!pending) return;
+    this.logger.warn(`\u8BF7\u6C42\u8D85\u65F6: ${requestId}`);
+    this.cleanupRequest(requestId);
+    this.sendError(pending.consumer, requestId, "E012" /* REQUEST_TIMEOUT */, "\u8BF7\u6C42\u8D85\u65F6");
+  }
+  /**
+   * 清理请求
+   */
+  cleanupRequest(requestId) {
+    const pending = this.pendingRequests.get(requestId);
+    if (pending) {
+      clearTimeout(pending.timer);
+      this.pendingRequests.delete(requestId);
+    }
+  }
+  /**
+   * 发送错误响应
+   */
+  sendError(consumer, requestId, code, message) {
+    const error = new MGError(code, message);
+    const response = {
+      id: requestId,
+      type: "error" /* ERROR */,
+      success: false,
+      data: null,
+      error: error.toJSON()
+    };
+    try {
+      consumer.send(JSON.stringify(response));
+    } catch (err) {
+      this.logger.error(`\u53D1\u9001\u9519\u8BEF\u54CD\u5E94\u5931\u8D25: ${requestId}`, err);
+    }
+  }
+  /**
+   * 清理特定连接的所有待处理请求
+   */
+  cleanupConnectionRequests(connectionId) {
+    for (const [requestId, pending] of this.pendingRequests) {
+      if (pending.consumer.connectionId === connectionId) {
+        this.cleanupRequest(requestId);
+      }
+    }
+  }
+  /**
+   * 清理所有待处理请求
+   */
+  cleanupAll() {
+    for (const [requestId] of this.pendingRequests) {
+      this.cleanupRequest(requestId);
+    }
+  }
+};
+
+// src/server/websocket-server.ts
+var MGServer = class {
+  wss = null;
+  logger;
+  connectionManager;
+  requestHandler;
+  port;
+  isRunning = false;
+  constructor(options = {}) {
+    this.port = options.port || DEFAULT_PORT;
+    this.logger = options.logger || createLogger();
+    this.connectionManager = new ConnectionManager(this.logger);
+    this.requestHandler = new RequestHandler(this.connectionManager, this.logger);
+  }
+  /**
+   * 启动服务器
+   */
+  async start() {
+    if (this.isRunning) {
+      throw new MGError("E016" /* SERVER_ALREADY_RUNNING */, "Server \u5DF2\u5728\u8FD0\u884C\u4E2D");
+    }
+    const port = await this.findAvailablePort();
+    return new Promise((resolve7, reject) => {
+      this.wss = new WebSocketServer({ port });
+      this.wss.on("listening", () => {
+        this.port = port;
+        this.isRunning = true;
+        this.logger.info(`Server \u542F\u52A8\u6210\u529F\uFF0C\u76D1\u542C\u7AEF\u53E3: ${port}`);
+        this.connectionManager.startHeartbeatCheck(HEARTBEAT_INTERVAL);
+        resolve7(port);
+      });
+      this.wss.on("error", (error) => {
+        this.logger.error("Server \u9519\u8BEF:", error);
+        reject(error);
+      });
+      this.wss.on("connection", (ws, request) => {
+        this.handleConnection(ws, request);
+      });
+    });
+  }
+  /**
+   * 查找可用端口
+   */
+  async findAvailablePort() {
+    for (let port = PORT_RANGE_START; port <= PORT_RANGE_END; port++) {
+      const available = await this.isPortAvailable(port);
+      if (available) {
+        return port;
+      }
+      this.logger.debug(`\u7AEF\u53E3 ${port} \u88AB\u5360\u7528\uFF0C\u5C1D\u8BD5\u4E0B\u4E00\u4E2A`);
+    }
+    throw new MGError(
+      "E013" /* PORT_EXHAUSTED */,
+      `\u7AEF\u53E3 ${PORT_RANGE_START}-${PORT_RANGE_END} \u5747\u88AB\u5360\u7528`
+    );
+  }
+  /**
+   * 检查端口是否可用
+   */
+  isPortAvailable(port) {
+    return new Promise((resolve7) => {
+      const testServer = new WebSocketServer({ port });
+      testServer.on("listening", () => {
+        testServer.close();
+        resolve7(true);
+      });
+      testServer.on("error", () => {
+        resolve7(false);
+      });
+    });
+  }
+  /**
+   * 处理新连接
+   */
+  handleConnection(ws, _request) {
+    this.logger.info("\u65B0\u8FDE\u63A5\u5EFA\u7ACB");
+    const registerTimeout = setTimeout(() => {
+      this.logger.warn("\u8FDE\u63A5\u6CE8\u518C\u8D85\u65F6\uFF0C\u5173\u95ED\u8FDE\u63A5");
+      ws.close();
+    }, 5e3);
+    ws.on("message", (data) => {
+      try {
+        const message = JSON.parse(data.toString());
+        if (message.type === "register" /* REGISTER */) {
+          clearTimeout(registerTimeout);
+          this.handleRegister(ws, message);
+          return;
+        }
+        const managedWs = ws;
+        if (!managedWs.connectionId) {
+          this.logger.warn("\u672A\u6CE8\u518C\u7684\u8FDE\u63A5\u53D1\u9001\u6D88\u606F\uFF0C\u5FFD\u7565");
+          return;
+        }
+        this.handleMessage(managedWs, message);
+      } catch (error) {
+        this.logger.error("\u6D88\u606F\u89E3\u6790\u5931\u8D25:", error);
+      }
+    });
+    ws.on("close", () => {
+      clearTimeout(registerTimeout);
+      const managedWs = ws;
+      if (managedWs.connectionId) {
+        this.requestHandler.cleanupConnectionRequests(managedWs.connectionId);
+        this.connectionManager.removeConnection(managedWs);
+      }
+    });
+    ws.on("error", (error) => {
+      this.logger.error("WebSocket \u9519\u8BEF:", error);
+    });
+  }
+  /**
+   * 处理注册消息
+   */
+  handleRegister(ws, message) {
+    const { connectionType, pageUrl, pageId } = message.data;
+    const managedWs = this.connectionManager.addConnection(
+      ws,
+      connectionType,
+      pageUrl,
+      pageId
+    );
+    const ack = {
+      id: message.id || "",
+      type: "register_ack" /* REGISTER_ACK */,
+      success: true,
+      data: {
+        connectionId: managedWs.connectionId,
+        pageUrl
+      }
+    };
+    ws.send(JSON.stringify(ack));
+  }
+  /**
+   * 处理消息
+   */
+  handleMessage(ws, message) {
+    this.connectionManager.updateLastActive(ws);
+    switch (message.type) {
+      case "ping" /* PING */:
+        this.handlePing(ws, message);
+        break;
+      case "response" /* RESPONSE */:
+      case "error" /* ERROR */:
+        this.requestHandler.handleResponse(message);
+        break;
+      default:
+        if (ws.connectionInfo.type === "consumer" /* CONSUMER */) {
+          this.requestHandler.handleRequest(ws, message);
+        }
+        break;
+    }
+  }
+  /**
+   * 处理心跳
+   */
+  handlePing(ws, message) {
+    const pong = {
+      type: "pong" /* PONG */,
+      timestamp: message.timestamp || Date.now()
+    };
+    ws.send(JSON.stringify(pong));
+  }
+  /**
+   * 停止服务器
+   */
+  async stop() {
+    if (!this.isRunning || !this.wss) {
+      return;
+    }
+    this.logger.info("\u6B63\u5728\u505C\u6B62 Server...");
+    this.requestHandler.cleanupAll();
+    this.connectionManager.closeAll();
+    return new Promise((resolve7) => {
+      this.wss.close(() => {
+        this.isRunning = false;
+        this.wss = null;
+        this.logger.info("Server \u5DF2\u505C\u6B62");
+        resolve7();
+      });
+    });
+  }
+  /**
+   * 获取运行状态
+   */
+  getStatus() {
+    return {
+      running: this.isRunning,
+      port: this.port,
+      stats: this.connectionManager.getStats(),
+      connectedPages: this.connectionManager.getConnectedPageUrls()
+    };
+  }
+  /**
+   * 获取端口
+   */
+  getPort() {
+    return this.port;
+  }
+  /**
+   * 是否运行中
+   */
+  isServerRunning() {
+    return this.isRunning;
+  }
+};
+function createServer(options) {
+  return new MGServer(options);
+}
+
+// src/server/daemon.ts
+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 startServerForeground(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 logger = createLogger({
+    console: true,
+    file: true,
+    minLevel: "INFO" /* INFO */
+  });
+  const server = createServer({
+    port: port || DEFAULT_PORT,
+    logger
+  });
+  const cleanup = async () => {
+    console.log("\n\u6B63\u5728\u505C\u6B62 Server...");
+    await server.stop();
+    deleteServerInfo();
+    process.exit(0);
+  };
+  process.on("SIGINT", cleanup);
+  process.on("SIGTERM", cleanup);
+  try {
+    const actualPort = await server.start();
+    writeServerInfo({
+      port: actualPort,
+      pid: process.pid,
+      startedAt: getCurrentISOTime()
+    });
+    console.log(`
+MG Server \u542F\u52A8\u6210\u529F`);
+    console.log(`\u76D1\u542C\u7AEF\u53E3: ${actualPort}`);
+    console.log(`\u8FDB\u7A0B PID: ${process.pid}`);
+    console.log(`\u8FD0\u884C\u6A21\u5F0F: \u524D\u53F0`);
+    console.log(`
+\u6309 Ctrl+C \u505C\u6B62...`);
+  } catch (error) {
+    logger.error("Server \u542F\u52A8\u5931\u8D25:", error);
+    throw error;
+  }
+}
+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 = fileURLToPath(import.meta.url);
+  const currentDir = dirname3(currentFile);
+  const serverScript = join2(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((resolve7) => setTimeout(resolve7, 200));
+    const { running: running2, info: info2 } = isServerRunning();
+    if (running2 && info2) {
+      return info2;
+    }
+  }
+  throw new MGError("E015" /* SERVER_START_FAILED */, "Server \u542F\u52A8\u8D85\u65F6");
+}
+function stopServer() {
+  const { running, info } = isServerRunning();
+  if (!running || !info) {
+    return { stopped: false, info: null };
+  }
+  const killed = killProcess(info.pid);
+  if (killed) {
+    deleteServerInfo();
+  }
+  return { stopped: killed, info };
+}
+async function restartServer(port) {
+  const { info: oldInfo } = stopServer();
+  await new Promise((resolve7) => setTimeout(resolve7, 500));
+  return startServerDaemon(port || oldInfo?.port);
+}
+function getServerStatus() {
+  const { running, info } = isServerRunning();
+  if (!running || !info) {
+    return { running: false };
+  }
+  const uptimeMs = Date.now() - new Date(info.startedAt).getTime();
+  return {
+    running: true,
+    port: info.port,
+    pid: info.pid,
+    startedAt: info.startedAt,
+    uptime: formatDuration(uptimeMs)
+  };
+}
+
+// src/cli/commands/server.ts
+function createServerCommand() {
+  const serverCmd = new Command("server").description("Server \u7BA1\u7406\u547D\u4EE4");
+  serverCmd.command("start").description("\u542F\u52A8 MG Server").option("--port <number>", "\u6307\u5B9A\u542F\u52A8\u7AEF\u53E3", (value) => parseInt(value, 10)).option("--foreground", "\u524D\u53F0\u6A21\u5F0F\u8FD0\u884C\uFF08\u4E0D\u4F5C\u4E3A\u5B88\u62A4\u8FDB\u7A0B\uFF09", false).action(async (options) => {
+    try {
+      if (options.foreground) {
+        await startServerForeground(options.port);
+      } else {
+        const info = await startServerDaemon(options.port);
+        console.log("MG Server \u542F\u52A8\u6210\u529F");
+        console.log(`\u76D1\u542C\u7AEF\u53E3: ${info.port}`);
+        console.log(`\u8FDB\u7A0B PID: ${info.pid}`);
+        console.log(`\u8FD0\u884C\u6A21\u5F0F: \u5B88\u62A4\u8FDB\u7A0B`);
+      }
+    } catch (error) {
+      console.error(`\u9519\u8BEF: ${error.message}`);
+      process.exit(1);
+    }
+  });
+  serverCmd.command("stop").description("\u505C\u6B62 MG Server").action(() => {
+    try {
+      const { stopped, info } = stopServer();
+      if (stopped && info) {
+        console.log("MG Server \u5DF2\u505C\u6B62");
+        console.log(`PID: ${info.pid}`);
+        const uptimeMs = Date.now() - new Date(info.startedAt).getTime();
+        const seconds = Math.floor(uptimeMs / 1e3);
+        const minutes = Math.floor(seconds / 60);
+        const hours = Math.floor(minutes / 60);
+        let uptime = "";
+        if (hours > 0) {
+          uptime = `${hours} \u5C0F\u65F6 ${minutes % 60} \u5206\u949F`;
+        } else if (minutes > 0) {
+          uptime = `${minutes} \u5206\u949F ${seconds % 60} \u79D2`;
+        } else {
+          uptime = `${seconds} \u79D2`;
+        }
+        console.log(`\u8FD0\u884C\u65F6\u957F: ${uptime}`);
+      } else {
+        console.log("MG Server \u672A\u8FD0\u884C");
+      }
+    } catch (error) {
+      console.error(`\u9519\u8BEF: ${error.message}`);
+      process.exit(1);
+    }
+  });
+  serverCmd.command("restart").description("\u91CD\u542F MG Server").option("--port <number>", "\u91CD\u542F\u540E\u4F7F\u7528\u7684\u7AEF\u53E3", (value) => parseInt(value, 10)).action(async (options) => {
+    try {
+      const status = getServerStatus();
+      if (status.running) {
+        console.log(`\u6B63\u5728\u505C\u6B62 MG Server (PID: ${status.pid})...`);
+      }
+      const info = await restartServer(options.port);
+      console.log("MG Server \u5DF2\u91CD\u542F");
+      console.log(`\u76D1\u542C\u7AEF\u53E3: ${info.port}`);
+      console.log(`\u65B0\u8FDB\u7A0B PID: ${info.pid}`);
+    } catch (error) {
+      console.error(`\u9519\u8BEF: ${error.message}`);
+      process.exit(1);
+    }
+  });
+  serverCmd.command("status").description("\u67E5\u770B Server \u8FD0\u884C\u72B6\u6001").action(() => {
+    try {
+      const status = getServerStatus();
+      if (status.running) {
+        console.log("MG Server \u72B6\u6001: \u8FD0\u884C\u4E2D \u2713");
+        console.log(`\u76D1\u542C\u7AEF\u53E3: ${status.port}`);
+        console.log(`\u8FDB\u7A0B PID: ${status.pid}`);
+        console.log(`\u542F\u52A8\u65F6\u95F4: ${status.startedAt}`);
+        console.log(`\u8FD0\u884C\u65F6\u957F: ${status.uptime}`);
+      } else {
+        console.log("MG Server \u72B6\u6001: \u672A\u8FD0\u884C \u2717");
+        console.log("\u63D0\u793A: \u4F7F\u7528 'mg-cli server start' \u542F\u52A8 Server");
+      }
+    } catch (error) {
+      console.error(`\u9519\u8BEF: ${error.message}`);
+      process.exit(1);
+    }
+  });
+  return serverCmd;
+}
+
+// src/cli/commands/get-node-by-id.ts
+import { Command as Command2 } from "commander";
+import { writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve2, dirname as dirname4 } from "path";
+import { mkdirSync as mkdirSync3 } from "fs";
+
+// src/cli/client.ts
+import WebSocket2 from "ws";
+var MGClient = class {
+  ws = null;
+  options;
+  constructor(options = {}) {
+    this.options = options;
+  }
+  /**
+   * 连接到 Server
+   */
+  async connect() {
+    const serverInfo = readServerInfo();
+    if (serverInfo) {
+      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((resolve7, 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();
+        resolve7();
+      });
+      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((resolve7, 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) {
+              resolve7(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;
+    }
+  }
+};
+
+// src/cli/commands/get-node-by-id.ts
+function createGetNodeByIdCommand() {
+  return new Command2("get_node_by_id").description("\u6839\u636E\u8282\u70B9 ID \u83B7\u53D6\u8282\u70B9\u8BE6\u7EC6\u4FE1\u606F\u3002\u6570\u636E\u4FDD\u5B58\u5230\u6307\u5B9A JSON \u6587\u4EF6\uFF0C\u8FD4\u56DE\u6587\u4EF6\u8DEF\u5F84\u548C\u5927\u5C0F\u4FE1\u606F").requiredOption("--nodeId <id>", "\u8282\u70B9 ID\uFF0C\u683C\u5F0F\u5982 123:456\u3002\u53EF\u4ECE MasterGo \u6D6E\u7A97\u94FE\u63A5\u4E2D\u83B7\u53D6").requiredOption("--output <path>", "\u8F93\u51FA JSON \u6587\u4EF6\u8DEF\u5F84\u3002\u652F\u6301\u7EDD\u5BF9\u8DEF\u5F84\u6216\u76F8\u5BF9\u8DEF\u5F84").option("--maxDepth <number>", "\u904D\u5386\u6DF1\u5EA6\uFF0C\u9ED8\u8BA4 1\u3002\u589E\u52A0\u6DF1\u5EA6\u4F1A\u663E\u8457\u589E\u52A0\u6570\u636E\u91CF", "1").option("--includeInvisible", "\u5305\u542B\u4E0D\u53EF\u89C1\u8282\u70B9\uFF08visible: false\uFF09\uFF0C\u9ED8\u8BA4\u4E0D\u5305\u542B", false).option("--no-auto-start", "\u7981\u7528\u81EA\u52A8\u542F\u52A8 Server").option("--no-retry", "\u7981\u7528\u81EA\u52A8\u91CD\u8BD5").action(async (options) => {
+    await handleGetNodeById(options);
+  });
+}
+async function handleGetNodeById(options) {
+  const client = new MGClient({
+    noAutoStart: options.noAutoStart,
+    noRetry: options.noRetry
+  });
+  try {
+    await client.connect();
+    const params = {
+      nodeId: options.nodeId,
+      maxDepth: parseInt(options.maxDepth || "1", 10),
+      includeInvisible: options.includeInvisible || false
+    };
+    const data = await client.requestWithRetry("get_node_by_id" /* GET_NODE_BY_ID */, params);
+    const outputPath = resolve2(options.output);
+    const outputDir = dirname4(outputPath);
+    mkdirSync3(outputDir, { recursive: true });
+    const jsonContent = JSON.stringify(data, null, 2);
+    writeFileSync2(outputPath, jsonContent, "utf-8");
+    const size = jsonContent.length;
+    const sizeKB = (size / 1024).toFixed(2);
+    console.log(`\u6587\u4EF6\u8DEF\u5F84: ${outputPath}`);
+    console.log(`\u8282\u70B9 ID: ${options.nodeId}`);
+    console.log(`\u6570\u636E\u5927\u5C0F: ${size.toLocaleString()} \u5B57\u7B26 (\u7EA6 ${sizeKB} KB)`);
+    console.log(`\u8282\u70B9\u6DF1\u5EA6: ${params.maxDepth}`);
+  } catch (error) {
+    console.error(`\u9519\u8BEF: ${error instanceof Error ? error.message : error}`);
+    process.exit(1);
+  } finally {
+    client.close();
+  }
+}
+
+// src/cli/commands/get-node-by-link.ts
+import { Command as Command3 } from "commander";
+import { writeFileSync as writeFileSync3 } from "fs";
+import { resolve as resolve3, dirname as dirname5 } from "path";
+import { mkdirSync as mkdirSync4 } from "fs";
+function createGetNodeByLinkCommand() {
+  return new Command3("get_node_by_link").description("\u89E3\u6790 mgp:// \u534F\u8BAE\u94FE\u63A5\u5E76\u83B7\u53D6\u8282\u70B9\u4FE1\u606F").requiredOption("--link <url>", "mgp:// \u534F\u8BAE\u94FE\u63A5").requiredOption("--output <path>", "\u8F93\u51FA JSON \u6587\u4EF6\u8DEF\u5F84").option("--maxDepth <number>", "\u904D\u5386\u6DF1\u5EA6", "1").option("--includeInvisible", "\u5305\u542B\u4E0D\u53EF\u89C1\u8282\u70B9", false).option("--no-auto-start", "\u7981\u7528\u81EA\u52A8\u542F\u52A8 Server").option("--no-retry", "\u7981\u7528\u81EA\u52A8\u91CD\u8BD5").action(async (options) => {
+    await handleGetNodeByLink(options);
+  });
+}
+async function handleGetNodeByLink(options) {
+  const parsed = parseMgpLink(options.link);
+  if (!parsed) {
+    console.error(`\u9519\u8BEF [${"E010" /* INVALID_LINK */}]: \u65E0\u6548\u7684 mgp:// \u94FE\u63A5\u683C\u5F0F`);
+    console.error(`\u63D0\u4F9B\u7684\u94FE\u63A5: ${options.link}`);
+    console.error(`\u671F\u671B\u683C\u5F0F: mgp://[mastergo_page_url]/nodeId`);
+    process.exit(1);
+  }
+  const { pageUrl, nodeId } = parsed;
+  const client = new MGClient({
+    noAutoStart: options.noAutoStart,
+    noRetry: options.noRetry
+  });
+  try {
+    await client.connect();
+    const params = {
+      nodeId,
+      maxDepth: parseInt(options.maxDepth || "1", 10),
+      includeInvisible: options.includeInvisible || false
+    };
+    const data = await client.requestWithRetry(
+      "get_node_by_id" /* GET_NODE_BY_ID */,
+      params,
+      pageUrl
+    );
+    const outputPath = resolve3(options.output);
+    const outputDir = dirname5(outputPath);
+    mkdirSync4(outputDir, { recursive: true });
+    const jsonContent = JSON.stringify(data, null, 2);
+    writeFileSync3(outputPath, jsonContent, "utf-8");
+    const size = jsonContent.length;
+    const sizeKB = (size / 1024).toFixed(2);
+    console.log(`\u6587\u4EF6\u8DEF\u5F84: ${outputPath}`);
+    console.log(`Link: ${options.link}`);
+    console.log(`\u9875\u9762 URL: ${pageUrl}`);
+    console.log(`\u8282\u70B9 ID: ${nodeId}`);
+    console.log(`\u6570\u636E\u5927\u5C0F: ${size.toLocaleString()} \u5B57\u7B26 (\u7EA6 ${sizeKB} KB)`);
+    console.log(`\u8282\u70B9\u6DF1\u5EA6: ${params.maxDepth}`);
+  } catch (error) {
+    if (error instanceof MGError) {
+      console.error(`\u9519\u8BEF [${error.code}]: ${error.message}`);
+    } else {
+      console.error(`\u9519\u8BEF: ${error instanceof Error ? error.message : error}`);
+    }
+    process.exit(1);
+  } finally {
+    client.close();
+  }
+}
+
+// src/cli/commands/get-all-nodes.ts
+import { Command as Command4 } from "commander";
+import { writeFileSync as writeFileSync4 } from "fs";
+import { resolve as resolve4, dirname as dirname6 } from "path";
+import { mkdirSync as mkdirSync5 } from "fs";
+function createGetAllNodesCommand() {
+  return new Command4("get_all_nodes").description("\u83B7\u53D6\u5F53\u524D\u9875\u9762\u7684\u6240\u6709\u8282\u70B9\u6811\u3002\u8B66\u544A\uFF1A\u6DF1\u5EA6\u6BCF\u589E\u52A0 1\uFF0C\u6570\u636E\u91CF\u53EF\u80FD\u5448\u6307\u6570\u7EA7\u589E\u957F\u3002\u5EFA\u8BAE\u4ECE maxDepth=1 \u5F00\u59CB").requiredOption("--output <path>", "\u8F93\u51FA JSON \u6587\u4EF6\u8DEF\u5F84\u3002\u652F\u6301\u7EDD\u5BF9\u8DEF\u5F84\u6216\u76F8\u5BF9\u8DEF\u5F84").option("--maxDepth <number>", "\u6700\u5927\u6DF1\u5EA6\uFF0C\u9ED8\u8BA4 1\u3002\u6DF1\u5EA6 2 \u53EF\u80FD\u4EA7\u751F 100KB-500KB\uFF0C\u6DF1\u5EA6 3 \u53EF\u80FD\u8D85\u8FC7 1MB", "1").option("--includeInvisible", "\u5305\u542B\u4E0D\u53EF\u89C1\u8282\u70B9\uFF08visible: false\uFF09\uFF0C\u9ED8\u8BA4\u4E0D\u5305\u542B", false).option("--no-auto-start", "\u7981\u7528\u81EA\u52A8\u542F\u52A8 Server").option("--no-retry", "\u7981\u7528\u81EA\u52A8\u91CD\u8BD5").action(async (options) => {
+    await handleGetAllNodes(options);
+  });
+}
+async function handleGetAllNodes(options) {
+  const client = new MGClient({
+    noAutoStart: options.noAutoStart,
+    noRetry: options.noRetry
+  });
+  try {
+    await client.connect();
+    const params = {
+      maxDepth: parseInt(options.maxDepth || "1", 10),
+      includeInvisible: options.includeInvisible || false
+    };
+    const data = await client.requestWithRetry("get_all_nodes" /* GET_ALL_NODES */, params);
+    const outputPath = resolve4(options.output);
+    const outputDir = dirname6(outputPath);
+    mkdirSync5(outputDir, { recursive: true });
+    const jsonContent = JSON.stringify(data, null, 2);
+    writeFileSync4(outputPath, jsonContent, "utf-8");
+    const size = jsonContent.length;
+    const sizeKB = (size / 1024).toFixed(2);
+    const nodeCount = Array.isArray(data) ? data.length : 1;
+    console.log(`\u6587\u4EF6\u8DEF\u5F84: ${outputPath}`);
+    console.log(`\u8282\u70B9\u6570\u91CF: ${nodeCount}`);
+    console.log(`\u6570\u636E\u5927\u5C0F: ${size.toLocaleString()} \u5B57\u7B26 (\u7EA6 ${sizeKB} KB)`);
+    console.log(`\u8282\u70B9\u6DF1\u5EA6: ${params.maxDepth}`);
+  } catch (error) {
+    console.error(`\u9519\u8BEF: ${error instanceof Error ? error.message : error}`);
+    process.exit(1);
+  } finally {
+    client.close();
+  }
+}
+
+// src/cli/commands/export-image.ts
+import { Command as Command5 } from "commander";
+import { writeFileSync as writeFileSync5 } from "fs";
+import { resolve as resolve5, dirname as dirname7, extname } from "path";
+import { mkdirSync as mkdirSync6 } from "fs";
+import { tmpdir } from "os";
+function createExportImageCommand() {
+  return new Command5("export_image").description("\u5BFC\u51FA MasterGo \u8282\u70B9\u4E3A\u56FE\u7247\u6587\u4EF6\u3002\u5F3A\u70C8\u5EFA\u8BAE\u6307\u5B9A --output\uFF0C\u5426\u5219\u4FDD\u5B58\u5230\u4E34\u65F6\u76EE\u5F55\u53EF\u80FD\u88AB\u7CFB\u7EDF\u6E05\u7406").option("--output <path>", "\u8F93\u51FA\u6587\u4EF6\u8DEF\u5F84\u3002\u5F3A\u70C8\u5EFA\u8BAE\u6307\u5B9A\uFF0C\u5426\u5219\u4FDD\u5B58\u5230\u7CFB\u7EDF\u4E34\u65F6\u76EE\u5F55\u53EF\u80FD\u88AB\u6E05\u7406").option("--link <mgp-link>", "mgp:// \u534F\u8BAE\u94FE\u63A5\u3002\u4E0D\u6307\u5B9A\u5219\u5BFC\u51FA\u5F53\u524D\u9009\u4E2D\u8282\u70B9").option("--format <type>", "\u5BFC\u51FA\u683C\u5F0F\uFF1APNG\uFF08\u65E0\u635F\u900F\u660E\uFF09\u3001JPG\uFF08\u6709\u635F\uFF09\u3001SVG\uFF08\u77E2\u91CF\uFF09\u3001PDF\u3001WEBP", "PNG").option("--scale <number>", "\u7F29\u653E\u500D\u7387\uFF08\u5982 1\u30012\u30013\uFF09\u3002\u4E0E width/height \u4E92\u65A5").option("--width <number>", "\u56FA\u5B9A\u5BBD\u5EA6\uFF08\u50CF\u7D20\uFF09\u3002\u4E0E scale/height \u4E92\u65A5").option("--height <number>", "\u56FA\u5B9A\u9AD8\u5EA6\uFF08\u50CF\u7D20\uFF09\u3002\u4E0E scale/width \u4E92\u65A5").option("--useAbsoluteBounds", "\u4F7F\u7528\u5B8C\u6574\u5C3A\u5BF8\u3002true: \u5305\u542B\u88AB\u88C1\u526A\u90E8\u5206\uFF0Cfalse: \u53EA\u5BFC\u51FA\u53EF\u89C1\u533A\u57DF", false).option("--no-use-render-bounds", "\u4E0D\u5305\u542B\u7279\u6548\u548C\u5916\u63CF\u8FB9\u3002\u9ED8\u8BA4\u5305\u542B\u9634\u5F71\u3001\u5916\u63CF\u8FB9\u7B49").option("--no-auto-start", "\u7981\u7528\u81EA\u52A8\u542F\u52A8 Server").option("--no-retry", "\u7981\u7528\u81EA\u52A8\u91CD\u8BD5").action(async (options) => {
+    await handleExportImage(options);
+  });
+}
+async function handleExportImage(options) {
+  const format = options.format?.toUpperCase() || "PNG";
+  const validFormats = ["PNG", "JPG", "SVG", "PDF", "WEBP"];
+  if (!validFormats.includes(format)) {
+    console.error(`\u9519\u8BEF: \u4E0D\u652F\u6301\u7684\u683C\u5F0F "${options.format}"`);
+    console.error(`\u652F\u6301\u7684\u683C\u5F0F: ${validFormats.join(", ")}`);
+    process.exit(1);
+  }
+  const sizeParams = [options.scale, options.width, options.height].filter(Boolean);
+  if (sizeParams.length > 1) {
+    console.error("\u9519\u8BEF: scale\u3001width\u3001height \u4E09\u8005\u4E92\u65A5\uFF0C\u53EA\u80FD\u6307\u5B9A\u5176\u4E2D\u4E00\u4E2A");
+    process.exit(1);
+  }
+  let pageUrl;
+  let nodeId;
+  if (options.link) {
+    const linkInfo = parseMgpLink(options.link);
+    if (!linkInfo) {
+      console.error(`\u9519\u8BEF: \u65E0\u6548\u7684 mgp:// \u94FE\u63A5\u683C\u5F0F: ${options.link}`);
+      process.exit(1);
+    }
+    pageUrl = linkInfo.pageUrl;
+    nodeId = linkInfo.nodeId;
+  }
+  const client = new MGClient({
+    noAutoStart: options.noAutoStart,
+    noRetry: options.noRetry
+  });
+  try {
+    await client.connect();
+    const params = {
+      format,
+      useAbsoluteBounds: options.useAbsoluteBounds || false,
+      useRenderBounds: options.useRenderBounds !== false
+    };
+    if (nodeId) {
+      params.nodeId = nodeId;
+    }
+    if (options.scale) {
+      params.scale = parseFloat(options.scale);
+    }
+    if (options.width) {
+      params.width = parseInt(options.width, 10);
+    }
+    if (options.height) {
+      params.height = parseInt(options.height, 10);
+    }
+    const response = await client.requestWithRetry(
+      "export_image" /* EXPORT_IMAGE */,
+      params,
+      pageUrl
+    );
+    const ext = getExtension(format);
+    let outputPath;
+    if (options.output) {
+      outputPath = resolve5(options.output);
+      if (!extname(outputPath)) {
+        outputPath = `${outputPath}${ext}`;
+      }
+    } else {
+      const filename = response.filename || `export_${Date.now()}${ext}`;
+      outputPath = resolve5(tmpdir(), filename);
+      console.log("\u8B66\u544A: \u672A\u6307\u5B9A --output\uFF0C\u6587\u4EF6\u5C06\u4FDD\u5B58\u5230\u4E34\u65F6\u76EE\u5F55\uFF0C\u53EF\u80FD\u4F1A\u88AB\u7CFB\u7EDF\u6E05\u7406");
+    }
+    const outputDir = dirname7(outputPath);
+    mkdirSync6(outputDir, { recursive: true });
+    const buffer = Buffer.from(response.data, "base64");
+    writeFileSync5(outputPath, buffer);
+    const sizeKB = (buffer.length / 1024).toFixed(2);
+    console.log(`\u6587\u4EF6\u8DEF\u5F84: ${outputPath}`);
+    if (options.link) {
+      console.log(`Link: ${options.link}`);
+    }
+    if (nodeId) {
+      console.log(`\u8282\u70B9 ID: ${nodeId}`);
+    } else {
+      console.log("\u8282\u70B9 ID: (\u9009\u4E2D\u7684\u8282\u70B9)");
+    }
+    console.log(`\u5BFC\u51FA\u683C\u5F0F: ${format}`);
+    console.log(`\u6587\u4EF6\u5927\u5C0F: ${buffer.length.toLocaleString()} \u5B57\u8282 (\u7EA6 ${sizeKB} KB)`);
+  } catch (error) {
+    if (error instanceof MGError) {
+      console.error(`\u9519\u8BEF [${error.code}]: ${error.message}`);
+    } else {
+      console.error(`\u9519\u8BEF: ${error instanceof Error ? error.message : error}`);
+    }
+    process.exit(1);
+  } finally {
+    client.close();
+  }
+}
+function getExtension(format) {
+  const extensions = {
+    PNG: ".png",
+    JPG: ".jpg",
+    SVG: ".svg",
+    PDF: ".pdf",
+    WEBP: ".webp"
+  };
+  return extensions[format];
+}
+
+// src/cli/commands/execute-code.ts
+import { Command as Command6 } from "commander";
+function createExecuteCodeCommand() {
+  return new Command6("execute_code").description("\u5728 MasterGo \u9875\u9762\u6267\u884C\u81EA\u5B9A\u4E49 JavaScript \u4EE3\u7801\u3002\u901A\u8FC7 mg \u53D8\u91CF\u8BBF\u95EE MasterGo API\uFF0C\u7ED3\u679C\u4F1A\u88AB JSON \u5E8F\u5217\u5316\u8FD4\u56DE").argument("<code>", "\u8981\u6267\u884C\u7684\u4EE3\u7801\u3002\u53EF\u4F7F\u7528 mg \u53D8\u91CF\uFF0C\u5982 mg.currentPage.name\u3001mg.currentPage.selection").option("--no-auto-start", "\u7981\u7528\u81EA\u52A8\u542F\u52A8 Server").option("--no-retry", "\u7981\u7528\u81EA\u52A8\u91CD\u8BD5").action(async (code, options) => {
+    await handleExecuteCode(code, options);
+  });
+}
+async function handleExecuteCode(code, options) {
+  const client = new MGClient({
+    noAutoStart: options.noAutoStart,
+    noRetry: options.noRetry
+  });
+  try {
+    await client.connect();
+    const result = await client.requestWithRetry("execute_code" /* EXECUTE_CODE */, { code });
+    if (result === null || result === void 0) {
+      console.log("\u6267\u884C\u5B8C\u6210\uFF08\u65E0\u8FD4\u56DE\u503C\uFF09");
+    } else if (typeof result === "object") {
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.log(result);
+    }
+  } catch (error) {
+    console.error(`\u9519\u8BEF: ${error instanceof Error ? error.message : error}`);
+    process.exit(1);
+  } finally {
+    client.close();
+  }
+}
+
+// src/cli/commands/get-all-pages.ts
+import { Command as Command7 } from "commander";
+import { writeFileSync as writeFileSync6 } from "fs";
+import { resolve as resolve6, dirname as dirname8 } from "path";
+import { mkdirSync as mkdirSync7 } from "fs";
+import { tmpdir as tmpdir2 } from "os";
+function createGetAllPagesCommand() {
+  return new Command7("get_all_pages").description("\u83B7\u53D6 MasterGo \u6587\u6863\u7684\u6240\u6709\u9875\u9762\u4FE1\u606F\u3002\u4E0D\u6307\u5B9A --output \u65F6\u4FDD\u5B58\u5230\u7CFB\u7EDF\u4E34\u65F6\u76EE\u5F55").option("--link <url>", "\u9875\u9762\u94FE\u63A5\u3002\u652F\u6301\u5B8C\u6574 URL \u6216 mgp:// \u534F\u8BAE").option("--fileId <id>", "\u6587\u4EF6 ID\uFF08\u7EAF\u6570\u5B57\uFF09\u3002\u4ECE URL \u4E2D /file/ \u540E\u9762\u7684\u6570\u5B57").option("--output <path>", "\u8F93\u51FA JSON \u6587\u4EF6\u8DEF\u5F84\u3002\u4E0D\u6307\u5B9A\u5219\u4FDD\u5B58\u5230\u7CFB\u7EDF\u4E34\u65F6\u76EE\u5F55").option("--no-auto-start", "\u7981\u7528\u81EA\u52A8\u542F\u52A8 Server").option("--no-retry", "\u7981\u7528\u81EA\u52A8\u91CD\u8BD5").action(async (options) => {
+    await handleGetAllPages(options);
+  });
+}
+async function handleGetAllPages(options) {
+  let fileId = null;
+  if (options.fileId) {
+    fileId = options.fileId;
+  } else if (options.link) {
+    fileId = extractFileId(options.link);
+    if (!fileId) {
+      console.error("\u9519\u8BEF: \u65E0\u6CD5\u4ECE\u94FE\u63A5\u4E2D\u63D0\u53D6 fileId");
+      console.error("\u652F\u6301\u7684\u683C\u5F0F:");
+      console.error("  - \u5B8C\u6574 URL: https://mastergo.netease.com/file/174875497054651");
+      console.error("  - mgp \u534F\u8BAE: mgp://mastergo.netease.com/file/174875497054651");
+      console.error("  - \u7EAF fileId: 174875497054651");
+      process.exit(1);
+    }
+  } else {
+    console.log("\u672A\u63D0\u4F9B --link \u6216 --fileId\uFF0C\u5C06\u83B7\u53D6\u5F53\u524D\u8FDE\u63A5\u9875\u9762\u7684\u6240\u6709\u9875\u9762\u4FE1\u606F");
+  }
+  const client = new MGClient({
+    noAutoStart: options.noAutoStart,
+    noRetry: options.noRetry
+  });
+  try {
+    await client.connect();
+    let pageUrl;
+    if (fileId) {
+      pageUrl = `mastergo.netease.com/file/${fileId}`;
+    }
+    const data = await client.requestWithRetry(
+      "get_all_pages" /* GET_ALL_PAGES */,
+      {},
+      pageUrl
+    );
+    let outputPath;
+    if (options.output) {
+      outputPath = resolve6(options.output);
+    } else {
+      const filename = `pages_${fileId || "current"}_${Date.now()}.json`;
+      outputPath = resolve6(tmpdir2(), filename);
+    }
+    const outputDir = dirname8(outputPath);
+    mkdirSync7(outputDir, { recursive: true });
+    const jsonContent = JSON.stringify(data, null, 2);
+    writeFileSync6(outputPath, jsonContent, "utf-8");
+    const size = jsonContent.length;
+    const sizeKB = (size / 1024).toFixed(2);
+    console.log(`\u6587\u4EF6\u8DEF\u5F84: ${outputPath}`);
+    console.log(`\u6587\u6863\u540D\u79F0: ${data.documentName}`);
+    console.log(`\u9875\u9762\u6570\u91CF: ${data.totalCount}`);
+    console.log(`\u6570\u636E\u5927\u5C0F: ${size.toLocaleString()} \u5B57\u7B26 (\u7EA6 ${sizeKB} KB)`);
+  } catch (error) {
+    console.error(`\u9519\u8BEF: ${error instanceof Error ? error.message : error}`);
+    process.exit(1);
+  } finally {
+    client.close();
+  }
+}
+
+// src/cli/index.ts
+var program = new Command8();
+program.name("mg-cli").description("MasterGo CLI \u5DE5\u5177 - \u7528\u4E8E Claude Code \u4E0E MasterGo \u901A\u4FE1").version("1.0.0");
+program.addCommand(createServerCommand());
+program.addCommand(createGetNodeByIdCommand());
+program.addCommand(createGetNodeByLinkCommand());
+program.addCommand(createGetAllNodesCommand());
+program.addCommand(createExportImageCommand());
+program.addCommand(createExecuteCodeCommand());
+program.addCommand(createGetAllPagesCommand());
+program.parse();
+//# sourceMappingURL=cli.js.map