@agentrhq/webcmd 0.1.1 → 0.2.0

package/dist/src/browser/bridge-readiness.d.ts

@@ -0,0 +1,14 @@
+import type { DaemonHealth } from './daemon-transport.js';
+export type { DaemonHealth };
+export type HealthFetcher = (opts?: {
+    timeout?: number;
+    contextId?: string;
+}) => Promise<DaemonHealth>;
+export declare function waitForBridgeReady(fetchHealth: HealthFetcher, opts: {
+    timeoutMs: number;
+    contextId?: string;
+    intervalMs?: number;
+}): Promise<DaemonHealth>;
+export declare const PRE_DISPATCH_ERROR_CODES: Set<"profile_disconnected" | "extension_not_connected">;
+export type PreDispatchErrorCode = typeof PRE_DISPATCH_ERROR_CODES extends Set<infer T> ? T : never;
+export declare function isPreDispatchError(errorCode: string | undefined): boolean;

package/dist/src/browser/bridge-readiness.js

@@ -0,0 +1,24 @@
+const DEFAULT_POLL_INTERVAL_MS = 200;
+export async function waitForBridgeReady(fetchHealth, opts) {
+    const interval = opts.intervalMs ?? DEFAULT_POLL_INTERVAL_MS;
+    let health = await fetchHealth({ contextId: opts.contextId });
+    if (health.state === 'ready')
+        return health;
+    const deadline = Date.now() + opts.timeoutMs;
+    while (Date.now() < deadline) {
+        await new Promise((resolve) => setTimeout(resolve, interval));
+        health = await fetchHealth({ contextId: opts.contextId });
+        if (health.state === 'ready')
+            return health;
+    }
+    return health;
+}
+export const PRE_DISPATCH_ERROR_CODES = new Set([
+    'extension_not_connected',
+    'profile_disconnected',
+]);
+export function isPreDispatchError(errorCode) {
+    if (!errorCode)
+        return false;
+    return PRE_DISPATCH_ERROR_CODES.has(errorCode);
+}

package/dist/src/browser/bridge-readiness.test.d.ts

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

package/dist/src/browser/bridge-readiness.test.js

@@ -0,0 +1,58 @@
+import { describe, expect, it, vi } from 'vitest';
+import { PRE_DISPATCH_ERROR_CODES, isPreDispatchError, waitForBridgeReady, } from './bridge-readiness.js';
+function status(runtimeConnected) {
+    return {
+        ok: true,
+        pid: 1,
+        uptime: 0,
+        runtimeConnected,
+        runtimeName: 'fake',
+        pending: 0,
+        memoryMB: 0,
+        port: 19825,
+    };
+}
+function readyHealth() {
+    return { state: 'ready', status: status(true) };
+}
+function notReadyHealth(state) {
+    if (state === 'stopped')
+        return { state: 'stopped', status: null };
+    return { state, status: status(false) };
+}
+describe('waitForBridgeReady', () => {
+    it('returns immediately on the first ready health', async () => {
+        const fetchHealth = vi.fn(async () => readyHealth());
+        const result = await waitForBridgeReady(fetchHealth, { timeoutMs: 10_000, intervalMs: 1 });
+        expect(result.state).toBe('ready');
+        expect(fetchHealth).toHaveBeenCalledTimes(1);
+    });
+    it('polls until ready when initial reads are not ready', async () => {
+        const sequence = [
+            notReadyHealth('stopped'),
+            notReadyHealth('no-runtime'),
+            readyHealth(),
+        ];
+        let i = 0;
+        const fetchHealth = vi.fn(async () => sequence[i++] ?? readyHealth());
+        const result = await waitForBridgeReady(fetchHealth, { timeoutMs: 10_000, intervalMs: 1 });
+        expect(result.state).toBe('ready');
+        expect(fetchHealth).toHaveBeenCalledTimes(3);
+    });
+    it('returns the last observed non-ready health when the deadline expires', async () => {
+        const fetchHealth = vi.fn(async () => notReadyHealth('profile-disconnected'));
+        const result = await waitForBridgeReady(fetchHealth, { timeoutMs: 25, intervalMs: 5 });
+        expect(result.state).toBe('profile-disconnected');
+        expect(vi.mocked(fetchHealth).mock.calls.length).toBeGreaterThan(1);
+    });
+});
+describe('isPreDispatchError', () => {
+    it('classifies only safe pre-dispatch daemon errors', () => {
+        expect(isPreDispatchError('extension_not_connected')).toBe(true);
+        expect(isPreDispatchError('profile_disconnected')).toBe(true);
+        expect(isPreDispatchError('profile_required')).toBe(false);
+        expect(isPreDispatchError('command_result_unknown')).toBe(false);
+        expect(isPreDispatchError(undefined)).toBe(false);
+        expect(PRE_DISPATCH_ERROR_CODES.size).toBe(2);
+    });
+});

