@hangox/mg-cli 1.0.0

package/src/server/connection-manager.ts

@@ -0,0 +1,211 @@
+/**
+ * 连接管理器
+ * 管理 Provider 和 Consumer 的 WebSocket 连接
+ */
+
+import type { WebSocket } from 'ws'
+import { ConnectionType, HEARTBEAT_TIMEOUT } from '../shared/constants.js'
+import type { ConnectionInfo } from '../shared/types.js'
+import { generateId } from '../shared/utils.js'
+import { Logger } from './logger.js'
+
+/** 带连接信息的 WebSocket */
+export interface ManagedWebSocket extends WebSocket {
+  /** 连接 ID */
+  connectionId: string
+  /** 连接信息 */
+  connectionInfo: ConnectionInfo
+  /** 是否存活 */
+  isAlive: boolean
+}
+
+/**
+ * 连接管理器
+ */
+export class ConnectionManager {
+  private logger: Logger
+
+  /** Provider 连接（按页面 URL 索引） */
+  private providers = new Map<string, ManagedWebSocket>()
+
+  /** Consumer 连接 */
+  private consumers = new Map<string, ManagedWebSocket>()
+
+  /** 所有连接（按 ID 索引） */
+  private allConnections = new Map<string, ManagedWebSocket>()
+
+  /** 心跳检查定时器 */
+  private heartbeatTimer: NodeJS.Timeout | null = null
+
+  constructor(logger: Logger) {
+    this.logger = logger
+  }
+
+  /**
+   * 启动心跳检查
+   */
+  startHeartbeatCheck(interval: number = 30000): void {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer)
+    }
+
+    this.heartbeatTimer = setInterval(() => {
+      this.checkHeartbeats()
+    }, interval)
+  }
+
+  /**
+   * 停止心跳检查
+   */
+  stopHeartbeatCheck(): void {
+    if (this.heartbeatTimer) {
+      clearInterval(this.heartbeatTimer)
+      this.heartbeatTimer = null
+    }
+  }
+
+  /**
+   * 检查所有连接的心跳
+   */
+  private checkHeartbeats(): void {
+    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(`连接 ${id} 心跳超时，关闭连接`)
+        this.removeConnection(ws)
+        ws.terminate()
+      }
+    }
+  }
+
+  /**
+   * 添加连接
+   */
+  addConnection(
+    ws: WebSocket,
+    type: ConnectionType,
+    pageUrl?: string,
+    pageId?: string
+  ): ManagedWebSocket {
+    const connectionId = generateId()
+    const now = new Date()
+
+    const connectionInfo: ConnectionInfo = {
+      id: connectionId,
+      type,
+      pageUrl,
+      pageId,
+      connectedAt: now,
+      lastActiveAt: now,
+    }
+
+    const managedWs = ws as ManagedWebSocket
+    managedWs.connectionId = connectionId
+    managedWs.connectionInfo = connectionInfo
+    managedWs.isAlive = true
+
+    this.allConnections.set(connectionId, managedWs)
+
+    if (type === ConnectionType.PROVIDER && pageUrl) {
+      // 如果已有同页面的连接，先移除旧的
+      const existing = this.providers.get(pageUrl)
+      if (existing) {
+        this.logger.info(`页面 ${pageUrl} 已有连接，替换为新连接`)
+        this.removeConnection(existing)
+        existing.close()
+      }
+      this.providers.set(pageUrl, managedWs)
+      this.logger.info(`Provider 连接: ${pageUrl}`)
+    } else if (type === ConnectionType.CONSUMER) {
+      this.consumers.set(connectionId, managedWs)
+      this.logger.info(`Consumer 连接: ${connectionId}`)
+    }
+
+    return managedWs
+  }
+
+  /**
+   * 移除连接
+   */
+  removeConnection(ws: ManagedWebSocket): void {
+    const { connectionId, connectionInfo } = ws
+
+    this.allConnections.delete(connectionId)
+
+    if (connectionInfo.type === ConnectionType.PROVIDER && connectionInfo.pageUrl) {
+      this.providers.delete(connectionInfo.pageUrl)
+      this.logger.info(`Provider 断开: ${connectionInfo.pageUrl}`)
+    } else if (connectionInfo.type === ConnectionType.CONSUMER) {
+      this.consumers.delete(connectionId)
+      this.logger.info(`Consumer 断开: ${connectionId}`)
+    }
+  }
+
+  /**
+   * 更新连接活跃时间
+   */
+  updateLastActive(ws: ManagedWebSocket): void {
+    ws.connectionInfo.lastActiveAt = new Date()
+    ws.isAlive = true
+  }
+
+  /**
+   * 根据页面 URL 查找 Provider
+   */
+  findProviderByPageUrl(pageUrl: string): ManagedWebSocket | undefined {
+    return this.providers.get(pageUrl)
+  }
+
+  /**
+   * 获取第一个可用的 Provider
+   */
+  getFirstProvider(): ManagedWebSocket | undefined {
+    const iterator = this.providers.values()
+    const first = iterator.next()
+    return first.value
+  }
+
+  /**
+   * 获取所有 Provider 信息
+   */
+  getAllProviders(): ConnectionInfo[] {
+    return Array.from(this.providers.values()).map((ws) => ws.connectionInfo)
+  }
+
+  /**
+   * 获取连接统计
+   */
+  getStats(): { providers: number; consumers: number; total: number } {
+    return {
+      providers: this.providers.size,
+      consumers: this.consumers.size,
+      total: this.allConnections.size,
+    }
+  }
+
+  /**
+   * 获取所有已连接的页面 URL
+   */
+  getConnectedPageUrls(): string[] {
+    return Array.from(this.providers.keys())
+  }
+
+  /**
+   * 关闭所有连接
+   */
+  closeAll(): void {
+    this.stopHeartbeatCheck()
+
+    for (const ws of this.allConnections.values()) {
+      ws.close()
+    }
+
+    this.providers.clear()
+    this.consumers.clear()
+    this.allConnections.clear()
+  }
+}

