@xcanwin/manyoyo 5.8.6 → 5.8.9

package/lib/plugin/playwright-extension-manager.js

@@ -0,0 +1,265 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { spawnSync } = require('child_process');
+
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+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}`);
+}
+
+class PlaywrightExtensionManager {
+    constructor(options = {}) {
+        this.extensions = Array.isArray(options.extensions) ? options.extensions : [];
+        this.ensureCommandAvailable = options.ensureCommandAvailable;
+        this.runCmd = options.runCmd;
+        this.writeStdout = options.writeStdout;
+        this.writeStderr = options.writeStderr;
+        this.extensionDirPath = options.extensionDirPath;
+        this.extensionTmpDirPath = options.extensionTmpDirPath;
+        this.defaultProdversion = String(options.defaultProdversion || '132.0.0.0').trim();
+    }
+
+    async downloadFile(url, output, retries = 3, timeoutMs = 60_000) {
+        const timeoutSec = Math.max(1, Math.ceil(timeoutMs / 1000));
+        if (!this.ensureCommandAvailable('curl')) {
+            throw new Error('curl command not found');
+        }
+
+        let lastError = null;
+        for (let i = 1; i <= retries; i += 1) {
+            try {
+                const result = this.runCmd([
+                    'curl',
+                    '--fail',
+                    '--location',
+                    '--silent',
+                    '--show-error',
+                    '--connect-timeout',
+                    String(timeoutSec),
+                    '--max-time',
+                    String(timeoutSec),
+                    '--output',
+                    output,
+                    url
+                ], { captureOutput: true, check: false });
+                if (result.returncode !== 0) {
+                    throw new Error(result.stderr || `curl failed with exit code ${result.returncode}`);
+                }
+                return;
+            } catch (error) {
+                lastError = error;
+                if (i < retries) {
+                    // eslint-disable-next-line no-await-in-loop
+                    await sleep(1000);
+                }
+            }
+        }
+
+        throw new Error(`download failed after ${retries} attempts: ${url}; ${String(lastError)}`);
+    }
+
+    extractZipBuffer(zipBuffer, outDir) {
+        fs.mkdirSync(outDir, { recursive: true });
+        const tempZip = path.join(os.tmpdir(), `manyoyo-playwright-ext-${process.pid}-${Date.now()}.zip`);
+        fs.writeFileSync(tempZip, zipBuffer);
+
+        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}`);
+        }
+    }
+
+    extractCrx(crxFile, outDir) {
+        const data = fs.readFileSync(crxFile);
+        const offset = crxZipOffset(data);
+        const zipBuffer = data.subarray(offset);
+
+        this.extractZipBuffer(zipBuffer, outDir);
+
+        const manifest = path.join(outDir, 'manifest.json');
+        if (!fs.existsSync(manifest)) {
+            throw new Error(`${crxFile} extracted but manifest.json missing`);
+        }
+
+        if (convertManifestV2ToV3(outDir)) {
+            this.writeStdout(`[manifest] upgraded to MV3: ${path.basename(outDir)}`);
+        }
+    }
+
+    async downloadExtensions(options = {}) {
+        if (!this.ensureCommandAvailable('unzip')) {
+            this.writeStderr('[ext-download] failed: unzip command not found.');
+            return 1;
+        }
+
+        const prodversion = String(options.prodversion || this.defaultProdversion).trim();
+        const extDir = path.resolve(this.extensionDirPath());
+        const tmpDir = path.resolve(this.extensionTmpDirPath());
+
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+        fs.mkdirSync(extDir, { recursive: true });
+        fs.mkdirSync(tmpDir, { recursive: true });
+
+        try {
+            this.writeStdout(`[info] ext dir: ${extDir}`);
+            this.writeStdout(`[info] tmp dir: ${tmpDir}`);
+
+            for (const [name, extId] of this.extensions) {
+                const url = buildCrxUrl(extId, prodversion);
+                const crxFile = path.join(tmpDir, `${name}.crx`);
+                const outDir = path.join(extDir, name);
+
+                this.writeStdout(`[download] ${name}`);
+                // eslint-disable-next-line no-await-in-loop
+                await this.downloadFile(url, crxFile);
+
+                this.writeStdout(`[extract] ${name}`);
+                fs.rmSync(outDir, { recursive: true, force: true });
+                this.extractCrx(crxFile, outDir);
+            }
+        } finally {
+            fs.rmSync(tmpDir, { recursive: true, force: true });
+            this.writeStdout(`[cleanup] removed ${tmpDir}`);
+        }
+
+        this.writeStdout(`[done] all extensions are ready: ${extDir}`);
+        return 0;
+    }
+}
+
+module.exports = {
+    buildCrxUrl,
+    convertManifestV2ToV3,
+    crxZipOffset,
+    PlaywrightExtensionManager
+};

