abelworkflow 1.2.3 → 1.3.0

package/skills/dev-browser/dist/src/client.js

@@ -1,310 +0,0 @@
-import { chromium, } from "playwright";
-import { getSnapshotScript } from "./snapshot/browser-script.js";
-const IGNORED_REQUEST_PATTERNS = [
-    "doubleclick.net",
-    "googlesyndication.com",
-    "googletagmanager.com",
-    "google-analytics.com",
-    "facebook.net",
-    "connect.facebook.net",
-    "analytics",
-    "/ads/",
-    "tracking",
-    "pixel",
-    "hotjar.com",
-    "clarity.ms",
-    "mixpanel.com",
-    "segment.com",
-    "newrelic.com",
-    "nr-data.net",
-    "/tracker/",
-    "/collector/",
-    "/beacon/",
-    "/telemetry/",
-    "/log/",
-    "/events/",
-    "/track.",
-    "/metrics/",
-];
-const NON_CRITICAL_RESOURCE_TYPES = ["img", "image", "icon", "font"];
-/**
- * Wait for a page to finish loading using document.readyState and Playwright request events.
- *
- * Uses browser-use's approach of:
- * - Checking document.readyState for 'complete'
- * - Monitoring pending network requests via Playwright
- * - Filtering out ads, tracking, and non-critical resources
- * - Graceful timeout handling (continues even if timeout reached)
- */
-export async function waitForPageLoad(page, options = {}) {
-    const { timeout = 10000, pollInterval = 50, minimumWait = 100, waitForNetworkIdle = true, } = options;
-    const startTime = Date.now();
-    let lastState = null;
-    const requests = new Map();
-    const trackRequest = (request, startedAt = Date.now()) => {
-        requests.set(request, {
-            url: request.url(),
-            resourceType: request.resourceType(),
-            startedAt,
-        });
-    };
-    const onRequest = (request) => trackRequest(request);
-    const onRequestDone = (request) => requests.delete(request);
-    page.on("request", onRequest);
-    page.on("requestfinished", onRequestDone);
-    page.on("requestfailed", onRequestDone);
-    try {
-        for (const request of await page.requests().catch(() => [])) {
-            const timing = request.timing();
-            if (request.failure() === null && timing.responseEnd === -1) {
-                trackRequest(request, timing.startTime);
-            }
-        }
-        // Wait minimum time first
-        if (minimumWait > 0) {
-            await new Promise((resolve) => setTimeout(resolve, minimumWait));
-        }
-        // Poll until ready or timeout
-        while (Date.now() - startTime < timeout) {
-            try {
-                lastState = await getPageLoadState(page, requests);
-                // Check if document is complete
-                const documentReady = lastState.documentReadyState === "complete";
-                // Check if network is idle (no pending critical requests)
-                const networkIdle = !waitForNetworkIdle || lastState.pendingRequests.length === 0;
-                if (documentReady && networkIdle) {
-                    return {
-                        success: true,
-                        readyState: lastState.documentReadyState,
-                        pendingRequests: lastState.pendingRequests.length,
-                        waitTimeMs: Date.now() - startTime,
-                        timedOut: false,
-                    };
-                }
-            }
-            catch {
-                // Page may be navigating, continue polling
-            }
-            await new Promise((resolve) => setTimeout(resolve, pollInterval));
-        }
-        // Timeout reached - return current state
-        return {
-            success: false,
-            readyState: lastState?.documentReadyState ?? "unknown",
-            pendingRequests: getPendingRequests(requests).length,
-            waitTimeMs: Date.now() - startTime,
-            timedOut: true,
-        };
-    }
-    finally {
-        page.off("request", onRequest);
-        page.off("requestfinished", onRequestDone);
-        page.off("requestfailed", onRequestDone);
-    }
-}
-async function getPageLoadState(page, requests) {
-    const documentReadyState = await page.evaluate(() => {
-        // Access browser globals via globalThis for TypeScript compatibility
-        /* eslint-disable @typescript-eslint/no-explicit-any */
-        const g = globalThis;
-        /* eslint-enable @typescript-eslint/no-explicit-any */
-        return g.document.readyState;
-    });
-    return { documentReadyState, pendingRequests: getPendingRequests(requests) };
-}
-function getPendingRequests(requests) {
-    const now = Date.now();
-    return [...requests.values()].flatMap(({ url, resourceType, startedAt }) => {
-        const loadingDurationMs = now - startedAt;
-        if (shouldIgnoreRequest(url, resourceType, loadingDurationMs))
-            return [];
-        return [{ url, resourceType, loadingDurationMs }];
-    });
-}
-function shouldIgnoreRequest(url, resourceType, loadingDurationMs) {
-    if (IGNORED_REQUEST_PATTERNS.some((pattern) => url.includes(pattern)))
-        return true;
-    if (url.startsWith("data:") || url.length > 500)
-        return true;
-    if (NON_CRITICAL_RESOURCE_TYPES.includes(resourceType) && loadingDurationMs > 3000) {
-        return true;
-    }
-    return /\.(jpg|jpeg|png|gif|webp|svg|ico)(\?|$)/i.test(url) && loadingDurationMs > 3000;
-}
-export async function findPageByTargetId(browser, targetId) {
-    for (const context of browser.contexts()) {
-        for (const page of context.pages()) {
-            let session;
-            try {
-                session = await context.newCDPSession(page);
-                const { targetInfo } = await session.send("Target.getTargetInfo");
-                if (targetInfo.targetId === targetId)
-                    return page;
-            }
-            catch (error) {
-                const message = error instanceof Error ? error.message : String(error);
-                if (!message.includes("Target closed") && !message.includes("Session closed")) {
-                    console.warn(`Unexpected error checking page target: ${message}`);
-                }
-            }
-            finally {
-                await session?.detach().catch(() => undefined);
-            }
-        }
-    }
-    return null;
-}
-export async function connect(serverUrl = "http://localhost:9222") {
-    const normalizedServerUrl = serverUrl.replace(/\/+$/, "");
-    let browser = null;
-    let connectingPromise = null;
-    async function ensureConnected() {
-        // Return existing connection if still active
-        if (browser && browser.isConnected()) {
-            return browser;
-        }
-        // If already connecting, wait for that connection (prevents race condition)
-        if (connectingPromise) {
-            return connectingPromise;
-        }
-        // Start new connection with mutex
-        connectingPromise = (async () => {
-            try {
-                const { wsEndpoint } = await fetchServerInfo(normalizedServerUrl);
-                // Connect to the browser via CDP
-                browser = await chromium.connectOverCDP(wsEndpoint);
-                return browser;
-            }
-            finally {
-                connectingPromise = null;
-            }
-        })();
-        return connectingPromise;
-    }
-    // Helper to get a page by name (used by multiple methods)
-    async function getPage(name, options) {
-        // Request the page from server (creates if doesn't exist)
-        const res = await fetch(`${normalizedServerUrl}/pages`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ name, viewport: options?.viewport }),
-        });
-        if (!res.ok) {
-            throw new Error(`Failed to get page: ${await res.text()}`);
-        }
-        const pageInfo = (await res.json());
-        const { targetId } = pageInfo;
-        // Connect to browser
-        const b = await ensureConnected();
-        const page = await waitForExactPage(b, targetId);
-        if (!page) {
-            throw new Error(`Page "${name}" not found in browser contexts`);
-        }
-        return page;
-    }
-    return {
-        page: getPage,
-        async list() {
-            const res = await fetch(`${normalizedServerUrl}/pages`);
-            const data = (await res.json());
-            return data.pages;
-        },
-        async close(name) {
-            const res = await fetch(`${normalizedServerUrl}/pages/${encodeURIComponent(name)}`, {
-                method: "DELETE",
-            });
-            if (!res.ok) {
-                throw new Error(`Failed to close page: ${await res.text()}`);
-            }
-        },
-        async disconnect() {
-            // Just disconnect the CDP connection - pages persist on server
-            if (browser) {
-                await browser.close();
-                browser = null;
-            }
-        },
-        async getAISnapshot(name) {
-            // Get the page
-            const page = await getPage(name);
-            // Inject the snapshot script and call getAISnapshot
-            const snapshotScript = getSnapshotScript();
-            const snapshot = await page.evaluate((script) => {
-                // Inject script if not already present
-                // Note: page.evaluate runs in browser context where window exists
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const w = globalThis;
-                if (!w.__devBrowser_getAISnapshot) {
-                    // eslint-disable-next-line no-eval
-                    eval(script);
-                }
-                return w.__devBrowser_getAISnapshot();
-            }, snapshotScript);
-            return snapshot;
-        },
-        async selectSnapshotRef(name, ref) {
-            // Get the page
-            const page = await getPage(name);
-            // Find the element using the stored refs
-            const elementHandle = await page.evaluateHandle((refId) => {
-                // Note: page.evaluateHandle runs in browser context where globalThis is the window
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                const w = globalThis;
-                const refs = w.__devBrowserRefs;
-                if (!refs) {
-                    throw new Error("No snapshot refs found. Call getAISnapshot first.");
-                }
-                const element = refs[refId];
-                if (!element) {
-                    throw new Error(`Ref "${refId}" not found. Available refs: ${Object.keys(refs).join(", ")}`);
-                }
-                return element;
-            }, ref);
-            // Check if we got an element
-            const element = elementHandle.asElement();
-            if (!element) {
-                await elementHandle.dispose();
-                return null;
-            }
-            return element;
-        },
-        async getServerInfo() {
-            return fetchServerInfo(normalizedServerUrl);
-        },
-    };
-}
-async function fetchServerInfo(serverUrl) {
-    const res = await fetch(serverUrl);
-    if (!res.ok) {
-        throw new Error(`Server returned ${res.status}: ${await res.text()}`);
-    }
-    return parseServerInfo(await res.json());
-}
-function parseServerInfo(value) {
-    const info = typeof value === "object" && value !== null
-        ? value
-        : {};
-    const mode = info.mode;
-    if (mode !== "standalone" && mode !== "extension") {
-        throw new Error(`Invalid dev-browser server mode: expected "standalone" or "extension", received ${JSON.stringify(mode)}`);
-    }
-    if (typeof info.wsEndpoint !== "string" || info.wsEndpoint.trim().length === 0) {
-        throw new Error(`Invalid dev-browser wsEndpoint: expected a non-empty string, received ${JSON.stringify(info.wsEndpoint)}`);
-    }
-    return {
-        wsEndpoint: info.wsEndpoint,
-        mode,
-        extensionConnected: info.extensionConnected,
-    };
-}
-async function waitForExactPage(browser, targetId) {
-    const deadline = Date.now() + 5000;
-    do {
-        const page = await findPageByTargetId(browser, targetId);
-        if (page)
-            return page;
-        if (Date.now() >= deadline)
-            return null;
-        await new Promise((resolve) => setTimeout(resolve, 25));
-    } while (true);
-}

