@xcanwin/manyoyo 8.3.0 → 8.3.2

package/lib/plugin/fingerprint.js

@@ -0,0 +1,176 @@
+'use strict';
+
+// 浏览器指纹的唯一数据源：宿主机生成的配置与镜像内的 docker/res/playwright/* 都从这里生成。
+// 原则是各项信号自洽：UA、Client Hints、平台、字体、WebGL 一律用浏览器真实值，不做自相矛盾的伪装；
+// 只固定语言、时区、窗口形态与自动化痕迹。
+
+const CONTAINER_CONFIG_DIR = '/run/manyoyo-playwright';
+const CONTAINER_CONFIG_PATH = `${CONTAINER_CONFIG_DIR}/config.json`;
+const CONTAINER_INIT_SCRIPT_PATH = `${CONTAINER_CONFIG_DIR}/stealth.init.js`;
+const CONTAINER_OUTPUT_DIR = '/tmp/.playwright-cli';
+
+const DEFAULT_PROFILE = {
+    locale: 'en-US',
+    timezoneId: 'UTC',
+    navigatorPlatform: '',
+    disableWebRTC: false
+};
+
+function resolveProfile(options = {}) {
+    const text = (value, fallback) => String(value || '').trim() || fallback;
+    return {
+        locale: text(options.locale, DEFAULT_PROFILE.locale),
+        timezoneId: text(options.timezoneId, DEFAULT_PROFILE.timezoneId),
+        navigatorPlatform: text(options.navigatorPlatform, DEFAULT_PROFILE.navigatorPlatform),
+        disableWebRTC: options.disableWebRTC === true
+    };
+}
+
+function acceptLanguage(locale) {
+    const language = String(locale).split('-')[0];
+    return language === locale ? `${locale};q=0.9` : `${locale},${language};q=0.9`;
+}
+
+// 宿主机的时区与系统语言，作为默认值
+function detectHostProfile() {
+    const resolved = Intl.DateTimeFormat().resolvedOptions();
+    return { locale: resolved.locale, timezoneId: resolved.timeZone };
+}
+
+// window: 'virtual' 为容器内 1920x1080 虚拟屏；'native' 为真实桌面，最大化即可
+function buildLaunchArgs(options = {}, window = 'native') {
+    const profile = resolveProfile(options);
+    const args = [
+        `--lang=${profile.locale}`,
+        window === 'virtual' ? '--window-size=1920,1080' : '--start-maximized',
+        '--disable-blink-features=AutomationControlled',
+        '--force-webrtc-ip-handling-policy=disable_non_proxied_udp'
+    ];
+    if (profile.disableWebRTC) {
+        args.push('--disable-webrtc');
+    }
+    return args;
+}
+
+// 有头浏览器不设置 viewport / screen，让窗口尺寸与屏幕尺寸像真实窗口一样不同
+function buildContextOptions(options = {}) {
+    const profile = resolveProfile(options);
+    return {
+        locale: profile.locale,
+        timezoneId: profile.timezoneId,
+        viewport: null,
+        extraHTTPHeaders: {
+            'Accept-Language': acceptLanguage(profile.locale)
+        }
+    };
+}
+
+function buildInitScript(options = {}) {
+    const profile = resolveProfile(options);
+    // 首个页面加载时窗口尚未显示，outerWidth/outerHeight 会读到 0（无头浏览器的典型特征）；
+    // 只在读到 0 时用 inner 尺寸加上工具栏高度补上，真实窗口的值原样返回
+    const lines = [
+        "'use strict';",
+        '(function () {',
+        '    try {',
+        '        const toolbar = 87;',
+        '        const patch = (name, fallback, getter) => {',
+        '            const original = Object.getOwnPropertyDescriptor(window, name);',
+        '            if (!original || !original.get) return;',
+        '            const real = original.get;',
+        '            Object.defineProperty(window, name, { ...original, get: getter(function () { const value = real.call(this); return value === 0 ? fallback() : value; }) });',
+        '        };',
+        "        patch('outerWidth', () => window.innerWidth, fn => Object.getOwnPropertyDescriptor({ get outerWidth() { return fn.call(this); } }, 'outerWidth').get);",
+        "        patch('outerHeight', () => window.innerHeight + toolbar, fn => Object.getOwnPropertyDescriptor({ get outerHeight() { return fn.call(this); } }, 'outerHeight').get);",
+        '    } catch (_) {}'
+    ];
+    if (profile.navigatorPlatform) {
+        lines.push(
+            '    try {',
+            '        const navProto = Object.getPrototypeOf(navigator);',
+            "        Object.defineProperty(navProto, 'platform', {",
+            '            configurable: true,',
+            `            get: () => ${JSON.stringify(profile.navigatorPlatform)}`,
+            '        });',
+            '    } catch (_) {}'
+        );
+    }
+    if (profile.disableWebRTC) {
+        lines.push(
+            '    try {',
+            "        const blocked = ['RTCPeerConnection', 'webkitRTCPeerConnection', 'RTCIceCandidate', 'RTCRtpSender', 'RTCRtpReceiver', 'RTCRtpTransceiver', 'RTCDataChannel'];",
+            '        for (const name of blocked) {',
+            '            Object.defineProperty(globalThis, name, { configurable: true, writable: true, value: undefined });',
+            '        }',
+            '        if (navigator.mediaDevices) {',
+            "            Object.defineProperty(navigator.mediaDevices, 'getUserMedia', {",
+            '                configurable: true,',
+            '                writable: true,',
+            "                value: async () => { throw new DOMException('WebRTC is disabled', 'NotAllowedError'); }",
+            '            });',
+            '        }',
+            '    } catch (_) {}'
+        );
+    }
+    lines.push('})();', '');
+    return lines.join('\n');
+}
+
+// 容器内 playwright-cli 读取的配置。
+// default: 容器内 Xvfb 里的有头浏览器；ws: 附着宿主机 launch-server；cdp: 附着用户自己的 Chrome（不注入指纹）
+function buildContainerConfig(kind, options = {}) {
+    const base = { outputDir: CONTAINER_OUTPUT_DIR };
+    if (kind === 'cdp') {
+        return { ...base, browser: { cdpEndpoint: options.endpoint, cdpTimeout: 60000 } };
+    }
+    const fingerprint = {
+        initScript: [CONTAINER_INIT_SCRIPT_PATH],
+        contextOptions: buildContextOptions(options)
+    };
+    if (kind === 'ws') {
+        // launch-server 不预创建 context，必须 isolated 才会自建
+        return { ...base, browser: { remoteEndpoint: options.endpoint, isolated: true, ...fingerprint } };
+    }
+    return {
+        ...base,
+        browser: {
+            // 容器内是 root，Chromium 不允许 root 开沙箱
+            chromiumSandbox: false,
+            browserName: 'chromium',
+            ...fingerprint,
+            launchOptions: {
+                channel: 'chromium',
+                headless: false,
+                args: buildLaunchArgs(options, 'virtual')
+            }
+        }
+    };
+}
+
+// 宿主机 playwright launch-server 的配置
+function buildServerConfig({ host, port, wsPath, headless = false, window = 'native', chromiumSandbox = true, extensionArgs = [], ...profileOptions }) {
+    return {
+        host,
+        port,
+        wsPath,
+        headless,
+        channel: 'chromium',
+        chromiumSandbox,
+        args: [...buildLaunchArgs(profileOptions, window), ...extensionArgs]
+    };
+}
+
+module.exports = {
+    CONTAINER_CONFIG_DIR,
+    CONTAINER_CONFIG_PATH,
+    CONTAINER_INIT_SCRIPT_PATH,
+    DEFAULT_PROFILE,
+    resolveProfile,
+    detectHostProfile,
+    acceptLanguage,
+    buildLaunchArgs,
+    buildContextOptions,
+    buildInitScript,
+    buildContainerConfig,
+    buildServerConfig
+};

