@hangox/mg-cli 1.0.0 → 1.0.1

package/dist/index.js

@@ -0,0 +1,950 @@
+// 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 MAX_PORT_ATTEMPTS = 10;
+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;
+var ConnectionType = /* @__PURE__ */ ((ConnectionType2) => {
+  ConnectionType2["CONSUMER"] = "consumer";
+  ConnectionType2["PROVIDER"] = "provider";
+  return ConnectionType2;
+})(ConnectionType || {});
+var MessageType = /* @__PURE__ */ ((MessageType2) => {
+  MessageType2["PING"] = "ping";
+  MessageType2["PONG"] = "pong";
+  MessageType2["REGISTER"] = "register";
+  MessageType2["REGISTER_ACK"] = "register_ack";
+  MessageType2["GET_NODE_BY_ID"] = "get_node_by_id";
+  MessageType2["GET_ALL_NODES"] = "get_all_nodes";
+  MessageType2["GET_SELECTION"] = "get_selection";
+  MessageType2["EXPORT_IMAGE"] = "export_image";
+  MessageType2["EXECUTE_CODE"] = "execute_code";
+  MessageType2["GET_ALL_PAGES"] = "get_all_pages";
+  MessageType2["RESPONSE"] = "response";
+  MessageType2["ERROR"] = "error";
+  return MessageType2;
+})(MessageType || {});
+
+// src/shared/errors.ts
+var ErrorCode = /* @__PURE__ */ ((ErrorCode2) => {
+  ErrorCode2["CONNECTION_FAILED"] = "E001";
+  ErrorCode2["CONNECTION_TIMEOUT"] = "E002";
+  ErrorCode2["NO_PAGE_CONNECTED"] = "E003";
+  ErrorCode2["PAGE_NOT_FOUND"] = "E004";
+  ErrorCode2["NODE_NOT_FOUND"] = "E005";
+  ErrorCode2["NO_SELECTION"] = "E006";
+  ErrorCode2["MG_UNAVAILABLE"] = "E007";
+  ErrorCode2["EXPORT_FAILED"] = "E008";
+  ErrorCode2["FILE_WRITE_FAILED"] = "E009";
+  ErrorCode2["INVALID_LINK"] = "E010";
+  ErrorCode2["INVALID_PARAMS"] = "E011";
+  ErrorCode2["REQUEST_TIMEOUT"] = "E012";
+  ErrorCode2["PORT_EXHAUSTED"] = "E013";
+  ErrorCode2["SERVER_DISCOVERY_FAILED"] = "E014";
+  ErrorCode2["SERVER_START_FAILED"] = "E015";
+  ErrorCode2["SERVER_ALREADY_RUNNING"] = "E016";
+  ErrorCode2["CONNECTION_LOST"] = "E017";
+  ErrorCode2["UNKNOWN_ERROR"] = "E099";
+  return ErrorCode2;
+})(ErrorCode || {});
+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}`;
+  }
+};
+function createError(code, message, details) {
+  return new MGError(code, message, details);
+}
+
+// src/shared/utils.ts
+import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync } from "fs";
+import { dirname, resolve, isAbsolute } from "path";
+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 resolveOutputPath(outputPath) {
+  if (isAbsolute(outputPath)) {
+    return outputPath;
+  }
+  return resolve(process.cwd(), outputPath);
+}
+function ensureOutputDir(outputPath) {
+  const dir = dirname(outputPath);
+  ensureDir(dir);
+}
+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 normalizePageUrl(url) {
+  try {
+    const urlObj = new URL(url);
+    return urlObj.host + urlObj.pathname;
+  } catch {
+    return url;
+  }
+}
+function isDesignPageUrl(url) {
+  return /\/file\/\d+/.test(url);
+}
+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 generateMgpLink(pageUrl, nodeId, nodePath) {
+  const normalizedUrl = normalizePageUrl(pageUrl);
+  const encodedNodeId = encodeURIComponent(nodeId);
+  let link = `mgp://${normalizedUrl}?nodeId=${encodedNodeId}`;
+  if (nodePath && nodePath.length > 0) {
+    const encodedNodePath = encodeURIComponent(nodePath.join("/"));
+    link += `&nodePath=${encodedNodePath}`;
+  }
+  return link;
+}
+function formatFileSize(bytes) {
+  if (bytes < 1024) {
+    return `${bytes} \u5B57\u8282`;
+  }
+  const kb = bytes / 1024;
+  if (kb < 1024) {
+    return `${kb.toFixed(2)} KB`;
+  }
+  const mb = kb / 1024;
+  return `${mb.toFixed(2)} MB`;
+}
+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/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 LogLevel = /* @__PURE__ */ ((LogLevel2) => {
+  LogLevel2["DEBUG"] = "DEBUG";
+  LogLevel2["INFO"] = "INFO";
+  LogLevel2["WARN"] = "WARN";
+  LogLevel2["ERROR"] = "ERROR";
+  return LogLevel2;
+})(LogLevel || {});
+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((resolve2, 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);
+        resolve2(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((resolve2) => {
+      const testServer = new WebSocketServer({ port });
+      testServer.on("listening", () => {
+        testServer.close();
+        resolve2(true);
+      });
+      testServer.on("error", () => {
+        resolve2(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((resolve2) => {
+      this.wss.close(() => {
+        this.isRunning = false;
+        this.wss = null;
+        this.logger.info("Server \u5DF2\u505C\u6B62");
+        resolve2();
+      });
+    });
+  }
+  /**
+   * 获取运行状态
+   */
+  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);
+}
+export {
+  CONFIG_DIR,
+  ConnectionManager,
+  ConnectionType,
+  DEFAULT_PORT,
+  ErrorCode,
+  ErrorMessages,
+  ErrorNames,
+  HEARTBEAT_INTERVAL,
+  HEARTBEAT_TIMEOUT,
+  LOG_DIR,
+  LogLevel,
+  Logger,
+  MAX_PORT_ATTEMPTS,
+  MAX_RETRY_COUNT,
+  MGError,
+  MGServer,
+  MessageType,
+  PORT_RANGE_END,
+  PORT_RANGE_START,
+  PORT_SCAN_TIMEOUT,
+  REQUEST_TIMEOUT,
+  RETRY_INTERVALS,
+  RequestHandler,
+  SERVER_INFO_FILE,
+  SERVER_LOG_FILE,
+  SERVER_START_TIMEOUT,
+  createError,
+  createLogger,
+  createServer,
+  deleteServerInfo,
+  ensureConfigDir,
+  ensureDir,
+  ensureOutputDir,
+  extractFileId,
+  extractFileIdFromMgpLink,
+  extractFileIdFromUrl,
+  formatDuration,
+  formatFileSize,
+  formatLogTime,
+  generateId,
+  generateMgpLink,
+  getCurrentISOTime,
+  isDesignPageUrl,
+  isProcessRunning,
+  killProcess,
+  normalizePageUrl,
+  parseMgpLink,
+  readServerInfo,
+  resolveOutputPath,
+  writeServerInfo
+};
+//# sourceMappingURL=index.js.map