@icyfenix-dmla/cli 2026.4.19-954 → 2026.5.2-7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@icyfenix-dmla/cli",
-  "version": "2026.4.19-954",
+  "version": "2026.5.2-7",
   "description": "DMLA 沙箱服务命令行工具",
   "type": "module",
   "main": "src/index.js",
@@ -23,7 +23,7 @@
     "commander": "^12.1.0",
     "chalk": "^5.3.0",
     "enquirer": "^2.4.1",
-    "dockerode": "^4.0.2",
+    "dockerode": "^5.0.0",
     "express": "^4.21.2",
     "cors": "^2.8.5",
     "@icyfenix-dmla/install": "*"

package/src/commands/manage.js

@@ -66,7 +66,7 @@ export async function installImages(types, registry = 'dockerhub') {
 
   console.log()
   console.log(chalk.green('🎉 镜像安装完成'))
-  console.log(chalk.yellow('💡 提示: 运行 dmla start 启动服务'))
+  console.log(chalk.yellow('提示: 运行 dmla start 启动服务'))
 }
 
 /**
@@ -105,70 +105,6 @@ async function pullImageWithProgress(imageName) {
   })
 }
 
-/**
- * 更新所有组件
- */
-export async function updateAll(registry = 'dockerhub') {
-  console.log()
-
-  // 更新 npm 包
-  console.log(chalk.bold('📦 更新 npm 包'))
-  try {
-    console.log(chalk.gray('   执行 npm update -g @icyfenix-dmla/cli...'))
-    execSync('npm update -g @icyfenix-dmla/cli', { stdio: 'inherit' })
-    console.log(chalk.green('✅ npm 包已更新'))
-  } catch (error) {
-    console.log(chalk.yellow('⚠️ npm 包更新失败或已是最新版本'))
-  }
-
-  console.log()
-
-  // 检查并更新镜像
-  console.log(chalk.bold('🖼️  检查 Docker 镜像更新'))
-  const registryUrl = getRegistryUrl(registry)
-
-  for (const type of ['cpu', 'gpu']) {
-    const remoteImage = `${registryUrl}:${type}`
-    const localImage = type === 'gpu' ? CONFIG.imageGpu : CONFIG.imageCpu
-
-    console.log(chalk.gray(`   检查 ${type.toUpperCase()} 版本...`))
-
-    try {
-      // 检查本地镜像是否存在
-      let localImageInfo = null
-      try {
-        localImageInfo = await docker.getImage(localImage).inspect()
-      } catch {
-        // 本地镜像不存在，需要拉取
-      }
-
-      // 拉取最新镜像
-      console.log(chalk.gray(`   拉取最新 ${type.toUpperCase()} 镜像...`))
-      await pullImageWithProgress(remoteImage)
-
-      // 获取拉取的镜像信息
-      const remoteImageInfo = await docker.getImage(remoteImage).inspect()
-
-      // 比较镜像 ID
-      if (localImageInfo && localImageInfo.Id === remoteImageInfo.Id) {
-        console.log(chalk.green(`✅ ${type.toUpperCase()} 镜像已是最新版本`))
-      } else {
-        // Tag 为本地名称
-        console.log(chalk.gray(`   重命名为 ${localImage}...`))
-        const image = docker.getImage(remoteImage)
-        await image.tag({ repo: CONFIG.imageName, tag: type })
-
-        console.log(chalk.green(`✅ ${type.toUpperCase()} 镜像已更新`))
-      }
-    } catch (error) {
-      console.log(chalk.yellow(`⚠️ ${type.toUpperCase()} 镜像更新失败: ${error.message}`))
-    }
-  }
-
-  console.log()
-  console.log(chalk.green('🎉 更新完成'))
-}
-
 /**
  * 环境诊断
  */
