browser-pilot 0.0.1

package/dist/browser.d.cts

@@ -0,0 +1,71 @@
+import { C as CDPClient } from './client-7Nqka5MV.cjs';
+import { C as ConnectOptions } from './types-D_uDqh0Z.cjs';
+import { P as Page } from './types-Cs89wle0.cjs';
+export { d as ActionOptions, e as ActionResult, C as ConsoleHandler, f as ConsoleMessage, g as ConsoleMessageType, h as CustomSelectConfig, D as Dialog, i as DialogHandler, j as DialogType, k as Download, E as ElementInfo, l as ElementNotFoundError, m as EmulationState, n as ErrorHandler, F as FileInput, o as FillOptions, G as GeolocationOptions, I as InteractiveElement, N as NavigationError, p as NetworkIdleOptions, q as PageError, r as PageSnapshot, s as SnapshotNode, t as SubmitOptions, T as TimeoutError, u as TypeOptions, U as UserAgentMetadata, v as UserAgentOptions, V as ViewportOptions, W as WaitForOptions } from './types-Cs89wle0.cjs';
+
+/**
+ * Browser class - manages CDP connection and pages
+ */
+
+interface BrowserOptions extends ConnectOptions {
+    /** Enable debug logging */
+    debug?: boolean;
+}
+declare class Browser {
+    private cdp;
+    private providerSession;
+    private pages;
+    private constructor();
+    /**
+     * Connect to a browser instance
+     */
+    static connect(options: BrowserOptions): Promise<Browser>;
+    /**
+     * Get or create a page by name
+     * If no name is provided, returns the first available page or creates a new one
+     */
+    page(name?: string): Promise<Page>;
+    /**
+     * Create a new page (tab)
+     */
+    newPage(url?: string): Promise<Page>;
+    /**
+     * Close a page by name
+     */
+    closePage(name: string): Promise<void>;
+    /**
+     * Get the WebSocket URL for this browser connection
+     */
+    get wsUrl(): string;
+    /**
+     * Get the provider session ID (for resumption)
+     */
+    get sessionId(): string | undefined;
+    /**
+     * Get provider metadata
+     */
+    get metadata(): Record<string, unknown> | undefined;
+    /**
+     * Check if connected
+     */
+    get isConnected(): boolean;
+    /**
+     * Disconnect from the browser (keeps provider session alive for reconnection)
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Close the browser session completely
+     */
+    close(): Promise<void>;
+    /**
+     * Get the underlying CDP client (for advanced usage)
+     */
+    get cdpClient(): CDPClient;
+}
+/**
+ * Connect to a browser instance
+ * Convenience function for Browser.connect()
+ */
+declare function connect(options: BrowserOptions): Promise<Browser>;
+
+export { Browser, type BrowserOptions, Page, connect };

package/dist/browser.d.ts

