@xcanwin/manyoyo 5.3.6 → 5.3.9

package/README.md

@@ -3,7 +3,8 @@
 </p>
 
 # <p align="center"><a href="https://github.com/xcanwin/manyoyo">MANYOYO（慢悠悠）</a></p>
-<p align="center">一款 AI Agent CLI 安全沙箱，基于 Docker/Podman 保护宿主机，支持 YOLO/SOLO 模式。</p>
+<p align="center">面向 AI Agent CLI 的 Docker / Podman 安全沙箱。</p>
+<p align="center">用于隔离 Claude Code、Codex、Gemini、OpenCode 等命令行智能体，降低宿主机风险，并保持可复现的运行环境。</p>
 <p align="center">
   <a href="https://www.npmjs.com/package/@xcanwin/manyoyo"><img alt="npm" src="https://img.shields.io/npm/v/@xcanwin/manyoyo?style=flat-square" /></a>
   <a href="https://github.com/xcanwin/manyoyo/actions/workflows/npm-publish.yml"><img alt="Build status" src="https://img.shields.io/github/actions/workflow/status/xcanwin/manyoyo/npm-publish.yml?style=flat-square" /></a>
@@ -15,157 +16,185 @@
   <a href="https://xcanwin.github.io/manyoyo/en/">English</a>
 </p>
 <p align="center">
-  📚 在线文档：<a href="https://xcanwin.github.io/manyoyo/">https://xcanwin.github.io/manyoyo/</a>
+  文档：<a href="https://xcanwin.github.io/manyoyo/">https://xcanwin.github.io/manyoyo/</a>
 </p>
 
 ---
 
-## 项目简介
+## 为什么是 MANYOYO
 
-**MANYOYO** 是一款 AI 智能体提效安全沙箱，安全、高效、省 token，专为 Agent YOLO 模式设计，保障宿主机安全。
+AI Agent CLI 往往需要：
 
-预装常见 Agent 与工具，进一步节省 token。循环自由切换 Agent 和 `/bin/bash`，进一步提效。
+- 访问代码仓库
+- 执行 shell 命令
+- 读写文件
+- 安装依赖或调用容器能力
 
-**MANYOYO** 提供隔离的 Docker/Podman 容器环境，用于安全运行 AI 智能体命令行工具。
+直接在宿主机上裸跑这些工具，风险边界通常不清晰。**MANYOYO** 的目标不是替代容器平台，而是把常见 Agent CLI 的运行方式收敛到一个更清晰、可复现、可审计的沙箱入口。
 
-## 功能亮点
+你可以把它理解为：
 
-- **多智能体支持**：支持 claude code, gemini, codex, opencode
-- **安全隔离**：保护宿主机，支持安全容器嵌套（Docker-in-Docker）
-- **快速启动**：快捷开启常见 Agent YOLO / SOLO 模式（例如 claude --dangerously-skip-permissions）
-- **便捷操作**：快速进入 `/bin/bash`
-- **会话恢复**：安装 Skills Marketplace 可快速恢复会话
-- **灵活自定义**：支持配置各 CLI 的 `*_BASE_URL` / `*_AUTH_TOKEN` / `*_API_KEY` 等变量
-- **配置管理**：快捷导入配置文件
-- **高级模式**：支持危险容器嵌套（mount-docker-socket）、自定义沙箱镜像
+- 面向 Agent CLI 的运行包装层
+- 面向团队协作的配置与镜像约定
+- 面向高风险模式的显式边界说明
 
----
+## 核心能力
+
+- **多 Agent 支持**：支持 `claude`、`gemini`、`codex`、`opencode`
+- **容器隔离**：基于 Docker / Podman 运行，降低宿主机暴露面
+- **YOLO / SOLO 工作流**：适配跳过权限确认的高效率模式
+- **统一配置入口**：集中管理 `runs.<name>`、环境变量、挂载与镜像参数
+- **命令可预览**：支持查看配置合并结果与最终命令拼装
+- **会话与 Web 模式**：支持容器会话管理与网页访问入口
+- **镜像可定制**：支持 common / full / 自定义工具集镜像
 
 ## 快速开始
 
 ```bash
-npm install -g @xcanwin/manyoyo    # 安装
+npm install -g @xcanwin/manyoyo
 podman pull ubuntu:24.04           # 仅 Podman 需要
-manyoyo build --iv 1.8.4-common     # 构建镜像
-manyoyo init all          # 从本机 Agent 配置迁移到 ~/.manyoyo
-manyoyo run -r claude                  # 使用 manyoyo.json 的 runs.claude 启动
+manyoyo build --iv 1.8.4-common
+manyoyo init all
+manyoyo run -r claude
 ```
 
