browser-pilot 0.0.1

package/dist/index.d.cts

@@ -0,0 +1,157 @@
+export { BatchExecutor, addBatchToPage } from './actions.cjs';
+import { R as RequestPattern, a as RequestHandler } from './types-Cs89wle0.cjs';
+export { d as ActionOptions, e as ActionResult, A as ActionType, B as BatchOptions, b as BatchResult, Q as ClearCookiesOptions, C as ConsoleHandler, f as ConsoleMessage, g as ConsoleMessageType, z as ContinueRequestOptions, X as Cookie, h as CustomSelectConfig, Y as DeleteCookieOptions, w as DeviceDescriptor, x as DeviceName, D as Dialog, i as DialogHandler, j as DialogType, k as Download, E as ElementInfo, l as ElementNotFoundError, m as EmulationState, n as ErrorHandler, H as FailRequestOptions, F as FileInput, o as FillOptions, J as FulfillRequestOptions, G as GeolocationOptions, I as InteractiveElement, K as InterceptedRequest, N as NavigationError, p as NetworkIdleOptions, P as Page, q as PageError, r as PageSnapshot, L as RequestActions, M as ResourceType, O as RouteOptions, Z as SetCookieOptions, s as SnapshotNode, S as Step, c as StepResult, t as SubmitOptions, T as TimeoutError, u as TypeOptions, U as UserAgentMetadata, v as UserAgentOptions, V as ViewportOptions, W as WaitForOptions, _ as WaitOptions, $ as WaitResult, a0 as WaitState, y as devices, a1 as waitForAnyElement, a2 as waitForElement, a3 as waitForNavigation, a4 as waitForNetworkIdle } from './types-Cs89wle0.cjs';
+export { Browser, BrowserOptions, connect } from './browser.cjs';
+import { C as CDPClient } from './client-7Nqka5MV.cjs';
+export { a as CDPClientOptions, c as createCDPClient } from './client-7Nqka5MV.cjs';
+export { CDPError } from './cdp.cjs';
+export { BrowserBaseProvider, BrowserlessProvider, GenericProvider, createProvider, discoverTargets, getBrowserWebSocketUrl } from './providers.cjs';
+export { C as ConnectOptions, a as CreateSessionOptions, P as Provider, b as ProviderSession } from './types-D_uDqh0Z.cjs';
+
+/**
+ * Request interception implementation
+ */
+
+declare class RequestInterceptor {
+    private cdp;
+    private enabled;
+    private handlers;
+    private pendingRequests;
+    private boundHandleRequestPaused;
+    private boundHandleAuthRequired;
+    constructor(cdp: CDPClient);
+    /**
+     * Enable request interception with optional patterns
+     */
+    enable(patterns?: RequestPattern[]): Promise<void>;
+    /**
+     * Disable request interception
+     */
+    disable(): Promise<void>;
+    /**
+     * Add a request handler
+     */
+    addHandler(pattern: RequestPattern, handler: RequestHandler): () => void;
+    /**
+     * Handle paused request from CDP
+     */
+    private handleRequestPaused;
+    /**
+     * Handle auth challenge
+     */
+    private handleAuthRequired;
+    /**
+     * Check if request matches pattern
+     */
+    private matchesPattern;
+    /**
+     * Convert glob pattern to regex
+     */
+    private globToRegex;
+    /**
+     * Create actions object for handler
+     */
+    private createActions;
+    /**
+     * Continue a paused request
+     */
+    private continueRequest;
+    /**
+     * Fulfill a request with custom response
+     */
+    private fulfillRequest;
+    /**
+     * Fail/abort a request
+     */
+    private failRequest;
+}
+
+/**
+ * Execution tracing and logging
+ */
+type TraceLevel = 'debug' | 'info' | 'warn' | 'error';
+type TraceCategory = 'cdp' | 'action' | 'wait' | 'navigation' | 'batch';
+interface TraceEvent {
+    /** Event timestamp */
+    timestamp: string;
+    /** Log level */
+    level: TraceLevel;
+    /** Event category */
+    category: TraceCategory;
+    /** Action being performed */
+    action?: string;
+    /** Target selector(s) */
+    selector?: string | string[];
+    /** Selector that was actually used */
+    selectorUsed?: string;
+    /** Duration in ms */
+    durationMs?: number;
+    /** Whether action succeeded */
+    success?: boolean;
+    /** Error message if failed */
+    error?: string;
+    /** Selectors that failed before success */
+    failedSelectors?: Array<{
+        selector: string;
+        reason: string;
+    }>;
+    /** Current page URL */
+    url?: string;
+    /** Additional data */
+    data?: Record<string, unknown>;
+}
+type TraceOutput = 'console' | 'callback' | 'silent';
+interface TracerOptions {
+    /** Whether tracing is enabled */
+    enabled: boolean;
+    /** Output destination */
+    output: TraceOutput;
+    /** Custom callback for trace events */
+    callback?: (event: TraceEvent) => void;
+    /** Minimum level to log */
+    level?: TraceLevel;
+    /** Include timing information */
+    includeTimings?: boolean;
+}
+declare class Tracer {
+    private options;
+    constructor(options?: Partial<TracerOptions>);
+    /**
+     * Emit a trace event
+     */
+    emit(event: Omit<TraceEvent, 'timestamp'>): void;
+    /**
+     * Log event to console
+     */
+    private logToConsole;
+    /**
+     * Create a child tracer with modified options
+     */
+    child(options: Partial<TracerOptions>): Tracer;
+    /**
+     * Enable tracing
+     */
+    enable(): void;
+    /**
+     * Disable tracing
+     */
+    disable(): void;
+    /**
+     * Check if tracing is enabled
+     */
+    get isEnabled(): boolean;
+}
+/**
+ * Get the global tracer instance
+ */
+declare function getTracer(): Tracer;
+/**
+ * Enable global tracing
+ */
+declare function enableTracing(options?: Partial<Omit<TracerOptions, 'enabled'>>): Tracer;
+/**
+ * Disable global tracing
+ */
+declare function disableTracing(): void;
+
+export { CDPClient, RequestHandler, RequestInterceptor, RequestPattern, type TraceCategory, type TraceEvent, type TraceLevel, Tracer, type TracerOptions, disableTracing, enableTracing, getTracer };