@@ -0,0 +1,71 @@
+import { C as CDPClient } from './client-7Nqka5MV.js';
+import { C as ConnectOptions } from './types-D_uDqh0Z.js';
+import { P as Page } from './types-DL_-3BZk.js';
+export { d as ActionOptions, e as ActionResult, C as ConsoleHandler, f as ConsoleMessage, g as ConsoleMessageType, h as CustomSelectConfig, D as Dialog, i as DialogHandler, j as DialogType, k as Download, E as ElementInfo, l as ElementNotFoundError, m as EmulationState, n as ErrorHandler, F as FileInput, o as FillOptions, G as GeolocationOptions, I as InteractiveElement, N as NavigationError, p as NetworkIdleOptions, q as PageError, r as PageSnapshot, s as SnapshotNode, t as SubmitOptions, T as TimeoutError, u as TypeOptions, U as UserAgentMetadata, v as UserAgentOptions, V as ViewportOptions, W as WaitForOptions } from './types-DL_-3BZk.js';
+
+/**
+ * Browser class - manages CDP connection and pages
+ */
+
+interface BrowserOptions extends ConnectOptions {
+    /** Enable debug logging */
+    debug?: boolean;
+}
+declare class Browser {
+    private cdp;
+    private providerSession;
+    private pages;
+    private constructor();
+    /**
+     * Connect to a browser instance
+     */
+    static connect(options: BrowserOptions): Promise<Browser>;
+    /**
+     * Get or create a page by name
+     * If no name is provided, returns the first available page or creates a new one
+     */
+    page(name?: string): Promise<Page>;
+    /**
+     * Create a new page (tab)
+     */
+    newPage(url?: string): Promise<Page>;
+    /**
+     * Close a page by name
+     */
+    closePage(name: string): Promise<void>;
+    /**
+     * Get the WebSocket URL for this browser connection
+     */
+    get wsUrl(): string;
+    /**
+     * Get the provider session ID (for resumption)
+     */
+    get sessionId(): string | undefined;
+    /**
+     * Get provider metadata
+     */
+    get metadata(): Record<string, unknown> | undefined;
+    /**
+     * Check if connected
+     */
+    get isConnected(): boolean;
+    /**
+     * Disconnect from the browser (keeps provider session alive for reconnection)
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Close the browser session completely
+     */
+    close(): Promise<void>;
+    /**
+     * Get the underlying CDP client (for advanced usage)
+     */
+    get cdpClient(): CDPClient;
+}
+/**
+ * Connect to a browser instance
+ * Convenience function for Browser.connect()
+ */
+declare function connect(options: BrowserOptions): Promise<Browser>;
+
+export { Browser, type BrowserOptions, Page, connect };

package/dist/browser.mjs

@@ -0,0 +1,19 @@
+import {
+  Browser,
+  ElementNotFoundError,
+  NavigationError,
+  Page,
+  TimeoutError,
+  connect
+} from "./chunk-FI55U7JS.mjs";
+import "./chunk-BCOZUKWS.mjs";
+import "./chunk-R3PS4PCM.mjs";
+import "./chunk-YEHK2XY3.mjs";
+export {
+  Browser,
+  ElementNotFoundError,
+  NavigationError,
+  Page,
+  TimeoutError,
+  connect
+};

package/dist/cdp.cjs

