conductor-oss 0.3.3 → 0.4.0

package/web/.next/standalone/node_modules/puppeteer-core/lib/esm/puppeteer/node/ScreenRecorder.js

@@ -0,0 +1,279 @@
+/**
+ * @license
+ * Copyright 2023 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __setFunctionName = (this && this.__setFunctionName) || function (f, name, prefix) {
+    if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
+    return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
+};
+import { spawn, spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import os from 'node:os';
+import { dirname } from 'node:path';
+import { PassThrough } from 'node:stream';
+import debug from 'debug';
+import { bufferCount, concatMap, filter, from, fromEvent, lastValueFrom, map, takeUntil, tap, } from '../../third_party/rxjs/rxjs.js';
+import { CDPSessionEvent } from '../api/CDPSession.js';
+import { debugError, fromEmitterEvent } from '../common/util.js';
+import { guarded } from '../util/decorators.js';
+import { asyncDisposeSymbol } from '../util/disposable.js';
+const CRF_VALUE = 30;
+const DEFAULT_FPS = 30;
+const debugFfmpeg = debug('puppeteer:ffmpeg');
+/**
+ * @public
+ */
+let ScreenRecorder = (() => {
+    let _classSuper = PassThrough;
+    let _instanceExtraInitializers = [];
+    let _private_writeFrame_decorators;
+    let _private_writeFrame_descriptor;
+    let _stop_decorators;
+    return class ScreenRecorder extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            __esDecorate(this, _private_writeFrame_descriptor = { value: __setFunctionName(async function (buffer) {
+                    const error = await new Promise(resolve => {
+                        this.#process.stdin.write(buffer, resolve);
+                    });
+                    if (error) {
+                        console.log(`ffmpeg failed to write: ${error.message}.`);
+                    }
+                }, "#writeFrame") }, _private_writeFrame_decorators, { kind: "method", name: "#writeFrame", static: false, private: true, access: { has: obj => #writeFrame in obj, get: obj => obj.#writeFrame }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _stop_decorators, { kind: "method", name: "stop", static: false, private: false, access: { has: obj => "stop" in obj, get: obj => obj.stop }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        #page = __runInitializers(this, _instanceExtraInitializers);
+        #process;
+        #controller = new AbortController();
+        #lastFrame;
+        #fps;
+        /**
+         * @internal
+         */
+        constructor(page, width, height, { ffmpegPath, speed, scale, crop, format, fps, loop, delay, quality, colors, path, overwrite, } = {}) {
+            super({ allowHalfOpen: false });
+            ffmpegPath ??= 'ffmpeg';
+            format ??= 'webm';
+            fps ??= DEFAULT_FPS;
+            // Maps 0 to -1 as ffmpeg maps 0 to infinity.
+            loop ||= -1;
+            delay ??= -1;
+            quality ??= CRF_VALUE;
+            colors ??= 256;
+            overwrite ??= true;
+            this.#fps = fps;
+            // Tests if `ffmpeg` exists.
+            const { error } = spawnSync(ffmpegPath);
+            if (error) {
+                throw error;
+            }
+            const filters = [
+                `crop='min(${width},iw):min(${height},ih):0:0'`,
+                `pad=${width}:${height}:0:0`,
+            ];
+            if (speed) {
+                filters.push(`setpts=${1 / speed}*PTS`);
+            }
+            if (crop) {
+                filters.push(`crop=${crop.width}:${crop.height}:${crop.x}:${crop.y}`);
+            }
+            if (scale) {
+                filters.push(`scale=iw*${scale}:-1:flags=lanczos`);
+            }
+            const formatArgs = this.#getFormatArgs(format, fps, loop, delay, quality, colors);
+            const vf = formatArgs.indexOf('-vf');
+            if (vf !== -1) {
+                filters.push(formatArgs.splice(vf, 2).at(-1) ?? '');
+            }
+            // Ensure provided output directory path exists.
+            if (path) {
+                fs.mkdirSync(dirname(path), { recursive: overwrite });
+            }
+            this.#process = spawn(ffmpegPath, 
+            // See https://trac.ffmpeg.org/wiki/Encode/VP9 for more information on flags.
+            [
+                ['-loglevel', 'error'],
+                // Reduces general buffering.
+                ['-avioflags', 'direct'],
+                // Reduces initial buffering while analyzing input fps and other stats.
+                [
+                    '-fpsprobesize',
+                    '0',
+                    '-probesize',
+                    '32',
+                    '-analyzeduration',
+                    '0',
+                    '-fflags',
+                    'nobuffer',
+                ],
+                // Forces input to be read from standard input, and forces png input
+                // image format.
+                ['-f', 'image2pipe', '-vcodec', 'png', '-i', 'pipe:0'],
+                // No audio
+                ['-an'],
+                // This drastically reduces stalling when cpu is overbooked. By default
+                // VP9 tries to use all available threads?
+                ['-threads', '1'],
+                // Specifies the frame rate we are giving ffmpeg.
+                ['-framerate', `${fps}`],
+                // Disable bitrate.
+                ['-b:v', '0'],
+                // Specifies the encoding and format we are using.
+                formatArgs,
+                // Filters to ensure the images are piped correctly,
+                // combined with any format-specific filters.
+                ['-vf', filters.join()],
+                // Overwrite output, or exit immediately if file already exists.
+                [overwrite ? '-y' : '-n'],
+                'pipe:1',
+            ].flat(), { stdio: ['pipe', 'pipe', 'pipe'] });
+            this.#process.stdout.pipe(this);
+            this.#process.stderr.on('data', (data) => {
+                debugFfmpeg(data.toString('utf8'));
+            });
+            this.#page = page;
+            const { client } = this.#page.mainFrame();
+            client.once(CDPSessionEvent.Disconnected, () => {
+                void this.stop().catch(debugError);
+            });
+            this.#lastFrame = lastValueFrom(fromEmitterEvent(client, 'Page.screencastFrame').pipe(tap(event => {
+                void client.send('Page.screencastFrameAck', {
+                    sessionId: event.sessionId,
+                });
+            }), filter(event => {
+                return event.metadata.timestamp !== undefined;
+            }), map(event => {
+                return {
+                    buffer: Buffer.from(event.data, 'base64'),
+                    timestamp: event.metadata.timestamp,
+                };
+            }), bufferCount(2, 1), concatMap(([{ timestamp: previousTimestamp, buffer }, { timestamp }]) => {
+                return from(Array(Math.round(fps * Math.max(timestamp - previousTimestamp, 0))).fill(buffer));
+            }), map(buffer => {
+                void this.#writeFrame(buffer);
+                return [buffer, performance.now()];
+            }), takeUntil(fromEvent(this.#controller.signal, 'abort'))), { defaultValue: [Buffer.from([]), performance.now()] });
+        }
+        #getFormatArgs(format, fps, loop, delay, quality, colors) {
+            const libvpx = [
+                ['-vcodec', 'vp9'],
+                // Sets the quality. Lower the better.
+                ['-crf', `${quality}`],
+                // Sets the quality and how efficient the compression will be.
+                [
+                    '-deadline',
+                    'realtime',
+                    '-cpu-used',
+                    `${Math.min(os.cpus().length / 2, 8)}`,
+                ],
+            ];
+            switch (format) {
+                case 'webm':
+                    return [
+                        ...libvpx,
+                        // Sets the format
+                        ['-f', 'webm'],
+                    ].flat();
+                case 'gif':
+                    fps = DEFAULT_FPS === fps ? 20 : 'source_fps';
+                    if (loop === Infinity) {
+                        loop = 0;
+                    }
+                    if (delay !== -1) {
+                        // ms to cs
+                        delay /= 10;
+                    }
+                    return [
+                        // Sets the frame rate and uses a custom palette generated from the
+                        // input.
+                        [
+                            '-vf',
+                            `fps=${fps},split[s0][s1];[s0]palettegen=stats_mode=diff:max_colors=${colors}[p];[s1][p]paletteuse=dither=bayer`,
+                        ],
+                        // Sets the number of times to loop playback.
+                        ['-loop', `${loop}`],
+                        // Sets the delay between iterations of a loop.
+                        ['-final_delay', `${delay}`],
+                        // Sets the format
+                        ['-f', 'gif'],
+                    ].flat();
+                case 'mp4':
+                    return [
+                        ...libvpx,
+                        // Fragment file during stream to avoid errors.
+                        ['-movflags', 'hybrid_fragmented'],
+                        // Sets the format
+                        ['-f', 'mp4'],
+                    ].flat();
+            }
+        }
+        get #writeFrame() { return _private_writeFrame_descriptor.value; }
+        /**
+         * Stops the recorder.
+         *
+         * @public
+         */
+        async stop() {
+            if (this.#controller.signal.aborted) {
+                return;
+            }
+            // Stopping the screencast will flush the frames.
+            await this.#page._stopScreencast().catch(debugError);
+            this.#controller.abort();
+            // Repeat the last frame for the remaining frames.
+            const [buffer, timestamp] = await this.#lastFrame;
+            await Promise.all(Array(Math.max(1, Math.round((this.#fps * (performance.now() - timestamp)) / 1000)))
+                .fill(buffer)
+                .map(this.#writeFrame.bind(this)));
+            // Close stdin to notify FFmpeg we are done.
+            this.#process.stdin.end();
+            await new Promise(resolve => {
+                this.#process.once('close', resolve);
+            });
+        }
+        /**
+         * @internal
+         */
+        async [(_private_writeFrame_decorators = [guarded()], _stop_decorators = [guarded()], asyncDisposeSymbol)]() {
+            await this.stop();
+        }
+    };
+})();
+export { ScreenRecorder };
+//# sourceMappingURL=ScreenRecorder.js.map

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

@@ -0,0 +1,12 @@
+/**
+ * @license
+ * Copyright 2022 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export * from './ChromeLauncher.js';
+export * from './FirefoxLauncher.js';
+export * from './PipeTransport.js';
+export * from './BrowserLauncher.js';
+export * from './PuppeteerNode.js';
+export * from './ScreenRecorder.js';
+//# sourceMappingURL=node.js.map

package/web/.next/standalone/node_modules/puppeteer-core/lib/esm/puppeteer/node/util/fs.js

@@ -0,0 +1,24 @@
+/**
+ * @license
+ * Copyright 2023 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import fs from 'node:fs';
+const rmOptions = {
+    force: true,
+    recursive: true,
+    maxRetries: 5,
+};
+/**
+ * @internal
+ */
+export async function rm(path) {
+    await fs.promises.rm(path, rmOptions);
+}
+/**
+ * @internal
+ */
+export function rmSync(path) {
+    fs.rmSync(path, rmOptions);
+}
+//# sourceMappingURL=fs.js.map

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

@@ -0,0 +1,41 @@
+/**
+ * @license
+ * Copyright 2017 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+export * from './index.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import { environment } from './environment.js';
+import * as Puppeteer from './index.js';
+// Set up Node-specific environment dependencies.
+environment.value = {
+    fs,
+    path,
+    ScreenRecorder: Puppeteer.ScreenRecorder,
+};
+/**
+ * @public
+ */
+const puppeteer = new Puppeteer.PuppeteerNode({
+    isPuppeteerCore: true,
+});
+export const { 
+/**
+ * @public
+ */
+connect, 
+/**
+ * @public
+ */
+defaultArgs, 
+/**
+ * @public
+ */
+executablePath, 
+/**
+ * @public
+ */
+launch, } = puppeteer;
+export default puppeteer;
+//# sourceMappingURL=puppeteer-core.js.map

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

@@ -0,0 +1,14 @@
+/**
+ * @license
+ * Copyright 2020 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @internal
+ */
+export const PUPPETEER_REVISIONS = Object.freeze({
+    chrome: '146.0.7680.31',
+    'chrome-headless-shell': '146.0.7680.31',
+    firefox: 'stable_148.0',
+});
+//# sourceMappingURL=revisions.js.map

package/web/.next/standalone/node_modules/puppeteer-core/lib/esm/puppeteer/util/AsyncIterableUtil.js

@@ -0,0 +1,29 @@
+/**
+ * @internal
+ */
+export class AsyncIterableUtil {
+    static async *map(iterable, map) {
+        for await (const value of iterable) {
+            yield await map(value);
+        }
+    }
+    static async *flatMap(iterable, map) {
+        for await (const value of iterable) {
+            yield* map(value);
+        }
+    }
+    static async collect(iterable) {
+        const result = [];
+        for await (const value of iterable) {
+            result.push(value);
+        }
+        return result;
+    }
+    static async first(iterable) {
+        for await (const value of iterable) {
+            return value;
+        }
+        return;
+    }
+}
+//# sourceMappingURL=AsyncIterableUtil.js.map

package/web/.next/standalone/node_modules/puppeteer-core/lib/esm/puppeteer/util/Deferred.js

@@ -0,0 +1,105 @@
+/**
+ * @license
+ * Copyright 2024 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { TimeoutError } from '../common/Errors.js';
+/**
+ * Creates and returns a deferred object along with the resolve/reject functions.
+ *
+ * If the deferred has not been resolved/rejected within the `timeout` period,
+ * the deferred gets resolves with a timeout error. `timeout` has to be greater than 0 or
+ * it is ignored.
+ *
+ * @internal
+ */
+export class Deferred {
+    static create(opts) {
+        return new Deferred(opts);
+    }
+    static async race(awaitables) {
+        const deferredWithTimeout = new Set();
+        try {
+            const promises = awaitables.map(value => {
+                if (value instanceof Deferred) {
+                    if (value.#timeoutId) {
+                        deferredWithTimeout.add(value);
+                    }
+                    return value.valueOrThrow();
+                }
+                return value;
+            });
+            // eslint-disable-next-line no-restricted-syntax
+            return await Promise.race(promises);
+        }
+        finally {
+            for (const deferred of deferredWithTimeout) {
+                // We need to stop the timeout else
+                // Node.JS will keep running the event loop till the
+                // timer executes
+                deferred.reject(new Error('Timeout cleared'));
+            }
+        }
+    }
+    #isResolved = false;
+    #isRejected = false;
+    #value;
+    // SAFETY: This is ensured by #taskPromise.
+    #resolve;
+    // TODO: Switch to Promise.withResolvers with Node 22
+    #taskPromise = new Promise(resolve => {
+        this.#resolve = resolve;
+    });
+    #timeoutId;
+    #timeoutError;
+    constructor(opts) {
+        if (opts && opts.timeout > 0) {
+            this.#timeoutError = new TimeoutError(opts.message);
+            this.#timeoutId = setTimeout(() => {
+                this.reject(this.#timeoutError);
+            }, opts.timeout);
+        }
+    }
+    #finish(value) {
+        clearTimeout(this.#timeoutId);
+        this.#value = value;
+        this.#resolve();
+    }
+    resolve(value) {
+        if (this.#isRejected || this.#isResolved) {
+            return;
+        }
+        this.#isResolved = true;
+        this.#finish(value);
+    }
+    reject(error) {
+        if (this.#isRejected || this.#isResolved) {
+            return;
+        }
+        this.#isRejected = true;
+        this.#finish(error);
+    }
+    resolved() {
+        return this.#isResolved;
+    }
+    finished() {
+        return this.#isResolved || this.#isRejected;
+    }
+    value() {
+        return this.#value;
+    }
+    #promise;
+    valueOrThrow() {
+        if (!this.#promise) {
+            this.#promise = (async () => {
+                await this.#taskPromise;
+                if (this.#isRejected) {
+                    throw this.#value;
+                }
+                return this.#value;
+            })();
+        }
+        return this.#promise;
+    }
+}
+//# sourceMappingURL=Deferred.js.map

