conductor-oss 0.3.4 → 0.4.0

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

@@ -0,0 +1,192 @@
+/**
+ * @license
+ * Copyright 2024 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { WEB_PERMISSION_TO_PROTOCOL_PERMISSION, } from '../api/Browser.js';
+import { BrowserContext } from '../api/BrowserContext.js';
+import { assert } from '../util/assert.js';
+import { convertCookiesPartitionKeyFromPuppeteerToCdp, convertSameSiteFromPuppeteerToCdp, } from './Page.js';
+/**
+ * @internal
+ */
+export class CdpBrowserContext extends BrowserContext {
+    #connection;
+    #browser;
+    #id;
+    constructor(connection, browser, contextId) {
+        super();
+        this.#connection = connection;
+        this.#browser = browser;
+        this.#id = contextId;
+    }
+    get id() {
+        return this.#id;
+    }
+    targets() {
+        return this.#browser.targets().filter(target => {
+            return target.browserContext() === this;
+        });
+    }
+    async pages(includeAll = false) {
+        const pages = await Promise.all(this.targets()
+            .filter(target => {
+            return (target.type() === 'page' ||
+                ((target.type() === 'other' || includeAll) &&
+                    this.#browser._getIsPageTargetCallback()?.(target)));
+        })
+            .map(target => {
+            return target.page();
+        }));
+        return pages.filter((page) => {
+            return !!page;
+        });
+    }
+    async overridePermissions(origin, permissions) {
+        const protocolPermissions = permissions.map(permission => {
+            const protocolPermission = WEB_PERMISSION_TO_PROTOCOL_PERMISSION.get(permission);
+            if (!protocolPermission) {
+                throw new Error('Unknown permission: ' + permission);
+            }
+            return protocolPermission;
+        });
+        await this.#connection.send('Browser.grantPermissions', {
+            origin,
+            browserContextId: this.#id || undefined,
+            permissions: protocolPermissions,
+        });
+    }
+    async setPermission(origin, ...permissions) {
+        await Promise.all(permissions.map(async (permission) => {
+            const protocolPermission = {
+                name: permission.permission.name,
+                userVisibleOnly: permission.permission.userVisibleOnly,
+                sysex: permission.permission.sysex,
+                allowWithoutSanitization: permission.permission.allowWithoutSanitization,
+                panTiltZoom: permission.permission.panTiltZoom,
+            };
+            await this.#connection.send('Browser.setPermission', {
+                origin: origin === '*' ? undefined : origin,
+                browserContextId: this.#id || undefined,
+                permission: protocolPermission,
+                setting: permission.state,
+            });
+        }));
+    }
+    async clearPermissionOverrides() {
+        await this.#connection.send('Browser.resetPermissions', {
+            browserContextId: this.#id || undefined,
+        });
+    }
+    async newPage(options) {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const _guard = __addDisposableResource(env_1, await this.waitForScreenshotOperations(), false);
+            return await this.#browser._createPageInContext(this.#id, options);
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            __disposeResources(env_1);
+        }
+    }
+    browser() {
+        return this.#browser;
+    }
+    async close() {
+        assert(this.#id, 'Default BrowserContext cannot be closed!');
+        await this.#browser._disposeContext(this.#id);
+    }
+    async cookies() {
+        const { cookies } = await this.#connection.send('Storage.getCookies', {
+            browserContextId: this.#id,
+        });
+        return cookies.map(cookie => {
+            return {
+                ...cookie,
+                partitionKey: cookie.partitionKey
+                    ? {
+                        sourceOrigin: cookie.partitionKey.topLevelSite,
+                        hasCrossSiteAncestor: cookie.partitionKey.hasCrossSiteAncestor,
+                    }
+                    : undefined,
+                // TODO: remove sameParty as it is removed from Chrome.
+                sameParty: false,
+            };
+        });
+    }
+    async setCookie(...cookies) {
+        return await this.#connection.send('Storage.setCookies', {
+            browserContextId: this.#id,
+            cookies: cookies.map(cookie => {
+                return {
+                    ...cookie,
+                    partitionKey: convertCookiesPartitionKeyFromPuppeteerToCdp(cookie.partitionKey),
+                    sameSite: convertSameSiteFromPuppeteerToCdp(cookie.sameSite),
+                };
+            }),
+        });
+    }
+    async setDownloadBehavior(downloadBehavior) {
+        await this.#connection.send('Browser.setDownloadBehavior', {
+            behavior: downloadBehavior.policy,
+            downloadPath: downloadBehavior.downloadPath,
+            browserContextId: this.#id,
+        });
+    }
+}
+//# sourceMappingURL=BrowserContext.js.map

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

