@xcanwin/manyoyo 8.1.0 → 8.2.1

package/README.md

@@ -71,7 +71,7 @@ manyoyo run -y c   # 在沙箱里以 YOLO 模式启动 Claude Code
 
 ## 安全须知
 
-MANYOYO 降低风险，但不是“绝对安全”：主要隔离手段是容器而不是虚拟机；`YOLO / SOLO` 仍可能执行危险命令；`sock` 模式会暴露宿主机 Docker socket；对外监听必须设强密码。详见[安全须知](https://xcanwin.github.io/manyoyo/reference/container-modes)。
+MANYOYO 降低风险，但不是“绝对安全”：主要隔离手段是容器而不是虚拟机；`YOLO / SOLO` 仍可能执行危险命令；`sock` 模式会暴露宿主机 Docker socket；对外监听必须设强密码。详见[安全须知](https://xcanwin.github.io/manyoyo/guide/security)。
 
 ## 文档
 

package/bin/manyoyo.js

@@ -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');
@@ -895,7 +897,7 @@ async function updateOfflineInstall(mode, options, globalConfig) {
 
     // Podman / VM 磁盘有变化只提示（需要新的完整包）
     const runtimeHint = appUpdate.describeRuntimeChange(appUpdate.readInstalledRecord(os.homedir()), result.manifest.runtime);
-    if (runtimeHint) console.log(`${YELLOW}ℹ️  ${runtimeHint}${NC}`);
+    if (runtimeHint && appUpdate.markRuntimeHintShown(os.homedir(), result.manifest.runtime)) console.log(`${YELLOW}ℹ️  ${runtimeHint}${NC}`);
 
     // 新版本要求的镜像不存在就拉取；仍用旧镜像的容器只列出来，不动
     const imageName = String(globalConfig.imageName || 'ghcr.io/xcanwin/manyoyo');
@@ -1274,7 +1276,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 +1431,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,6 +1461,12 @@ 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) {
@@ -1489,6 +1498,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 +1510,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') {
@@ -2349,12 +2352,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/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/app-update.js

@@ -275,6 +275,27 @@ function describeRuntimeChange(installed, remoteRuntime) {
     return `新版本捆绑的运行环境有变化（${parts.join('，')}）。本次只升级了 manyoyo 本体；要换 Podman / 虚拟机，请下载新的完整安装包重新安装。`;
 }
 
+/**
+ * 同一份新运行环境的提示只显示一次（每次 update 都重复提示只是噪音）：
+ * 记下已提示过的 runtime（~/.manyoyo/.install/runtime-hint.json），返回这次是否应该显示。
+ */
+function markRuntimeHintShown(homeDir, runtime) {
+    const file = path.join(homeDir, '.manyoyo', '.install', 'runtime-hint.json');
+    const key = JSON.stringify({ podmanVersion: runtime && runtime.podmanVersion || '', vmDiskSha256: runtime && runtime.vmDiskSha256 || '' });
+    try {
+        if (fs.readFileSync(file, 'utf-8').trim() === key) return false;
+    } catch (error) {
+        // 没有记录或记录损坏：当作没提示过
+    }
+    try {
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.writeFileSync(file, `${key}\n`);
+    } catch (error) {
+        // 记录写不进去不影响升级，最多下次再提示一次
+    }
+    return true;
+}
+
 function readInstalledRecord(homeDir) {
     try {
         return JSON.parse(fs.readFileSync(path.join(homeDir, '.manyoyo', '.install', 'installed.json'), 'utf-8'));
@@ -316,6 +337,7 @@ module.exports = {
     rollbackApp,
     currentVersion,
     describeRuntimeChange,
+    markRuntimeHintShown,
     readInstalledRecord,
     findOutdatedContainers,
     fetchText,

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/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/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);
         }