package/dist/index.d.ts

@@ -0,0 +1,157 @@
+export { BatchExecutor, addBatchToPage } from './actions.js';
+import { R as RequestPattern, a as RequestHandler } from './types-DL_-3BZk.js';
+export { d as ActionOptions, e as ActionResult, A as ActionType, B as BatchOptions, b as BatchResult, Q as ClearCookiesOptions, C as ConsoleHandler, f as ConsoleMessage, g as ConsoleMessageType, z as ContinueRequestOptions, X as Cookie, h as CustomSelectConfig, Y as DeleteCookieOptions, w as DeviceDescriptor, x as DeviceName, D as Dialog, i as DialogHandler, j as DialogType, k as Download, E as ElementInfo, l as ElementNotFoundError, m as EmulationState, n as ErrorHandler, H as FailRequestOptions, F as FileInput, o as FillOptions, J as FulfillRequestOptions, G as GeolocationOptions, I as InteractiveElement, K as InterceptedRequest, N as NavigationError, p as NetworkIdleOptions, P as Page, q as PageError, r as PageSnapshot, L as RequestActions, M as ResourceType, O as RouteOptions, Z as SetCookieOptions, s as SnapshotNode, S as Step, c as StepResult, t as SubmitOptions, T as TimeoutError, u as TypeOptions, U as UserAgentMetadata, v as UserAgentOptions, V as ViewportOptions, W as WaitForOptions, _ as WaitOptions, $ as WaitResult, a0 as WaitState, y as devices, a1 as waitForAnyElement, a2 as waitForElement, a3 as waitForNavigation, a4 as waitForNetworkIdle } from './types-DL_-3BZk.js';
+export { Browser, BrowserOptions, connect } from './browser.js';
+import { C as CDPClient } from './client-7Nqka5MV.js';
+export { a as CDPClientOptions, c as createCDPClient } from './client-7Nqka5MV.js';
+export { CDPError } from './cdp.js';
+export { BrowserBaseProvider, BrowserlessProvider, GenericProvider, createProvider, discoverTargets, getBrowserWebSocketUrl } from './providers.js';
+export { C as ConnectOptions, a as CreateSessionOptions, P as Provider, b as ProviderSession } from './types-D_uDqh0Z.js';
+
+/**
+ * Request interception implementation
+ */
+
+declare class RequestInterceptor {
+    private cdp;
+    private enabled;
+    private handlers;
+    private pendingRequests;
+    private boundHandleRequestPaused;
+    private boundHandleAuthRequired;
+    constructor(cdp: CDPClient);
+    /**
+     * Enable request interception with optional patterns
+     */
+    enable(patterns?: RequestPattern[]): Promise<void>;
+    /**
+     * Disable request interception
+     */
+    disable(): Promise<void>;
+    /**
+     * Add a request handler
+     */
+    addHandler(pattern: RequestPattern, handler: RequestHandler): () => void;
+    /**
+     * Handle paused request from CDP
+     */
+    private handleRequestPaused;
+    /**
+     * Handle auth challenge
+     */
+    private handleAuthRequired;
+    /**
+     * Check if request matches pattern
+     */
+    private matchesPattern;
+    /**
+     * Convert glob pattern to regex
+     */
+    private globToRegex;
+    /**
+     * Create actions object for handler
+     */
+    private createActions;
+    /**
+     * Continue a paused request
+     */
+    private continueRequest;
+    /**
+     * Fulfill a request with custom response
+     */
+    private fulfillRequest;
+    /**
+     * Fail/abort a request
+     */
+    private failRequest;
+}
+
+/**
+ * Execution tracing and logging
+ */
+type TraceLevel = 'debug' | 'info' | 'warn' | 'error';
+type TraceCategory = 'cdp' | 'action' | 'wait' | 'navigation' | 'batch';
+interface TraceEvent {
+    /** Event timestamp */
+    timestamp: string;
+    /** Log level */
+    level: TraceLevel;
+    /** Event category */
+    category: TraceCategory;
+    /** Action being performed */
+    action?: string;
+    /** Target selector(s) */
+    selector?: string | string[];
+    /** Selector that was actually used */
+    selectorUsed?: string;
+    /** Duration in ms */
+    durationMs?: number;
+    /** Whether action succeeded */
+    success?: boolean;
+    /** Error message if failed */
+    error?: string;
+    /** Selectors that failed before success */
+    failedSelectors?: Array<{
+        selector: string;
+        reason: string;
+    }>;
+    /** Current page URL */
+    url?: string;
+    /** Additional data */
+    data?: Record<string, unknown>;
+}
+type TraceOutput = 'console' | 'callback' | 'silent';
+interface TracerOptions {
+    /** Whether tracing is enabled */
+    enabled: boolean;
+    /** Output destination */
+    output: TraceOutput;
+    /** Custom callback for trace events */
+    callback?: (event: TraceEvent) => void;
+    /** Minimum level to log */
+    level?: TraceLevel;
+    /** Include timing information */
+    includeTimings?: boolean;
+}
+declare class Tracer {
+    private options;
+    constructor(options?: Partial<TracerOptions>);
+    /**
+     * Emit a trace event
+     */
+    emit(event: Omit<TraceEvent, 'timestamp'>): void;
+    /**
+     * Log event to console
+     */
+    private logToConsole;
+    /**
+     * Create a child tracer with modified options
+     */
+    child(options: Partial<TracerOptions>): Tracer;
+    /**
+     * Enable tracing
+     */
+    enable(): void;
+    /**
+     * Disable tracing
+     */
+    disable(): void;
+    /**
+     * Check if tracing is enabled
+     */
+    get isEnabled(): boolean;
+}
+/**
+ * Get the global tracer instance
+ */
+declare function getTracer(): Tracer;
+/**
+ * Enable global tracing
+ */
+declare function enableTracing(options?: Partial<Omit<TracerOptions, 'enabled'>>): Tracer;
+/**
+ * Disable global tracing
+ */
+declare function disableTracing(): void;
+
+export { CDPClient, RequestHandler, RequestInterceptor, RequestPattern, type TraceCategory, type TraceEvent, type TraceLevel, Tracer, type TracerOptions, disableTracing, enableTracing, getTracer };

