@xcanwin/manyoyo 8.3.2 → 8.4.0

package/lib/plugin/playwright.js

@@ -1,8 +1,8 @@
 'use strict';
 
 // Playwright 插件：容器内的浏览器怎么来，只有 4 种模式、同一时间只有一个。
-//   default  容器内 Xvfb 里的有头浏览器（无需宿主机进程）
-//   headed   宿主机有窗口的浏览器
+//   default  容器内 Xvfb 里的有头 Google Chrome（无需宿主机进程）
+//   headed   宿主机有窗口的浏览器（优先用本机 Google Chrome）
 //   chrome   用户正在使用的 Chrome（经本机中继）
 //   vnc      独立容器里的浏览器，用 noVNC 网页观看
 // 宿主机目录 current/ 以目录方式只读挂进容器的 /run/manyoyo-playwright/，里面的 config.json 一律原子替换，
@@ -106,6 +106,19 @@ function defaultListenHost(platform = process.platform) {
     return platform === 'darwin' ? '127.0.0.1' : '0.0.0.0';
 }
 
+// Google Chrome 在各平台的标准安装位置（patchright 的 channel: 'chrome' 也在这些位置查找）
+function googleChromeCandidates(platform = process.platform, env = process.env) {
+    if (platform === 'darwin') {
+        return ['/Applications/Google Chrome.app/Contents/MacOS/Google Chrome'];
+    }
+    if (platform === 'win32') {
+        return ['PROGRAMFILES', 'PROGRAMFILES(X86)', 'LOCALAPPDATA']
+            .filter(name => env[name])
+            .map(name => path.join(env[name], 'Google', 'Chrome', 'Application', 'chrome.exe'));
+    }
+    return ['/opt/google/chrome/chrome'];
+}
+
 // headed 的浏览器服务必须监听 0.0.0.0：playwright 只绑 loopback 时会按 Host 头做 DNS 重绑定防护，
 // 容器用 host.containers.internal 访问会被 403（macOS 上实测）；监听 0.0.0.0 则不检查 Host，靠 token 保护
 function headedListenHost() {
@@ -171,7 +184,7 @@ class PlaywrightPlugin {
             locale: String(merged.locale || '').trim() || host.locale,
             timezoneId: String(merged.timezoneId || '').trim() || host.timezoneId,
             navigatorPlatform: String(merged.navigatorPlatform || '').trim(),
-            disableWebRTC: merged.disableWebRTC === true || String(merged.disableWebRTC).toLowerCase() === 'true',
+            disableWebRTC: merged.disableWebRTC === undefined ? fingerprint.DEFAULT_PROFILE.disableWebRTC : (merged.disableWebRTC === true || String(merged.disableWebRTC).toLowerCase() === 'true'),
             devtoolsActivePortPath: String(merged.devtoolsActivePortPath || '').trim(),
             extensionProdversion: String(merged.extensionProdversion || '').trim() || '132.0.0.0'
         };
@@ -276,8 +289,10 @@ class PlaywrightPlugin {
         this.ensureDirs();
         const config = `${JSON.stringify(this.containerConfigFor(state, runtimeCommand), null, 4)}\n`;
         const initScript = fingerprint.buildInitScript(this.profile());
+        const envFile = fingerprint.buildContainerEnvFile(this.profile());
         const configPath = path.join(this.currentDir, 'config.json');
         const initPath = path.join(this.currentDir, 'stealth.init.js');
+        const envPath = path.join(this.currentDir, 'env');
         const same = (file, content) => {
             try {
                 return fs.readFileSync(file, 'utf8') === content;
@@ -288,6 +303,9 @@ class PlaywrightPlugin {
         if (!same(initPath, initScript)) {
             writeConfigFileSecure(initPath, initScript);
         }
+        if (!same(envPath, envFile)) {
+            writeConfigFileSecure(envPath, envFile);
+        }
         if (!same(configPath, config)) {
             writeConfigFileSecure(configPath, config);
         }
@@ -395,27 +413,42 @@ class PlaywrightPlugin {
         };
     }
 
+    // 浏览器服务与探测用 patchright-core（去掉 CDP Runtime 痕迹的开源补丁版），
+    // 版本与镜像内 @playwright/cli 的 playwright-core 同 minor，否则容器内 client 连宿主机服务会被 428 拒绝
     corePath() {
-        const cliPackage = require.resolve('@playwright/cli/package.json');
-        return path.dirname(require.resolve('playwright-core/package.json', { paths: [path.dirname(cliPackage)] }));
+        return path.dirname(require.resolve('patchright-core/package.json'));
     }
 
     coreCli() {
         return path.join(this.corePath(), 'cli.js');
     }
 
-    // 浏览器与探测都用 @playwright/cli 自带的 playwright-core，保证与容器内版本一致
     installCommand(args) {
         return `node ${shellValue(this.coreCli())} ${args}`;
     }
 
-    ensureBrowserInstalled() {
+    // 宿主机是否装了 Google Chrome；不会替用户安装（需要 sudo）
+    hasGoogleChrome() {
+        return googleChromeCandidates().some(file => fs.existsSync(file));
+    }
+
+    installChromium() {
         const result = spawnSync(process.execPath, [this.coreCli(), 'install', '--no-shell', 'chromium'], { stdio: 'inherit' });
         if (result.status !== 0) {
             throw new Error(`浏览器安装失败，请手动执行: ${this.installCommand('install --no-shell chromium')}`);
         }
     }
 
+    // 返回是否使用 Google Chrome；没有时退回 patchright 的 Chromium 并提示
+    ensureBrowserInstalled() {
+        if (this.hasGoogleChrome()) {
+            return true;
+        }
+        this.out('[up] 未检测到 Google Chrome，使用 Chromium，部分检测站点会识别为 Chromium。安装 Google Chrome 后重新 up 即可。');
+        this.installChromium();
+        return false;
+    }
+
     // ---------- 探测 ----------
 
     probe(kind, endpoint, timeout = PROBE_TIMEOUT_MS) {
@@ -454,10 +487,10 @@ class PlaywrightPlugin {
 
     // ---------- 进程管理 ----------
 
-    spawnDetached(command, args, logPath) {
+    spawnDetached(command, args, logPath, env = process.env) {
         fs.mkdirSync(path.dirname(logPath), { recursive: true });
         const logFd = fs.openSync(logPath, 'a', 0o600);
-        const child = spawn(command, args, { detached: true, stdio: ['ignore', logFd, logFd] });
+        const child = spawn(command, args, { detached: true, stdio: ['ignore', logFd, logFd], env });
         fs.closeSync(logFd);
         child.unref();
         return child;
@@ -538,8 +571,9 @@ class PlaywrightPlugin {
         if (!(await this.portPreflight('headed', port))) {
             return 1;
         }
+        let useChrome;
         try {
-            this.ensureBrowserInstalled();
+            useChrome = this.ensureBrowserInstalled();
         } catch (error) {
             return this.startFailure('headed', error.message);
         }
@@ -553,21 +587,24 @@ class PlaywrightPlugin {
                 port,
                 wsPath: `/${token}`,
                 chromiumSandbox,
-                extensionArgs: extensions.buildExtensionLaunchArgs(extensionPaths),
+                useChrome,
+                extensionPaths,
                 ...this.profile()
             }), null, 4)}\n`);
             fs.rmSync(this.logPath(), { force: true });
+            // 语言与时区放进浏览器进程的原生环境（合并而不是替换 process.env，代理等变量要保留）
             child = this.spawnDetached(process.execPath,
-                [path.join(__dirname, 'playwright-server.js'), this.corePath(), serverConfigPath], this.logPath());
+                [path.join(__dirname, 'playwright-server.js'), this.corePath(), serverConfigPath], this.logPath(),
+                { ...process.env, ...fingerprint.buildProcessEnv(this.profile()) });
             if (await this.waitForPort(port, child)) {
                 break;
             }
             await this.killGroup(child.pid, { verify: false });
             if (!chromiumSandbox || !tailText(this.logPath(), 200).includes('No usable sandbox')) {
                 return this.startFailure('headed', '浏览器服务没有启动成功。',
-                    `${tailText(this.logPath(), 20)}\n缺系统依赖时执行: sudo ${this.installCommand('install-deps chromium')}`);
+                    `${tailText(this.logPath(), 20)}${useChrome ? '' : `\n缺系统依赖时执行: sudo ${this.installCommand('install-deps chromium')}`}`);
             }
-            this.out('[up] 系统不允许非特权用户命名空间，Chromium 沙箱不可用，改为无沙箱启动。');
+            this.out('[up] 系统不允许非特权用户命名空间，浏览器沙箱不可用，改为无沙箱启动。');
         }
         return { mode: 'headed', port, pid: child.pid, listenHost: headedListenHost(), extensionPaths };
     }
@@ -669,12 +706,13 @@ class PlaywrightPlugin {
             wsPath: `/${token}`,
             window: 'virtual',
             chromiumSandbox: false,
-            extensionArgs: extensions.buildExtensionLaunchArgs(mounts.containerPaths),
+            extensionPaths: mounts.containerPaths,
             ...this.profile()
         }), null, 4)}\n`);
         const envFile = path.join(mountDir, 'env');
         const noProxy = appendNoProxy(process.env.NO_PROXY ?? process.env.no_proxy);
-        writeConfigFileSecure(envFile, `VNC_PASSWORD=${password}\nNO_PROXY=${noProxy}\nno_proxy=${noProxy}\n`);
+        const nativeEnv = Object.entries(fingerprint.buildProcessEnv(this.profile())).map(([key, value]) => `${key}=${value}\n`).join('');
+        writeConfigFileSecure(envFile, `VNC_PASSWORD=${password}\nNO_PROXY=${noProxy}\nno_proxy=${noProxy}\n${nativeEnv}`);
         this.runtimeCall(['rm', '-f', VNC_CONTAINER]);
         const listenHost = defaultListenHost();
         const args = [
@@ -917,5 +955,6 @@ module.exports = {
     appendNoProxy,
     connectHostFor,
     defaultListenHost,
+    googleChromeCandidates,
     headedListenHost
 };

package/lib/port-forward.js

@@ -0,0 +1,135 @@
+'use strict';
+
+const { spawn } = require('child_process');
+const net = require('net');
+const os = require('os');
+const { buildExecArgs } = require('./container-exec');
+
+// 运行中暴露容器端口：serve 在宿主机监听 bind:hostPort，每个连接起一个 `exec -i <容器> socat STDIO TCP:127.0.0.1:<端口>` 双向 pipe。
+// 不需要重启容器、不依赖容器的网络模式（slirp4netns / bridge / pasta 都一样）。
+const MAX_CONNECTIONS_PER_FORWARD = 64;
+
+// 容器里优先 socat，没有就用 node 兜底；端口是校验过的整数
+function containerCommand(port) {
+    const p = Number(port);
+    if (!Number.isInteger(p) || p < 1 || p > 65535) throw new Error(`端口非法: ${port}`);
+    const nodeScript = `const s=require('net').connect(${p},'127.0.0.1');process.stdin.pipe(s);s.pipe(process.stdout);s.on('error',()=>process.exit(1));s.on('close',()=>process.exit(0))`;
+    return ['/bin/sh', '-c', `if command -v socat >/dev/null 2>&1; then exec socat STDIO TCP:127.0.0.1:${p}; else exec node -e "${nodeScript}"; fi`];
+}
+
+function keyOf(id, bind, hostPort) {
+    return `${id}|${bind}:${hostPort}`;
+}
+
+function createPortForwarder(options) {
+    const command = options.command;
+    const env = options.env ? { ...process.env, ...options.env } : process.env;
+    const homeDir = options.homeDir || os.homedir();
+    const resolveName = options.resolveName;
+    const warn = options.warn || (() => {});
+    const forwards = new Map(); // key → { id, bind, hostPort, port, server, sockets:Set, active }
+
+    function handleConnection(forward, socket) {
+        if (forward.active >= MAX_CONNECTIONS_PER_FORWARD) {
+            socket.destroy();
+            return;
+        }
+        const name = resolveName(forward.id);
+        if (!name) {
+            // 容器（状态目录）已被删：这个转发没有意义了，释放宿主机端口
+            closeForward(keyOf(forward.id, forward.bind, forward.hostPort));
+            socket.destroy();
+            return;
+        }
+        forward.active += 1;
+        forward.sockets.add(socket);
+        const built = buildExecArgs({ homeDir, dockerExecArgs: () => '' }, name, {
+            interactive: true,
+            withEnv: false,
+            command: containerCommand(forward.port)
+        });
+        const child = spawn(command, built.args, { env, stdio: ['pipe', 'pipe', 'ignore'] });
+        const finish = () => {
+            if (forward.sockets.delete(socket)) forward.active -= 1;
+            built.cleanup();
+            socket.destroy();
+            if (!child.killed) child.kill('SIGTERM');
+        };
+        socket.on('error', finish);
+        socket.on('close', finish);
+        child.on('error', finish);
+        child.on('close', finish);
+        child.stdin.on('error', () => {});
+        child.stdout.on('error', () => {});
+        socket.pipe(child.stdin);
+        child.stdout.pipe(socket);
+    }
+
+    function open({ id, bind, hostPort, port }) {
+        const key = keyOf(id, bind, hostPort);
+        if (forwards.has(key)) return Promise.resolve();
+        return new Promise((resolve, reject) => {
+            const forward = { id, bind, hostPort, port, sockets: new Set(), active: 0, server: null };
+            const server = net.createServer(socket => handleConnection(forward, socket));
+            forward.server = server;
+            server.once('error', error => {
+                reject(error.code === 'EADDRINUSE'
+                    ? new Error(`宿主机端口 ${bind}:${hostPort} 已被占用`)
+                    : error);
+            });
+            server.listen(hostPort, bind, () => {
+                server.removeAllListeners('error');
+                server.on('error', error => warn(`端口转发 ${bind}:${hostPort} 出错: ${error.message}`));
+                forwards.set(key, forward);
+                resolve();
+            });
+        });
+    }
+
+    function closeForward(key) {
+        const forward = forwards.get(key);
+        if (!forward) return;
+        forwards.delete(key);
+        forward.server.close();
+        forward.sockets.forEach(socket => socket.destroy());
+    }
+
+    function close(id, bind, hostPort) {
+        closeForward(keyOf(id, bind, hostPort));
+    }
+
+    function closeFor(id) {
+        [...forwards.keys()].filter(key => key.startsWith(`${id}|`)).forEach(closeForward);
+    }
+
+    function closeAll() {
+        [...forwards.keys()].forEach(closeForward);
+    }
+
+    function list(id) {
+        return [...forwards.values()].filter(f => f.id === id).map(f => ({ bind: f.bind, hostPort: f.hostPort, port: f.port }));
+    }
+
+    // 让转发列表与策略一致：多的关、少的开；单条失败只警告
+    async function sync(id, expose) {
+        const want = new Map(expose.map(e => [keyOf(id, e.bind, e.hostPort), e]));
+        [...forwards.keys()].filter(key => key.startsWith(`${id}|`) && !want.has(key)).forEach(closeForward);
+        const failures = [];
+        for (const [key, entry] of want) {
+            const existing = forwards.get(key);
+            if (existing && existing.port === entry.port) continue;
+            if (existing) closeForward(key);
+            try {
+                await open({ id, ...entry });
+            } catch (e) {
+                failures.push(e.message);
+                warn(e.message);
+            }
+        }
+        return failures;
+    }
+
+    return { open, close, closeFor, closeAll, list, sync };
+}
+
+module.exports = { createPortForwarder, containerCommand, MAX_CONNECTIONS_PER_FORWARD };

package/lib/web/AGENTS.md

@@ -21,6 +21,10 @@
 - 空闲保活是 `/agent/stream` 那条心跳规则的同类问题，**两个入口都要守**：终端侧服务端每 `WEB_TERMINAL_PING_INTERVAL_MS`（30s）发 WebSocket ping 帧，连续 `WEB_TERMINAL_MAX_MISSED_PONGS`（3 次，约 90s）无 pong 才判死；前端另发应用层 `ping`（浏览器 JS 发不出 ping 帧，上行需要自己造流量）。判死阈值不要收紧到一个周期：手机切后台会让连接短暂挂起，误杀等于用户的 shell 没了。升级后的 socket 还要 `setTimeout(0)` + `setKeepAlive`，解除 HTTP 侧空闲超时。
 - 新增接口/页面必须走全局认证网关，禁止在业务路由里零散补认证；匿名白名单见根 `AGENTS.md` 的安全约束。
 
+## 容器管理接口
+
+`lib/web/container-manage.js`（路由工厂，由 `handleWebApi` 追加进路由表）：`/api/containers/:name/{env,autostart,autostart/run,autostart/log,network,expose}` 与 `/api/containers/orphans`。旧容器（无 `manyoyo.id`）GET 返回 `{legacy:true}`、写返回 409。`PUT env` 用 `If-Match`（etag）防止覆盖容器内的修改；放开类改动（`open`、非 loopback 暴露）服务端也要求 `confirmRisk:true`。serve 运行时就绪后 `startContainerServices` 订阅 `<runtime> events`（start）补下发规则、拉起 `autostartOnServe` 容器、恢复端口暴露；过滤代理 `ensureWebEgressProxy` 懒启动。所有 exec 经 `spawnContainerExec`（env 临时文件在子进程 close 时删）。
+
 ## lib/web/index.html
 
 前端构建产物（`npm run build:web`，已 `.gitignore`），由 `loadIndexHtml()` 在每次请求时读取，`/` 与登录页 `/auth/login` 共用。服务端不托管其它前端静态资源，别往 `lib/web/` 里放散装 js/css。