@pyrokine/mcp-chrome 2.0.2 → 2.2.0

package/dist/core/unified-session.js

@@ -6,12 +6,16 @@
  * 2. CDP 模式：通过 Chrome DevTools Protocol 操作（Fallback）
  */
 import { ExtensionBridge } from '../extension/index.js';
+import { DriverCapabilityError, } from './browser-driver.js';
 import { isExtensionDisconnected } from './extension-errors.js';
 import { getKeyDefinition, getSession as getCdpSession } from './session.js';
-import { extractCdpValue, formatCdpException, MODIFIER_KEYS } from './types.js';
+import { EvaluateResultTooLargeError, extractCdpValue, formatCdpException, isKnownNonSerializableRemoteObject, MODIFIER_KEYS, NonSerializableEvaluateResultError, } from './types.js';
 class UnifiedSessionManager {
     static instance;
     static CONNECTION_COOLDOWN = 30000; // 连接失败后 30 秒内不重试
+    static CDP_MATERIALIZE_MAX_DEPTH = 8;
+    static CDP_MATERIALIZE_MAX_NODES = 2000;
+    static CDP_MATERIALIZE_MAX_CHARS = 1_000_000;
     extensionBridge = null;
     inputMode = 'precise'; // 默认使用 precise 模式，可绕过 CSP 限制
     currentMousePosition = { x: 0, y: 0 }; // 跟踪鼠标位置
@@ -20,6 +24,7 @@ class UnifiedSessionManager {
     /** 当前按下的所有键（用于 Puppeteer 风格的 rawKeyDown/autoRepeat 长按重复） */
     pressedKeys = new Set();
     lastConnectionFailure = 0;
+    activeMode = null;
     tabSwitchLock = Promise.resolve(); // 串行化 tab 切换，防止并发竞态
     requireExtension = false; // 指定 tabId 或 frame 时为 true，禁止 CDP 回退
     currentFrameOffset = null; // iframe 在主页面的偏移量（withFrame 期间有效）
@@ -51,14 +56,26 @@ class UnifiedSessionManager {
      * 获取当前连接模式
      */
     getMode() {
+        if (this.activeMode === 'extension' && this.extensionBridge?.isConnected()) {
+            return 'extension';
+        }
+        if (this.activeMode === 'cdp' && getCdpSession().isConnected()) {
+            return 'cdp';
+        }
+        this.activeMode = null;
         if (this.extensionBridge?.isConnected()) {
+            this.activeMode = 'extension';
             return 'extension';
         }
         if (getCdpSession().isConnected()) {
+            this.activeMode = 'cdp';
             return 'cdp';
         }
         return 'none';
     }
+    setActiveMode(mode) {
+        this.activeMode = mode;
+    }
     /**
      * 获取当前输入模式
      */
@@ -90,6 +107,9 @@ class UnifiedSessionManager {
      * 是否 Extension 已连接
      */
     isExtensionConnected() {
+        return this.activeMode === 'extension' && (this.extensionBridge?.isConnected() ?? false);
+    }
+    isExtensionAvailable() {
         return this.extensionBridge?.isConnected() ?? false;
     }
     /**
@@ -103,22 +123,28 @@ class UnifiedSessionManager {
      * 启动浏览器（CDP 模式）或等待 Extension 连接
      */
     async launch(options = {}) {
+        const extensionReady = this.activeMode === 'cdp'
+            ? (this.extensionBridge?.isConnected() ?? false)
+            : await this.ensureExtensionConnected(options.timeout);
         // 优先检查 Extension 是否已连接，如果断开则等待重连（受 timeout 约束）
-        if (await this.ensureExtensionConnected(options.timeout)) {
+        if (extensionReady) {
             // newPage 会设置 currentTabId，需要加锁
             const result = await this.withTabLock(async () => {
                 return this.extensionBridge.newPage(undefined, options.timeout);
             });
+            this.activeMode = 'extension';
             return {
                 targetId: result.targetId,
                 type: result.type ?? 'page',
                 url: result.url,
                 title: result.title,
+                managed: result.managed,
                 mode: 'extension',
             };
         }
         // Fallback 到 CDP 模式
         const target = await getCdpSession().launch(options);
+        this.activeMode = 'cdp';
         return {
             ...target,
             mode: 'cdp',
@@ -149,6 +175,88 @@ class UnifiedSessionManager {
             status: t.status,
         }));
     }
+    async listTopology() {
+        const mode = this.getMode();
+        if (mode === 'none') {
+            return null;
+        }
+        const driver = await this.getDriver();
+        if (!driver.listWindows) {
+            return null;
+        }
+        return driver.listWindows();
+    }
+    async adoptPage(targetId) {
+        const driver = await this.getDriver();
+        if (!driver.adoptPage) {
+            throw new DriverCapabilityError('adoptPage 仅支持 Extension 模式');
+        }
+        return driver.adoptPage(targetId);
+    }
+    async releasePage(targetId) {
+        const driver = await this.getDriver();
+        if (!driver.releasePage) {
+            throw new DriverCapabilityError('releasePage 仅支持 Extension 模式');
+        }
+        return driver.releasePage(targetId);
+    }
+    async movePage(targetId, options) {
+        const driver = await this.getDriver();
+        if (!driver.movePage) {
+            throw new DriverCapabilityError('movePage 仅支持 Extension 模式');
+        }
+        return driver.movePage(targetId, options);
+    }
+    async reorderPage(targetId, index) {
+        const driver = await this.getDriver();
+        if (!driver.reorderPage) {
+            throw new DriverCapabilityError('reorderPage 仅支持 Extension 模式');
+        }
+        return driver.reorderPage(targetId, index);
+    }
+    async pinPage(targetId, pinned) {
+        const driver = await this.getDriver();
+        if (!driver.pinPage) {
+            throw new DriverCapabilityError('pinPage 仅支持 Extension 模式');
+        }
+        return driver.pinPage(targetId, pinned);
+    }
+    async activatePageWithAffected(targetId) {
+        const driver = await this.getDriver();
+        const bridge = driver;
+        if (!bridge.activatePageWithAffected) {
+            throw new DriverCapabilityError('activatePage 受控 affected 返回仅支持 Extension 模式');
+        }
+        return this.withTabLock(() => bridge.activatePageWithAffected(targetId));
+    }
+    async focusWindow(windowId) {
+        const driver = await this.getDriver();
+        if (!driver.focusWindow) {
+            throw new DriverCapabilityError('focusWindow 仅支持 Extension 模式');
+        }
+        return driver.focusWindow(windowId);
+    }
+    async resizeWindow(windowId, options) {
+        const driver = await this.getDriver();
+        if (!driver.resizeWindow) {
+            throw new DriverCapabilityError('resizeWindow 仅支持 Extension 模式');
+        }
+        return driver.resizeWindow(windowId, options);
+    }
+    async newWindow(options) {
+        const driver = await this.getDriver();
+        if (!driver.newWindow) {
+            throw new DriverCapabilityError('newWindow 仅支持 Extension 模式');
+        }
+        return this.withTabLock(() => driver.newWindow(options));
+    }
+    async closeWindow(windowId) {
+        const driver = await this.getDriver();
+        if (!driver.closeWindow) {
+            throw new DriverCapabilityError('closeWindow 仅支持 Extension 模式');
+        }
+        return this.withTabLock(() => driver.closeWindow(windowId));
+    }
     /**
      * 导航到 URL
      */
@@ -181,8 +289,7 @@ class UnifiedSessionManager {
      * 截图
      */
     async screenshot(options) {
-        const result = await (await this.getDriver()).screenshot(options);
-        return result.data;
+        return (await this.getDriver()).screenshot(options);
     }
     /**
      * 点击元素
@@ -200,6 +307,10 @@ class UnifiedSessionManager {
         const driver = await this.getDriver();
         return driver.actionableClick(refId, force);
     }
+    async checkActionability(refId) {
+        const driver = await this.getDriver();
+        return driver.checkActionability(refId);
+    }
     /**
      * dispatch 模式输入（ISOLATED 世界，兼容 React/Vue 受控组件）
      */
@@ -403,6 +514,13 @@ class UnifiedSessionManager {
         const driver = await this.getDriver();
         return driver.getAttribute(selector, refId, attribute);
     }
+    async getFrames() {
+        const driver = await this.getDriver();
+        if (!driver.getFrames) {
+            return { frames: [] };
+        }
+        return driver.getFrames();
+    }
     /**
      * 获取 Cookies
      */
@@ -432,6 +550,7 @@ class UnifiedSessionManager {
                 type: result.type ?? 'page',
                 url: result.url,
                 title: result.title,
+                managed: result.managed,
             };
         };
         // Extension 模式 createTab 设置 currentTabId,需要加锁防止并发竞态
@@ -445,11 +564,9 @@ class UnifiedSessionManager {
         const isExt = this.isExtensionConnected();
         const op = () => driver.closePage(targetId);
         if (isExt) {
-            await this.withTabLock(op);
-        }
-        else {
-            await op();
+            return this.withTabLock(op);
         }
+        return op();
     }
     /**
      * 激活页面（切到前台）
@@ -510,15 +627,19 @@ class UnifiedSessionManager {
         const driver = this.extensionBridge;
         return this.withTabLock(async () => {
             const previousTargetId = driver.getCurrentTargetId();
+            // 临时切换用 setCurrentTargetId，跳过 managed 校验（tabId 仅用于读取/执行，不改变持久 attach 目标）
             driver.setCurrentTargetId(tabId);
             // tabId 明确指定时，禁止 CDP 回退（CDP 不感知 Extension tab）
             const previousRequireExtension = this.requireExtension;
+            const previousActiveMode = this.activeMode;
             this.requireExtension = true;
+            this.activeMode = 'extension';
             try {
                 return await fn();
             }
             finally {
                 this.requireExtension = previousRequireExtension;
+                this.activeMode = previousActiveMode;
                 driver.setCurrentTargetId(previousTargetId);
             }
         });
@@ -544,15 +665,18 @@ class UnifiedSessionManager {
         const previousFrameId = driver.getCurrentFrameId();
         const previousFrameOffset = this.currentFrameOffset;
         const previousRequireExtension = this.requireExtension;
+        const previousActiveMode = this.activeMode;
         driver.setCurrentFrameId(frameId);
         this.currentFrameOffset = offset;
         this.requireExtension = true;
+        this.activeMode = 'extension';
         try {
             return await fn();
         }
         finally {
             // 字段赋值不会 throw,driver.setCurrentFrameId 是同步函数也不会 throw,无需嵌套 try
             this.requireExtension = previousRequireExtension;
+            this.activeMode = previousActiveMode;
             this.currentFrameOffset = previousFrameOffset;
             driver.setCurrentFrameId(previousFrameId);
         }
@@ -562,7 +686,7 @@ class UnifiedSessionManager {
      */
     getState() {
         // driver.getState() 两侧都返回 DriverState | null（{url, title}），SessionState 含 targetId 是其超集，结构兼容
-        if (this.extensionBridge?.isConnected()) {
+        if (this.getMode() === 'extension') {
             return this.extensionBridge.getState();
         }
         return getCdpSession().getState();
@@ -702,7 +826,7 @@ class UnifiedSessionManager {
     async mouseClick(button = 'left', clickCount = 1, refId) {
         const driver = await this.getDriver();
         const isExt = this.isExtensionConnected();
-        if (this.inputMode === 'stealth' && isExt) {
+        if (isExt && (this.inputMode === 'stealth' || button === 'right')) {
             const { x, y } = this.currentMousePosition;
             // stealth 通过单次脚本注入完成所有 mouse/click/dblclick/contextmenu 事件
             // refId 透传：嵌套 iframe overlay 场景下绕过 elementFromPoint 命中外层 IFRAME 的问题
@@ -804,18 +928,19 @@ class UnifiedSessionManager {
             const result = (await this.extensionBridge.evaluateInFrame(currentFrameId, iframeExpression, timeout));
             return this.checkCdpResult(result);
         }
-        // 主 frame，无 args：直接 Runtime.evaluate
         const params = {
             expression,
-            returnByValue: true,
+            returnByValue: false,
             awaitPromise: true,
         };
         if (timeout !== undefined) {
             params.timeout = timeout;
         }
-        // timeout 即端到端预算，直接作为 RPC 超时（不额外加 margin）
         const result = (await this.extensionBridge.debuggerSend('Runtime.evaluate', params, undefined, timeout));
-        return this.checkCdpResult(result);
+        if (result.exceptionDetails) {
+            throw new Error(formatCdpException(result.exceptionDetails));
+        }
+        return this.materializeCdpResult(result.result, timeout);
     }
     async evaluateViaExtensionStealth(expression, timeout) {
         return (await this.extensionBridge.evaluate(expression, undefined, timeout));
@@ -873,6 +998,126 @@ class UnifiedSessionManager {
         }
         return extractCdpValue(result.result);
     }
+    async materializeCdpResult(result, timeout) {
+        if (!result?.objectId) {
+            return extractCdpValue(result);
+        }
+        try {
+            return await this.materializeRemoteObject(result, timeout, { seen: new Set(), nodes: 0, chars: 0 }, 0);
+        }
+        finally {
+            this.extensionBridge.debuggerSend('Runtime.releaseObject', { objectId: result.objectId }).catch(() => { });
+        }
+    }
+    async materializeRemoteObject(result, timeout, state, depth) {
+        if (!result.objectId) {
+            return this.trackMaterializedValue(extractCdpValue(result), state, depth);
+        }
+        if (isKnownNonSerializableRemoteObject(result) || state.seen.has(result.objectId)) {
+            throw new NonSerializableEvaluateResultError(result);
+        }
+        this.trackMaterializedNode(result, state, depth);
+        state.seen.add(result.objectId);
+        try {
+            const properties = (await this.extensionBridge.debuggerSend('Runtime.getProperties', {
+                objectId: result.objectId,
+                ownProperties: true,
+                accessorPropertiesOnly: false,
+                generatePreview: false,
+            }, undefined, timeout));
+            if (properties.exceptionDetails) {
+                throw new Error(formatCdpException(properties.exceptionDetails));
+            }
+            const descriptors = properties.result ?? [];
+            state.nodes += descriptors.length;
+            this.assertMaterializeBudget(state, depth, result);
+            if (result.subtype === 'array') {
+                const array = [];
+                for (const descriptor of descriptors) {
+                    if (!descriptor.value || !/^\d+$/.test(descriptor.name)) {
+                        continue;
+                    }
+                    const index = Number(descriptor.name);
+                    if (index >= UnifiedSessionManager.CDP_MATERIALIZE_MAX_NODES) {
+                        this.throwMaterializeLimit(state, depth, result);
+                    }
+                    this.trackMaterializedPropertyName(descriptor.name, state, depth, result);
+                    array[index] = await this.materializePropertyValue(descriptor.value, timeout, state, depth + 1);
+                }
+                return array;
+            }
+            const object = {};
+            for (const descriptor of descriptors) {
+                if (!descriptor.enumerable || descriptor.wasThrown || !descriptor.value) {
+                    continue;
+                }
+                this.trackMaterializedPropertyName(descriptor.name, state, depth, result);
+                object[descriptor.name] = await this.materializePropertyValue(descriptor.value, timeout, state, depth + 1);
+            }
+            return object;
+        }
+        finally {
+            state.seen.delete(result.objectId);
+        }
+    }
+    async materializePropertyValue(value, timeout, state, depth) {
+        if (!value.objectId) {
+            return this.trackMaterializedValue(extractCdpValue(value), state, depth);
+        }
+        try {
+            return await this.materializeRemoteObject(value, timeout, state, depth);
+        }
+        finally {
+            this.extensionBridge.debuggerSend('Runtime.releaseObject', { objectId: value.objectId }).catch(() => { });
+        }
+    }
+    trackMaterializedNode(result, state, depth) {
+        state.nodes += 1;
+        state.chars += result.description?.length ?? 0;
+        this.assertMaterializeBudget(state, depth, result);
+    }
+    trackMaterializedPropertyName(name, state, depth, result) {
+        state.chars += name.length;
+        this.assertMaterializeBudget(state, depth, result);
+    }
+    trackMaterializedValue(value, state, depth) {
+        state.nodes += 1;
+        state.chars += this.estimateSerializedLength(value);
+        this.assertMaterializeBudget(state, depth);
+        return value;
+    }
+    estimateSerializedLength(value) {
+        if (value === undefined) {
+            return 'undefined'.length;
+        }
+        try {
+            return JSON.stringify(value)?.length ?? String(value).length;
+        }
+        catch {
+            return String(value).length;
+        }
+    }
+    assertMaterializeBudget(state, depth, result) {
+        if (depth > UnifiedSessionManager.CDP_MATERIALIZE_MAX_DEPTH ||
+            state.nodes > UnifiedSessionManager.CDP_MATERIALIZE_MAX_NODES ||
+            state.chars > UnifiedSessionManager.CDP_MATERIALIZE_MAX_CHARS) {
+            this.throwMaterializeLimit(state, depth, result);
+        }
+    }
+    throwMaterializeLimit(state, depth, result) {
+        throw new EvaluateResultTooLargeError({
+            depth,
+            nodes: state.nodes,
+            chars: state.chars,
+            maxDepth: UnifiedSessionManager.CDP_MATERIALIZE_MAX_DEPTH,
+            maxNodes: UnifiedSessionManager.CDP_MATERIALIZE_MAX_NODES,
+            maxChars: UnifiedSessionManager.CDP_MATERIALIZE_MAX_CHARS,
+            type: result?.type,
+            subtype: result?.subtype,
+            className: result?.className,
+            description: result?.description?.slice(0, 200),
+        });
+    }
     /**
      * 检查 CDP 回退是否允许
      *
@@ -900,20 +1145,31 @@ class UnifiedSessionManager {
      *               避免工具 timeout 被连接等待吞掉，不传则使用默认 30s
      */
     async getDriver(timeout) {
+        if (this.activeMode === 'cdp' && getCdpSession().isConnected()) {
+            this.assertCdpFallbackAllowed();
+            return getCdpSession();
+        }
         if (await this.ensureExtensionConnected(timeout)) {
+            this.activeMode = 'extension';
             return this.extensionBridge;
         }
+        this.activeMode = 'cdp';
         return getCdpSession();
     }
     async ensureExtensionConnected(maxWait) {
         if (!this.extensionBridge) {
             return this.assertCdpFallbackAllowed();
         }
+        if (this.activeMode === 'cdp' && getCdpSession().isConnected()) {
+            return this.assertCdpFallbackAllowed();
+        }
         if (this.extensionBridge.isConnected()) {
+            this.activeMode = 'extension';
             return true;
         }
         // CDP 已连接时跳过 Extension 等待，直接使用 CDP 回退
         if (getCdpSession().isConnected()) {
+            this.activeMode = 'cdp';
             return this.assertCdpFallbackAllowed();
         }
         // 冷却期内不重复等待，避免每次操作都阻塞 30 秒
@@ -945,27 +1201,44 @@ class UnifiedSessionManager {
      * 要求 code 必须是函数表达式（如 "(x) => x + 1"）
      */
     async callFunctionOn(code, args, timeout) {
+        const buildFallbackExpression = () => `(${code})(${args.map((a) => JSON.stringify(a)).join(', ')})`;
         const globalResult = (await this.extensionBridge.debuggerSend('Runtime.evaluate', {
             expression: 'globalThis',
             returnByValue: false,
         }, undefined, timeout));
+        const globalObjectId = globalResult.result?.objectId;
+        if (!globalObjectId) {
+            const fallbackExpression = buildFallbackExpression();
+            return this.evaluateViaExtensionPrecise(fallbackExpression, fallbackExpression, undefined, timeout);
+        }
         try {
             const params = {
                 functionDeclaration: code,
-                objectId: globalResult.result.objectId,
+                objectId: globalObjectId,
                 arguments: args.map((a) => ({ value: a })),
-                returnByValue: true,
+                returnByValue: false,
                 awaitPromise: true,
             };
             if (timeout !== undefined) {
                 params.timeout = timeout;
             }
             const result = (await this.extensionBridge.debuggerSend('Runtime.callFunctionOn', params, undefined, timeout));
-            return this.checkCdpResult(result);
+            if (result.exceptionDetails) {
+                throw new Error(formatCdpException(result.exceptionDetails));
+            }
+            return await this.materializeCdpResult(result.result, timeout);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            if (message.includes('Either objectId or executionContextId or uniqueContextId must be specified')) {
+                const fallbackExpression = buildFallbackExpression();
+                return this.evaluateViaExtensionPrecise(fallbackExpression, fallbackExpression, undefined, timeout);
+            }
+            throw error;
         }
         finally {
             this.extensionBridge.debuggerSend('Runtime.releaseObject', {
-                objectId: globalResult.result.objectId,
+                objectId: globalObjectId,
             }).catch(() => { });
         }
     }