@@ -0,0 +1,279 @@
+"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/cdp/index.ts
+var cdp_exports = {};
+__export(cdp_exports, {
+  CDPError: () => CDPError,
+  createCDPClient: () => createCDPClient,
+  createTransport: () => createTransport
+});
+module.exports = __toCommonJS(cdp_exports);
+
+// src/cdp/protocol.ts
+var CDPError = class extends Error {
+  code;
+  data;
+  constructor(error) {
+    super(error.message);
+    this.name = "CDPError";
+    this.code = error.code;
+    this.data = error.data;
+  }
+};
+
+// src/cdp/transport.ts
+function createTransport(wsUrl, options = {}) {
+  const { timeout = 3e4 } = options;
+  return new Promise((resolve, reject) => {
+    const timeoutId = setTimeout(() => {
+      reject(new Error(`WebSocket connection timeout after ${timeout}ms`));
+    }, timeout);
+    const ws = new WebSocket(wsUrl);
+    const messageHandlers = [];
+    const closeHandlers = [];
+    const errorHandlers = [];
+    ws.addEventListener("open", () => {
+      clearTimeout(timeoutId);
+      const transport = {
+        send(message) {
+          if (ws.readyState === WebSocket.OPEN) {
+            ws.send(message);
+          } else {
+            throw new Error(
+              `Cannot send message, WebSocket is ${getReadyStateString(ws.readyState)}`
+            );
+          }
+        },
+        async close() {
+          return new Promise((resolveClose) => {
+            if (ws.readyState === WebSocket.CLOSED) {
+              resolveClose();
+              return;
+            }
+            const onClose = () => {
+              ws.removeEventListener("close", onClose);
+              resolveClose();
+            };
+            ws.addEventListener("close", onClose);
+            ws.close();
+            setTimeout(resolveClose, 5e3);
+          });
+        },
+        onMessage(handler) {
+          messageHandlers.push(handler);
+        },
+        onClose(handler) {
+          closeHandlers.push(handler);
+        },
+        onError(handler) {
+          errorHandlers.push(handler);
+        }
+      };
+      resolve(transport);
+    });
+    ws.addEventListener("message", (event) => {
+      const data = typeof event.data === "string" ? event.data : String(event.data);
+      for (const handler of messageHandlers) {
+        handler(data);
+      }
+    });
+    ws.addEventListener("close", () => {
+      for (const handler of closeHandlers) {
+        handler();
+      }
+    });
+    ws.addEventListener("error", (_event) => {
+      clearTimeout(timeoutId);
+      const error = new Error("WebSocket connection error");
+      for (const handler of errorHandlers) {
+        handler(error);
+      }
+      reject(error);
+    });
+  });
+}
+function getReadyStateString(state) {
+  switch (state) {
+    case WebSocket.CONNECTING:
+      return "CONNECTING";
+    case WebSocket.OPEN:
+      return "OPEN";
+    case WebSocket.CLOSING:
+      return "CLOSING";
+    case WebSocket.CLOSED:
+      return "CLOSED";
+    default:
+      return "UNKNOWN";
+  }
+}
+
+// src/cdp/client.ts
+async function createCDPClient(wsUrl, options = {}) {
+  const { debug = false, timeout = 3e4 } = options;
+  const transport = await createTransport(wsUrl, { timeout });
+  let messageId = 0;
+  let currentSessionId;
+  let connected = true;
+  const pending = /* @__PURE__ */ new Map();
+  const eventHandlers = /* @__PURE__ */ new Map();
+  const anyEventHandlers = /* @__PURE__ */ new Set();
+  transport.onMessage((raw) => {
+    let msg;
+    try {
+      msg = JSON.parse(raw);
+    } catch {
+      if (debug) console.error("[CDP] Failed to parse message:", raw);
+      return;
+    }
+    if (debug) {
+      console.log("[CDP] <--", JSON.stringify(msg, null, 2).slice(0, 500));
+    }
+    if ("id" in msg && typeof msg.id === "number") {
+      const response = msg;
+      const request = pending.get(response.id);
+      if (request) {
+        pending.delete(response.id);
+        clearTimeout(request.timer);
+        if (response.error) {
+          request.reject(new CDPError(response.error));
+        } else {
+          request.resolve(response.result);
+        }
+      }
+      return;
+    }
+    if ("method" in msg) {
+      const event = msg;
+      const params = event.params ?? {};
+      for (const handler of anyEventHandlers) {
+        try {
+          handler(event.method, params);
+        } catch (e) {
+          if (debug) console.error("[CDP] Error in any-event handler:", e);
+        }
+      }
+      const handlers = eventHandlers.get(event.method);
+      if (handlers) {
+        for (const handler of handlers) {
+          try {
+            handler(params);
+          } catch (e) {
+            if (debug) console.error(`[CDP] Error in handler for ${event.method}:`, e);
+          }
+        }
+      }
+    }
+  });
+  transport.onClose(() => {
+    connected = false;
+    for (const [id, request] of pending) {
+      clearTimeout(request.timer);
+      request.reject(new Error("WebSocket connection closed"));
+      pending.delete(id);
+    }
+  });
+  transport.onError((error) => {
+    if (debug) console.error("[CDP] Transport error:", error);
+  });
+  const client = {
+    async send(method, params, sessionId) {
+      if (!connected) {
+        throw new Error("CDP client is not connected");
+      }
+      const id = ++messageId;
+      const effectiveSessionId = sessionId ?? currentSessionId;
+      const request = { id, method };
+      if (params !== void 0) {
+        request.params = params;
+      }
+      if (effectiveSessionId !== void 0) {
+        request.sessionId = effectiveSessionId;
+      }
+      const message = JSON.stringify(request);
+      if (debug) {
+        console.log("[CDP] -->", message.slice(0, 500));
+      }
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          pending.delete(id);
+          reject(new Error(`CDP command ${method} timed out after ${timeout}ms`));
+        }, timeout);
+        pending.set(id, {
+          resolve,
+          reject,
+          method,
+          timer
+        });
+        try {
+          transport.send(message);
+        } catch (e) {
+          pending.delete(id);
+          clearTimeout(timer);
+          reject(e);
+        }
+      });
+    },
+    on(event, handler) {
+      let handlers = eventHandlers.get(event);
+      if (!handlers) {
+        handlers = /* @__PURE__ */ new Set();
+        eventHandlers.set(event, handlers);
+      }
+      handlers.add(handler);
+    },
+    off(event, handler) {
+      const handlers = eventHandlers.get(event);
+      if (handlers) {
+        handlers.delete(handler);
+        if (handlers.size === 0) {
+          eventHandlers.delete(event);
+        }
+      }
+    },
+    onAny(handler) {
+      anyEventHandlers.add(handler);
+    },
+    async close() {
+      connected = false;
+      await transport.close();
+    },
+    async attachToTarget(targetId) {
+      const result = await this.send("Target.attachToTarget", {
+        targetId,
+        flatten: true
+      });
+      currentSessionId = result.sessionId;
+      return result.sessionId;
+    },
+    get sessionId() {
+      return currentSessionId;
+    },
+    get isConnected() {
+      return connected;
+    }
+  };
+  return client;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CDPError,
+  createCDPClient,
+  createTransport
+});

