abelworkflow 1.2.3 → 1.3.0

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

@@ -1,13 +0,0 @@
-/**
- * ARIA Snapshot module for dev-browser.
- *
- * Provides Playwright-compatible ARIA snapshots with cross-connection ref persistence.
- * Refs are stored on window.__devBrowserRefs and survive across Playwright reconnections.
- *
- * Usage:
- *   import { getSnapshotScript } from './snapshot';
- *   const script = getSnapshotScript();
- *   await page.evaluate(script);
- *   // Now window.__devBrowser_getAISnapshot() and window.__devBrowser_selectSnapshotRef(ref) are available
- */
-export { getSnapshotScript, clearSnapshotScriptCache } from "./browser-script.js";

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

@@ -1,13 +0,0 @@
-/**
- * ARIA Snapshot module for dev-browser.
- *
- * Provides Playwright-compatible ARIA snapshots with cross-connection ref persistence.
- * Refs are stored on window.__devBrowserRefs and survive across Playwright reconnections.
- *
- * Usage:
- *   import { getSnapshotScript } from './snapshot';
- *   const script = getSnapshotScript();
- *   await page.evaluate(script);
- *   // Now window.__devBrowser_getAISnapshot() and window.__devBrowser_selectSnapshotRef(ref) are available
- */
-export { getSnapshotScript, clearSnapshotScriptCache } from "./browser-script.js";

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

@@ -1,12 +0,0 @@
-/**
- * Injectable snapshot script for browser context.
- *
- * This module provides the getSnapshotScript function that returns a
- * self-contained JavaScript string for injection into browser contexts.
- *
- * The script is injected via page.evaluate() and exposes:
- * - window.__devBrowser_getAISnapshot(): Returns ARIA snapshot YAML
- * - window.__devBrowser_selectSnapshotRef(ref): Returns element for given ref
- * - window.__devBrowserRefs: Map of ref -> Element (persists across connections)
- */
-export { getSnapshotScript, clearSnapshotScriptCache } from "./browser-script.js";

package/skills/dev-browser/dist/src/snapshot/inject.js

@@ -1,12 +0,0 @@
-/**
- * Injectable snapshot script for browser context.
- *
- * This module provides the getSnapshotScript function that returns a
- * self-contained JavaScript string for injection into browser contexts.
- *
- * The script is injected via page.evaluate() and exposes:
- * - window.__devBrowser_getAISnapshot(): Returns ARIA snapshot YAML
- * - window.__devBrowser_selectSnapshotRef(ref): Returns element for given ref
- * - window.__devBrowserRefs: Map of ref -> Element (persists across connections)
- */
-export { getSnapshotScript, clearSnapshotScriptCache } from "./browser-script.js";

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

@@ -1,31 +0,0 @@
-import { Hono } from "hono";
-import { type PageBackend, type Viewport } from "./page-api.js";
-import type { ServeOptions } from "./types.js";
-export interface DevBrowserServer {
-    wsEndpoint: string;
-    port: number;
-    stop: () => Promise<void>;
-}
-interface StandalonePage {
-    setViewportSize(viewport: Viewport): Promise<void>;
-    close(): Promise<void>;
-    on(event: "close", listener: () => void): void;
-}
-interface StandaloneContext {
-    newPage(): Promise<StandalonePage>;
-    newCDPSession(page: StandalonePage): Promise<{
-        send(method: "Target.getTargetInfo"): Promise<{
-            targetInfo: {
-                targetId: string;
-            };
-        }>;
-        detach(): Promise<void>;
-    }>;
-}
-export declare function createStandalonePageBackend(context: StandaloneContext): PageBackend;
-export declare function createStandaloneApp({ backend, wsEndpoint, }: {
-    backend: PageBackend;
-    wsEndpoint: string;
-}): Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
-export declare function serve(options?: ServeOptions): Promise<DevBrowserServer>;
-export type { ServeOptions } from "./types.js";

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