package/web/.next/standalone/node_modules/puppeteer-core/lib/esm/puppeteer/util/ErrorLike.js

@@ -0,0 +1,41 @@
+/**
+ * @license
+ * Copyright 2022 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @internal
+ */
+export function isErrorLike(obj) {
+    return (typeof obj === 'object' && obj !== null && 'name' in obj && 'message' in obj);
+}
+/**
+ * @internal
+ */
+export function isErrnoException(obj) {
+    return (isErrorLike(obj) &&
+        ('errno' in obj || 'code' in obj || 'path' in obj || 'syscall' in obj));
+}
+/**
+ * @internal
+ */
+export function rewriteError(error, message, originalMessage) {
+    error.message = message;
+    error.originalMessage = originalMessage ?? error.originalMessage;
+    return error;
+}
+/**
+ * @internal
+ */
+export function createProtocolErrorMessage(object) {
+    let message = object.error.message;
+    // TODO: remove the type checks when we stop connecting to BiDi with a CDP
+    // client.
+    if (object.error &&
+        typeof object.error === 'object' &&
+        'data' in object.error) {
+        message += ` ${object.error.data}`;
+    }
+    return message;
+}
+//# sourceMappingURL=ErrorLike.js.map

package/web/.next/standalone/node_modules/puppeteer-core/lib/esm/puppeteer/util/Function.js

