conductor-oss 0.60.20 → 0.61.1

package/web/.next/standalone/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/IsolatedWorld.js

@@ -9,17 +9,22 @@ import { EventEmitter } from '../common/EventEmitter.js';
 import { fromEmitterEvent, timeout, withSourcePuppeteerURLIfNone, } from '../common/util.js';
 import { disposeSymbol } from '../util/disposable.js';
 import { CdpElementHandle } from './ElementHandle.js';
+import { MAIN_WORLD } from './IsolatedWorlds.js';
 import { CdpJSHandle } from './JSHandle.js';
+import { CdpWebWorker } from './WebWorker.js';
 /**
  * @internal
  */
 export class IsolatedWorld extends Realm {
     #context;
     #emitter = new EventEmitter();
+    #worldId;
+    #origin;
     #frameOrWorker;
-    constructor(frameOrWorker, timeoutSettings) {
+    constructor(frameOrWorker, timeoutSettings, worldId) {
         super(timeoutSettings);
         this.#frameOrWorker = frameOrWorker;
+        this.#worldId = worldId;
     }
     get environment() {
         return this.#frameOrWorker;
@@ -150,8 +155,33 @@ export class IsolatedWorld extends Realm {
     [disposeSymbol]() {
         this.#context?.[disposeSymbol]();
         this.#emitter.emit('disposed', undefined);
-        super[disposeSymbol]();
         this.#emitter.removeAllListeners();
+        super[disposeSymbol]();
+    }
+    get origin() {
+        return this.#origin;
+    }
+    set origin(origin) {
+        this.#origin = origin;
+    }
+    setWorldId(worldId) {
+        this.#worldId = worldId;
+    }
+    async extension() {
+        if (this.#frameOrWorker instanceof CdpWebWorker) {
+            throw new Error('Unable to get extension from Realm');
+        }
+        if (this.#worldId === MAIN_WORLD) {
+            return null;
+        }
+        if (typeof this.#worldId === 'string') {
+            const extensions = await this.#frameOrWorker._frameManager
+                .page()
+                .browser()
+                .extensions();
+            return extensions.get(this.#worldId) ?? null;
+        }
+        return null;
     }
 }
 //# sourceMappingURL=IsolatedWorld.js.map

package/web/.next/standalone/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/Page.js

@@ -58,7 +58,8 @@ var __disposeResources = (this && this.__disposeResources) || (function (Suppres
 import { firstValueFrom, from, raceWith } from '../../third_party/rxjs/rxjs.js';
 import { CDPSessionEvent } from '../api/CDPSession.js';
 import { Page, } from '../api/Page.js';
-import { ConsoleMessage, } from '../common/ConsoleMessage.js';
+import { WebWorker, WebWorkerEvent } from '../api/WebWorker.js';
+import { ConsoleMessage } from '../common/ConsoleMessage.js';
 import { TargetCloseError } from '../common/Errors.js';
 import { EventEmitter } from '../common/EventEmitter.js';
 import { FileChooser } from '../common/FileChooser.js';
@@ -82,16 +83,9 @@ import { CdpKeyboard, CdpMouse, CdpTouchscreen } from './Input.js';
 import { MAIN_WORLD } from './IsolatedWorlds.js';
 import { releaseObject } from './JSHandle.js';
 import { Tracing } from './Tracing.js';
-import { createClientError, pageBindingInitString, valueFromJSHandle, } from './utils.js';
+import { convertConsoleMessageLevel, createClientError, createConsoleMessage, pageBindingInitString, } from './utils.js';
+import { WebMCP } from './WebMCP.js';
 import { CdpWebWorker } from './WebWorker.js';
-function convertConsoleMessageLevel(method) {
-    switch (method) {
-        case 'warning':
-            return 'warn';
-        default:
-            return method;
-    }
-}
 /**
  * @internal
  */
@@ -140,6 +134,7 @@ export class CdpPage extends Page {
     #frameManager;
     #emulationManager;
     #tracing;
+    #webmcp;
     #bindings = new Map();
     #exposedFunctions = new Map();
     #coverage;
@@ -165,6 +160,7 @@ export class CdpPage extends Page {
         this.#frameManager = new FrameManager(client, this, this._timeoutSettings);
         this.#emulationManager = new EmulationManager(client);
         this.#tracing = new Tracing(client);
+        this.#webmcp = new WebMCP(client, this.#frameManager);
         this.#coverage = new Coverage(client);
         this.#viewport = null;
         // Use browser context's connection, as current Bluetooth emulation in Chromium is
@@ -245,6 +241,7 @@ export class CdpPage extends Page {
         this.#touchscreen.updateClient(newSession);
         this.#emulationManager.updateClient(newSession);
         this.#tracing.updateClient(newSession);
+        this.#webmcp.updateClient(newSession);
         this.#coverage.updateClient(newSession);
         await this.#frameManager.swapFrameTree(newSession);
         this.#setupPrimaryTargetListeners();
@@ -295,8 +292,23 @@ export class CdpPage extends Page {
         assert(session instanceof CdpCDPSession);
         this.#frameManager.onAttachedToTarget(session.target());
         if (session.target()._getTargetInfo().type === 'worker') {
-            const worker = new CdpWebWorker(session, session.target().url(), session.target()._targetId, session.target().type(), this.#onConsoleAPI.bind(this), this.#handleException.bind(this), this.#frameManager.networkManager);
+            const worker = new CdpWebWorker(session, session.target().url(), session.target()._targetId, session.target().type(), this.#handleException.bind(this), this.#frameManager.networkManager);
             this.#workers.set(session.id(), worker);
+            worker.internalEmitter.on(WebWorkerEvent.Console, message => {
+                const noListenersForConsoleOnPage = this.listenerCount("console" /* PageEvent.Console */) === 0;
+                const noListenersForConsoleOnWorker = worker.listenerCount(WebWorkerEvent.Console) === 0;
+                if (noListenersForConsoleOnPage && noListenersForConsoleOnWorker) {
+                    // eslint-disable-next-line max-len -- The comment is long.
+                    // eslint-disable-next-line @puppeteer/use-using -- These are not owned by this function.
+                    for (const arg of message.args()) {
+                        void arg.dispose().catch(debugError);
+                    }
+                    return;
+                }
+                if (!noListenersForConsoleOnPage) {
+                    this.emit("console" /* PageEvent.Console */, message);
+                }
+            });
             this.emit("workercreated" /* PageEvent.WorkerCreated */, worker);
         }
         session.on(CDPSessionEvent.Ready, this.#onAttachedToTarget);
@@ -307,6 +319,7 @@ export class CdpPage extends Page {
                 this.#frameManager.initialize(this.#primaryTargetClient),
                 this.#primaryTargetClient.send('Performance.enable'),
                 this.#primaryTargetClient.send('Log.enable'),
+                this.#webmcp.initialize(),
             ]);
         }
         catch (err) {
@@ -357,6 +370,9 @@ export class CdpPage extends Page {
     _client() {
         return this.#primaryTargetClient;
     }
+    _isUrlAllowed(url) {
+        return this.#targetManager.isUrlAllowed(url);
+    }
     isServiceWorkerBypassed() {
         return this.#serviceWorkerBypassed;
     }
@@ -369,9 +385,18 @@ export class CdpPage extends Page {
     async openDevTools() {
         const pageTargetId = this.target()._targetId;
         const browser = this.browser();
+        const devtoolsTargetId = await browser._hasDevToolsTarget(this.target()._targetId);
+        if (devtoolsTargetId) {
+            return await browser._getDevToolsTargetPage(devtoolsTargetId);
+        }
         const devtoolsPage = await browser._createDevToolsPage(pageTargetId);
         return devtoolsPage;
     }
+    async hasDevTools() {
+        const browser = this.browser();
+        const targetId = await browser._hasDevToolsTarget(this.target()._targetId);
+        return Boolean(targetId);
+    }
     async waitForFileChooser(options = {}) {
         const needsEnable = this.#fileChooserDeferreds.size === 0;
         const { timeout = this._timeoutSettings.timeout() } = options;
@@ -444,6 +469,9 @@ export class CdpPage extends Page {
     get tracing() {
         return this.#tracing;
     }
+    get webmcp() {
+        return this.#webmcp;
+    }
     frames() {
         return this.#frameManager.frames();
     }
@@ -667,38 +695,30 @@ export class CdpPage extends Page {
     #handleException(exception) {
         this.emit("pageerror" /* PageEvent.PageError */, createClientError(exception.exceptionDetails));
     }
-    #onConsoleAPI(world, event) {
-        const values = event.args.map(arg => {
-            return world.createCdpHandle(arg);
-        });
-        if (!this.listenerCount("console" /* PageEvent.Console */)) {
-            values.forEach(arg => {
-                return arg.dispose();
+    #onConsoleAPI(world, event, values) {
+        if (!values) {
+            values = event.args.map(arg => {
+                return world.createCdpHandle(arg);
             });
-            return;
         }
-        const textTokens = [];
-        // eslint-disable-next-line max-len -- The comment is long.
-        // eslint-disable-next-line @puppeteer/use-using -- These are not owned by this function.
-        for (const arg of values) {
-            textTokens.push(valueFromJSHandle(arg));
-        }
-        const stackTraceLocations = [];
-        if (event.stackTrace) {
-            for (const callFrame of event.stackTrace.callFrames) {
-                stackTraceLocations.push({
-                    url: callFrame.url,
-                    lineNumber: callFrame.lineNumber,
-                    columnNumber: callFrame.columnNumber,
-                });
+        const hasPageConsoleListeners = this.listenerCount("console" /* PageEvent.Console */) > 0;
+        const hasWorkerConsoleListeners = world.environment instanceof WebWorker &&
+            world.environment.listenerCount(WebWorkerEvent.Console) > 0;
+        if (!hasPageConsoleListeners) {
+            if (!hasWorkerConsoleListeners) {
+                // eslint-disable-next-line max-len -- The comment is long.
+                // eslint-disable-next-line @puppeteer/use-using -- These are not owned by this function.
+                for (const value of values) {
+                    void value.dispose().catch(debugError);
+                }
             }
+            return;
         }
         let targetId;
         if (world.environment.client instanceof CdpCDPSession) {
             targetId = world.environment.client.target()._targetId;
         }
-        const message = new ConsoleMessage(convertConsoleMessageLevel(event.type), textTokens.join(' '), values, stackTraceLocations, undefined, event.stackTrace, targetId);
-        this.emit("console" /* PageEvent.Console */, message);
+        this.emit("console" /* PageEvent.Console */, createConsoleMessage(event, values, targetId));
     }
     async #onBindingCalled(world, event) {
         let payload;
@@ -770,6 +790,9 @@ export class CdpPage extends Page {
     async setBypassCSP(enabled) {
         await this.#primaryTargetClient.send('Page.setBypassCSP', { enabled });
     }
+    async triggerExtensionAction(extension) {
+        return await extension.triggerAction(this);
+    }
     async emulateMediaType(type) {
         return await this.#emulationManager.emulateMediaType(type);
     }
@@ -957,6 +980,9 @@ export class CdpPage extends Page {
     get bluetooth() {
         return this.#cdpBluetoothEmulation;
     }
+    extensionRealms() {
+        return this.mainFrame().extensionRealms();
+    }
 }
 const supportedMetrics = new Set([
     'Timestamp',

package/web/.next/standalone/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/Target.js

@@ -29,6 +29,9 @@ export class CdpTarget extends Target {
     _initializedDeferred = Deferred.create();
     _isClosedDeferred = Deferred.create();
     _targetId;
+    _asPagePromise;
+    /** @internal */
+    pagePromise;
     /**
      * To initialize the target for use, call initialize.
      *
@@ -47,13 +50,21 @@ export class CdpTarget extends Target {
         }
     }
     async asPage() {
-        const session = this._session();
-        if (!session) {
-            return await this.createCDPSession().then(client => {
+        if (this.pagePromise) {
+            const page = await this.pagePromise;
+            if (page) {
+                return page;
+            }
+        }
+        if (!this._asPagePromise) {
+            const session = this._session();
+            this._asPagePromise = (session
+                ? Promise.resolve(session)
+                : this._sessionFactory()(/* isAutoAttachEmulated=*/ false)).then(client => {
                 return CdpPage._create(client, this, null);
             });
         }
-        return await CdpPage._create(session, this, null);
+        return (await this._asPagePromise) ?? null;
     }
     _subtype() {
         return this.#targetInfo.subtype;
@@ -162,7 +173,6 @@ export class CdpTarget extends Target {
  */
 export class PageTarget extends CdpTarget {
     #defaultViewport;
-    pagePromise;
     constructor(targetInfo, session, browserContext, targetManager, sessionFactory, defaultViewport) {
         super(targetInfo, session, browserContext, targetManager, sessionFactory);
         this.#defaultViewport = defaultViewport ?? undefined;
@@ -225,11 +235,10 @@ export class WorkerTarget extends CdpTarget {
     async worker() {
         if (!this.#workerPromise) {
             const session = this._session();
-            // TODO(einbinder): Make workers send their console logs.
             this.#workerPromise = (session
                 ? Promise.resolve(session)
                 : this._sessionFactory()(/* isAutoAttachEmulated=*/ false)).then(client => {
-                return new CdpWebWorker(client, this._getTargetInfo().url, this._targetId, this.type(), () => { } /* consoleAPICalled */, () => { } /* exceptionThrown */, undefined /* networkManager */);
+                return new CdpWebWorker(client, this._getTargetInfo().url, this._targetId, this.type(), () => { } /* exceptionThrown */, undefined /* networkManager */);
             });
         }
         return await this.#workerPromise;

package/web/.next/standalone/node_modules/puppeteer-core/lib/esm/puppeteer/cdp/TargetManager.js

@@ -3,6 +3,7 @@
  * Copyright 2022 Google Inc.
  * SPDX-License-Identifier: Apache-2.0
  */
+import { URLPattern } from '../../third_party/urlpattern-polyfill/urlpattern-polyfill.js';
 import { CDPSessionEvent } from '../api/CDPSession.js';
 import { EventEmitter } from '../common/EventEmitter.js';
 import { debugError } from '../common/util.js';
@@ -70,12 +71,19 @@ export class TargetManager extends EventEmitter {
     // done. It indicates whethere we are running the initial auto-attach step or
     // if we are handling targets after that.
     #initialAttachDone = false;
-    constructor(connection, targetFactory, targetFilterCallback, waitForInitiallyDiscoveredTargets = true) {
+    #blocklist = [];
+    #allowlist = [];
+    constructor(connection, targetFactory, targetFilterCallback, waitForInitiallyDiscoveredTargets = true, blocklist, allowlist) {
         super();
+        if (blocklist && allowlist) {
+            throw new Error('Cannot specify both blockList and allowList');
+        }
         this.#connection = connection;
         this.#targetFilterCallback = targetFilterCallback;
         this.#targetFactory = targetFactory;
         this.#waitForInitiallyDiscoveredTargets = waitForInitiallyDiscoveredTargets;
+        this.#blocklist = this.#mapPatterns(blocklist);
+        this.#allowlist = this.#mapPatterns(allowlist);
         this.#connection.on('Target.targetCreated', this.#onTargetCreated);
         this.#connection.on('Target.targetDestroyed', this.#onTargetDestroyed);
         this.#connection.on('Target.targetInfoChanged', this.#onTargetInfoChanged);
@@ -103,6 +111,9 @@ export class TargetManager extends EventEmitter {
         this.#finishInitializationIfReady();
         await this.#initializeDeferred.valueOrThrow();
     }
+    addToIgnoreTarget(targetId) {
+        this.#ignoredTargets.add(targetId);
+    }
     getChildTargets(target) {
         return target._childTargets();
     }
@@ -116,6 +127,9 @@ export class TargetManager extends EventEmitter {
     getAvailableTargets() {
         return this.#attachedTargetsByTargetId;
     }
+    getDiscoveredTargetInfos() {
+        return this.#discoveredTargetsByTargetId;
+    }
     #setupAttachmentListeners(session) {
         const listener = (event) => {
             void this.#onAttachedToTarget(session, event);
@@ -224,6 +238,12 @@ export class TargetManager extends EventEmitter {
         if (!this.#connection.isAutoAttached(targetInfo.targetId)) {
             return;
         }
+        // If we connect to a browser that is already open,
+        // immediately detach from any tab that is on the blocklist.
+        if (!this.#initialAttachDone && !this.isUrlAllowed(targetInfo.url)) {
+            await this.#silentDetach(session, parentSession);
+            return;
+        }
         // Special case for service workers: being attached to service workers will
         // prevent them from ever being destroyed. Therefore, we silently detach
         // from service workers unless the connection was manually created via
@@ -233,7 +253,9 @@ export class TargetManager extends EventEmitter {
         // CDP.
         if (targetInfo.type === 'service_worker') {
             await this.#silentDetach(session, parentSession);
-            if (this.#attachedTargetsByTargetId.has(targetInfo.targetId)) {
+            if (this.#attachedTargetsByTargetId.has(targetInfo.targetId) ||
+                this.#ignoredTargets.has(targetInfo.targetId) ||
+                !this.#discoveredTargetsByTargetId.has(targetInfo.targetId)) {
                 return;
             }
             const target = this.#targetFactory(targetInfo);
@@ -288,6 +310,7 @@ export class TargetManager extends EventEmitter {
                 autoAttach: true,
                 filter: this.#discoveryFilter,
             }),
+            this.#maybeSetupNetworkConditions(session),
             session.send('Runtime.runIfWaitingForDebugger'),
         ]).catch(debugError);
     };
@@ -316,5 +339,76 @@ export class TargetManager extends EventEmitter {
         this.#attachedTargetsByTargetId.delete(target._targetId);
         this.emit("targetGone" /* TargetManagerEvent.TargetGone */, target);
     };
+    /**
+     * Helper to validate URL against blocklist patterns
+     */
+    isUrlAllowed = (url) => {
+        if (this.#blocklist.length === 0 && this.#allowlist.length === 0) {
+            return true;
+        }
+        // Always allow internal or setup pages
+        if (!url || url === 'about:blank') {
+            return true;
+        }
+        for (const item of this.#blocklist) {
+            if (item.pattern.test(url)) {
+                return false;
+            }
+        }
+        if (this.#allowlist.length > 0) {
+            for (const item of this.#allowlist) {
+                if (item.pattern.test(url)) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        return true;
+    };
+    #mapPatterns(rules) {
+        const result = [];
+        for (const rule of rules ?? []) {
+            result.push({ pattern: new URLPattern(rule), rule });
+        }
+        return result;
+    }
+    #maybeSetupNetworkConditions = async (session) => {
+        if (this.#blocklist.length === 0 && this.#allowlist.length === 0) {
+            return;
+        }
+        const matchedNetworkConditions = [];
+        for (const item of this.#blocklist) {
+            matchedNetworkConditions.push({
+                urlPattern: item.rule,
+                offline: true,
+                latency: 0,
+                downloadThroughput: -1,
+                uploadThroughput: -1,
+            });
+        }
+        if (this.#allowlist.length > 0) {
+            for (const item of this.#allowlist) {
+                matchedNetworkConditions.push({
+                    urlPattern: item.rule,
+                    offline: false,
+                    latency: 0,
+                    downloadThroughput: -1,
+                    uploadThroughput: -1,
+                });
+            }
+            matchedNetworkConditions.push({
+                urlPattern: '',
+                offline: true,
+                latency: 0,
+                downloadThroughput: -1,
+                uploadThroughput: -1,
+            });
+        }
+        await session.send('Network.emulateNetworkConditionsByRule', {
+            // @ts-expect-error offline cannot be undefined before M149.
+            offline: this.#blocklist.length > 0 ? true : undefined,
+            matchedNetworkConditions,
+        });
+    };
 }
 //# sourceMappingURL=TargetManager.js.map