browser-pilot 0.0.1

package/dist/cdp.d.ts

@@ -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.js';
+
+/**
+ * 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 };

package/dist/cdp.mjs

@@ -0,0 +1,10 @@
+import {
+  CDPError,
+  createCDPClient,
+  createTransport
+} from "./chunk-BCOZUKWS.mjs";
+export {
+  CDPError,
+  createCDPClient,
+  createTransport
+};

package/dist/chunk-BCOZUKWS.mjs

@@ -0,0 +1,251 @@
+// 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;
+}
+
+export {
+  CDPError,
+  createTransport,
+  createCDPClient
+};