@@ -1,173 +0,0 @@
-import { once } from "node:events";
-import { serve as serveNode } from "@hono/node-server";
-import { Hono } from "hono";
-import { chromium } from "playwright";
-import { formatHttpUrl, normalizeLoopbackHost } from "./entrypoint.js";
-import { createPageApi, } from "./page-api.js";
-export function createStandalonePageBackend(context) {
-    const pages = new Map();
-    const pending = new Map();
-    async function create(name, viewport) {
-        const pagePromise = context.newPage();
-        let page;
-        try {
-            page = await withTimeout(pagePromise, 30_000, "Page creation timed out after 30000ms");
-        }
-        catch (error) {
-            void pagePromise.then((latePage) => latePage.close().catch(() => undefined), () => undefined);
-            throw error;
-        }
-        try {
-            if (viewport)
-                await page.setViewportSize(viewport);
-            const session = await context.newCDPSession(page);
-            let targetId;
-            try {
-                ({ targetInfo: { targetId } } = await session.send("Target.getTargetInfo"));
-            }
-            finally {
-                await session.detach();
-            }
-            const entry = { name, targetId, page };
-            pages.set(name, entry);
-            page.on("close", () => {
-                if (pages.get(name) === entry)
-                    pages.delete(name);
-            });
-            return { name, targetId };
-        }
-        catch (error) {
-            await page.close().catch(() => undefined);
-            throw error;
-        }
-    }
-    return {
-        async list() {
-            return [...pages.values()].map(({ name, targetId }) => ({ name, targetId }));
-        },
-        async getOrCreate(name, viewport) {
-            const existing = pages.get(name);
-            if (existing)
-                return { name, targetId: existing.targetId };
-            const inFlight = pending.get(name);
-            if (inFlight)
-                return inFlight;
-            const creation = create(name, viewport);
-            pending.set(name, creation);
-            try {
-                return await creation;
-            }
-            finally {
-                if (pending.get(name) === creation)
-                    pending.delete(name);
-            }
-        },
-        async close(name) {
-            const entry = pages.get(name);
-            if (!entry)
-                return false;
-            await entry.page.close();
-            if (pages.get(name) === entry)
-                pages.delete(name);
-            return true;
-        },
-    };
-}
-export function createStandaloneApp({ backend, wsEndpoint, }) {
-    const app = new Hono();
-    app.get("/", (c) => c.json({ wsEndpoint, mode: "standalone" }));
-    app.route("/", createPageApi({ backend, wsEndpoint }));
-    return app;
-}
-export async function serve(options = {}) {
-    const port = options.port ?? 9222;
-    const host = normalizeLoopbackHost(options.host ?? "localhost");
-    const cdpPort = options.cdpPort ?? 9223;
-    validatePorts(port, cdpPort);
-    const context = await chromium.launchPersistentContext("", {
-        headless: options.headless ?? false,
-        args: [`--remote-debugging-port=${cdpPort}`],
-    });
-    try {
-        const response = await fetchWithRetry(`http://127.0.0.1:${cdpPort}/json/version`);
-        const { webSocketDebuggerUrl: wsEndpoint } = (await response.json());
-        const backend = createStandalonePageBackend(context);
-        const app = createStandaloneApp({ backend, wsEndpoint });
-        const server = serveNode({ fetch: app.fetch, port, hostname: host });
-        const connections = new Set();
-        server.on("connection", (socket) => {
-            connections.add(socket);
-            socket.on("close", () => connections.delete(socket));
-        });
-        await once(server, "listening");
-        console.log(`HTTP API server running on ${formatHttpUrl(host, port)}`);
-        let stopped = false;
-        return {
-            wsEndpoint,
-            port,
-            async stop() {
-                if (stopped)
-                    return;
-                stopped = true;
-                for (const socket of connections)
-                    socket.destroy();
-                connections.clear();
-                for (const { name } of await backend.list()) {
-                    await backend.close(name).catch(() => undefined);
-                }
-                await context.close().catch(() => undefined);
-                await closeServer(server);
-            },
-        };
-    }
-    catch (error) {
-        await context.close().catch(() => undefined);
-        throw error;
-    }
-}
-function validatePorts(port, cdpPort) {
-    if (!Number.isInteger(port) || port < 1 || port > 65535) {
-        throw new Error(`Invalid port: ${port}. Must be between 1 and 65535`);
-    }
-    if (!Number.isInteger(cdpPort) || cdpPort < 1 || cdpPort > 65535) {
-        throw new Error(`Invalid cdpPort: ${cdpPort}. Must be between 1 and 65535`);
-    }
-    if (port === cdpPort)
-        throw new Error("port and cdpPort must be different");
-}
-async function fetchWithRetry(url, maxRetries = 5, delayMs = 500) {
-    let lastError;
-    for (let attempt = 0; attempt < maxRetries; attempt += 1) {
-        try {
-            const response = await fetch(url);
-            if (response.ok)
-                return response;
-            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-        }
-        catch (error) {
-            lastError = error;
-            if (attempt + 1 < maxRetries) {
-                await new Promise((resolve) => setTimeout(resolve, delayMs * (attempt + 1)));
-            }
-        }
-    }
-    const message = lastError instanceof Error ? lastError.message : String(lastError);
-    throw new Error(`Failed after ${maxRetries} retries: ${message}`);
-}
-function withTimeout(promise, timeoutMs, message) {
-    return new Promise((resolve, reject) => {
-        const timer = setTimeout(() => reject(new Error(message)), timeoutMs);
-        promise.then((value) => {
-            clearTimeout(timer);
-            resolve(value);
-        }, (error) => {
-            clearTimeout(timer);
-            reject(error);
-        });
-    });
-}
-function closeServer(server) {
-    return new Promise((resolve, reject) => {
-        server.close((error) => (error ? reject(error) : resolve()));
-    });
-}

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

