@hangox/mg-cli 1.0.0 → 1.0.2

package/src/cli/commands/server.ts

@@ -1,130 +0,0 @@
-/**
- * Server 管理命令
- */
-
-import { Command } from 'commander'
-import {
-  startServerForeground,
-  startServerDaemon,
-  stopServer,
-  restartServer,
-  getServerStatus,
-} from '../../server/daemon.js'
-
-/**
- * 创建 server 命令组
- */
-export function createServerCommand(): Command {
-  const serverCmd = new Command('server')
-    .description('Server 管理命令')
-
-  // server start
-  serverCmd
-    .command('start')
-    .description('启动 MG Server')
-    .option('--port <number>', '指定启动端口', (value) => parseInt(value, 10))
-    .option('--foreground', '前台模式运行（不作为守护进程）', false)
-    .action(async (options) => {
-      try {
-        if (options.foreground) {
-          await startServerForeground(options.port)
-        } else {
-          const info = await startServerDaemon(options.port)
-          console.log('MG Server 启动成功')
-          console.log(`监听端口: ${info.port}`)
-          console.log(`进程 PID: ${info.pid}`)
-          console.log(`运行模式: 守护进程`)
-        }
-      } catch (error: any) {
-        console.error(`错误: ${error.message}`)
-        process.exit(1)
-      }
-    })
-
-  // server stop
-  serverCmd
-    .command('stop')
-    .description('停止 MG Server')
-    .action(() => {
-      try {
-        const { stopped, info } = stopServer()
-
-        if (stopped && info) {
-          console.log('MG Server 已停止')
-          console.log(`PID: ${info.pid}`)
-
-          // 计算运行时长
-          const uptimeMs = Date.now() - new Date(info.startedAt).getTime()
-          const seconds = Math.floor(uptimeMs / 1000)
-          const minutes = Math.floor(seconds / 60)
-          const hours = Math.floor(minutes / 60)
-
-          let uptime = ''
-          if (hours > 0) {
-            uptime = `${hours} 小时 ${minutes % 60} 分钟`
-          } else if (minutes > 0) {
-            uptime = `${minutes} 分钟 ${seconds % 60} 秒`
-          } else {
-            uptime = `${seconds} 秒`
-          }
-
-          console.log(`运行时长: ${uptime}`)
-        } else {
-          console.log('MG Server 未运行')
-        }
-      } catch (error: any) {
-        console.error(`错误: ${error.message}`)
-        process.exit(1)
-      }
-    })
-
-  // server restart
-  serverCmd
-    .command('restart')
-    .description('重启 MG Server')
-    .option('--port <number>', '重启后使用的端口', (value) => parseInt(value, 10))
-    .action(async (options) => {
-      try {
-        const status = getServerStatus()
-
-        if (status.running) {
-          console.log(`正在停止 MG Server (PID: ${status.pid})...`)
-        }
-
-        const info = await restartServer(options.port)
-
-        console.log('MG Server 已重启')
-        console.log(`监听端口: ${info.port}`)
-        console.log(`新进程 PID: ${info.pid}`)
-      } catch (error: any) {
-        console.error(`错误: ${error.message}`)
-        process.exit(1)
-      }
-    })
-
-  // server status
-  serverCmd
-    .command('status')
-    .description('查看 Server 运行状态')
-    .action(() => {
-      try {
-        const status = getServerStatus()
-
-        if (status.running) {
-          console.log('MG Server 状态: 运行中 ✓')
-          console.log(`监听端口: ${status.port}`)
-          console.log(`进程 PID: ${status.pid}`)
-          console.log(`启动时间: ${status.startedAt}`)
-          console.log(`运行时长: ${status.uptime}`)
-        } else {
-          console.log('MG Server 状态: 未运行 ✗')
-          console.log("提示: 使用 'mg-cli server start' 启动 Server")
-        }
-      } catch (error: any) {
-        console.error(`错误: ${error.message}`)
-        process.exit(1)
-      }
-    })
-
-  return serverCmd
-}

package/src/cli/index.ts

@@ -1,33 +0,0 @@
-/**
- * MG CLI 入口
- */
-
-import { Command } from 'commander'
-import { createServerCommand } from './commands/server.js'
-import { createGetNodeByIdCommand } from './commands/get-node-by-id.js'
-import { createGetNodeByLinkCommand } from './commands/get-node-by-link.js'
-import { createGetAllNodesCommand } from './commands/get-all-nodes.js'
-import { createExportImageCommand } from './commands/export-image.js'
-import { createExecuteCodeCommand } from './commands/execute-code.js'
-import { createGetAllPagesCommand } from './commands/get-all-pages.js'
-
-const program = new Command()
-
-program
-  .name('mg-cli')
-  .description('MasterGo CLI 工具 - 用于 Claude Code 与 MasterGo 通信')
-  .version('1.0.0')
-
-// 添加 server 命令组
-program.addCommand(createServerCommand())
-
-// 添加业务命令
-program.addCommand(createGetNodeByIdCommand())
-program.addCommand(createGetNodeByLinkCommand())
-program.addCommand(createGetAllNodesCommand())
-program.addCommand(createExportImageCommand())
-program.addCommand(createExecuteCodeCommand())
-program.addCommand(createGetAllPagesCommand())
-
-// 解析命令行参数
-program.parse()

package/src/index.ts

@@ -1,9 +0,0 @@
-/**
- * MG CLI 包入口
- */
-
-// 导出共享模块
-export * from './shared/index.js'
-
-// 导出 Server 模块
-export * from './server/index.js'

package/src/server/connection-manager.ts

@@ -1,211 +0,0 @@
-/**
- * 连接管理器
- * 管理 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

@@ -1,22 +0,0 @@
-/**
- * 守护进程启动脚本
- * 这个脚本被 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

@@ -1,211 +0,0 @@
-/**
- * 守护进程管理
- */
-
-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

@@ -1,8 +0,0 @@
-/**
- * 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'