@icyfenix-dmla/cli 2026.5.2-7 → 2026.5.3-821

package/src/commands/server.js

@@ -21,6 +21,106 @@ const CONFIG = {
   defaultPort: 3001
 }
 
+/**
+ * 从 Docker 镜像标签解析日期
+ * 标签格式: YYYY.M.D-HHMM (如 2026.4.21-2025)
+ * @returns {Date|null}
+ */
+function parseImageTagDate(tag) {
+  const match = tag.match(/^(\d{4})\.(\d{1,2})\.(\d{1,2})-(\d{4})$/)
+  if (!match) return null
+
+  const [, year, month, day, time] = match
+  const hour = time.substring(0, 2)
+  const minute = time.substring(2, 4)
+
+  return new Date(`${year}-${month.padStart(2, '0')}-${day.padStart(2, '0')}T${hour}:${minute}:00+08:00`)
+}
+
+/**
+ * 获取 Docker 镜像的最新标签日期
+ * @param {string} imageType - 'cpu' 或 'gpu'
+ * @returns {Promise<Date|null>}
+ */
+async function getImageLatestDate(imageType) {
+  const imageName = imageType === 'gpu' ? 'dmla-sandbox' : 'dmla-sandbox'
+
+  try {
+    const images = await docker.listImages()
+    const targetTag = imageType === 'gpu' ? ':gpu' : ':cpu'
+
+    for (const image of images) {
+      if (image.RepoTags) {
+        for (const tag of image.RepoTags) {
+          if (tag.includes(imageName) && tag.includes(targetTag)) {
+            // 尝试从标签解析日期
+            const tagPart = tag.split(':')[1]
+            const date = parseImageTagDate(tagPart)
+            if (date) return date
+
+            // 如果标签不是日期格式，使用镜像创建时间
+            return new Date(image.Created * 1000)
+          }
+        }
+      }
+    }
+    return null
+  } catch {
+    return null
+  }
+}
+
+/**
+ * 获取 CLI 包的构建日期
+ * @returns {Date|null}
+ */
+function getCliBuildDate() {
+  try {
+    // 尝试读取 version.json（build 时生成）
+    const versionPath = path.resolve(__dirname, '../../version.json')
+    if (fs.existsSync(versionPath)) {
+      const versionInfo = JSON.parse(fs.readFileSync(versionPath, 'utf8'))
+      return new Date(versionInfo.buildTime)
+    }
+
+    // 如果没有 version.json，使用 package.json 的修改时间作为参考
+    const pkgPath = path.resolve(__dirname, '../../package.json')
+    if (fs.existsSync(pkgPath)) {
+      const stats = fs.statSync(pkgPath)
+      return stats.mtime
+    }
+
+    return null
+  } catch {
+    return null
+  }
+}
+
+/**
+ * 检查 --dev 模式的版本兼容性
+ * 比较镜像标签日期和 CLI 包构建日期
+ */
+async function checkDevModeCompatibility(imageType) {
+  const imageDate = await getImageLatestDate(imageType)
+  const cliDate = getCliBuildDate()
+
+  if (!imageDate || !cliDate) {
+    // 无法获取日期，不警告
+    return { compatible: true, imageDate: null, cliDate: null }
+  }
+
+  // 镜像日期比 CLI 包日期新，说明用户可能更新了镜像但 CLI 包是旧版本
+  // 在 --dev 模式下，本地代码会覆盖镜像中的代码，可能导致代码版本不匹配
+  const imageNewer = imageDate > cliDate
+
+  return {
+    compatible: !imageNewer,
+    imageDate,
+    cliDate,
+    warning: imageNewer ? '镜像版本比 CLI 包更新，本地代码可能覆盖了新版本镜像中的代码' : null
+  }
+}
+
 /**
  * 检查端口是否可用
  */
@@ -226,12 +326,43 @@ function findServerPath() {
   return null
 }
 