@@ -1,46 +0,0 @@
-import { type EntrypointArgs } from "./entrypoint.js";
-interface StandaloneServer {
-    port: number;
-    wsEndpoint: string;
-    stop: () => Promise<void>;
-}
-interface ExtensionServer {
-    port: number;
-    wsEndpoint: string;
-    stop: () => Promise<void>;
-}
-export interface RunEntrypointDeps {
-    serveStandalone: (options: {
-        port: number;
-        host: string;
-        headless: boolean;
-        cdpPort: number;
-    }) => Promise<StandaloneServer>;
-    serveExtension: (options: {
-        port: number;
-        host: string;
-    }) => Promise<ExtensionServer>;
-    registerShutdown: (stop: () => Promise<void>) => void;
-    keepAlive: () => Promise<void>;
-    log: (line: string) => void;
-    ensureBrowser?: () => Promise<void>;
-    preflightStandalone?: () => Promise<boolean>;
-}
-export interface PlaywrightChromiumPreflightDeps {
-    isInstalled: () => boolean;
-}
-export interface PreflightStandaloneStartupDeps {
-    checkServer: (host: string, port: number) => Promise<{
-        ok: boolean;
-        info?: {
-            mode?: unknown;
-            wsEndpoint?: unknown;
-        };
-    }>;
-    isPortInUse: (port: number, host: string) => Promise<boolean>;
-    log: (line: string) => void;
-}
-export declare function preflightStandaloneStartup(args: EntrypointArgs, deps: PreflightStandaloneStartupDeps): Promise<boolean>;
-export declare function assertPlaywrightChromiumAvailable(deps: PlaywrightChromiumPreflightDeps): void;
-export declare function runEntrypoint(args: EntrypointArgs, deps: RunEntrypointDeps): Promise<void>;
-export {};

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