package/lib/plugin/index.js

@@ -2,67 +2,82 @@
 
 const { PlaywrightPlugin } = require('./playwright');
 
-const AVAILABLE_PLUGINS = ['playwright'];
-
 function asObject(value) {
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
-        return {};
-    }
-    return value;
-}
-
-function getPluginConfigs(pluginName, globalConfig, runConfig) {
-    const globalPlugins = asObject(asObject(globalConfig).plugins);
-    const runPlugins = asObject(asObject(runConfig).plugins);
-    return {
-        globalPluginConfig: asObject(globalPlugins[pluginName]),
-        runPluginConfig: asObject(runPlugins[pluginName])
-    };
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : {};
 }
 
-function createPlugin(pluginName, options = {}) {
-    if (pluginName !== 'playwright') {
-        throw new Error(`未知插件: ${pluginName}`);
-    }
-
-    const cfg = getPluginConfigs(pluginName, options.globalConfig, options.runConfig);
+// 全局配置与 runs.<name> 里的 plugins.playwright 分别传入，后者覆盖前者
+function createPlaywrightPlugin(options = {}) {
+    const pluginConfig = config => asObject(asObject(asObject(config).plugins).playwright);
     return new PlaywrightPlugin({
-        projectRoot: options.projectRoot,
         stdout: options.stdout,
         stderr: options.stderr,
-        globalConfig: cfg.globalPluginConfig,
-        runConfig: cfg.runPluginConfig,
+        runtime: options.runtime,
+        homeDir: options.homeDir,
+        globalConfig: pluginConfig(options.globalConfig),
+        runConfig: pluginConfig(options.runConfig),
         rootGlobalConfig: asObject(options.globalConfig),
         rootRunConfig: asObject(options.runConfig)
     });
 }
 
-async function runPluginCommand(request, options = {}) {
-    const action = String(request && request.action || '').trim();
-
-    if (action === 'ls') {
-        const plugin = createPlugin('playwright', options);
-        return await plugin.run({ action: 'ls' });
-    }
-
-    const pluginName = String(request && request.pluginName || '').trim();
-    if (!pluginName) {
-        throw new Error('plugin 名称不能为空');
-    }
+async function runPlaywrightCommand(request, options = {}) {
+    return await createPlaywrightPlugin(options).run(request);
+}
 
-    const plugin = createPlugin(pluginName, options);
-    return await plugin.run({
-        action,
-        scene: request.scene,
-        host: request.host,
-        extensionPaths: request.extensionPaths,
-        extensionNames: request.extensionNames,
-        prodversion: request.prodversion
+// 新建会话容器时要加的参数：CLI 的 run 与 Web 建会话共用这一个入口。
+// 返回扁平的 run 参数数组（--env / --volume / 其余），以及要给用户看的警告；不会抛错。
+async function buildContainerIntegration(options = {}) {
+    const plugin = createPlaywrightPlugin(options);
+    const integration = await plugin.buildContainerIntegration({
+        runtimeCommand: options.runtimeCommand,
+        envEntries: options.envEntries || [],
+        dryRun: options.dryRun === true
     });
+    return {
+        envArgs: integration.env.flatMap(entry => ['--env', entry]),
+        volumeArgs: integration.volumes.flatMap(volume => ['--volume', volume]),
+        extraArgs: integration.extraArgs,
+        warning: integration.warning
+    };
+}
+
+// 把集成参数并进已有的扁平参数数组：已有的 env 不覆盖（NO_PROXY 由集成在原值上追加，故替换），volume 与其余参数去重
+function mergeIntegration(runtime, integration) {
+    const keyOf = entry => String(entry).split('=')[0];
+    const proxyKeys = new Set(['NO_PROXY', 'no_proxy']);
+    const pairs = args => {
+        const out = [];
+        for (let i = 0; i + 1 < args.length; i += 2) {
+            out.push([args[i], args[i + 1]]);
+        }
+        return out;
+    };
+    const existingEnv = pairs(runtime.containerEnvs || []);
+    const kept = existingEnv.filter(([head, value]) => !(head === '--env' && proxyKeys.has(keyOf(value))));
+    const present = new Set(kept.filter(([head]) => head === '--env').map(([, value]) => keyOf(value)));
+    const added = pairs(integration.envArgs).filter(([, value]) => proxyKeys.has(keyOf(value)) || !present.has(keyOf(value)));
+    const append = (base, extra) => {
+        const seen = new Set(pairs(base).map(pair => pair.join('\u0000')));
+        const out = [...base];
+        for (const pair of pairs(extra)) {
+            if (!seen.has(pair.join('\u0000'))) {
+                seen.add(pair.join('\u0000'));
+                out.push(...pair);
+            }
+        }
+        return out;
+    };
+    return {
+        containerEnvs: [...kept, ...added].flat(),
+        containerVolumes: append(runtime.containerVolumes || [], integration.volumeArgs),
+        containerExtraArgs: append(runtime.containerExtraArgs || [], integration.extraArgs)
+    };
 }
 
 module.exports = {
-    AVAILABLE_PLUGINS,
-    createPlugin,
-    runPluginCommand
+    buildContainerIntegration,
+    mergeIntegration,
+    createPlaywrightPlugin,
+    runPlaywrightCommand
 };

package/lib/plugin/playwright-assets/vnc-entry.sh

@@ -0,0 +1,21 @@
+#!/bin/sh
+# 在 Xvfb 里跑有头浏览器服务，并用 x11vnc + noVNC 让用户在网页上观看
+set -eu
+
+export DISPLAY=:99
+: "${VNC_PASSWORD:?VNC_PASSWORD is required}"
+
+rm -f /tmp/.X99-lock
+Xvfb :99 -screen 0 1920x1080x24 -nolisten tcp &
+i=0
+while [ ! -S /tmp/.X11-unix/X99 ] && [ "$i" -lt 50 ]; do
+    sleep 0.1
+    i=$((i + 1))
+done
+fluxbox >/tmp/fluxbox.log 2>&1 &
+x11vnc -display :99 -forever -shared -rfbport 5900 -passwd "$VNC_PASSWORD" >/tmp/x11vnc.log 2>&1 &
+websockify --web=/usr/share/novnc/ 6080 localhost:5900 >/tmp/websockify.log 2>&1 &
+
+exec node /run/manyoyo-playwright-vnc/playwright-server.js \
+    /usr/local/lib/node_modules/@playwright/cli/node_modules/playwright-core \
+    /run/manyoyo-playwright-vnc/server.json

package/lib/plugin/playwright-extensions.js

@@ -0,0 +1,299 @@
+'use strict';
+
+// 浏览器扩展：下载 CRX 并转成可加载的目录，以及把目录解析成 Chromium 启动参数。
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+const EXTENSIONS = [
+    ['ublock-origin-lite', 'ddkjiahejlhfcafbddmgiahcphecmpfh'],
+    ['adguard', 'bgnkhhnnamicmpeenaelnjfhikgbkllg'],
+    ['privacy-badger', 'pkehgijcmpdhfbdbbnkijodmdjhbjlgp'],
+    ['webrtc-leak-shield', 'bppamachkoflopbagkdoflbgfjflfnfl'],
+    ['webgl-fingerprint-defender', 'olnbjpaejebpnokblkepbphhembdicik']
+];
+
+function isHostPermission(value) {
+    if (value === '<all_urls>') {
+        return true;
+    }
+    return /^(?:\*|http|https|file|ftp):\/\//.test(value);
+}
+
+function scriptSourcesFromHtml(htmlFile) {
+    const content = fs.readFileSync(htmlFile, { encoding: 'utf8' });
+    const scripts = [...content.matchAll(/<script[^>]+src=["']([^"']+)["']/gi)].map(m => m[1]);
+    return scripts.filter(src => !/^(?:https?:)?\/\//.test(src));
+}
+
+function convertManifestV2ToV3(extDir) {
+    const manifestFile = path.join(extDir, 'manifest.json');
+    const manifest = JSON.parse(fs.readFileSync(manifestFile, 'utf8'));
+    if (manifest.manifest_version !== 2) {
+        return false;
+    }
+
+    manifest.manifest_version = 3;
+
+    if (manifest.browser_action && !manifest.action) {
+        manifest.action = manifest.browser_action;
+        delete manifest.browser_action;
+    }
+    if (manifest.page_action && !manifest.action) {
+        manifest.action = manifest.page_action;
+        delete manifest.page_action;
+    }
+
+    const background = manifest.background;
+    if (background && typeof background === 'object' && !Array.isArray(background)) {
+        let scripts = [];
+        if (Array.isArray(background.scripts)) {
+            scripts = background.scripts.filter(s => typeof s === 'string');
+        } else if (typeof background.page === 'string') {
+            const pagePath = path.join(extDir, background.page);
+            if (fs.existsSync(pagePath)) {
+                scripts = scriptSourcesFromHtml(pagePath);
+            }
+        }
+
+        if (scripts.length > 0) {
+            const swName = 'generated_background_sw.js';
+            const swFile = path.join(extDir, swName);
+            const swLines = [
+                '// Auto-generated by manyoyo playwright ext-download for MV3.',
+                `importScripts(${scripts.map(s => JSON.stringify(s)).join(', ')});`,
+                ''
+            ];
+            fs.writeFileSync(swFile, swLines.join('\n'), 'utf8');
+            manifest.background = { service_worker: swName };
+        } else {
+            delete manifest.background;
+        }
+    }
+
+    if (typeof manifest.content_security_policy === 'string') {
+        manifest.content_security_policy = { extension_pages: manifest.content_security_policy };
+    }
+
+    if (Array.isArray(manifest.permissions)) {
+        const hostPermissions = Array.isArray(manifest.host_permissions) ? [...manifest.host_permissions] : [];
+        const keptPermissions = [];
+
+        for (const perm of manifest.permissions) {
+            if (typeof perm === 'string' && isHostPermission(perm)) {
+                if (!hostPermissions.includes(perm)) {
+                    hostPermissions.push(perm);
+                }
+            } else {
+                keptPermissions.push(perm);
+            }
+        }
+
+        manifest.permissions = keptPermissions;
+        if (hostPermissions.length > 0) {
+            manifest.host_permissions = hostPermissions;
+        }
+    }
+
+    const war = manifest.web_accessible_resources;
+    if (Array.isArray(war) && war.length > 0 && war.every(v => typeof v === 'string')) {
+        manifest.web_accessible_resources = [
+            {
+                resources: war,
+                matches: ['<all_urls>']
+            }
+        ];
+    }
+
+    fs.writeFileSync(manifestFile, `${JSON.stringify(manifest, null, 2)}\n`, 'utf8');
+    return true;
+}
+
+function buildCrxUrl(extId, prodversion) {
+    return (
+        'https://clients2.google.com/service/update2/crx' +
+        `?response=redirect&prodversion=${prodversion}` +
+        '&acceptformat=crx2,crx3' +
+        `&x=id%3D${extId}%26installsource%3Dondemand%26uc`
+    );
+}
+
+function crxZipOffset(data) {
+    if (data.subarray(0, 4).toString('ascii') !== 'Cr24') {
+        throw new Error('not a CRX file');
+    }
+
+    const version = data.readUInt32LE(4);
+    if (version === 2) {
+        const pubLen = data.readUInt32LE(8);
+        const sigLen = data.readUInt32LE(12);
+        return 16 + pubLen + sigLen;
+    }
+    if (version === 3) {
+        const headerLen = data.readUInt32LE(8);
+        return 12 + headerLen;
+    }
+    throw new Error(`unsupported CRX version: ${version}`);
+}
+const CONTAINER_EXTENSION_ROOT = '/app/extensions';
+
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+function extensionDirPath(pluginRoot) {
+    return path.join(pluginRoot, 'extensions');
+}
+
+function resolveExtensionPaths(inputs) {
+    const uniquePaths = [];
+    const add = value => {
+        if (!uniquePaths.includes(value)) {
+            uniquePaths.push(value);
+        }
+    };
+
+    for (const item of inputs) {
+        const absPath = path.resolve(item);
+        if (absPath.includes(',')) {
+            throw new Error(`扩展路径不能包含逗号: ${absPath}`);
+        }
+        if (!fs.existsSync(absPath)) {
+            throw new Error(`扩展路径不存在: ${absPath}`);
+        }
+        if (!fs.statSync(absPath).isDirectory()) {
+            throw new Error(`扩展路径必须是目录: ${absPath}`);
+        }
+        if (fs.existsSync(path.join(absPath, 'manifest.json'))) {
+            add(absPath);
+            continue;
+        }
+        const children = fs.readdirSync(absPath, { withFileTypes: true })
+            .filter(dirent => dirent.isDirectory())
+            .map(dirent => path.join(absPath, dirent.name))
+            .filter(child => fs.existsSync(path.join(child, 'manifest.json')));
+        if (children.length === 0) {
+            throw new Error(`目录下未找到扩展(manifest.json): ${absPath}`);
+        }
+        children.forEach(add);
+    }
+    return uniquePaths;
+}
+
+// --ext-path 给目录，--ext-name 给 ~/.manyoyo/plugin/playwright/extensions/ 下的目录名
+function resolveExtensionInputs(pluginRoot, { extensionPaths = [], extensionNames = [] } = {}) {
+    const extensionRoot = path.resolve(extensionDirPath(pluginRoot));
+    const named = extensionNames.map(name => {
+        if (name.includes('/') || name.includes('\\') || name === '.' || name === '..') {
+            throw new Error(`扩展名称无效: ${name}`);
+        }
+        return path.join(extensionRoot, name);
+    });
+    return resolveExtensionPaths([...extensionPaths, ...named]);
+}
+
+function buildExtensionLaunchArgs(extensionPaths) {
+    if (extensionPaths.length === 0) {
+        return [];
+    }
+    const joined = extensionPaths.join(',');
+    return [`--disable-extensions-except=${joined}`, `--load-extension=${joined}`];
+}
+
+// 容器里看到的扩展目录：${CONTAINER_EXTENSION_ROOT}/ext-<序号>-<目录名>
+function buildContainerExtensionMounts(extensionPaths) {
+    const containerPaths = [];
+    const volumes = [];
+    extensionPaths.forEach((hostPath, idx) => {
+        const safeName = path.basename(hostPath).replace(/[^A-Za-z0-9._-]/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '') || 'ext';
+        const containerPath = path.posix.join(CONTAINER_EXTENSION_ROOT, `ext-${idx + 1}-${safeName}`);
+        containerPaths.push(containerPath);
+        volumes.push(`${hostPath}:${containerPath}:ro`);
+    });
+    return { containerPaths, volumes };
+}
+
+function curlDownload(url, output, retries = 3, timeoutSec = 60) {
+    let lastError = null;
+    for (let i = 1; i <= retries; i += 1) {
+        const result = spawnSync('curl', [
+            '--fail', '--location', '--silent', '--show-error',
+            '--connect-timeout', String(timeoutSec), '--max-time', String(timeoutSec),
+            '--output', output, url
+        ], { encoding: 'utf8' });
+        if (!result.error && result.status === 0) {
+            return;
+        }
+        lastError = result.error || new Error(result.stderr || `curl failed with exit code ${result.status}`);
+    }
+    throw new Error(`download failed after ${retries} attempts: ${url}; ${String(lastError)}`);
+}
+
+function extractCrx(crxFile, outDir, log) {
+    const data = fs.readFileSync(crxFile);
+    const tempZip = path.join(os.tmpdir(), `manyoyo-playwright-ext-${process.pid}-${Date.now()}.zip`);
+    fs.mkdirSync(outDir, { recursive: true });
+    fs.writeFileSync(tempZip, data.subarray(crxZipOffset(data)));
+    const result = spawnSync('unzip', ['-oq', tempZip, '-d', outDir], { encoding: 'utf8' });
+    fs.rmSync(tempZip, { force: true });
+    if (result.error) {
+        throw result.error;
+    }
+    if (result.status !== 0) {
+        throw new Error(result.stderr || `unzip failed with exit code ${result.status}`);
+    }
+    if (!fs.existsSync(path.join(outDir, 'manifest.json'))) {
+        throw new Error(`${crxFile} extracted but manifest.json missing`);
+    }
+    if (convertManifestV2ToV3(outDir)) {
+        log(`[manifest] upgraded to MV3: ${path.basename(outDir)}`);
+    }
+}
+
+async function downloadExtensions({ pluginRoot, prodversion, log, logError }) {
+    if (spawnSync('unzip', ['-v'], { stdio: 'ignore' }).status !== 0) {
+        logError('[ext-download] failed: unzip command not found.');
+        return 1;
+    }
+    const extDir = path.resolve(extensionDirPath(pluginRoot));
+    const tmpDir = path.resolve(pluginRoot, 'tmp-crx');
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+    fs.mkdirSync(extDir, { recursive: true });
+    fs.mkdirSync(tmpDir, { recursive: true });
+    try {
+        log(`[info] ext dir: ${extDir}`);
+        for (const [name, extId] of EXTENSIONS) {
+            const crxFile = path.join(tmpDir, `${name}.crx`);
+            const outDir = path.join(extDir, name);
+            log(`[download] ${name}`);
+            curlDownload(buildCrxUrl(extId, prodversion), crxFile);
+            log(`[extract] ${name}`);
+            // 先解到临时目录再替换，解压失败不会丢掉原来能用的扩展
+            const stagingDir = path.join(tmpDir, `${name}.staged`);
+            extractCrx(crxFile, stagingDir, log);
+            fs.rmSync(outDir, { recursive: true, force: true });
+            fs.renameSync(stagingDir, outDir);
+            await sleep(0);
+        }
+    } finally {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    }
+    log(`[done] all extensions are ready: ${extDir}`);
+    return 0;
+}
+
+module.exports = {
+    EXTENSIONS,
+    CONTAINER_EXTENSION_ROOT,
+    buildContainerExtensionMounts,
+    buildCrxUrl,
+    buildExtensionLaunchArgs,
+    convertManifestV2ToV3,
+    crxZipOffset,
+    downloadExtensions,
+    extensionDirPath,
+    resolveExtensionInputs,
+    resolveExtensionPaths
+};

package/lib/plugin/playwright-probe.js

@@ -0,0 +1,53 @@
+'use strict';
+
+// 真实探测：连上浏览器、新开页面、打开 data: 页面并读回内容。
+// 作为子进程运行，父进程负责超时；端点（含 token）只经环境变量 MANYOYO_PROBE 传入。
+// MANYOYO_PROBE = { core, kind: 'ws' | 'cdp', endpoint, timeout }
+
+async function probe({ core, kind, endpoint, timeout }) {
+    const { chromium } = require(core);
+    const started = Date.now();
+    const browser = kind === 'cdp'
+        ? await chromium.connectOverCDP(endpoint, { timeout })
+        : await chromium.connect(endpoint, { timeout });
+    try {
+        let context;
+        let ownContext = false;
+        if (kind === 'cdp') {
+            context = browser.contexts()[0] || await browser.newContext();
+        } else {
+            context = await browser.newContext();
+            ownContext = true;
+        }
+        const page = await context.newPage();
+        try {
+            await page.goto('data:text/html,<title>manyoyo-ok</title>', { timeout });
+            const title = await page.title();
+            if (title !== 'manyoyo-ok') {
+                throw new Error(`页面内容不符: ${title}`);
+            }
+        } finally {
+            await page.close().catch(() => {});
+            if (ownContext) {
+                await context.close().catch(() => {});
+            }
+        }
+    } finally {
+        await browser.close().catch(() => {});
+    }
+    return Date.now() - started;
+}
+
+if (require.main === module) {
+    probe(JSON.parse(process.env.MANYOYO_PROBE))
+        .then(ms => {
+            console.log(JSON.stringify({ ok: true, ms }));
+            process.exit(0);
+        })
+        .catch(error => {
+            console.log(JSON.stringify({ ok: false, error: String(error && error.message || error).split('\n')[0] }));
+            process.exit(1);
+        });
+}
+
+module.exports = { probe };