package/src/server/daemon-runner.ts

@@ -0,0 +1,22 @@
+/**
+ * 守护进程启动脚本
+ * 这个脚本被 daemon.ts 作为子进程启动
+ */
+
+import { startServerForeground } from './daemon.js'
+
+// 解析命令行参数
+const args = process.argv.slice(2)
+let port: number | undefined
+
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === '--port' && args[i + 1]) {
+    port = parseInt(args[i + 1], 10)
+  }
+}
+
+// 启动 Server
+startServerForeground(port).catch((error) => {
+  console.error('守护进程启动失败:', error)
+  process.exit(1)
+})

package/src/server/daemon.ts

@@ -0,0 +1,211 @@
+/**
+ * 守护进程管理
+ */
+
+import { spawn, ChildProcess } from 'node:child_process'
+import { fileURLToPath } from 'node:url'
+import { dirname, join } from 'node:path'
+import {
+  readServerInfo,
+  writeServerInfo,
+  deleteServerInfo,
+  isProcessRunning,
+  killProcess,
+  ensureConfigDir,
+  getCurrentISOTime,
+  formatDuration,
+} from '../shared/utils.js'
+import { SERVER_START_TIMEOUT, DEFAULT_PORT } from '../shared/constants.js'
+import { ErrorCode, MGError } from '../shared/errors.js'
+import type { ServerInfo } from '../shared/types.js'
+import { createServer } from './websocket-server.js'
+import { createLogger, LogLevel } from './logger.js'
+
+/**
+ * 检查 Server 是否在运行
+ */
+export function isServerRunning(): { running: boolean; info: ServerInfo | null } {
+  const info = readServerInfo()
+
+  if (!info) {
+    return { running: false, info: null }
+  }
+
+  // 检查进程是否存在
+  if (!isProcessRunning(info.pid)) {
+    // 进程不存在，清理旧文件
+    deleteServerInfo()
+    return { running: false, info: null }
+  }
+
+  return { running: true, info }
+}
+
+/**
+ * 启动 Server（前台模式）
+ */
+export async function startServerForeground(port?: number): Promise<void> {
+  const { running, info } = isServerRunning()
+
+  if (running && info) {
+    throw new MGError(
+      ErrorCode.SERVER_ALREADY_RUNNING,
+      `Server 已在运行中 (PID: ${info.pid}, 端口: ${info.port})`
+    )
+  }
+
+  ensureConfigDir()
+
+  const logger = createLogger({
+    console: true,
+    file: true,
+    minLevel: LogLevel.INFO,
+  })
+
+  const server = createServer({
+    port: port || DEFAULT_PORT,
+    logger,
+  })
+
+  // 注册信号处理
+  const cleanup = async () => {
+    console.log('\n正在停止 Server...')
+    await server.stop()
+    deleteServerInfo()
+    process.exit(0)
+  }
+
+  process.on('SIGINT', cleanup)
+  process.on('SIGTERM', cleanup)
+
+  try {
+    const actualPort = await server.start()
+
+    // 写入 Server 信息
+    writeServerInfo({
+      port: actualPort,
+      pid: process.pid,
+      startedAt: getCurrentISOTime(),
+    })
+
+    console.log(`\nMG Server 启动成功`)
+    console.log(`监听端口: ${actualPort}`)
+    console.log(`进程 PID: ${process.pid}`)
+    console.log(`运行模式: 前台`)
+    console.log(`\n按 Ctrl+C 停止...`)
+  } catch (error) {
+    logger.error('Server 启动失败:', error)
+    throw error
+  }
+}
+
+/**
+ * 启动 Server（守护进程模式）
+ */
+export async function startServerDaemon(port?: number): Promise<ServerInfo> {
+  const { running, info } = isServerRunning()
+
+  if (running && info) {
+    throw new MGError(
+      ErrorCode.SERVER_ALREADY_RUNNING,
+      `Server 已在运行中 (PID: ${info.pid}, 端口: ${info.port})`
+    )
+  }
+
+  ensureConfigDir()
+
+  // 获取当前模块的路径
+  const currentFile = fileURLToPath(import.meta.url)
+  const currentDir = dirname(currentFile)
+  const serverScript = join(currentDir, 'daemon-runner.js')
+
+  // 启动子进程
+  const args = ['--foreground']
+  if (port) {
+    args.push('--port', String(port))
+  }
+
+  const child: ChildProcess = spawn(process.execPath, [serverScript, ...args], {
+    detached: true,
+    stdio: 'ignore',
+    env: {
+      ...process.env,
+      MG_DAEMON: '1',
+    },
+  })
+
+  child.unref()
+
+  // 等待 Server 启动
+  const startTime = Date.now()
+  while (Date.now() - startTime < SERVER_START_TIMEOUT) {
+    await new Promise((resolve) => setTimeout(resolve, 200))
+
+    const { running, info } = isServerRunning()
+    if (running && info) {
+      return info
+    }
+  }
+
+  throw new MGError(ErrorCode.SERVER_START_FAILED, 'Server 启动超时')
+}
+
+/**
+ * 停止 Server
+ */
+export function stopServer(): { stopped: boolean; info: ServerInfo | null } {
+  const { running, info } = isServerRunning()
+
+  if (!running || !info) {
+    return { stopped: false, info: null }
+  }
+
+  // 终止进程
+  const killed = killProcess(info.pid)
+
+  if (killed) {
+    deleteServerInfo()
+  }
+
+  return { stopped: killed, info }
+}
+
+/**
+ * 重启 Server
+ */
+export async function restartServer(port?: number): Promise<ServerInfo> {
+  const { info: oldInfo } = stopServer()
+
+  // 等待旧进程完全停止
+  await new Promise((resolve) => setTimeout(resolve, 500))
+
+  // 启动新 Server
+  return startServerDaemon(port || oldInfo?.port)
+}
+
+/**
+ * 获取 Server 状态
+ */
+export function getServerStatus(): {
+  running: boolean
+  port?: number
+  pid?: number
+  startedAt?: string
+  uptime?: string
+} {
+  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),
+  }
+}