package/dist/index.mjs

@@ -0,0 +1,64 @@
+import {
+  Tracer,
+  devices,
+  disableTracing,
+  enableTracing,
+  getTracer
+} from "./chunk-ZIQA4JOT.mjs";
+import {
+  Browser,
+  ElementNotFoundError,
+  NavigationError,
+  Page,
+  RequestInterceptor,
+  TimeoutError,
+  connect,
+  waitForAnyElement,
+  waitForElement,
+  waitForNavigation,
+  waitForNetworkIdle
+} from "./chunk-FI55U7JS.mjs";
+import {
+  CDPError,
+  createCDPClient
+} from "./chunk-BCOZUKWS.mjs";
+import {
+  BrowserBaseProvider,
+  BrowserlessProvider,
+  GenericProvider,
+  createProvider,
+  discoverTargets,
+  getBrowserWebSocketUrl
+} from "./chunk-R3PS4PCM.mjs";
+import {
+  BatchExecutor,
+  addBatchToPage
+} from "./chunk-YEHK2XY3.mjs";
+export {
+  BatchExecutor,
+  Browser,
+  BrowserBaseProvider,
+  BrowserlessProvider,
+  CDPError,
+  ElementNotFoundError,
+  GenericProvider,
+  NavigationError,
+  Page,
+  RequestInterceptor,
+  TimeoutError,
+  Tracer,
+  addBatchToPage,
+  connect,
+  createCDPClient,
+  createProvider,
+  devices,
+  disableTracing,
+  discoverTargets,
+  enableTracing,
+  getBrowserWebSocketUrl,
+  getTracer,
+  waitForAnyElement,
+  waitForElement,
+  waitForNavigation,
+  waitForNetworkIdle
+};