@@ -0,0 +1,39 @@
+/**
+ * @license
+ * Copyright 2024 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @internal
+ */
+export class CdpPreloadScript {
+    /**
+     * This is the ID of the preload script returned by
+     * Page.addScriptToEvaluateOnNewDocument in the main frame.
+     *
+     * Sub-frames would get a different CDP ID because
+     * addScriptToEvaluateOnNewDocument is called for each subframe. But
+     * users only see this ID and subframe IDs are internal to Puppeteer.
+     */
+    #id;
+    #source;
+    #frameToId = new WeakMap();
+    constructor(mainFrame, id, source) {
+        this.#id = id;
+        this.#source = source;
+        this.#frameToId.set(mainFrame, id);
+    }
+    get id() {
+        return this.#id;
+    }
+    get source() {
+        return this.#source;
+    }
+    getIdForFrame(frame) {
+        return this.#frameToId.get(frame);
+    }
+    setIdForFrame(frame, identifier) {
+        this.#frameToId.set(frame, identifier);
+    }
+}
+//# sourceMappingURL=CdpPreloadScript.js.map

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

@@ -0,0 +1,129 @@
+/**
+ * @license
+ * Copyright 2017 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { CDPSession, CDPSessionEvent, } from '../api/CDPSession.js';
+import { CallbackRegistry } from '../common/CallbackRegistry.js';
+import { TargetCloseError } from '../common/Errors.js';
+import { assert } from '../util/assert.js';
+import { createProtocolErrorMessage } from '../util/ErrorLike.js';
+/**
+ * @internal
+ */
+export class CdpCDPSession extends CDPSession {
+    #sessionId;
+    #targetType;
+    #callbacks;
+    #connection;
+    #parentSessionId;
+    #target;
+    #rawErrors = false;
+    #detached = false;
+    /**
+     * @internal
+     */
+    constructor(connection, targetType, sessionId, parentSessionId, rawErrors) {
+        super();
+        this.#connection = connection;
+        this.#targetType = targetType;
+        this.#callbacks = new CallbackRegistry(connection._idGenerator);
+        this.#sessionId = sessionId;
+        this.#parentSessionId = parentSessionId;
+        this.#rawErrors = rawErrors;
+    }
+    /**
+     * Sets the {@link CdpTarget} associated with the session instance.
+     *
+     * @internal
+     */
+    setTarget(target) {
+        this.#target = target;
+    }
+    /**
+     * Gets the {@link CdpTarget} associated with the session instance.
+     *
+     * @internal
+     */
+    target() {
+        assert(this.#target, 'Target must exist');
+        return this.#target;
+    }
+    connection() {
+        return this.#connection;
+    }
+    get detached() {
+        return this.#connection._closed || this.#detached;
+    }
+    parentSession() {
+        if (!this.#parentSessionId) {
+            // In some cases, e.g., DevTools pages there is no parent session. In this
+            // case, we treat the current session as the parent session.
+            return this;
+        }
+        const parent = this.#connection?.session(this.#parentSessionId);
+        return parent ?? undefined;
+    }
+    send(method, params, options) {
+        if (this.detached) {
+            return Promise.reject(new TargetCloseError(`Protocol error (${method}): Session closed. Most likely the ${this.#targetType} has been closed.`));
+        }
+        return this.#connection._rawSend(this.#callbacks, method, params, this.#sessionId, options);
+    }
+    /**
+     * @internal
+     */
+    onMessage(object) {
+        if (object.id) {
+            if (object.error) {
+                if (this.#rawErrors) {
+                    this.#callbacks.rejectRaw(object.id, object.error);
+                }
+                else {
+                    this.#callbacks.reject(object.id, createProtocolErrorMessage(object), object.error.message);
+                }
+            }
+            else {
+                this.#callbacks.resolve(object.id, object.result);
+            }
+        }
+        else {
+            assert(!object.id);
+            this.emit(object.method, object.params);
+        }
+    }
+    /**
+     * Detaches the cdpSession from the target. Once detached, the cdpSession object
+     * won't emit any events and can't be used to send messages.
+     */
+    async detach() {
+        if (this.detached) {
+            throw new Error(`Session already detached. Most likely the ${this.#targetType} has been closed.`);
+        }
+        await this.#connection.send('Target.detachFromTarget', {
+            sessionId: this.#sessionId,
+        });
+        this.#detached = true;
+    }
+    /**
+     * @internal
+     */
+    onClosed() {
+        this.#callbacks.clear();
+        this.#detached = true;
+        this.emit(CDPSessionEvent.Disconnected, undefined);
+    }
+    /**
+     * Returns the session's id.
+     */
+    id() {
+        return this.#sessionId;
+    }
+    /**
+     * @internal
+     */
+    getPendingProtocolErrors() {
+        return this.#callbacks.getPendingProtocolErrors();
+    }
+}
+//# sourceMappingURL=CdpSession.js.map

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

