@jackwener/opencli 1.5.8 → 1.6.0

package/dist/browser/cdp.js

@@ -11,11 +11,11 @@ import { WebSocket } from 'ws';
 import { request as httpRequest } from 'node:http';
 import { request as httpsRequest } from 'node:https';
 import { wrapForEval } from './utils.js';
-import { generateSnapshotJs, scrollToRefJs, getFormStateJs } from './dom-snapshot.js';
 import { generateStealthJs } from './stealth.js';
-import { clickJs, typeTextJs, pressKeyJs, waitForTextJs, scrollJs, autoScrollJs, networkRequestsJs, waitForDomStableJs, waitForCaptureJs, waitForSelectorJs, } from './dom-helpers.js';
+import { waitForDomStableJs } from './dom-helpers.js';
 import { isRecord, saveBase64ToFile } from '../utils.js';
 import { getAllElectronApps } from '../electron-apps.js';
+import { BasePage } from './base-page.js';
 const CDP_SEND_TIMEOUT = 30_000;
 export class CDPBridge {
     _ws = null;
@@ -133,11 +133,11 @@ export class CDPBridge {
         });
     }
 }
-class CDPPage {
+class CDPPage extends BasePage {
     bridge;
     _pageEnabled = false;
-    _lastUrl = null;
     constructor(bridge) {
+        super();
         this.bridge = bridge;
     }
     async goto(url, options) {
@@ -174,70 +174,6 @@ class CDPPage {
             ? cookies.filter((cookie) => isCookie(cookie) && matchesCookieDomain(cookie.domain, domain))
             : cookies;
     }
-    async snapshot(opts = {}) {
-        const snapshotJs = generateSnapshotJs({
-            viewportExpand: opts.viewportExpand ?? 800,
-            maxDepth: Math.max(1, Math.min(Number(opts.maxDepth) || 50, 200)),
-            interactiveOnly: opts.interactive ?? false,
-            maxTextLength: opts.maxTextLength ?? 120,
-            includeScrollInfo: true,
-            bboxDedup: true,
-        });
-        return this.evaluate(snapshotJs);
-    }
-    async click(ref) {
-        await this.evaluate(clickJs(ref));
-    }
-    async typeText(ref, text) {
-        await this.evaluate(typeTextJs(ref, text));
-    }
-    async pressKey(key) {
-        await this.evaluate(pressKeyJs(key));
-    }
-    async scrollTo(ref) {
-        return this.evaluate(scrollToRefJs(ref));
-    }
-    async getFormState() {
-        return (await this.evaluate(getFormStateJs()));
-    }
-    async wait(options) {
-        if (typeof options === 'number') {
-            if (options >= 1) {
-                try {
-                    const maxMs = options * 1000;
-                    await this.evaluate(waitForDomStableJs(maxMs, Math.min(500, maxMs)));
-                    return;
-                }
-                catch {
-                    // Fallback: fixed sleep
-                }
-            }
-            await new Promise((resolve) => setTimeout(resolve, options * 1000));
-            return;
-        }
-        if (typeof options.time === 'number') {
-            const waitTime = options.time;
-            await new Promise((resolve) => setTimeout(resolve, waitTime * 1000));
-            return;
-        }
-        if (options.selector) {
-            const timeout = (options.timeout ?? 10) * 1000;
-            await this.evaluate(waitForSelectorJs(options.selector, timeout));
-            return;
-        }
-        if (options.text) {
-            const timeout = (options.timeout ?? 30) * 1000;
-            await this.evaluate(waitForTextJs(options.text, timeout));
-        }
-    }
-    async scroll(direction = 'down', amount = 500) {
-        await this.evaluate(scrollJs(direction, amount));
-    }
-    async autoScroll(options) {
-        const times = options?.times ?? 3;
-        const delayMs = options?.delayMs ?? 2000;
-        await this.evaluate(autoScrollJs(times, delayMs));
-    }
     async screenshot(options = {}) {
         const result = await this.bridge.send('Page.captureScreenshot', {
             format: options.format ?? 'png',
@@ -250,10 +186,6 @@ class CDPPage {
         }
         return base64;
     }
-    async networkRequests(includeStatic = false) {
-        const result = await this.evaluate(networkRequestsJs(includeStatic));
-        return Array.isArray(result) ? result : [];
-    }
     async tabs() {
         return [];
     }
@@ -266,40 +198,6 @@ class CDPPage {
     async selectTab(_index) {
         // Not supported in direct CDP mode
     }
-    async consoleMessages(_level) {
-        return [];
-    }
-    async getCurrentUrl() {
-        if (this._lastUrl)
-            return this._lastUrl;
-        try {
-            const current = await this.evaluate('window.location.href');
-            if (typeof current === 'string' && current) {
-                this._lastUrl = current;
-                return current;
-            }
-        }
-        catch {
-            // Best-effort: direct CDP sessions may not have a ready page yet.
-        }
-        return null;
-    }
-    async installInterceptor(pattern) {
-        const { generateInterceptorJs } = await import('../interceptor.js');
-        await this.evaluate(generateInterceptorJs(JSON.stringify(pattern), {
-            arrayName: '__opencli_xhr',
-            patchGuard: '__opencli_interceptor_patched',
-        }));
-    }
-    async getInterceptedRequests() {
-        const { generateReadInterceptedJs } = await import('../interceptor.js');
-        const result = await this.evaluate(generateReadInterceptedJs('__opencli_xhr'));
-        return Array.isArray(result) ? result : [];
-    }
-    async waitForCapture(timeout = 10) {
-        const maxMs = timeout * 1000;
-        await this.evaluate(waitForCaptureJs(maxMs));
-    }
 }
 function isCookie(value) {
     return isRecord(value)

package/dist/browser/daemon-client.d.ts

@@ -6,7 +6,7 @@
 import type { BrowserSessionInfo } from '../types.js';
 export interface DaemonCommand {
     id: string;
-    action: 'exec' | 'navigate' | 'tabs' | 'cookies' | 'screenshot' | 'close-window' | 'sessions' | 'set-file-input' | 'bind-current';
+    action: 'exec' | 'navigate' | 'tabs' | 'cookies' | 'screenshot' | 'close-window' | 'sessions' | 'set-file-input' | 'cdp';
     tabId?: number;
     code?: string;
     workspace?: string;
@@ -14,8 +14,6 @@ export interface DaemonCommand {
     op?: string;
     index?: number;
     domain?: string;
-    matchDomain?: string;
-    matchPathPrefix?: string;
     format?: 'png' | 'jpeg';
     quality?: number;
     fullPage?: boolean;
@@ -23,6 +21,8 @@ export interface DaemonCommand {
     files?: string[];
     /** CSS selector for file input element (set-file-input action) */
     selector?: string;
+    cdpMethod?: string;
+    cdpParams?: Record<string, unknown>;
 }
 export interface DaemonResult {
     id: string;
@@ -30,6 +30,23 @@ export interface DaemonResult {
     data?: unknown;
     error?: string;
 }
+export interface DaemonStatus {
+    ok: boolean;
+    pid: number;
+    uptime: number;
+    extensionConnected: boolean;
+    extensionVersion?: string;
+    pending: number;
+    lastCliRequestTime: number;
+    memoryMB: number;
+    port: number;
+}
+export declare function fetchDaemonStatus(opts?: {
+    timeout?: number;
+}): Promise<DaemonStatus | null>;
+export declare function requestDaemonShutdown(opts?: {
+    timeout?: number;
+}): Promise<boolean>;
 /**
  * Check if daemon is running.
  */
@@ -45,7 +62,3 @@ export declare function isExtensionConnected(): Promise<boolean>;
  */
 export declare function sendCommand(action: DaemonCommand['action'], params?: Omit<DaemonCommand, 'id' | 'action'>): Promise<unknown>;
 export declare function listSessions(): Promise<BrowserSessionInfo[]>;
-export declare function bindCurrentTab(workspace: string, opts?: {
-    matchDomain?: string;
-    matchPathPrefix?: string;
-}): Promise<unknown>;

package/dist/browser/daemon-client.js

@@ -5,50 +5,61 @@
  */
 import { DEFAULT_DAEMON_PORT } from '../constants.js';
 import { sleep } from '../utils.js';
+import { isTransientBrowserError } from './errors.js';
 const DAEMON_PORT = parseInt(process.env.OPENCLI_DAEMON_PORT ?? String(DEFAULT_DAEMON_PORT), 10);
 const DAEMON_URL = `http://127.0.0.1:${DAEMON_PORT}`;
+const OPENCLI_HEADERS = { 'X-OpenCLI': '1' };
 let _idCounter = 0;
 function generateId() {
     return `cmd_${Date.now()}_${++_idCounter}`;
 }
-/**
- * Check if daemon is running.
- */
-export async function isDaemonRunning() {
+async function requestDaemon(pathname, init) {
+    const { timeout = 2000, headers, ...rest } = init ?? {};
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeout);
     try {
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), 2000);
-        const res = await fetch(`${DAEMON_URL}/status`, {
-            headers: { 'X-OpenCLI': '1' },
+        return await fetch(`${DAEMON_URL}${pathname}`, {
+            ...rest,
+            headers: { ...OPENCLI_HEADERS, ...headers },
             signal: controller.signal,
         });
+    }
+    finally {
         clearTimeout(timer);
+    }
+}
+export async function fetchDaemonStatus(opts) {
+    try {
+        const res = await requestDaemon('/status', { timeout: opts?.timeout ?? 2000 });
+        if (!res.ok)
+            return null;
+        return await res.json();
+    }
+    catch {
+        return null;
+    }
+}
+export async function requestDaemonShutdown(opts) {
+    try {
+        const res = await requestDaemon('/shutdown', { method: 'POST', timeout: opts?.timeout ?? 5000 });
         return res.ok;
     }
     catch {
         return false;
     }
 }
+/**
+ * Check if daemon is running.
+ */
+export async function isDaemonRunning() {
+    return (await fetchDaemonStatus()) !== null;
+}
 /**
  * Check if daemon is running AND the extension is connected.
  */
 export async function isExtensionConnected() {
-    try {
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), 2000);
-        const res = await fetch(`${DAEMON_URL}/status`, {
-            headers: { 'X-OpenCLI': '1' },
-            signal: controller.signal,
-        });
-        clearTimeout(timer);
-        if (!res.ok)
-            return false;
-        const data = await res.json();
-        return !!data.extensionConnected;
-    }
-    catch {
-        return false;
-    }
+    const status = await fetchDaemonStatus();
+    return !!status?.extensionConnected;
 }
 /**
  * Send a command to the daemon and wait for a result.
@@ -62,24 +73,16 @@ export async function sendCommand(action, params = {}) {
         const id = generateId();
         const command = { id, action, ...params };
         try {
-            const controller = new AbortController();
-            const timer = setTimeout(() => controller.abort(), 30000);
-            const res = await fetch(`${DAEMON_URL}/command`, {
+            const res = await requestDaemon('/command', {
                 method: 'POST',
-                headers: { 'Content-Type': 'application/json', 'X-OpenCLI': '1' },
+                headers: { 'Content-Type': 'application/json' },
                 body: JSON.stringify(command),
-                signal: controller.signal,
+                timeout: 30000,
             });
-            clearTimeout(timer);
             const result = (await res.json());
             if (!result.ok) {
                 // Check if error is a transient extension issue worth retrying
-                const errMsg = result.error ?? '';
-                const isTransient = errMsg.includes('Extension disconnected')
-                    || errMsg.includes('Extension not connected')
-                    || errMsg.includes('attach failed')
-                    || errMsg.includes('no longer exists');
-                if (isTransient && attempt < maxRetries) {
+                if (isTransientBrowserError(new Error(result.error ?? '')) && attempt < maxRetries) {
                     // Longer delay for extension recovery (service worker restart)
                     await sleep(1500);
                     continue;
@@ -105,6 +108,3 @@ export async function listSessions() {
     const result = await sendCommand('sessions');
     return Array.isArray(result) ? result : [];
 }
-export async function bindCurrentTab(workspace, opts = {}) {
-    return sendCommand('bind-current', { workspace, ...opts });
-}

package/dist/browser/daemon-client.test.js

@@ -0,0 +1,77 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { fetchDaemonStatus, isDaemonRunning, isExtensionConnected, requestDaemonShutdown, } from './daemon-client.js';
+describe('daemon-client', () => {
+    beforeEach(() => {
+        vi.stubGlobal('fetch', vi.fn());
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('fetchDaemonStatus sends the shared status request and returns parsed data', async () => {
+        const status = {
+            ok: true,
+            pid: 123,
+            uptime: 10,
+            extensionConnected: true,
+            extensionVersion: '1.2.3',
+            pending: 0,
+            lastCliRequestTime: Date.now(),
+            memoryMB: 32,
+            port: 19825,
+        };
+        const fetchMock = vi.mocked(fetch);
+        fetchMock.mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve(status),
+        });
+        await expect(fetchDaemonStatus()).resolves.toEqual(status);
+        expect(fetchMock).toHaveBeenCalledWith(expect.stringMatching(/\/status$/), expect.objectContaining({
+            headers: expect.objectContaining({ 'X-OpenCLI': '1' }),
+        }));
+    });
+    it('fetchDaemonStatus returns null on network failure', async () => {
+        vi.mocked(fetch).mockRejectedValue(new Error('ECONNREFUSED'));
+        await expect(fetchDaemonStatus()).resolves.toBeNull();
+    });
+    it('requestDaemonShutdown POSTs to the shared shutdown endpoint', async () => {
+        const fetchMock = vi.mocked(fetch);
+        fetchMock.mockResolvedValue({ ok: true });
+        await expect(requestDaemonShutdown()).resolves.toBe(true);
+        expect(fetchMock).toHaveBeenCalledWith(expect.stringMatching(/\/shutdown$/), expect.objectContaining({
+            method: 'POST',
+            headers: expect.objectContaining({ 'X-OpenCLI': '1' }),
+        }));
+    });
+    it('isDaemonRunning reflects shared status availability', async () => {
+        vi.mocked(fetch).mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({
+                ok: true,
+                pid: 123,
+                uptime: 10,
+                extensionConnected: false,
+                pending: 0,
+                lastCliRequestTime: Date.now(),
+                memoryMB: 16,
+                port: 19825,
+            }),
+        });
+        await expect(isDaemonRunning()).resolves.toBe(true);
+    });
+    it('isExtensionConnected reflects shared status payload', async () => {
+        vi.mocked(fetch).mockResolvedValue({
+            ok: true,
+            json: () => Promise.resolve({
+                ok: true,
+                pid: 123,
+                uptime: 10,
+                extensionConnected: false,
+                pending: 0,
+                lastCliRequestTime: Date.now(),
+                memoryMB: 16,
+                port: 19825,
+            }),
+        });
+        await expect(isExtensionConnected()).resolves.toBe(false);
+    });
+});

package/dist/browser/discover.d.ts

@@ -1,8 +1,5 @@
 /**
- * Daemon discovery — simplified from MCP server path discovery.
- *
- * Only needs to check if the daemon is running. No more file system
- * scanning for @playwright/mcp locations.
+ * Daemon discovery — checks if the daemon is running.
  */
 import { isDaemonRunning } from './daemon-client.js';
 export { isDaemonRunning };

package/dist/browser/discover.js

@@ -1,33 +1,19 @@
 /**
- * Daemon discovery — simplified from MCP server path discovery.
- *
- * Only needs to check if the daemon is running. No more file system
- * scanning for @playwright/mcp locations.
+ * Daemon discovery — checks if the daemon is running.
  */
-import { DEFAULT_DAEMON_PORT } from '../constants.js';
-import { isDaemonRunning } from './daemon-client.js';
+import { fetchDaemonStatus, isDaemonRunning } from './daemon-client.js';
 export { isDaemonRunning };
 /**
  * Check daemon status and return connection info.
  */
 export async function checkDaemonStatus(opts) {
-    try {
-        const port = parseInt(process.env.OPENCLI_DAEMON_PORT ?? String(DEFAULT_DAEMON_PORT), 10);
-        const controller = new AbortController();
-        const timer = setTimeout(() => controller.abort(), opts?.timeout ?? 2000);
-        try {
-            const res = await fetch(`http://127.0.0.1:${port}/status`, {
-                headers: { 'X-OpenCLI': '1' },
-                signal: controller.signal,
-            });
-            const data = await res.json();
-            return { running: true, extensionConnected: data.extensionConnected, extensionVersion: data.extensionVersion };
-        }
-        finally {
-            clearTimeout(timer);
-        }
-    }
-    catch {
+    const status = await fetchDaemonStatus({ timeout: opts?.timeout ?? 2000 });
+    if (!status) {
         return { running: false, extensionConnected: false };
     }
+    return {
+        running: true,
+        extensionConnected: status.extensionConnected,
+        extensionVersion: status.extensionVersion,
+    };
 }

package/dist/browser/errors.d.ts

@@ -5,5 +5,9 @@
  * The daemon architecture has a single failure mode: daemon not reachable or extension not connected.
  */
 import { BrowserConnectError, type BrowserConnectKind } from '../errors.js';
+/**
+ * Check if an error message indicates a transient browser error worth retrying.
+ */
+export declare function isTransientBrowserError(err: unknown): boolean;
 export type ConnectFailureKind = BrowserConnectKind;
 export declare function formatBrowserConnectError(kind: ConnectFailureKind, detail?: string): BrowserConnectError;

package/dist/browser/errors.js

@@ -6,6 +6,26 @@
  */
 import { BrowserConnectError } from '../errors.js';
 import { DEFAULT_DAEMON_PORT } from '../constants.js';
+/**
+ * Transient browser error patterns — shared across daemon-client, pipeline executor,
+ * and page retry logic. These errors indicate temporary conditions (extension restart,
+ * service worker cycle, tab navigation) that are worth retrying.
+ */
+const TRANSIENT_ERROR_PATTERNS = [
+    'Extension disconnected',
+    'Extension not connected',
+    'attach failed',
+    'no longer exists',
+    'CDP connection',
+    'Daemon command failed',
+];
+/**
+ * Check if an error message indicates a transient browser error worth retrying.
+ */
+export function isTransientBrowserError(err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return TRANSIENT_ERROR_PATTERNS.some(pattern => msg.includes(pattern));
+}
 export function formatBrowserConnectError(kind, detail) {
     switch (kind) {
         case 'daemon-not-running':

package/dist/browser/index.d.ts

@@ -5,7 +5,7 @@
  * External code should import from './browser/index.js' (or './browser.js' via Node resolution).
  */
 export { Page } from './page.js';
-export { BrowserBridge } from './mcp.js';
+export { BrowserBridge } from './bridge.js';
 export { CDPBridge } from './cdp.js';
 export { isDaemonRunning } from './daemon-client.js';
 export { generateSnapshotJs, scrollToRefJs, getFormStateJs } from './dom-snapshot.js';

package/dist/browser/index.js

@@ -5,7 +5,7 @@
  * External code should import from './browser/index.js' (or './browser.js' via Node resolution).
  */
 export { Page } from './page.js';
-export { BrowserBridge } from './mcp.js';
+export { BrowserBridge } from './bridge.js';
 export { CDPBridge } from './cdp.js';
 export { isDaemonRunning } from './daemon-client.js';
 export { generateSnapshotJs, scrollToRefJs, getFormStateJs } from './dom-snapshot.js';

package/dist/browser/page.d.ts

@@ -9,18 +9,17 @@
  * where resolveTabId() in the extension picks a chrome:// or
  * chrome-extension:// tab that can't be debugged.
  */
-import type { BrowserCookie, IPage, ScreenshotOptions, SnapshotOptions, WaitOptions } from '../types.js';
+import type { BrowserCookie, ScreenshotOptions } from '../types.js';
+import { BasePage } from './base-page.js';
 export declare function isRetryableSettleError(err: unknown): boolean;
 /**
  * Page — implements IPage by talking to the daemon via HTTP.
  */
-export declare class Page implements IPage {
+export declare class Page extends BasePage {
     private readonly workspace;
     constructor(workspace?: string);
     /** Active tab ID, set after navigate and used in all subsequent commands */
     private _tabId;
-    /** Last navigated URL, tracked in-memory to avoid extra round-trips */
-    private _lastUrl;
     /** Helper: spread workspace into command params */
     private _wsOpt;
     /** Helper: spread workspace + tabId into command params */
@@ -29,54 +28,30 @@ export declare class Page implements IPage {
         waitUntil?: 'load' | 'none';
         settleMs?: number;
     }): Promise<void>;
-    getCurrentUrl(): Promise<string | null>;
-    /** Close the automation window in the extension */
-    closeWindow(): Promise<void>;
+    getActiveTabId(): number | undefined;
     evaluate(js: string): Promise<unknown>;
     getCookies(opts?: {
         domain?: string;
         url?: string;
     }): Promise<BrowserCookie[]>;
-    snapshot(opts?: SnapshotOptions): Promise<unknown>;
-    /** Fallback basic snapshot — original buildTree approach */
-    private _basicSnapshot;
-    click(ref: string): Promise<void>;
-    typeText(ref: string, text: string): Promise<void>;
-    pressKey(key: string): Promise<void>;
-    scrollTo(ref: string): Promise<unknown>;
-    getFormState(): Promise<Record<string, unknown>>;
-    wait(options: number | WaitOptions): Promise<void>;
+    /** Close the automation window in the extension */
+    closeWindow(): Promise<void>;
     tabs(): Promise<unknown[]>;
     closeTab(index?: number): Promise<void>;
     newTab(): Promise<void>;
     selectTab(index: number): Promise<void>;
-    networkRequests(includeStatic?: boolean): Promise<unknown[]>;
-    /**
-     * Console messages are not available in lightweight daemon mode.
-     * Would require CDP Runtime.consoleAPICalled event listener.
-     * @returns Always returns empty array.
-     */
-    consoleMessages(_level?: string): Promise<unknown[]>;
     /**
      * Capture a screenshot via CDP Page.captureScreenshot.
-     * @param options.format - 'png' (default) or 'jpeg'
-     * @param options.quality - JPEG quality 0-100
-     * @param options.fullPage - capture full scrollable page
-     * @param options.path - save to file path (returns base64 if omitted)
      */
     screenshot(options?: ScreenshotOptions): Promise<string>;
-    scroll(direction?: string, amount?: number): Promise<void>;
-    autoScroll(options?: {
-        times?: number;
-        delayMs?: number;
-    }): Promise<void>;
-    installInterceptor(pattern: string): Promise<void>;
-    getInterceptedRequests(): Promise<unknown[]>;
     /**
      * Set local file paths on a file input element via CDP DOM.setFileInputFiles.
      * Chrome reads the files directly from the local filesystem, avoiding the
      * payload size limits of base64-in-evaluate.
      */
     setFileInput(files: string[], selector?: string): Promise<void>;
-    waitForCapture(timeout?: number): Promise<void>;
+    cdp(method: string, params?: Record<string, unknown>): Promise<unknown>;
+    nativeClick(x: number, y: number): Promise<void>;
+    nativeType(text: string): Promise<void>;
+    nativeKeyPress(key: string, modifiers?: string[]): Promise<void>;
 }