@ranger1/dx 0.1.76 → 0.1.78

package/lib/cli/commands/stack.js

@@ -1,245 +1,240 @@
-#!/usr/bin/env node
-
-/**
- * PM2 开发服务栈交互式管理器
- * 启动 backend、front、admin 三个服务，并提供交互式命令界面
- *
- * 使用方法：
- *   dx dev stack
- *
- * 可用命令：
- *   r <service>   - 重启服务 (r backend / r front / r admin)
- *   l <service>   - 查看日志 (l backend / l front / l admin)
- *   s <service>   - 停止服务 (s backend / s front / s admin)
- *   list          - 显示服务状态
- *   monit         - 打开实时监控
- *   q / quit      - 停止所有服务并退出
- *   help          - 显示帮助信息
- */
-
 import { exec, spawn } from 'node:child_process'
 import { promisify } from 'node:util'
 import readline from 'node:readline'
-import { join } from 'node:path'
-import { existsSync, rmSync, readdirSync, unlinkSync, mkdirSync } from 'node:fs'
+import { isAbsolute, join } from 'node:path'
+import { existsSync, mkdirSync, readdirSync, rmSync, unlinkSync } from 'node:fs'
 import { homedir } from 'node:os'
 import { logger } from '../../logger.js'
+import { execManager } from '../../exec.js'
 
 const execPromise = promisify(exec)
 
