@xcanwin/manyoyo 7.1.5 → 8.0.1

package/docker/manyoyo.Dockerfile

@@ -3,12 +3,14 @@
 # ==============================================================================
 # 镜像源参数化（默认使用阿里云，可按需覆盖），两个阶段共享同一默认值
 ARG APT_MIRROR=https://mirrors.aliyun.com
+ARG NODEJS_MIRROR=https://mirrors.tencent.com/nodejs-release/
 
 FROM ubuntu:24.04 AS cache-stage
 
 ARG TARGETARCH
 ARG TOOL="common"
 ARG APT_MIRROR
+ARG NODEJS_MIRROR
 
 # 复制缓存目录（可能为空）
 COPY ./docker/cache/ /cache/
@@ -26,7 +28,7 @@ RUN <<EOX
     ensure_curl() {
         if command -v curl > /dev/null 2>&1; then return 0; fi
         echo "安装 curl（缓存缺失，需联网下载）"
-        sed -i "s|http://[^/]*\.ubuntu\.com|${APT_MIRROR}|g" /etc/apt/sources.list.d/ubuntu.sources
+        if [ -n "${APT_MIRROR}" ]; then sed -i "s|http://[^/]*\.ubuntu\.com|${APT_MIRROR}|g" /etc/apt/sources.list.d/ubuntu.sources; fi
         apt-get -o Acquire::https::Verify-Peer=false update -y
         apt-get -o Acquire::https::Verify-Peer=false install -y --no-install-recommends curl ca-certificates
     }
@@ -41,7 +43,7 @@ RUN <<EOX
     else
         echo "下载 Node.js"
         ensure_curl
-        NVM_NODEJS_ORG_MIRROR=https://mirrors.tencent.com/nodejs-release/
+        NVM_NODEJS_ORG_MIRROR=${NODEJS_MIRROR%/}
         NODE_TAR=$(curl -sL ${NVM_NODEJS_ORG_MIRROR}/latest-v24.x/SHASUMS256.txt | grep linux-${ARCH_NODE}.tar.gz | awk '{print $2}')
         curl -fsSL ${NVM_NODEJS_ORG_MIRROR}/latest-v24.x/${NODE_TAR} | tar -xz -C /opt/node --strip-components=1 --exclude='*.md' --exclude='LICENSE'
     fi
@@ -99,7 +101,7 @@ ENV LANG=C.UTF-8 \
 RUN <<EOX
     # 配置 APT 镜像源
     set -eu
-    sed -i "s|http://[^/]*\.ubuntu\.com|${APT_MIRROR}|g" /etc/apt/sources.list.d/ubuntu.sources
+    if [ -n "${APT_MIRROR}" ]; then sed -i "s|http://[^/]*\.ubuntu\.com|${APT_MIRROR}|g" /etc/apt/sources.list.d/ubuntu.sources; fi
     ln -fs /usr/share/zoneinfo/Asia/Shanghai /etc/localtime
 
     # 安装所有基础依赖
@@ -119,6 +121,10 @@ RUN <<EOX
     # 更新 CA 证书
     update-ca-certificates
 
+    # ssh 元包会带上 openssh-server 并在安装时生成主机私钥；公开镜像里不能带每个人都一样的固定私钥，
+    # 删掉后用到 sshd 的人在容器里 ssh-keygen -A 自己生成
+    rm -f /etc/ssh/ssh_host_*_key /etc/ssh/ssh_host_*_key.pub
+
     # 安装 podman（条件）
     case ",$TOOL," in *,full,*|*,podman,*)
         apt-get install -y --no-install-recommends podman
@@ -283,7 +289,7 @@ RUN <<EOX
             ln -sf /usr/local/share/manyoyo-gopls/gopls /usr/local/bin/gopls
         else
             # 下载编译
-            go install golang.org/x/tools/gopls@latest
+            go install -trimpath golang.org/x/tools/gopls@latest
             ln -sf ~/go/bin/gopls /usr/local/bin/gopls
             rm -rf /usr/local/share/manyoyo-gopls
         fi

package/lib/app-launcher.js

