@poe-platform/safe-bash 0.1.695 → 0.1.697

package/dist/safe-playwright-cloudflare/browser-codegen.js

@@ -0,0 +1,26 @@
+import { languageSet } from "./browser-codegen.generated.js";
+const MAX_ACTION_BYTES = 1024 * 1024;
+const MAX_CODE_BYTES = 8 * 1024 * 1024;
+/** Uses the qualified native generators; source strings stay in the CLI renderer. */
+export const generateBrowserActionCode = ({ language, action, }) => {
+    const encoder = new TextEncoder();
+    if (encoder.encode(JSON.stringify(action)).byteLength > MAX_ACTION_BYTES)
+        throw new Error("Playwright code generation input limit exceeded");
+    const id = language === "typescript" ? "playwright-test" : language;
+    const generator = [...languageSet()].find((candidate) => candidate.id === id);
+    if (!generator)
+        throw new Error("Unsupported native code generation language");
+    const code = generator.generateAction({
+        frame: { pageGuid: "page", pageAlias: "page", framePath: [] },
+        startTime: 0,
+        action: { ...action, signals: [] },
+    });
+    if (encoder.encode(code).byteLength > MAX_CODE_BYTES)
+        throw new Error("Playwright code generation output limit exceeded");
+    const lines = code.split("\n");
+    const indents = lines
+        .filter((line) => line.trim())
+        .map((line) => line.length - line.trimStart().length);
+    const indent = indents.length ? Math.min(...indents) : 0;
+    return lines.map((line) => line.substring(indent)).join("\n");
+};

package/dist/safe-playwright-cloudflare/browser-page-cdp.js

@@ -0,0 +1,21 @@
+const sessions = new WeakMap();
+/** Cloudflare resets touch emulation when any page CDP session detaches. Keep
+ * one identity session per live page; page/context destruction releases it.
+ * The owning browser's page limit bounds these sessions. Native frame identity
+ * also unifies the page wrappers used for navigation and run-code. */
+export function browserPageCDP(page) {
+    const frame = page.mainFrame();
+    const existing = sessions.get(frame);
+    if (existing)
+        return existing;
+    const pending = page.context().newCDPSession(page);
+    sessions.set(frame, pending);
+    const forget = () => {
+        if (sessions.get(frame) === pending)
+            sessions.delete(frame);
+        page.off("close", forget);
+    };
+    page.on("close", forget);
+    void pending.catch(forget);
+    return pending;
+}

package/dist/safe-playwright-cloudflare/browser-private-transport.js