package/dist/providers.cjs

@@ -0,0 +1,238 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/providers/index.ts
+var providers_exports = {};
+__export(providers_exports, {
+  BrowserBaseProvider: () => BrowserBaseProvider,
+  BrowserlessProvider: () => BrowserlessProvider,
+  GenericProvider: () => GenericProvider,
+  createProvider: () => createProvider,
+  discoverTargets: () => discoverTargets,
+  getBrowserWebSocketUrl: () => getBrowserWebSocketUrl
+});
+module.exports = __toCommonJS(providers_exports);
+
+// src/providers/browserbase.ts
+var BrowserBaseProvider = class {
+  name = "browserbase";
+  apiKey;
+  projectId;
+  baseUrl;
+  constructor(options) {
+    this.apiKey = options.apiKey;
+    this.projectId = options.projectId;
+    this.baseUrl = options.baseUrl ?? "https://api.browserbase.com";
+  }
+  async createSession(options = {}) {
+    const response = await fetch(`${this.baseUrl}/v1/sessions`, {
+      method: "POST",
+      headers: {
+        "X-BB-API-Key": this.apiKey,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        projectId: this.projectId,
+        browserSettings: {
+          viewport: options.width && options.height ? {
+            width: options.width,
+            height: options.height
+          } : void 0
+        },
+        ...options
+      })
+    });
+    if (!response.ok) {
+      const text = await response.text();
+      throw new Error(`BrowserBase createSession failed: ${response.status} ${text}`);
+    }
+    const session = await response.json();
+    const connectResponse = await fetch(`${this.baseUrl}/v1/sessions/${session.id}`, {
+      headers: {
+        "X-BB-API-Key": this.apiKey
+      }
+    });
+    if (!connectResponse.ok) {
+      throw new Error(`BrowserBase getSession failed: ${connectResponse.status}`);
+    }
+    const sessionDetails = await connectResponse.json();
+    if (!sessionDetails.connectUrl) {
+      throw new Error("BrowserBase session does not have a connectUrl");
+    }
+    return {
+      wsUrl: sessionDetails.connectUrl,
+      sessionId: session.id,
+      metadata: {
+        debugUrl: sessionDetails.debugUrl,
+        projectId: this.projectId,
+        status: sessionDetails.status
+      },
+      close: async () => {
+        await fetch(`${this.baseUrl}/v1/sessions/${session.id}`, {
+          method: "DELETE",
+          headers: {
+            "X-BB-API-Key": this.apiKey
+          }
+        });
+      }
+    };
+  }
+  async resumeSession(sessionId) {
+    const response = await fetch(`${this.baseUrl}/v1/sessions/${sessionId}`, {
+      headers: {
+        "X-BB-API-Key": this.apiKey
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`BrowserBase resumeSession failed: ${response.status}`);
+    }
+    const session = await response.json();
+    if (!session.connectUrl) {
+      throw new Error("BrowserBase session does not have a connectUrl (may be closed)");
+    }
+    return {
+      wsUrl: session.connectUrl,
+      sessionId: session.id,
+      metadata: {
+        debugUrl: session.debugUrl,
+        projectId: this.projectId,
+        status: session.status
+      },
+      close: async () => {
+        await fetch(`${this.baseUrl}/v1/sessions/${sessionId}`, {
+          method: "DELETE",
+          headers: {
+            "X-BB-API-Key": this.apiKey
+          }
+        });
+      }
+    };
+  }
+};
+
+// src/providers/browserless.ts
+var BrowserlessProvider = class {
+  name = "browserless";
+  token;
+  baseUrl;
+  constructor(options) {
+    this.token = options.token;
+    this.baseUrl = options.baseUrl ?? "wss://chrome.browserless.io";
+  }
+  async createSession(options = {}) {
+    const params = new URLSearchParams({
+      token: this.token
+    });
+    if (options.width && options.height) {
+      params.set("--window-size", `${options.width},${options.height}`);
+    }
+    if (options.proxy?.server) {
+      params.set("--proxy-server", options.proxy.server);
+    }
+    const wsUrl = `${this.baseUrl}?${params.toString()}`;
+    return {
+      wsUrl,
+      metadata: {
+        provider: "browserless"
+      },
+      close: async () => {
+      }
+    };
+  }
+  // Browserless doesn't support session resumption in the same way
+  // Each connection is a fresh browser instance
+};
+
+// src/providers/generic.ts
+var GenericProvider = class {
+  name = "generic";
+  wsUrl;
+  constructor(options) {
+    this.wsUrl = options.wsUrl;
+  }
+  async createSession(_options = {}) {
+    return {
+      wsUrl: this.wsUrl,
+      metadata: {
+        provider: "generic"
+      },
+      close: async () => {
+      }
+    };
+  }
+};
+async function discoverTargets(host = "localhost:9222") {
+  const protocol = host.includes("://") ? "" : "http://";
+  const response = await fetch(`${protocol}${host}/json/list`);
+  if (!response.ok) {
+    throw new Error(`Failed to discover targets: ${response.status}`);
+  }
+  return await response.json();
+}
+async function getBrowserWebSocketUrl(host = "localhost:9222") {
+  const protocol = host.includes("://") ? "" : "http://";
+  const response = await fetch(`${protocol}${host}/json/version`);
+  if (!response.ok) {
+    throw new Error(`Failed to get browser info: ${response.status}`);
+  }
+  const info = await response.json();
+  return info.webSocketDebuggerUrl;
+}
+
+// src/providers/index.ts
+function createProvider(options) {
+  switch (options.provider) {
+    case "browserbase":
+      if (!options.apiKey) {
+        throw new Error("BrowserBase provider requires apiKey");
+      }
+      if (!options.projectId) {
+        throw new Error("BrowserBase provider requires projectId");
+      }
+      return new BrowserBaseProvider({
+        apiKey: options.apiKey,
+        projectId: options.projectId
+      });
+    case "browserless":
+      if (!options.apiKey) {
+        throw new Error("Browserless provider requires apiKey (token)");
+      }
+      return new BrowserlessProvider({
+        token: options.apiKey
+      });
+    case "generic":
+      if (!options.wsUrl) {
+        throw new Error("Generic provider requires wsUrl");
+      }
+      return new GenericProvider({
+        wsUrl: options.wsUrl
+      });
+    default:
+      throw new Error(`Unknown provider: ${options.provider}`);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BrowserBaseProvider,
+  BrowserlessProvider,
+  GenericProvider,
+  createProvider,
+  discoverTargets,
+  getBrowserWebSocketUrl
+});