@@ -1,77 +0,0 @@
-import { formatReadinessLines } from "./entrypoint.js";
-export async function preflightStandaloneStartup(args, deps) {
-    const serverCheck = await deps.checkServer(args.host, args.port);
-    if (serverCheck.ok &&
-        serverCheck.info?.mode === "standalone" &&
-        typeof serverCheck.info.wsEndpoint === "string" &&
-        serverCheck.info.wsEndpoint.trim().length > 0) {
-        deps.log(`Server already running on port ${args.port}`);
-        return false;
-    }
-    if (await deps.isPortInUse(args.port, args.host)) {
-        throw new Error(`HTTP port ${args.port} is already in use. Stop the existing service or use --port.`);
-    }
-    if (await deps.isPortInUse(args.cdpPort, "127.0.0.1")) {
-        throw new Error(`CDP port ${args.cdpPort} is already in use. Close the existing browser or use --cdp-port.`);
-    }
-    return true;
-}
-export function assertPlaywrightChromiumAvailable(deps) {
-    if (deps.isInstalled())
-        return;
-    throw new Error("Playwright Chromium is missing. From the dev-browser skill directory, run: " +
-        "node node_modules/playwright/cli.js install chromium");
-}
-export async function runEntrypoint(args, deps) {
-    if (args.mode === "extension") {
-        const server = await deps.serveExtension({
-            port: args.port,
-            host: args.host,
-        });
-        for (const line of formatReadinessLines({
-            mode: "extension",
-            host: args.host,
-            port: args.port,
-            wsEndpoint: server.wsEndpoint,
-        })) {
-            deps.log(line);
-        }
-        deps.registerShutdown(() => server.stop());
-        await deps.keepAlive();
-        return;
-    }
-    const shouldStart = await deps.preflightStandalone?.();
-    if (shouldStart === false) {
-        return;
-    }
-    await deps.ensureBrowser?.();
-    let settleServer;
-    const serverReady = new Promise((resolve) => {
-        settleServer = resolve;
-    });
-    deps.registerShutdown(async () => {
-        await (await serverReady)?.stop();
-    });
-    try {
-        const server = await deps.serveStandalone({
-            port: args.port,
-            host: args.host,
-            headless: args.headless,
-            cdpPort: args.cdpPort,
-        });
-        settleServer(server);
-        for (const line of formatReadinessLines({
-            mode: "standalone",
-            host: args.host,
-            port: args.port,
-            wsEndpoint: server.wsEndpoint,
-        })) {
-            deps.log(line);
-        }
-        await deps.keepAlive();
-    }
-    catch (error) {
-        settleServer(undefined);
-        throw error;
-    }
-}

package/skills/dev-browser/dist/src/target-registry.d.ts

@@ -1,28 +0,0 @@
-import type { PageDescriptor } from "./page-api.js";
-export interface TargetInfo {
-    targetId: string;
-    type: string;
-    title: string;
-    url: string;
-    attached: boolean;
-    [key: string]: unknown;
-}
-export interface ConnectedTarget {
-    sessionId: string;
-    targetId: string;
-    targetInfo: TargetInfo;
-}
-export declare function createTargetRegistry(): {
-    attach: (target: ConnectedTarget) => void;
-    detach: (sessionId: string) => ConnectedTarget | undefined;
-    updateTargetInfo: (targetInfo: TargetInfo) => ConnectedTarget | undefined;
-    bindName: (name: string, targetId: string) => void;
-    getByName: (name: string) => ConnectedTarget | undefined;
-    getByTargetId: (targetId: string) => ConnectedTarget | undefined;
-    getBySessionId: (sessionId: string) => ConnectedTarget | undefined;
-    targets: () => ConnectedTarget[];
-    list: () => PageDescriptor[];
-    waitForAttach: (targetId: string, timeoutMs: number) => Promise<ConnectedTarget>;
-    waitForDetach: (targetId: string, timeoutMs: number) => Promise<void>;
-    disconnect: (error: Error) => void;
-};

package/skills/dev-browser/dist/src/target-registry.js