package/skills/dev-browser/dist/src/entrypoint.d.ts

@@ -1,29 +0,0 @@
-export type EntrypointMode = "standalone" | "extension";
-export interface EntrypointArgs {
-    mode: EntrypointMode;
-    host: string;
-    port: number;
-    cdpPort: number;
-    headless: boolean;
-}
-export interface StandaloneReadinessInfo {
-    mode: "standalone";
-    host: string;
-    port: number;
-    wsEndpoint: string;
-}
-export interface ExtensionReadinessInfo {
-    mode: "extension";
-    host: string;
-    port: number;
-    wsEndpoint: string;
-}
-export type ReadinessInfo = StandaloneReadinessInfo | ExtensionReadinessInfo;
-export declare const DEFAULT_HOST = "localhost";
-export declare function formatHostForUrl(host: string): string;
-export declare function formatHttpUrl(host: string, port: number): string;
-export declare function formatWsUrl(host: string, port: number, path?: string): string;
-export declare function resolveHostForProbe(host: string): string;
-export declare function normalizeLoopbackHost(host: string): string;
-export declare function parseEntrypointArgs(argv: string[], env?: Record<string, string | undefined>): EntrypointArgs;
-export declare function formatReadinessLines(info: ReadinessInfo): string[];

package/skills/dev-browser/dist/src/entrypoint.js