package/dist/providers.d.cts

@@ -0,0 +1,86 @@
+import { P as Provider, a as CreateSessionOptions, b as ProviderSession, C as ConnectOptions } from './types-D_uDqh0Z.cjs';
+export { c as ProxyConfig } from './types-D_uDqh0Z.cjs';
+
+/**
+ * BrowserBase provider implementation
+ * https://docs.browserbase.com/
+ */
+
+interface BrowserBaseOptions {
+    apiKey: string;
+    projectId: string;
+    baseUrl?: string;
+}
+declare class BrowserBaseProvider implements Provider {
+    readonly name = "browserbase";
+    private readonly apiKey;
+    private readonly projectId;
+    private readonly baseUrl;
+    constructor(options: BrowserBaseOptions);
+    createSession(options?: CreateSessionOptions): Promise<ProviderSession>;
+    resumeSession(sessionId: string): Promise<ProviderSession>;
+}
+
+/**
+ * Browserless.io provider implementation
+ * https://www.browserless.io/docs/
+ */
+
+interface BrowserlessOptions {
+    token: string;
+    baseUrl?: string;
+}
+declare class BrowserlessProvider implements Provider {
+    readonly name = "browserless";
+    private readonly token;
+    private readonly baseUrl;
+    constructor(options: BrowserlessOptions);
+    createSession(options?: CreateSessionOptions): Promise<ProviderSession>;
+}
+
+/**
+ * Generic CDP provider for direct WebSocket connections
+ * Use this when connecting to a local Chrome instance or any CDP-compatible endpoint
+ */
+
+interface GenericProviderOptions {
+    /** WebSocket URL to connect to (e.g., ws://localhost:9222/devtools/browser/xxx) */
+    wsUrl: string;
+}
+declare class GenericProvider implements Provider {
+    readonly name = "generic";
+    private readonly wsUrl;
+    constructor(options: GenericProviderOptions);
+    createSession(_options?: CreateSessionOptions): Promise<ProviderSession>;
+}
+/**
+ * Discover CDP endpoints from a Chrome DevTools JSON endpoint
+ * Useful for connecting to a local Chrome instance
+ *
+ * @param host - Host to query (e.g., "localhost:9222")
+ * @returns List of available debug targets
+ */
+declare function discoverTargets(host?: string): Promise<Array<{
+    id: string;
+    type: string;
+    url: string;
+    webSocketDebuggerUrl?: string;
+}>>;
+/**
+ * Get the browser-level WebSocket debugger URL
+ *
+ * @param host - Host to query (e.g., "localhost:9222")
+ * @returns WebSocket URL for browser-level CDP connection
+ */
+declare function getBrowserWebSocketUrl(host?: string): Promise<string>;
+
+/**
+ * Provider module exports
+ */
+
+/**
+ * Create a provider instance based on connection options
+ */
+declare function createProvider(options: ConnectOptions): Provider;
+
+export { type BrowserBaseOptions, BrowserBaseProvider, type BrowserlessOptions, BrowserlessProvider, ConnectOptions, CreateSessionOptions, GenericProvider, type GenericProviderOptions, Provider, ProviderSession, createProvider, discoverTargets, getBrowserWebSocketUrl };