-注意：YOLO/SOLO 会跳过权限确认，请确保在可控环境中使用。
+系统要求：
 
----
+- Node.js >= 22
+- Podman（推荐）或 Docker
 
-## 适用场景（高频）
+注意：
 
-- 安全运行 **Claude Code YOLO** / **SOLO** 模式
-- 在容器中运行 **Codex CLI**，降低宿主机风险
-- 使用 **Gemini CLI / OpenCode** 做代码任务隔离
-- 用 **Docker/Podman sandbox** 统一团队 Agent 运行环境
+- `YOLO / SOLO` 会跳过权限确认，只适合在可控环境中使用
+- `sock` 模式会暴露宿主机 Docker socket，不属于强隔离
+
+## 适合什么场景
+
+- 在容器中运行 **Claude Code YOLO / SOLO**
+- 为 **Codex CLI** 提供独立于宿主机的运行边界
+- 隔离运行 **Gemini CLI / OpenCode** 的代码任务
+- 用统一镜像和配置管理团队 Agent 环境
+- 在调试和自动化任务中快速切换 Agent 与 `/bin/bash`
 
 ## 裸跑 vs MANYOYO
 
 | 对比项 | 裸跑 Agent CLI | MANYOYO |
 | --- | --- | --- |
-| 宿主机风险 | 高 | 低（容器隔离） |
-| 环境复用 | 弱 | 强（镜像 + 配置） |
-| 会话恢复 | 依赖工具自身 | 支持统一会话管理 |
-| 切换效率 | 一般 | 快捷（`-y` / `-x`） |
+| 宿主机暴露面 | 高 | 更低 |
+| 运行边界 | 分散 | 集中到容器与配置 |
+| 环境复现 | 弱 | 强（镜像 + 配置） |
+| 高风险模式说明 | 通常依赖工具自身 | 明确提示 YOLO / SOLO / sock 风险 |
+| 团队统一性 | 弱 | 更强 |
 
----
+## 安全边界
 
-## 安全提示
+MANYOYO 可以降低风险，但不是“绝对安全”：
 