+/**
+ * 查找共享模块目录
+ * --dev 模式下需要挂载此目录
+ */
+function findSharedModulesPath() {
+  // 开发环境路径：packages/cli/src/commands -> ../../../local-server/shared_modules
+  const devPath = path.resolve(__dirname, '../../../local-server/shared_modules')
+  // npm 包路径：packages/cli/src/commands -> ../../shared_modules（构建后）
+  const npmPath = path.resolve(__dirname, '../../shared_modules')
+  // CLI 包根目录下的 shared_modules（构建后）
+  const cliRootPath = path.resolve(__dirname, '../../shared_modules')
+
+  // 优先使用开发环境路径（如果 local-server 存在）
+  if (fs.existsSync(devPath) && fs.readdirSync(devPath).length > 0) {
+    return devPath
+  }
+
+  // 其次使用 npm 包路径
+  if (fs.existsSync(npmPath) && fs.readdirSync(npmPath).length > 0) {
+    return npmPath
+  }
+
+  // 最后检查 CLI 包根目录
+  if (fs.existsSync(cliRootPath) && fs.readdirSync(cliRootPath).length > 0) {
+    return cliRootPath
+  }
+
+  return null
+}
+
 /**
  * 同步启动服务（在当前进程运行，用于调试）
  * @param {number} port - 服务端口
  * @param {boolean} useGpu - 是否使用 GPU（可选，自动检测）
+ * @param {boolean} dev - 开发模式（挂载本地代码）
  */