@@ -0,0 +1,338 @@
+import { createPlaywrightPrivateTargetTransport, } from "@poe-platform/safe-bash/playwright";
+import { closeBrowserSocket, registerBrowserSocketClose, } from "./browser-socket-closure.js";
+export { waitForBrowserSocketClose } from "./browser-socket-closure.js";
+function targetIdentity(value) {
+    return (typeof value === "string" &&
+        value.length > 0 &&
+        value.length <= 1024 &&
+        !value.includes("\0"));
+}
+function protocolObject(data, maxBytes) {
+    if (typeof data !== "string" ||
+        new TextEncoder().encode(data).length > maxBytes)
+        throw new Error("Private browser frame limit or type violation");
+    const value = JSON.parse(data);
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        throw new Error("Invalid private browser protocol frame");
+    return value;
+}
+export function createBrowserPrivateTransport(options = {}) {
+    const { maxClients = 8, ...guardOptions } = options;
+    const maxTargets = options.maxPrivateTargets ?? 256;
+    const maxBytes = options.maxMessageBytes ?? 16 * 1024 * 1024;
+    const creationTimeoutMs = options.creationTimeoutMs ?? 2000;
+    for (const [name, value] of Object.entries({
+        ...guardOptions,
+        maxClients,
+        maxTargets,
+        maxBytes,
+        creationTimeoutMs,
+    })) {
+        if (!Number.isSafeInteger(value) ||
+            value <= 0 ||
+            (name.endsWith("TimeoutMs") && value > 2147483647))
+            throw new TypeError(`Invalid private browser limit: ${name}`);
+    }
+    const clients = new Set();
+    const rawClosures = new Set();
+    const active = new Set();
+    const retired = new Set();
+    const errors = [];
+    let creation;
+    let closed;
+    let closing;
+    function check() {
+        if (closed)
+            throw closed;
+    }
+    function closeClients(reason) {
+        if (closed)
+            return;
+        closed = reason;
+        if (creation) {
+            creation.deadline.removeEventListener("abort", creation.expire);
+            creation.active = false;
+            creation.failed = true;
+            creation = undefined;
+        }
+        for (const client of [...clients])
+            client.stop();
+        active.clear();
+        retired.clear();
+    }
+    function fail(error) {
+        if (closed)
+            return;
+        const reason = error instanceof Error ? error : new Error(String(error));
+        errors.push(reason);
+        closeClients(reason);
+    }
+    function seed(client) {
+        for (const targetId of retired) {
+            client.guard.beginCreation().commit(targetId);
+            client.upstream.onmessage?.({
+                method: "Target.targetDestroyed",
+                params: { targetId },
+            });
+        }
+        for (const targetId of active)
+            client.guard.beginCreation().commit(targetId);
+        if (creation)
+            creation.tokens.set(client, client.guard.beginCreation());
+    }
+    function closeRejected(socket, error) {
+        try {
+            registerBrowserSocketClose(socket);
+            closeBrowserSocket(socket);
+        }
+        catch (cleanup) {
+            throw new AggregateError([error, cleanup], "Private client admission and cleanup failed");
+        }
+        throw error;
+    }
+    function wrap(socket, signal) {
+        try {
+            check();
+            signal.throwIfAborted();
+        }
+        catch (error) {
+            return closeRejected(socket, error);
+        }
+        if (rawClosures.size >= maxClients)
+            return closeRejected(socket, new Error("Private browser client capacity exceeded"));
+        const pair = new WebSocketPair();
+        const rawClosed = registerBrowserSocketClose(socket, pair[0]);
+        rawClosures.add(rawClosed);
+        void rawClosed.then(() => rawClosures.delete(rawClosed), (error) => {
+            rawClosures.delete(rawClosed);
+            errors.push(error);
+        });
+        const bridge = pair[1];
+        let stopped = false;
+        const upstream = {
+            open() {
+                socket.accept();
+            },
+            send(message) {
+                socket.send(JSON.stringify(message));
+            },
+            close() {
+                client.stop();
+            },
+        };
+        const guard = createPlaywrightPrivateTargetTransport(upstream, guardOptions);
+        const cleanup = (operation) => {
+            try {
+                operation();
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        };
+        const client = {
+            guard,
+            upstream,
+            stop(error) {
+                if (stopped)
+                    return;
+                stopped = true;
+                if (error !== undefined)
+                    errors.push(error);
+                clients.delete(client);
+                creation?.tokens.delete(client);
+                signal.removeEventListener("abort", aborted);
+                socket.removeEventListener("message", incoming);
+                socket.removeEventListener("close", disconnected);
+                socket.removeEventListener("error", socketFailed);
+                bridge.removeEventListener("message", outgoing);
+                bridge.removeEventListener("close", clientClosed);
+                bridge.removeEventListener("error", socketFailed);
+                cleanup(() => guard.transport.close());
+                cleanup(() => closeBrowserSocket(socket));
+                cleanup(() => bridge.close());
+            },
+        };
+        function incoming(event) {
+            try {
+                upstream.onmessage?.(protocolObject(event.data, maxBytes));
+            }
+            catch (error) {
+                client.stop(error);
+            }
+        }
+        function outgoing(event) {
+            try {
+                guard.transport.send(protocolObject(event.data, maxBytes));
+            }
+            catch (error) {
+                client.stop(error);
+            }
+        }
+        function aborted() {
+            client.stop();
+        }
+        function disconnected(event) {
+            client.stop(event.code === 1000
+                ? undefined
+                : new Error(`Private browser disconnected: ${event.code} ${event.reason}`));
+        }
+        function socketFailed() {
+            client.stop(new Error("Private browser socket failed"));
+        }
+        function clientClosed() {
+            client.stop();
+        }
+        guard.transport.onmessage = (message) => {
+            try {
+                bridge.send(JSON.stringify(message));
+            }
+            catch (error) {
+                client.stop(error);
+            }
+        };
+        guard.transport.onclose = (reason) => client.stop(new Error(reason ?? "Private browser transport failed"));
+        try {
+            bridge.accept();
+            clients.add(client);
+            seed(client);
+            signal.addEventListener("abort", aborted, { once: true });
+            socket.addEventListener("message", incoming);
+            socket.addEventListener("close", disconnected);
+            socket.addEventListener("error", socketFailed);
+            bridge.addEventListener("message", outgoing);
+            bridge.addEventListener("close", clientClosed);
+            bridge.addEventListener("error", socketFailed);
+            signal.throwIfAborted();
+            guard.transport.open?.();
+            if (stopped)
+                throw new Error("Private browser closed during admission");
+            return pair[0];
+        }
+        catch (error) {
+            client.stop();
+            throw error;
+        }
+    }
+    function admitIdentity(entry, targetId) {
+        if (!targetIdentity(targetId) ||
+            active.has(targetId) ||
+            retired.has(targetId) ||
+            entry.destroyed.has(targetId)) {
+            const error = new Error("Invalid, reused or destroyed private target identity");
+            fail(error);
+            throw error;
+        }
+        active.add(targetId);
+    }
+    function settleTokens(entry, targetId) {
+        for (const token of entry.tokens.values()) {
+            if (targetId === undefined)
+                token.rollback();
+            else
+                token.commit(targetId);
+        }
+    }
+    function finish(entry, targetId) {
+        check();
+        if (!entry.active || creation !== entry)
+            throw new Error("Private creation is no longer active");
+        if (targetId !== undefined)
+            admitIdentity(entry, targetId);
+        entry.deadline.removeEventListener("abort", entry.expire);
+        entry.active = false;
+        creation = undefined;
+        try {
+            settleTokens(entry, targetId);
+        }
+        catch (error) {
+            entry.failed = true;
+            fail(error);
+            throw error;
+        }
+    }
+    function beginCreation() {
+        check();
+        if (creation)
+            throw new Error("Private target creation already pending");
+        if (active.size >= maxTargets)
+            throw new Error("Private target active capacity exceeded");
+        const entry = {
+            active: true,
+            tokens: new Map(),
+            destroyed: new Set(),
+            deadline: AbortSignal.timeout(creationTimeoutMs),
+            expire: () => fail(new Error("Private target creation identity timed out")),
+        };
+        creation = entry;
+        entry.deadline.addEventListener("abort", entry.expire, { once: true });
+        try {
+            for (const client of clients)
+                entry.tokens.set(client, client.guard.beginCreation());
+        }
+        catch (error) {
+            fail(error);
+            throw error;
+        }
+        return {
+            commit(targetId) {
+                finish(entry, targetId);
+            },
+            rollback() {
+                finish(entry);
+            },
+            fail(error) {
+                if (entry.failed)
+                    return;
+                if (!entry.active || creation !== entry)
+                    throw new Error("Private creation is no longer active");
+                fail(error);
+            },
+        };
+    }
+    function rememberDestroyed(targetId) {
+        if (!creation)
+            return;
+        if (creation.destroyed.size >= maxTargets) {
+            const error = new Error("Private creation retirement capacity exceeded");
+            fail(error);
+            throw error;
+        }
+        creation.destroyed.add(targetId);
+    }
+    function observe(event) {
+        check();
+        if (event.method !== "Target.targetDestroyed")
+            return;
+        const targetId = event.params?.["targetId"];
+        if (!targetIdentity(targetId)) {
+            const error = new Error("Invalid native private retirement identity");
+            fail(error);
+            throw error;
+        }
+        if (!active.delete(targetId)) {
+            rememberDestroyed(targetId);
+            return;
+        }
+        retired.add(targetId);
+        if (retired.size > maxTargets)
+            retired.delete(retired.values().next().value);
+        for (const client of clients)
+            client.upstream.onmessage?.({
+                method: event.method,
+                params: { targetId },
+            });
+    }
+    return {
+        wrap,
+        beginCreation,
+        observe,
+        close() {
+            closeClients(new Error("Private browser coordinator closed"));
+            closing ??= Promise.allSettled([...rawClosures]).then(() => {
+                if (errors.length)
+                    throw new AggregateError([...errors], "Private browser transport cleanup failed");
+            });
+            return closing;
+        },
+    };
+}

package/dist/safe-playwright-cloudflare/browser-profile-runtime.js

@@ -0,0 +1,33 @@
+import { captureRunCodeState, replaceRunCodeContextInitScripts, restoreRunCodePageState, restoreRunCodeTimeouts } from './browser-run-code-native.js';
+import { restoreRunCodeContextState } from './browser-run-code-context-state.js';
+import { parseRunCodeState, serializeRunCodeState } from './browser-run-code-state.js';
+const provider = '@cloudflare/playwright@1.3.6';
+/** Reuse reconnect state transfer, with ordered new pages instead of old target identities. */
+export function browserProfileRuntime(browser, context) {
+    return {
+        async capture(signal) {
+            signal.throwIfAborted();
+            const state = captureRunCodeState(browser, context);
+            serializeRunCodeState(state);
+            return { provider, state };
+        },
+        async restore(value, signal) {
+            signal.throwIfAborted();
+            if (!value || typeof value !== 'object' || !('provider' in value) || value.provider !== provider || !('state' in value))
+                throw new Error('Unsupported Cloudflare browser profile settings');
+            const state = parseRunCodeState(JSON.stringify(value.state));
+            const pages = context.pages();
+            if (state.pages.length !== pages.length && !(state.pages.length === 0 && pages.length === 1))
+                throw new Error('Cloudflare browser profile tab settings mismatch');
+            await restoreRunCodeContextState(context, state.context);
+            restoreRunCodeTimeouts(context, state.contextTimeouts);
+            signal.throwIfAborted();
+            await replaceRunCodeContextInitScripts(browser, context, state.contextInitScripts);
+            for (let index = 0; index < state.pages.length; index++) {
+                signal.throwIfAborted();
+                await restoreRunCodePageState(browser, pages[index], state.pages[index]);
+            }
+            signal.throwIfAborted();
+        },
+    };
+}

package/dist/safe-playwright-cloudflare/browser-run-code-budget.js

@@ -0,0 +1,130 @@
+import { PlaywrightResourceLimitError } from "@poe-platform/safe-bash/playwright";
+export const MAX_RUN_CODE_FRAME_BYTES = 32 * 1024 * 1024;
+export const MAX_RUN_CODE_BYTES = 64 * 1024 * 1024;
+export const MAX_RUN_CODE_FRAMES = 4096;
+export const MAX_RUN_CODE_CONTEXTS = 16;
+export const MAX_RUN_CODE_TARGETS = 64;
+function codePointByteLength(character) {
+    const codePoint = character.codePointAt(0);
+    if (codePoint <= 0x7f)
+        return 1;
+    if (codePoint <= 0x7ff)
+        return 2;
+    return codePoint <= 0xffff ? 3 : 4;
+}
+/** O(n) in code points, O(1) auxiliary memory; never materializes encoded frames. */
+export function frameByteLength(message) {
+    let bytes = 0;
+    for (const character of message) {
+        bytes += codePointByteLength(character);
+        if (bytes > MAX_RUN_CODE_FRAME_BYTES)
+            throw new PlaywrightResourceLimitError("Run-code CDP frame limit exceeded");
+    }
+    return bytes;
+}
+/** O(n) in frame bytes; retained accounting is bounded by the frame limit. */
+export function createRunCodeFrameBudget() {
+    let frames = 0;
+    let bytes = 0;
+    return (message) => {
+        if (typeof message !== "string" ||
+            message.length > MAX_RUN_CODE_FRAME_BYTES)
+            throw new PlaywrightResourceLimitError("Run-code CDP frame limit exceeded");
+        const size = frameByteLength(message);
+        frames++;
+        bytes += size;
+        if (size > MAX_RUN_CODE_FRAME_BYTES ||
+            frames > MAX_RUN_CODE_FRAMES ||
+            bytes > MAX_RUN_CODE_BYTES)
+            throw new PlaywrightResourceLimitError("Run-code CDP transport limit exceeded");
+        const parsed = JSON.parse(message);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            throw new Error("Invalid run-code CDP message");
+        return parsed;
+    };
+}
+/** Reservations count before forwarding, including commands awaiting replies. */
+export function createRunCodeCreationBudget(options) {
+    const pages = new Set(options.pages);
+    const contexts = new Set(options.contexts);
+    const pending = new Map();
+    const disposals = new Map();
+    const groups = {
+        page: { ids: pages, limit: options.maxPages, field: "targetId" },
+        context: {
+            ids: contexts,
+            limit: MAX_RUN_CODE_CONTEXTS,
+            field: "browserContextId",
+        },
+    };
+    const count = (kind) => [...pending.values()].filter((value) => value === kind).length;
+    const reserveDisposal = (message) => {
+        if (!Number.isSafeInteger(message.id) ||
+            pending.has(message.id) ||
+            disposals.has(message.id))
+            throw new Error("Invalid run-code creation command ID");
+        const id = message.params?.["browserContextId"];
+        if (typeof id === "string")
+            disposals.set(message.id, id);
+    };
+    const confirmDisposal = (message) => {
+        const disposed = disposals.get(message.id);
+        if (disposed === undefined)
+            return false;
+        disposals.delete(message.id);
+        if (!message.error)
+            contexts.delete(disposed);
+        return true;
+    };
+    return {
+        command(message) {
+            if (message.method === "Target.disposeBrowserContext") {
+                reserveDisposal(message);
+                return;
+            }
+            const kind = creationKind(message.method);
+            if (!kind)
+                return;
+            if (!Number.isSafeInteger(message.id) ||
+                pending.has(message.id) ||
+                disposals.has(message.id))
+                throw new Error("Invalid run-code creation command ID");
+            const group = groups[kind];
+            if (group.ids.size + count(kind) >= group.limit)
+                throw new PlaywrightResourceLimitError(`Run-code ${kind} limit exceeded`);
+            pending.set(message.id, kind);
+        },
+        reply(message) {
+            if (message.id === undefined)
+                return;
+            if (confirmDisposal(message))
+                return;
+            const kind = pending.get(message.id);
+            if (!kind)
+                return;
+            pending.delete(message.id);
+            if (message.error)
+                return;
+            const group = groups[kind];
+            const id = message.result?.[group.field];
+            if (typeof id !== "string")
+                throw new Error("Invalid CDP creation response");
+            group.ids.add(id);
+        },
+        pageCreated(id) {
+            pages.add(id);
+            if (pages.size > options.maxPages)
+                throw new PlaywrightResourceLimitError("Run-code page limit exceeded");
+        },
+        pageDestroyed(id) {
+            pages.delete(id);
+        },
+    };
+}
+function creationKind(method) {
+    if (method === "Target.createTarget")
+        return "page";
+    if (method === "Target.createBrowserContext")
+        return "context";
+    return undefined;
+}

package/dist/safe-playwright-cloudflare/browser-run-code-context-state.js

@@ -0,0 +1,54 @@
+function header(value) {
+    if (!value ||
+        typeof value !== "object" ||
+        !("name" in value) ||
+        !("value" in value))
+        return false;
+    if (typeof value.name !== "string" || typeof value.value !== "string")
+        return false;
+    try {
+        new Headers([[value.name, value.value]]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function geolocation(value) {
+    if (value === null)
+        return true;
+    if (!value ||
+        typeof value !== "object" ||
+        !("latitude" in value) ||
+        !("longitude" in value))
+        return false;
+    return (typeof value.latitude === "number" &&
+        Number.isFinite(value.latitude) &&
+        Math.abs(value.latitude) <= 90 &&
+        typeof value.longitude === "number" &&
+        Number.isFinite(value.longitude) &&
+        Math.abs(value.longitude) <= 180 &&
+        (!("accuracy" in value) ||
+            (typeof value.accuracy === "number" &&
+                Number.isFinite(value.accuracy) &&
+                value.accuracy >= 0)));
+}
+/** The completion envelope already bounds aggregate bytes; preserve native API ranges. */
+export function isRunCodeContextState(value) {
+    return (!!value &&
+        typeof value === "object" &&
+        "headers" in value &&
+        Array.isArray(value.headers) &&
+        value.headers.every(header) &&
+        "offline" in value &&
+        typeof value.offline === "boolean" &&
+        "geolocation" in value &&
+        geolocation(value.geolocation));
+}
+export async function restoreRunCodeContextState(context, state) {
+    await Promise.all([
+        context.setExtraHTTPHeaders(Object.fromEntries(state.headers.map(({ name, value }) => [name, value]))),
+        context.setOffline(state.offline),
+        context.setGeolocation(state.geolocation),
+    ]);
+}

package/dist/safe-playwright-cloudflare/browser-run-code-contract.js

@@ -0,0 +1 @@
+export const BROWSER_RUN_CODE_URL = "http://fake.host/v1/devtools/browser/owned?persistent=true";