abelworkflow 1.2.3 → 1.3.0

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

@@ -1,567 +0,0 @@
-import { serve } from "@hono/node-server";
-import { createNodeWebSocket } from "@hono/node-ws";
-import { Hono } from "hono";
-import { formatHttpUrl, formatWsUrl, normalizeLoopbackHost } from "./entrypoint.js";
-import { PageBackendError, createPageApi, } from "./page-api.js";
-import { createTargetRegistry, } from "./target-registry.js";
-export const WEBSOCKET_POLICY_VIOLATION_CODE = 1008;
-export const CDP_ORIGIN_POLICY_REASON = "CDP endpoint requires an originless client";
-export const EXTENSION_ORIGIN_POLICY_REASON = "Extension endpoint requires originless or chrome-extension client";
-export function isTrustedCdpOrigin(origin) {
-    return origin === undefined;
-}
-export function isTrustedExtensionOrigin(origin) {
-    if (origin === undefined)
-        return true;
-    try {
-        const url = new URL(origin);
-        return (url.protocol === "chrome-extension:" &&
-            /^[a-p]{32}$/.test(url.hostname) &&
-            (url.pathname === "" || url.pathname === "/") &&
-            url.username === "" &&
-            url.password === "" &&
-            url.port === "" &&
-            url.search === "" &&
-            url.hash === "");
-    }
-    catch {
-        return false;
-    }
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isCdpCommand(value) {
-    return isRecord(value)
-        && typeof value.id === "number"
-        && Number.isFinite(value.id)
-        && typeof value.method === "string"
-        && (value.params === undefined || isRecord(value.params))
-        && (value.sessionId === undefined || typeof value.sessionId === "string");
-}
-function isTargetInfo(value) {
-    return isRecord(value)
-        && typeof value.targetId === "string"
-        && typeof value.type === "string"
-        && typeof value.title === "string"
-        && typeof value.url === "string"
-        && typeof value.attached === "boolean";
-}
-function isExtensionEvent(value) {
-    if (!isRecord(value) || value.method !== "forwardCDPEvent" || !isRecord(value.params)) {
-        return false;
-    }
-    const event = value.params;
-    if (typeof event.method !== "string"
-        || (event.params !== undefined && !isRecord(event.params))
-        || (event.sessionId !== undefined && typeof event.sessionId !== "string")) {
-        return false;
-    }
-    if (event.method === "Target.attachedToTarget") {
-        return isRecord(event.params)
-            && typeof event.params.sessionId === "string"
-            && isTargetInfo(event.params.targetInfo);
-    }
-    if (event.method === "Target.detachedFromTarget") {
-        return isRecord(event.params) && typeof event.params.sessionId === "string";
-    }
-    if (event.method === "Target.targetInfoChanged") {
-        return isRecord(event.params) && isTargetInfo(event.params.targetInfo);
-    }
-    return true;
-}
-export function createExtensionPageBackend({ registry, isConnected, sendCommand, timeoutMs, }) {
-    const pending = new Map();
-    async function create(name) {
-        if (!isConnected())
-            throw new PageBackendError(503, "extension not connected");
-        const result = (await sendCommand("Target.createTarget", { url: "about:blank" }));
-        if (typeof result?.targetId !== "string" || result.targetId.length === 0) {
-            throw new PageBackendError(502, "extension returned an invalid targetId");
-        }
-        if (!isConnected()) {
-            throw new PageBackendError(503, "extension connection closed");
-        }
-        let target;
-        try {
-            target = await registry.waitForAttach(result.targetId, timeoutMs);
-        }
-        catch (error) {
-            if (error instanceof PageBackendError)
-                throw error;
-            const timeout = new PageBackendError(504, errorMessage(error));
-            try {
-                await sendCommand("Target.closeTarget", { targetId: result.targetId });
-            }
-            catch { }
-            throw timeout;
-        }
-        registry.bindName(name, target.targetId);
-        return { name, targetId: target.targetId };
-    }
-    return {
-        async list() {
-            return registry.list();
-        },
-        async getOrCreate(name, viewport) {
-            if (viewport) {
-                throw new PageBackendError(400, "viewport is not supported in extension mode");
-            }
-            const existing = registry.getByName(name);
-            if (existing)
-                return { name, targetId: existing.targetId };
-            const inFlight = pending.get(name);
-            if (inFlight)
-                return inFlight;
-            const creation = create(name);
-            pending.set(name, creation);
-            try {
-                return await creation;
-            }
-            finally {
-                if (pending.get(name) === creation)
-                    pending.delete(name);
-            }
-        },
-        async close(name) {
-            const target = registry.getByName(name);
-            if (!target)
-                return false;
-            if (!isConnected())
-                throw new PageBackendError(503, "extension not connected");
-            const result = (await sendCommand("Target.closeTarget", {
-                targetId: target.targetId,
-            }));
-            if (result?.success !== true) {
-                throw new PageBackendError(502, `extension failed to close target ${target.targetId}`);
-            }
-            if (!isConnected()) {
-                throw new PageBackendError(503, "extension connection closed");
-            }
-            try {
-                await registry.waitForDetach(target.targetId, timeoutMs);
-            }
-            catch (error) {
-                if (error instanceof PageBackendError)
-                    throw error;
-                throw new PageBackendError(504, errorMessage(error));
-            }
-            return true;
-        },
-    };
-}
-export async function serveRelay(options = {}) {
-    const requestedPort = options.port ?? 9222;
-    const host = normalizeLoopbackHost(options.host ?? "127.0.0.1");
-    if (!Number.isInteger(requestedPort) || requestedPort < 1 || requestedPort > 65535) {
-        throw new Error(`Invalid port: ${requestedPort}. Must be between 1 and 65535`);
-    }
-    const targetTimeoutMs = options.targetTimeoutMs ?? 5000;
-    const wsEndpoint = formatWsUrl(host, requestedPort, "/cdp");
-    const registry = createTargetRegistry();
-    const playwrightClients = new Map();
-    const extensionPending = new Map();
-    let extensionWs = null;
-    let extensionMessageId = 0;
-    let virtualSessionId = 0;
-    function log(...args) {
-        console.log("[relay]", ...args);
-    }
-    function isPlaywrightClientOwner(client) {
-        return playwrightClients.get(client.id) === client;
-    }
-    function sendToPlaywright(message, client) {
-        const encoded = JSON.stringify(message);
-        if (client) {
-            if (isPlaywrightClientOwner(client))
-                client.ws.send(encoded);
-            return;
-        }
-        for (const client of playwrightClients.values())
-            client.ws.send(encoded);
-    }
-    function sendAttached(target, client) {
-        const event = {
-            method: "Target.attachedToTarget",
-            params: {
-                sessionId: target.sessionId,
-                targetInfo: { ...target.targetInfo, attached: true },
-                waitingForDebugger: false,
-            },
-        };
-        const clients = client ? [client] : playwrightClients.values();
-        for (const owner of clients) {
-            if (!isPlaywrightClientOwner(owner) || owner.knownTargets.has(target.targetId))
-                continue;
-            owner.knownTargets.add(target.targetId);
-            owner.ws.send(JSON.stringify(event));
-        }
-    }
-    function createSessionAlias(client, physicalSessionId, parentSessionId) {
-        let sessionId;
-        do {
-            sessionId = `dev-browser-virtual-${++virtualSessionId}`;
-        } while (registry.getBySessionId(sessionId) || client.sessionAliases.has(sessionId));
-        client.sessionAliases.set(sessionId, { physicalSessionId, parentSessionId });
-        return sessionId;
-    }
-    function resolveSessionId(client, sessionId) {
-        return sessionId
-            ? (client.sessionAliases.get(sessionId)?.physicalSessionId ?? sessionId)
-            : undefined;
-    }
-    function sendSessionEvent(method, params, sessionId) {
-        for (const client of playwrightClients.values()) {
-            client.ws.send(JSON.stringify({ method, params, sessionId }));
-            if (!sessionId)
-                continue;
-            for (const [alias, binding] of client.sessionAliases) {
-                if (binding.physicalSessionId !== sessionId)
-                    continue;
-                client.ws.send(JSON.stringify({ method, params, sessionId: alias }));
-            }
-        }
-    }
-    function sendDetached(physicalSessionId, params, target) {
-        const physicalParams = { ...params, sessionId: physicalSessionId };
-        for (const client of playwrightClients.values()) {
-            if (target)
-                client.knownTargets.delete(target.targetId);
-            client.ws.send(JSON.stringify({ method: "Target.detachedFromTarget", params: physicalParams }));
-            for (const [alias, binding] of client.sessionAliases) {
-                if (binding.physicalSessionId !== physicalSessionId)
-                    continue;
-                client.sessionAliases.delete(alias);
-                client.ws.send(JSON.stringify({
-                    method: "Target.detachedFromTarget",
-                    params: { ...params, sessionId: alias },
-                    sessionId: binding.parentSessionId,
-                }));
-            }
-        }
-    }
-    function rejectExtensionPending(error) {
-        for (const pending of extensionPending.values())
-            pending.reject(error);
-        extensionPending.clear();
-    }
-    function closePlaywrightClients(reason) {
-        for (const client of playwrightClients.values())
-            client.ws.close(1000, reason);
-        playwrightClients.clear();
-    }
-    function disconnectExtension(error) {
-        rejectExtensionPending(error);
-        registry.disconnect(error);
-        extensionWs = null;
-        closePlaywrightClients(error.message);
-    }
-    function closeInvalidExtension(ws, code, reason) {
-        if (extensionWs === ws) {
-            disconnectExtension(new PageBackendError(502, reason));
-        }
-        ws.close(code, reason);
-    }
-    async function sendToExtension(method, params, timeoutMs = 30_000) {
-        const ws = extensionWs;
-        if (!ws)
-            throw new PageBackendError(503, "extension not connected");
-        const id = ++extensionMessageId;
-        ws.send(JSON.stringify({ id, method, params }));
-        return new Promise((resolve, reject) => {
-            const timer = setTimeout(() => {
-                extensionPending.delete(id);
-                reject(new Error(`Extension request timeout after ${timeoutMs}ms: ${method}`));
-            }, timeoutMs);
-            extensionPending.set(id, {
-                resolve: (result) => {
-                    clearTimeout(timer);
-                    resolve(result);
-                },
-                reject: (error) => {
-                    clearTimeout(timer);
-                    reject(error);
-                },
-            });
-        });
-    }
-    const sendCdpCommand = (method, params) => sendToExtension("forwardCDPCommand", { method, params });
-    const pageBackend = createExtensionPageBackend({
-        registry,
-        isConnected: () => extensionWs !== null,
-        sendCommand: sendCdpCommand,
-        timeoutMs: targetTimeoutMs,
-    });
-    async function routeCdpCommand(client, { method, params, sessionId }) {
-        const physicalSessionId = resolveSessionId(client, sessionId);
-        switch (method) {
-            case "Browser.getVersion":
-                return {
-                    protocolVersion: "1.3",
-                    product: "Chrome/Extension-Bridge",
-                    revision: "1.0.0",
-                    userAgent: "dev-browser-relay/1.0.0",
-                    jsVersion: "V8",
-                };
-            case "Browser.setDownloadBehavior":
-            case "Target.setDiscoverTargets":
-                return {};
-            case "Target.setAutoAttach":
-                if (!sessionId)
-                    return {};
-                break;
-            case "Target.attachToBrowserTarget":
-                return { sessionId: "browser" };
-            case "Target.detachFromTarget": {
-                const detachedSessionId = params?.sessionId;
-                if (typeof detachedSessionId === "string" && client.sessionAliases.delete(detachedSessionId)) {
-                    return {};
-                }
-                if (sessionId === "browser" || params?.sessionId === "browser")
-                    return {};
-                break;
-            }
-            case "Target.attachToTarget": {
-                const targetId = params?.targetId;
-                if (typeof targetId !== "string")
-                    throw new Error("targetId is required");
-                const target = registry.getByTargetId(targetId);
-                if (!target)
-                    throw new Error(`Target ${targetId} not found`);
-                return {
-                    sessionId: createSessionAlias(client, target.sessionId, sessionId),
-                };
-            }
-            case "Target.getTargetInfo": {
-                const targetId = params?.targetId;
-                const target = typeof targetId === "string"
-                    ? registry.getByTargetId(targetId)
-                    : physicalSessionId
-                        ? registry.getBySessionId(physicalSessionId)
-                        : undefined;
-                return { targetInfo: target?.targetInfo };
-            }
-            case "Target.getTargets":
-                return {
-                    targetInfos: registry.targets().map(({ targetInfo }) => ({
-                        ...targetInfo,
-                        attached: true,
-                    })),
-                };
-            case "Target.createTarget":
-            case "Target.closeTarget":
-                return sendCdpCommand(method, params);
-        }
-        return sendToExtension("forwardCDPCommand", {
-            sessionId: physicalSessionId,
-            method,
-            params,
-        });
-    }
-    const app = new Hono();
-    const { injectWebSocket, upgradeWebSocket } = createNodeWebSocket({ app });
-    app.get("/", (c) => c.json({
-        wsEndpoint,
-        extensionConnected: extensionWs !== null,
-        mode: "extension",
-    }));
-    app.route("/", createPageApi({ backend: pageBackend, wsEndpoint }));
-    app.get("/cdp/:clientId?", upgradeWebSocket((c) => {
-        const clientId = c.req.param("clientId") ?? `client-${Date.now()}-${Math.random().toString(36).slice(2)}`;
-        const trustedOrigin = isTrustedCdpOrigin(c.req.header("origin"));
-        return {
-            onOpen(_event, ws) {
-                if (!trustedOrigin) {
-                    ws.close(WEBSOCKET_POLICY_VIOLATION_CODE, CDP_ORIGIN_POLICY_REASON);
-                    return;
-                }
-                if (playwrightClients.has(clientId)) {
-                    ws.close(1000, "Client ID already connected");
-                    return;
-                }
-                playwrightClients.set(clientId, {
-                    id: clientId,
-                    ws,
-                    knownTargets: new Set(),
-                    sessionAliases: new Map(),
-                });
-            },
-            async onMessage(event, ws) {
-                if (!trustedOrigin)
-                    return;
-                let parsed;
-                try {
-                    parsed = JSON.parse(event.data.toString());
-                }
-                catch {
-                    return;
-                }
-                if (!isCdpCommand(parsed))
-                    return;
-                const command = parsed;
-                const { id, method, params, sessionId } = command;
-                const client = playwrightClients.get(clientId);
-                if (!client || client.ws !== ws)
-                    return;
-                if (!extensionWs) {
-                    sendToPlaywright({ id, sessionId, error: { message: "extension not connected" } }, client);
-                    return;
-                }
-                try {
-                    const result = await routeCdpCommand(client, { method, params, sessionId });
-                    if (method === "Target.setAutoAttach" && !sessionId) {
-                        for (const target of registry.targets())
-                            sendAttached(target, client);
-                    }
-                    if (method === "Target.setDiscoverTargets" && params?.discover === true) {
-                        for (const target of registry.targets()) {
-                            sendToPlaywright({
-                                method: "Target.targetCreated",
-                                params: { targetInfo: { ...target.targetInfo, attached: true } },
-                            }, client);
-                        }
-                    }
-                    if (method === "Target.attachToTarget") {
-                        const targetId = params?.targetId;
-                        if (typeof targetId === "string") {
-                            const target = registry.getByTargetId(targetId);
-                            if (target)
-                                sendAttached(target, client);
-                        }
-                    }
-                    sendToPlaywright({ id, sessionId, result }, client);
-                }
-                catch (error) {
-                    sendToPlaywright({ id, sessionId, error: { message: errorMessage(error) } }, client);
-                }
-            },
-            onClose(_event, ws) {
-                if (!trustedOrigin)
-                    return;
-                const client = playwrightClients.get(clientId);
-                if (client?.ws === ws)
-                    playwrightClients.delete(clientId);
-            },
-        };
-    }));
-    app.get("/extension", upgradeWebSocket((c) => {
-        const trustedOrigin = isTrustedExtensionOrigin(c.req.header("origin"));
-        return {
-            onOpen(_event, ws) {
-                if (!trustedOrigin) {
-                    ws.close(WEBSOCKET_POLICY_VIOLATION_CODE, EXTENSION_ORIGIN_POLICY_REASON);
-                    return;
-                }
-                if (extensionWs) {
-                    const old = extensionWs;
-                    disconnectExtension(new PageBackendError(503, "extension connection replaced"));
-                    old.close(4001, "Extension replaced");
-                }
-                extensionWs = ws;
-                log("Extension connected");
-            },
-            onMessage(event, ws) {
-                if (!trustedOrigin)
-                    return;
-                if (extensionWs !== ws)
-                    return;
-                let parsed;
-                try {
-                    parsed = JSON.parse(event.data.toString());
-                }
-                catch {
-                    closeInvalidExtension(ws, 1000, "Invalid JSON");
-                    return;
-                }
-                if (!isRecord(parsed)) {
-                    closeInvalidExtension(ws, 1003, "Invalid extension message");
-                    return;
-                }
-                const message = parsed;
-                if ("id" in message) {
-                    if (typeof message.id !== "number")
-                        return;
-                    const pending = extensionPending.get(message.id);
-                    if (!pending)
-                        return;
-                    extensionPending.delete(message.id);
-                    if (message.error)
-                        pending.reject(new PageBackendError(502, message.error));
-                    else
-                        pending.resolve(message.result);
-                    return;
-                }
-                if (message.method !== "forwardCDPEvent")
-                    return;
-                if (!isExtensionEvent(parsed)) {
-                    closeInvalidExtension(ws, 1003, "Invalid extension message");
-                    return;
-                }
-                const { method, params, sessionId } = parsed.params;
-                if (method === "Target.attachedToTarget") {
-                    const attached = params;
-                    const target = {
-                        sessionId: attached.sessionId,
-                        targetId: attached.targetInfo.targetId,
-                        targetInfo: attached.targetInfo,
-                    };
-                    registry.attach(target);
-                    sendAttached(target);
-                    return;
-                }
-                if (method === "Target.detachedFromTarget") {
-                    const detached = params;
-                    const target = registry.detach(detached.sessionId);
-                    sendDetached(detached.sessionId, detached, target);
-                    return;
-                }
-                if (method === "Target.targetInfoChanged") {
-                    const changed = params;
-                    registry.updateTargetInfo(changed.targetInfo);
-                    sendToPlaywright({ method, params: changed });
-                    return;
-                }
-                sendSessionEvent(method, params, sessionId);
-            },
-            onClose(_event, ws) {
-                if (!trustedOrigin)
-                    return;
-                if (extensionWs !== ws)
-                    return;
-                log("Extension disconnected");
-                disconnectExtension(new PageBackendError(503, "extension connection closed"));
-            },
-        };
-    }));
-    const server = serve({ fetch: app.fetch, port: requestedPort, hostname: host });
-    injectWebSocket(server);
-    await waitForListening(server);
-    log(`HTTP: ${formatHttpUrl(host, requestedPort)}`);
-    let stopped = false;
-    return {
-        wsEndpoint,
-        port: requestedPort,
-        async stop() {
-            if (stopped)
-                return;
-            stopped = true;
-            const ws = extensionWs;
-            disconnectExtension(new PageBackendError(503, "relay server stopped"));
-            ws?.close(1000, "Server stopped");
-            await new Promise((resolve, reject) => {
-                server.close((error) => (error ? reject(error) : resolve()));
-            });
-        },
-    };
-}
-function waitForListening(server) {
-    if (server.listening)
-        return Promise.resolve();
-    return new Promise((resolve, reject) => {
-        server.once("listening", resolve);
-        server.once("error", reject);
-    });
-}
-function errorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}

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

