@xcanwin/manyoyo 8.2.0 → 8.3.0

package/README.en.md

@@ -0,0 +1,88 @@
+<p align="center">
+  <img src="./assets/manyoyo-logo-09-cyberpunk-terminal.svg" alt="MANYOYO logo" width="560" />
+</p>
+
+# <p align="center"><a href="https://github.com/xcanwin/manyoyo">MANYOYO</a></p>
+<p align="center"><b>MANYOYO – open-source sandbox for running AI coding agents (Claude Code / Codex / Gemini) safely in Docker/Podman</b></p>
+<p align="center">Run Claude Code / Codex / Gemini / OpenCode in YOLO mode inside a container: let the AI go wild without hurting your computer.</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>
+  <a href="https://github.com/xcanwin/manyoyo/blob/main/LICENSE"><img alt="license" src="https://img.shields.io/badge/License-MIT-yellow.svg" /></a>
+</p>
+
+<p align="center">
+  <a href="README.md">中文</a> |
+  <a href="README.en.md"><b>English</b></a>
+</p>
+<p align="center">
+  Docs: <a href="https://xcanwin.github.io/manyoyo/en/">https://xcanwin.github.io/manyoyo/en/</a>
+</p>
+
+---
+
+## Install
+
+### macOS / Linux (recommended)
+
+```bash
+curl -fsSL https://github.com/xcanwin/manyoyo/raw/main/scripts/install.sh | sh
+```
+
+When it finishes, follow the on-screen prompts to finish setup. macOS needs nothing installed first. Linux: if the container runtime is missing, the installer explains why and, with your consent, installs it with sudo.
+
+### Already have Node.js and Docker/Podman
+
+```bash
+npm install -g @xcanwin/manyoyo
+manyoyo
+```
+
+## Daily use
+
+```bash
+manyoyo            # open the web UI
+manyoyo update     # upgrade
+manyoyo uninstall  # uninstall (config and data are kept by default)
+```
+
+## Command line (optional)
+
+```bash
+manyoyo init all   # import the agent configs already on this machine
+manyoyo run -y c   # start Claude Code in YOLO mode inside the sandbox
+```
+
+The default image `ghcr.io/xcanwin/manyoyo` is pulled automatically on first use; run `manyoyo build --iv 2.1.0-common` only if you need a custom image. More commands: [CLI reference](https://xcanwin.github.io/manyoyo/en/reference/cli-options).
+
+## What it does
+
+- **Multiple agents**: `claude`, `codex`, `gemini`, `opencode` behind one entry point
+- **Container isolation**: Docker / Podman; the agent only sees the work directory you give it
+- **Web UI**: chat, browse files and open a terminal in the browser, phone friendly
+- **One config**: run profiles, environment variables, mounts and image arguments in `~/.manyoyo/manyoyo.json`
+- **One command** to install, upgrade and uninstall
+
+| | Running the agent CLI directly | MANYOYO |
+| --- | --- | --- |
+| Host exposure | High | Lower |
+| Run boundary | Scattered | Centralised in the container and config |
+| Reproducible environment | Weak | Strong (image + config) |
+| High-risk mode warnings | Left to the tool | Explicit YOLO / SOLO / sock warnings |
+
+## Security notes
+
+MANYOYO reduces risk but is not "absolutely safe": the main isolation is a container, not a virtual machine; `YOLO / SOLO` can still run dangerous commands; `sock` mode exposes the host Docker socket; set a strong password before listening on a public address. See [Security notes](https://xcanwin.github.io/manyoyo/en/guide/security).
+
+## Docs
+
+- 中文: <https://xcanwin.github.io/manyoyo/>
+- English: <https://xcanwin.github.io/manyoyo/en/> ([Install](https://xcanwin.github.io/manyoyo/en/guide/quick-start), [CLI reference](https://xcanwin.github.io/manyoyo/en/reference/cli-options), [Configuration](https://xcanwin.github.io/manyoyo/en/configuration/), [FAQ](https://xcanwin.github.io/manyoyo/en/troubleshooting/))
+
+## License
+
+MIT
+
+## Contributing
+
+[Issues](https://github.com/xcanwin/manyoyo/issues) and pull requests are welcome.

package/README.md

@@ -3,7 +3,8 @@
 </p>
 
 # <p align="center"><a href="https://github.com/xcanwin/manyoyo">MANYOYO（慢悠悠）</a></p>
-<p align="center">让 Claude Code / Codex / Gemini / OpenCode 在容器里放心跑 YOLO 模式：AI 随便折腾，伤不到你的电脑。</p>
+<p align="center"><b>MANYOYO – open-source sandbox for running AI coding agents (Claude Code / Codex / Gemini) safely in Docker/Podman</b></p>
+<p align="center">开源 AI Agent 沙箱：让 Claude Code / Codex / Gemini / OpenCode 在容器里放心跑 YOLO 模式，AI 随便折腾，伤不到你的电脑。</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>
@@ -12,7 +13,7 @@
 
 <p align="center">
   <a href="README.md"><b>中文</b></a> |
-  <a href="https://xcanwin.github.io/manyoyo/en/">English</a>
+  <a href="README.en.md">English</a>
 </p>
 <p align="center">
   文档：<a href="https://xcanwin.github.io/manyoyo/">https://xcanwin.github.io/manyoyo/</a>
@@ -28,7 +29,7 @@
 curl -fsSL https://github.com/xcanwin/manyoyo/raw/main/scripts/install.sh | sh
 ```
 
-装完浏览器自动打开，按向导选 Agent、填 Key 就能开始对话。macOS 不需要预装任何东西；Linux 需要已有 Docker 或 Podman。
+装完按屏幕提示完成配置。macOS 不需要预装任何东西。Linux：缺少容器环境时，安装器会说明原因，征得你同意后用 sudo 自动安装。
 
 ### 已有 Node.js 和 Docker/Podman
 

package/bin/manyoyo.js

@@ -9,7 +9,7 @@ const net = require('net');
 const readline = require('readline');
 const { Command, Help } = require('commander');
 const { startWebServer } = require('../lib/web/server');
-const { buildContainerRunArgs, buildContainerRunCommand } = require('../lib/container-run');
+const { buildContainerRunArgs, buildContainerRunCommand, runWithEnvFile } = require('../lib/container-run');
 const { getManyoyoConfigPath, readManyoyoConfig, syncGlobalImageVersion } = require('../lib/global-config');
 const { resolveUpdateImageVersion } = require('../lib/image-version-policy');
 const { selectContainerRuntime, mergeRuntimeEnv } = require('../lib/container-runtime');
@@ -20,6 +20,8 @@ const { readImportState, waitForImport } = require('../lib/offline-import');
 const { runPodmanCommand } = require('../lib/podman-passthrough');
 const { detectHeadless, parseLauncherArgs } = require('../lib/headless');
 const { runSetupCli, createPrompter } = require('../lib/setup-cli');
+const { runPostInstall } = require('../lib/post-install');
+const { listServeInstances, formatServeTable } = require('../lib/serve-instances');
 const { pruneDanglingImages: pruneDanglingImagesSafely } = require('../lib/image-prune');
 const { runUninstall, readPid, defaultIsManyoyoServe, defaultKill } = require('../lib/uninstall');
 const appUpdate = require('../lib/app-update');
@@ -45,6 +47,7 @@ const { applyAptMirror } = require('../lib/mirrors');
 const {
     sanitizeSensitiveData,
     sanitizeServeLogText,
+    redactCommandArgs,
     formatServeLogValue,
     getServeProcessSnapshot
 } = require('../lib/serve-log');
@@ -726,6 +729,18 @@ async function ensureRunImage(runtime) {
     });
 }
 
+// 把 run 失败的 stderr 尾部（已打码）与可执行的修复提示拼进错误信息，而不是只剩一行 Command failed
+function explainCreateFailure(err) {
+    const raw = getCommandFailureText(err);
+    const tail = sanitizeServeLogText(String(err && err.stderr || '')).trim().split('\n').slice(-8).join('\n');
+    const info = describeError(raw, { command: DOCKER_CMD });
+    const parts = [err.message];
+    if (tail) parts.push(tail);
+    if (info && info.code === 'ROOTLESS_NETWORK_MISSING') parts.push(`提示: ${info.reason}\n${info.action}`);
+    err.message = parts.join('\n');
+    return err;
+}
+
 function showImagePullHint(err) {
     const info = describeError(getCommandFailureText(err), { imageRef: `${IMAGE_NAME}:${IMAGE_VERSION}` });
     if (!info || !['IMAGE_PULL_FAILED', 'IMAGE_NOT_FOUND'].includes(info.code)) {
@@ -751,7 +766,7 @@ function runCmd(cmd, args, options = {}) {
         if (options.ignoreError) {
             return result.stdout || '';
         }
-        const err = new Error(`Command failed: ${cmd} ${args.join(' ')}`);
+        const err = new Error(`Command failed: ${cmd} ${redactCommandArgs(args).join(' ')}`);
         err.stdout = result.stdout;
         err.stderr = result.stderr;
         err.status = result.status;
@@ -1274,7 +1289,7 @@ async function setupCommander() {
         .description(`MANYOYO - AI Agent CLI Sandbox
 https://github.com/xcanwin/manyoyo
 
-不带参数直接运行，打开网页界面（首次使用进入配置向导）:
+不带参数直接运行，会启动网页服务，打开网页界面（首次使用进入配置向导）:
   ${MANYOYO_NAME}              自动判断有无图形界面
   ${MANYOYO_NAME} --headless   强制按无图形界面处理（不打开浏览器，用密码登录）
   ${MANYOYO_NAME} --gui        强制按有图形界面处理（自动打开浏览器）`)
@@ -1429,6 +1444,7 @@ https://github.com/xcanwin/manyoyo
     serveCommand.option('-d, --detach', '后台启动网页服务并立即返回');
     serveCommand.option('--stop', '停止后台网页服务；必须显式传入 listen');
     serveCommand.option('--restart', '重启后台网页服务；必须显式传入 listen');
+    serveCommand.option('--list', '列出正在运行的网页服务（监听地址、PID、版本、启动命令）');
     serveCommand.action((listen, options) => {
         selectAction('serve', {
             ...options,
@@ -1458,12 +1474,21 @@ https://github.com/xcanwin/manyoyo
     const pluginPlaywrightCommand = pluginCommand.command('playwright').description('管理 playwright 插件服务');
     registerPlaywrightAliasCommands(pluginPlaywrightCommand);
 
+    // 安装包装完后调用的隐藏入口（不在帮助里）：按有头 / 无头决定下一步
+    if (process.argv[2] === '--post-install') {
+        await runPostInstallCommand(process.argv.slice(3));
+        process.exit(0);
+    }
+
     // No args (or only --headless / --gui): start (or reuse) the local web app; open the browser already logged in unless headless
     const launcherArgs = parseLauncherArgs(process.argv.slice(2));
     if (launcherArgs) {
         await runAppLauncher({ force: launcherArgs.force });
     }
 
+    // 顶层 -V 与 -v 等价（commander 只允许一个短选项；子命令里的 -v 仍是 --volume，不受影响）
+    if (process.argv.length === 3 && process.argv[2] === '-V') process.argv[2] = '-v';
+
     // Pre-handle -x/--shell-full: treat all following args as a single command
     normalizeShellFullArgv(process.argv);
     normalizeWorktreeArgv(process.argv);
@@ -1489,6 +1514,10 @@ https://github.com/xcanwin/manyoyo
     const isServerMode = options.server !== undefined;
     const isServerStopMode = Boolean(selectedAction === 'serve' && options.stop);
     const isServerRestartMode = Boolean(selectedAction === 'serve' && options.restart);
+    const isServerListMode = Boolean(selectedAction === 'serve' && options.list);
+    if (isServerListMode && (isServerStopMode || isServerRestartMode || options.detach || options.server !== true)) {
+        throw new Error('serve --list 不能与 listen、-d、--stop、--restart 同时使用');
+    }
 
     if (isServerStopMode && isServerRestartMode) {
         throw new Error('serve --stop 与 --restart 不能同时使用');
@@ -1497,35 +1526,25 @@ https://github.com/xcanwin/manyoyo
     UPDATE_CHECK_ENABLED = config.updateCheck !== false;
     MIRRORS = normalizeMirrors(config.mirrors);
     const noDockerActions = new Set(['init', 'update', 'config-show', 'plugin', 'doctor', 'uninstall', 'podman', 'setup']);
-    if (isServerStopMode) {
+    if (isServerStopMode || isServerListMode) {
         noDockerActions.add('serve');
     }
     if (!noDockerActions.has(selectedAction)) {
         await ensureDocker(config.containerRuntime, { deferHeal: selectedAction === 'serve' });
     }
 
+    if (isServerListMode) {
+        console.log(formatServeTable(listServeInstances()));
+        process.exit(0);
+    }
+
     if (options.update) {
         await updateManyoyo(options, config);
         process.exit(0);
     }
 
     if (selectedAction === 'setup') {
-        const interactive = Boolean(process.stdin.isTTY);
-        const code = await runSetupCli({
-            isTTY: interactive,
-            prompter: interactive ? createPrompter() : null,
-            configPath: getManyoyoConfigPath(),
-            defaultWorkpath: path.join(os.homedir(), '.manyoyo', 'work'),
-            validateHostPath: value => validateHostPathOrThrow(value),
-            commandName: MANYOYO_NAME,
-            log: line => console.log(line),
-            // 新密码要让后台服务重新读配置：先停掉旧的，再按当前环境（有头 / 无头）启动
-            afterSave: async () => {
-                stopBackgroundApp({ quiet: true });
-                await runAppLauncher({ exit: false });
-            }
-        });
-        process.exit(code);
+        process.exit(await runSetupCommand());
     }
 
     if (selectedAction === 'podman') {
@@ -1578,8 +1597,10 @@ https://github.com/xcanwin/manyoyo
         };
     }
 
-    // Load run config if specified
-    const runConfig = options.run ? loadRunConfig(options.run, config) : {};
+    // Load run config if specified；doctor 不带 -r 且 runs 里只有一个配置时，按它检查
+    const runsMap = config.runs && typeof config.runs === 'object' && !Array.isArray(config.runs) ? Object.keys(config.runs) : [];
+    const runNameToLoad = options.run || (selectedAction === 'doctor' && runsMap.length === 1 ? runsMap[0] : '');
+    const runConfig = runNameToLoad ? loadRunConfig(runNameToLoad, config) : {};
     const globalFirstConfig = normalizeFirstConfig(config.first, '全局配置');
     const runFirstConfig = normalizeFirstConfig(runConfig.first, '运行配置');
 
@@ -2172,10 +2193,12 @@ async function createNewContainer(runtime) {
     // 使用数组参数执行命令（安全方式）
     try {
         const args = buildDockerRunArgs(runtime);
-        dockerExecArgs(args, { stdio: 'pipe' });
+        runWithEnvFile(args, path.join(os.homedir(), '.manyoyo', 'tmp'), finalArgs => dockerExecArgs(finalArgs, { stdio: 'pipe' }));
     } catch (e) {
         showImagePullHint(e);
-        throw e;
+        // 失败的 run 可能留下 Created 状态的容器；这个名字创建前不存在，所以只清理本次留下的这一个
+        try { dockerExecArgs(['rm', '-f', runtime.containerName], { stdio: 'pipe' }); } catch (cleanupError) { /* 尽力清理 */ }
+        throw explainCreateFailure(e);
     }
 
     // Wait for container to be ready
@@ -2220,7 +2243,7 @@ function buildDockerRunArgs(runtime) {
  * @returns {string} 命令字符串
  */
 function buildDockerRunCmd(runtime) {
-    const args = buildDockerRunArgs(runtime);
+    const args = redactCommandArgs(buildDockerRunArgs(runtime));
     return buildContainerRunCommand(DOCKER_CMD, args);
 }
 
@@ -2349,12 +2372,66 @@ async function handlePostExit(runtime, defaultCommand) {
     }
 }
 
+async function runSetupCommand() {
+    const interactive = Boolean(process.stdin.isTTY);
+    return runSetupCli({
+        isTTY: interactive,
+        prompter: interactive ? createPrompter() : null,
+        configPath: getManyoyoConfigPath(),
+        defaultWorkpath: path.join(os.homedir(), '.manyoyo', 'work'),
+        validateHostPath: value => validateHostPathOrThrow(value),
+        commandName: MANYOYO_NAME,
+        log: line => console.log(line),
+        // 新密码要让后台服务重新读配置：先停掉旧的，再按当前环境（有头 / 无头）启动
+        afterSave: async () => {
+            stopBackgroundApp({ quiet: true });
+            await runAppLauncher({ exit: false });
+        }
+    });
+}
+
+async function runPostInstallCommand(args) {
+    const launcher = parseLauncherArgs(args) || { force: null };
+    const { headless } = detectHeadless({ force: launcher.force });
+    const interactive = Boolean(process.stdin.isTTY);
+    let prompter = null; // 需要提问时才创建（有图形界面、没有终端都不需要，避免多余的 readline 占着 stdin）
+    try {
+        await runPostInstall({
+            headless,
+            interactive,
+            currentVersion: BIN_VERSION,
+            ownRoot: path.join(os.homedir(), '.manyoyo'),
+            commandName: MANYOYO_NAME,
+            log: line => console.log(line),
+            ask: text => {
+                if (!prompter) prompter = createPrompter();
+                return prompter.ask(text);
+            },
+            // 升级安装时先停掉旧版留下的本机服务，避免“复用”到旧代码
+            startApp: () => {
+                stopBackgroundApp({ quiet: true });
+                return runAppLauncher({ force: launcher.force, exit: false });
+            },
+            // 同一个 stdin 不能同时挂两个提示器：选完之后先关掉这个，再交给 setup 自己的
+            runSetup: async () => {
+                if (prompter) prompter.close();
+                return runSetupCommand();
+            },
+            listServes: () => listServeInstances()
+        });
+    } finally {
+        if (prompter) prompter.close();
+    }
+}
+
 async function runAppLauncher({ force = null, exit = true } = {}) {
     try {
         const { headless } = detectHeadless({ force });
+        const launcherConfig = readManyoyoConfig().config;
         await launchApp({
             headless,
-            authUser: String(readManyoyoConfig().config.serverUser || '').trim() || 'admin',
+            authUser: String(launcherConfig.serverUser || '').trim() || 'admin',
+            hasPassword: Boolean(String(launcherConfig.serverPass || process.env.MANYOYO_SERVER_PASS || '').trim()),
             statePath: getAppStatePath(),
             isProcessRunning,
             spawnServe: port => {

package/docker/res/claude/settings.json

@@ -1,4 +1,9 @@
 {
+    "attribution": {
+        "commit": "",
+        "pr": "",
+        "sessionUrl": false
+    },
     "statusLine": {
         "type": "command",
         "command": "bash /root/.claude/statusline.sh"

package/lib/app-launcher.js

@@ -190,9 +190,11 @@ async function launchApp(deps) {
     if (deps.headless) {
         // 无头环境没有浏览器：不签发一次性令牌（用户要先建立端口转发，60 秒不够），用密码登录
         const commandName = deps.commandName || 'manyoyo';
-        log(`${reused ? '已复用运行中的服务' : '已启动本机服务'}（无头环境，不打开浏览器）: ${baseUrl}`);
-        log(`  在你自己的电脑上转发端口: ssh -L ${state.port}:127.0.0.1:${state.port} <用户名>@<这台机器的地址>，然后浏览器访问 ${baseUrl}`);
-        log(`  登录用户名: ${deps.authUser || 'admin'}；密码是你用 ${commandName} setup 设置的那个（还没设置请先运行 ${commandName} setup）`);
+        log(`${reused ? '已复用运行中的网页版' : '已启动网页版'}（只监听本机 ${APP_HOST}:${state.port}）`);
+        log(`  在你自己的电脑上执行: ssh -L ${state.port}:127.0.0.1:${state.port} <用户名>@<这台机器的地址>`);
+        log(`  然后浏览器打开: ${baseUrl}`);
+        if (deps.hasPassword) log(`  登录用户名 ${deps.authUser || 'admin'}；密码是你用 ${commandName} setup 设置的那个`);
+        else log(`  登录用户名 ${deps.authUser || 'admin'}；还没有设置登录密码，请先运行 ${commandName} setup`);
         log(`  关闭服务: ${commandName} serve ${APP_HOST}:${state.port} --stop`);
         return { reused, opened: false, headless: true, baseUrl, loginUrl: '', pid: state.pid };
     }

package/lib/container-run.js

@@ -1,5 +1,8 @@
 'use strict';
 
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
 const { buildMirrorEnvArgs } = require('./mirrors');
 
 function sanitizeDefaultCommand(defaultCommand) {
@@ -26,6 +29,38 @@ function buildContainerRunArgs(options) {
     return args;
 }
 
+/**
+ * 把命令行里的 `--env KEY=值` 挪进 0600 的临时 env 文件，改用 `--env-file` 传入，
+ * 避免密钥出现在 ps / /proc 与错误信息里；exec 返回（或抛错）后立即删除文件。
+ * 没有 KEY=值 形式的 env 时原样执行。
+ */
+function runWithEnvFile(args, dir, exec) {
+    const rest = [];
+    const lines = [];
+    let envFileIndex = -1;
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--env' && /^[^=]+=/.test(String(args[i + 1] ?? ''))) {
+            if (envFileIndex < 0) envFileIndex = rest.length;
+            lines.push(args[i + 1]);
+            i += 1;
+        } else {
+            rest.push(args[i]);
+        }
+    }
+    if (!lines.length) return exec(args);
+
+    fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+    fs.chmodSync(dir, 0o700);
+    const file = path.join(dir, `env-${process.pid}-${crypto.randomBytes(4).toString('hex')}`);
+    fs.writeFileSync(file, `${lines.join('\n')}\n`, { mode: 0o600, flag: 'wx' });
+    rest.splice(envFileIndex, 0, '--env-file', file);
+    try {
+        return exec(rest);
+    } finally {
+        fs.rmSync(file, { force: true });
+    }
+}
+
 function quoteShellArg(value) {
     const text = String(value);
     if (text.includes(' ') || text.includes('"') || text.includes('=')) {
@@ -40,5 +75,6 @@ function buildContainerRunCommand(dockerCmd, args) {
 
 module.exports = {
     buildContainerRunArgs,
+    runWithEnvFile,
     buildContainerRunCommand
 };

package/lib/doctor.js

@@ -2,6 +2,8 @@
 
 const { resolveContainerMode } = require('./container-modes');
 const { resolveAgentProgram } = require('./agent-resume');
+const { describeError } = require('./error-hints');
+const { checkRootlessNetwork } = require('./rootless-network');
 
 function createCheck(code, status, summary, action = '', detail = '') {
     return { code, status, summary, action, detail };
@@ -9,6 +11,8 @@ function createCheck(code, status, summary, action = '', detail = '') {
 
 // 卡死的 daemon（如无响应的 Docker Desktop）不能让诊断无限挂起
 const COMMAND_TIMEOUT_MS = 10000;
+// 真实启动一次容器（含网络配置），比 info 慢
+const START_TEST_TIMEOUT_MS = 60000;
 
 // runCommand 可以是同步或异步执行器；serve 里传异步的，避免阻塞事件循环
 async function runDoctorChecks(options = {}) {
@@ -45,13 +49,37 @@ async function runDoctorChecks(options = {}) {
         } catch (error) {
             checks.push(createCheck('DAEMON_UNAVAILABLE', 'error', `${runtimeCommand} daemon 不可用`, `启动 ${runtimeCommand} daemon 后重试。`, error.message || ''));
         }
+        const network = await checkRootlessNetwork(runCommand, { command: runtimeCommand, env: runtimeEnv, timeout: COMMAND_TIMEOUT_MS, platform: options.platform });
+        if (network && network.missing) {
+            checks.push(createCheck('ROOTLESS_NETWORK_MISSING', 'error', network.reason, network.action));
+        } else if (network) {
+            checks.push(createCheck('ROOTLESS_NETWORK_OK', 'ok', `rootless 网络组件可用: ${network.component}`));
+        }
+        const image = `${options.imageName || ''}:${options.imageVersion || ''}`;
+        let imageAvailable = false;
         try {
-            const image = `${options.imageName || ''}:${options.imageVersion || ''}`;
             const detail = String(await runCommand(runtimeCommand, ['image', 'inspect', image], { env: runtimeEnv, timeout: COMMAND_TIMEOUT_MS }) || '').trim();
             checks.push(createCheck('IMAGE_AVAILABLE', 'ok', `镜像可用: ${image}`, '', detail));
+            imageAvailable = true;
         } catch (error) {
             checks.push(createCheck('IMAGE_MISSING', 'warning', '目标镜像尚不可用', '执行 manyoyo build，或拉取匹配镜像。', error.message || ''));
         }
+        // 镜像在、网络组件也没查出问题时，真实启动一次：info 正常不代表容器能起来
+        if (imageAvailable && !(network && network.missing)) {
+            try {
+                await runCommand(runtimeCommand, ['run', '--rm', '--entrypoint', '', image, 'true'], { env: runtimeEnv, timeout: START_TEST_TIMEOUT_MS });
+                checks.push(createCheck('CONTAINER_START_OK', 'ok', '容器可以正常启动'));
+            } catch (error) {
+                const raw = `${error.message || ''}\n${error.stderr || ''}`;
+                const info = describeError(raw, { command: runtimeCommand, imageRef: image });
+                checks.push(createCheck(
+                    'CONTAINER_START_FAILED', 'error',
+                    info ? info.reason : '容器无法启动',
+                    info ? info.action : `手动执行 ${runtimeCommand} run --rm ${image} true 查看原因。`,
+                    String(error.stderr || error.message || '').trim().split('\n').slice(-5).join('\n')
+                ));
+            }
+        }
     }
 
     checks.push(options.configExists === true
@@ -71,9 +99,13 @@ async function runDoctorChecks(options = {}) {
     }
 
     const pluginConfig = options.pluginConfig;
-    checks.push(pluginConfig && typeof pluginConfig === 'object' && !Array.isArray(pluginConfig)
-        ? createCheck('PLUGIN_CONFIG_VALID', 'ok', '插件配置有效')
-        : createCheck('PLUGIN_CONFIG_INVALID', 'warning', '插件配置不存在或格式无效', '将 plugins 配置为对象(map)。'));
+    if (pluginConfig === undefined || pluginConfig === null) {
+        checks.push(createCheck('PLUGIN_CONFIG_VALID', 'ok', '未配置插件'));
+    } else {
+        checks.push(typeof pluginConfig === 'object' && !Array.isArray(pluginConfig)
+            ? createCheck('PLUGIN_CONFIG_VALID', 'ok', '插件配置有效')
+            : createCheck('PLUGIN_CONFIG_INVALID', 'warning', '插件配置格式无效', '将 plugins 配置为对象(map)。'));
+    }
 
     if (options.portStatus === 'available') {
         checks.push(createCheck('PORT_AVAILABLE', 'ok', '监听端口可用'));

package/lib/error-hints.js

@@ -1,7 +1,14 @@
 'use strict';
 
+const { describeMissing } = require('./rootless-network');
+
 // 原始运行时/系统错误 -> “原因 + 下一步”。新增映射只改这里。
 const RULES = [
+    {
+        code: 'ROOTLESS_NETWORK_MISSING',
+        pattern: /could not find (slirp4netns|pasta)/i,
+        describe: (ctx, match) => describeMissing(match[1].toLowerCase(), ctx)
+    },
     {
         code: 'PODMAN_MACHINE_UNAVAILABLE',
         pattern: /Cannot connect to Podman|unable to connect to Podman socket|podman machine start|podman system connection/i,
@@ -78,8 +85,9 @@ function describeError(text, context = {}) {
     const raw = String(text || '');
     const ctx = { command: 'docker', imageRef: '', port: '', ...context };
     for (const rule of RULES) {
-        if (rule.pattern.test(raw)) {
-            return { code: rule.code, ...rule.describe(ctx) };
+        const match = rule.pattern.exec(raw);
+        if (match) {
+            return { code: rule.code, ...rule.describe(ctx, match) };
         }
     }
     return null;

package/lib/json5-text-edit.js

@@ -235,11 +235,26 @@ function formatPropertyKey(key) {
     return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(key) ? key : JSON.stringify(key);
 }
 
+// 某个位置所在行的缩进
+function lineIndentAt(text, index) {
+    const lineStart = text.lastIndexOf('\n', index - 1) + 1;
+    return /^[ \t]*/.exec(text.slice(lineStart))[0];
+}
+
+// 多行值（JSON.stringify 的结果）的后续行补上插入位置的缩进，否则内层会顶格
+function reindent(valueText, indent) {
+    return String(valueText).replace(/\n/g, `\n${indent}`);
+}
+
 // 永远只在对象的 '{' 后面插入，不管这个对象原来是空的还是已经有属性——
 // 不用去判断"是不是最后一个属性、要不要补逗号"，语法上总是安全的
 function insertObjectProperty(text, objectStartIndex, key, valueText) {
-    const prefix = `\n    ${formatPropertyKey(key)}: `;
-    const insertion = `${prefix}${valueText},`;
+    const objectIndent = lineIndentAt(text, objectStartIndex);
+    const childIndent = `${objectIndent}    `;
+    const prefix = `\n${childIndent}${formatPropertyKey(key)}: `;
+    // 空对象：闭合的 } 另起一行，不要贴在逗号后面
+    const closesRightAfter = text[skipTrivia(text, objectStartIndex + 1)] === '}';
+    const insertion = `${prefix}${reindent(valueText, childIndent)},${closesRightAfter ? `\n${objectIndent}` : ''}`;
     const insertPos = objectStartIndex + 1;
     const nextText = `${text.slice(0, insertPos)}${insertion}${text.slice(insertPos)}`;
     return { text: nextText, valueStart: insertPos + prefix.length };
@@ -269,7 +284,7 @@ function upsertValueByPath(text, pathParts, valueText) {
         if (existingRange) {
             if (isLast) {
                 return applyTextReplacements(currentText, [
-                    { start: existingRange.start, end: existingRange.end, text: valueText }
+                    { start: existingRange.start, end: existingRange.end, text: reindent(valueText, lineIndentAt(currentText, existingRange.start)) }
                 ]);
             }
             const nextObjectStart = skipTrivia(currentText, existingRange.start);

package/lib/post-install.js

@@ -0,0 +1,143 @@
+'use strict';
+
+// 安装完成后的“下一步”：由安装包调用 `manyoyo --post-install [--headless|--gui]`（隐藏入口，不在帮助里）。
+//   有图形界面            直接启动网页服务并打开浏览器
+//   无头 + 有终端         问一次：1 在终端里配置（manyoyo setup）/ 2 启动网页版（SSH 端口转发）/ 3 先不配置
+//   无头 + 没有终端       只安装，不启动任何服务，打印下一步（脚本、CI、ssh host '…' 的场景）
+// 另外会提示：PATH 里还有另一份 manyoyo、还在运行旧版代码的 serve。所有 IO 注入，便于测试。
+
+const fs = require('fs');
+const path = require('path');
+const { inspectScript, findOutdatedInstances, restartCommand, sourceLabel } = require('./serve-instances');
+
+/**
+ * PATH 里除 ownRoot（~/.manyoyo）之外的其他 manyoyo 可执行文件，按真实路径去重。
+ */
+function findOtherManyoyo({ pathEnv = process.env.PATH || '', ownRoot, currentVersion = '' } = {}) {
+    const seen = new Set();
+    const result = [];
+    // home 可能经过符号链接（如 /home → /var/home）：realpath 后的路径要和解析后的 ownRoot 比
+    let realOwnRoot = ownRoot || '';
+    try {
+        if (ownRoot) realOwnRoot = fs.realpathSync(ownRoot);
+    } catch (error) {
+        // 目录不存在：按原样比较
+    }
+    for (const dir of String(pathEnv).split(path.delimiter).filter(Boolean)) {
+        const candidate = path.join(dir, 'manyoyo');
+        let real;
+        try {
+            fs.accessSync(candidate, fs.constants.X_OK);
+            real = fs.realpathSync(candidate);
+        } catch (error) {
+            continue;
+        }
+        if (seen.has(real)) continue;
+        seen.add(real);
+        if (ownRoot && (real.startsWith(`${ownRoot}${path.sep}`) || real.startsWith(`${realOwnRoot}${path.sep}`))) continue;
+        const info = inspectScript(real);
+        if (info.version && info.version === currentVersion && info.source === 'offline') continue;
+        result.push({ path: candidate, version: info.version, source: info.source });
+    }
+    return result;
+}
+
+function otherManyoyoNotice(others, currentVersion) {
+    if (others.length === 0) return [];
+    const lines = ['', '提示：这台机器上还有另一份 manyoyo'];
+    for (const item of others) {
+        const detail = [item.version || '版本未知', sourceLabel(item.source)].join('，');
+        lines.push(`  ${item.path}（${detail}）`);
+    }
+    lines.push(`  新开终端后，输入 manyoyo 会优先使用本次的 ${currentVersion}；另一份不会被改动。`);
+    return lines;
+}
+
+function outdatedServeNotice(instances, currentVersion) {
+    const outdated = findOutdatedInstances(instances, currentVersion);
+    if (outdated.length === 0) return [];
+    const lines = ['', '提示：有 serve 还在运行旧版代码，需要重启才会换成新版'];
+    for (const item of outdated) {
+        lines.push(`  ${item.listen}（pid ${item.pid}，版本 ${item.version || '未知'}，${sourceLabel(item.source)}）`);
+    }
+    const hasMaskedPassword = outdated.some(item => item.args.includes('******'));
+    lines.push(`  重启命令${hasMaskedPassword ? '（把 ****** 换成你原来的密码）' : ''}：`);
+    for (const item of outdated) lines.push(`  ${restartCommand(item)}`);
+    return lines;
+}
+
+const CHOICES = [
+    '在终端里配置（推荐）',
+    '启动网页版，用你自己电脑的浏览器访问（需要 SSH 端口转发）',
+    '先不配置，以后自己运行 manyoyo setup'
+];
+
+async function askChoice(ask, log) {
+    log('');
+    log('这台机器没有图形界面，怎么完成首次配置？');
+    CHOICES.forEach((text, index) => log(`  ${index + 1}) ${text}`));
+    for (;;) {
+        let answer;
+        try {
+            answer = String(await ask('请选择 [默认选1]: ')).trim();
+        } catch (error) {
+            return 3; // 输入被中断（Ctrl-D / stdin 关闭）：按“先不配置”处理
+        }
+        if (answer === '') return 1;
+        if (['1', '2', '3'].includes(answer)) return Number(answer);
+        log('请输入 1、2 或 3。');
+    }
+}
+
+function installedOnlyHint(log, name) {
+    log('');
+    log('已安装，没有启动任何服务。之后：');
+    log(`  ${name} setup   在终端里配置`);
+    log(`  ${name}         启动网页版（无图形界面时会告诉你怎么转发端口）`);
+}
+
+/**
+ * @param {object} deps
+ *   headless, interactive, currentVersion, ownRoot, commandName
+ *   ask(prompt) → Promise<string>、log(line)
+ *   startApp() → Promise  启动（或复用）网页服务；有头时打开浏览器
+ *   runSetup() → Promise<number>  manyoyo setup 的退出码
+ *   findOthers() → [] / listServes() → []（默认读真实环境）
+ */
+async function runPostInstall(deps) {
+    const { headless, interactive, currentVersion, log, ask } = deps;
+    const name = deps.commandName || 'manyoyo';
+    const others = deps.findOthers ? deps.findOthers() : findOtherManyoyo({ ownRoot: deps.ownRoot, currentVersion });
+    otherManyoyoNotice(others, currentVersion).forEach(line => log(line));
+
+    if (!headless) {
+        await deps.startApp();
+    } else if (!interactive) {
+        installedOnlyHint(log, name);
+    } else {
+        const choice = await askChoice(ask, log);
+        if (choice === 1) {
+            log('');
+            const code = await deps.runSetup();
+            if (code === 0) {
+                log('');
+                log('✓ 配置完成。常用命令：');
+                log(`  ${name} run -y c      在沙箱里启动 Claude Code`);
+                log(`  ${name}               启动网页服务，打开网页版（无图形界面时会告诉你怎么转发端口）`);
+                log(`  ${name} serve --list  查看正在运行的 serve`);
+            } else {
+                log(`配置没有完成，之后运行 ${name} setup 重试。`);
+            }
+        } else if (choice === 2) {
+            await deps.startApp();
+        } else {
+            installedOnlyHint(log, name);
+        }
+    }
+
+    const serves = deps.listServes ? deps.listServes() : [];
+    outdatedServeNotice(serves, currentVersion).forEach(line => log(line));
+    return 0;
+}
+
+module.exports = { runPostInstall, findOtherManyoyo, otherManyoyoNotice, outdatedServeNotice };

package/lib/rootless-network.js

@@ -0,0 +1,68 @@
+'use strict';
+
+const fs = require('fs');
+
+// rootless podman 的默认网络组件：4.x 用 slirp4netns，5.x 起用 pasta
+const PACKAGE_OF = { slirp4netns: 'slirp4netns', pasta: 'passt' };
+
+function parsePodmanMajor(versionText) {
+    const match = /(\d+)\.\d+/.exec(String(versionText || ''));
+    return match ? Number(match[1]) : null;
+}
+
+function defaultNetworkComponent(major) {
+    return major !== null && major >= 5 ? 'pasta' : 'slirp4netns';
+}
+
+function readOsRelease() {
+    try {
+        return fs.readFileSync('/etc/os-release', 'utf8');
+    } catch (e) {
+        return '';
+    }
+}
+
+function hasCommand(name) {
+    return String(process.env.PATH || '').split(':').some(dir => dir && fs.existsSync(`${dir}/${name}`));
+}
+
+// 与 scripts/offline/install.sh 的 Linux 分支保持同一套规则；不认识的发行版返回 null（只给说明）
+function installCommand(component, { osRelease = readOsRelease(), hasDnf = hasCommand('dnf') } = {}) {
+    const pkg = PACKAGE_OF[component] || component;
+    const ids = (String(osRelease).match(/^(?:ID|ID_LIKE)=(.*)$/gm) || [])
+        .map(line => line.split('=')[1].replace(/["']/g, '').toLowerCase())
+        .join(' ')
+        .split(/\s+/);
+    if (ids.some(id => id === 'debian' || id === 'ubuntu')) return `sudo apt-get install -y ${pkg}`;
+    if (ids.some(id => ['fedora', 'rhel', 'centos'].includes(id))) return `sudo ${hasDnf ? 'dnf' : 'yum'} install -y ${pkg}`;
+    return null;
+}
+
+function describeMissing(component, options) {
+    const pkg = PACKAGE_OF[component] || component;
+    const command = installCommand(component, options);
+    return {
+        reason: `rootless Podman 缺少默认网络组件 ${component}，容器无法创建网络。`,
+        action: command ? `请执行: ${command}` : `请用系统包管理器安装 ${pkg}（提供 ${component}）。`
+    };
+}
+
+/**
+ * 检查 rootless podman 的默认网络组件是否存在（只在 Linux 的 podman 上检查）。
+ * @returns {Promise<null|{component: string, reason: string, action: string}>} null 表示无需处理
+ */
+async function checkRootlessNetwork(runCommand, { command, env, timeout, platform = process.platform } = {}) {
+    if (platform !== 'linux' || !/(^|\/)podman$/.test(String(command || ''))) return null;
+    const run = async args => String(await runCommand(command, args, { env, timeout }) || '').trim();
+    try {
+        if ((await run(['info', '--format', '{{.Host.Security.Rootless}}'])) !== 'true') return null;
+        const component = defaultNetworkComponent(parsePodmanMajor(await run(['--version'])));
+        const field = component === 'pasta' ? 'Pasta' : 'Slirp4NetNS';
+        if (await run(['info', '--format', `{{.Host.${field}.Executable}}`])) return { component, missing: false };
+        return { component, missing: true, ...describeMissing(component) };
+    } catch (e) {
+        return null;
+    }
+}
+
+module.exports = { parsePodmanMajor, defaultNetworkComponent, installCommand, describeMissing, checkRootlessNetwork };

package/lib/serve-instances.js

@@ -0,0 +1,172 @@
+'use strict';
+
+// 正在运行的 manyoyo serve 实例：靠 ~/.manyoyo/run/serve/<监听地址>.pid 记录（7.x 起就是这个格式，所以也能认出旧版实例）。
+// `manyoyo serve --list` 与安装器装完后的“旧版 serve 还在运行”提示共用这里。
+// 版本与来源从进程命令行里的脚本路径推断（脚本旁边的 package.json；npm 全局安装或 ~/.manyoyo/app/<版本>/）。
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const DEFAULT_LISTEN = '127.0.0.1:3000';
+const SECRET_FLAGS = new Set(['-P', '--pass']);
+const SECRET_ENV_NAME = /(KEY|TOKEN|SECRET|PASSWORD|PASS|AUTH|CREDENTIAL)/i;
+
+// Linux 优先读 /proc/<pid>/cmdline（NUL 分隔，路径里有空格也不会被拆开）；否则退回 ps（macOS）
+function defaultReadArgs(pid) {
+    try {
+        const raw = fs.readFileSync(`/proc/${pid}/cmdline`, 'utf-8');
+        const tokens = raw.split('\0').filter(Boolean);
+        if (tokens.length > 0) return tokens;
+    } catch (error) {
+        // 没有 /proc：用 ps
+    }
+    const result = spawnSync('ps', ['-p', String(pid), '-o', 'args='], { encoding: 'utf-8' });
+    return result.status === 0 ? String(result.stdout || '').trim() : '';
+}
+
+function defaultIsRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    } catch (error) {
+        return error && error.code === 'EPERM';
+    }
+}
+
+/** 密码不出现在任何输出里：-P <值> / --pass <值> / --pass=<值> 都遮成 ****** */
+function maskSecretArgs(tokens) {
+    const result = [];
+    const maskEnv = value => value.replace(/^([^=]+)=.*$/, (all, name) => (SECRET_ENV_NAME.test(name) ? `${name}=******` : all));
+    for (let i = 0; i < tokens.length; i += 1) {
+        const token = tokens[i];
+        if ((token === '-e' || token === '--env') && i + 1 < tokens.length) {
+            result.push(token, maskEnv(tokens[i + 1]));
+            i += 1;
+        } else if (/^--env=/.test(token)) {
+            result.push(`--env=${maskEnv(token.slice(6))}`);
+        } else if (/^-P.+/.test(token)) {
+            result.push('-P', '******'); // 粘连写法 -Psecret
+        } else if (SECRET_FLAGS.has(token)) {
+            result.push(token);
+            if (i + 1 < tokens.length) {
+                result.push('******');
+                i += 1;
+            }
+        } else if (/^--pass=/.test(token)) {
+            result.push('--pass=******');
+        } else {
+            result.push(token);
+        }
+    }
+    return result;
+}
+
+function listenFromFileName(name) {
+    const base = name.replace(/\.pid$/, '');
+    const index = base.lastIndexOf('_');
+    return index > 0 ? `${base.slice(0, index)}:${base.slice(index + 1)}` : DEFAULT_LISTEN;
+}
+
+function inspectScript(scriptPath, readFile = fs.readFileSync, realpath = fs.realpathSync) {
+    let real = scriptPath;
+    try {
+        real = realpath(scriptPath);
+    } catch (error) {
+        // 路径已不存在：按原样判断
+    }
+    let version = '';
+    try {
+        version = String(JSON.parse(readFile(path.join(path.dirname(real), '..', 'package.json'), 'utf-8')).version || '');
+    } catch (error) {
+        // 读不到就是“版本未知”
+    }
+    const normalized = real.split(path.sep).join('/');
+    let source = 'unknown';
+    if (normalized.includes('/node_modules/@xcanwin/manyoyo/')) source = 'npm';
+    else if (normalized.includes('/.manyoyo/app/')) source = 'offline';
+    return { version, source };
+}
+
+/** 把 `node /…/manyoyo.js serve 0.0.0.0:3000 -U admin -P x` 拆成脚本与 serve 之后的参数 */
+function parseServeCommand(commandLine) {
+    const tokens = Array.isArray(commandLine) ? commandLine : String(commandLine || '').trim().split(/\s+/).filter(Boolean);
+    const serveIndex = tokens.indexOf('serve');
+    if (serveIndex < 1) return null;
+    const script = tokens.slice(0, serveIndex).reverse().find(token => /manyoyo(\.js)?$|\/my$|\.js$/.test(token)) || tokens[serveIndex - 1];
+    const args = tokens.slice(serveIndex + 1);
+    // 监听地址形如 host:port 或 [ipv6]:port；不能取“第一个非选项参数”，否则 -U admin 的 admin 会被当成地址
+    const listen = args.find(token => /^(\[[^\]]+\]|[A-Za-z0-9.-]+):\d+$/.test(token)) || '';
+    return { script, args, listen };
+}
+
+function listServeInstances(options = {}) {
+    const homeDir = options.homeDir || os.homedir();
+    const readArgs = options.readArgs || defaultReadArgs;
+    const isRunning = options.isRunning || defaultIsRunning;
+    const dir = path.join(homeDir, '.manyoyo', 'run', 'serve');
+    let names = [];
+    try {
+        names = fs.readdirSync(dir).filter(name => name.endsWith('.pid')).sort();
+    } catch (error) {
+        return [];
+    }
+    const instances = [];
+    for (const name of names) {
+        let pid = 0;
+        try {
+            const text = fs.readFileSync(path.join(dir, name), 'utf-8').trim();
+            pid = /^\d+$/.test(text) ? Number(text) : 0;
+        } catch (error) {
+            pid = 0;
+        }
+        if (!pid || !isRunning(pid)) continue;
+        const parsed = parseServeCommand(readArgs(pid));
+        // 命令行不是 manyoyo serve：pid 文件残留且 pid 已被别的进程复用，不能算 serve 实例
+        if (!parsed) continue;
+        const info = inspectScript(parsed.script);
+        const args = parsed.args;
+        instances.push({
+            pid,
+            // 命令行里写了监听地址就用它；没写（用默认或配置）时 pid 文件名就是实际监听地址（host_port）
+            listen: parsed.listen || listenFromFileName(name),
+            version: info.version,
+            source: info.source,
+            args: maskSecretArgs(args),
+            command: `my serve ${maskSecretArgs(args).join(' ')}`.trim()
+        });
+    }
+    return instances;
+}
+
+function sourceLabel(source) {
+    return { npm: '由全局 Node 的 npm 安装', offline: '安装包安装', unknown: '来源未知' }[source] || '来源未知';
+}
+
+/** 表格：监听地址 / PID / 版本 / 启动命令 */
+function formatServeTable(instances) {
+    if (instances.length === 0) return '没有正在运行的 serve。';
+    const rows = instances.map(item => [item.listen, String(item.pid), item.version || '未知', item.command]);
+    const header = ['监听地址', 'PID', '版本', '启动命令'];
+    // 终端里中日韩字符占两列，按显示宽度对齐
+    const width = text => [...text].reduce((sum, char) => sum + (/[\u1100-\u115f\u2e80-\ua4cf\uac00-\ud7a3\uf900-\ufaff\ufe30-\ufe6f\uff00-\uff60]/.test(char) ? 2 : 1), 0);
+    const widths = header.map((_, column) => Math.max(...[header, ...rows].map(row => width(row[column]))));
+    const pad = (text, size) => text + ' '.repeat(size - width(text) + 2);
+    return [header, ...rows].map(row => row.map((cell, column) => (column === 3 ? cell : pad(cell, widths[column]))).join('').trimEnd()).join('\n');
+}
+
+/** 与当前版本不同的实例（旧版代码还在跑） */
+function findOutdatedInstances(instances, currentVersion) {
+    return instances.filter(item => item.version !== currentVersion);
+}
+
+/** 重启成新版的命令：沿用原参数（密码仍是 ******，需要换回原密码），加 -d --restart */
+function restartCommand(instance) {
+    const args = instance.args.filter(token => token !== '-d' && token !== '--detach' && token !== '--restart');
+    // --restart 必须显式带监听地址：命令行里没写（用了默认或配置里的）就补上实际监听地址
+    if (!args.includes(instance.listen)) args.unshift(instance.listen);
+    return `my serve ${args.join(' ')} -d --restart`.replace(/\s+/g, ' ');
+}
+
+module.exports = { listServeInstances, formatServeTable, findOutdatedInstances, restartCommand, sourceLabel, maskSecretArgs, parseServeCommand, inspectScript };

package/lib/serve-log.js

@@ -84,6 +84,16 @@ function sanitizeSensitiveData(obj) {
     return result;
 }
 
+// 命令行参数里的 KEY=值（--env / 镜像构建参数等）：敏感键的值整体打码，用于错误信息与 show-command
+function redactCommandArgs(args) {
+    const sensitive = /KEY|TOKEN|SECRET|PASSWORD|PASS|AUTH|CREDENTIAL/i;
+    return (Array.isArray(args) ? args : []).map(arg => {
+        const text = String(arg);
+        const match = /^([A-Za-z_][A-Za-z0-9_.]*)=/.exec(text);
+        return match && sensitive.test(match[1]) ? `${match[1]}=****` : text;
+    });
+}
+
 function formatServeLogValue(value) {
     if (value instanceof Error) {
         return sanitizeServeLogText(value.stack || value.message || String(value));
@@ -111,6 +121,7 @@ module.exports = {
     sanitizeProcessArgv,
     sanitizeServeLogText,
     sanitizeSensitiveData,
+    redactCommandArgs,
     formatServeLogValue,
     getServeProcessSnapshot
 };

package/lib/setup-cli.js

@@ -68,7 +68,7 @@ async function chooseNumber(prompter, log, title, items, { defaultIndex = 0, all
     items.forEach((item, index) => log(`  ${index + 1}) ${item}`));
     if (allowSkip) log('  0) 跳过 / 官方默认');
     for (;;) {
-        const answer = String(await prompter.ask(`请选择${allowSkip ? '' : ` [${defaultIndex + 1}]`}: `)).trim();
+        const answer = String(await prompter.ask(allowSkip ? '请选择（回车 = 跳过）: ' : `请选择 [默认选${defaultIndex + 1}]: `)).trim();
         if (answer === '' && !allowSkip) return defaultIndex;
         if (allowSkip && (answer === '' || answer === '0')) return -1;
         const index = Number(answer) - 1;
@@ -137,10 +137,14 @@ async function runSetupCli(deps) {
     }
     const prompter = deps.prompter;
     try {
+        // 步骤与网页向导一致：1 选择 Agent → 2 接入方式（Base URL → Key → 模型）→ 3 工作目录 → 4 保存并开始（登录密码）
         const agents = listSetupAgents();
-        const agentIndex = await chooseNumber(prompter, log, '选择要配置的 Agent：', agents.map(item => `${item.label}（${item.id}）`));
+        log('\n第 1 / 4 步 · 选择 Agent');
+        const agentIndex = await chooseNumber(prompter, log, '选择你想在沙箱里运行的 Agent：', agents.map(item => `${item.label}（${item.id}）`));
         const agent = agents[agentIndex];
 
+        log('\n第 2 / 4 步 · 接入方式');
+        const modeIndex = await chooseNumber(prompter, log, '访问模型服务的方式：', ['官方 API Key', '兼容服务（自定义 Base URL）']);
         const env = {};
         let keyName = agent.requiredAnyOf[0];
         if (agent.requiredAnyOf.length > 1) {
@@ -150,26 +154,32 @@ async function runSetupCli(deps) {
             }));
             keyName = agent.requiredAnyOf[keyIndex];
         }
-        const key = String(await prompter.askSecret(`${keyName}（输入不回显）: `)).trim();
+        if (modeIndex === 1) {
+            const baseUrlItems = [...agent.baseUrlPresets.map(item => `${item.label}  ${item.value}`), '自定义地址'];
+            const baseIndex = await chooseNumber(prompter, log, 'Base URL：', baseUrlItems);
+            if (baseIndex < agent.baseUrlPresets.length) {
+                env[agent.baseUrlKey] = agent.baseUrlPresets[baseIndex].value;
+            } else {
+                const custom = String(await prompter.ask('请输入 Base URL: ')).trim();
+                if (!custom) {
+                    log('兼容服务必须填写 Base URL，已退出，没有改动任何配置。');
+                    return 1;
+                }
+                env[agent.baseUrlKey] = custom;
+            }
+        }
+        const key = String(await prompter.askSecret(`API Key（${keyName}，输入不回显）: `)).trim();
         if (!key) {
             log('凭据不能为空，已退出，没有改动任何配置。');
             return 1;
         }
         env[keyName] = key;
-
-        const baseUrlItems = [...agent.baseUrlPresets.map(item => `${item.label}  ${item.value}`), '自定义地址'];
-        const baseIndex = await chooseNumber(prompter, log, 'API 地址：', baseUrlItems, { allowSkip: true });
-        if (baseIndex >= 0 && baseIndex < agent.baseUrlPresets.length) {
-            env[agent.baseUrlKey] = agent.baseUrlPresets[baseIndex].value;
-        } else if (baseIndex === agent.baseUrlPresets.length) {
-            const custom = String(await prompter.ask('请输入 API 地址: ')).trim();
-            if (custom) env[agent.baseUrlKey] = custom;
-        }
-        const model = String(await prompter.ask(`默认模型 ${agent.modelKey}（可留空）: `)).trim();
+        const model = String(await prompter.ask(`模型（${agent.modelKey}，可选，回车跳过）: `)).trim();
         if (model) env[agent.modelKey] = model;
 
+        log('\n第 3 / 4 步 · 工作目录');
         const defaultWork = deps.defaultWorkpath;
-        let hostPath = String(await prompter.ask(`工作目录（Agent 只能看到这里）[${defaultWork}]: `)).trim() || defaultWork;
+        let hostPath = String(await prompter.ask(`工作目录（Agent 只能看到这里）[默认 ${defaultWork}]: `)).trim() || defaultWork;
         if (!path.isAbsolute(hostPath)) {
             log('工作目录必须是绝对路径，已退出，没有改动任何配置。');
             return 1;
@@ -178,10 +188,11 @@ async function runSetupCli(deps) {
         fs.mkdirSync(hostPath, { recursive: true });
         deps.validateHostPath(hostPath);
 
+        log('\n第 4 / 4 步 · 保存并开始');
         const password = await askPassword(prompter, log);
 
         let mirrors = {};
-        if (/^y(es)?$/i.test(String(await prompter.ask('配置 apt / npm / pip 软件源吗？默认官方源 [y/N]: ')).trim())) {
+        if (/^y(es)?$/i.test(String(await prompter.ask('配置 apt / npm / pip 软件源吗？默认官方源 [默认选否 y/N]: ')).trim())) {
             mirrors = await askMirrors(prompter, log);
         }
 

package/package.json

@@ -1,9 +1,9 @@
 {
     "name": "@xcanwin/manyoyo",
-    "version": "8.2.0",
+    "version": "8.3.0",
     "imageVersion": "2.1.0-common",
     "playwrightCliVersion": "0.1.21",
-    "description": "AI Agent CLI Security Sandbox for Docker and Podman",
+    "description": "MANYOYO – open-source AI agent sandbox: run AI coding agents (Claude Code / Codex / Gemini) safely in Docker/Podman",
     "keywords": [
         "manyoyo",
         "ai-agent",