-- **YOLO/SOLO 模式**：跳过权限确认，存在误删或执行危险命令风险。详见：[AI 智能体](https://xcanwin.github.io/manyoyo/zh/reference/agents)
-- **sock 容器模式**：挂载宿主机 Docker socket，容器可完全控制宿主机容器。详见：[容器模式](https://xcanwin.github.io/manyoyo/zh/reference/container-modes)
+- 它的主要隔离手段是容器，不是虚拟机
+- `YOLO / SOLO` 仍然可能执行危险命令
+- `sock` 模式本质上会把宿主机容器控制权暴露给容器
+- 自定义挂载、环境变量和网络访问会直接影响实际安全边界
 
-## 安装
+相关文档：
 
-### 全局安装（推荐）
+- [AI 智能体说明](https://xcanwin.github.io/manyoyo/zh/reference/agents)
+- [容器模式说明](https://xcanwin.github.io/manyoyo/zh/reference/container-modes)
+- [网页认证与安全](https://xcanwin.github.io/manyoyo/zh/advanced/web-server-auth)
+
+## 常用命令
 
 ```bash
-npm install -g @xcanwin/manyoyo
-```
+# 初始化与迁移
+manyoyo init all
+
+# 启动常见 Agent
+manyoyo run -y c
+manyoyo run -y gm
+manyoyo run -y cx
+manyoyo run -y oc
 
-### 系统要求
+# 更新
+manyoyo update
+
+# 容器与调试
+manyoyo ps
+manyoyo images
+manyoyo run -n my-dev -x /bin/bash
+manyoyo rm my-dev
 
-- Node.js >= 22.0.0
-- Podman（推荐） 或 Docker
+# Web 模式
+manyoyo serve 127.0.0.1:3000
+manyoyo serve 127.0.0.1:3000 -U admin -P 123456
+manyoyo serve 127.0.0.1:3000 -U admin -P 123456 -d
+manyoyo serve 127.0.0.1:3000 -d   # 未设置密码时会打印本次随机密码
 
-详细安装指南请参考：[安装详解](https://xcanwin.github.io/manyoyo/zh/guide/installation)
+# 查看配置与命令拼装
+manyoyo config show
+manyoyo config command
+```
 
-## 构建镜像
+## 镜像构建
 
 ```bash
-# 构建 common 版本（推荐）
+# common 版本
 manyoyo build --iv 1.8.4-common
 
-# 构建 full 版本
+# full 版本
 manyoyo build --iv 1.8.4-full
 
-# 构建自定义版本
+# 自定义工具集
 manyoyo build --iba TOOL=go,codex,java,gemini
 ```
 
-- 首次构建会自动下载依赖到 `docker/cache/`，2天内再次构建会使用缓存，速度提升约 **5 倍**
-
-## 常用命令
+说明：
 
-```bash
-# 配置迁移（推荐首步）
-manyoyo init all
+- 首次构建会把依赖缓存到 `docker/cache/`
+- 在缓存有效期内重复构建，通常会更快
+- `imageVersion` 格式必须为 `x.y.z-后缀`
 
-# 启动常见智能体
-manyoyo run -y c          # Claude Code（或 claude / cc）
-manyoyo run -y gm         # Gemini（或 gemini / g）
-manyoyo run -y cx         # Codex（或 codex）
-manyoyo run -y oc         # OpenCode（或 opencode）
-manyoyo update      # 更新 MANYOYO（全局 npm 安装场景）
+## 配置模型
 
-# 容器管理
-manyoyo ps
-manyoyo images
-manyoyo run -n my-dev -x /bin/bash
-manyoyo rm my-dev
-manyoyo serve 127.0.0.1:3000
-manyoyo serve 127.0.0.1:3000 -U admin -P 123456
+MANYOYO 的配置重点不是“多”，而是“可预测”：
 
-# 调试配置与命令拼装
-manyoyo config show
-manyoyo config command
-```
+- 标量值按 `命令行参数 > runs.<name> > 全局配置 > 默认值` 覆盖
+- 数组值按 `全局配置 -> runs.<name> -> 命令行参数` 追加合并
+- `env` 使用 map 合并，按 key 覆盖
 
-## 配置
+相关文档：
 
-配置优先级：命令行参数 > runs.<name> > 全局配置 > 默认值
-详细说明请参考：
 - [配置系统概览](https://xcanwin.github.io/manyoyo/zh/configuration/)
-- [环境变量详解](https://xcanwin.github.io/manyoyo/zh/configuration/environment)
 - [配置文件详解](https://xcanwin.github.io/manyoyo/zh/configuration/config-files)
+- [环境变量详解](https://xcanwin.github.io/manyoyo/zh/configuration/environment)
 
-## 📚 完整文档
+## 文档入口
 
-在线文档：**https://xcanwin.github.io/manyoyo/**
+中文文档：
 
-**中文文档：**
 - [快速开始](https://xcanwin.github.io/manyoyo/zh/guide/quick-start)
 - [安装详解](https://xcanwin.github.io/manyoyo/zh/guide/installation)
-- [配置系统](https://xcanwin.github.io/manyoyo/zh/configuration/)
+- [CLI 选项](https://xcanwin.github.io/manyoyo/zh/reference/cli-options)
 - [故障排查](https://xcanwin.github.io/manyoyo/zh/troubleshooting/)
 
-**English Documentation:**
+English Documentation:
+
 - [Quick Start](https://xcanwin.github.io/manyoyo/en/guide/quick-start)
 - [Installation](https://xcanwin.github.io/manyoyo/en/guide/installation)
-- [Configuration](https://xcanwin.github.io/manyoyo/en/configuration/)
+- [CLI Options](https://xcanwin.github.io/manyoyo/en/reference/cli-options)
 - [Troubleshooting](https://xcanwin.github.io/manyoyo/en/troubleshooting/)
 
-## 卸载
+## 安装与卸载
+
+安装：
 
 ```bash
-# 卸载全局安装
-npm uninstall -g @xcanwin/manyoyo
+npm install -g @xcanwin/manyoyo
+```
 
-# 清理配置（可选）
-rm -rf ~/.manyoyo/
+卸载：
+
+```bash
+npm uninstall -g @xcanwin/manyoyo
+rm -rf ~/.manyoyo/   # 可选
 ```
 
 ## 许可证
@@ -174,6 +203,7 @@ MIT
 
 ## 贡献
 
-欢迎提交 Issue 和 Pull Request！
+欢迎提交 Issue 和 Pull Request。
 
-访问 [GitHub Issues](https://github.com/xcanwin/manyoyo/issues) 报告问题或提出建议。
+- Issues: <https://github.com/xcanwin/manyoyo/issues>
+- Repository: <https://github.com/xcanwin/manyoyo>

package/bin/manyoyo.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-const { spawnSync } = require('child_process');
+const { spawn, spawnSync } = require('child_process');
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
@@ -16,6 +16,12 @@ const { buildImage } = require('../lib/image-build');
 const { resolveAgentResumeArg, buildAgentResumeCommand } = require('../lib/agent-resume');
 const { runPluginCommand } = require('../lib/plugin');
 const { buildManyoyoLogPath } = require('../lib/log-path');
+const {
+    sanitizeSensitiveData,
+    sanitizeServeLogText,
+    formatServeLogValue,
+    getServeProcessSnapshot
+} = require('../lib/serve-log');
 const { version: BIN_VERSION, imageVersion: IMAGE_VERSION_DEFAULT } = require('../package.json');
 const IMAGE_VERSION_BASE = String(IMAGE_VERSION_DEFAULT || '1.0.0').split('-')[0];
 const IMAGE_VERSION_HELP_EXAMPLE = IMAGE_VERSION_DEFAULT || `${IMAGE_VERSION_BASE}-common`;
@@ -190,93 +196,6 @@ function ensureWebServerAuthCredentials() {
     }
 }
 
-/**
- * 敏感信息脱敏（用于 config show 输出）
- * @param {Object} obj - 配置对象
- * @returns {Object} 脱敏后的配置对象
- */
-function sanitizeSensitiveData(obj) {
-    const sensitiveKeys = ['KEY', 'TOKEN', 'SECRET', 'PASSWORD', 'PASS', 'AUTH', 'CREDENTIAL'];
-
-    function sanitizeValue(key, value) {
-        if (typeof value !== 'string') return value;
-        const upperKey = key.toUpperCase();
-        if (sensitiveKeys.some(k => upperKey.includes(k))) {
-            if (value.length <= 8) return '****';
-            return value.slice(0, 4) + '****' + value.slice(-4);
-        }
-        return value;
-    }
-
-    function sanitizeArray(arr) {
-        return arr.map(item => {
-            if (typeof item === 'string' && item.includes('=')) {
-                const idx = item.indexOf('=');
-                const key = item.slice(0, idx);
-                const value = item.slice(idx + 1);
-                return `${key}=${sanitizeValue(key, value)}`;
-            }
-            return item;
-        });
-    }
-
-    const result = {};
-    for (const [key, value] of Object.entries(obj)) {
-        if (Array.isArray(value)) {
-            result[key] = sanitizeArray(value);
-        } else if (typeof value === 'object' && value !== null) {
-            result[key] = sanitizeSensitiveData(value);
-        } else {
-            result[key] = sanitizeValue(key, value);
-        }
-    }
-    return result;
-}
-
-function stripAnsi(text) {
-    if (typeof text !== 'string') return '';
-    return text.replace(/\x1b\[[0-9;]*m/g, '');
-}
-
-function sanitizeServeLogText(input) {
-    let text = stripAnsi(String(input || ''));
-    if (!text) return text;
-
-    text = text.replace(/(--pass|-P)\s+\S+/gi, '$1 ****');
-    text = text.replace(
-        /\b(MANYOYO_SERVER_PASS|OPENAI_API_KEY|ANTHROPIC_AUTH_TOKEN|GEMINI_API_KEY|GOOGLE_API_KEY|OPENCODE_API_KEY)\s*=\s*([^\s'"]+)/gi,
-        '$1=****'
-    );
-    text = text.replace(
-        /("?(?:password|pass|token|api[_-]?key|authorization|cookie)"?\s*[:=]\s*)("[^"]*"|'[^']*'|[^,\s]+)/gi,
-        '$1"****"'
-    );
-    return text;
-}
-
-function formatServeLogValue(value) {
-    if (value instanceof Error) {
-        return sanitizeServeLogText(value.stack || value.message || String(value));
-    }
-    if (typeof value === 'object' && value !== null) {
-        try {
-            return sanitizeServeLogText(JSON.stringify(sanitizeSensitiveData(value)));
-        } catch (e) {
-            return sanitizeServeLogText(String(value));
-        }
-    }
-    return sanitizeServeLogText(String(value));
-}
-
-function getServeProcessSnapshot() {
-    return {
-        pid: process.pid,
-        ppid: process.ppid,
-        cwd: process.cwd(),
-        argv: Array.isArray(process.argv) ? process.argv.slice() : []
-    };
-}
-
 function createServeLogger() {
     function formatLocalTimestamp(date = new Date()) {
         const y = date.getFullYear();
@@ -1120,7 +1039,8 @@ async function setupCommander() {
   ${MANYOYO_NAME} run -n test -- -c                   恢复之前会话
   ${MANYOYO_NAME} run -x "echo 123"                   使用完整命令
   ${MANYOYO_NAME} serve 127.0.0.1:3000                启动本机网页服务
-  ${MANYOYO_NAME} serve 0.0.0.0:3000 -U admin -P 123 &>/dev/null &  后台启动并监听全部网卡
+  ${MANYOYO_NAME} serve 127.0.0.1:3000 -d             后台启动；未设密码时会打印本次随机密码
+  ${MANYOYO_NAME} serve 0.0.0.0:3000 -U admin -P 123 -d  后台启动并监听全部网卡
   ${MANYOYO_NAME} playwright up host-headless         启动 playwright 默认场景（推荐）
   ${MANYOYO_NAME} plugin playwright up host-headless  通过 plugin 命名空间启动
   ${MANYOYO_NAME} run -n test -q tip -q cmd           多次使用静默选项
@@ -1163,6 +1083,7 @@ Notes:
 
     const serveCommand = program.command('serve [listen]').description('启动网页交互服务 (默认 127.0.0.1:3000)');
     applyRunStyleOptions(serveCommand, { includeRmOnExit: false, includeWebAuthOptions: true });
+    serveCommand.option('-d, --detach', '后台启动网页服务并立即返回');
     serveCommand.action((listen, options) => {
         selectAction('serve', {
             ...options,
@@ -1498,6 +1419,7 @@ Notes:
         isRemoveMode,
         isShowCommandMode,
         isServerMode,
+        isServerDetach: Boolean(selectedAction === 'serve' && options.detach),
         isPluginMode: false
     };
 }
@@ -1524,6 +1446,7 @@ function createRuntimeContext(modeState = {}) {
         showCommand: Boolean(modeState.isShowCommandMode),
         rmOnExit: RM_ON_EXIT,
         serverMode: Boolean(modeState.isServerMode),
+        serverDetach: Boolean(modeState.isServerDetach),
         serverHost: SERVER_HOST,
         serverPort: SERVER_PORT,
         serverAuthUser: SERVER_AUTH_USER,
@@ -1558,6 +1481,62 @@ function validateHostPath(runtime) {
     }
 }
 
+function validateHostPathOrThrow(hostPath) {
+    if (!fs.existsSync(hostPath)) {
+        throw new Error(`宿主机路径不存在: ${hostPath}`);
+    }
+    const realHostPath = fs.realpathSync(hostPath);
+    const homeDir = process.env.HOME || '/home';
+    if (realHostPath === '/' || realHostPath === '/home' || realHostPath === homeDir) {
+        throw new Error('不允许挂载根目录或home目录。');
+    }
+}
+
+function buildDetachedServeArgv(argv) {
+    const result = [];
+    for (let i = 0; i < argv.length; i++) {
+        const arg = String(argv[i] || '');
+        if (arg === '-d' || arg === '--detach') {
+            continue;
+        }
+        result.push(arg);
+    }
+    return result;
+}
+
+function buildDetachedServeEnv(runtime) {
+    const env = { ...process.env };
+    if (runtime.serverAuthUser) {
+        env.MANYOYO_SERVER_USER = runtime.serverAuthUser;
+    }
+    if (runtime.serverAuthPass) {
+        env.MANYOYO_SERVER_PASS = runtime.serverAuthPass;
+    }
+    return env;
+}
+
+function relaunchServeDetached(runtime) {
+    const serveLog = buildManyoyoLogPath('serve');
+    fs.mkdirSync(serveLog.dir, { recursive: true });
+
+    const child = spawn(process.argv[0], buildDetachedServeArgv(process.argv.slice(1)), {
+        detached: true,
+        stdio: 'ignore',
+        env: buildDetachedServeEnv(runtime)
+    });
+    child.unref();
+
+    console.log(`${GREEN}✅ serve 已转入后台运行${NC}`);
+    console.log(`PID: ${child.pid}`);
+    console.log(`日志: ${serveLog.path}`);
+    console.log(`登录用户名: ${runtime.serverAuthUser}`);
+    if (runtime.serverAuthPassAuto) {
+        console.log(`登录密码(本次随机): ${runtime.serverAuthPass}`);
+    } else {
+        console.log('登录密码: 使用你配置的 serve -P / serverPass / MANYOYO_SERVER_PASS');
+    }
+}
+
 /**
  * 等待容器就绪（使用指数退避算法）
  * @param {string} containerName - 容器名称
@@ -1850,7 +1829,7 @@ async function runWebServerMode(runtime) {
         containerEnvs: runtime.containerEnvs,
         containerVolumes: runtime.containerVolumes,
         containerPorts: runtime.containerPorts,
-        validateHostPath: () => validateHostPath(runtime),
+        validateHostPath: value => validateHostPathOrThrow(value),
         formatDate,
         isValidContainerName,
         containerExists,
@@ -1892,6 +1871,10 @@ async function main() {
 
         // 2. Start web server mode
         if (runtime.serverMode) {
+            if (runtime.serverDetach) {
+                relaunchServeDetached(runtime);
+                return;
+            }
             const serveLogger = createServeLogger();
             runtime.logger = serveLogger;
             installServeProcessDiagnostics(serveLogger);

package/lib/serve-log.js

@@ -0,0 +1,116 @@
+function stripAnsi(text) {
+    if (typeof text !== 'string') return '';
+    return text.replace(/\x1b\[[0-9;]*m/g, '');
+}
+
+function sanitizeProcessArgv(argv) {
+    if (!Array.isArray(argv)) {
+        return [];
+    }
+
+    const result = [];
+    for (let i = 0; i < argv.length; i++) {
+        const arg = String(argv[i] || '');
+        if (arg === '--pass' || arg === '-P') {
+            result.push(arg);
+            if (i + 1 < argv.length) {
+                result.push('****');
+                i += 1;
+            }
+            continue;
+        }
+        if (arg.startsWith('--pass=')) {
+            result.push('--pass=****');
+            continue;
+        }
+        result.push(arg);
+    }
+    return result;
+}
+
+function sanitizeServeLogText(input) {
+    let text = stripAnsi(String(input || ''));
+    if (!text) return text;
+
+    text = text.replace(/(--pass|-P)\s+\S+/gi, '$1 ****');
+    text = text.replace(/("--pass"|"-P")\s*,\s*"[^"]*"/gi, '$1,"****"');
+    text = text.replace(/--pass=([^\s'"]+)/gi, '--pass=****');
+    text = text.replace(
+        /\b(MANYOYO_SERVER_PASS|OPENAI_API_KEY|ANTHROPIC_AUTH_TOKEN|GEMINI_API_KEY|GOOGLE_API_KEY|OPENCODE_API_KEY)\s*=\s*([^\s'"]+)/gi,
+        '$1=****'
+    );
+    text = text.replace(
+        /(?<![-\w])("?(?:password|pass|token|api[_-]?key|authorization|cookie)"?\s*[:=]\s*)("[^"]*"|'[^']*'|[^,\s]+)/gi,
+        '$1"****"'
+    );
+    return text;
+}
+
+function sanitizeSensitiveData(obj) {
+    const sensitiveKeys = ['KEY', 'TOKEN', 'SECRET', 'PASSWORD', 'PASS', 'AUTH', 'CREDENTIAL'];
+
+    function sanitizeValue(key, value) {
+        if (typeof value !== 'string') return value;
+        const upperKey = key.toUpperCase();
+        if (sensitiveKeys.some(k => upperKey.includes(k))) {
+            if (value.length <= 8) return '****';
+            return value.slice(0, 4) + '****' + value.slice(-4);
+        }
+        return value;
+    }
+
+    function sanitizeArray(arr) {
+        return arr.map(item => {
+            if (typeof item === 'string' && item.includes('=')) {
+                const idx = item.indexOf('=');
+                const key = item.slice(0, idx);
+                const value = item.slice(idx + 1);
+                return `${key}=${sanitizeValue(key, value)}`;
+            }
+            return item;
+        });
+    }
+
+    const result = {};
+    for (const [key, value] of Object.entries(obj || {})) {
+        if (Array.isArray(value)) {
+            result[key] = sanitizeArray(value);
+        } else if (typeof value === 'object' && value !== null) {
+            result[key] = sanitizeSensitiveData(value);
+        } else {
+            result[key] = sanitizeValue(key, value);
+        }
+    }
+    return result;
+}
+
+function formatServeLogValue(value) {
+    if (value instanceof Error) {
+        return sanitizeServeLogText(value.stack || value.message || String(value));
+    }
+    if (typeof value === 'object' && value !== null) {
+        try {
+            return sanitizeServeLogText(JSON.stringify(sanitizeSensitiveData(value)));
+        } catch (e) {
+            return sanitizeServeLogText(String(value));
+        }
+    }
+    return sanitizeServeLogText(String(value));
+}
+
+function getServeProcessSnapshot(processRef = process) {
+    return {
+        pid: processRef.pid,
+        ppid: processRef.ppid,
+        cwd: typeof processRef.cwd === 'function' ? processRef.cwd() : '',
+        argv: sanitizeProcessArgv(Array.isArray(processRef.argv) ? processRef.argv.slice() : [])
+    };
+}
+
+module.exports = {
+    sanitizeProcessArgv,
+    sanitizeServeLogText,
+    sanitizeSensitiveData,
+    formatServeLogValue,
+    getServeProcessSnapshot
+};

package/lib/web/server.js

@@ -812,7 +812,11 @@ function buildCreateRuntime(ctx, state, payload) {
     validateContainerNameStrict(containerName);
 
     const hostPath = pickFirstString(requestOptions.hostPath, config.hostPath, ctx.hostPath);
-    validateWebHostPath(hostPath);
+    if (typeof ctx.validateHostPath === 'function') {
+        ctx.validateHostPath(hostPath);
+    } else {
+        validateWebHostPath(hostPath);
+    }
 
     const containerPath = pickFirstString(requestOptions.containerPath, config.containerPath, ctx.containerPath, hostPath) || hostPath;
     const imageName = pickFirstString(requestOptions.imageName, config.imageName, ctx.imageName);
@@ -1788,7 +1792,7 @@ async function startWebServer(options) {
     };
 
     if (!ctx.authUser || !ctx.authPass) {
-        throw new Error('Web 认证配置缺失，请设置 serve -u / serve -P');
+        throw new Error('Web 认证配置缺失，请设置 serve -U / serve -P');
     }
 
     const state = {
@@ -1798,7 +1802,6 @@ async function startWebServer(options) {
         terminalSessions: new Map()
     };
 
-    ctx.validateHostPath();
     ensureWebHistoryDir(state.webHistoryDir);
 
     const wsServer = new WebSocket.Server({

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@xcanwin/manyoyo",
-    "version": "5.3.6",
+    "version": "5.3.9",
     "imageVersion": "1.8.4-common",
     "description": "AI Agent CLI Security Sandbox for Docker and Podman",
     "keywords": [