package/lib/plugin/playwright-extension-paths.js

@@ -0,0 +1,98 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+function createPlaywrightExtensionPathManager(options = {}) {
+    const plugin = options.plugin;
+    const asStringArray = options.asStringArray || ((value, fallback) => fallback);
+    const containerExtensionRoot = options.containerExtensionRoot || '/app/extensions';
+
+    return {
+        resolveExtensionPaths(extensionArgs = []) {
+            const inputs = asStringArray(extensionArgs, []);
+            const uniquePaths = [];
+            const seen = new Set();
+
+            for (const item of inputs) {
+                const absPath = path.resolve(item);
+                if (!fs.existsSync(absPath)) {
+                    throw new Error(`扩展路径不存在: ${absPath}`);
+                }
+                const stat = fs.statSync(absPath);
+                if (!stat.isDirectory()) {
+                    throw new Error(`扩展路径必须是目录: ${absPath}`);
+                }
+
+                const manifestPath = path.join(absPath, 'manifest.json');
+                if (fs.existsSync(manifestPath)) {
+                    if (!seen.has(absPath)) {
+                        seen.add(absPath);
+                        uniquePaths.push(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}`);
+                }
+
+                for (const childPath of children) {
+                    if (!seen.has(childPath)) {
+                        seen.add(childPath);
+                        uniquePaths.push(childPath);
+                    }
+                }
+            }
+
+            return uniquePaths;
+        },
+        resolveNamedExtensionPaths(extensionNames = []) {
+            const names = asStringArray(extensionNames, []);
+            const extensionRoot = path.resolve(plugin.extensionDirPath());
+
+            return names.map(name => {
+                if (name.includes('/') || name.includes('\\') || name === '.' || name === '..') {
+                    throw new Error(`扩展名称无效: ${name}`);
+                }
+                return path.join(extensionRoot, name);
+            });
+        },
+        resolveExtensionInputs(inputOptions = {}) {
+            const extensionPaths = asStringArray(inputOptions.extensionPaths, []);
+            const namedPaths = this.resolveNamedExtensionPaths(inputOptions.extensionNames || []);
+            return this.resolveExtensionPaths([...extensionPaths, ...namedPaths]);
+        },
+        sanitizeExtensionMountName(value) {
+            const sanitized = String(value || '')
+                .trim()
+                .replace(/[^A-Za-z0-9._-]/g, '-')
+                .replace(/-+/g, '-')
+                .replace(/^-|-$/g, '');
+            return sanitized || 'ext';
+        },
+        buildContainerExtensionMounts(extensionPaths = []) {
+            const hostPaths = asStringArray(extensionPaths, []);
+            const containerPaths = [];
+            const volumeMounts = [];
+
+            hostPaths.forEach((hostPath, idx) => {
+                const safeName = this.sanitizeExtensionMountName(path.basename(hostPath));
+                const containerPath = path.posix.join(containerExtensionRoot, `ext-${idx + 1}-${safeName}`);
+                containerPaths.push(containerPath);
+                volumeMounts.push(`${hostPath}:${containerPath}:ro`);
+            });
+
+            return { containerPaths, volumeMounts };
+        }
+    };
+}
+
+module.exports = {
+    createPlaywrightExtensionPathManager
+};

package/lib/plugin/playwright-host-runtime.js

@@ -0,0 +1,114 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+
+function createPlaywrightHostRuntimeManager(options = {}) {
+    const plugin = options.plugin;
+    const isCliScene = options.isCliScene || (() => false);
+    const sleep = options.sleep || (async () => {});
+
+    return {
+        hostLaunchCommand(sceneName, cfgPath) {
+            if (isCliScene(sceneName)) {
+                return {
+                    command: plugin.playwrightBinPath(sceneName),
+                    args: ['launch-server', '--browser', plugin.defaultBrowserName(sceneName), '--config', String(cfgPath)]
+                };
+            }
+            return {
+                command: plugin.localBinPath('playwright-mcp'),
+                args: ['--config', String(cfgPath)]
+            };
+        },
+        spawnHostProcess(command, args, logFd) {
+            return spawn(command, args, {
+                detached: true,
+                stdio: ['ignore', logFd, logFd]
+            });
+        },
+        stopHostStarter(pid) {
+            if (!Number.isInteger(pid) || pid <= 0) {
+                return;
+            }
+            try {
+                process.kill(-pid, 'SIGTERM');
+                return;
+            } catch {
+                // no-op
+            }
+            try {
+                process.kill(pid, 'SIGTERM');
+            } catch {
+                // no-op
+            }
+        },
+        hostScenePids(sceneName) {
+            const cfgPath = plugin.sceneConfigPath(sceneName);
+            const pattern = isCliScene(sceneName)
+                ? `playwright.*launch-server.*--config ${cfgPath}`
+                : `playwright-mcp.*--config ${cfgPath}`;
+            const cp = plugin.runCmd(['pgrep', '-f', pattern], { captureOutput: true, check: false });
+
+            if (cp.returncode !== 0 || !cp.stdout.trim()) {
+                return [];
+            }
+
+            const pids = [];
+            for (const line of cp.stdout.split(/\r?\n/)) {
+                const text = line.trim();
+                if (/^\d+$/.test(text)) {
+                    pids.push(Number(text));
+                }
+            }
+            return pids;
+        },
+        async waitForHostPids(sceneName, fallbackPid) {
+            for (let i = 0; i < 5; i += 1) {
+                const pids = this.hostScenePids(sceneName);
+                if (pids.length > 0) {
+                    return pids;
+                }
+                // eslint-disable-next-line no-await-in-loop
+                await sleep(100);
+            }
+            if (Number.isInteger(fallbackPid) && fallbackPid > 0) {
+                return [fallbackPid];
+            }
+            return [];
+        },
+        async getHostSceneRuntimeInfo(sceneName) {
+            const pidFile = plugin.scenePidFile(sceneName);
+            const port = plugin.scenePort(sceneName);
+            const managedPids = this.hostScenePids(sceneName);
+            const portReachable = await plugin.portReady(port);
+            return { pidFile, port, managedPids, portReachable };
+        },
+        signalPids(pids, signal = 'SIGTERM') {
+            const values = Array.isArray(pids) ? pids : [];
+            values.forEach(pid => {
+                try {
+                    process.kill(pid, signal);
+                } catch {
+                    // no-op
+                }
+            });
+        },
+        readPidFilePid(pidFile) {
+            if (!fs.existsSync(pidFile)) {
+                return 0;
+            }
+            const text = fs.readFileSync(pidFile, 'utf8').trim();
+            return /^\d+$/.test(text) ? Number(text) : 0;
+        },
+        writeScenePidFile(pidFile, pid) {
+            fs.mkdirSync(path.dirname(pidFile), { recursive: true });
+            fs.writeFileSync(pidFile, `${pid}`, 'utf8');
+        }
+    };
+}
+
+module.exports = {
+    createPlaywrightHostRuntimeManager
+};

package/lib/plugin/playwright-scene-config.js

@@ -0,0 +1,137 @@
+'use strict';
+
+const fs = require('fs');
+const crypto = require('crypto');
+
+function createPlaywrightSceneConfigManager(options = {}) {
+    const plugin = options.plugin;
+    const sceneDefs = options.sceneDefs || {};
+    const isCliScene = options.isCliScene || (() => false);
+    const asStringArray = options.asStringArray || ((value, fallback) => fallback);
+    const defaultFingerprintProfile = options.defaultFingerprintProfile || {};
+    const disableWebRtcLaunchArgs = options.disableWebRtcLaunchArgs || [];
+
+    return {
+        buildExtensionLaunchArgs(extensionPaths) {
+            const joined = extensionPaths.join(',');
+            return [
+                `--disable-extensions-except=${joined}`,
+                `--load-extension=${joined}`
+            ];
+        },
+        baseLaunchArgs() {
+            return [
+                `--user-agent=${defaultFingerprintProfile.userAgent}`,
+                `--lang=${defaultFingerprintProfile.locale}`,
+                `--window-size=${defaultFingerprintProfile.width},${defaultFingerprintProfile.height}`,
+                '--disable-blink-features=AutomationControlled',
+                '--force-webrtc-ip-handling-policy=disable_non_proxied_udp'
+            ];
+        },
+        buildSceneLaunchArgs(extensionPaths = []) {
+            const args = [...this.baseLaunchArgs()];
+            if (Array.isArray(extensionPaths) && extensionPaths.length > 0) {
+                args.push(...this.buildExtensionLaunchArgs(extensionPaths));
+            }
+            if (plugin.config.disableWebRTC) {
+                args.push(...disableWebRtcLaunchArgs);
+            }
+            return args;
+        },
+        buildMcpSceneConfig(sceneName, actionOptions = {}) {
+            const def = sceneDefs[sceneName];
+            const port = plugin.scenePort(sceneName);
+            const extensionPaths = asStringArray(actionOptions.extensionPaths, []);
+            const initScript = asStringArray(actionOptions.initScript, []);
+            const launchOptions = {
+                channel: 'chromium',
+                headless: def.headless,
+                args: this.buildSceneLaunchArgs(extensionPaths)
+            };
+
+            const contextOptions = {
+                userAgent: defaultFingerprintProfile.userAgent,
+                locale: defaultFingerprintProfile.locale,
+                timezoneId: defaultFingerprintProfile.timezoneId,
+                extraHTTPHeaders: {
+                    'Accept-Language': defaultFingerprintProfile.acceptLanguage
+                }
+            };
+            if (sceneName !== 'mcp-host-headed') {
+                contextOptions.viewport = {
+                    width: defaultFingerprintProfile.width,
+                    height: defaultFingerprintProfile.height
+                };
+                contextOptions.screen = {
+                    width: defaultFingerprintProfile.width,
+                    height: defaultFingerprintProfile.height
+                };
+            }
+
+            return {
+                outputDir: '/tmp/.playwright-mcp',
+                server: {
+                    host: def.listenHost,
+                    port,
+                    allowedHosts: [
+                        `localhost:${port}`,
+                        `127.0.0.1:${port}`,
+                        `host.docker.internal:${port}`,
+                        `host.containers.internal:${port}`
+                    ]
+                },
+                browser: {
+                    chromiumSandbox: true,
+                    browserName: 'chromium',
+                    initScript,
+                    launchOptions,
+                    contextOptions
+                }
+            };
+        },
+        buildCliSceneConfig(sceneName, actionOptions = {}) {
+            const def = sceneDefs[sceneName];
+            const extensionPaths = asStringArray(actionOptions.extensionPaths, []);
+            return {
+                host: def.listenHost,
+                port: plugin.scenePort(sceneName),
+                wsPath: `/${sceneName}-${crypto.randomBytes(8).toString('hex')}`,
+                headless: def.headless,
+                channel: 'chromium',
+                chromiumSandbox: true,
+                args: this.buildSceneLaunchArgs(extensionPaths)
+            };
+        },
+        buildSceneConfig(sceneName, actionOptions = {}) {
+            if (isCliScene(sceneName)) {
+                return this.buildCliSceneConfig(sceneName, actionOptions);
+            }
+            return this.buildMcpSceneConfig(sceneName, actionOptions);
+        },
+        writeSceneConfigFile(sceneName, payload) {
+            const filePath = plugin.sceneConfigPath(sceneName);
+            fs.writeFileSync(filePath, `${JSON.stringify(payload, null, 4)}\n`, 'utf8');
+            return filePath;
+        },
+        ensureSceneConfig(sceneName, actionOptions = {}) {
+            fs.mkdirSync(plugin.config.configDir, { recursive: true });
+            let payload = null;
+            if (isCliScene(sceneName)) {
+                payload = this.buildCliSceneConfig(sceneName, actionOptions);
+            } else {
+                const initScriptPath = plugin.ensureSceneInitScript(sceneName);
+                const configuredInitScript = asStringArray(actionOptions.initScript, []);
+                const initScript = configuredInitScript.length > 0 ? configuredInitScript : [initScriptPath];
+                payload = this.buildSceneConfig(sceneName, {
+                    ...actionOptions,
+                    initScript
+                });
+            }
+            return this.writeSceneConfigFile(sceneName, payload);
+        }
+    };
+}
+
+module.exports = {
+    createPlaywrightSceneConfigManager
+};