@icyfenix-dmla/cli 2026.4.19-954 → 2026.4.21-2145

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@icyfenix-dmla/cli",
-  "version": "2026.4.19-954",
+  "version": "2026.4.21-2145",
   "description": "DMLA 沙箱服务命令行工具",
   "type": "module",
   "main": "src/index.js",

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,7 +170,7 @@ 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' })
@@ -261,7 +197,7 @@ export async function runDoctor() {
   // ───────────────────────────────────────────────────────────
   // 端口检查
   // ───────────────────────────────────────────────────────────
-  console.log(chalk.bold('🔌 端口可用性'))
+  console.log(chalk.bold('端口可用性'))
 
   const port = CONFIG.defaultPort
   const portAvailable = await checkPortAvailable(port)
@@ -310,11 +246,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 是否可用
  */
@@ -117,35 +152,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)
@@ -158,23 +222,26 @@ export async function startServerSync(port, useGpu = false) {
   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 +256,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)
@@ -210,6 +277,7 @@ export async function startServer(port, useGpu = false) {
   }
 
   // 启动服务
+  console.log(chalk.gray(`   镜像类型: ${imageResolution.message}`))
   console.log(chalk.gray('   正在启动...'))
 
   try {
@@ -217,24 +285,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 +354,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 +374,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 +426,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 +445,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 +458,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 +467,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 +485,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})`))

package/src/index.js

@@ -2,18 +2,87 @@
  * DMLA CLI 入口
  * 沙箱服务命令行管理工具
  */
-import { program } from 'commander'
+import { program, Help } from 'commander'
 import chalk from 'chalk'
+import path from 'path'
+import { fileURLToPath } from 'url'
+import fs from 'fs'
 import { startServer, startServerSync, stopServer, getStatus } from './commands/server.js'
-import { updateAll, runDoctor } from './commands/manage.js'
+import { runDoctor } from './commands/manage.js'
 import { runInstallTUI } from '@icyfenix-dmla/install'
 
-const VERSION = '0.0.0' // 将在发布时由 workflow 更新
+// 从 package.json 读取版本号
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+const pkgPath = path.resolve(__dirname, '../package.json')
+const VERSION = JSON.parse(fs.readFileSync(pkgPath, 'utf8')).version
+
+// 重写 Help 类的方法以输出中文标题
+Help.prototype.padWidth = function(cmd, helper) {
+  return 20
+}
+
+// 重写帮助信息格式化方法
+Help.prototype.formatHelp = function(cmd, helper) {
+  const indent = '  '
+  const itemIndent = '  '
+
+  let output = []
+
+  // 用法（中文）
+  output.push('用法:')
+  output.push(indent + helper.commandUsage(cmd))
+
+  // 说明（中文）
+  if (cmd.description()) {
+    output.push('')
+    output.push('说明:')
+    output.push(indent + cmd.description())
+  }
+
+  // 参数（中文）
+  const args = helper.visibleArguments(cmd)
+  if (args.length > 0) {
+    output.push('')
+    output.push('参数:')
+    args.forEach(arg => {
+      output.push(itemIndent + arg.name())
+    })
+  }
+
+  // 选项（中文）
+  const options = helper.visibleOptions(cmd)
+  if (options.length > 0) {
+    output.push('')
+    output.push('选项:')
+    options.forEach(opt => {
+      const term = helper.optionTerm(opt)
+      const description = helper.optionDescription(opt)
+      output.push(itemIndent + term.padEnd(20) + description)
+    })
+  }
+
+  // 命令（中文）
+  const commands = helper.visibleCommands(cmd)
+  if (commands.length > 0) {
+    output.push('')
+    output.push('命令:')
+    commands.forEach(subcmd => {
+      const term = helper.subcommandTerm(subcmd)
+      const description = helper.subcommandDescription(subcmd)
+      output.push(itemIndent + term.padEnd(20) + description)
+    })
+  }
+
+  return output.join('\n')
+}
 
 program
   .name('dmla')
   .description('DMLA 沙箱服务命令行管理工具')
-  .version(VERSION)
+  .version(VERSION, '-v, --version', '显示版本号')
+  .helpOption('-h, --help', '显示帮助信息')
+  .addHelpCommand('help [command]', '显示命令帮助信息')
 
 // ─────────────────────────────────────────────────────────────
 // start 命令
@@ -29,9 +98,9 @@ program
     const useGpu = options.gpu
     const sync = options.sync
 
-    console.log(chalk.blue('🚀 启动 DMLA 沙箱服务...'))
+    console.log(chalk.blue('启动 DMLA 沙箱服务...'))
     console.log(chalk.gray(`   端口: ${port}`))
-    console.log(chalk.gray(`   镜像: ${useGpu ? 'GPU' : 'CPU'}`))
+    console.log(chalk.gray(`   请求类型: ${useGpu ? 'GPU' : '自动选择'}`))
     if (sync) {
       console.log(chalk.yellow(`   模式: 同步（调试模式）`))
     }
@@ -50,7 +119,7 @@ program
   .command('stop')
   .description('停止运行中的沙箱服务')
   .action(async () => {
-    console.log(chalk.blue('🛑 停止 DMLA 沙箱服务...'))
+    console.log(chalk.blue('停止 DMLA 沙箱服务...'))
     await stopServer()
   })
 
@@ -61,7 +130,7 @@ program
   .command('status')
   .description('查看服务状态')
   .action(async () => {
-    console.log(chalk.blue('📊 DMLA 沙箱服务状态'))
+    console.log(chalk.blue('DMLA 沙箱服务状态'))
     await getStatus()
   })
 
@@ -75,18 +144,6 @@ program
     await runInstallTUI()
   })
 
-// ─────────────────────────────────────────────────────────────
-// update 命令
-// ─────────────────────────────────────────────────────────────
-program
-  .command('update')
-  .description('更新 npm 包和 Docker 镜像')
-  .option('-r, --registry <type>', '镜像仓库 (dockerhub/acr)', 'dockerhub')
-  .action(async (options) => {
-    console.log(chalk.blue('🔄 更新 DMLA...'))
-    await updateAll(options.registry)
-  })
-
 // ─────────────────────────────────────────────────────────────
 // doctor 命令
 // ─────────────────────────────────────────────────────────────
@@ -94,7 +151,7 @@ program
   .command('doctor')
   .description('诊断安装环境')
   .action(async () => {
-    console.log(chalk.blue('🔍 DMLA 环境诊断'))
+    console.log(chalk.blue('DMLA 环境诊断'))
     await runDoctor()
   })
 

package/src/server/index.js

@@ -11,27 +11,82 @@ import sandboxRouter from './routes/sandbox.js'
 export const app = express()
 const PORT = process.env.PORT || 3001
 
+// 日志函数
+function log(message) {
+  const timestamp = new Date().toISOString()
+  console.log(`[${timestamp}] ${message}`)
+}
+
+// 启动日志
+log('Server initializing...')
+log(`PORT: ${PORT}`)
+log(`NODE_VERSION: ${process.version}`)
+log(`PLATFORM: ${process.platform}`)
+log(`DMLA_SYNC_MODE: ${process.env.DMLA_SYNC_MODE || 'false'}`)
+
 // 中间件
 app.use(cors())
 app.use(express.json())
 
+// 请求日志中间件
+app.use((req, res, next) => {
+  log(`Request: ${req.method} ${req.path}`)
+  next()
+})
+
 // 健康检查
 app.get('/api/health', (req, res) => {
+  log('Health check request')
   res.json({ status: 'ok', timestamp: new Date().toISOString() })
 })
 
+// 停止服务（用于 CLI stop 命令）
+app.post('/api/shutdown', (req, res) => {
+  log('Shutdown request received')
+  res.json({ status: 'shutting_down', timestamp: new Date().toISOString() })
+  // 延迟关闭，确保响应发送完成
+  setTimeout(() => {
+    log('Exiting due to shutdown request')
+    process.exit(0)
+  }, 100)
+})
+
 // 沙箱 API
 app.use('/api/sandbox', sandboxRouter)
 
 // 错误处理
 app.use((err, req, res, next) => {
-  console.error('Error:', err)
+  log(`Error: ${err.message}`)
+  log(`Stack: ${err.stack}`)
   res.status(500).json({
     success: false,
     error: err.message || 'Internal Server Error'
   })
 })
 
+// 捕获未处理的异常
+process.on('uncaughtException', (err) => {
+  log(`UNCAUGHT EXCEPTION: ${err.message}`)
+  log(`Stack: ${err.stack}`)
+  process.exit(1)
+})
+
+// 捕获未处理的 Promise 拒绝
+process.on('unhandledRejection', (reason, promise) => {
+  log(`UNHANDLED REJECTION: ${reason}`)
+})
+
+// 捕获进程信号
+process.on('SIGTERM', () => {
+  log('Received SIGTERM')
+  process.exit(0)
+})
+
+process.on('SIGINT', () => {
+  log('Received SIGINT')
+  process.exit(0)
+})
+
 // 启动服务器
 // 条件1: 直接运行（入口点匹配）
 // 条件2: 同步模式（DMLA_SYNC_MODE 环境变量）
@@ -39,12 +94,24 @@ const __filename = fileURLToPath(import.meta.url)
 const entryPoint = resolve(process.argv[1] || '')
 const shouldStart = __filename === entryPoint || process.env.DMLA_SYNC_MODE === 'true'
 
+log(`Entry point check: __filename=${__filename}, entryPoint=${entryPoint}, match=${__filename === entryPoint}`)
+
 if (shouldStart) {
-  app.listen(PORT, () => {
-    console.log(`🚀 DMLA 本地服务已启动`)
-    console.log(`   API: http://localhost:${PORT}`)
-    console.log(`   健康检查: http://localhost:${PORT}/api/health`)
+  const server = app.listen(PORT, () => {
+    log('Server started successfully')
+    log(`API: http://localhost:${PORT}`)
+    log(`Health: http://localhost:${PORT}/api/health`)
+  })
+
+  server.on('error', (err) => {
+    log(`Server error: ${err.message}`)
+  })
+
+  server.on('close', () => {
+    log('Server closed')
   })
