@icyfenix-dmla/cli 2026.5.3-1305 → 2026.5.3-2128

package/package.json

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

package/src/server/dmla_progress.py

@@ -36,7 +36,8 @@ class ProgressReporter:
         self,
         total_steps: int,
         description: str = "",
-        start_step: int = 0
+        start_step: int = 0,
+        clear_existing: bool = True
     ):
         """
         初始化进度报告器
@@ -45,17 +46,26 @@ class ProgressReporter:
             total_steps: 总步数（如 epoch 数）
             description: 任务描述
             start_step: 起始步数（默认 0）
+            clear_existing: 是否清除已存在的进度文件（默认 True）
         """
         self.total_steps = total_steps
         self.description = description
         self.current_step = start_step
         self.start_time = time.time()
 
-        # 写入初始状态
+        # 清除旧的进度文件，避免显示上一个任务的进度
+        if clear_existing:
+            clear_progress()
+
+        # 计算初始百分比
+        initial_percent = (start_step / total_steps) * 100 if total_steps > 0 else 0
+
+        # 写入初始状态（包含 percent）
         self._write_progress(
             step=start_step,
             status="starting",
-            message=description
+            message=description,
+            percent=initial_percent
         )
 
     def update(
@@ -117,11 +127,12 @@ class ProgressReporter:
             self.start_time = time.time()
         self.current_step = 0
 
-        # 写入新阶段的初始状态
+        # 写入新阶段的初始状态（包含 percent=0）
         self._write_progress(
             step=0,
             status="starting",
-            message=self.description
+            message=self.description,
+            percent=0.0
         )
 
     def complete(self, message: str = "", extra_data: Optional[dict] = None):
@@ -175,7 +186,7 @@ class ProgressReporter:
         extra_data: Optional[dict] = None
     ):
         """
-        写入进度文件
+        写入进度信息（stdout + 文件双模式）
 
         Args:
             step: 当前步数
@@ -187,6 +198,7 @@ class ProgressReporter:
             extra_data: 额外数据
         """
         data = {
+            "type": "progress",  # 流式消息类型标识
             "description": self.description,
             "total_steps": self.total_steps,
             "current_step": step,
@@ -202,7 +214,17 @@ class ProgressReporter:
         if extra_data:
             data["extra_data"] = extra_data
 
-        # 写入文件
+        # 1. stderr 输出（用于流式 HTTP 响应，与 stdout 分开避免合并）
+        # Jupyter kernel 会将 stdout 和 stderr 分到不同的 stream 消息
+        try:
+            import sys
+            sys.stderr.write(json.dumps(data, ensure_ascii=False) + '\n')
+            sys.stderr.flush()
+        except Exception as e:
+            # stderr 输出失败不影响训练，仅打印警告
+            print(f"Warning: Failed to output progress to stderr: {e}")
+
+        # 2. 文件写入（作为降级/备用方案）
         try:
             PROGRESS_FILE.write_text(json.dumps(data, ensure_ascii=False))
         except Exception as e:

package/src/server/kernel_runner.py

@@ -156,18 +156,19 @@ def enrich_cuda_error(error_dict: dict) -> dict:
     return error_dict
 
 
-def run_code(code: str, timeout: int = DEFAULT_TIMEOUT) -> dict:
+def run_code(code: str, timeout: int = DEFAULT_TIMEOUT, stream: bool = False) -> dict:
     """
     使用 IPython Kernel 执行代码
 
     Args:
         code: 要执行的 Python 代码
         timeout: 执行超时时间（秒）
+        stream: 是否启用流式输出模式（实时输出每个消息）
 
     Returns:
-        包含 success, outputs, executionTime 的字典
+        包含 success, outputs, executionTime 的字典（stream 模式下返回空字典）
     """
-    log_debug(f'run_code called, code length={len(code)}, timeout={timeout}')
+    log_debug(f'run_code called, code length={len(code)}, timeout={timeout}, stream={stream}')
 
     # 注意：不再在执行期间抑制 stdout
     # stdout 只在导入阶段抑制（避免 matplotlib 等导入输出污染结果）
@@ -179,9 +180,11 @@ def run_code(code: str, timeout: int = DEFAULT_TIMEOUT) -> dict:
     deadline = start_time + timeout
     km = None
     kc = None
-    outputs = []
+    outputs = []  # stream 模式下不使用，保留用于非流式模式
     timed_out = False
     msg_count = 0
+    has_error = False
+    final_outputs = []  # 用于最终 result 消息的 outputs 汇总
 
     try:
         # 1. 启动 Kernel（抑制 stdout 避免启动输出污染）
@@ -248,28 +251,48 @@ def run_code(code: str, timeout: int = DEFAULT_TIMEOUT) -> dict:
 
             # 处理不同类型的输出
             if msg_type == 'stream':
-                outputs.append({
+                stream_output = {
                     'type': 'stream',
                     'name': content.get('name', 'stdout'),
                     'text': content.get('text', '')
-                })
+                }
+
+                if stream:
+                    # 流式模式：立即输出
+                    print(json.dumps(stream_output, ensure_ascii=False), flush=True)
+                else:
+                    outputs.append(stream_output)
                 log_debug(f'Stream output: {content.get("name")} len={len(content.get("text", ""))}')
 
             elif msg_type == 'display_data':
-                outputs.append({
+                display_output = {
                     'type': 'display_data',
                     'data': content.get('data', {}),
                     'metadata': content.get('metadata', {})
-                })
+                }
+
+                if stream:
+                    # 流式模式：立即输出
+                    print(json.dumps(display_output, ensure_ascii=False), flush=True)
+                else:
+                    outputs.append(display_output)
+                final_outputs.append(display_output)  # 汇总到最终结果
                 log_debug(f'Display data: keys={list(content.get("data", {}).keys())}')
 
             elif msg_type == 'execute_result':
-                outputs.append({
+                result_output = {
                     'type': 'execute_result',
                     'data': content.get('data', {}),
                     'metadata': content.get('metadata', {}),
                     'execution_count': content.get('execution_count')
-                })
+                }
+
+                if stream:
+                    # 流式模式：立即输出
+                    print(json.dumps(result_output, ensure_ascii=False), flush=True)
+                else:
+                    outputs.append(result_output)
+                final_outputs.append(result_output)  # 汇总到最终结果
                 log_debug(f'Execute result: keys={list(content.get("data", {}).keys())}')
 
             elif msg_type == 'error':
@@ -286,7 +309,14 @@ def run_code(code: str, timeout: int = DEFAULT_TIMEOUT) -> dict:
                     error_output = enrich_cuda_error(error_output)
                     log_debug(f'Detected CUDA compatibility error, enriched output')
 
-                outputs.append(error_output)
+                has_error = True
+
+                if stream:
+                    # 流式模式：立即输出
+                    print(json.dumps(error_output, ensure_ascii=False), flush=True)
+                else:
+                    outputs.append(error_output)
+                final_outputs.append(error_output)  # 汇总到最终结果
                 log_debug(f'Error: {content.get("ename")}: {content.get("evalue")}')
 
             elif msg_type == 'clear_output':
@@ -306,7 +336,7 @@ def run_code(code: str, timeout: int = DEFAULT_TIMEOUT) -> dict:
             log_debug(f'Suppressed output preview: {suppressed_content[:500]}')
 
         if timed_out:
-            return {
+            timeout_result = {
                 'success': False,
                 'outputs': [{
                     'type': 'error',
@@ -316,9 +346,33 @@ def run_code(code: str, timeout: int = DEFAULT_TIMEOUT) -> dict:
                 }],
                 'executionTime': round(execution_time, 3)
             }
+            if stream:
+                # 流式模式：输出超时消息
+                print(json.dumps({'type': 'error', 'ename': 'TimeoutError',
+                                  'evalue': f'Execution timed out after {timeout} seconds',
+                                  'traceback': [f'Execution timed out after {timeout} seconds']},
+                                 ensure_ascii=False), flush=True)
+                print(json.dumps({'type': 'result', 'success': False,
+                                  'executionTime': round(execution_time, 3)},
+                                 ensure_ascii=False), flush=True)
+                return {}
+            return timeout_result
+
+        success = not has_error
+
+        if stream:
+            # 流式模式：输出最终结果消息
+            result_msg = {
+                'type': 'result',
+                'success': success,
+                'outputs': final_outputs,
+                'executionTime': round(execution_time, 3)
+            }
+            print(json.dumps(result_msg, ensure_ascii=False), flush=True)
+            return {}
 
         return {
-            'success': True,
+            'success': success,
             'outputs': outputs,
             'executionTime': round(execution_time, 3)
         }
@@ -341,6 +395,15 @@ def run_code(code: str, timeout: int = DEFAULT_TIMEOUT) -> dict:
             error_output = enrich_cuda_error(error_output)
             log_debug(f'Detected CUDA compatibility error in exception, enriched output')
 
+        if stream:
+            # 流式模式：输出错误消息和结果消息
+            print(json.dumps(error_output, ensure_ascii=False), flush=True)
+            print(json.dumps({'type': 'result', 'success': False,
+                              'outputs': [error_output],
+                              'executionTime': round(execution_time, 3)},
+                             ensure_ascii=False), flush=True)
+            return {}
+
         return {
             'success': False,
             'outputs': [error_output],
@@ -428,6 +491,7 @@ def main():
     parser.add_argument('--code', type=str, required=True, help='要执行的 Python 代码')
     parser.add_argument('--timeout', type=int, default=DEFAULT_TIMEOUT, help='执行超时时间（秒）')
     parser.add_argument('--check-cuda', action='store_true', help='仅检查 CUDA 兼容性')
+    parser.add_argument('--stream', action='store_true', help='启用流式输出模式（实时输出每个消息）')
 
     args = parser.parse_args()
 
@@ -437,13 +501,14 @@ def main():
         print(json.dumps(result, ensure_ascii=False))
         return
 
-    result = run_code(args.code, args.timeout)
+    result = run_code(args.code, args.timeout, stream=args.stream)
 
-    # 输出 JSON 结果到 stdout
-    output_json = json.dumps(result, ensure_ascii=False)
-    log_debug(f'Final JSON output length: {len(output_json)}')
-    log_debug(f'Final JSON preview: {output_json[:500]}')
-    print(output_json)
+    # 非流式模式：输出 JSON 结果到 stdout
+    if not args.stream:
+        output_json = json.dumps(result, ensure_ascii=False)
+        log_debug(f'Final JSON output length: {len(output_json)}')
+        log_debug(f'Final JSON preview: {output_json[:500]}')
+        print(output_json)
 
 
 if __name__ == '__main__':

package/src/server/routes/sandbox.js

@@ -3,7 +3,7 @@
  */
 import { Router } from 'express'
 import Docker from 'dockerode'
-import sandbox, { runPythonCode, checkImageExists, checkGPUAvailable, checkCUDACompatibility, abortExecution } from '../sandbox.js'
+import sandbox, { runPythonCode, runPythonCodeStreaming, checkImageExists, checkGPUAvailable, checkCUDACompatibility, abortExecution } from '../sandbox.js'
 
 const { SANDBOX_CONFIG } = sandbox
 const docker = new Docker()
@@ -121,6 +121,92 @@ router.post('/run', async (req, res) => {
   }
 })
 
+/**
+ * 流式执行代码
+ * POST /api/sandbox/stream
+ * Body: { code: string, useGpu?: boolean, timeout?: number|null }
+ * 响应: JSON Lines 流式输出
+ */
+router.post('/stream', async (req, res) => {
+  const { code, useGpu = false, timeout = null } = req.body
+
+  // 验证请求
+  if (!code || typeof code !== 'string') {
+    return res.status(400).json({
+      success: false,
+      error: 'Missing or invalid code parameter'
+    })
+  }
+
+  // 代码长度限制
+  if (code.length > 100000) {
+    return res.status(400).json({
+      success: false,
+      error: 'Code too long (max 100KB)'
+    })
+  }
+
+  // 验证 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 {
+    // 检查镜像是否存在，智能降级
+    let actualUseGpu = useGpu
+    let actualImage = null
+    let imageExists = await checkImageExists(useGpu)
+
+    if (!imageExists && !useGpu) {
+      const gpuImageExists = await checkImageExists(true)
+      if (gpuImageExists) {
+        imageExists = true
+        actualUseGpu = false
+        actualImage = SANDBOX_CONFIG.imageGpu
+        console.log('[Sandbox Stream] CPU镜像不存在，使用GPU镜像执行')
+      }
+    }
+
+    if (!imageExists) {
+      return res.status(503).json({
+        success: false,
+        error: useGpu
+          ? 'GPU 镜像未安装。请运行 npm run build:sandbox:gpu 或 dmla install --gpu'
+          : '沙箱镜像未安装。请运行 npm run build:sandbox:cpu 或 dmla install --cpu'
+      })
+    }
+
+    // 如果请求 GPU，检查 GPU 是否可用
+    if (actualUseGpu) {
+      const gpuAvailable = await checkGPUAvailable()
+      if (!gpuAvailable) {
+        return res.status(503).json({
+          success: false,
+          error: 'GPU 硬件不可用。请确保系统安装了 NVIDIA GPU 驱动和 nvidia-container-toolkit。'
+        })
+      }
+    }
+
+    // 流式执行代码
+    await runPythonCodeStreaming(code, actualUseGpu, res, actualImage, timeout)
+
+  } catch (error) {
+    console.error('Sandbox stream error:', error)
+    // 如果响应头已发送，无法发送状态码
+    if (!res.headersSent) {
+      res.status(500).json({
+        success: false,
+        error: error.message || 'Internal sandbox error'
+      })
+    }
+  }
+})
+
 /**
  * GPU 状态检查
  */

package/src/server/sandbox.js

@@ -708,6 +708,318 @@ export async function runPythonCode(code, useGpu = false, imageOverride = null,
   }
 }
 