@@ -0,0 +1,220 @@
+'use strict';
+
+const fs = require('fs');
+const http = require('http');
+const net = require('net');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const APP_HOST = '127.0.0.1';
+const READY_TIMEOUT_MS = 30000;
+const LOCK_STALE_MS = 60000;
+const SERVE_MARKER_HEADER = 'x-manyoyo-serve';
+const SPAWN_ATTEMPTS = 2;
+
+function getAppStatePath(homeDir = os.homedir()) {
+    return path.join(homeDir, '.manyoyo', 'serve', 'app.json');
+}
+
+function readAppState(filePath) {
+    try {
+        const state = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+        if (state && state.host === APP_HOST && Number.isInteger(state.port) && Number.isInteger(state.pid)) {
+            return state;
+        }
+    } catch (e) {
+        // 不存在或损坏都按“没有实例”处理
+    }
+    return null;
+}
+
+function writeAppState(filePath, state) {
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, `${JSON.stringify(state)}\n`, { mode: 0o600 });
+}
+
+function canConnect(host, port, timeoutMs = 500) {
+    return new Promise(resolve => {
+        const socket = net.connect({ host, port });
+        const done = ok => {
+            socket.destroy();
+            resolve(ok);
+        };
+        socket.setTimeout(timeoutMs, () => done(false));
+        socket.once('connect', () => done(true));
+        socket.once('error', () => done(false));
+    });
+}
+
+// TCP 能连上不代表是 manyoyo：端口可能被别的程序（甚至别的用户）占了，一次性令牌只能发给 manyoyo serve。
+// serve 的每个响应都带 X-Manyoyo-Serve 头（包括未登录的 401），请求本身不带任何凭据。
+function probeManyoyoServe(host, port, timeoutMs = 1500) {
+    return new Promise(resolve => {
+        const req = http.get({ host, port, path: '/api/sessions', timeout: timeoutMs, headers: { Connection: 'close' } }, res => {
+            res.resume();
+            resolve(Boolean(res.headers[SERVE_MARKER_HEADER]));
+        });
+        req.on('timeout', () => { req.destroy(); resolve(false); });
+        req.on('error', () => resolve(false));
+    });
+}
+
+function readLockPid(lockDir) {
+    try {
+        return Number(fs.readFileSync(path.join(lockDir, 'pid'), 'utf-8').trim());
+    } catch (e) {
+        return NaN;
+    }
+}
+
+/**
+ * 同一时刻只让一个 manyoyo 启动器去选端口/启动 serve（mkdir 是原子的）。
+ * 锁的持有者已退出或锁太旧就当作残留清掉。拿不到锁说明另一个终端正在启动，等它结束再复用其结果。
+ */
+async function acquireStartLock(lockDir, deps) {
+    const { isProcessRunning, sleep, now, timeoutMs } = deps;
+    const deadline = now() + timeoutMs;
+    fs.mkdirSync(path.dirname(lockDir), { recursive: true });
+    for (;;) {
+        try {
+            fs.mkdirSync(lockDir);
+            fs.writeFileSync(path.join(lockDir, 'pid'), `${process.pid}\n`);
+            return () => fs.rmSync(lockDir, { recursive: true, force: true });
+        } catch (error) {
+            if (error.code !== 'EEXIST') throw error;
+        }
+        const pid = readLockPid(lockDir);
+        let age = 0;
+        try { age = Date.now() - fs.statSync(lockDir).mtimeMs; } catch (e) { continue; }
+        const holderAlive = Number.isInteger(pid) && pid > 0 && isProcessRunning(pid);
+        if (!holderAlive || age > LOCK_STALE_MS + timeoutMs) {
+            fs.rmSync(lockDir, { recursive: true, force: true });
+            continue;
+        }
+        if (now() > deadline) {
+            throw new Error('另一个 manyoyo 正在启动本机服务，请稍后重试');
+        }
+        await sleep(200);
+    }
+}
+
+function pickFreePort() {
+    return new Promise((resolve, reject) => {
+        const server = net.createServer();
+        server.once('error', reject);
+        server.listen(0, APP_HOST, () => {
+            const { port } = server.address();
+            server.close(err => (err ? reject(err) : resolve(port)));
+        });
+    });
+}
+
+// macOS 用 open，Linux 用 xdg-open；都没有返回 false（由调用方只打印地址）
+function openBrowser(url, deps = {}) {
+    const platform = deps.platform || process.platform;
+    const run = deps.run || ((command, args) => spawnSync(command, args, { stdio: 'ignore' }));
+    const command = platform === 'darwin' ? 'open' : (platform === 'linux' ? 'xdg-open' : '');
+    if (!command) return false;
+    const result = run(command, [url]);
+    return Boolean(result) && !result.error && result.status === 0;
+}
+
+/**
+ * 无参数 manyoyo：复用或后台启动本机 serve，签发一次性令牌并打开浏览器。
+ * 所有副作用都从 deps 注入，便于测试。
+ */
+async function launchApp(deps) {
+    const {
+        statePath, isProcessRunning, spawnServe, issueToken, open, log
+    } = deps;
+    const connect = deps.canConnect || canConnect;
+    const pickPort = deps.pickPort || pickFreePort;
+    const sleep = deps.sleep || (ms => new Promise(resolve => setTimeout(resolve, ms)));
+    const now = deps.now || Date.now;
+    const timeoutMs = deps.readyTimeoutMs || READY_TIMEOUT_MS;
+
+    const probe = deps.probe || (async (host, port) => (await connect(host, port)) && probeManyoyoServe(host, port));
+    const release = await acquireStartLock(path.join(path.dirname(statePath), 'app.lock'), {
+        isProcessRunning, sleep, now, timeoutMs
+    });
+    let state;
+    let reused = false;
+    try {
+        state = readAppState(statePath);
+        if (state && isProcessRunning(state.pid) && await probe(APP_HOST, state.port)) {
+            reused = true;
+        } else {
+            state = await startFresh();
+        }
+    } finally {
+        release();
+    }
+
+    // 选端口与 serve 绑定之间有空档，端口可能被抢；serve 因此立即退出时换端口重试一次
+    async function startFresh() {
+        let lastError = null;
+        for (let attempt = 0; attempt < SPAWN_ATTEMPTS; attempt += 1) {
+            const port = await pickPort();
+            const child = spawnServe(port);
+            let spawnError = null;
+            let exited = false;
+            if (child && typeof child.on === 'function') {
+                child.on('error', error => { spawnError = error; });
+                child.on('exit', () => { exited = true; });
+            }
+            if (child && !Number.isInteger(child.pid)) {
+                await new Promise(resolve => setImmediate(resolve)); // 让异步的 spawn error（如 ENOENT）先到
+            }
+            if (!child || !Number.isInteger(child.pid)) {
+                throw new Error(`无法启动本机服务${spawnError ? `: ${spawnError.message}` : ''}${deps.logPathHint ? `，请查看日志: ${deps.logPathHint}` : ''}`);
+            }
+            const next = { host: APP_HOST, port, pid: child.pid, startedAt: new Date(now()).toISOString() };
+            writeAppState(statePath, next);
+
+            const deadline = now() + timeoutMs;
+            while (now() < deadline && !spawnError && !exited) {
+                if (await probe(APP_HOST, port)) return next;
+                await sleep(200);
+            }
+            if (spawnError) throw new Error(`无法启动本机服务: ${spawnError.message}`);
+            lastError = exited
+                ? new Error(`本机服务启动后立即退出（端口可能被占用）${deps.logPathHint ? `，请查看日志: ${deps.logPathHint}` : ''}`)
+                : new Error(`本机服务在 ${Math.round(timeoutMs / 1000)} 秒内未就绪${deps.logPathHint ? `，请查看日志: ${deps.logPathHint}` : ''}`);
+            if (!exited) break;
+        }
+        throw lastError;
+    }
+
+    const baseUrl = `http://${APP_HOST}:${state.port}`;
+    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(`  关闭服务: ${commandName} serve ${APP_HOST}:${state.port} --stop`);
+        return { reused, opened: false, headless: true, baseUrl, loginUrl: '', pid: state.pid };
+    }
+    const loginUrl = `${baseUrl}/auth/login?token=${issueToken()}`;
+    log(`${reused ? '已复用运行中的服务' : '已启动本机服务'}: ${baseUrl}`);
+    // 服务在后台一直运行，必须告诉用户怎么关
+    log(`  关闭服务: ${deps.commandName || 'manyoyo'} serve ${APP_HOST}:${state.port} --stop`);
+    const opened = open(loginUrl);
+    if (!opened) {
+        // 没有浏览器打开器：一次性地址只在这里打印（60 秒内、用一次即失效）
+        log(`未能自动打开浏览器，请在 60 秒内访问: ${loginUrl}`);
+    }
+    return { reused, opened, baseUrl, loginUrl, pid: state.pid };
+}
+
+module.exports = {
+    APP_HOST,
+    getAppStatePath,
+    readAppState,
+    canConnect,
+    probeManyoyoServe,
+    SERVE_MARKER_HEADER,
+    openBrowser,
+    launchApp
+};

