@hangox/mg-cli 1.0.0 → 1.0.2

package/dist/daemon-runner.js

@@ -0,0 +1,794 @@
+#!/usr/bin/env node
+
+// 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 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;
+
+// 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 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}`;
+}
+
+// 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, ...args2) {
+    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 (args2.length > 0) {
+        consoleMethod(formattedMessage, ...args2);
+      } else {
+        consoleMethod(formattedMessage);
+      }
+    }
+    if (this.options.file) {
+      try {
+        const fileMessage = args2.length > 0 ? `${formattedMessage} ${JSON.stringify(args2)}
+` : `${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, ...args2) {
+    this.log("DEBUG" /* DEBUG */, message, ...args2);
+  }
+  info(message, ...args2) {
+    this.log("INFO" /* INFO */, message, ...args2);
+  }
+  warn(message, ...args2) {
+    this.log("WARN" /* WARN */, message, ...args2);
+  }
+  error(message, ...args2) {
+    this.log("ERROR" /* ERROR */, message, ...args2);
+  }
+};
+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 port2 = await this.findAvailablePort();
+    return new Promise((resolve2, reject) => {
+      this.wss = new WebSocketServer({ port: port2 });
+      this.wss.on("listening", () => {
+        this.port = port2;
+        this.isRunning = true;
+        this.logger.info(`Server \u542F\u52A8\u6210\u529F\uFF0C\u76D1\u542C\u7AEF\u53E3: ${port2}`);
+        this.connectionManager.startHeartbeatCheck(HEARTBEAT_INTERVAL);
+        resolve2(port2);
+      });
+      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 port2 = PORT_RANGE_START; port2 <= PORT_RANGE_END; port2++) {
+      const available = await this.isPortAvailable(port2);
+      if (available) {
+        return port2;
+      }
+      this.logger.debug(`\u7AEF\u53E3 ${port2} \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(port2) {
+    return new Promise((resolve2) => {
+      const testServer = new WebSocketServer({ port: port2 });
+      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);
+}
+
+// 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(port2) {
+  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: port2 || 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;
+  }
+}
+
+// src/server/daemon-runner.ts
+var args = process.argv.slice(2);
+var port;
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === "--port" && args[i + 1]) {
+    port = parseInt(args[i + 1], 10);
+  }
+}
+startServerForeground(port).catch((error) => {
+  console.error("\u5B88\u62A4\u8FDB\u7A0B\u542F\u52A8\u5931\u8D25:", error);
+  process.exit(1);
+});
+//# sourceMappingURL=daemon-runner.js.map