@@ -1,113 +0,0 @@
-import { isIP } from "node:net";
-export const DEFAULT_HOST = "localhost";
-const DEFAULT_PORT = 9222;
-const DEFAULT_CDP_PORT = 9223;
-export function formatHostForUrl(host) {
-    const normalizedHost = host.startsWith("[") && host.endsWith("]") ? host.slice(1, -1) : host;
-    return normalizedHost.includes(":") ? `[${normalizedHost}]` : normalizedHost;
-}
-export function formatHttpUrl(host, port) {
-    return `http://${formatHostForUrl(host)}:${port}`;
-}
-export function formatWsUrl(host, port, path = "") {
-    return `ws://${formatHostForUrl(host)}:${port}${path}`;
-}
-export function resolveHostForProbe(host) {
-    return normalizeLoopbackHost(host);
-}
-export function normalizeLoopbackHost(host) {
-    const normalized = host === "[::1]" ? "::1" : host.toLowerCase();
-    if (normalized === "localhost" || normalized === "::1")
-        return normalized;
-    if (isIP(normalized) === 4 && normalized.split(".")[0] === "127")
-        return normalized;
-    throw new Error(`Invalid host: ${host}. Only loopback hosts are allowed`);
-}
-export function parseEntrypointArgs(argv, env = process.env) {
-    let index = 0;
-    let mode = "standalone";
-    let host = env.HOST ?? DEFAULT_HOST;
-    let port = env.PORT ?? String(DEFAULT_PORT);
-    let portLabel = env.PORT === undefined ? "port" : "PORT";
-    let cdpPort = String(DEFAULT_CDP_PORT);
-    let headless = env.HEADLESS?.trim().toLowerCase() === "true";
-    const first = argv[0];
-    if (first && !first.startsWith("--")) {
-        if (first !== "standalone" && first !== "extension") {
-            throw new Error(`Unknown mode: ${first}`);
-        }
-        mode = first;
-        index = 1;
-    }
-    while (index < argv.length) {
-        const token = argv[index++];
-        switch (token) {
-            case "--headless":
-                if (mode === "extension") {
-                    throw new Error("--headless is only valid in standalone mode");
-                }
-                headless = true;
-                break;
-            case "--host":
-                host = readValue(argv, index - 1);
-                index += 1;
-                break;
-            case "--port":
-                port = readValue(argv, index - 1);
-                portLabel = "port";
-                index += 1;
-                break;
-            case "--cdp-port":
-                if (mode === "extension") {
-                    throw new Error("--cdp-port is only valid in standalone mode");
-                }
-                cdpPort = readValue(argv, index - 1);
-                index += 1;
-                break;
-            default:
-                throw new Error(`Unknown argument: ${token}`);
-        }
-    }
-    return {
-        mode,
-        host: normalizeLoopbackHost(host),
-        port: parsePort(port, portLabel),
-        cdpPort: parsePort(cdpPort, "cdpPort"),
-        headless,
-    };
-}
-export function formatReadinessLines(info) {
-    if (info.mode === "standalone") {
-        return [
-            "Dev browser server started",
-            `  HTTP: ${formatHttpUrl(info.host, info.port)}`,
-            `  WebSocket: ${info.wsEndpoint}`,
-            "",
-            "Ready",
-        ];
-    }
-    return [
-        "CDP relay server started",
-        `  HTTP: ${formatHttpUrl(info.host, info.port)}`,
-        `  CDP endpoint: ${info.wsEndpoint}`,
-        `  Extension endpoint: ${formatWsUrl(info.host, info.port, "/extension")}`,
-        "",
-        "Waiting for extension to connect...",
-    ];
-}
-function readValue(argv, optionIndex) {
-    const value = argv[optionIndex + 1];
-    if (value === undefined || value.startsWith("--")) {
-        throw new Error(`Missing value for ${argv[optionIndex]}`);
-    }
-    return value;
-}
-function parsePort(value, label) {
-    if (!/^\d+$/.test(value))
-        throw new Error(`Invalid ${label}: ${value}`);
-    const port = Number(value);
-    if (port < 1 || port > 65535) {
-        throw new Error(`Invalid ${label}: ${value}`);
-    }
-    return port;
-}