+const DEFAULT_SERVICES = ['backend', 'front', 'admin']
+const DEFAULT_PRE_FLIGHT = {
+  pm2Reset: true,
+  killPorts: [3000, 3001, 3500],
+  forcePortCleanup: true,
+  cleanPaths: [
+    'apps/front/.next',
+    'dist/front',
+    'apps/front/.eslintcache',
+    'apps/admin-front/node_modules/.vite',
+    'dist/admin-front',
+    'apps/admin-front/.eslintcache',
+  ],
+  cleanTsBuildInfo: true,
+  cleanTsBuildInfoDirs: ['apps/front', 'apps/admin-front'],
+}
+
 class PM2StackManager {
-  constructor() {
-    this.configPath = join(process.cwd(), 'ecosystem.config.cjs')
-    this.services = ['backend', 'front', 'admin']
+  constructor(options = {}) {
+    this.projectRoot = process.cwd()
+    this.pm2Bin = String(options.pm2Bin || 'pnpm pm2').trim()
+
+    const ecosystemConfig = options.ecosystemConfig || 'ecosystem.config.cjs'
+    this.configPath = this.resolvePath(ecosystemConfig)
+
+    this.services = Array.isArray(options.services) && options.services.length > 0
+      ? options.services.map(item => String(item).trim()).filter(Boolean)
+      : [...DEFAULT_SERVICES]
+
+    const incomingPreflight = options.preflight && typeof options.preflight === 'object'
+      ? options.preflight
+      : {}
+
+    this.preflight = {
+      pm2Reset: incomingPreflight.pm2Reset ?? DEFAULT_PRE_FLIGHT.pm2Reset,
+      killPorts: this.normalizePorts(incomingPreflight.killPorts, DEFAULT_PRE_FLIGHT.killPorts),
+      forcePortCleanup:
+        incomingPreflight.forcePortCleanup ?? DEFAULT_PRE_FLIGHT.forcePortCleanup,
+      cleanPaths: this.normalizeStringArray(
+        incomingPreflight.cleanPaths,
+        DEFAULT_PRE_FLIGHT.cleanPaths,
+      ),
+      cleanTsBuildInfo:
+        incomingPreflight.cleanTsBuildInfo ?? DEFAULT_PRE_FLIGHT.cleanTsBuildInfo,
+      cleanTsBuildInfoDirs: this.normalizeStringArray(
+        incomingPreflight.cleanTsBuildInfoDirs,
+        DEFAULT_PRE_FLIGHT.cleanTsBuildInfoDirs,
+      ),
+    }
+
     this.isRunning = false
   }
 
+  resolvePath(targetPath) {
+    if (isAbsolute(targetPath)) return targetPath
+    return join(this.projectRoot, targetPath)
+  }
+
+  normalizePorts(input, fallback) {
+    const source = Array.isArray(input) ? input : fallback
+    return source
+      .map(port => Number(port))
+      .filter(port => Number.isFinite(port) && port > 0)
+  }
+
+  normalizeStringArray(input, fallback) {
+    const source = Array.isArray(input) ? input : fallback
+    return source.map(item => String(item).trim()).filter(Boolean)
+  }
+
   async start() {
-    // 检查配置文件
     if (!existsSync(this.configPath)) {
-      logger.error('未找到 ecosystem.config.cjs 配置文件')
-      logger.info('请确保配置文件存在于项目根目录')
-      process.exit(1)
+      logger.error(`未找到 PM2 配置文件: ${this.configPath}`)
+      logger.info('请在 commands.json 的 start.stack.stack.ecosystemConfig 中配置正确路径')
+      throw new Error('PM2 配置文件不存在')
     }
 
-    logger.step('启动 PM2 开发服务栈')
+    logger.step('启动 PM2 交互式服务栈')
 
-    try {
-      // 启动前清理 PM2 状态（确保干净启动）
-      await this.preparePM2State()
+    await this.prepareBeforeStart()
+    await this.pm2Start()
+    this.isRunning = true
+    await this.showStatus()
+    this.startInteractive()
+  }
 
-      // 清理前端缓存
-      this.cleanFrontendCache()
+  async prepareBeforeStart() {
+    logger.info('正在执行 stack 启动前检查...')
 
-      // 启动 PM2 服务
-      await this.pm2Start()
-      this.isRunning = true
+    if (this.preflight.pm2Reset) {
+      await this.resetPm2State()
+    }
 
-      // 显示初始状态
-      await this.showStatus()
+    if (this.preflight.killPorts.length > 0) {
+      logger.info(`正在清理端口占用: ${this.preflight.killPorts.join(', ')}`)
+      await execManager.handlePortConflicts(
+        this.preflight.killPorts,
+        Boolean(this.preflight.forcePortCleanup),
+      )
+    }
 
-      // 启动交互式命令行
-      this.startInteractive()
-    } catch (error) {
-      logger.error('启动失败')
-      logger.error(error.message)
-      process.exit(1)
+    this.cleanConfiguredPaths()
+
+    if (this.preflight.cleanTsBuildInfo) {
+      this.cleanTsBuildInfoFiles()
     }
   }
 
-  /**
-   * 准备 PM2 状态
-   * 启动前清理 PM2 状态，确保干净启动
-   */
-  async preparePM2State() {
-    logger.info('正在准备 PM2 环境...')
-    await this.fixPM2State()
-  }
+  async resetPm2State() {
+    logger.info('正在重置 PM2 状态...')
 
-  /**
-   * 清理 PM2 状态
-   * 停止守护进程并清理状态文件，确保干净启动
-   */
-  async fixPM2State() {
     try {
-      // 1. 停止 PM2 守护进程
-      logger.info('正在停止 PM2 守护进程...')
       try {
-        // 先尝试删除所有进程
-        try {
-          await execPromise('pnpm pm2 delete all', { timeout: 5000 })
-        } catch {
-          // 忽略删除失败
-        }
-
-        // 然后停止守护进程
-        await execPromise('pnpm pm2 kill', { timeout: 5000 })
-        logger.success('PM2 守护进程已停止')
-      } catch (killError) {
-        // 如果 kill 失败（可能已经停止），继续执行清理
-        logger.info('PM2 守护进程可能已停止')
+        await this.pm2Exec('delete all', { timeout: 5000 })
+      } catch {
+        // ignore
       }
 
-      // 2. 清理 PM2 状态文件
-      logger.info('正在清理 PM2 状态文件...')
-      const pm2Home = join(homedir(), '.pm2')
-      const stateFiles = ['dump.pm2', 'pm2.log', 'pm2.pid']
-
-      for (const file of stateFiles) {
-        const filePath = join(pm2Home, file)
-        try {
-          if (existsSync(filePath)) {
-            rmSync(filePath, { force: true })
-            logger.success(`已清理: ${file}`)
-          }
-        } catch (error) {
-          // 忽略清理失败，继续执行
-          logger.warn(`清理 ${file} 失败: ${error.message}`)
-        }
-      }
+      await this.pm2Exec('kill', { timeout: 5000 })
+      logger.success('PM2 守护进程已停止')
+    } catch {
+      logger.info('PM2 守护进程可能已停止')
+    }
+
+    const pm2Home = join(homedir(), '.pm2')
+    const stateFiles = ['dump.pm2', 'pm2.log', 'pm2.pid']
 
-      // 3. 确保日志目录存在
-      const projectRoot = process.cwd()
-      const logDir = join(projectRoot, 'logs', 'pm2')
-      if (!existsSync(logDir)) {
-        mkdirSync(logDir, { recursive: true })
-        logger.success('已创建日志目录')
+    for (const file of stateFiles) {
+      const filePath = join(pm2Home, file)
+      try {
+        if (existsSync(filePath)) {
+          rmSync(filePath, { force: true })
+          logger.success(`已清理 PM2 文件: ${file}`)
+        }
+      } catch (error) {
+        logger.warn(`清理 PM2 文件失败 (${file}): ${error.message}`)
       }
+    }
 
-      logger.success('PM2 环境准备完成')
-    } catch (error) {
-      logger.warn(`准备 PM2 环境时出现警告: ${error.message}`)
-      // 不抛出错误，继续尝试启动
+    const logDir = join(this.projectRoot, 'logs', 'pm2')
+    if (!existsSync(logDir)) {
+      mkdirSync(logDir, { recursive: true })
+      logger.success('已创建 PM2 日志目录')
     }
   }
 
-  /**
-   * 清理前端缓存
-   * 清理 Next.js 用户端和 Vite 管理后台的构建缓存
-   * 注意：此方法使用同步文件系统 API，无需 async/await
-   */
-  cleanFrontendCache() {
-    logger.info('正在清理前端缓存...')
-
-    const projectRoot = process.cwd()
-    const cachePaths = [
-      // Next.js 用户端 (apps/front)
-      { path: join(projectRoot, 'apps/front/.next'), type: 'dir', name: 'Next.js 构建缓存' },
-      { path: join(projectRoot, 'dist/front'), type: 'dir', name: 'Next.js 构建输出' },
-      { path: join(projectRoot, 'apps/front/.eslintcache'), type: 'file', name: 'ESLint 缓存' },
-      // Vite 管理后台 (apps/admin-front)
-      {
-        path: join(projectRoot, 'apps/admin-front/node_modules/.vite'),
-        type: 'dir',
-        name: 'Vite 开发服务器缓存',
-      },
-      { path: join(projectRoot, 'dist/admin-front'), type: 'dir', name: '管理后台构建输出' },
-      {
-        path: join(projectRoot, 'apps/admin-front/.eslintcache'),
-        type: 'file',
-        name: 'ESLint 缓存',
-      },
-    ]
-
-    // 清理目录和文件
-    for (const { path: cachePath, type, name } of cachePaths) {
+  cleanConfiguredPaths() {
+    if (this.preflight.cleanPaths.length === 0) return
+
+    logger.info('正在清理缓存路径...')
+
+    for (const rawPath of this.preflight.cleanPaths) {
+      const targetPath = this.resolvePath(rawPath)
       try {
-        if (existsSync(cachePath)) {
-          if (type === 'dir') {
-            rmSync(cachePath, { recursive: true, force: true })
-            logger.success(`已清理: ${name}`)
-          } else {
-            unlinkSync(cachePath)
-            logger.success(`已清理: ${name}`)
-          }
+        if (existsSync(targetPath)) {
+          rmSync(targetPath, { recursive: true, force: true })
+          logger.success(`已清理: ${rawPath}`)
         }
       } catch (error) {
-        logger.warn(`清理 ${name} 失败: ${error.message}`)
+        logger.warn(`清理失败 (${rawPath}): ${error.message}`)
       }
     }
+  }
+
+  cleanTsBuildInfoFiles() {
+    if (this.preflight.cleanTsBuildInfoDirs.length === 0) return
 
-    // 清理 TypeScript 构建信息文件 (*.tsbuildinfo)
-    const tsBuildInfoPaths = [
-      join(projectRoot, 'apps/front'),
-      join(projectRoot, 'apps/admin-front'),
-    ]
+    logger.info('正在清理 TypeScript 构建缓存...')
+
+    for (const rawDirPath of this.preflight.cleanTsBuildInfoDirs) {
+      const dirPath = this.resolvePath(rawDirPath)
+      if (!existsSync(dirPath)) continue
 
-    for (const dirPath of tsBuildInfoPaths) {
       try {
-        if (existsSync(dirPath)) {
-          const files = readdirSync(dirPath)
-          for (const file of files) {
-            if (file.endsWith('.tsbuildinfo')) {
-              const filePath = join(dirPath, file)
-              try {
-                unlinkSync(filePath)
-                logger.success(`已清理: TypeScript 构建信息 (${file})`)
-              } catch (error) {
-                logger.warn(`清理 ${file} 失败: ${error.message}`)
-              }
-            }
+        const files = readdirSync(dirPath)
+        for (const file of files) {
+          if (!file.endsWith('.tsbuildinfo')) continue
+          const filePath = join(dirPath, file)
+          try {
+            unlinkSync(filePath)
+            logger.success(`已清理: ${join(rawDirPath, file)}`)
+          } catch (error) {
+            logger.warn(`清理失败 (${join(rawDirPath, file)}): ${error.message}`)
           }
         }
       } catch (error) {
-        // 忽略目录不存在的错误
+        logger.warn(`读取目录失败 (${rawDirPath}): ${error.message}`)
       }
     }
+  }
 
-    logger.success('前端缓存清理完成')
+  async pm2Exec(args, options = {}) {
+    return execPromise(`${this.pm2Bin} ${args}`, options)
   }
 
   async pm2Start() {
-    logger.info('正在启动服务...')
-    try {
-      const { stderr } = await execPromise(`pnpm pm2 start ${this.configPath}`, { timeout: 30000 })
-      if (stderr && !stderr.includes('[PM2]')) {
-        logger.warn(stderr)
-      }
-      logger.success('服务启动成功')
-    } catch (error) {
-      throw new Error(`启动失败: ${error.message || error.stderr || error.stdout || '未知错误'}`)
+    logger.info('正在启动 PM2 服务...')
+    const { stderr } = await this.pm2Exec(`start "${this.configPath}"`, { timeout: 30000 })
+    if (stderr && !stderr.includes('[PM2]')) {
+      logger.warn(stderr)
     }
+    logger.success('服务启动成功')
   }
 
   async showStatus() {
     try {
-      const { stdout } = await execPromise('pnpm pm2 list', { timeout: 5000 })
+      const { stdout } = await this.pm2Exec('list', { timeout: 5000 })
       console.log(`\n${stdout}`)
     } catch (error) {
       logger.error(`获取状态失败: ${error.message}`)
     }
   }
 
+  ensureKnownService(service) {
+    if (this.services.includes(service)) return true
+    logger.error(`未知服务: ${service}`)
+    logger.info(`可用服务: ${this.services.join(', ')}`)
+    return false
+  }
+
   async restart(service) {
-    if (!this.services.includes(service)) {
-      logger.error(`未知服务: ${service}`)
-      logger.info(`可用服务: ${this.services.join(', ')}`)
-      return
-    }
+    if (!this.ensureKnownService(service)) return
 
     logger.info(`正在重启 ${service}...`)
     try {
-      await execPromise(`pnpm pm2 restart ${service}`)
+      await this.pm2Exec(`restart ${service}`)
       logger.success(`${service} 重启成功`)
       await this.showStatus()
     } catch (error) {
@@ -248,21 +243,15 @@ class PM2StackManager {
   }
 
   async logs(service) {
-    if (!this.services.includes(service)) {
-      logger.error(`未知服务: ${service}`)
-      logger.info(`可用服务: ${this.services.join(', ')}`)
-      return
-    }
+    if (!this.ensureKnownService(service)) return
 
     logger.info(`查看 ${service} 日志（按 Ctrl+C 返回）...`)
     console.log('')
 
-    // 使用 spawn 以便实时显示日志
-    const pm2Logs = spawn('pnpm', ['pm2', 'logs', service], {
+    const pm2Logs = spawn('bash', ['-lc', `${this.pm2Bin} logs ${service}`], {
       stdio: 'inherit',
     })
 
-    // 等待用户按 Ctrl+C
     await new Promise(resolve => {
       pm2Logs.on('exit', resolve)
     })
@@ -272,16 +261,12 @@ class PM2StackManager {
   }
 
   async stop(service) {
-    if (!this.services.includes(service)) {
-      logger.error(`未知服务: ${service}`)
-      logger.info(`可用服务: ${this.services.join(', ')}`)
-      return
-    }
+    if (!this.ensureKnownService(service)) return
 
     logger.info(`正在停止 ${service}...`)
     try {
-      await execPromise(`pnpm pm2 stop ${service}`)
-      logger.success(`${service} 已停止`)
+      await this.pm2Exec(`stop ${service}`)
+      logger.success(`${service} 停止成功`)
       await this.showStatus()
     } catch (error) {
       logger.error(`停止失败: ${error.message}`)
@@ -289,10 +274,10 @@ class PM2StackManager {
   }
 
   async monit() {
-    logger.info('启动实时监控（按 Ctrl+C 返回）...')
+    logger.info('打开 PM2 实时监控（按 q 退出）...')
     console.log('')
 
-    const pm2Monit = spawn('pnpm', ['pm2', 'monit'], {
+    const pm2Monit = spawn('bash', ['-lc', `${this.pm2Bin} monit`], {
       stdio: 'inherit',
     })
 
@@ -305,35 +290,29 @@ class PM2StackManager {
   }
 
   async stopAll() {
-    logger.info('正在停止所有服务...')
+    if (!this.isRunning) return
+
+    logger.step('正在停止所有服务...')
     try {
-      await execPromise('pnpm pm2 stop all')
-      await execPromise('pnpm pm2 delete all')
+      await this.pm2Exec('stop all')
+      await this.pm2Exec('delete all')
       logger.success('所有服务已停止')
       this.isRunning = false
     } catch (error) {
-      logger.error(`停止失败: ${error.message}`)
+      logger.error(`停止服务失败: ${error.message}`)
     }
   }
 
   showHelp() {
-    console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━')
-    console.log('🚀 服务访问链接：')
-    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━')
-    console.log('  📦 Backend (后端 API)    → http://localhost:3000')
-    console.log('  📦 API 文档 (Swagger)    → http://localhost:3000/doc')
-    console.log('  🌐 Front (用户端)        → http://localhost:3001')
-    console.log('  ⚙️  Admin (管理后台)     → http://localhost:3500')
-    console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━')
-    console.log('\n📋 可用命令：')
-    console.log('  r <service>   - 重启服务 (例: r backend)')
-    console.log('  l <service>   - 查看日志 (例: l backend)')
-    console.log('  s <service>   - 停止服务 (例: s backend)')
+    console.log('\n可用命令:')
+    console.log('  r <service>   - 重启服务')
+    console.log('  l <service>   - 查看日志')
+    console.log('  s <service>   - 停止服务')
     console.log('  list          - 显示服务状态')
     console.log('  monit         - 打开实时监控')
     console.log('  q / quit      - 停止所有服务并退出')
     console.log('  help          - 显示此帮助信息')
-    console.log('\n📦 可用服务: backend, front, admin\n')
+    console.log(`\n可用服务: ${this.services.join(', ')}\n`)
   }
 
   showPrompt() {
@@ -341,7 +320,6 @@ class PM2StackManager {
   }
 
   startInteractive() {
-    // 自动显示帮助信息和访问链接
     this.showHelp()
     this.showPrompt()
 
@@ -363,29 +341,20 @@ class PM2StackManager {
       switch (cmd.toLowerCase()) {
         case 'r':
         case 'restart':
-          if (args[0]) {
-            await this.restart(args[0])
-          } else {
-            logger.error('请指定服务名称，例如: r backend')
-          }
+          if (args[0]) await this.restart(args[0])
+          else logger.error('请指定服务名称，例如: r backend')
           break
 
         case 'l':
         case 'logs':
-          if (args[0]) {
-            await this.logs(args[0])
-          } else {
-            logger.error('请指定服务名称，例如: l backend')
-          }
-          return // logs 命令会自己处理 prompt
+          if (args[0]) await this.logs(args[0])
+          else logger.error('请指定服务名称，例如: l backend')
+          return
 
         case 's':
         case 'stop':
-          if (args[0]) {
-            await this.stop(args[0])
-          } else {
-            logger.error('请指定服务名称，例如: s backend')
-          }
+          if (args[0]) await this.stop(args[0])
+          else logger.error('请指定服务名称，例如: s backend')
           break
 
         case 'list':
@@ -396,7 +365,7 @@ class PM2StackManager {
         case 'monit':
         case 'monitor':
           await this.monit()
-          return // monit 命令会自己处理 prompt
+          return
 
         case 'q':
         case 'quit':
@@ -429,7 +398,6 @@ class PM2StackManager {
       process.exit(0)
     })
 
-    // 处理 Ctrl+C
     process.on('SIGINT', async () => {
       console.log('\n')
       await this.stopAll()
@@ -438,14 +406,7 @@ class PM2StackManager {
   }
 }
 
-// 主函数
-async function main() {
-  const manager = new PM2StackManager()
+export async function runPm2Stack(options = {}) {
+  const manager = new PM2StackManager(options)
   await manager.start()
 }
-
-main().catch(error => {
-  logger.error('启动失败')
-  logger.error(error.message)
-  process.exit(1)
-})

package/lib/cli/commands/start.js

@@ -3,12 +3,6 @@ import { logger } from '../../logger.js'
 export async function handleStart(cli, args) {
   const service = args[0] || 'dev'
 
-  // 处理 stack 子命令 - PM2 交互式管理
-  if (service === 'stack') {
-    await import('./stack.js')
-    return  // stack.js 会接管执行流程
-  }
-
   const environment = cli.determineEnvironment()
   const envKey = cli.normalizeEnvKey(environment)
 

package/lib/cli/dx-cli.js

@@ -169,7 +169,7 @@ class DxCli {
       try {
         const generateConfig = this.commands?.db?.generate
         if (!generateConfig?.command) {
-          throw new Error('未找到 db.generate 命令配置，请检查 scripts/config/commands.json')
+          throw new Error('未找到 db.generate 命令配置，请检查 dx/config/commands.json')
         }
 
         const envKey = this.normalizeEnvKey(environment)
@@ -834,6 +834,15 @@ class DxCli {
         return
       }
 
+      if (config.internal === 'pm2-stack') {
+        await withTempEnv(async () => {
+          const { runPm2Stack } = await import('./commands/stack.js')
+          const stackConfig = config.stack && typeof config.stack === 'object' ? config.stack : {}
+          await runPm2Stack(stackConfig)
+        })
+        return
+      }
+
       throw new Error(`未知 internal runner: ${config.internal}`)
     }