@@ -1,134 +0,0 @@
-export function createTargetRegistry() {
-    const byTargetId = new Map();
-    const bySessionId = new Map();
-    const names = new Map();
-    const attachWaiters = new Map();
-    const detachWaiters = new Map();
-    function attach(target) {
-        const previousTarget = byTargetId.get(target.targetId);
-        if (previousTarget) {
-            bySessionId.delete(previousTarget.sessionId);
-        }
-        const previousSession = bySessionId.get(target.sessionId);
-        if (previousSession && previousSession.targetId !== target.targetId) {
-            removeTarget(previousSession);
-        }
-        byTargetId.set(target.targetId, target);
-        bySessionId.set(target.sessionId, target);
-        resolveWaiters(attachWaiters, target.targetId, target);
-    }
-    function detach(sessionId) {
-        const target = bySessionId.get(sessionId);
-        if (!target)
-            return undefined;
-        removeTarget(target);
-        return target;
-    }
-    function removeTarget(target) {
-        bySessionId.delete(target.sessionId);
-        byTargetId.delete(target.targetId);
-        for (const [name, targetId] of names) {
-            if (targetId === target.targetId)
-                names.delete(name);
-        }
-        resolveWaiters(detachWaiters, target.targetId, undefined);
-    }
-    function updateTargetInfo(targetInfo) {
-        const target = byTargetId.get(targetInfo.targetId);
-        if (!target)
-            return undefined;
-        target.targetInfo = targetInfo;
-        return target;
-    }
-    function bindName(name, targetId) {
-        if (!byTargetId.has(targetId)) {
-            throw new Error(`Target ${targetId} is not attached`);
-        }
-        names.set(name, targetId);
-    }
-    function getByName(name) {
-        const targetId = names.get(name);
-        return targetId ? byTargetId.get(targetId) : undefined;
-    }
-    function list() {
-        const pages = [];
-        for (const [name, targetId] of names) {
-            if (byTargetId.has(targetId))
-                pages.push({ name, targetId });
-        }
-        return pages;
-    }
-    function waitForAttach(targetId, timeoutMs) {
-        const existing = byTargetId.get(targetId);
-        if (existing)
-            return Promise.resolve(existing);
-        return waitFor(attachWaiters, targetId, timeoutMs, `Timed out waiting for target ${targetId} to attach after ${timeoutMs}ms`);
-    }
-    function waitForDetach(targetId, timeoutMs) {
-        if (!byTargetId.has(targetId))
-            return Promise.resolve();
-        return waitFor(detachWaiters, targetId, timeoutMs, `Timed out waiting for target ${targetId} to detach after ${timeoutMs}ms`);
-    }
-    function disconnect(error) {
-        rejectAll(attachWaiters, error);
-        rejectAll(detachWaiters, error);
-        byTargetId.clear();
-        bySessionId.clear();
-        names.clear();
-    }
-    return {
-        attach,
-        detach,
-        updateTargetInfo,
-        bindName,
-        getByName,
-        getByTargetId: (targetId) => byTargetId.get(targetId),
-        getBySessionId: (sessionId) => bySessionId.get(sessionId),
-        targets: () => [...byTargetId.values()],
-        list,
-        waitForAttach,
-        waitForDetach,
-        disconnect,
-    };
-}
-function waitFor(waiters, key, timeoutMs, timeoutMessage) {
-    return new Promise((resolve, reject) => {
-        let pending;
-        pending = {
-            resolve,
-            reject,
-            timer: setTimeout(() => {
-                removeWaiter(waiters, key, pending);
-                reject(new Error(timeoutMessage));
-            }, timeoutMs),
-        };
-        const entries = waiters.get(key) ?? new Set();
-        entries.add(pending);
-        waiters.set(key, entries);
-    });
-}
-function removeWaiter(waiters, key, pending) {
-    const entries = waiters.get(key);
-    entries?.delete(pending);
-    if (entries?.size === 0)
-        waiters.delete(key);
-}
-function resolveWaiters(waiters, key, value) {
-    const entries = waiters.get(key);
-    if (!entries)
-        return;
-    waiters.delete(key);
-    for (const pending of entries) {
-        clearTimeout(pending.timer);
-        pending.resolve(value);
-    }
-}
-function rejectAll(waiters, error) {
-    for (const entries of waiters.values()) {
-        for (const pending of entries) {
-            clearTimeout(pending.timer);
-            pending.reject(error);
-        }
-    }
-    waiters.clear();
-}

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

@@ -1,26 +0,0 @@
-import type { Viewport } from "./page-api.js";
-export interface ServeOptions {
-    port?: number;
-    host?: string;
-    headless?: boolean;
-    cdpPort?: number;
-}
-export type ViewportSize = Viewport;
-export interface GetPageRequest {
-    name: string;
-    /** Optional viewport size for new pages */
-    viewport?: ViewportSize;
-}
-export interface GetPageResponse {
-    wsEndpoint: string;
-    name: string;
-    targetId: string;
-}
-export interface ListPagesResponse {
-    pages: string[];
-}
-export interface ServerInfoResponse {
-    wsEndpoint: string;
-    mode: "standalone" | "extension";
-    extensionConnected?: boolean;
-}

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

@@ -1 +0,0 @@
-export {};