package/dist/src/browser/bridge.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Browser session manager — auto-spawns daemon and provides IPage.
+ */
+import type { IPage } from '../types.js';
+import type { IBrowserFactory } from '../runtime.js';
+export type BrowserBridgeState = 'idle' | 'connecting' | 'connected' | 'closing' | 'closed';
+/**
+ * Browser factory: manages daemon lifecycle and provides IPage instances.
+ */
+export declare class BrowserBridge implements IBrowserFactory {
+    private _state;
+    private _page;
+    private _daemonProc;
+    get state(): BrowserBridgeState;
+    connect(opts?: {
+        timeout?: number;
+        session?: string;
+        idleTimeout?: number;
+        contextId?: string;
+        windowMode?: 'foreground' | 'background';
+        surface?: 'browser' | 'adapter';
+        siteSession?: 'ephemeral' | 'persistent';
+    }): Promise<IPage>;
+    close(): Promise<void>;
+    private _ensureDaemon;
+}

package/dist/src/browser/bridge.js

@@ -0,0 +1,58 @@
+/**
+ * Browser session manager — auto-spawns daemon and provides IPage.
+ */
+import { Page } from './page.js';
+import { resolveProfileContextId } from './profile.js';
+import { ensureBrowserBridgeReady } from './daemon-lifecycle.js';
+const DAEMON_SPAWN_TIMEOUT = 10000; // 10s to wait for daemon + extension
+/**
+ * Browser factory: manages daemon lifecycle and provides IPage instances.
+ */
+export class BrowserBridge {
+    _state = 'idle';
+    _page = null;
+    _daemonProc = null;
+    get state() {
+        return this._state;
+    }
+    async connect(opts = {}) {
+        if (this._state === 'connected' && this._page)
+            return this._page;
+        if (this._state === 'connecting')
+            throw new Error('Already connecting');
+        if (this._state === 'closing')
+            throw new Error('Session is closing');
+        if (this._state === 'closed')
+            throw new Error('Session is closed');
+        this._state = 'connecting';
+        try {
+            const contextId = opts.contextId ?? resolveProfileContextId();
+            await this._ensureDaemon(opts.timeout, contextId);
+            if (!opts.session?.trim())
+                throw new Error('Browser session is required');
+            this._page = new Page(opts.session.trim(), opts.idleTimeout, contextId, opts.windowMode, opts.surface, opts.siteSession);
+            this._state = 'connected';
+            return this._page;
+        }
+        catch (err) {
+            this._state = 'idle';
+            throw err;
+        }
+    }
+    async close() {
+        if (this._state === 'closed')
+            return;
+        this._state = 'closing';
+        // We don't kill the daemon — it's persistent.
+        // Just clean up our reference.
+        this._page = null;
+        this._state = 'closed';
+    }
+    async _ensureDaemon(timeoutSeconds, contextId) {
+        const result = await ensureBrowserBridgeReady({
+            timeoutSeconds: timeoutSeconds ?? Math.ceil(DAEMON_SPAWN_TIMEOUT / 1000),
+            contextId,
+        });
+        this._daemonProc = result.spawnedProcess;
+    }
+}

package/dist/src/browser/cdp-click-fixture.test.d.ts

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

package/dist/src/browser/cdp-click-fixture.test.js