+/**
+ * 流式执行 Python 代码
+ * 使用 Docker logs follow 模式实时转发容器输出到 HTTP 响应
+ * @param {string} code - Python 代码
+ * @param {boolean} useGpu - 是否启用 GPU 设备
+ * @param {object} res - Express 响应对象
+ * @param {string|null} imageOverride - 可选，指定使用的镜像名称
+ * @param {number|null} timeoutOverride - 可选，超时时间（秒）
+ * @returns {Promise<void>}
+ */
+export async function runPythonCodeStreaming(code, useGpu = false, res, imageOverride = null, timeoutOverride = null) {
+  const startTime = Date.now()
+
+  // 生成唯一执行 ID
+  const executionId = generateExecutionId()
+
+  // 计算实际超时时间
+  const actualTimeout = timeoutOverride === null
+    ? null  // unlimited
+    : (timeoutOverride || Math.floor(SANDBOX_CONFIG.timeout / 1000))
+
+  log(`runPythonCodeStreaming called, executionId=${executionId}, useGpu=${useGpu}, code length=${code.length}`)
+
+  // 设置流式响应头
+  res.setHeader('Content-Type', 'application/x-ndjson')
+  res.setHeader('Transfer-Encoding', 'chunked')
+  res.setHeader('X-Accel-Buffering', 'no')  // 禁用 nginx 缓冲
+  res.setHeader('Cache-Control', 'no-cache')
+  res.setHeader('Connection', 'keep-alive')
+
+  // 选择镜像
+  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 errorMsg = {
+        type: 'error',
+        ename: 'CUDACompatError',
+        evalue: 'CUDA 兼容性错误',
+        traceback: ['PyTorch CUDA 版本与您的 GPU 不兼容，请使用 CPU 模式运行']
+      }
+      res.write(JSON.stringify(errorMsg) + '\n')
+      const resultMsg = {
+        type: 'result',
+        success: false,
+        executionTime: (Date.now() - startTime) / 1000
+      }
+      res.write(JSON.stringify(resultMsg) + '\n')
+      res.end()
+      return
+    }
+    log('CUDA compatibility check passed')
+  }
+
+  // 创建容器配置
+  const timeoutSeconds = actualTimeout === null ? 86400 : actualTimeout
+  const containerConfig = {
+    Image: image,
+    Cmd: ['python3', '/workspace/kernel_runner.py', '--code', code, '--timeout', String(timeoutSeconds), '--stream'],
+    HostConfig: {
+      Memory: SANDBOX_CONFIG.memory,
+      AutoRemove: false
+    },
+    Env: [
+      'PYTHONUNBUFFERED=1',
+      'PYTHONPATH=/workspace',
+      actualTimeout === null ? 'DMLA_NO_TIMEOUT=1' : ''
+    ].filter(e => e)
+  }
+
+  log('Container config created for streaming')
+
+  // Volume Mount 配置（与 runPythonCode 相同）
+  const useMount = shouldMountSharedModules()
+  const sharedModulesPath = getSharedModulesPath()
+  const mountKernelRunner = shouldMountKernelRunner()
+  const kernelRunnerPath = getKernelRunnerPath()
+  const binds = []
+
+  // 挂数据目录
+  const dataVolumePath = getDataVolumePath()
+  if (dataVolumePath && fs.existsSync(dataVolumePath)) {
+    binds.push(`${dataVolumePath}:/data`)
+  }
+
+  // 挂共享模块
+  if (useMount && sharedModulesPath && fs.existsSync(sharedModulesPath)) {
+    binds.push(`${sharedModulesPath}:/workspace/shared:ro`)
+  }
+
+  // 挂 kernel_runner.py
+  if (mountKernelRunner && kernelRunnerPath && fs.existsSync(kernelRunnerPath)) {
+    binds.push(`${kernelRunnerPath}:/workspace/kernel_runner.py:ro`)
+  }
+
+  // 挂 dmla_progress.py
+  const progressReporterPath = getProgressReporterPath()
+  if (mountKernelRunner && progressReporterPath && fs.existsSync(progressReporterPath)) {
+    binds.push(`${progressReporterPath}:/workspace/dmla_progress.py:ro`)
+  }
+
+  if (binds.length > 0) {
+    containerConfig.HostConfig.Binds = binds
+  }
+
+  // GPU 配置
+  if (useGpu) {
+    containerConfig.HostConfig.DeviceRequests = [{
+      Driver: 'nvidia',
+      Count: -1,
+      Capabilities: [['gpu']]
+    }]
+  }
+
+  let container = null
+
+  try {
+    // 创建容器
+    log('Creating container for streaming...')
+    container = await docker.createContainer(containerConfig)
+    log(`Container created: ${container.id}`)
+
+    // 注册到活跃容器列表
+    registerContainer(executionId, container)
+
+    // 输出启动状态消息
+    const statusMsg = {
+      type: 'status',
+      status: 'starting',
+      message: '正在启动容器...',
+      executionId
+    }
+    res.write(JSON.stringify(statusMsg) + '\n')
+
+    // 启动容器
+    log('Starting container...')
+    await container.start()
+    log('Container started')
+
+    // 输出运行状态消息
+    const runningMsg = {
+      type: 'status',
+      status: 'running',
+      message: '代码执行中...'
+    }
+    res.write(JSON.stringify(runningMsg) + '\n')
+
+    // 获取实时日志流
+    log('Starting log stream...')
+    const logStream = await container.logs({
+      stdout: true,
+      stderr: true,
+      follow: true,  // 实时跟踪
+      timestamps: false,
+      tail: 0  // 从当前位置开始
+    })
+
+    // 处理日志流数据
+    logStream.on('data', (chunk) => {
+      if (Buffer.isBuffer(chunk)) {
+        // 解析 Docker 日志格式
+        const lines = parseDockerLogLines(chunk)
+        for (const { streamType, text } of lines) {
+          if (text && text.trim()) {
+            log(`Stream output (${streamType}): ${text.substring(0, 100)}...`)
+            // kernel_runner.py 已经输出 JSON 格式消息，直接转发
+            // 检查是否已经是 JSON 格式（stream, result, progress 等消息）
+            if (text.trim().startsWith('{') && text.includes('"type":')) {
+              res.write(text + '\n')
+            } else {
+              // 非 JSON 内容（如容器启动日志），包装为 stream 消息
+              res.write(JSON.stringify({
+                type: 'stream',
+                name: streamType,
+                text: text
+              }) + '\n')
+            }
+          }
+        }
+      } else {
+        // 字符串格式（fallback）
+        const textLines = chunk.toString().split('\n').filter(l => l.trim())
+        for (const line of textLines) {
+          if (line.trim().startsWith('{') && line.includes('"type":')) {
+            res.write(line + '\n')
+          } else {
+            res.write(JSON.stringify({
+              type: 'stream',
+              name: 'stdout',
+              text: line
+            }) + '\n')
+          }
+        }
+      }
+    })
+
+    logStream.on('error', (err) => {
+      log(`Log stream error: ${err.message}`)
+      const errorMsg = {
+        type: 'error',
+        ename: 'StreamError',
+        evalue: err.message,
+        traceback: [err.message]
+      }
+      res.write(JSON.stringify(errorMsg) + '\n')
+    })
+
+    // 等待容器结束
+    log('Waiting for container to finish...')
+    await container.wait()
+    log('Container finished')
+
+    // 等待日志流结束
+    await new Promise((resolve) => {
+      logStream.on('end', resolve)
+      // 确保流已结束（可能已经结束）
+      if (logStream.destroyed || logStream.readableEnded) {
+        resolve()
+      }
+    })
+
+    log('Log stream ended')
+
+  } catch (error) {
+    log(`Streaming execution error: ${error.message}`)
+    log(`Error stack: ${error.stack}`)
+
+    const errorMsg = {
+      type: 'error',
+      ename: error.name || 'ExecutionError',
+      evalue: error.message || 'Unknown error',
+      traceback: [error.message || 'Unknown error']
+    }
+    res.write(JSON.stringify(errorMsg) + '\n')
+
+    const resultMsg = {
+      type: 'result',
+      success: false,
+      executionTime: (Date.now() - startTime) / 1000
+    }
+    res.write(JSON.stringify(resultMsg) + '\n')
+
+  } finally {
+    // 从活跃列表移除
+    unregisterContainer(executionId)
+
+    // 清理容器
+    log('Cleaning up container...')
+    if (container) {
+      try {
+        await container.remove({ force: true })
+        log('Container removed')
+      } catch (e) {
+        log(`Container cleanup error: ${e.message}`)
+      }
+    }
+
+    // 结束响应
+    res.end()
+    log('Streaming response ended')
+  }
+}
+
+/**
+ * 解析 Docker 日志流中的多行数据
+ * Docker 日志格式: [8字节头][数据]
+ * @param {Buffer} buffer - Docker 日志 buffer
+ * @returns {string[]} - 解析后的行数组
+ */
+function parseDockerLogLines(buffer) {
+  if (!Buffer.isBuffer(buffer) || buffer.length === 0) return []
+
+  const lines = []
+  let offset = 0
+
+  while (offset < buffer.length) {
+    // 检查是否有完整的头部
+    if (offset + 8 > buffer.length) break
+
+    const streamType = buffer[offset]  // 1=stdout, 2=stderr
+    const length = buffer.readUInt32BE(offset + 4)
+
+    offset += 8
+
+    // 检查是否有完整的数据
+    if (offset + length > buffer.length) break
+
+    const chunk = buffer.slice(offset, offset + length).toString('utf8')
+    offset += length
+
+    // 按行分割（一个 Docker 消息可能包含多行）
+    const chunkLines = chunk.split('\n').filter(l => l.trim())
+    for (const line of chunkLines) {
+      // 返回包含 streamType 的对象
+      lines.push({
+        streamType: streamType === 1 ? 'stdout' : 'stderr',
+        text: line
+      })
+    }
+  }
+
+  return lines
+}
+
 /**
  * 解析 Docker 日志输出
  * Docker 日志格式: [8字节头][数据]
@@ -826,6 +1138,7 @@ export async function pullImage(useGpu = false) {
 
 export default {
   runPythonCode,
+  runPythonCodeStreaming,
   checkGPUAvailable,
   checkCUDACompatibility,
   checkImageExists,

package/version.json

@@ -1,4 +1,4 @@
 {
-  "buildTime": "2026-05-03T05:06:40.087Z",
-  "cliVersion": "2026.5.3-1305"
+  "buildTime": "2026-05-03T13:29:41.242Z",
+  "cliVersion": "2026.5.3-2128"
 }