@@ -0,0 +1,70 @@
+/**
+ * @license
+ * Copyright 2023 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const createdFunctions = new Map();
+/**
+ * Creates a function from a string.
+ *
+ * @internal
+ */
+export const createFunction = (functionValue) => {
+    let fn = createdFunctions.get(functionValue);
+    if (fn) {
+        return fn;
+    }
+    fn = new Function(`return ${functionValue}`)();
+    createdFunctions.set(functionValue, fn);
+    return fn;
+};
+/**
+ * @internal
+ */
+export function stringifyFunction(fn) {
+    let value = fn.toString();
+    if (value.match(/^(async )*function(\(|\s)/) ||
+        value.match(/^(async )*function\s*\*\s*/)) {
+        return value;
+    }
+    const isArrow = value.startsWith('(') ||
+        value.match(/^async\s*\(/) ||
+        value.match(/^(async)*\s*(?:[$_\p{ID_Start}])(?:[$\u200C\u200D\p{ID_Continue}])*\s*=>/u);
+    if (isArrow) {
+        return value;
+    }
+    // This means we might have a function shorthand (e.g. `test(){}`). Let's
+    // try prefixing.
+    let prefix = 'function ';
+    if (value.startsWith('async ')) {
+        prefix = `async ${prefix}`;
+        value = value.substring('async '.length);
+    }
+    return `${prefix}${value}`;
+}
+/**
+ * Replaces `PLACEHOLDER`s with the given replacements.
+ *
+ * All replacements must be valid JS code.
+ *
+ * @example
+ *
+ * ```ts
+ * interpolateFunction(() => PLACEHOLDER('test'), {test: 'void 0'});
+ * // Equivalent to () => void 0
+ * ```
+ *
+ * @internal
+ */
+export const interpolateFunction = (fn, replacements) => {
+    let value = stringifyFunction(fn);
+    for (const [name, jsValue] of Object.entries(replacements)) {
+        value = value.replace(new RegExp(`PLACEHOLDER\\(\\s*(?:'${name}'|"${name}")\\s*\\)`, 'g'), 
+        // Wrapping this ensures tersers that accidentally inline PLACEHOLDER calls
+        // are still valid. Without, we may get calls like ()=>{...}() which is
+        // not valid.
+        `(${jsValue})`);
+    }
+    return createFunction(value);
+};
+//# sourceMappingURL=Function.js.map

package/web/.next/standalone/node_modules/puppeteer-core/lib/esm/puppeteer/util/Mutex.js

@@ -0,0 +1,46 @@
+/**
+ * @license
+ * Copyright 2024 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { Deferred } from './Deferred.js';
+import { disposeSymbol } from './disposable.js';
+/**
+ * @internal
+ */
+export class Mutex {
+    static Guard = class Guard {
+        #mutex;
+        #onRelease;
+        constructor(mutex, onRelease) {
+            this.#mutex = mutex;
+            this.#onRelease = onRelease;
+        }
+        [disposeSymbol]() {
+            this.#onRelease?.();
+            return this.#mutex.release();
+        }
+    };
+    #locked = false;
+    #acquirers = [];
+    // This is FIFO.
+    async acquire(onRelease) {
+        if (!this.#locked) {
+            this.#locked = true;
+            return new Mutex.Guard(this);
+        }
+        const deferred = Deferred.create();
+        this.#acquirers.push(deferred.resolve.bind(deferred));
+        await deferred.valueOrThrow();
+        return new Mutex.Guard(this, onRelease);
+    }
+    release() {
+        const resolve = this.#acquirers.shift();
+        if (!resolve) {
+            this.#locked = false;
+            return;
+        }
+        resolve();
+    }
+}
+//# sourceMappingURL=Mutex.js.map

package/web/.next/standalone/node_modules/puppeteer-core/lib/esm/puppeteer/util/assert.js

@@ -0,0 +1,18 @@
+/**
+ * @license
+ * Copyright 2020 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * Asserts that the given value is truthy.
+ * @param value - some conditional statement
+ * @param message - the error message to throw if the value is not truthy.
+ *
+ * @internal
+ */
+export const assert = (value, message) => {
+    if (!value) {
+        throw new Error(message);
+    }
+};
+//# sourceMappingURL=assert.js.map