+} else {
+  log('Skipping server start (imported as module)')
 }
 
 export default app

package/src/server/routes/sandbox.js

@@ -2,7 +2,9 @@
  * 沙箱 API 路由
  */
 import { Router } from 'express'
-import { runPythonCode, checkImageExists, checkGPUAvailable } from '../sandbox.js'
+import sandbox, { runPythonCode, checkImageExists, checkGPUAvailable, checkCUDACompatibility } from '../sandbox.js'
+
+const { SANDBOX_CONFIG } = sandbox
 
 const router = Router()
 
@@ -56,31 +58,45 @@ router.post('/run', async (req, res) => {
   }
 
   try {
-    // 检查镜像是否存在
-    const imageExists = await checkImageExists(useGpu)
+    // 检查镜像是否存在，智能降级
+    // GPU镜像包含CPU的全部功能，如果CPU镜像不存在但GPU镜像存在，可以使用GPU镜像执行CPU代码
+    let actualUseGpu = useGpu
+    let actualImage = null  // 指定使用的镜像
+    let imageExists = await checkImageExists(useGpu)
+
+    if (!imageExists && !useGpu) {
+      // CPU镜像不存在，检查是否可以用GPU镜像替代
+      const gpuImageExists = await checkImageExists(true)
+      if (gpuImageExists) {
+        imageExists = true
+        actualUseGpu = false  // 不启用GPU设备
+        actualImage = SANDBOX_CONFIG.imageGpu  // 使用GPU镜像
+        console.log('[Sandbox] CPU镜像不存在，使用GPU镜像执行（不启用GPU设备）')
+      }
+    }
 
     if (!imageExists) {
       return res.status(503).json({
         success: false,
         error: useGpu
           ? 'GPU 镜像未安装。请运行以下命令安装：\n\nnpm run build:sandbox:gpu\n\n或使用 dmla CLI：\n\ndmla install --gpu'
-          : '沙箱镜像未安装。请运行以下命令安装：\n\nnpm run build:sandbox:cpu\n\n或使用 dmla CLI：\n\ndmla install --cpu'
+          : '沙箱镜像未安装。请运行以下命令安装：\n\nnpm run build:sandbox:cpu\n\n或使用 dmla CLI：\n\ndmla install --cpu\n\n注意：如果您已安装 GPU 镜像，它也支持 CPU 执行'
       })
     }
 
     // 如果请求 GPU，检查 GPU 是否可用
-    if (useGpu) {
+    if (actualUseGpu) {
       const gpuAvailable = await checkGPUAvailable()
       if (!gpuAvailable) {
         return res.status(503).json({
           success: false,
-          error: 'GPU 硬件不可用。请确保系统安装了 NVIDIA GPU 驱动和 nvidia-container-toolkit。\n\n诊断步骤：\n1. 运行 nvidia-smi 检查 GPU 状态\n2. 运行 docker run --rm --gpus all nvidia/cuda:11.8-base nvidia-smi 测试 Docker GPU 支持\n\n或使用 dmla doctor 进行环境诊断'
+          error: `GPU 硬件不可用。请确保系统安装了 NVIDIA GPU 驱动和 nvidia-container-toolkit。\n\n诊断步骤：\n1. 运行 nvidia-smi 检查 GPU 状态\n2. 运行 docker run --rm --gpus all ${SANDBOX_CONFIG.imageGpu} nvidia-smi 测试 Docker GPU 支持\n\n或使用 dmla doctor 进行环境诊断`
         })
       }
     }
 
-    // 执行代码
-    const result = await runPythonCode(code, useGpu)
+    // 执行代码（使用确定后的镜像）
+    const result = await runPythonCode(code, actualUseGpu, actualImage)
 
     res.json(result)
 
@@ -112,4 +128,41 @@ router.get('/gpu', async (req, res) => {
   }
 })
 
+/**
+ * CUDA 兼容性检查
+ * 返回详细的 CUDA 环境诊断信息
+ */
+router.get('/cuda-compat', async (req, res) => {
+  try {
+    const imageGpuExists = await checkImageExists(true)
+
+    if (!imageGpuExists) {
+      return res.json({
+        status: 'error',
+        message: 'GPU 镜像未安装',
+        compatible: false,
+        suggestion: '请运行 npm run build:sandbox:gpu 或 dmla install --gpu'
+      })
+    }
+
+    const compatResult = await checkCUDACompatibility()
+
+    res.json({
+      status: compatResult.compatible ? 'ok' : 'error',
+      compatible: compatResult.compatible,
+      details: compatResult.details,
+      issues: compatResult.issues,
+      message: compatResult.compatible
+        ? 'CUDA 环境完全兼容，GPU 加速可用'
+        : 'CUDA 环境不兼容，请使用 CPU 模式或重新构建镜像'
+    })
+  } catch (error) {
+    res.status(500).json({
+      status: 'error',
+      compatible: false,
+      error: error.message
+    })
+  }
+})
+
 export default router

package/src/server/sandbox.js

@@ -10,6 +10,15 @@ import fs from 'fs'
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = path.dirname(__filename)
 
+// 日志函数
+function log(message) {
+  const timestamp = new Date().toISOString()
+  console.log(`[${timestamp}] [Sandbox] ${message}`)
+}
+
+// 启动时记录
+log('Sandbox module initialized')
+
 // 检测运行模式并计算正确的路径
 // 开发模式: 从 local-server/src 运行，项目根目录在上两级
 // 独立模式: 从 packages/cli/src/server 运行，无 shared_modules 目录
@@ -39,6 +48,11 @@ const DEFAULT_SHARED_MODULES_PATH = PROJECT_ROOT
   ? path.join(PROJECT_ROOT, 'local-server', 'shared_modules')
   : null
 
+// kernel_runner.py 路径（开发模式下可用）
+const DEFAULT_KERNEL_RUNNER_PATH = PROJECT_ROOT
+  ? path.join(PROJECT_ROOT, 'local-server', 'src', 'kernel_runner.py')
+  : null
+
 const docker = new Docker()
 
 // 沙箱配置
@@ -61,6 +75,18 @@ function getSharedModulesPath() {
   return DEFAULT_SHARED_MODULES_PATH
 }
 
+/**
+ * 获取 kernel_runner.py 路径
+ */
+function getKernelRunnerPath() {
+  // 优先使用环境变量指定的路径
+  if (process.env.KERNEL_RUNNER_PATH) {
+    return process.env.KERNEL_RUNNER_PATH
+  }
+  // 开发模式下的默认路径
+  return DEFAULT_KERNEL_RUNNER_PATH
+}
+
 /**
  * 检查是否启用 Volume Mount
  */
@@ -68,17 +94,24 @@ function shouldMountSharedModules() {
   return process.env.MOUNT_SHARED_MODULES !== 'false'
 }
 
+/**
+ * 检查是否挂载本地 kernel_runner.py（开发模式）
+ */
+function shouldMountKernelRunner() {
+  return process.env.MOUNT_KERNEL_RUNNER !== 'false' && PROJECT_ROOT !== null
+}
+
 /**
  * 检查 GPU 是否可用
- * 通过运行 nvidia-smi 命令检测 GPU 状态
+ * 使用已安装的 GPU 镜像运行 nvidia-smi 命令检测 GPU 状态
  */
 export async function checkGPUAvailable() {
   let container = null
 
   try {
-    // 创建容器运行 nvidia-smi 命令
+    // 使用已配置的 GPU 镜像检测，而非硬编码的 nvidia/cuda 镜像
     container = await docker.createContainer({
-      Image: 'nvidia/cuda:11.8-base',
+      Image: SANDBOX_CONFIG.imageGpu,
       Cmd: ['nvidia-smi', '-L'],
       HostConfig: {
         DeviceRequests: [{
@@ -121,18 +154,179 @@ export async function checkGPUAvailable() {
   }
 }
 
+/**
+ * 检查 CUDA 兼容性
+ * 在 GPU 镜像中运行简单的 CUDA 操作测试，验证 PyTorch 与 GPU 兼容
+ * @returns {Promise<{compatible: boolean, issues: string[], details: object}>}
+ */
+export async function checkCUDACompatibility() {
+  let container = null
+
+  const testCode = `
+import torch
+import json
+
+result = {
+    'pytorch_version': torch.__version__,
+    'cuda_available': torch.cuda.is_available(),
+    'cuda_version': str(torch.version.cuda) if torch.cuda.is_available() else None,
+    'device_name': torch.cuda.get_device_name(0) if torch.cuda.is_available() else None,
+    'compatible': True,
+    'test_passed': False,
+    'error': None
+}
+
+if torch.cuda.is_available():
+    try:
+        x = torch.randn(100, 100, device='cuda')
+        y = x + x
+        torch.cuda.synchronize()
+        result['test_passed'] = True
+    except RuntimeError as e:
+        result['compatible'] = False
+        result['error'] = str(e)
+        if 'no kernel image' in str(e) or 'CUDA error' in str(e):
+            result['error_type'] = 'compatibility'
+
+print(json.dumps(result))
+`
+
+  try {
+    container = await docker.createContainer({
+      Image: SANDBOX_CONFIG.imageGpu,
+      Cmd: ['python3', '-c', testCode],
+      HostConfig: {
+        DeviceRequests: [{
+          Driver: 'nvidia',
+          Count: -1,
+          Capabilities: [['gpu']]
+        }],
+        AutoRemove: false
+      },
+      Env: ['PYTHONUNBUFFERED=1']
+    })
+
+    await container.start()
+    await container.wait()
+
+    const logs = await container.logs({
+      stdout: true,
+      stderr: true
+    })
+
+    const { stdout, stderr } = parseDockerLogsSeparate(logs)
+
+    // 尝试解析 JSON 输出
+    const jsonStart = stdout.indexOf('{')
+    if (jsonStart !== -1) {
+      try {
+        const result = JSON.parse(stdout.substring(jsonStart))
+        return {
+          compatible: result.compatible && result.test_passed,
+          issues: result.error ? [result.error] : [],
+          details: result
+        }
+      } catch {
+        // JSON 解析失败
+      }
+    }
+
+    // 如果无法解析，检查 stderr 是否有 CUDA 错误
+    if (stderr.includes('no kernel image') || stderr.includes('CUDA error')) {
+      return {
+        compatible: false,
+        issues: [stderr],
+        details: { raw_output: stderr }
+      }
+    }
+
+    // 默认返回未知状态
+    return {
+      compatible: true,  // 假设兼容，让实际执行来验证
+      issues: [],
+      details: { stdout, stderr }
+    }
+
+  } catch (error) {
+    return {
+      compatible: false,
+      issues: [error.message],
+      details: { error: error.message }
+    }
+  } finally {
+    if (container) {
+      try {
+        await container.remove({ force: true })
+      } catch {
+        // 忽略清理错误
+      }
+    }
+  }
+}
+
 /**
  * 执行 Python 代码
  * 使用 IPython Kernel 执行代码，支持富输出（图片、文本、错误等）
  * @param {string} code - Python 代码
- * @param {boolean} useGpu - 是否使用 GPU
+ * @param {boolean} useGpu - 是否启用 GPU 设备
+ * @param {string|null} imageOverride - 可选，指定使用的镜像名称（覆盖默认选择）
  * @returns {Promise<{success: boolean, outputs: Array, executionTime: number, gpuUsed: boolean}>}
  */
-export async function runPythonCode(code, useGpu = false) {
+export async function runPythonCode(code, useGpu = false, imageOverride = null) {
   const startTime = Date.now()
 
-  // 选择镜像
-  const image = useGpu ? SANDBOX_CONFIG.imageGpu : SANDBOX_CONFIG.imageCpu
+  log(`runPythonCode called, useGpu=${useGpu}, code length=${code.length}, imageOverride=${imageOverride}`)
+
+  // 选择镜像：优先使用指定的镜像，否则根据 useGpu 选择
+  const image = imageOverride || (useGpu ? SANDBOX_CONFIG.imageGpu : SANDBOX_CONFIG.imageCpu)
+  log(`Using image: ${image}`)
+
+  // GPU 兼容性预检查
+  if (useGpu) {
+    log('GPU mode: running CUDA compatibility pre-check...')
+    const compatResult = await checkCUDACompatibility()
+    log(`CUDA compatibility check result: ${JSON.stringify(compatResult)}`)
+
+    if (!compatResult.compatible) {
+      log('CUDA compatibility check failed')
+      const executionTime = (Date.now() - startTime) / 1000
+
+      // 构建详细的错误信息
+      const errorDetails = compatResult.details || {}
+      const errorType = errorDetails.error_type || 'unknown'
+
+      let errorMessage = 'CUDA 兼容性错误：PyTorch CUDA 版本与您的 GPU 不兼容\n\n'
+
+      if (errorType === 'compatibility' || compatResult.issues.some(i => i.includes('no kernel image'))) {
+        errorMessage += `诊断详情:\n`
+        errorMessage += `- PyTorch 版本: ${errorDetails.pytorch_version || '未知'}\n`
+        errorMessage += `- CUDA 版本: ${errorDetails.cuda_version || '未知'}\n`
+        errorMessage += `- GPU 设备: ${errorDetails.device_name || '未知'}\n`
+        errorMessage += `- 错误类型: CUDA kernel 不兼容\n\n`
+        errorMessage += `解决方案:\n`
+        errorMessage += `1. 使用 CPU 模式运行代码（在前端选择 "Run on CPU"）\n`
+        errorMessage += `2. 在代码开头添加: device = torch.device('cpu')\n`
+        errorMessage += `3. 重新构建兼容的 Docker 镜像（修改 Dockerfile.sandbox 使用 CUDA 12.x）\n\n`
+        errorMessage += `更多诊断信息请运行: dmla doctor`
+      } else {
+        errorMessage += `错误详情: ${compatResult.issues.join('\n')}\n\n`
+        errorMessage += `建议使用 CPU 模式运行代码。`
+      }
+
+      return {
+        success: false,
+        outputs: [{
+          type: 'error',
+          ename: 'CUDACompatError',
+          evalue: 'CUDA 兼容性错误',
+          traceback: [errorMessage]
+        }],
+        executionTime,
+        gpuUsed: false
+      }
+    }
+    log('CUDA compatibility check passed')
+  }
 
   // 创建容器配置 - 使用 kernel_runner.py 执行代码
   const containerConfig = {
@@ -148,25 +342,40 @@ export async function runPythonCode(code, useGpu = false) {
     ]
   }
 
-  // Volume Mount 配置 - 挂载共享模块
+  log('Container config created')
+
+  // Volume Mount 配置
   const useMount = shouldMountSharedModules()
   const sharedModulesPath = getSharedModulesPath()
+  const mountKernelRunner = shouldMountKernelRunner()
+  const kernelRunnerPath = getKernelRunnerPath()
+
+  // 收集所有需要挂载的路径
+  const binds = []
+
+  // 挂载共享模块
+  if (useMount && sharedModulesPath && fs.existsSync(sharedModulesPath)) {
+    binds.push(`${sharedModulesPath}:/usr/local/lib/python3.11/site-packages/shared:ro`)
+    console.log(`[Sandbox] 共享模块 Volume Mount: ${sharedModulesPath}`)
+  } else if (useMount && sharedModulesPath) {
+    console.warn(`[Sandbox] 警告: 共享模块目录不存在: ${sharedModulesPath}`)
+  }
 
-  if (useMount && sharedModulesPath) {
-    // 检查共享模块目录是否存在
-    if (fs.existsSync(sharedModulesPath)) {
-      containerConfig.HostConfig.Binds = [
-        `${sharedModulesPath}:/usr/local/lib/python3.11/site-packages/shared:ro`
-      ]
-      console.log(`[Sandbox] Volume Mount 已启用: ${sharedModulesPath}`)
-    } else {
-      console.warn(`[Sandbox] 警告: 共享模块目录不存在: ${sharedModulesPath}`)
-      console.warn('[Sandbox] 提示: 运行 npm run extract:shared 生成共享模块')
-    }
-  } else if (!sharedModulesPath) {
-    console.log('[Sandbox] 独立安装模式，无共享模块目录')
-  } else {
-    console.log('[Sandbox] Volume Mount 已禁用 (MOUNT_SHARED_MODULES=false)')
+  // 挂载 kernel_runner.py（开发模式调试）
+  if (mountKernelRunner && kernelRunnerPath && fs.existsSync(kernelRunnerPath)) {
+    binds.push(`${kernelRunnerPath}:/workspace/kernel_runner.py:ro`)
+    console.log(`[Sandbox] kernel_runner.py Volume Mount: ${kernelRunnerPath}`)
+  } else if (mountKernelRunner && kernelRunnerPath) {
+    console.warn(`[Sandbox] 警告: kernel_runner.py 不存在: ${kernelRunnerPath}`)
+  }
+
+  // 设置 Binds
+  if (binds.length > 0) {
+    containerConfig.HostConfig.Binds = binds
+  }
+
+  if (!PROJECT_ROOT) {
+    console.log('[Sandbox] 独立安装模式，无 Volume Mount')
   }
 
   // GPU 配置
@@ -183,41 +392,80 @@ export async function runPythonCode(code, useGpu = false) {
 
   try {
     // 创建容器
+    log('Creating container...')
     container = await docker.createContainer(containerConfig)
+    log(`Container created: ${container.id}`)
 
     // 设置超时
     const timeoutPromise = new Promise((_, reject) => {
       timeoutId = setTimeout(() => {
+        log('Execution timeout triggered')
         reject(new Error('Execution timeout'))
       }, SANDBOX_CONFIG.timeout + 10000)  // 额外 10 秒用于清理
     })
 
     // 启动容器
+    log('Starting container...')
     await container.start()
+    log('Container started')
 
     // 等待执行完成
+    log('Waiting for container to finish...')
     const waitPromise = container.wait()
 
     // 竞速: 超时 vs 正常完成
     const result = await Promise.race([waitPromise, timeoutPromise])
+    log(`Container finished, result: ${JSON.stringify(result)}`)
 
     // 清除超时
     if (timeoutId) clearTimeout(timeoutId)
 
     // 获取输出
+    log('Getting container logs...')
     const logs = await container.logs({
       stdout: true,
       stderr: true
     })
 
-    // 解析输出
-    const rawOutput = parseDockerLogs(logs)
+    // 解析输出 - 分别处理 stdout 和 stderr
+    const { stdout, stderr } = parseDockerLogsSeparate(logs)
+    log(`Stdout length: ${stdout.length}`)
+    log(`Stderr length: ${stderr.length}`)
+
+    // stderr 可能包含调试信息
+    if (stderr.length > 0) {
+      log(`Stderr content preview: ${stderr.substring(0, 500)}`)
+    }
+
+    // stdout 可能包含 CUDA banner + JSON，需要提取 JSON 部分
+    // 找到第一个 '{' 作为 JSON 开始
+    const jsonStart = stdout.indexOf('{')
+    if (jsonStart === -1) {
+      log(`No JSON found in stdout`)
+      const executionTime = (Date.now() - startTime) / 1000
+      return {
+        success: false,
+        outputs: [{
+          type: 'error',
+          ename: 'OutputParseError',
+          evalue: 'No JSON output found',
+          traceback: [stdout.substring(0, 1000)]
+        }],
+        executionTime,
+        gpuUsed: useGpu
+      }
+    }
+
+    const rawOutput = stdout.substring(jsonStart)
+    log(`JSON extracted from position ${jsonStart}, length: ${rawOutput.length}`)
 
     // 解析 JSON 输出
     let parsedResult
     try {
       parsedResult = JSON.parse(rawOutput)
+      log('Output parsed successfully')
     } catch (parseError) {
+      log(`JSON parse error: ${parseError.message}`)
       // 如果 JSON 解析失败，返回原始输出作为错误
       const executionTime = (Date.now() - startTime) / 1000
       return {
@@ -241,6 +489,8 @@ export async function runPythonCode(code, useGpu = false) {
     }
 
   } catch (error) {
+    log(`Execution error: ${error.message}`)
+    log(`Error stack: ${error.stack}`)
     // 清除超时
     if (timeoutId) clearTimeout(timeoutId)
 
@@ -260,11 +510,13 @@ export async function runPythonCode(code, useGpu = false) {
 
   } finally {
     // 清理容器
+    log('Cleaning up container...')
     if (container) {
       try {
         await container.remove({ force: true })
+        log('Container removed')
       } catch (e) {
-        console.warn('Failed to remove container:', e.message)
+        log(`Container cleanup error: ${e.message}`)
       }
     }
   }
@@ -305,6 +557,49 @@ function parseDockerLogs(logs) {
   return logs.toString()
 }
 
+/**
+ * 解析 Docker 日志输出，分别返回 stdout 和 stderr
+ * Docker 日志格式: [8字节头][数据]
+ * 头部第一个字节: 0=stdin, 1=stdout, 2=stderr
+ */
+function parseDockerLogsSeparate(logs) {
+  if (!logs || logs.length === 0) return { stdout: '', stderr: '' }
+
+  // 如果是 Buffer
+  if (Buffer.isBuffer(logs)) {
+    let stdout = ''
+    let stderr = ''
+    let offset = 0
+
+    while (offset < logs.length) {
+      // 跳过 8 字节头
+      if (offset + 8 > logs.length) break
+
+      const streamType = logs[offset]  // 1=stdout, 2=stderr
+      const length = logs.readUInt32BE(offset + 4)
+
+      offset += 8
+
+      if (offset + length > logs.length) break
+
+      const chunk = logs.slice(offset, offset + length).toString('utf8')
+
+      if (streamType === 1) {
+        stdout += chunk
+      } else if (streamType === 2) {
+        stderr += chunk
+      }
+
+      offset += length
+    }
+
+    return { stdout, stderr }
+  }
+
+  // 如果是字符串，无法区分，全部作为 stdout
+  return { stdout: logs.toString(), stderr: '' }
+}
+
 /**
  * 检查沙箱镜像是否存在
  */
@@ -346,6 +641,8 @@ export async function pullImage(useGpu = false) {
 export default {
   runPythonCode,
   checkGPUAvailable,
+  checkCUDACompatibility,
   checkImageExists,
-  pullImage
+  pullImage,
+  SANDBOX_CONFIG
 }