browser-pilot 0.0.13 → 0.0.15

package/dist/chunk-WPNW23CE.mjs

@@ -0,0 +1,466 @@
+import {
+  createCDPClient
+} from "./chunk-LCNFBXB5.mjs";
+import {
+  Page
+} from "./chunk-USYSHCI3.mjs";
+
+// 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
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function fetchDevToolsJson(host, path, errorPrefix, options = {}) {
+  const protocol = host.includes("://") ? "" : "http://";
+  const attempts = options.attempts ?? 1;
+  let delayMs = options.initialDelayMs ?? 50;
+  const maxDelayMs = options.maxDelayMs ?? 250;
+  let lastError;
+  for (let attempt = 1; attempt <= attempts; attempt++) {
+    try {
+      const response = await fetch(`${protocol}${host}${path}`);
+      if (response.ok) {
+        return await response.json();
+      }
+      lastError = new Error(`${errorPrefix}: ${response.status}`);
+    } catch (error) {
+      lastError = new Error(
+        `${errorPrefix}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+    if (attempt < attempts) {
+      await sleep(delayMs);
+      delayMs = Math.min(delayMs * 2, maxDelayMs);
+    }
+  }
+  throw lastError ?? new Error(errorPrefix);
+}
+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 getBrowserWebSocketUrl(host = "localhost:9222") {
+  const info = await fetchDevToolsJson(host, "/json/version", "Failed to get browser info", {
+    attempts: 10,
+    initialDelayMs: 50,
+    maxDelayMs: 250
+  });
+  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}`);
+  }
+}
+
+// src/browser/browser.ts
+function scoreTarget(t) {
+  let score = 0;
+  if (t.url.startsWith("http://") || t.url.startsWith("https://")) score += 10;
+  if (t.url.startsWith("chrome://")) score -= 20;
+  if (t.url.startsWith("chrome-extension://")) score -= 15;
+  if (t.url.startsWith("devtools://")) score -= 25;
+  if (t.url === "about:blank") score -= 5;
+  if (!t.attached) score += 3;
+  if (t.title && t.title.length > 0) score += 2;
+  return score;
+}
+function pickBestTarget(targets) {
+  if (targets.length === 0) return void 0;
+  const sorted = [...targets].sort((a, b) => scoreTarget(b) - scoreTarget(a));
+  return sorted[0].targetId;
+}
+var Browser = class _Browser {
+  cdp;
+  providerSession;
+  pages = /* @__PURE__ */ new Map();
+  pageCounter = 0;
+  constructor(cdp, _provider, providerSession, _options) {
+    this.cdp = cdp;
+    this.providerSession = providerSession;
+  }
+  /**
+   * Create a Browser from an existing CDPClient (used by daemon fast-path).
+   * The caller is responsible for the CDP connection lifecycle.
+   */
+  static fromCDP(cdp, sessionInfo) {
+    const providerSession = {
+      wsUrl: sessionInfo.wsUrl,
+      sessionId: sessionInfo.sessionId,
+      async close() {
+      }
+    };
+    const provider = {
+      name: sessionInfo.provider ?? "daemon",
+      async createSession() {
+        return providerSession;
+      }
+    };
+    return new _Browser(cdp, provider, providerSession, { provider: "generic" });
+  }
+  /**
+   * Connect to a browser instance
+   */
+  static async connect(options) {
+    const provider = createProvider(options);
+    const session = await provider.createSession(options.session);
+    const cdp = await createCDPClient(session.wsUrl, {
+      debug: options.debug,
+      timeout: options.timeout
+    });
+    return new _Browser(cdp, provider, session, options);
+  }
+  /**
+   * Get or create a page by name.
+   * If no name is provided, returns the first available page or creates a new one.
+   *
+   * Target selection heuristics (when no targetId is specified):
+   * - Prefer http/https URLs over chrome://, devtools://, about:blank
+   * - Prefer unattached targets (not already controlled by another client)
+   * - Filter by targetUrl if provided
+   */
+  async page(name, options) {
+    const pageName = name ?? "default";
+    const cached = this.pages.get(pageName);
+    if (cached) return cached;
+    const targets = await this.cdp.send(
+      "Target.getTargets",
+      void 0,
+      null
+    );
+    let pageTargets = targets.targetInfos.filter((t) => t.type === "page");
+    if (options?.targetUrl) {
+      const urlFilter = options.targetUrl;
+      const filtered = pageTargets.filter((t) => t.url.includes(urlFilter));
+      if (filtered.length > 0) {
+        pageTargets = filtered;
+      } else {
+        console.warn(
+          `[browser-pilot] No targets match URL filter "${urlFilter}", falling back to all page targets`
+        );
+      }
+    }
+    let targetId;
+    if (options?.targetId) {
+      const targetExists = targets.targetInfos.some(
+        (t) => t.type === "page" && t.targetId === options.targetId
+      );
+      if (targetExists) {
+        targetId = options.targetId;
+      } else {
+        console.warn(`[browser-pilot] Target ${options.targetId} no longer exists, falling back`);
+        targetId = pickBestTarget(pageTargets) ?? (await this.cdp.send(
+          "Target.createTarget",
+          {
+            url: "about:blank"
+          },
+          null
+        )).targetId;
+      }
+    } else if (pageTargets.length > 0) {
+      targetId = pickBestTarget(pageTargets);
+    } else {
+      const result = await this.cdp.send(
+        "Target.createTarget",
+        {
+          url: "about:blank"
+        },
+        null
+      );
+      targetId = result.targetId;
+    }
+    await this.cdp.attachToTarget(targetId);
+    const page = new Page(this.cdp, targetId);
+    await page.init();
+    const minViewport = options?.minViewport !== void 0 ? options.minViewport : { width: 200, height: 200 };
+    if (minViewport !== false) {
+      try {
+        const viewport = await page.evaluate(
+          "({ w: window.innerWidth, h: window.innerHeight })"
+        );
+        if (viewport.w < minViewport.width || viewport.h < minViewport.height) {
+          console.warn(
+            `[browser-pilot] Attached target has small viewport (${viewport.w}x${viewport.h}). Applying default viewport override (1280x720). Use { minViewport: false } to disable this check.`
+          );
+          await page.setViewport({ width: 1280, height: 720 });
+        }
+      } catch {
+      }
+    }
+    this.pages.set(pageName, page);
+    return page;
+  }
+  /**
+   * Create a new page (tab)
+   */
+  async newPage(url = "about:blank") {
+    const result = await this.cdp.send(
+      "Target.createTarget",
+      {
+        url
+      },
+      null
+    );
+    await this.cdp.attachToTarget(result.targetId);
+    const page = new Page(this.cdp, result.targetId);
+    await page.init();
+    const name = `page-${++this.pageCounter}`;
+    this.pages.set(name, page);
+    return page;
+  }
+  /**
+   * Close a page by name
+   */
+  async closePage(name) {
+    const page = this.pages.get(name);
+    if (!page) return;
+    const targetId = page.targetId;
+    await this.cdp.send("Target.closeTarget", { targetId }, null);
+    this.pages.delete(name);
+    const deadline = Date.now() + 5e3;
+    while (Date.now() < deadline) {
+      const { targetInfos } = await this.cdp.send(
+        "Target.getTargets",
+        void 0,
+        null
+      );
+      if (!targetInfos.some((t) => t.targetId === targetId)) return;
+      await new Promise((r) => setTimeout(r, 50));
+    }
+  }
+  /**
+   * List all page targets in the connected browser.
+   */
+  async listTargets() {
+    const { targetInfos } = await this.cdp.send(
+      "Target.getTargets",
+      void 0,
+      null
+    );
+    return targetInfos.filter((target) => target.type === "page");
+  }
+  /**
+   * Get the WebSocket URL for this browser connection
+   */
+  get wsUrl() {
+    return this.providerSession.wsUrl;
+  }
+  /**
+   * Get the provider session ID (for resumption)
+   */
+  get sessionId() {
+    return this.providerSession.sessionId;
+  }
+  /**
+   * Get provider metadata
+   */
+  get metadata() {
+    return this.providerSession.metadata;
+  }
+  /**
+   * Check if connected
+   */
+  get isConnected() {
+    return this.cdp.isConnected;
+  }
+  /**
+   * Disconnect from the browser (keeps provider session alive for reconnection)
+   */
+  async disconnect() {
+    this.pages.clear();
+    await this.cdp.close();
+  }
+  /**
+   * Close the browser session completely
+   */
+  async close() {
+    this.pages.clear();
+    await this.cdp.close();
+    await this.providerSession.close();
+  }
+  /**
+   * Get the underlying CDP client (for advanced usage)
+   */
+  get cdpClient() {
+    return this.cdp;
+  }
+};
+function connect(options) {
+  return Browser.connect(options);
+}
+
+export {
+  getBrowserWebSocketUrl,
+  Browser,
+  connect
+};