@@ -201,7 +137,7 @@ export async function runDoctor() {
   // ───────────────────────────────────────────────────────────
   // 镜像检查
   // ───────────────────────────────────────────────────────────
-  console.log(chalk.bold('🖼️  Docker 镜像'))
+  console.log(chalk.bold('Docker 镜像'))
 
   const cpuImage = CONFIG.imageCpu
   const gpuImage = CONFIG.imageGpu
@@ -234,18 +170,73 @@ export async function runDoctor() {
   // ───────────────────────────────────────────────────────────
   // GPU 检查
   // ───────────────────────────────────────────────────────────
-  console.log(chalk.bold('🎮 GPU 驱动'))
+  console.log(chalk.bold('GPU 驱动'))
 
   try {
-    const output = execSync('nvidia-smi -L', { timeout: 5000, encoding: 'utf8' })
+    // 获取完整的 nvidia-smi 输出以解析驱动和 CUDA 版本
+    const output = execSync('nvidia-smi', { timeout: 5000, encoding: 'utf8' })
+
+    // 解析驱动版本
+    const driverMatch = output.match(/Driver Version:\s*(\d+\.\d+)/)
+    const driverVersion = driverMatch ? driverMatch[1] : null
+
+    // 解析 CUDA 兼容上限
+    const cudaMatch = output.match(/CUDA Version:\s*(\d+\.\d+)/)
+    const cudaVersion = cudaMatch ? cudaMatch[1] : null
+
     if (output.includes('GPU')) {
       console.log(chalk.green('   ✅ NVIDIA GPU 可用'))
+
+      // 显示驱动版本和 CUDA 兼容上限
+      if (driverVersion) {
+        console.log(chalk.gray(`   驱动版本: ${driverVersion}`))
+      }
+      if (cudaVersion) {
+        console.log(chalk.gray(`   CUDA 兼容上限: ${cudaVersion}`))
+      }
+
+      // GPU 镜像兼容性检查（CUDA 12.8 需要驱动 >= 570）
+      const minDriverForGpuImage = 570
+      const driverNum = parseFloat(driverVersion || '0')
+
+      // 显示 GPU 设备信息
       const lines = output.split('\n').filter(l => l.trim())
-      lines.forEach(line => console.log(chalk.gray(`   ${line.trim()}`)))
+      lines.slice(0, 20).forEach(line => {
+        if (line.includes('GPU') && !line.includes('Driver Version') && !line.includes('CUDA Version')) {
+          console.log(chalk.gray(`   ${line.trim()}`))
+        }
+      })
+
+      console.log()
+
+      // GPU 镜像兼容性诊断
+      console.log(chalk.bold('GPU 镜像兼容性'))
+
+      if (gpuExists) {
+        if (driverNum >= minDriverForGpuImage) {
+          console.log(chalk.green(`   ✅ GPU 镜像可用 (驱动 ${driverVersion} >= ${minDriverForGpuImage})`))
+        } else {
+          console.log(chalk.red(`   ❌ GPU 镜像不兼容 (驱动 ${driverVersion} < ${minDriverForGpuImage})`))
+          console.log(chalk.yellow(`   💡 CUDA 12.8 需要驱动 >= ${minDriverForGpuImage}`))
+          console.log(chalk.yellow('   解决方案：'))
+          console.log(chalk.gray('      1. 升级 NVIDIA 驱动到 570+ 版本'))
+          console.log(chalk.gray('      2. 或在前端选择 "Run on CPU" 模式'))
+          issues.push('GPU 镜像不兼容，请升级驱动或使用 CPU 模式')
+        }
+      } else if (!gpuExists) {
+        console.log(chalk.yellow('   ⚠️ GPU 镜像未安装'))
+        if (driverNum >= minDriverForGpuImage) {
+          console.log(chalk.green(`   ✅ 驱动兼容，可以安装 GPU 镜像`))
+          console.log(chalk.gray('   运行 dmla install --gpu 安装'))
+        } else {
+          console.log(chalk.yellow(`   ⚠️ 驱动 ${driverVersion} 不兼容 CUDA 12.8`))
+          console.log(chalk.yellow(`   💡 需要驱动 >= ${minDriverForGpuImage} 才能使用 GPU 镜像`))
+        }
+      }
 
       // 检查 GPU 镜像
-      if (!gpuExists) {
-        console.log(chalk.yellow('   💡 检测到 GPU，建议安装 GPU 镜像'))
+      if (!gpuExists && driverNum >= minDriverForGpuImage) {
+        console.log(chalk.yellow('   💡 检测到兼容 GPU，建议安装 GPU 镜像'))
         issues.push('运行 dmla install --gpu 安装 GPU 镜像')
       }
     } else {
@@ -261,7 +252,7 @@ export async function runDoctor() {
   // ───────────────────────────────────────────────────────────
   // 端口检查
   // ───────────────────────────────────────────────────────────
-  console.log(chalk.bold('🔌 端口可用性'))
+  console.log(chalk.bold('端口可用性'))
 
   const port = CONFIG.defaultPort
   const portAvailable = await checkPortAvailable(port)
@@ -310,11 +301,11 @@ export async function runDoctor() {
       console.log(chalk.red(`   ${i + 1}. ${issue}`))
     })
     console.log()
-    console.log(chalk.yellow('💡 请根据上述提示解决问题后再次运行 dmla doctor'))
+    console.log(chalk.yellow('请根据上述提示解决问题后再次运行 dmla doctor'))
   } else {
     console.log(chalk.bold.green('✅ 所有检查通过，环境正常'))
     console.log()
-    console.log(chalk.gray('💡 运行 dmla start 启动服务'))
+    console.log(chalk.gray('运行 dmla start 启动服务'))
   }
 }
 

package/src/commands/server.js

@@ -6,7 +6,7 @@ import Docker from 'dockerode'
 import { spawn } from 'child_process'
 import http from 'http'
 import path from 'path'
-import { fileURLToPath } from 'url'
+import { fileURLToPath, pathToFileURL } from 'url'
 import fs from 'fs'
 
 const __filename = fileURLToPath(import.meta.url)
@@ -49,6 +49,41 @@ async function checkImageExists(type) {
   }
 }
 
+/**
+ * 检查可用镜像并自动选择
+ * @returns {Object} { imageType: 'cpu'|'gpu', message: string }
+ */
+async function resolveImageType(useGpu) {
+  const cpuExists = await checkImageExists('cpu')
+  const gpuExists = await checkImageExists('gpu')
+
+  // 用户明确指定了 GPU
+  if (useGpu) {
+    if (gpuExists) {
+      return { imageType: 'gpu', message: 'GPU' }
+    }
+    // 用户想要 GPU 但 GPU 镜像不存在
+    if (cpuExists) {
+      console.log(chalk.yellow('⚠️ GPU 镜像不存在，将使用 CPU 镜像'))
+      return { imageType: 'cpu', message: 'CPU (降级)' }
+    }
+    return { imageType: null, message: '无可用镜像' }
+  }
+
+  // 用户未指定，自动选择
+  if (cpuExists) {
+    return { imageType: 'cpu', message: 'CPU' }
+  }
+
+  // CPU 镜像不存在
+  if (gpuExists) {
+    console.log(chalk.yellow('⚠️ CPU 镜像不存在，自动使用 GPU 镜像'))
+    return { imageType: 'gpu', message: 'GPU (自动)' }
+  }
+
+  return { imageType: null, message: '无可用镜像' }
+}
+
 /**
  * 检查 GPU 是否可用
  */
@@ -72,6 +107,44 @@ async function checkGPUAvailable() {
   }
 }
 
+/**
+ * 检查 GPU 驱动兼容性
+ * @returns {Promise<{compatible: boolean, driverVersion: string|null, cudaVersion: string|null}>}
+ */
+async function checkGPUDriverCompatibility() {
+  const minDriverForCuda128 = 570
+
+  try {
+    const result = await new Promise((resolve, reject) => {
+      const proc = spawn('nvidia-smi', [], { timeout: 5000 })
+      let output = ''
+      proc.stdout.on('data', (data) => output += data.toString())
+      proc.stderr.on('data', (data) => output += data.toString())
+      proc.on('close', (code) => {
+        if (code === 0) resolve(output)
+        else reject(new Error('nvidia-smi failed'))
+      })
+      proc.on('error', reject)
+    })
+
+    // 解析驱动版本
+    const driverMatch = result.match(/Driver Version:\s*(\d+\.\d+)/)
+    const driverVersion = driverMatch ? driverMatch[1] : null
+
+    // 解析 CUDA 兼容上限
+    const cudaMatch = result.match(/CUDA Version:\s*(\d+\.\d+)/)
+    const cudaVersion = cudaMatch ? cudaMatch[1] : null
+
+    // 判断兼容性
+    const driverNum = parseFloat(driverVersion || '0')
+    const compatible = driverNum >= minDriverForCuda128
+
+    return { compatible, driverVersion, cudaVersion }
+  } catch {
+    return { compatible: false, driverVersion: null, cudaVersion: null }
+  }
+}
+
 /**
  * 检查服务是否运行
  */
@@ -117,35 +190,64 @@ async function findServiceContainer() {
  * 查找服务器入口文件
  */
 function findServerPath() {
+  // 开发环境路径：packages/cli/src/commands -> ../../../local-server/src/index.js
   const serverPath = path.resolve(__dirname, '../../../local-server/src/index.js')
+  // npm 包路径：packages/cli/src/commands -> ../server/index.js
   const standaloneServerPath = path.resolve(__dirname, '../server/index.js')
 
-  return fs.existsSync(serverPath) ? serverPath :
-         fs.existsSync(standaloneServerPath) ? standaloneServerPath : null
+  // 检查 __dirname 是否正确（调试用）
+  const cliPackageRoot = path.resolve(__dirname, '../..')
+  const expectedServerDir = path.resolve(cliPackageRoot, 'src/server')
+
+  if (fs.existsSync(serverPath)) {
+    return serverPath
+  }
+
+  if (fs.existsSync(standaloneServerPath)) {
+    return standaloneServerPath
+  }
+
+  // 调试输出：显示路径信息帮助诊断
+  console.log(chalk.yellow('⚠️ 服务入口文件查找失败'))
+  console.log(chalk.gray(`   __dirname: ${__dirname}`))
+  console.log(chalk.gray(`   开发路径: ${serverPath} (${fs.existsSync(serverPath) ? '存在' : '不存在'})`))
+  console.log(chalk.gray(`   npm路径: ${standaloneServerPath} (${fs.existsSync(standaloneServerPath) ? '存在' : '不存在'})`))
+  console.log(chalk.gray(`   CLI包根目录: ${cliPackageRoot}`))
+
+  // 检查 CLI 包根目录下的文件结构
+  const srcDir = path.resolve(cliPackageRoot, 'src')
+  if (fs.existsSync(srcDir)) {
+    console.log(chalk.gray(`   src目录内容: ${fs.readdirSync(srcDir).join(', ')}`))
+    if (fs.existsSync(expectedServerDir)) {
+      console.log(chalk.gray(`   server目录内容: ${fs.readdirSync(expectedServerDir).join(', ')}`))
+    }
+  }
+
+  return null
 }
 
 /**
  * 同步启动服务（在当前进程运行，用于调试）
  * @param {number} port - 服务端口
- * @param {boolean} useGpu - 是否使用 GPU
+ * @param {boolean} useGpu - 是否使用 GPU（可选，自动检测）
  */
 export async function startServerSync(port, useGpu = false) {
   // 检查端口
   const portAvailable = await checkPortAvailable(port)
   if (!portAvailable) {
     console.log(chalk.red(`❌ 端口 ${port} 已被占用`))
-    console.log(chalk.yellow('💡 提示: 使用 --port 选项指定其他端口'))
+    console.log(chalk.yellow('提示: 使用 --port 选项指定其他端口'))
     return
   }
 
-  // 检查镜像
-  const imageType = useGpu ? 'gpu' : 'cpu'
-  const imageExists = await checkImageExists(imageType)
-  if (!imageExists) {
-    console.log(chalk.red(`❌ 镜像 ${useGpu ? CONFIG.imageGpu : CONFIG.imageCpu} 不存在`))
-    console.log(chalk.yellow('💡 提示: 运行 dmla install 安装镜像'))
+  // 智能选择镜像
+  const imageResolution = await resolveImageType(useGpu)
+  if (!imageResolution.imageType) {
+    console.log(chalk.red('❌ 无可用镜像'))
+    console.log(chalk.yellow('提示: 运行 dmla install 安装镜像'))
     return
   }
+  const resolvedUseGpu = imageResolution.imageType === 'gpu'
 
   // 检查服务是否已运行
   const alreadyRunning = await checkServiceRunning(port)
@@ -154,27 +256,46 @@ export async function startServerSync(port, useGpu = false) {
     return
   }
 
+  // GPU 驱动兼容性预检
+  if (resolvedUseGpu) {
+    const driverCheck = await checkGPUDriverCompatibility()
+    if (!driverCheck.compatible && driverCheck.driverVersion) {
+      console.log(chalk.yellow(`⚠️ GPU 驱动兼容性警告`))
+      console.log(chalk.gray(`   当前驱动: ${driverCheck.driverVersion}`))
+      console.log(chalk.gray(`   CUDA 12.8 需要: 驱动 >= 570`))
+      console.log(chalk.yellow('   解决方案：'))
+      console.log(chalk.gray('      1. 升级 NVIDIA 驾动到 570+ 版本'))
+      console.log(chalk.gray('      2. 使用 CPU 模式: dmla start'))
+      console.log()
+      console.log(chalk.gray('   继续启动 GPU 模式（可能会失败）...'))
+      console.log()
+    }
+  }
+
   // 查找服务器入口
   const actualServerPath = findServerPath()
   if (!actualServerPath) {
     console.log(chalk.red('❌ 找不到服务入口文件'))
-    console.log(chalk.yellow('💡 提示: 确保正确安装了 @icyfenix-dmla/cli'))
+    console.log(chalk.yellow('提示: 确保正确安装了 @icyfenix-dmla/cli'))
     return
   }
 
+  console.log(chalk.gray(`   镜像类型: ${imageResolution.message}`))
   console.log(chalk.gray('   同步模式启动...'))
   console.log(chalk.gray(`   服务入口: ${actualServerPath}`))
   console.log()
 
   // 设置环境变量
   process.env.PORT = port.toString()
-  process.env.USE_GPU = useGpu ? 'true' : 'false'
+  process.env.USE_GPU = resolvedUseGpu ? 'true' : 'false'
   process.env.DMLA_SYNC_MODE = 'true'  // 标记同步模式，让服务器在 import 时启动
 
   // 动态 import 服务器模块并直接运行
   // 服务器模块会在 import 时自动启动（因为入口点检测逻辑）
+  // Windows 需要将路径转换为 file:// URL 格式
   try {
-    await import(actualServerPath)
+    const serverURL = pathToFileURL(actualServerPath).href
+    await import(serverURL)
   } catch (error) {
     console.log(chalk.red(`❌ 服务启动失败: ${error.message}`))
     console.log(chalk.gray(error.stack))
@@ -189,18 +310,18 @@ export async function startServer(port, useGpu = false) {
   const portAvailable = await checkPortAvailable(port)
   if (!portAvailable) {
     console.log(chalk.red(`❌ 端口 ${port} 已被占用`))
-    console.log(chalk.yellow('💡 提示: 使用 --port 选项指定其他端口'))
+    console.log(chalk.yellow('提示: 使用 --port 选项指定其他端口'))
     return
   }
 
-  // 检查镜像
-  const imageType = useGpu ? 'gpu' : 'cpu'
-  const imageExists = await checkImageExists(imageType)
-  if (!imageExists) {
-    console.log(chalk.red(`❌ 镜像 ${useGpu ? CONFIG.imageGpu : CONFIG.imageCpu} 不存在`))
-    console.log(chalk.yellow('💡 提示: 运行 dmla install 安装镜像'))
+  // 智能选择镜像
+  const imageResolution = await resolveImageType(useGpu)
+  if (!imageResolution.imageType) {
+    console.log(chalk.red('❌ 无可用镜像'))
+    console.log(chalk.yellow('提示: 运行 dmla install 安装镜像'))
     return
   }
+  const resolvedUseGpu = imageResolution.imageType === 'gpu'
 
   // 检查服务是否已运行
   const alreadyRunning = await checkServiceRunning(port)
@@ -209,7 +330,24 @@ export async function startServer(port, useGpu = false) {
     return
   }
 
+  // GPU 驱动兼容性预检
+  if (resolvedUseGpu) {
+    const driverCheck = await checkGPUDriverCompatibility()
+    if (!driverCheck.compatible && driverCheck.driverVersion) {
+      console.log(chalk.yellow(`⚠️ GPU 驱动兼容性警告`))
+      console.log(chalk.gray(`   当前驱动: ${driverCheck.driverVersion}`))
+      console.log(chalk.gray(`   CUDA 12.8 需要: 驱动 >= 570`))
+      console.log(chalk.yellow('   解决方案：'))
+      console.log(chalk.gray('      1. 升级 NVIDIA 驱动到 570+ 版本'))
+      console.log(chalk.gray('      2. 使用 CPU 模式: dmla start'))
+      console.log()
+      console.log(chalk.gray('   继续启动 GPU 模式（可能会失败）...'))
+      console.log()
+    }
+  }
+
   // 启动服务
+  console.log(chalk.gray(`   镜像类型: ${imageResolution.message}`))
   console.log(chalk.gray('   正在启动...'))
 
   try {
@@ -217,24 +355,65 @@ export async function startServer(port, useGpu = false) {
 
     if (!actualServerPath) {
       console.log(chalk.red('❌ 找不到服务入口文件'))
-      console.log(chalk.yellow('💡 提示: 确保正确安装了 @icyfenix-dmla/cli'))
+      console.log(chalk.yellow('提示: 确保正确安装了 @icyfenix-dmla/cli'))
       return
     }
 
+    // 日志文件路径
+    const logDir = path.resolve(__dirname, '../../logs')
+    if (!fs.existsSync(logDir)) {
+      fs.mkdirSync(logDir, { recursive: true })
+    }
+    const logFile = path.join(logDir, 'server.log')
+    const errorLogFile = path.join(logDir, 'server-error.log')
+
+    console.log(chalk.gray(`   日志文件: ${logFile}`))
+
+    // 创建日志文件流
+    const logStream = fs.openSync(logFile, 'a')
+    const errorLogStream = fs.openSync(errorLogFile, 'a')
+
     const env = {
       ...process.env,
       PORT: port.toString(),
-      USE_GPU: useGpu ? 'true' : 'false'
+      USE_GPU: resolvedUseGpu ? 'true' : 'false',
+      DMLA_LOG_FILE: logFile  // 传递日志文件路径给服务端
     }
 
+    // 写入启动日志
+    const timestamp = new Date().toISOString()
+    fs.writeSync(logStream, `[${timestamp}] Server starting...\n`)
+    fs.writeSync(logStream, `[${timestamp}] Server path: ${actualServerPath}\n`)
+    fs.writeSync(logStream, `[${timestamp}] Port: ${port}\n`)
+    fs.writeSync(logStream, `[${timestamp}] GPU: ${resolvedUseGpu} (${imageResolution.message})\n`)
+
+    // 使用 spawn 启动 server 进程
+    // 重要：stdio 必须是 'ignore' 或管道，不能是 'inherit'
+    // 因为 'inherit' 会让子进程依赖父进程的 stdout，父进程退出后子进程也会退出
     const serverProcess = spawn('node', [actualServerPath], {
       env,
-      stdio: 'inherit',
-      detached: true
+      stdio: ['ignore', logStream, errorLogStream],  // stdin: ignore, stdout: log file, stderr: error log
+      detached: true,
+      windowsHide: true  // Windows 下隐藏窗口
+    })
+
+    // 监听子进程事件（调试用）
+    serverProcess.on('error', (err) => {
+      fs.writeSync(errorLogStream, `[${new Date().toISOString()}] Spawn error: ${err.message}\n`)
+    })
+
+    serverProcess.on('exit', (code, signal) => {
+      const msg = `[${new Date().toISOString()}] Process exited: code=${code}, signal=${signal}\n`
+      fs.writeSync(logStream, msg)
+      fs.writeSync(errorLogStream, msg)
     })
 
     serverProcess.unref()
 
+    // 关闭父进程中的文件描述符（子进程会保留自己的副本）
+    fs.closeSync(logStream)
+    fs.closeSync(errorLogStream)
+
     // 等待服务启动
     console.log(chalk.gray('   等待服务就绪...'))
     let attempts = 0
@@ -245,15 +424,19 @@ export async function startServer(port, useGpu = false) {
       if (running) {
         console.log(chalk.green(`✅ 服务已启动: http://localhost:${port}`))
         console.log(chalk.gray(`   健康检查: http://localhost:${port}/api/health`))
+        console.log(chalk.gray(`   日志查看: ${logFile}`))
         return
       }
       await new Promise(resolve => setTimeout(resolve, 500))
       attempts++
     }
 
-    console.log(chalk.yellow('⚠️ 服务启动超时，请检查日志'))
+    console.log(chalk.yellow('⚠️ 服务启动超时'))
+    console.log(chalk.gray(`   请查看日志: ${logFile}`))
+    console.log(chalk.gray(`   或使用 --sync 模式调试`))
   } catch (error) {
     console.log(chalk.red(`❌ 启动失败: ${error.message}`))
+    console.log(chalk.gray(error.stack))
   }
 }
 
@@ -261,7 +444,51 @@ export async function startServer(port, useGpu = false) {
  * 停止服务
  */
 export async function stopServer() {
-  // 查找运行中的容器
+  // 首先尝试通过 API 停止服务
+  const port = CONFIG.defaultPort
+  const running = await checkServiceRunning(port)
+
+  if (running) {
+    try {
+      // 调用 shutdown API
+      await new Promise((resolve, reject) => {
+        const req = http.request({
+          hostname: 'localhost',
+          port: port,
+          path: '/api/shutdown',
+          method: 'POST',
+          timeout: 5000
+        }, (res) => {
+          if (res.statusCode === 200) {
+            console.log(chalk.green('✅ 服务已停止'))
+            resolve()
+          } else {
+            reject(new Error(`HTTP ${res.statusCode}`))
+          }
+        })
+        req.on('error', (e) => reject(e))
+        req.on('timeout', () => {
+          req.destroy()
+          reject(new Error('Timeout'))
+        })
+        req.end()
+      })
+
+      // 等待服务完全关闭
+      let attempts = 0
+      while (attempts < 10) {
+        const stillRunning = await checkServiceRunning(port)
+        if (!stillRunning) break
+        await new Promise(r => setTimeout(r, 200))
+        attempts++
+      }
+      return
+    } catch (error) {
+      console.log(chalk.yellow(`⚠️ 通过 API 停止失败: ${error.message}`))
+    }
+  }
+
+  // 尝试查找并停止 Docker 容器
   const container = await findServiceContainer()
 
   if (container) {
@@ -269,14 +496,15 @@ export async function stopServer() {
       const containerObj = docker.getContainer(container.Id)
       await containerObj.stop()
       await containerObj.remove()
-      console.log(chalk.green('✅ 服务已停止'))
+      console.log(chalk.green('✅ 服务容器已停止'))
     } catch (error) {
-      console.log(chalk.red(`❌ 停止失败: ${error.message}`))
+      console.log(chalk.red(`❌ 停止容器失败: ${error.message}`))
     }
+  } else if (!running) {
+    console.log(chalk.gray('   服务未运行'))
   } else {
-    // 尝试通过端口查找进程
-    console.log(chalk.yellow('⚠️ 未找到运行中的服务容器'))
-    console.log(chalk.gray('   提示: 服务可能以非容器模式运行'))
+    console.log(chalk.yellow('⚠️ 无法停止服务'))
+    console.log(chalk.gray('   提示: 手动终止端口 3001 上的进程'))
   }
 }
 
@@ -287,9 +515,10 @@ export async function getStatus() {
   console.log()
 
   // 检查 npm 包版本
-  console.log(chalk.bold('📦 npm 包版本'))
+  console.log(chalk.bold('npm 包版本'))
   try {
-    const pkgPath = path.resolve(__dirname, '../package.json')
+    // __dirname 是 src/commands，需要向上两级到包根目录
+    const pkgPath = path.resolve(__dirname, '../../package.json')
     const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'))
     console.log(chalk.gray(`   @icyfenix-dmla/cli: ${pkg.version}`))
   } catch {
@@ -299,7 +528,7 @@ export async function getStatus() {
   console.log()
 
   // 检查镜像
-  console.log(chalk.bold('🖼️  Docker 镜像'))
+  console.log(chalk.bold('Docker 镜像'))
   const cpuExists = await checkImageExists('cpu')
   const gpuExists = await checkImageExists('gpu')
   console.log(chalk.gray(`   CPU: ${cpuExists ? chalk.green('已安装') : chalk.red('未安装')}`))
@@ -308,7 +537,7 @@ export async function getStatus() {
   console.log()
 
   // 检查 GPU
-  console.log(chalk.bold('🎮 GPU 状态'))
+  console.log(chalk.bold('GPU 状态'))
   const gpuAvailable = await checkGPUAvailable()
   if (gpuAvailable) {
     console.log(chalk.green('   GPU 可用'))
@@ -326,7 +555,7 @@ export async function getStatus() {
   console.log()
 
   // 检查服务
-  console.log(chalk.bold('🚀 服务状态'))
+  console.log(chalk.bold('服务状态'))
   const running = await checkServiceRunning(CONFIG.defaultPort)
   if (running) {
     console.log(chalk.green(`   服务运行中 (端口 ${CONFIG.defaultPort})`))