@icyfenix-dmla/cli 2026.4.18-957 → 2026.4.19-1028

package/README.md

@@ -0,0 +1,46 @@
+# @icyfenix-dmla/cli
+
+DMLA 沙箱服务命令行工具。
+
+## 安装
+
+```bash
+npm install -g @icyfenix-dmla/cli
+```
+
+## 使用
+
+```bash
+# 启动服务
+dmla start                 # 默认端口 3001
+dmla start --port 8080     # 自定义端口
+dmla start --gpu           # GPU 模式
+
+# 停止服务
+dmla stop
+
+# 查看状态
+dmla status
+
+# 安装镜像
+dmla install               # 安装所有镜像（默认从 Docker Hub）
+dmla install --cpu         # 仅 CPU 版本
+dmla install --gpu         # 仅 GPU 版本
+dmla install --registry acr  # 从阿里云 ACR 安装（国内加速）
+
+# 更新
+dmla update                # 更新 npm 包和镜像
+dmla update --registry acr
+
+# 环境诊断
+dmla doctor
+```
+
+## 要求
+
+- Node.js >= 18.0.0
+- Docker
+
+## 许可证
+
+MIT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@icyfenix-dmla/cli",
-  "version": "2026.4.18-957",
+  "version": "2026.4.19-1028",
   "description": "DMLA 沙箱服务命令行工具",
   "type": "module",
   "main": "src/index.js",
@@ -9,15 +9,24 @@
   },
   "scripts": {
     "start": "node src/index.js",
+    "build": "node scripts/build.js",
+    "prepublishOnly": "npm run build",
     "test": "node --experimental-vm-modules $(npm root)/jest/bin/jest.js"
   },
+  "files": [
+    "bin/",
+    "src/",
+    "scripts/",
+    "README.md"
+  ],
   "dependencies": {
     "commander": "^12.1.0",
     "chalk": "^5.3.0",
     "enquirer": "^2.4.1",
     "dockerode": "^4.0.2",
     "express": "^4.21.2",
-    "cors": "^2.8.5"
+    "cors": "^2.8.5",
+    "@icyfenix-dmla/install": "*"
   },
   "devDependencies": {
     "jest": "^29.7.0"

package/scripts/build.js

@@ -0,0 +1,50 @@
+/**
+ * 构建脚本：将 local-server 代码复制到 CLI 包中
+ * 用于 npm 发布时包含完整的服务器代码
+ */
+import fs from 'fs'
+import path from 'path'
+import { fileURLToPath } from 'url'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+const rootDir = path.resolve(__dirname, '../../..')
+const localServerSrc = path.resolve(rootDir, 'local-server/src')
+const cliServerDest = path.resolve(__dirname, '../src/server')
+
+console.log('📦 构建 CLI 包...')
+console.log(`   源目录: ${localServerSrc}`)
+console.log(`   目标目录: ${cliServerDest}`)
+
+// 递归复制目录
+function copyDir(src, dest) {
+  if (!fs.existsSync(src)) {
+    console.error(`❌ 源目录不存在: ${src}`)
+    process.exit(1)
+  }
+
+  // 创建目标目录
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(dest, { recursive: true })
+  }
+
+  const entries = fs.readdirSync(src, { withFileTypes: true })
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name)
+    const destPath = path.join(dest, entry.name)
+
+    if (entry.isDirectory()) {
+      copyDir(srcPath, destPath)
+    } else if (entry.isFile() && entry.name.endsWith('.js')) {
+      fs.copyFileSync(srcPath, destPath)
+      console.log(`   ✓ 复制: ${entry.name}`)
+    }
+  }
+}
+
+// 执行复制
+copyDir(localServerSrc, cliServerDest)
+
+console.log('✅ 服务器代码已复制到 CLI 包')

package/src/commands/manage.js