-export async function startServerSync(port, useGpu = false) {
+export async function startServerSync(port, useGpu = false, dev = false) {
   // 检查端口
   const portAvailable = await checkPortAvailable(port)
   if (!portAvailable) {
@@ -249,6 +380,20 @@ export async function startServerSync(port, useGpu = false) {
   }
   const resolvedUseGpu = imageResolution.imageType === 'gpu'
 
+  // --dev 模式版本检查
+  if (dev) {
+    const compat = await checkDevModeCompatibility(imageResolution.imageType)
+    if (!compat.compatible) {
+      console.log(chalk.yellow('⚠️ 开发模式版本兼容性警告'))
+      console.log(chalk.gray(`   镜像构建时间: ${compat.imageDate?.toLocaleString('zh-CN') || '未知'}`))
+      console.log(chalk.gray(`   CLI 包构建时间: ${compat.cliDate?.toLocaleString('zh-CN') || '未知'}`))
+      console.log(chalk.yellow(`   风险: ${compat.warning}`))
+      console.log(chalk.gray('   说明: --dev 模式会挂载本地代码到容器，可能覆盖镜像中的新版本代码'))
+      console.log(chalk.gray('   建议: 如需使用镜像最新功能，请退出 --dev 模式，或更新 CLI 包'))
+      console.log()
+    }
+  }
+
   // 检查服务是否已运行
   const alreadyRunning = await checkServiceRunning(port)
   if (alreadyRunning) {
@@ -276,13 +421,23 @@ 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
   }
 
+  // 查找共享模块路径（--dev 模式需要）
+  const sharedModulesPath = dev ? findSharedModulesPath() : null
+  if (dev && !sharedModulesPath) {
+    console.log(chalk.yellow('⚠️ --dev 模式需要共享模块目录'))
+    console.log(chalk.gray('   未找到 shared_modules，将仅使用镜像内置模块'))
+  }
+
   console.log(chalk.gray(`   镜像类型: ${imageResolution.message}`))
   console.log(chalk.gray('   同步模式启动...'))
   console.log(chalk.gray(`   服务入口: ${actualServerPath}`))
+  if (dev && sharedModulesPath) {
+    console.log(chalk.gray(`   共享模块: ${sharedModulesPath}`))
+  }
   console.log()
 
   // 设置环境变量
@@ -290,6 +445,15 @@ export async function startServerSync(port, useGpu = false) {
   process.env.USE_GPU = resolvedUseGpu ? 'true' : 'false'
   process.env.DMLA_SYNC_MODE = 'true'  // 标记同步模式，让服务器在 import 时启动
 
+  // --dev 模式：启用 Volume Mount
+  if (dev) {
+    process.env.MOUNT_SHARED_MODULES = 'true'
+    process.env.MOUNT_KERNEL_RUNNER = 'true'
+    if (sharedModulesPath) {
+      process.env.SHARED_MODULES_PATH = sharedModulesPath
+    }
+  }
+
   // 动态 import 服务器模块并直接运行
   // 服务器模块会在 import 时自动启动（因为入口点检测逻辑）
   // Windows 需要将路径转换为 file:// URL 格式
@@ -304,8 +468,11 @@ export async function startServerSync(port, useGpu = false) {
 
 /**
  * 启动服务（异步模式，spawn 子进程）
+ * @param {number} port - 服务端口
+ * @param {boolean} useGpu - 是否使用 GPU（可选，自动检测）
+ * @param {boolean} dev - 开发模式（挂载本地代码）
  */
-export async function startServer(port, useGpu = false) {
+export async function startServer(port, useGpu = false, dev = false) {
   // 检查端口
   const portAvailable = await checkPortAvailable(port)
   if (!portAvailable) {
@@ -323,6 +490,20 @@ export async function startServer(port, useGpu = false) {
   }
   const resolvedUseGpu = imageResolution.imageType === 'gpu'
 
+  // --dev 模式版本检查
+  if (dev) {
+    const compat = await checkDevModeCompatibility(imageResolution.imageType)
+    if (!compat.compatible) {
+      console.log(chalk.yellow('⚠️ 开发模式版本兼容性警告'))
+      console.log(chalk.gray(`   镜像构建时间: ${compat.imageDate?.toLocaleString('zh-CN') || '未知'}`))
+      console.log(chalk.gray(`   CLI 包构建时间: ${compat.cliDate?.toLocaleString('zh-CN') || '未知'}`))
+      console.log(chalk.yellow(`   风险: ${compat.warning}`))
+      console.log(chalk.gray('   说明: --dev 模式会挂载本地代码到容器，可能覆盖镜像中的新版本代码'))
+      console.log(chalk.gray('   建议: 如需使用镜像最新功能，请退出 --dev 模式，或更新 CLI 包'))
+      console.log()
+    }
+  }
+
   // 检查服务是否已运行
   const alreadyRunning = await checkServiceRunning(port)
   if (alreadyRunning) {
@@ -338,7 +519,7 @@ export async function startServer(port, useGpu = false) {
       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('      1. 升级 NVIDIA 驾动到 570+ 版本'))
       console.log(chalk.gray('      2. 使用 CPU 模式: dmla start'))
       console.log()
       console.log(chalk.gray('   继续启动 GPU 模式（可能会失败）...'))
@@ -359,6 +540,12 @@ export async function startServer(port, useGpu = false) {
       return
     }
 
+    // 查找共享模块路径（--dev 模式需要）
+    const sharedModulesPath = dev ? findSharedModulesPath() : null
+    if (dev && sharedModulesPath) {
+      console.log(chalk.gray(`   共享模块: ${sharedModulesPath}`))
+    }
+
     // 日志文件路径
     const logDir = path.resolve(__dirname, '../../logs')
     if (!fs.existsSync(logDir)) {
@@ -380,12 +567,27 @@ export async function startServer(port, useGpu = false) {
       DMLA_LOG_FILE: logFile  // 传递日志文件路径给服务端
     }
 
+    // --dev 模式：启用 Volume Mount
+    if (dev) {
+      env.MOUNT_SHARED_MODULES = 'true'
+      env.MOUNT_KERNEL_RUNNER = 'true'
+      if (sharedModulesPath) {
+        env.SHARED_MODULES_PATH = sharedModulesPath
+      }
+    }
+
     // 写入启动日志
     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`)
+    if (dev) {
+      fs.writeSync(logStream, `[${timestamp}] Dev mode: enabled (volume mount)\n`)
+      if (sharedModulesPath) {
+        fs.writeSync(logStream, `[${timestamp}] Shared modules: ${sharedModulesPath}\n`)
+      }
+    }
 
     // 使用 spawn 启动 server 进程
     // 重要：stdio 必须是 'ignore' 或管道，不能是 'inherit'
@@ -425,6 +627,9 @@ export async function startServer(port, useGpu = false) {
         console.log(chalk.green(`✅ 服务已启动: http://localhost:${port}`))
         console.log(chalk.gray(`   健康检查: http://localhost:${port}/api/health`))
         console.log(chalk.gray(`   日志查看: ${logFile}`))
+        if (dev) {
+          console.log(chalk.cyan('   开发模式: 已启用 Volume Mount'))
+        }
         return
       }
       await new Promise(resolve => setTimeout(resolve, 500))

package/src/index.js

@@ -9,6 +9,7 @@ import { fileURLToPath } from 'url'
 import fs from 'fs'
 import { startServer, startServerSync, stopServer, getStatus } from './commands/server.js'
 import { runDoctor } from './commands/manage.js'
+import { runDataTUI, runDataCommand } from './commands/data.js'
 import { runInstallTUI } from '@icyfenix-dmla/install'
 
 // 从 package.json 读取版本号
@@ -93,10 +94,12 @@ program
   .option('-p, --port <number>', '服务端口', '3001')
   .option('--gpu', '使用 GPU 镜像')
   .option('--sync', '同步模式：在当前进程运行，日志直接输出（用于调试）')
+  .option('--dev', '开发模式：挂载本地代码到容器，无需重建镜像')
   .action(async (options) => {
     const port = parseInt(options.port, 10)
     const useGpu = options.gpu
     const sync = options.sync
+    const dev = options.dev
 
     console.log(chalk.blue('启动 DMLA 沙箱服务...'))
     console.log(chalk.gray(`   端口: ${port}`))
@@ -104,11 +107,14 @@ program
     if (sync) {
       console.log(chalk.yellow(`   模式: 同步（调试模式）`))
     }
+    if (dev) {
+      console.log(chalk.cyan(`   模式: 开发（挂载本地代码）`))
+    }
 
     if (sync) {
-      await startServerSync(port, useGpu)
+      await startServerSync(port, useGpu, dev)
     } else {
-      await startServer(port, useGpu)
+      await startServer(port, useGpu, dev)
     }
   })
 
@@ -155,4 +161,19 @@ program
     await runDoctor()
   })
 
+// ─────────────────────────────────────────────────────────────
+// data 命令
+// ─────────────────────────────────────────────────────────────
+program
+  .command('data [subcommand]')
+  .description('数据管理（挂载、下载、清理等）')
+  .option('-p, --path <path>', '设置挂载路径')
+  .action(async (subcommand, options) => {
+    if (subcommand) {
+      await runDataCommand(subcommand, options)
+    } else {
+      await runDataTUI()
+    }
+  })
+
 program.parse()

package/src/server/routes/sandbox.js

@@ -2,9 +2,11 @@
  * 沙箱 API 路由
  */
 import { Router } from 'express'
+import Docker from 'dockerode'
 import sandbox, { runPythonCode, checkImageExists, checkGPUAvailable, checkCUDACompatibility } from '../sandbox.js'
 
 const { SANDBOX_CONFIG } = sandbox
+const docker = new Docker()
 
 const router = Router()
 
@@ -36,10 +38,10 @@ router.get('/health', async (req, res) => {
 /**
  * 执行代码
  * POST /api/sandbox/run
- * Body: { code: string, useGpu?: boolean }
+ * Body: { code: string, useGpu?: boolean, timeout?: number|null }
  */
 router.post('/run', async (req, res) => {
-  const { code, useGpu = false } = req.body
+  const { code, useGpu = false, timeout = null } = req.body
 
   // 验证请求
   if (!code || typeof code !== 'string') {
@@ -57,6 +59,16 @@ router.post('/run', async (req, res) => {
     })
   }
 
+  // 验证 timeout 参数
+  if (timeout !== null && timeout !== undefined) {
+    if (typeof timeout !== 'number' || timeout < 0 || timeout > 86400) {
+      return res.status(400).json({
+        success: false,
+        error: 'Invalid timeout parameter (must be null or number 0-86400)'
+      })
+    }
+  }
+
   try {
     // 检查镜像是否存在，智能降级
     // GPU镜像包含CPU的全部功能，如果CPU镜像不存在但GPU镜像存在，可以使用GPU镜像执行CPU代码
@@ -96,7 +108,7 @@ router.post('/run', async (req, res) => {
     }
 
     // 执行代码（使用确定后的镜像）
-    const result = await runPythonCode(code, actualUseGpu, actualImage)
+    const result = await runPythonCode(code, actualUseGpu, actualImage, timeout)
 
     res.json(result)
 
@@ -128,6 +140,61 @@ router.get('/gpu', async (req, res) => {
   }
 })
 
+/**
+ * 进度查询
+ * GET /api/sandbox/progress
+ * 用于长时间任务的进度轮询
+ */
+router.get('/progress', async (req, res) => {
+  try {
+    // 进度文件在容器内的 /workspace/progress.json
+    // 需要通过 docker exec 读取
+
+    // 查找运行中的沙箱容器
+    const containers = await docker.listContainers({ filters: { status: ['running'] } })
+    const sandboxContainer = containers.find(c =>
+      c.Names.some(name => name.includes('dmla')) ||
+      c.Image.includes('dmla-sandbox')
+    )
+
+    if (!sandboxContainer) {
+      return res.json({ status: 'no_task', message: 'No running task' })
+    }
+
+    // 在容器内读取进度文件
+    const container = docker.getContainer(sandboxContainer.Id)
+    const exec = await container.exec({
+      Cmd: ['cat', '/workspace/progress.json'],
+      AttachStdout: true
+    })
+
+    const stream = await exec.start()
+    const chunks = []
+    stream.on('data', chunk => chunks.push(chunk))
+
+    await new Promise(resolve => stream.on('end', resolve))
+
+    const output = Buffer.concat(chunks).toString()
+
+    // 解析进度 JSON
+    try {
+      // 去除 Docker exec 的头部信息
+      const jsonStart = output.indexOf('{')
+      if (jsonStart !== -1) {
+        const progressData = JSON.parse(output.substring(jsonStart))
+        return res.json(progressData)
+      }
+    } catch {
+      // JSON 解析失败
+    }
+
+    return res.json({ status: 'no_progress', message: 'Progress file not found' })
+
+  } catch (error) {
+    res.json({ status: 'error', message: error.message })
+  }
+})
+
 /**
  * CUDA 兼容性检查
  * 返回详细的 CUDA 环境诊断信息

package/src/server/sandbox.js

@@ -6,6 +6,7 @@ import Docker from 'dockerode'
 import path from 'path'
 import { fileURLToPath } from 'url'
 import fs from 'fs'
+import os from 'os'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = path.dirname(__filename)
@@ -63,6 +64,34 @@ const SANDBOX_CONFIG = {
   memory: 4 * 1024 * 1024 * 1024  // 4GB 内存
 }
 
+// DMLA 配置文件路径
+const DMLA_CONFIG_DIR = path.join(os.homedir(), '.dmla')
+const DMLA_CONFIG_FILE = path.join(DMLA_CONFIG_DIR, 'config.json')
+const DEFAULT_DATA_DIR = path.join(os.homedir(), 'dmla-data')
+
+/**
+ * 读取 DMLA 配置文件
+ */
+function readDmlaConfig() {
+  try {
+    if (fs.existsSync(DMLA_CONFIG_FILE)) {
+      const content = fs.readFileSync(DMLA_CONFIG_FILE, 'utf8')
+      return JSON.parse(content)
+    }
+  } catch (error) {
+    log(`配置文件读取失败: ${error.message}`)
+  }
+  return { dataVolumePath: DEFAULT_DATA_DIR }
+}
+
+/**
+ * 获取数据卷路径
+ */
+function getDataVolumePath() {
+  const config = readDmlaConfig()
+  return config.dataVolumePath || DEFAULT_DATA_DIR
+}
+
 /**
  * 获取共享模块路径
  */
@@ -87,6 +116,21 @@ function getKernelRunnerPath() {
   return DEFAULT_KERNEL_RUNNER_PATH
 }
 
+/**
+ * 获取 dmla_progress.py 路径（开发模式挂载）
+ */
+function getProgressReporterPath() {
+  if (process.env.PROGRESS_REPORTER_PATH) {
+    return process.env.PROGRESS_REPORTER_PATH
+  }
+  return DEFAULT_PROGRESS_REPORTER_PATH
+}
+
+// dmla_progress.py 默认路径
+const DEFAULT_PROGRESS_REPORTER_PATH = PROJECT_ROOT
+  ? path.join(PROJECT_ROOT, 'local-server', 'src', 'dmla_progress.py')
+  : null
+
 /**
  * 检查是否启用 Volume Mount
  */
@@ -270,12 +314,18 @@ print(json.dumps(result))
  * @param {string} code - Python 代码
  * @param {boolean} useGpu - 是否启用 GPU 设备
  * @param {string|null} imageOverride - 可选，指定使用的镜像名称（覆盖默认选择）
+ * @param {number|null} timeoutOverride - 可选，超时时间（秒），null 表示 unlimited
  * @returns {Promise<{success: boolean, outputs: Array, executionTime: number, gpuUsed: boolean}>}
  */
-export async function runPythonCode(code, useGpu = false, imageOverride = null) {
+export async function runPythonCode(code, useGpu = false, imageOverride = null, timeoutOverride = null) {
   const startTime = Date.now()
 
-  log(`runPythonCode called, useGpu=${useGpu}, code length=${code.length}, imageOverride=${imageOverride}`)
+  // 计算实际超时时间
+  const actualTimeout = timeoutOverride === null
+    ? null  // unlimited
+    : (timeoutOverride || Math.floor(SANDBOX_CONFIG.timeout / 1000))
+
+  log(`runPythonCode called, useGpu=${useGpu}, code length=${code.length}, imageOverride=${imageOverride}, timeout=${actualTimeout === null ? 'unlimited' : actualTimeout}`)
 
   // 选择镜像：优先使用指定的镜像，否则根据 useGpu 选择
   const image = imageOverride || (useGpu ? SANDBOX_CONFIG.imageGpu : SANDBOX_CONFIG.imageCpu)
@@ -329,17 +379,21 @@ export async function runPythonCode(code, useGpu = false, imageOverride = null)
   }
 
   // 创建容器配置 - 使用 kernel_runner.py 执行代码
+  const timeoutSeconds = actualTimeout === null ? 86400 : actualTimeout  // unlimited 使用 24 小时
   const containerConfig = {
     Image: image,
-    Cmd: ['python3', '/workspace/kernel_runner.py', '--code', code, '--timeout', String(Math.floor(SANDBOX_CONFIG.timeout / 1000))],
+    Cmd: ['python3', '/workspace/kernel_runner.py', '--code', code, '--timeout', String(timeoutSeconds)],
     HostConfig: {
       Memory: SANDBOX_CONFIG.memory,
       AutoRemove: false  // 手动移除以获取日志
     },
+    // matplotlib 使用 IPython Kernel 的 inline 后端，自动发送 display_data
+    // PYTHONPATH 添加 /workspace 以支持导入 volume-mounted 的模块
     Env: [
-      'PYTHONUNBUFFERED=1'
-      // matplotlib 使用 IPython Kernel 的 inline 后端，自动发送 display_data
-    ]
+      'PYTHONUNBUFFERED=1',
+      'PYTHONPATH=/workspace',
+      actualTimeout === null ? 'DMLA_NO_TIMEOUT=1' : ''
+    ].filter(e => e)  // 过滤空字符串
   }
 
   log('Container config created')
@@ -353,10 +407,22 @@ export async function runPythonCode(code, useGpu = false, imageOverride = null)
   // 收集所有需要挂载的路径
   const binds = []
 
-  // 挂载共享模块
+  // 挂载数据目录
+  const dataVolumePath = getDataVolumePath()
+  if (dataVolumePath && fs.existsSync(dataVolumePath)) {
+    binds.push(`${dataVolumePath}:/data`)
+    console.log(`[Sandbox] 数据目录 Volume Mount: ${dataVolumePath}`)
+  } else if (dataVolumePath) {
+    console.warn(`[Sandbox] 警告: 数据目录不存在: ${dataVolumePath}`)
+    console.log(`[Sandbox] 提示: 运行 'dmla data' 创建数据目录`)
+  }
+
+  // 挂载共享模块到 /workspace/shared（而非 site-packages）
+  // 原因：PYTHONPATH=/workspace，这样 Python 可以直接导入 shared.xxx
+  // 避免 Windows Docker 的 site-packages 路径兼容性问题
   if (useMount && sharedModulesPath && fs.existsSync(sharedModulesPath)) {
-    binds.push(`${sharedModulesPath}:/usr/local/lib/python3.11/site-packages/shared:ro`)
-    console.log(`[Sandbox] 共享模块 Volume Mount: ${sharedModulesPath}`)
+    binds.push(`${sharedModulesPath}:/workspace/shared:ro`)
+    console.log(`[Sandbox] 共享模块 Volume Mount: ${sharedModulesPath} -> /workspace/shared`)
   } else if (useMount && sharedModulesPath) {
     console.warn(`[Sandbox] 警告: 共享模块目录不存在: ${sharedModulesPath}`)
   }
@@ -369,6 +435,15 @@ export async function runPythonCode(code, useGpu = false, imageOverride = null)
     console.warn(`[Sandbox] 警告: kernel_runner.py 不存在: ${kernelRunnerPath}`)
   }
 
+  // 挂载 dmla_progress.py（开发模式新增文件，无需重建镜像）
+  const progressReporterPath = getProgressReporterPath()
+  if (mountKernelRunner && progressReporterPath && fs.existsSync(progressReporterPath)) {
+    binds.push(`${progressReporterPath}:/workspace/dmla_progress.py:ro`)
+    console.log(`[Sandbox] dmla_progress.py Volume Mount: ${progressReporterPath}`)
+  } else if (mountKernelRunner && progressReporterPath) {
+    console.warn(`[Sandbox] 警告: dmla_progress.py 不存在: ${progressReporterPath}`)
+  }
+
   // 设置 Binds
   if (binds.length > 0) {
     containerConfig.HostConfig.Binds = binds
@@ -396,12 +471,13 @@ export async function runPythonCode(code, useGpu = false, imageOverride = null)
     container = await docker.createContainer(containerConfig)
     log(`Container created: ${container.id}`)
 
-    // 设置超时
+    // 设置超时（使用动态计算的超时时间，unlimited 时为 24 小时）
+    const containerTimeoutMs = timeoutSeconds * 1000 + 10000  // 转换为毫秒，额外 10 秒用于清理
     const timeoutPromise = new Promise((_, reject) => {
       timeoutId = setTimeout(() => {
         log('Execution timeout triggered')
         reject(new Error('Execution timeout'))
-      }, SANDBOX_CONFIG.timeout + 10000)  // 额外 10 秒用于清理
+      }, containerTimeoutMs)
     })
 
     // 启动容器

package/version.json

@@ -0,0 +1,4 @@
+{
+  "buildTime": "2026-05-03T00:21:45.756Z",
+  "cliVersion": "2026.5.3-821"
+}