@@ -1,34 +0,0 @@
-export interface TcpPortProbe {
-    once(event: "error" | "listening", listener: () => void): this;
-    listen(port: number, host: string): unknown;
-    close(callback: () => void): unknown;
-}
-export type TcpPortProbeFactory = () => TcpPortProbe;
-export type PlaywrightChromiumExecutableName = "chromium" | "chromium-headless-shell";
-export interface ChromiumInstallCheckOptions {
-    headless: boolean;
-    findExecutable: (name: PlaywrightChromiumExecutableName) => {
-        executablePath: () => string | undefined;
-    } | undefined;
-    exists: (path: string) => boolean;
-}
-export interface RuntimePackageLock {
-    packages?: Record<string, {
-        dependencies?: Record<string, string>;
-        version?: string;
-    }>;
-}
-export interface InvalidRuntimeDependenciesOptions {
-    skillDir: string;
-    lockedDependencies: Record<string, string>;
-    readPackageVersion: (packageJsonPath: string) => string | undefined;
-}
-export declare function assertRuntimeDependenciesAvailable({ invalidDependencies, }: {
-    invalidDependencies: string[];
-}): void;
-export declare function isTcpPortInUse(port: number, host?: string, createProbe?: TcpPortProbeFactory): Promise<boolean>;
-export declare function isPlaywrightChromiumInstalled({ headless, findExecutable, exists, }: ChromiumInstallCheckOptions): boolean;
-export declare function getLockedRuntimeDependencies(lockfile: RuntimePackageLock): Record<string, string>;
-export declare function getInvalidRuntimeDependencies({ skillDir, lockedDependencies, readPackageVersion, }: InvalidRuntimeDependenciesOptions): string[];
-export declare function resolveImportMetaDir(moduleUrl: string): string;
-export declare function resolveSkillDirFromEntrypoint(moduleUrl: string): string;

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