@@ -19,7 +19,7 @@ const CONFIG = {
   imageCpu: 'dmla-sandbox:cpu',
   imageGpu: 'dmla-sandbox:gpu',
   dockerhubRegistry: 'icyfenix',
-  tcrRegistry: 'ccr.ccs.tencentyun.com/icyfenix',
+  acrRegistry: 'crpi-aani1ibpows293b8.cn-hangzhou.personal.cr.aliyuncs.com/fenixsoft',
   imageName: 'dmla-sandbox',
   defaultPort: 3001
 }
@@ -28,8 +28,8 @@ const CONFIG = {
  * 获取镜像仓库地址
  */
 function getRegistryUrl(registry) {
-  if (registry === 'tcr') {
-    return `${CONFIG.tcrRegistry}/${CONFIG.imageName}`
+  if (registry === 'acr') {
+    return `${CONFIG.acrRegistry}/${CONFIG.imageName}`
   }
   return `${CONFIG.dockerhubRegistry}/${CONFIG.imageName}`
 }
@@ -40,7 +40,7 @@ function getRegistryUrl(registry) {
 export async function installImages(types, registry = 'dockerhub') {
   const registryUrl = getRegistryUrl(registry)
 
-  console.log(chalk.gray(`   从 ${registry === 'tcr' ? '腾讯云 TCR' : 'Docker Hub'} 拉取镜像`))
+  console.log(chalk.gray(`   从 ${registry === 'acr' ? '阿里云 ACR' : 'Docker Hub'} 拉取镜像`))
 
   for (const type of types) {
     console.log()
@@ -289,13 +289,13 @@ export async function runDoctor() {
     console.log(chalk.yellow('   ⚠️ Docker Hub 连接超时或受限'))
   }
 
-  // 测试 TCR
-  console.log(chalk.gray('   测试腾讯云 TCR 连接...'))
+  // 测试 ACR
+  console.log(chalk.gray('   测试阿里云 ACR 连接...'))
   try {
-    execSync('docker pull ccr.ccs.tencentyun.com/icyfenix/dmla-sandbox:cpu --quiet', { timeout: 10000 })
-    console.log(chalk.green('   ✅ TCR 连接正常'))
+    execSync('docker pull crpi-aani1ibpows293b8.cn-hangzhou.personal.cr.aliyuncs.com/fenixsoft/dmla-sandbox:cpu --quiet', { timeout: 10000 })
+    console.log(chalk.green('   ✅ ACR 连接正常'))
   } catch {
-    console.log(chalk.yellow('   ⚠️ TCR 连接超时或受限'))
+    console.log(chalk.yellow('   ⚠️ ACR 连接超时或受限'))
   }
 
   console.log()

package/src/commands/server.js

@@ -114,7 +114,75 @@ async function findServiceContainer() {
 }
 
 /**
- * 启动服务
+ * 查找服务器入口文件
+ */
+function findServerPath() {
+  const serverPath = path.resolve(__dirname, '../../../local-server/src/index.js')
+  const standaloneServerPath = path.resolve(__dirname, '../server/index.js')
+
+  return fs.existsSync(serverPath) ? serverPath :
+         fs.existsSync(standaloneServerPath) ? standaloneServerPath : null
+}
+
+/**
+ * 同步启动服务（在当前进程运行，用于调试）
+ * @param {number} port - 服务端口
+ * @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 选项指定其他端口'))
+    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 安装镜像'))
+    return
+  }
+
+  // 检查服务是否已运行
+  const alreadyRunning = await checkServiceRunning(port)
+  if (alreadyRunning) {
+    console.log(chalk.green(`✅ 服务已在端口 ${port} 运行`))
+    return
+  }
+
+  // 查找服务器入口
+  const actualServerPath = findServerPath()
+  if (!actualServerPath) {
+    console.log(chalk.red('❌ 找不到服务入口文件'))
+    console.log(chalk.yellow('💡 提示: 确保正确安装了 @icyfenix-dmla/cli'))
+    return
+  }
+
+  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.DMLA_SYNC_MODE = 'true'  // 标记同步模式，让服务器在 import 时启动
+
+  // 动态 import 服务器模块并直接运行
+  // 服务器模块会在 import 时自动启动（因为入口点检测逻辑）
+  try {
+    await import(actualServerPath)
+  } catch (error) {
+    console.log(chalk.red(`❌ 服务启动失败: ${error.message}`))
+    console.log(chalk.gray(error.stack))
+  }
+}
+
+/**
+ * 启动服务（异步模式，spawn 子进程）
  */
 export async function startServer(port, useGpu = false) {
   // 检查端口
@@ -145,14 +213,7 @@ export async function startServer(port, useGpu = false) {
   console.log(chalk.gray('   正在启动...'))
 
   try {
-    // 使用 spawn 启动 server 进程
-    const serverPath = path.resolve(__dirname, '../../../local-server/src/index.js')
-
-    // 如果 server 文件不存在，说明是独立安装模式，需要启动内置服务
-    const standaloneServerPath = path.resolve(__dirname, '../server/index.js')
-
-    const actualServerPath = fs.existsSync(serverPath) ? serverPath :
-                             fs.existsSync(standaloneServerPath) ? standaloneServerPath : null
+    const actualServerPath = findServerPath()
 
     if (!actualServerPath) {
       console.log(chalk.red('❌ 找不到服务入口文件'))
@@ -200,7 +261,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) {
@@ -208,14 +313,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 上的进程'))
   }
 }
 

package/src/index.js

@@ -4,8 +4,9 @@
  */
 import { program } from 'commander'
 import chalk from 'chalk'
-import { startServer, stopServer, getStatus } from './commands/server.js'
-import { installImages, updateAll, runDoctor } from './commands/manage.js'
+import { startServer, startServerSync, stopServer, getStatus } from './commands/server.js'
+import { updateAll, runDoctor } from './commands/manage.js'
+import { runInstallTUI } from '@icyfenix-dmla/install'
 
 const VERSION = '0.0.0' // 将在发布时由 workflow 更新
 
@@ -22,13 +23,24 @@ program
   .description('启动沙箱服务')
   .option('-p, --port <number>', '服务端口', '3001')
   .option('--gpu', '使用 GPU 镜像')
+  .option('--sync', '同步模式：在当前进程运行，日志直接输出（用于调试）')
   .action(async (options) => {
     const port = parseInt(options.port, 10)
     const useGpu = options.gpu
+    const sync = options.sync
+
     console.log(chalk.blue('🚀 启动 DMLA 沙箱服务...'))
     console.log(chalk.gray(`   端口: ${port}`))
     console.log(chalk.gray(`   镜像: ${useGpu ? 'GPU' : 'CPU'}`))
-    await startServer(port, useGpu)
+    if (sync) {
+      console.log(chalk.yellow(`   模式: 同步（调试模式）`))
+    }
+
+    if (sync) {
+      await startServerSync(port, useGpu)
+    } else {
+      await startServer(port, useGpu)
+    }
   })
 
 // ─────────────────────────────────────────────────────────────
@@ -58,24 +70,9 @@ program
 // ─────────────────────────────────────────────────────────────
 program
   .command('install')
-  .description('安装 Docker 镜像')
-  .option('--cpu', '仅安装 CPU 版本')
-  .option('--gpu', '仅安装 GPU 版本')
-  .option('--all', '安装所有镜像（默认）')
-  .option('-r, --registry <type>', '镜像仓库 (dockerhub/tcr)', 'dockerhub')
-  .action(async (options) => {
-    const registry = options.registry
-    let types = []
-
-    if (options.cpu) types.push('cpu')
-    if (options.gpu) types.push('gpu')
-    if (types.length === 0 || options.all) types = ['cpu', 'gpu']
-
-    console.log(chalk.blue('📦 安装 DMLA Docker 镜像...'))
-    console.log(chalk.gray(`   仓库: ${registry}`))
-    console.log(chalk.gray(`   类型: ${types.join(', ')}`))
-
-    await installImages(types, registry)
+  .description('启动安装向导')
+  .action(async () => {
+    await runInstallTUI()
   })
 
 // ─────────────────────────────────────────────────────────────
@@ -84,7 +81,7 @@ program
 program
   .command('update')
   .description('更新 npm 包和 Docker 镜像')
-  .option('-r, --registry <type>', '镜像仓库 (dockerhub/tcr)', 'dockerhub')
+  .option('-r, --registry <type>', '镜像仓库 (dockerhub/acr)', 'dockerhub')
   .action(async (options) => {
     console.log(chalk.blue('🔄 更新 DMLA...'))
     await updateAll(options.registry)

package/src/server/index.js

@@ -0,0 +1,60 @@
+/**
+ * Design Machine Learning Applications 本地服务
+ * 提供 Python 代码沙箱执行 API
+ */
+import express from 'express'
+import cors from 'cors'
+import { fileURLToPath } from 'url'
+import { resolve } from 'path'
+import sandboxRouter from './routes/sandbox.js'
+
+export const app = express()
+const PORT = process.env.PORT || 3001
+
+// 中间件
+app.use(cors())
+app.use(express.json())
+
+// 健康检查
+app.get('/api/health', (req, res) => {
+  res.json({ status: 'ok', timestamp: new Date().toISOString() })
+})
+
+// 停止服务（用于 CLI stop 命令）
+app.post('/api/shutdown', (req, res) => {
+  res.json({ status: 'shutting_down', timestamp: new Date().toISOString() })
+  console.log('🛑 收到停止请求，服务即将关闭...')
+  // 延迟关闭，确保响应发送完成
+  setTimeout(() => {
+    process.exit(0)
+  }, 100)
+})
+
+// 沙箱 API
+app.use('/api/sandbox', sandboxRouter)
+
+// 错误处理
+app.use((err, req, res, next) => {
+  console.error('Error:', err)
+  res.status(500).json({
+    success: false,
+    error: err.message || 'Internal Server Error'
+  })
+})
+
+// 启动服务器
+// 条件1: 直接运行（入口点匹配）
+// 条件2: 同步模式（DMLA_SYNC_MODE 环境变量）
+const __filename = fileURLToPath(import.meta.url)
+const entryPoint = resolve(process.argv[1] || '')
+const shouldStart = __filename === entryPoint || process.env.DMLA_SYNC_MODE === 'true'
+
+if (shouldStart) {
+  app.listen(PORT, () => {
+    console.log(`🚀 DMLA 本地服务已启动`)
+    console.log(`   API: http://localhost:${PORT}`)
+    console.log(`   健康检查: http://localhost:${PORT}/api/health`)
+  })
+}
+
+export default app

package/src/server/routes/sandbox.js

@@ -0,0 +1,115 @@
+/**
+ * 沙箱 API 路由
+ */
+import { Router } from 'express'
+import { runPythonCode, checkImageExists, checkGPUAvailable } from '../sandbox.js'
+
+const router = Router()
+
+/**
+ * 健康检查
+ */
+router.get('/health', async (req, res) => {
+  try {
+    const imageCpuExists = await checkImageExists(false)
+    const imageGpuExists = await checkImageExists(true)
+    const gpuAvailable = await checkGPUAvailable()
+
+    res.json({
+      status: 'ok',
+      images: {
+        cpu: imageCpuExists,
+        gpu: imageGpuExists
+      },
+      gpu: gpuAvailable
+    })
+  } catch (error) {
+    res.status(500).json({
+      status: 'error',
+      error: error.message
+    })
+  }
+})
+
+/**
+ * 执行代码
+ * POST /api/sandbox/run
+ * Body: { code: string, useGpu?: boolean }
+ */
+router.post('/run', async (req, res) => {
+  const { code, useGpu = false } = req.body
+
+  // 验证请求
+  if (!code || typeof code !== 'string') {
+    return res.status(400).json({
+      success: false,
+      error: 'Missing or invalid code parameter'
+    })
+  }
+
+  // 代码长度限制 (约 100KB)
+  if (code.length > 100000) {
+    return res.status(400).json({
+      success: false,
+      error: 'Code too long (max 100KB)'
+    })
+  }
+
+  try {
+    // 检查镜像是否存在
+    const imageExists = await checkImageExists(useGpu)
+
+    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'
+      })
+    }
+
+    // 如果请求 GPU，检查 GPU 是否可用
+    if (useGpu) {
+      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 进行环境诊断'
+        })
+      }
+    }
+
+    // 执行代码
+    const result = await runPythonCode(code, useGpu)
+
+    res.json(result)
+
+  } catch (error) {
+    console.error('Sandbox error:', error)
+    res.status(500).json({
+      success: false,
+      error: error.message || 'Internal sandbox error'
+    })
+  }
+})
+
+/**
+ * GPU 状态检查
+ */
+router.get('/gpu', async (req, res) => {
+  try {
+    const gpuAvailable = await checkGPUAvailable()
+
+    res.json({
+      available: gpuAvailable,
+      message: gpuAvailable ? 'GPU is available' : 'No GPU detected'
+    })
+  } catch (error) {
+    res.status(500).json({
+      available: false,
+      error: error.message
+    })
+  }
+})
+
+export default router

package/src/server/sandbox.js

@@ -0,0 +1,351 @@
+/**
+ * 沙箱管理模块
+ * 负责创建和管理 Docker 容器执行 Python 代码
+ */
+import Docker from 'dockerode'
+import path from 'path'
+import { fileURLToPath } from 'url'
+import fs from 'fs'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+// 检测运行模式并计算正确的路径
+// 开发模式: 从 local-server/src 运行，项目根目录在上两级
+// 独立模式: 从 packages/cli/src/server 运行，无 shared_modules 目录
+function detectProjectRoot() {
+  // 尝试向上两级查找 local-server 目录（开发模式）
+  const candidateRoot = path.resolve(__dirname, '..', '..')
+  const localServerPath = path.join(candidateRoot, 'local-server')
+  if (fs.existsSync(localServerPath)) {
+    return candidateRoot
+  }
+
+  // 尝试向上三级查找（独立模式下的项目根目录）
+  const standaloneRoot = path.resolve(__dirname, '..', '..', '..')
+  const standaloneLocalServer = path.join(standaloneRoot, 'local-server')
+  if (fs.existsSync(standaloneLocalServer)) {
+    return standaloneRoot
+  }
+
+  // 独立安装模式，无项目根目录
+  return null
+}
+
+const PROJECT_ROOT = detectProjectRoot()
+
+// 共享模块目录（仅开发模式可用）
+const DEFAULT_SHARED_MODULES_PATH = PROJECT_ROOT
+  ? path.join(PROJECT_ROOT, 'local-server', 'shared_modules')
+  : null
+
+const docker = new Docker()
+
+// 沙箱配置
+const SANDBOX_CONFIG = {
+  imageCpu: 'dmla-sandbox:cpu',
+  imageGpu: 'dmla-sandbox:gpu',
+  timeout: 60000,           // 60 秒超时
+  memory: 4 * 1024 * 1024 * 1024  // 4GB 内存
+}
+
+/**
+ * 获取共享模块路径
+ */
+function getSharedModulesPath() {
+  // 优先使用环境变量指定的路径
+  if (process.env.SHARED_MODULES_PATH) {
+    return process.env.SHARED_MODULES_PATH
+  }
+  // 开发模式下的默认路径
+  return DEFAULT_SHARED_MODULES_PATH
+}
+
+/**
+ * 检查是否启用 Volume Mount
+ */
+function shouldMountSharedModules() {
+  return process.env.MOUNT_SHARED_MODULES !== 'false'
+}
+
+/**
+ * 检查 GPU 是否可用
+ * 通过运行 nvidia-smi 命令检测 GPU 状态
+ */
+export async function checkGPUAvailable() {
+  let container = null
+
+  try {
+    // 创建容器运行 nvidia-smi 命令
+    container = await docker.createContainer({
+      Image: 'nvidia/cuda:11.8-base',
+      Cmd: ['nvidia-smi', '-L'],
+      HostConfig: {
+        DeviceRequests: [{
+          Driver: 'nvidia',
+          Count: -1,  // 使用所有 GPU
+          Capabilities: [['gpu']]
+        }]
+      }
+    })
+
+    // 启动容器
+    await container.start()
+
+    // 等待执行完成
+    await container.wait()
+
+    // 获取输出日志
+    const logs = await container.logs({
+      stdout: true,
+      stderr: true
+    })
+
+    // 解析输出
+    const output = parseDockerLogs(logs)
+
+    // 检查输出是否包含 GPU 信息
+    return output.includes('GPU')
+  } catch {
+    // GPU 不可用或 Docker/nvidia-smi 执行失败
+    return false
+  } finally {
+    // 清理容器
+    if (container) {
+      try {
+        await container.remove({ force: true })
+      } catch {
+        // 忽略清理错误
+      }
+    }
+  }
+}
+
+/**
+ * 执行 Python 代码
+ * 使用 IPython Kernel 执行代码，支持富输出（图片、文本、错误等）
+ * @param {string} code - Python 代码
+ * @param {boolean} useGpu - 是否使用 GPU
+ * @returns {Promise<{success: boolean, outputs: Array, executionTime: number, gpuUsed: boolean}>}
+ */
+export async function runPythonCode(code, useGpu = false) {
+  const startTime = Date.now()
+
+  // 选择镜像
+  const image = useGpu ? SANDBOX_CONFIG.imageGpu : SANDBOX_CONFIG.imageCpu
+
+  // 创建容器配置 - 使用 kernel_runner.py 执行代码
+  const containerConfig = {
+    Image: image,
+    Cmd: ['python3', '/workspace/kernel_runner.py', '--code', code, '--timeout', String(Math.floor(SANDBOX_CONFIG.timeout / 1000))],
+    HostConfig: {
+      Memory: SANDBOX_CONFIG.memory,
+      AutoRemove: false  // 手动移除以获取日志
+    },
+    Env: [
+      'PYTHONUNBUFFERED=1'
+      // matplotlib 使用 IPython Kernel 的 inline 后端，自动发送 display_data
+    ]
+  }
+
+  // Volume Mount 配置 - 挂载共享模块
+  const useMount = shouldMountSharedModules()
+  const sharedModulesPath = getSharedModulesPath()
+
+  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)')
+  }
+
+  // GPU 配置
+  if (useGpu) {
+    containerConfig.HostConfig.DeviceRequests = [{
+      Driver: 'nvidia',
+      Count: -1,  // 使用所有 GPU
+      Capabilities: [['gpu']]
+    }]
+  }
+
+  let container = null
+  let timeoutId = null
+
+  try {
+    // 创建容器
+    container = await docker.createContainer(containerConfig)
+
+    // 设置超时
+    const timeoutPromise = new Promise((_, reject) => {
+      timeoutId = setTimeout(() => {
+        reject(new Error('Execution timeout'))
+      }, SANDBOX_CONFIG.timeout + 10000)  // 额外 10 秒用于清理
+    })
+
+    // 启动容器
+    await container.start()
+
+    // 等待执行完成
+    const waitPromise = container.wait()
+
+    // 竞速: 超时 vs 正常完成
+    const result = await Promise.race([waitPromise, timeoutPromise])
+
+    // 清除超时
+    if (timeoutId) clearTimeout(timeoutId)
+
+    // 获取输出
+    const logs = await container.logs({
+      stdout: true,
+      stderr: true
+    })
+
+    // 解析输出
+    const rawOutput = parseDockerLogs(logs)
+
+    // 解析 JSON 输出
+    let parsedResult
+    try {
+      parsedResult = JSON.parse(rawOutput)
+    } catch (parseError) {
+      // 如果 JSON 解析失败，返回原始输出作为错误
+      const executionTime = (Date.now() - startTime) / 1000
+      return {
+        success: false,
+        outputs: [{
+          type: 'error',
+          ename: 'OutputParseError',
+          evalue: 'Failed to parse kernel output',
+          traceback: [rawOutput]
+        }],
+        executionTime,
+        gpuUsed: useGpu
+      }
+    }
+
+    return {
+      success: parsedResult.success,
+      outputs: parsedResult.outputs || [],
+      executionTime: parsedResult.executionTime || (Date.now() - startTime) / 1000,
+      gpuUsed: useGpu
+    }
+
+  } catch (error) {
+    // 清除超时
+    if (timeoutId) clearTimeout(timeoutId)
+
+    const executionTime = (Date.now() - startTime) / 1000
+
+    return {
+      success: false,
+      outputs: [{
+        type: 'error',
+        ename: error.name || 'ExecutionError',
+        evalue: error.message || 'Unknown error',
+        traceback: [error.message || 'Unknown error']
+      }],
+      executionTime,
+      gpuUsed: useGpu
+    }
+
+  } finally {
+    // 清理容器
+    if (container) {
+      try {
+        await container.remove({ force: true })
+      } catch (e) {
+        console.warn('Failed to remove container:', e.message)
+      }
+    }
+  }
+}
+
+/**
+ * 解析 Docker 日志输出
+ * Docker 日志格式: [8字节头][数据]
+ */
+function parseDockerLogs(logs) {
+  if (!logs || logs.length === 0) return ''
+
+  // 如果是 Buffer
+  if (Buffer.isBuffer(logs)) {
+    let output = ''
+    let offset = 0
+
+    while (offset < logs.length) {
+      // 跳过 8 字节头
+      if (offset + 8 > logs.length) break
+
+      const streamType = logs[offset]
+      const length = logs.readUInt32BE(offset + 4)
+
+      offset += 8
+
+      if (offset + length > logs.length) break
+
+      const chunk = logs.slice(offset, offset + length).toString('utf8')
+      output += chunk
+      offset += length
+    }
+
+    return output
+  }
+
+  // 如果是字符串
+  return logs.toString()
+}
+
+/**
+ * 检查沙箱镜像是否存在
+ */
+export async function checkImageExists(useGpu = false) {
+  const image = useGpu ? SANDBOX_CONFIG.imageGpu : SANDBOX_CONFIG.imageCpu
+
+  try {
+    await docker.getImage(image).inspect()
+    return true
+  } catch {
+    return false
+  }
+}
+
+/**
+ * 拉取沙箱镜像
+ */
+export async function pullImage(useGpu = false) {
+  const image = useGpu ? SANDBOX_CONFIG.imageGpu : SANDBOX_CONFIG.imageCpu
+
+  return new Promise((resolve, reject) => {
+    docker.pull(image, (err, stream) => {
+      if (err) {
+        reject(err)
+        return
+      }
+
+      docker.modem.followProgress(stream, (err, output) => {
+        if (err) {
+          reject(err)
+        } else {
+          resolve(output)
+        }
+      })
+    })
+  })
+}
+
+export default {
+  runPythonCode,
+  checkGPUAvailable,
+  checkImageExists,
+  pullImage
+}

package/tests/cli.test.js

@@ -1,34 +0,0 @@
-/**
- * CLI 命令单元测试
- */
-import { describe, it, expect, beforeAll } from '@jest/globals'
-import { fileURLToPath } from 'url'
-import path from 'path'
-import fs from 'fs'
-
-// ESM 中获取 __dirname
-const __filename = fileURLToPath(import.meta.url)
-const __dirname = path.dirname(__filename)
-
-// 基础测试：确保模块可导入
-describe('CLI Module', () => {
-  beforeAll(() => {
-    // 设置测试环境
-  })
-
-  it('should have correct package.json', async () => {
-    const pkgPath = path.resolve(__dirname, '../package.json')
-    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'))
-
-    expect(pkg.name).toBe('@icyfenix-dmla/cli')
-    expect(pkg.bin).toBeDefined()
-    expect(pkg.bin.dmla).toBe('./bin/dmla.js')
-  })
-
-  it('should have commander dependency', async () => {
-    const pkgPath = path.resolve(__dirname, '../package.json')
-    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'))
-
-    expect(pkg.dependencies.commander).toBeDefined()
-  })
-})