package/dist/cdp.d.cts

@@ -0,0 +1,230 @@
+export { C as CDPClient, a as CDPClientOptions, T as Transport, d as TransportOptions, c as createCDPClient, b as createTransport } from './client-7Nqka5MV.cjs';
+
+/**
+ * CDP Protocol type definitions
+ * Minimal subset of Chrome DevTools Protocol types needed for browser automation
+ */
+interface CDPRequest {
+    id: number;
+    method: string;
+    params?: Record<string, unknown>;
+    sessionId?: string;
+}
+interface CDPResponse {
+    id: number;
+    result?: unknown;
+    error?: CDPErrorData;
+    sessionId?: string;
+}
+interface CDPEvent {
+    method: string;
+    params?: Record<string, unknown>;
+    sessionId?: string;
+}
+interface CDPErrorData {
+    code: number;
+    message: string;
+    data?: string;
+}
+type CDPMessage = CDPResponse | CDPEvent;
+declare class CDPError extends Error {
+    code: number;
+    data?: string;
+    constructor(error: CDPErrorData);
+}
+interface TargetInfo {
+    targetId: string;
+    type: string;
+    title: string;
+    url: string;
+    attached: boolean;
+    canAccessOpener: boolean;
+    browserContextId?: string;
+}
+interface DOMNode {
+    nodeId: number;
+    backendNodeId: number;
+    nodeType: number;
+    nodeName: string;
+    localName: string;
+    nodeValue: string;
+    childNodeCount?: number;
+    children?: DOMNode[];
+    attributes?: string[];
+    documentURL?: string;
+    baseURL?: string;
+    publicId?: string;
+    systemId?: string;
+    internalSubset?: string;
+    xmlVersion?: string;
+    name?: string;
+    value?: string;
+    pseudoType?: string;
+    shadowRootType?: string;
+    frameId?: string;
+    contentDocument?: DOMNode;
+    shadowRoots?: DOMNode[];
+    templateContent?: DOMNode;
+    pseudoElements?: DOMNode[];
+    importedDocument?: DOMNode;
+    distributedNodes?: BackendNode[];
+    isSVG?: boolean;
+}
+interface BackendNode {
+    nodeType: number;
+    nodeName: string;
+    backendNodeId: number;
+}
+interface AXNode {
+    nodeId: string;
+    ignored: boolean;
+    ignoredReasons?: AXProperty[];
+    role?: AXValue;
+    chromeRole?: AXValue;
+    name?: AXValue;
+    description?: AXValue;
+    value?: AXValue;
+    properties?: AXProperty[];
+    parentId?: string;
+    childIds?: string[];
+    backendDOMNodeId?: number;
+    frameId?: string;
+}
+interface AXValue {
+    type: string;
+    value?: unknown;
+    relatedNodes?: AXRelatedNode[];
+    sources?: AXValueSource[];
+}
+interface AXRelatedNode {
+    backendDOMNodeId: number;
+    idref?: string;
+    text?: string;
+}
+interface AXValueSource {
+    type: string;
+    value?: AXValue;
+    attribute?: string;
+    attributeValue?: AXValue;
+    superseded?: boolean;
+    nativeSource?: string;
+    nativeSourceValue?: AXValue;
+    invalid?: boolean;
+    invalidReason?: string;
+}
+interface AXProperty {
+    name: string;
+    value: AXValue;
+}
+interface RemoteObject {
+    type: string;
+    subtype?: string;
+    className?: string;
+    value?: unknown;
+    unserializableValue?: string;
+    description?: string;
+    objectId?: string;
+    preview?: ObjectPreview;
+    customPreview?: CustomPreview;
+}
+interface ObjectPreview {
+    type: string;
+    subtype?: string;
+    description?: string;
+    overflow: boolean;
+    properties: PropertyPreview[];
+    entries?: EntryPreview[];
+}
+interface PropertyPreview {
+    name: string;
+    type: string;
+    value?: string;
+    valuePreview?: ObjectPreview;
+    subtype?: string;
+}
+interface EntryPreview {
+    key?: ObjectPreview;
+    value: ObjectPreview;
+}
+interface CustomPreview {
+    header: string;
+    bodyGetterId?: string;
+}
+interface ExceptionDetails {
+    exceptionId: number;
+    text: string;
+    lineNumber: number;
+    columnNumber: number;
+    scriptId?: string;
+    url?: string;
+    stackTrace?: StackTrace;
+    exception?: RemoteObject;
+    executionContextId?: number;
+}
+interface StackTrace {
+    description?: string;
+    callFrames: CallFrame[];
+    parent?: StackTrace;
+    parentId?: StackTraceId;
+}
+interface CallFrame {
+    functionName: string;
+    scriptId: string;
+    url: string;
+    lineNumber: number;
+    columnNumber: number;
+}
+interface StackTraceId {
+    id: string;
+    debuggerId?: string;
+}
+type MouseButton = 'none' | 'left' | 'middle' | 'right' | 'back' | 'forward';
+type MouseEventType = 'mousePressed' | 'mouseReleased' | 'mouseMoved' | 'mouseWheel';
+type KeyEventType = 'keyDown' | 'keyUp' | 'rawKeyDown' | 'char';
+interface FrameTree {
+    frame: FrameInfo;
+    childFrames?: FrameTree[];
+}
+interface FrameInfo {
+    id: string;
+    parentId?: string;
+    loaderId: string;
+    name?: string;
+    url: string;
+    urlFragment?: string;
+    domainAndRegistry: string;
+    securityOrigin: string;
+    mimeType: string;
+    unreachableUrl?: string;
+    adFrameStatus?: AdFrameStatus;
+    secureContextType: string;
+    crossOriginIsolatedContextType: string;
+    gatedAPIFeatures: string[];
+}
+interface AdFrameStatus {
+    adFrameType: string;
+    explanations?: string[];
+}
+interface Viewport {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+    scale: number;
+}
+interface BoxModel {
+    content: number[];
+    padding: number[];
+    border: number[];
+    margin: number[];
+    width: number;
+    height: number;
+    shapeOutside?: ShapeOutsideInfo;
+}
+interface ShapeOutsideInfo {
+    bounds: number[];
+    shape: unknown[];
+    marginShape: unknown[];
+}
+
+export { type AXNode, type AXProperty, type AXRelatedNode, type AXValue, type AXValueSource, type AdFrameStatus, type BackendNode, type BoxModel, CDPError, type CDPErrorData, type CDPEvent, type CDPMessage, type CDPRequest, type CDPResponse, type CallFrame, type CustomPreview, type DOMNode, type EntryPreview, type ExceptionDetails, type FrameInfo, type FrameTree, type KeyEventType, type MouseButton, type MouseEventType, type ObjectPreview, type PropertyPreview, type RemoteObject, type ShapeOutsideInfo, type StackTrace, type StackTraceId, type TargetInfo, type Viewport };