@@ -0,0 +1,244 @@
+/**
+ * @license
+ * Copyright 2017 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { CDPSessionEvent, } from '../api/CDPSession.js';
+import { CallbackRegistry } from '../common/CallbackRegistry.js';
+import { debug } from '../common/Debug.js';
+import { ConnectionClosedError, TargetCloseError } from '../common/Errors.js';
+import { EventEmitter } from '../common/EventEmitter.js';
+import { createProtocolErrorMessage } from '../util/ErrorLike.js';
+import { createIncrementalIdGenerator, } from '../util/incremental-id-generator.js';
+import { CdpCDPSession } from './CdpSession.js';
+const debugProtocolSend = debug('puppeteer:protocol:SEND ►');
+const debugProtocolReceive = debug('puppeteer:protocol:RECV ◀');
+/**
+ * @public
+ */
+export class Connection extends EventEmitter {
+    #url;
+    #transport;
+    #delay;
+    #timeout;
+    #sessions = new Map();
+    #closed = false;
+    #manuallyAttached = new Set();
+    #callbacks;
+    #rawErrors = false;
+    #idGenerator;
+    constructor(url, transport, delay = 0, timeout, rawErrors = false, idGenerator = createIncrementalIdGenerator()) {
+        super();
+        this.#rawErrors = rawErrors;
+        this.#idGenerator = idGenerator;
+        this.#callbacks = new CallbackRegistry(idGenerator);
+        this.#url = url;
+        this.#delay = delay;
+        this.#timeout = timeout ?? 180_000;
+        this.#transport = transport;
+        this.#transport.onmessage = this.onMessage.bind(this);
+        this.#transport.onclose = this.#onClose.bind(this);
+    }
+    static fromSession(session) {
+        return session.connection();
+    }
+    /**
+     * @internal
+     */
+    get delay() {
+        return this.#delay;
+    }
+    get timeout() {
+        return this.#timeout;
+    }
+    /**
+     * @internal
+     */
+    get _closed() {
+        return this.#closed;
+    }
+    /**
+     * @internal
+     */
+    get _idGenerator() {
+        return this.#idGenerator;
+    }
+    /**
+     * @internal
+     */
+    get _sessions() {
+        return this.#sessions;
+    }
+    /**
+     * @internal
+     */
+    _session(sessionId) {
+        return this.#sessions.get(sessionId) || null;
+    }
+    /**
+     * @param sessionId - The session id
+     * @returns The current CDP session if it exists
+     */
+    session(sessionId) {
+        return this._session(sessionId);
+    }
+    url() {
+        return this.#url;
+    }
+    send(method, params, options) {
+        // There is only ever 1 param arg passed, but the Protocol defines it as an
+        // array of 0 or 1 items See this comment:
+        // https://github.com/ChromeDevTools/devtools-protocol/pull/113#issuecomment-412603285
+        // which explains why the protocol defines the params this way for better
+        // type-inference.
+        // So now we check if there are any params or not and deal with them accordingly.
+        return this._rawSend(this.#callbacks, method, params, undefined, options);
+    }
+    /**
+     * @internal
+     */
+    _rawSend(callbacks, method, params, sessionId, options) {
+        if (this.#closed) {
+            return Promise.reject(new ConnectionClosedError('Connection closed.'));
+        }
+        return callbacks.create(method, options?.timeout ?? this.#timeout, id => {
+            const stringifiedMessage = JSON.stringify({
+                method,
+                params,
+                id,
+                sessionId,
+            });
+            debugProtocolSend(stringifiedMessage);
+            this.#transport.send(stringifiedMessage);
+        });
+    }
+    /**
+     * @internal
+     */
+    async closeBrowser() {
+        await this.send('Browser.close');
+    }
+    /**
+     * @internal
+     */
+    async onMessage(message) {
+        if (this.#delay) {
+            await new Promise(r => {
+                return setTimeout(r, this.#delay);
+            });
+        }
+        debugProtocolReceive(message);
+        const object = JSON.parse(message);
+        if (object.method === 'Target.attachedToTarget') {
+            const sessionId = object.params.sessionId;
+            const session = new CdpCDPSession(this, object.params.targetInfo.type, sessionId, object.sessionId, this.#rawErrors);
+            this.#sessions.set(sessionId, session);
+            this.emit(CDPSessionEvent.SessionAttached, session);
+            const parentSession = this.#sessions.get(object.sessionId);
+            if (parentSession) {
+                parentSession.emit(CDPSessionEvent.SessionAttached, session);
+            }
+        }
+        else if (object.method === 'Target.detachedFromTarget') {
+            const session = this.#sessions.get(object.params.sessionId);
+            if (session) {
+                session.onClosed();
+                this.#sessions.delete(object.params.sessionId);
+                this.emit(CDPSessionEvent.SessionDetached, session);
+                const parentSession = this.#sessions.get(object.sessionId);
+                if (parentSession) {
+                    parentSession.emit(CDPSessionEvent.SessionDetached, session);
+                }
+            }
+        }
+        if (object.sessionId) {
+            const session = this.#sessions.get(object.sessionId);
+            if (session) {
+                session.onMessage(object);
+            }
+        }
+        else if (object.id) {
+            if (object.error) {
+                if (this.#rawErrors) {
+                    this.#callbacks.rejectRaw(object.id, object.error);
+                }
+                else {
+                    this.#callbacks.reject(object.id, createProtocolErrorMessage(object), object.error.message);
+                }
+            }
+            else {
+                this.#callbacks.resolve(object.id, object.result);
+            }
+        }
+        else {
+            this.emit(object.method, object.params);
+        }
+    }
+    #onClose() {
+        if (this.#closed) {
+            return;
+        }
+        this.#closed = true;
+        this.#transport.onmessage = undefined;
+        this.#transport.onclose = undefined;
+        this.#callbacks.clear();
+        for (const session of this.#sessions.values()) {
+            session.onClosed();
+        }
+        this.#sessions.clear();
+        this.emit(CDPSessionEvent.Disconnected, undefined);
+    }
+    dispose() {
+        this.#onClose();
+        this.#transport.close();
+    }
+    /**
+     * @internal
+     */
+    isAutoAttached(targetId) {
+        return !this.#manuallyAttached.has(targetId);
+    }
+    /**
+     * @internal
+     */
+    async _createSession(targetInfo, isAutoAttachEmulated = true) {
+        if (!isAutoAttachEmulated) {
+            this.#manuallyAttached.add(targetInfo.targetId);
+        }
+        const { sessionId } = await this.send('Target.attachToTarget', {
+            targetId: targetInfo.targetId,
+            flatten: true,
+        });
+        this.#manuallyAttached.delete(targetInfo.targetId);
+        const session = this.#sessions.get(sessionId);
+        if (!session) {
+            throw new Error('CDPSession creation failed.');
+        }
+        return session;
+    }
+    /**
+     * @param targetInfo - The target info
+     * @returns The CDP session that is created
+     */
+    async createSession(targetInfo) {
+        return await this._createSession(targetInfo, false);
+    }
+    /**
+     * @internal
+     */
+    getPendingProtocolErrors() {
+        const result = [];
+        result.push(...this.#callbacks.getPendingProtocolErrors());
+        for (const session of this.#sessions.values()) {
+            result.push(...session.getPendingProtocolErrors());
+        }
+        return result;
+    }
+}
+/**
+ * @internal
+ */
+export function isTargetClosedError(error) {
+    return error instanceof TargetCloseError;
+}
+//# sourceMappingURL=Connection.js.map