package/skills/dev-browser/dist/src/index.d.ts

@@ -1,3 +0,0 @@
-export { createStandaloneApp, createStandalonePageBackend, serve } from "./standalone.js";
-export type { DevBrowserServer } from "./standalone.js";
-export type { GetPageResponse, ListPagesResponse, ServeOptions, ServerInfoResponse, } from "./types.js";

package/skills/dev-browser/dist/src/index.js

@@ -1 +0,0 @@
-export { createStandaloneApp, createStandalonePageBackend, serve } from "./standalone.js";

package/skills/dev-browser/dist/src/page-api.d.ts

@@ -1,24 +0,0 @@
-import { Hono } from "hono";
-export interface Viewport {
-    width: number;
-    height: number;
-}
-export interface PageDescriptor {
-    name: string;
-    targetId: string;
-}
-export interface PageBackend {
-    list(): Promise<PageDescriptor[]>;
-    getOrCreate(name: string, viewport?: Viewport): Promise<PageDescriptor>;
-    close(name: string): Promise<boolean>;
-}
-type PageBackendStatus = 400 | 404 | 409 | 500 | 502 | 503 | 504;
-export declare class PageBackendError extends Error {
-    readonly status: PageBackendStatus;
-    constructor(status: PageBackendStatus, message: string);
-}
-export declare function createPageApi({ backend, wsEndpoint, }: {
-    backend: PageBackend;
-    wsEndpoint: string;
-}): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
-export {};

package/skills/dev-browser/dist/src/page-api.js