package/src/server/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Server 模块导出
+ */
+
+export { MGServer, createServer, type ServerOptions } from './websocket-server.js'
+export { ConnectionManager, type ManagedWebSocket } from './connection-manager.js'
+export { RequestHandler } from './request-handler.js'
+export { Logger, createLogger, LogLevel, type LoggerOptions } from './logger.js'

package/src/server/logger.ts

@@ -0,0 +1,117 @@
+/**
+ * 日志模块
+ */
+
+import { appendFileSync, existsSync, mkdirSync } from 'node:fs'
+import { dirname } from 'node:path'
+import { SERVER_LOG_FILE } from '../shared/constants.js'
+import { formatLogTime } from '../shared/utils.js'
+
+export enum LogLevel {
+  DEBUG = 'DEBUG',
+  INFO = 'INFO',
+  WARN = 'WARN',
+  ERROR = 'ERROR',
+}
+
+export interface LoggerOptions {
+  /** 是否输出到控制台 */
+  console?: boolean
+  /** 是否输出到文件 */
+  file?: boolean
+  /** 日志文件路径 */
+  filePath?: string
+  /** 最小日志级别 */
+  minLevel?: LogLevel
+}
+
+const levelPriority: Record<LogLevel, number> = {
+  [LogLevel.DEBUG]: 0,
+  [LogLevel.INFO]: 1,
+  [LogLevel.WARN]: 2,
+  [LogLevel.ERROR]: 3,
+}
+
+/**
+ * 日志记录器
+ */
+export class Logger {
+  private options: Required<LoggerOptions>
+
+  constructor(options: LoggerOptions = {}) {
+    this.options = {
+      console: options.console ?? true,
+      file: options.file ?? false,
+      filePath: options.filePath ?? SERVER_LOG_FILE,
+      minLevel: options.minLevel ?? LogLevel.INFO,
+    }
+
+    // 确保日志目录存在
+    if (this.options.file) {
+      const dir = dirname(this.options.filePath)
+      if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true })
+      }
+    }
+  }
+
+  /**
+   * 记录日志
+   */
+  private log(level: LogLevel, message: string, ...args: unknown[]): void {
+    // 检查日志级别
+    if (levelPriority[level] < levelPriority[this.options.minLevel]) {
+      return
+    }
+
+    const timestamp = formatLogTime()
+    const formattedMessage = `[${timestamp}] [${level}] ${message}`
+
+    // 输出到控制台
+    if (this.options.console) {
+      const consoleMethod = level === LogLevel.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)}\n`
+            : `${formattedMessage}\n`
+        appendFileSync(this.options.filePath, fileMessage)
+      } catch (error) {
+        // 文件写入失败时静默处理
+        if (this.options.console) {
+          console.error('日志文件写入失败:', error)
+        }
+      }
+    }
+  }
+
+  debug(message: string, ...args: unknown[]): void {
+    this.log(LogLevel.DEBUG, message, ...args)
+  }
+
+  info(message: string, ...args: unknown[]): void {
+    this.log(LogLevel.INFO, message, ...args)
+  }
+
+  warn(message: string, ...args: unknown[]): void {
+    this.log(LogLevel.WARN, message, ...args)
+  }
+
+  error(message: string, ...args: unknown[]): void {
+    this.log(LogLevel.ERROR, message, ...args)
+  }
+}
+
+/** 创建默认日志记录器 */
+export function createLogger(options?: LoggerOptions): Logger {
+  return new Logger(options)
+}