@xcanwin/manyoyo 8.3.2 → 8.4.0

package/lib/network-policy.js

@@ -0,0 +1,265 @@
+'use strict';
+
+const net = require('net');
+const { isValidId } = require('./container-state');
+
+// 容器网络策略：校验（唯一入口）+ 生成 nft 规则文本。
+// nft 文本只由校验过的结构化数据生成：IP/CIDR 经 net.isIP + 前缀整数、端口是 1-65535 的整数、域名不进规则
+// （域名只在过滤代理里匹配），所以任何用户字符串都拼不进规则。
+const PRESETS = ['restricted', 'open', 'allowlist'];
+const PROTOS = ['tcp', 'udp'];
+const LIMITS = { domains: 200, rules: 100, host: 50, inbound: 50, deny: 100, expose: 20, portItems: 32 };
+const DOMAIN_RE = /^(\*\.)?([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,63}$/;
+
+// restricted / allowlist 默认禁止的私有与保留网段（公网放行）
+const PRIVATE_V4 = ['0.0.0.0/8', '10.0.0.0/8', '100.64.0.0/10', '169.254.0.0/16', '172.16.0.0/12', '192.0.0.0/24', '192.168.0.0/16', '198.18.0.0/15', '224.0.0.0/4', '240.0.0.0/4'];
+// 64:ff9b::/96（NAT64）里嵌的是 IPv4，可以映射到私有地址
+const PRIVATE_V6 = ['fc00::/7', '64:ff9b::/96'];
+
+function fail(message) {
+    throw new Error(message);
+}
+
+function isPort(value) {
+    return Number.isInteger(value) && value >= 1 && value <= 65535;
+}
+
+/**
+ * 端口表达式 "80" / "80-90" / "80,443,8000-8100" → 规范化字符串；空串表示不限端口（仅部分规则允许）。
+ */
+function normalizePorts(input, { required = true, label = '端口' } = {}) {
+    const text = String(input === undefined || input === null ? '' : input).replace(/\s+/g, '');
+    if (!text) {
+        if (required) fail(`${label}不能为空`);
+        return '';
+    }
+    const items = text.split(',');
+    if (items.length > LIMITS.portItems) fail(`${label}条目过多`);
+    const out = items.map(item => {
+        const m = /^(\d{1,5})(?:-(\d{1,5}))?$/.exec(item);
+        if (!m) fail(`${label}格式非法: ${String(input).slice(0, 40)}`);
+        const a = Number(m[1]);
+        const b = m[2] === undefined ? a : Number(m[2]);
+        if (!isPort(a) || !isPort(b) || b < a) fail(`${label}超出范围: ${item}`);
+        return a === b ? String(a) : `${a}-${b}`;
+    });
+    return out.join(',');
+}
+
+function normalizeProto(input) {
+    const proto = String(input === undefined || input === null || input === '' ? 'tcp' : input).toLowerCase();
+    if (!PROTOS.includes(proto)) fail(`协议只支持 tcp / udp: ${String(input).slice(0, 20)}`);
+    return proto;
+}
+
+/** IP 或 CIDR，返回 {cidr, family}；不接受主机名。 */
+function normalizeCidr(input, label = 'CIDR') {
+    const text = String(input === undefined || input === null ? '' : input).trim();
+    const m = /^([0-9a-fA-F:.]+)(?:\/(\d{1,3}))?$/.exec(text);
+    if (!m) fail(`${label}格式非法: ${text.slice(0, 60)}`);
+    const family = net.isIP(m[1]);
+    if (!family) fail(`${label}不是合法 IP: ${text.slice(0, 60)}`);
+    const max = family === 4 ? 32 : 128;
+    let prefix = m[2] === undefined ? max : Number(m[2]);
+    if (!Number.isInteger(prefix) || prefix < 0 || prefix > max) fail(`${label}前缀超出范围: ${text.slice(0, 60)}`);
+    return { cidr: `${m[1].toLowerCase()}${m[2] === undefined ? '' : `/${prefix}`}`, family };
+}
+
+function normalizeDomain(input) {
+    const text = String(input === undefined || input === null ? '' : input).trim().toLowerCase();
+    if (text.length > 253 || !DOMAIN_RE.test(text)) fail(`域名非法: ${text.slice(0, 80)}`);
+    return text;
+}
+
+function normalizeBind(input) {
+    const text = String(input === undefined || input === null || input === '' ? '127.0.0.1' : input).trim();
+    if (!net.isIP(text)) fail(`监听地址必须是 IP: ${text.slice(0, 60)}`);
+    return text.toLowerCase();
+}
+
+function asArray(value, max, label) {
+    if (value === undefined || value === null) return [];
+    if (!Array.isArray(value)) fail(`${label}必须是数组`);
+    if (value.length > max) fail(`${label}最多 ${max} 条`);
+    return value;
+}
+
+function asObject(value, label) {
+    if (value === undefined || value === null) return {};
+    if (typeof value !== 'object' || Array.isArray(value)) fail(`${label}必须是对象`);
+    return value;
+}
+
+function defaultPolicy() {
+    return {
+        version: 1,
+        preset: 'restricted',
+        egress: { domains: [], rules: [] },
+        host: [],
+        peers: { inbound: [] },
+        deny: [],
+        expose: [],
+        autostartOnServe: false
+    };
+}
+
+/**
+ * 校验并规范化策略；任何非法输入抛错（调用方返回 400）。
+ */
+function normalizePolicy(input) {
+    const src = asObject(input, '网络策略');
+    const policy = defaultPolicy();
+    if (src.preset !== undefined) {
+        if (!PRESETS.includes(src.preset)) fail(`preset 只支持 ${PRESETS.join(' / ')}`);
+        policy.preset = src.preset;
+    }
+    const egress = asObject(src.egress, 'egress');
+    const seenDomains = new Set();
+    asArray(egress.domains, LIMITS.domains, 'egress.domains').forEach(d => {
+        const domain = normalizeDomain(d);
+        if (!seenDomains.has(domain)) {
+            seenDomains.add(domain);
+            policy.egress.domains.push(domain);
+        }
+    });
+    asArray(egress.rules, LIMITS.rules, 'egress.rules').forEach(rule => {
+        const r = asObject(rule, 'egress.rules[]');
+        const { cidr } = normalizeCidr(r.cidr, 'egress.rules.cidr');
+        policy.egress.rules.push({ cidr, ports: normalizePorts(r.ports, { required: false }), proto: normalizeProto(r.proto) });
+    });
+    asArray(src.host, LIMITS.host, 'host').forEach(entry => {
+        const e = asObject(entry, 'host[]');
+        policy.host.push({ ports: normalizePorts(e.ports, { label: '宿主机端口' }), proto: normalizeProto(e.proto) });
+    });
+    const peers = asObject(src.peers, 'peers');
+    asArray(peers.inbound, LIMITS.inbound, 'peers.inbound').forEach(entry => {
+        const e = asObject(entry, 'peers.inbound[]');
+        if (!isValidId(e.from)) fail('peers.inbound.from 必须是容器 id');
+        policy.peers.inbound.push({ from: e.from, ports: normalizePorts(e.ports, { label: '入站端口' }), proto: normalizeProto(e.proto) });
+    });
+    asArray(src.deny, LIMITS.deny, 'deny').forEach(entry => {
+        policy.deny.push({ cidr: normalizeCidr(asObject(entry, 'deny[]').cidr, 'deny.cidr').cidr });
+    });
+    const hostPorts = new Set();
+    asArray(src.expose, LIMITS.expose, 'expose').forEach(entry => {
+        const e = asObject(entry, 'expose[]');
+        const hostPort = Number(e.hostPort);
+        const port = Number(e.port);
+        if (!isPort(hostPort)) fail(`宿主机端口非法: ${String(e.hostPort).slice(0, 10)}`);
+        if (!isPort(port)) fail(`容器端口非法: ${String(e.port).slice(0, 10)}`);
+        const bind = normalizeBind(e.bind);
+        const key = `${bind}:${hostPort}`;
+        if (hostPorts.has(key)) fail(`重复的暴露端口: ${key}`);
+        hostPorts.add(key);
+        policy.expose.push({ bind, hostPort, port });
+    });
+    policy.autostartOnServe = src.autostartOnServe === true;
+    return policy;
+}
+
+// ---- 域名匹配（过滤代理用） ----
+
+/** pattern 为 `example.com`（只匹配自身）或 `*.example.com`（匹配任意子域，不含自身）。 */
+function domainMatches(pattern, host) {
+    const h = String(host || '').toLowerCase().replace(/\.$/, '');
+    if (pattern.startsWith('*.')) return h.endsWith(pattern.slice(1)) && h.length > pattern.length - 1;
+    return h === pattern;
+}
+
+function domainAllowed(domains, host) {
+    return (domains || []).some(pattern => domainMatches(pattern, host));
+}
+
+// ---- nft 生成 ----
+
+function portSet(ports) {
+    const normalized = normalizePorts(ports);
+    return normalized.includes(',') ? `{ ${normalized.split(',').join(', ')} }` : normalized;
+}
+
+function addrExpr(direction, cidr, label) {
+    const { cidr: c, family } = normalizeCidr(cidr, label);
+    return `${family === 4 ? 'ip' : 'ip6'} ${direction} ${c}`;
+}
+
+function portClause(proto, ports) {
+    return ports ? ` ${normalizeProto(proto)} dport ${portSet(ports)}` : ` meta l4proto ${normalizeProto(proto)}`;
+}
+
+function cidrList(cidrs, family) {
+    return cidrs.map(c => normalizeCidr(c)).filter(c => c.family === family).map(c => c.cidr);
+}
+
+/**
+ * @param {object} policy normalizePolicy 的结果
+ * @param {object} endpoints 运行时解析出的地址（下发时现算，全部重新校验）
+ * @param {string[]} [endpoints.dns]
+ * @param {{ip:string, ports:string, proto?:string}[]} [endpoints.allow] manyoyo 必需端点、上游代理、过滤代理、Playwright、镜像、host 端口、出站 peer
+ * @param {{ip:string, ports:string, proto?:string}[]} [endpoints.peerIn] 允许进来的 peer
+ * @param {{subnet:string, gateway:string}|null} [endpoints.bridge]
+ * @returns {string} 整份 nft 脚本（先删后建，一次 nft -f 原子替换）；open 预设只删表
+ */
+function buildNftRuleset(policy, endpoints = {}) {
+    const lines = ['add table inet manyoyo', 'delete table inet manyoyo'];
+    if (policy.preset === 'open') return `${lines.join('\n')}\n`;
+
+    const out = ['    oif lo accept', '    ct state established,related accept'];
+    // 用户 deny 排在所有放行规则之前，才能真正“禁止”
+    if (policy.preset !== 'open') policy.deny.forEach(rule => out.push(`    ${addrExpr('daddr', rule.cidr, 'deny')} reject`));
+    (endpoints.dns || []).forEach(ip => {
+        const { cidr, family } = normalizeCidr(ip, 'dns');
+        const prefix = family === 4 ? 'ip' : 'ip6';
+        out.push(`    ${prefix} daddr ${cidr} udp dport 53 accept`);
+        out.push(`    ${prefix} daddr ${cidr} tcp dport 53 accept`);
+    });
+    (endpoints.allow || []).forEach(item => {
+        out.push(`    ${addrExpr('daddr', item.ip, 'allow')}${portClause(item.proto, item.ports)} accept`);
+    });
+    // egress.rules：直连放行的 IP 规则（restricted 下用来放行私有网段里的指定端点，allowlist 下是唯一的直连出口）
+    policy.egress.rules.forEach(rule => {
+        out.push(`    ${addrExpr('daddr', rule.cidr, 'egress')}${portClause(rule.proto, rule.ports)} accept`);
+    });
+    if (policy.preset === 'allowlist') {
+        out.push('    reject');
+    } else {
+        // restricted：先放行用户 deny 之外的公网，再封私有网段
+        const v4 = cidrList(PRIVATE_V4, 4);
+        const v6 = cidrList(PRIVATE_V6, 6);
+        out.push(`    ip daddr { ${v4.join(', ')} } reject`);
+        out.push(`    ip6 daddr { ${v6.join(', ')} } reject`);
+        out.push('    meta l4proto { tcp, udp } ip6 daddr fe80::/10 reject');
+    }
+
+    const inn = ['    iif lo accept', '    ct state established,related accept'];
+    (endpoints.peerIn || []).forEach(item => {
+        inn.push(`    ${addrExpr('saddr', item.ip, 'peer')}${portClause(item.proto, item.ports)} accept`);
+    });
+    if (endpoints.bridge) {
+        const subnet = normalizeCidr(endpoints.bridge.subnet, 'bridge.subnet');
+        const gateway = normalizeCidr(endpoints.bridge.gateway, 'bridge.gateway');
+        if (subnet.family === 4 && gateway.family === 4) {
+            inn.push(`    ip saddr ${subnet.cidr} ip saddr != ${gateway.cidr} ct state new reject`);
+        }
+    }
+
+    lines.push('table inet manyoyo {');
+    lines.push('  chain output {', '    type filter hook output priority 0; policy accept;', ...out, '  }');
+    lines.push('  chain input {', '    type filter hook input priority 0; policy accept;', ...inn, '  }');
+    lines.push('}');
+    return `${lines.join('\n')}\n`;
+}
+
+module.exports = {
+    PRESETS,
+    PRIVATE_V4,
+    PRIVATE_V6,
+    normalizePorts,
+    normalizeProto,
+    normalizeCidr,
+    normalizeDomain,
+    normalizePolicy,
+    defaultPolicy,
+    domainMatches,
+    domainAllowed,
+    buildNftRuleset
+};

package/lib/plugin/fingerprint.js

@@ -2,7 +2,8 @@
 
 // 浏览器指纹的唯一数据源：宿主机生成的配置与镜像内的 docker/res/playwright/* 都从这里生成。
 // 原则是各项信号自洽：UA、Client Hints、平台、字体、WebGL 一律用浏览器真实值，不做自相矛盾的伪装；
-// 只固定语言、时区、窗口形态与自动化痕迹。
+// 只固定语言、时区、窗口形态与自动化痕迹。语言与时区由浏览器进程的原生环境变量（TZ / LANG / LANGUAGE）提供，
+// 而不是 Playwright 的 contextOptions 模拟：后者只作用于页面，Worker 里还是系统值，会被检测站点识别为不一致。
 
 const CONTAINER_CONFIG_DIR = '/run/manyoyo-playwright';
 const CONTAINER_CONFIG_PATH = `${CONTAINER_CONFIG_DIR}/config.json`;
@@ -13,7 +14,7 @@ const DEFAULT_PROFILE = {
     locale: 'en-US',
     timezoneId: 'UTC',
     navigatorPlatform: '',
-    disableWebRTC: false
+    disableWebRTC: true
 };
 
 function resolveProfile(options = {}) {
@@ -22,13 +23,34 @@ function resolveProfile(options = {}) {
         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
+        disableWebRTC: options.disableWebRTC === undefined ? DEFAULT_PROFILE.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`;
+// 浏览器进程的原生语言与时区环境变量；值会写进 shell 与 env 文件，所以格式必须严格。
+// locale 只取“语言[-文字][-地区]”（兼容 en_US 写法，丢掉 -u- 之类的扩展），LANG 用 ll_RR.UTF-8
+function buildProcessEnv(options = {}) {
+    const profile = resolveProfile(options);
+    const match = /^([A-Za-z]{2,3})(?:[-_][A-Za-z]{4})?(?:[-_]([A-Za-z]{2}|\d{3}))?(?:[-_][A-Za-z0-9]{1,8})*$/.exec(profile.locale);
+    if (!match) {
+        throw new Error(`locale 格式无效: ${profile.locale}`);
+    }
+    if (!/^[A-Za-z0-9_+/-]+$/.test(profile.timezoneId)) {
+        throw new Error(`timezoneId 格式无效: ${profile.timezoneId}`);
+    }
+    const language = match[1].toLowerCase();
+    const region = match[2] ? match[2].toUpperCase() : '';
+    const posix = region ? `${language}_${region}` : language;
+    return {
+        TZ: profile.timezoneId,
+        LANG: `${posix}.UTF-8`,
+        LANGUAGE: region ? `${posix}:${language}` : language
+    };
+}
+
+// 容器内 playwright-cli 包装脚本 source 的文件
+function buildContainerEnvFile(options = {}) {
+    return Object.entries(buildProcessEnv(options)).map(([key, value]) => `export ${key}='${value}'\n`).join('');
 }
 
 // 宿主机的时区与系统语言，作为默认值
@@ -42,7 +64,8 @@ function buildLaunchArgs(options = {}, window = 'native') {
     const profile = resolveProfile(options);
     const args = [
         `--lang=${profile.locale}`,
-        window === 'virtual' ? '--window-size=1920,1080' : '--start-maximized',
+        // 虚拟屏 1920x1080，fluxbox 底栏占 22px：窗口取工作区大小并贴在 (0,0)，否则 Chrome 被整体顶上去（y=-21），顶部标签栏被截掉
+        ...(window === 'virtual' ? ['--window-size=1920,1058', '--window-position=0,0'] : ['--start-maximized']),
         '--disable-blink-features=AutomationControlled',
         '--force-webrtc-ip-handling-policy=disable_non_proxied_udp'
     ];
@@ -53,36 +76,23 @@ function buildLaunchArgs(options = {}, window = 'native') {
 }
 
 // 有头浏览器不设置 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 buildContextOptions() {
+    return { viewport: null };
+}
+
+// 只有 navigatorPlatform（用户显式设置）或 disableWebRTC（默认开启，STUN 会暴露本机公网 IP）生效时才会改写页面；都不需要时什么都不改（每个被改写的 getter 都可能被检测站点当作 lie）
+function needsInitScript(profile) {
+    return Boolean(profile.navigatorPlatform) || profile.disableWebRTC;
 }
 
 function buildInitScript(options = {}) {
     const profile = resolveProfile(options);
-    // 首个页面加载时窗口尚未显示，outerWidth/outerHeight 会读到 0（无头浏览器的典型特征）；
-    // 只在读到 0 时用 inner 尺寸加上工具栏高度补上，真实窗口的值原样返回
+    if (!needsInitScript(profile)) {
+        return "'use strict';\n";
+    }
     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 (_) {}'
+        '(function () {'
     ];
     if (profile.navigatorPlatform) {
         lines.push(
@@ -117,16 +127,16 @@ function buildInitScript(options = {}) {
 }
 
 // 容器内 playwright-cli 读取的配置。
-// default: 容器内 Xvfb 里的有头浏览器；ws: 附着宿主机 launch-server；cdp: 附着用户自己的 Chrome（不注入指纹）
+// default: 容器内 Xvfb 里的有头 Google Chrome；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)
-    };
+    const fingerprint = { contextOptions: buildContextOptions() };
+    if (needsInitScript(resolveProfile(options))) {
+        fingerprint.initScript = [CONTAINER_INIT_SCRIPT_PATH];
+    }
     if (kind === 'ws') {
         // launch-server 不预创建 context，必须 isolated 才会自建
         return { ...base, browser: { remoteEndpoint: options.endpoint, isolated: true, ...fingerprint } };
@@ -134,12 +144,12 @@ function buildContainerConfig(kind, options = {}) {
     return {
         ...base,
         browser: {
-            // 容器内是 root，Chromium 不允许 root 开沙箱
-            chromiumSandbox: false,
             browserName: 'chromium',
             ...fingerprint,
             launchOptions: {
-                channel: 'chromium',
+                channel: 'chrome',
+                // 容器内是 root，Chrome 不允许 root 开沙箱；必须写在 launchOptions 里才生效
+                chromiumSandbox: false,
                 headless: false,
                 args: buildLaunchArgs(options, 'virtual')
             }
@@ -148,16 +158,20 @@ function buildContainerConfig(kind, options = {}) {
 }
 
 // 宿主机 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]
-    };
+// useChrome 为 false（宿主机没装 Google Chrome）时不写 channel，退回 patchright 自己下载的 Chromium。
+// extensionPaths：官方 Google Chrome 从 M137 起忽略 --load-extension，扩展由 playwright-server.js 在启动后经 CDP
+// Extensions.loadUnpacked 加载（需要 --enable-unsafe-extension-debugging，所以只在有扩展时才加）；该字段会在 launchServer 前被取走
+function buildServerConfig({ host, port, wsPath, headless = false, window = 'native', chromiumSandbox = true, useChrome = true, extensionPaths = [], ...profileOptions }) {
+    const config = { host, port, wsPath, headless, chromiumSandbox };
+    if (useChrome) {
+        config.channel = 'chrome';
+    }
+    config.args = buildLaunchArgs(profileOptions, window);
+    if (extensionPaths.length > 0) {
+        config.args.push('--enable-unsafe-extension-debugging');
+        config.extensionPaths = extensionPaths;
+    }
+    return config;
 }
 
 module.exports = {
@@ -167,7 +181,8 @@ module.exports = {
     DEFAULT_PROFILE,
     resolveProfile,
     detectHostProfile,
-    acceptLanguage,
+    buildProcessEnv,
+    buildContainerEnvFile,
     buildLaunchArgs,
     buildContextOptions,
     buildInitScript,

package/lib/plugin/playwright-extensions.js

@@ -194,14 +194,6 @@ function resolveExtensionInputs(pluginRoot, { extensionPaths = [], extensionName
     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 = [];
@@ -289,7 +281,6 @@ module.exports = {
     CONTAINER_EXTENSION_ROOT,
     buildContainerExtensionMounts,
     buildCrxUrl,
-    buildExtensionLaunchArgs,
     convertManifestV2ToV3,
     crxZipOffset,
     downloadExtensions,

package/lib/plugin/playwright-server.js

@@ -1,15 +1,35 @@
 'use strict';
 
-// 宿主机（或 vnc 容器内）的 Playwright 浏览器服务：用 @playwright/cli 自带的 playwright-core 启动有头浏览器并开放 WebSocket。
+// 宿主机（或 vnc 容器内）的 Playwright 浏览器服务：用 patchright-core 启动有头浏览器（Google Chrome 优先）并开放 WebSocket。
 // 用法：node playwright-server.js <playwright-core 目录> <配置文件>，配置为 chromium.launchServer 的选项。
 
 const fs = require('fs');
 
+// 官方 Google Chrome 忽略 --load-extension，改用 CDP Extensions.loadUnpacked；加载后的扩展在连接断开后仍保留
+async function loadExtensions(chromium, endpoint, extensionPaths) {
+    const browser = await chromium.connect(endpoint);
+    try {
+        const cdp = await browser.newBrowserCDPSession();
+        for (const extensionPath of extensionPaths) {
+            try {
+                await cdp.send('Extensions.loadUnpacked', { path: extensionPath });
+            } catch (error) {
+                console.error(`扩展加载失败 ${extensionPath}: ${String(error && error.message || error).split('\n')[0]}`);
+            }
+        }
+    } finally {
+        await browser.close();
+    }
+}
+
 async function main() {
     const [corePath, configPath] = process.argv.slice(2);
-    const options = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    const { extensionPaths = [], ...options } = JSON.parse(fs.readFileSync(configPath, 'utf8'));
     const { chromium } = require(corePath);
     const server = await chromium.launchServer(options);
+    if (extensionPaths.length > 0) {
+        await loadExtensions(chromium, server.wsEndpoint(), extensionPaths);
+    }
     const shutdown = () => server.close().finally(() => process.exit(0));
     process.on('SIGTERM', shutdown);
     process.on('SIGINT', shutdown);