@@ -1,103 +0,0 @@
-import { Hono } from "hono";
-export class PageBackendError extends Error {
-    status;
-    constructor(status, message) {
-        super(message);
-        this.status = status;
-        this.name = "PageBackendError";
-    }
-}
-export function createPageApi({ backend, wsEndpoint, }) {
-    const app = new Hono();
-    app.get("/pages", async (c) => {
-        try {
-            const pages = await backend.list();
-            return c.json({ pages: pages.map(({ name }) => name) });
-        }
-        catch (error) {
-            return backendError(c, error);
-        }
-    });
-    app.post("/pages", async (c) => {
-        const originError = rejectBrowserMutation(c);
-        if (originError)
-            return originError;
-        if (c.req.header("content-type")?.split(";", 1)[0]?.trim().toLowerCase() !== "application/json") {
-            return c.json({ error: "content-type must be application/json" }, 415);
-        }
-        let body;
-        try {
-            body = await c.req.json();
-        }
-        catch {
-            return c.json({ error: "request body must be valid JSON" }, 400);
-        }
-        const validation = validatePageRequest(body);
-        if (typeof validation === "string") {
-            return c.json({ error: validation }, 400);
-        }
-        try {
-            const page = await backend.getOrCreate(validation.name, validation.viewport);
-            return c.json({ wsEndpoint, ...page });
-        }
-        catch (error) {
-            return backendError(c, error);
-        }
-    });
-    app.delete("/pages/:name", async (c) => {
-        const originError = rejectBrowserMutation(c);
-        if (originError)
-            return originError;
-        try {
-            if (!(await backend.close(c.req.param("name")))) {
-                return c.json({ error: "page not found" }, 404);
-            }
-            return c.json({ success: true });
-        }
-        catch (error) {
-            return backendError(c, error);
-        }
-    });
-    return app;
-}
-function rejectBrowserMutation(c) {
-    if (c.req.header("origin") !== undefined) {
-        return c.json({ error: "browser-origin requests are not allowed" }, 403);
-    }
-    return null;
-}
-function validatePageRequest(body) {
-    if (!isRecord(body) || typeof body.name !== "string") {
-        return "name is required and must be a string";
-    }
-    if (body.name.length === 0) {
-        return "name cannot be empty";
-    }
-    if (body.name.length > 256) {
-        return "name must be 256 characters or less";
-    }
-    if (body.viewport === undefined) {
-        return { name: body.name };
-    }
-    if (!isRecord(body.viewport) ||
-        !isPositiveInteger(body.viewport.width) ||
-        !isPositiveInteger(body.viewport.height)) {
-        return "viewport must have positive integer width and height";
-    }
-    return {
-        name: body.name,
-        viewport: { width: body.viewport.width, height: body.viewport.height },
-    };
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isPositiveInteger(value) {
-    return typeof value === "number" && Number.isInteger(value) && value > 0;
-}
-function backendError(c, error) {
-    if (error instanceof PageBackendError) {
-        return c.json({ error: error.message }, error.status);
-    }
-    return c.json({ error: error instanceof Error ? error.message : "internal server error" }, 500);
-}

package/skills/dev-browser/dist/src/relay.d.ts

@@ -1,26 +0,0 @@
-import { type PageBackend } from "./page-api.js";
-import { createTargetRegistry } from "./target-registry.js";
-export interface RelayOptions {
-    port?: number;
-    host?: string;
-    targetTimeoutMs?: number;
-}
-export interface RelayServer {
-    wsEndpoint: string;
-    port: number;
-    stop(): Promise<void>;
-}
-export declare const WEBSOCKET_POLICY_VIOLATION_CODE = 1008;
-export declare const CDP_ORIGIN_POLICY_REASON = "CDP endpoint requires an originless client";
-export declare const EXTENSION_ORIGIN_POLICY_REASON = "Extension endpoint requires originless or chrome-extension client";
-export declare function isTrustedCdpOrigin(origin: string | undefined): boolean;
-export declare function isTrustedExtensionOrigin(origin: string | undefined): boolean;
-type TargetRegistry = ReturnType<typeof createTargetRegistry>;
-export declare function createExtensionPageBackend({ registry, isConnected, sendCommand, timeoutMs, }: {
-    registry: TargetRegistry;
-    isConnected: () => boolean;
-    sendCommand: (method: string, params?: Record<string, unknown>) => Promise<unknown>;
-    timeoutMs: number;
-}): PageBackend;
-export declare function serveRelay(options?: RelayOptions): Promise<RelayServer>;
-export {};