@@ -1,44 +0,0 @@
-import { createServer } from "node:net";
-import { basename, dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-export function assertRuntimeDependenciesAvailable({ invalidDependencies, }) {
-    if (invalidDependencies.length === 0)
-        return;
-    throw new Error(`Runtime dependencies missing or out of date: ${invalidDependencies.join(", ")}. ` +
-        "From the dev-browser skill directory, run: npm ci --omit=dev");
-}
-export async function isTcpPortInUse(port, host = "127.0.0.1", createProbe = createServer) {
-    return await new Promise((resolve) => {
-        const server = createProbe();
-        server.once("error", () => resolve(true));
-        server.once("listening", () => server.close(() => resolve(false)));
-        server.listen(port, host);
-    });
-}
-export function isPlaywrightChromiumInstalled({ headless, findExecutable, exists, }) {
-    const name = headless ? "chromium-headless-shell" : "chromium";
-    const executablePath = findExecutable(name)?.executablePath();
-    return typeof executablePath === "string" && executablePath.length > 0 && exists(executablePath);
-}
-export function getLockedRuntimeDependencies(lockfile) {
-    const packages = lockfile.packages ?? {};
-    return Object.fromEntries(Object.keys(packages[""]?.dependencies ?? {}).map((name) => {
-        const version = packages[`node_modules/${name}`]?.version;
-        if (!version)
-            throw new Error(`Missing locked version for runtime dependency ${name}`);
-        return [name, version];
-    }));
-}
-export function getInvalidRuntimeDependencies({ skillDir, lockedDependencies, readPackageVersion, }) {
-    return Object.entries(lockedDependencies).flatMap(([name, version]) => readPackageVersion(join(skillDir, "node_modules", ...name.split("/"), "package.json")) ===
-        version
-        ? []
-        : [name]);
-}
-export function resolveImportMetaDir(moduleUrl) {
-    return dirname(fileURLToPath(moduleUrl));
-}
-export function resolveSkillDirFromEntrypoint(moduleUrl) {
-    const parentDir = dirname(resolveImportMetaDir(moduleUrl));
-    return basename(parentDir) === "dist" ? dirname(parentDir) : parentDir;
-}

package/skills/dev-browser/dist/src/snapshot/browser-script.d.ts

@@ -1,22 +0,0 @@
-/**
- * Browser-injectable snapshot script.
- *
- * This module provides the snapshot functionality as a string that can be
- * injected into the browser via page.addScriptTag() or page.evaluate().
- *
- * The approach is to read the compiled JavaScript at runtime and bundle it
- * into a single script that exposes window.__devBrowser_getAISnapshot() and
- * window.__devBrowser_selectSnapshotRef().
- */
-/**
- * Get the snapshot script that can be injected into the browser.
- * Returns a self-contained JavaScript string that:
- * 1. Defines all necessary functions (domUtils, roleUtils, yaml, ariaSnapshot)
- * 2. Exposes window.__devBrowser_getAISnapshot()
- * 3. Exposes window.__devBrowser_selectSnapshotRef()
- */
-export declare function getSnapshotScript(): string;
-/**
- * Clear the cached script (useful for development/testing)
- */
-export declare function clearSnapshotScriptCache(): void;