package/lib/app-update.js

@@ -0,0 +1,325 @@
+'use strict';
+
+// 离线包安装的 manyoyo 的增量升级：只下载 -app.tar.gz（Node + manyoyo，数十 MB），校验后放进 app/<版本>/，
+// 原子切换 app/current，保留上一版本以便回滚。npm 安装的用户走原来的 npm 逻辑，不经过这里。
+// 所有网络与进程副作用都从参数注入，便于用本地 HTTP 服务替身做测试。
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+const { downloadVerified, sha256File } = require('./download-verified');
+
+const REPO = 'xcanwin/manyoyo';
+const API_BASE = 'https://api.github.com';
+// 不依赖 PATH 查找 tar（macOS 与常见 Linux 都在 /usr/bin）
+const TAR_COMMAND = fs.existsSync('/usr/bin/tar') ? '/usr/bin/tar' : 'tar';
+const VERSION_PATTERN = /^\d+\.\d+\.\d+$/;
+const FETCH_TIMEOUT_MS = 15000;
+
+class UpdateError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+    }
+}
+
+function parseVersion(text) {
+    const match = String(text || '').trim().replace(/^v/, '').match(/^(\d+)\.(\d+)\.(\d+)/);
+    return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : null;
+}
+
+function compareVersions(a, b) {
+    const left = parseVersion(a);
+    const right = parseVersion(b);
+    if (!left || !right) return 0;
+    for (let i = 0; i < 3; i += 1) {
+        if (left[i] !== right[i]) return left[i] < right[i] ? -1 : 1;
+    }
+    return 0;
+}
+
+/**
+ * 程序真实路径在 ~/.manyoyo/app/<版本>/ 下 → 离线包安装；否则按 npm 安装处理。
+ */
+function detectInstallMode({ scriptPath, homeDir = os.homedir() }) {
+    let real = scriptPath;
+    try {
+        real = fs.realpathSync(scriptPath);
+    } catch (error) {
+        // 路径不存在就按原样比较
+    }
+    const appRoot = path.join(homeDir, '.manyoyo', 'app');
+    const relative = path.relative(appRoot, real);
+    if (!relative.startsWith('..') && !path.isAbsolute(relative)) {
+        const version = relative.split(path.sep)[0];
+        if (VERSION_PATTERN.test(version)) {
+            return { mode: 'offline', appRoot, version };
+        }
+    }
+    return { mode: 'npm' };
+}
+
+function arch() {
+    return process.arch === 'arm64' ? 'arm64' : 'x64';
+}
+
+// Release 资产名里的平台段：macos | linux
+function platformOs() {
+    return process.platform === 'linux' ? 'linux' : 'macos';
+}
+
+async function request(fetchImpl, url, options = {}) {
+    try {
+        return await fetchImpl(url, {
+            redirect: 'follow',
+            // 下载整包不能套短超时（慢网络下几十 MB 要好一会儿），查询类请求才限时
+            signal: options.noTimeout ? undefined : AbortSignal.timeout(FETCH_TIMEOUT_MS),
+            ...options,
+            // 固定的请求头，不附带任何本机信息（用户名、主机名、版本之外的任何东西）
+            headers: { Accept: 'application/vnd.github+json', 'User-Agent': 'manyoyo-update', ...(options.headers || {}) }
+        });
+    } catch (error) {
+        throw new UpdateError('NETWORK', `无法连接 GitHub（${error && error.cause && error.cause.code || error.name || '网络错误'}）。请检查网络或代理后重试。`);
+    }
+}
+
+/**
+ * 查询最新 Release（匿名 API）。返回 { version, tag, assets: { name: url } }。
+ */
+async function fetchLatestRelease({ fetchImpl = fetch, apiBase = API_BASE, now = Date.now } = {}) {
+    const response = await request(fetchImpl, `${apiBase}/repos/${REPO}/releases/latest`);
+    if (response.status === 403 || response.status === 429) {
+        const remaining = response.headers.get('x-ratelimit-remaining');
+        if (response.status === 429 || remaining === '0') {
+            const reset = Number(response.headers.get('x-ratelimit-reset'));
+            const when = reset > 0 ? new Date(reset * 1000).toLocaleTimeString('zh-CN', { hour12: false }) : '';
+            throw new UpdateError('RATE_LIMIT', `GitHub 对匿名请求做了频率限制，${when ? `请在 ${when} 之后重试` : '请稍后重试'}。`);
+        }
+    }
+    if (response.status === 404) throw new UpdateError('NO_RELEASE', '仓库还没有发布的 Release，暂时无法升级。');
+    if (!response.ok) throw new UpdateError('HTTP', `查询最新版本失败（HTTP ${response.status}）。`);
+    let release;
+    try {
+        release = await response.json();
+    } catch (error) {
+        throw new UpdateError('HTTP', '查询最新版本失败（返回内容不是有效的 JSON）。');
+    }
+    const version = String(release.tag_name || '').replace(/^v/, '');
+    if (!VERSION_PATTERN.test(version)) throw new UpdateError('HTTP', `最新 Release 的版本号无法识别: ${release.tag_name}`);
+    // 默认 API 下，下载地址必须在本仓库的 Release 下载路径内（测试注入自定义 apiBase 时不限制）
+    const allowedPrefix = apiBase === API_BASE ? `https://github.com/${REPO}/releases/download/` : '';
+    const assets = {};
+    for (const asset of Array.isArray(release.assets) ? release.assets : []) {
+        if (asset && typeof asset.name === 'string' && typeof asset.browser_download_url === 'string' && asset.browser_download_url.startsWith(allowedPrefix)) assets[asset.name] = asset.browser_download_url;
+    }
+    return { version, tag: release.tag_name, assets };
+}
+
+function parseSha256Sums(text) {
+    const result = {};
+    for (const line of String(text).split('\n')) {
+        const match = line.trim().match(/^([0-9a-f]{64})\s+\*?(.+)$/i);
+        if (match) result[match[2].trim()] = match[1].toLowerCase();
+    }
+    return result;
+}
+
+function releaseAssetNames(version, targetArch, targetOs = 'macos') {
+    return {
+        app: `manyoyo-${version}-${targetOs}-${targetArch}-app.tar.gz`,
+        sums: `SHA256SUMS-${targetOs}-${targetArch}`,
+        manifest: `release-manifest-${targetOs}-${targetArch}.json`
+    };
+}
+
+async function fetchText(fetchImpl, url) {
+    const response = await request(fetchImpl, url);
+    if (!response.ok) throw new UpdateError('HTTP', `下载 ${url.split('/').pop()} 失败（HTTP ${response.status}）。`);
+    return response.text();
+}
+
+function switchCurrent(appRoot, version) {
+    const link = path.join(appRoot, 'current');
+    const staging = path.join(appRoot, `.current.${process.pid}.tmp`);
+    fs.rmSync(staging, { force: true });
+    fs.symlinkSync(version, staging);
+    try {
+        if (fs.existsSync(link) && !fs.lstatSync(link).isSymbolicLink()) {
+            throw new UpdateError('BAD_LAYOUT', `${link} 不是符号链接，拒绝覆盖。`);
+        }
+        fs.renameSync(staging, link); // rename 覆盖符号链接是原子的
+    } catch (error) {
+        fs.rmSync(staging, { force: true });
+        throw error;
+    }
+}
+
+function currentVersion(appRoot) {
+    try {
+        return path.basename(fs.readlinkSync(path.join(appRoot, 'current')));
+    } catch (error) {
+        return '';
+    }
+}
+
+function writeUpdateRecord(appRoot, record) {
+    fs.writeFileSync(path.join(appRoot, '.update.json'), `${JSON.stringify(record)}\n`);
+}
+
+function readUpdateRecord(appRoot) {
+    try {
+        return JSON.parse(fs.readFileSync(path.join(appRoot, '.update.json'), 'utf-8'));
+    } catch (error) {
+        return {};
+    }
+}
+
+// 只保留当前与上一版本，其它版本目录与残留的临时目录一起清掉
+function pruneApps(appRoot, keep) {
+    for (const name of fs.readdirSync(appRoot)) {
+        if (keep.includes(name) || name === 'current' || name === '.update.json') continue;
+        if (VERSION_PATTERN.test(name) || name.startsWith('.tmp-')) fs.rmSync(path.join(appRoot, name), { recursive: true, force: true });
+    }
+}
+
+/**
+ * 下载并安装 -app.tar.gz，成功后切换 current。校验失败/包不完整都在切换前中止，不留半成品。
+ */
+async function installAppUpdate({ appRoot, release, fetchImpl = fetch, targetArch = arch(), targetOs = 'macos', run = defaultRun, log = () => {}, tmpRoot = os.tmpdir() }) {
+    const names = releaseAssetNames(release.version, targetArch, targetOs);
+    const appUrl = release.assets[names.app];
+    const sumsUrl = release.assets[names.sums] || release.assets.SHA256SUMS;
+    if (!appUrl || !sumsUrl) {
+        throw new UpdateError('NO_ASSET', `Release ${release.version} 里没有适合这台机器（${targetOs}-${targetArch}）的升级包（需要 ${names.app} 与 ${names.sums}）。`);
+    }
+
+    log(`校验清单: ${names.sums}`);
+    const sums = parseSha256Sums(await fetchText(fetchImpl, sumsUrl));
+    const expected = sums[names.app];
+    if (!expected) throw new UpdateError('CHECKSUM', `校验清单里没有 ${names.app}，已中止升级。`);
+
+    const workDir = fs.mkdtempSync(path.join(tmpRoot, 'manyoyo-update-'));
+    const staging = path.join(appRoot, `.tmp-${release.version}-${process.pid}`);
+    try {
+        log(`下载升级包: ${names.app}`);
+        const archive = path.join(workDir, names.app);
+        try {
+            await downloadVerified({ url: appUrl, sha256: expected, dest: archive, fetchImpl: (url, options) => request(fetchImpl, url, { ...options, noTimeout: true }), log });
+        } catch (error) {
+            if (/SHA256 校验失败/.test(error.message)) throw new UpdateError('CHECKSUM', `升级包 SHA256 校验失败，已中止升级，当前版本不受影响。`);
+            if (error instanceof UpdateError) throw error;
+            throw new UpdateError('NETWORK', `下载升级包失败：${error.message}`);
+        }
+
+        fs.rmSync(staging, { recursive: true, force: true });
+        fs.mkdirSync(staging, { recursive: true });
+        run(TAR_COMMAND, ['-xzf', archive, '-C', staging]);
+
+        for (const required of ['node/bin/node', 'manyoyo/bin/manyoyo.js', 'manifest.json']) {
+            if (!fs.existsSync(path.join(staging, required))) throw new UpdateError('BAD_PACKAGE', `升级包不完整（缺少 ${required}），已中止升级。`);
+        }
+        let manifest;
+        try {
+            manifest = JSON.parse(fs.readFileSync(path.join(staging, 'manifest.json'), 'utf-8'));
+        } catch (error) {
+            throw new UpdateError('BAD_PACKAGE', '升级包的 manifest.json 无法解析，已中止升级。');
+        }
+        if (manifest.version !== release.version || manifest.kind !== 'app' || manifest.arch !== targetArch || (manifest.os && manifest.os !== targetOs)) {
+            throw new UpdateError('BAD_PACKAGE', `升级包内容与预期不符（版本 ${manifest.version}、类型 ${manifest.kind}、架构 ${manifest.arch}、系统 ${manifest.os || targetOs}），已中止升级。`);
+        }
+        fs.writeFileSync(path.join(staging, '.installed'), await sha256File(path.join(staging, 'manifest.json')));
+
+        const previous = currentVersion(appRoot);
+        const target = path.join(appRoot, release.version);
+        if (release.version !== previous) fs.rmSync(target, { recursive: true, force: true });
+        if (release.version !== previous) fs.renameSync(staging, target);
+        switchCurrent(appRoot, release.version);
+        writeUpdateRecord(appRoot, { previous: previous && previous !== release.version ? previous : readUpdateRecord(appRoot).previous || '', current: release.version, updatedAt: new Date().toISOString() });
+        const record = readUpdateRecord(appRoot);
+        pruneApps(appRoot, [release.version, record.previous].filter(Boolean));
+        return { version: release.version, previous: record.previous || '', manifest };
+    } finally {
+        fs.rmSync(workDir, { recursive: true, force: true });
+        fs.rmSync(staging, { recursive: true, force: true });
+    }
+}
+
+function rollbackApp({ appRoot }) {
+    const current = currentVersion(appRoot);
+    const record = readUpdateRecord(appRoot);
+    let previous = record.previous;
+    if (!previous || !VERSION_PATTERN.test(previous) || !fs.existsSync(path.join(appRoot, previous))) {
+        const candidates = fs.existsSync(appRoot) ? fs.readdirSync(appRoot).filter(name => VERSION_PATTERN.test(name) && name !== current && fs.existsSync(path.join(appRoot, name, 'manyoyo', 'bin', 'manyoyo.js'))) : [];
+        candidates.sort((a, b) => compareVersions(b, a));
+        previous = candidates[0];
+    }
+    if (!previous) throw new UpdateError('NO_PREVIOUS', '没有可回滚的上一版本。');
+    switchCurrent(appRoot, previous);
+    writeUpdateRecord(appRoot, { previous: current, current: previous, updatedAt: new Date().toISOString() });
+    return { from: current, to: previous };
+}
+
+/**
+ * Podman / VM 磁盘版本变化只提示，不自动替换（需要下载新的完整包）。
+ * installed：安装器写的 ~/.manyoyo/.install/installed.json；remoteManifest：Release 里的 release-manifest（含完整包 manifest）。
+ */
+function describeRuntimeChange(installed, remoteManifest) {
+    const remote = remoteManifest && remoteManifest.manifest && remoteManifest.manifest.components;
+    if (!installed || !installed.podmanVersion || !remote || !remote.podman) return '';
+    const podmanChanged = remote.podman.version !== installed.podmanVersion;
+    const vmChanged = Boolean(installed.vmDiskSha256) && remote.vmDisk && remote.vmDisk.sha256 !== installed.vmDiskSha256;
+    if (!podmanChanged && !vmChanged) return '';
+    const parts = [];
+    if (podmanChanged) parts.push(`Podman ${installed.podmanVersion} → ${remote.podman.version}`);
+    if (vmChanged) parts.push('虚拟机磁盘有更新');
+    return `新版本捆绑的运行环境有变化（${parts.join('，')}）。本次只升级了 manyoyo 本体；要换 Podman / 虚拟机，请下载新的完整安装包重新安装。`;
+}
+
+function readInstalledRecord(homeDir) {
+    try {
+        return JSON.parse(fs.readFileSync(path.join(homeDir, '.manyoyo', '.install', 'installed.json'), 'utf-8'));
+    } catch (error) {
+        return null;
+    }
+}
+
+/** 仍在使用旧镜像的 manyoyo 容器（ref 为新版本要求的镜像）。 */
+function findOutdatedContainers({ run, runtime, imageRef }) {
+    let output = '';
+    try {
+        output = String(run(runtime.command, ['ps', '-a', '--filter', 'label=manyoyo.default_cmd', '--format', '{{.Names}}\t{{.Image}}'], { env: runtime.env }));
+    } catch (error) {
+        return [];
+    }
+    return output.split('\n').map(line => line.trim()).filter(Boolean).map(line => {
+        const [name, image] = line.split('\t');
+        return { name, image: image || '' };
+    }).filter(item => item.name && item.image && item.image !== imageRef);
+}
+
+function defaultRun(command, args, options = {}) {
+    const result = spawnSync(command, args, { encoding: 'utf-8', env: options.env });
+    if (result.error) throw result.error;
+    if (result.status !== 0) throw new Error(String(result.stderr || '').trim() || `${command} 退出码 ${result.status}`);
+    return result.stdout || '';
+}
+
+module.exports = {
+    UpdateError,
+    parseVersion,
+    compareVersions,
+    detectInstallMode,
+    fetchLatestRelease,
+    parseSha256Sums,
+    releaseAssetNames,
+    installAppUpdate,
+    rollbackApp,
+    currentVersion,
+    describeRuntimeChange,
+    readInstalledRecord,
+    findOutdatedContainers,
+    fetchText,
+    arch,
+    platformOs
+};

package/lib/container-run.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const { buildMirrorEnvArgs } = require('./mirrors');
+
 function sanitizeDefaultCommand(defaultCommand) {
     return String(defaultCommand || '').replace(/[\r\n]/g, ' ');
 }
@@ -12,6 +14,7 @@ function buildContainerRunArgs(options) {
         ...(options.contModeArgs || []),
         ...(options.containerExtraArgs || []),
         ...(options.containerEnvs || []),
+        ...buildMirrorEnvArgs(options.mirrors, options.containerEnvs),
         ...(options.containerVolumes || []),
         ...(options.containerPorts || []),
         '--volume', `${options.hostPath}:${options.containerPath}`,