@@ -0,0 +1,87 @@
+import { afterEach, describe, expect, it } from 'vitest';
+import { JSDOM } from 'jsdom';
+function installDom(html) {
+    const dom = new JSDOM(html, { pretendToBeVisual: true });
+    globalThis.window = dom.window;
+    globalThis.document = dom.window.document;
+    globalThis.Event = dom.window.Event;
+    globalThis.MouseEvent = dom.window.MouseEvent;
+    return dom.window.document;
+}
+function dispatchNativeMouseSequence(target) {
+    for (const type of ['mousemove', 'pointerdown', 'mousedown', 'mouseup', 'pointerup', 'click']) {
+        target.dispatchEvent(new MouseEvent(type, { bubbles: true, cancelable: true, view: window }));
+    }
+}
+describe('CDP-primary click dropdown fixtures', () => {
+    afterEach(() => {
+        Reflect.deleteProperty(globalThis, 'window');
+        Reflect.deleteProperty(globalThis, 'document');
+    });
+    it('captures the Radix/shadcn class of dropdowns that open on pointerdown and select on pointerup', () => {
+        const document = installDom(`
+      <button id="trigger" role="combobox" aria-expanded="false">Category</button>
+      <div id="portal-root"></div>
+      <output id="value"></output>
+    `);
+        const trigger = document.querySelector('#trigger');
+        const portal = document.querySelector('#portal-root');
+        const value = document.querySelector('#value');
+        trigger.addEventListener('pointerdown', () => {
+            trigger.setAttribute('aria-expanded', 'true');
+            portal.innerHTML = `
+        <div role="listbox">
+          <div id="meals" role="option">Meals</div>
+        </div>
+      `;
+            portal.querySelector('#meals').addEventListener('pointerup', () => {
+                value.textContent = 'Meals';
+                trigger.textContent = 'Meals';
+                trigger.setAttribute('aria-expanded', 'false');
+            });
+        });
+        // Baseline: DOM el.click() dispatches click only. This is the old Webcmd
+        // failure mode: the command reports success but the dropdown never opens.
+        trigger.click();
+        expect(trigger.getAttribute('aria-expanded')).toBe('false');
+        expect(portal.querySelector('[role="option"]')).toBeNull();
+        expect(value.textContent).toBe('');
+        // CDP-style mouse input opens the portal and can commit the option.
+        dispatchNativeMouseSequence(trigger);
+        const option = portal.querySelector('#meals');
+        expect(trigger.getAttribute('aria-expanded')).toBe('true');
+        dispatchNativeMouseSequence(option);
+        expect(value.textContent).toBe('Meals');
+        expect(trigger.textContent).toBe('Meals');
+    });
+    it('captures the MUI autocomplete class that opens on mousedown and commits on mousedown in a popper', () => {
+        const document = installDom(`
+      <label for="category">Category</label>
+      <input id="category" role="combobox" value="" />
+      <div id="mui-popper"></div>
+      <output id="value"></output>
+    `);
+        const input = document.querySelector('#category');
+        const popper = document.querySelector('#mui-popper');
+        const value = document.querySelector('#value');
+        input.addEventListener('mousedown', () => {
+            popper.innerHTML = `
+        <ul role="listbox">
+          <li id="travel" role="option">Travel</li>
+        </ul>
+      `;
+            popper.querySelector('#travel').addEventListener('mousedown', () => {
+                input.value = 'Travel';
+                value.textContent = 'Travel';
+            });
+        });
+        input.click();
+        expect(popper.querySelector('[role="option"]')).toBeNull();
+        expect(input.value).toBe('');
+        dispatchNativeMouseSequence(input);
+        const option = popper.querySelector('#travel');
+        dispatchNativeMouseSequence(option);
+        expect(input.value).toBe('Travel');
+        expect(value.textContent).toBe('Travel');
+    });
+});

package/dist/src/browser/cdp.d.ts

@@ -0,0 +1,46 @@
+/**
+ * CDP client — implements IPage by connecting directly to a Chrome/Electron CDP WebSocket.
+ *
+ * Fixes applied:
+ * - send() now has a 30s timeout guard (P0 #4)
+ * - goto() waits for Page.loadEventFired instead of hardcoded 1s sleep (P1 #3)
+ * - Implemented scroll, autoScroll, screenshot, networkRequests (P1 #2)
+ * - Shared DOM helper methods extracted to reduce duplication with Page (P1 #5)
+ */
+import type { IPage } from '../types.js';
+import type { IBrowserFactory } from '../runtime.js';
+export interface CDPTarget {
+    type?: string;
+    url?: string;
+    title?: string;
+    webSocketDebuggerUrl?: string;
+}
+export declare const CDP_RESPONSE_BODY_CAPTURE_LIMIT: number;
+export declare class CDPBridge implements IBrowserFactory {
+    private _ws;
+    private _idCounter;
+    private _pending;
+    private _eventListeners;
+    connect(opts?: {
+        timeout?: number;
+        session?: string;
+        cdpEndpoint?: string;
+        contextId?: string;
+        idleTimeout?: number;
+        windowMode?: 'foreground' | 'background';
+        surface?: 'browser' | 'adapter';
+        siteSession?: 'ephemeral' | 'persistent';
+    }): Promise<IPage>;
+    close(): Promise<void>;
+    send(method: string, params?: Record<string, unknown>, timeoutMs?: number): Promise<unknown>;
+    on(event: string, handler: (params: unknown) => void): void;
+    off(event: string, handler: (params: unknown) => void): void;
+    waitForEvent(event: string, timeoutMs?: number): Promise<unknown>;
+}
+declare function selectCDPTarget(targets: CDPTarget[]): CDPTarget | undefined;
+declare function scoreCDPTarget(target: CDPTarget, preferredPattern?: RegExp): number;
+export declare const __test__: {
+    selectCDPTarget: typeof selectCDPTarget;
+    scoreCDPTarget: typeof scoreCDPTarget;
+};
+export {};