browser-pilot 0.0.14 → 0.0.16

package/dist/chunk-TJ5B56NV.mjs

@@ -0,0 +1,804 @@
+import {
+  createCDPClient
+} from "./chunk-LCNFBXB5.mjs";
+import {
+  Page
+} from "./chunk-6GBYX7C2.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/local-discovery.ts
+var CHANNEL_ORDER = ["stable", "beta", "dev", "canary"];
+var DEFAULT_PROBE_TIMEOUT_MS = 1e3;
+var DevToolsActivePortParseError = class extends Error {
+  constructor(message, reason) {
+    super(message);
+    this.reason = reason;
+    this.name = "DevToolsActivePortParseError";
+  }
+};
+function getRuntimeEnv() {
+  if (typeof process === "undefined") {
+    return {};
+  }
+  return process.env;
+}
+function getRuntimePlatform() {
+  if (typeof process === "undefined") {
+    return void 0;
+  }
+  return process.platform;
+}
+function normalizePlatform(platform) {
+  if (platform === "darwin" || platform === "linux" || platform === "win32") {
+    return platform;
+  }
+  throw new Error(`Unsupported platform: ${platform ?? "unknown"}`);
+}
+function trimTrailingSeparator(path) {
+  return path.replace(/[\\/]+$/, "");
+}
+function joinPath(platform, ...parts) {
+  const separator = platform === "win32" ? "\\" : "/";
+  const cleaned = parts.map((part, index) => {
+    if (index === 0) return trimTrailingSeparator(part);
+    return part.replace(/^[\\/]+/, "").replace(/[\\/]+$/, "");
+  }).filter((part) => part.length > 0);
+  return cleaned.join(separator);
+}
+function resolveHomeDir(platform, env, explicitHomeDir) {
+  if (explicitHomeDir) {
+    return explicitHomeDir;
+  }
+  if (platform === "win32") {
+    return env["USERPROFILE"] ?? env["HOME"] ?? "";
+  }
+  return env["HOME"] ?? env["USERPROFILE"] ?? "";
+}
+function toFileFailure(target, error) {
+  const errno = error?.code;
+  if (errno === "ENOENT") {
+    return {
+      ...target,
+      reason: "missing-file",
+      message: `DevToolsActivePort not found at ${target.portFile}`
+    };
+  }
+  return {
+    ...target,
+    reason: "unreadable-file",
+    message: error instanceof Error ? error.message : `Could not read DevToolsActivePort at ${target.portFile}`
+  };
+}
+function toProbeFailure(target, wsUrl, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const lowerMessage = message.toLowerCase();
+  let reason = "connection-error";
+  if (lowerMessage.includes("refused") || lowerMessage.includes("econnrefused")) {
+    reason = "connection-refused";
+  } else if (lowerMessage.includes("timeout") || lowerMessage.includes("timed out")) {
+    reason = "connection-timeout";
+  } else if (lowerMessage.includes("closed")) {
+    reason = "unexpected-close";
+  } else if (lowerMessage.includes("browser.getversion") || lowerMessage.includes("cdp") || lowerMessage.includes("protocol")) {
+    reason = "cdp-error";
+  }
+  return {
+    ...target,
+    wsUrl,
+    reason,
+    message
+  };
+}
+async function readTextFile(path) {
+  const fs = await import("fs/promises");
+  return fs.readFile(path, "utf-8");
+}
+async function probeBrowserWebSocket(wsUrl, timeoutMs) {
+  let client;
+  try {
+    client = await createCDPClient(wsUrl, { timeout: timeoutMs });
+    const version = await client.send("Browser.getVersion", void 0, null);
+    return { browserVersion: version.product };
+  } finally {
+    await client?.close().catch(() => {
+    });
+  }
+}
+var defaultDependencies = {
+  readTextFile,
+  probeBrowserWebSocket,
+  getLegacyBrowserWebSocketUrl: getBrowserWebSocketUrl
+};
+function resolveChromeUserDataDirs(options = {}) {
+  const env = options.env ?? getRuntimeEnv();
+  const platform = normalizePlatform(options.platform ?? getRuntimePlatform());
+  const homeDir = resolveHomeDir(platform, env, options.homeDir);
+  if (!homeDir) {
+    throw new Error("Could not determine home directory for local Chrome discovery");
+  }
+  switch (platform) {
+    case "darwin": {
+      const base = joinPath(platform, homeDir, "Library", "Application Support", "Google");
+      return {
+        stable: joinPath(platform, base, "Chrome"),
+        beta: joinPath(platform, base, "Chrome Beta"),
+        dev: joinPath(platform, base, "Chrome Dev"),
+        canary: joinPath(platform, base, "Chrome Canary")
+      };
+    }
+    case "linux": {
+      const configHome = env["CHROME_CONFIG_HOME"] ?? env["XDG_CONFIG_HOME"] ?? joinPath(platform, homeDir, ".config");
+      return {
+        stable: joinPath(platform, configHome, "google-chrome"),
+        beta: joinPath(platform, configHome, "google-chrome-beta"),
+        dev: joinPath(platform, configHome, "google-chrome-dev"),
+        canary: joinPath(platform, configHome, "google-chrome-canary")
+      };
+    }
+    case "win32": {
+      const localAppData = env["LOCALAPPDATA"] ?? joinPath(platform, homeDir, "AppData", "Local");
+      const base = joinPath(platform, localAppData, "Google");
+      return {
+        stable: joinPath(platform, base, "Chrome", "User Data"),
+        beta: joinPath(platform, base, "Chrome Beta", "User Data"),
+        dev: joinPath(platform, base, "Chrome Dev", "User Data"),
+        canary: joinPath(platform, base, "Chrome SxS", "User Data")
+      };
+    }
+  }
+  throw new Error(`Unsupported platform for local Chrome discovery: ${platform}`);
+}
+function buildLocalBrowserScanTargets(options = {}) {
+  const env = options.env ?? getRuntimeEnv();
+  const platform = normalizePlatform(options.platform ?? getRuntimePlatform());
+  if (options.userDataDir) {
+    return [
+      {
+        channel: options.channel ?? "custom",
+        userDataDir: options.userDataDir,
+        portFile: joinPath(platform, options.userDataDir, "DevToolsActivePort")
+      }
+    ];
+  }
+  const dirs = resolveChromeUserDataDirs({
+    platform,
+    env,
+    homeDir: options.homeDir
+  });
+  const channels = options.channel ? [options.channel] : CHANNEL_ORDER;
+  return channels.map((channel) => ({
+    channel,
+    userDataDir: dirs[channel],
+    portFile: joinPath(platform, dirs[channel], "DevToolsActivePort")
+  }));
+}
+function parseDevToolsActivePortFile(content) {
+  const lines = content.split(/\r?\n/u).map((line) => line.trim()).filter((line) => line.length > 0);
+  if (lines.length !== 2) {
+    throw new DevToolsActivePortParseError(
+      `Expected exactly 2 non-empty lines in DevToolsActivePort, got ${lines.length}`,
+      "malformed-file"
+    );
+  }
+  const portText = lines[0];
+  const browserPath = lines[1];
+  const port = Number.parseInt(portText, 10);
+  if (!Number.isInteger(port) || port < 1 || port > 65535) {
+    throw new DevToolsActivePortParseError(
+      `Invalid DevToolsActivePort port: ${portText}`,
+      "invalid-port"
+    );
+  }
+  if (!browserPath.startsWith("/devtools/browser/") || browserPath.includes("..") || /[?#\s\\]/u.test(browserPath)) {
+    throw new DevToolsActivePortParseError(
+      `Invalid DevToolsActivePort browser path: ${browserPath}`,
+      "invalid-path"
+    );
+  }
+  return {
+    port,
+    browserPath,
+    wsUrl: `ws://127.0.0.1:${port}${browserPath}`
+  };
+}
+async function inspectScanTarget(target, options, deps) {
+  let content;
+  try {
+    content = await deps.readTextFile(target.portFile);
+  } catch (error) {
+    return { kind: "failure", failure: toFileFailure(target, error) };
+  }
+  let parsed;
+  try {
+    parsed = parseDevToolsActivePortFile(content);
+  } catch (error) {
+    if (error instanceof DevToolsActivePortParseError) {
+      return {
+        kind: "failure",
+        failure: {
+          ...target,
+          reason: error.reason,
+          message: error.message
+        }
+      };
+    }
+    throw error;
+  }
+  try {
+    const probe = await deps.probeBrowserWebSocket(
+      parsed.wsUrl,
+      options.probeTimeoutMs ?? DEFAULT_PROBE_TIMEOUT_MS
+    );
+    return {
+      kind: "candidate",
+      candidate: {
+        ...target,
+        port: parsed.port,
+        browserPath: parsed.browserPath,
+        wsUrl: parsed.wsUrl,
+        browserVersion: probe.browserVersion
+      }
+    };
+  } catch (error) {
+    return {
+      kind: "failure",
+      failure: toProbeFailure(target, parsed.wsUrl, error)
+    };
+  }
+}
+async function discoverLocalBrowsers(options = {}, deps = defaultDependencies) {
+  const scanTargets = buildLocalBrowserScanTargets(options);
+  const outcomes = await Promise.all(
+    scanTargets.map((target) => inspectScanTarget(target, options, deps))
+  );
+  const candidates = [];
+  const failures = [];
+  for (const outcome of outcomes) {
+    if (outcome.kind === "candidate") {
+      candidates.push(outcome.candidate);
+    } else {
+      failures.push(outcome.failure);
+    }
+  }
+  return { candidates, failures };
+}
+var BrowserEndpointResolutionError = class extends Error {
+  constructor(code, message, details = {}) {
+    super(message);
+    this.code = code;
+    this.details = details;
+  }
+  name = "BrowserEndpointResolutionError";
+};
+async function resolveBrowserEndpoint(options = {}, deps = defaultDependencies) {
+  if (options.explicitWsUrl) {
+    return {
+      wsUrl: options.explicitWsUrl,
+      source: "explicit-ws"
+    };
+  }
+  let localDiscovery;
+  if (options.allowLocalDiscovery ?? true) {
+    localDiscovery = await discoverLocalBrowsers(options, deps);
+    if (localDiscovery.candidates.length === 1) {
+      const candidate = localDiscovery.candidates[0];
+      return {
+        wsUrl: candidate.wsUrl,
+        source: "devtools-active-port",
+        channel: candidate.channel,
+        userDataDir: candidate.userDataDir
+      };
+    }
+    if (localDiscovery.candidates.length > 1) {
+      throw new BrowserEndpointResolutionError(
+        "multiple-local-browsers",
+        "Multiple local Chrome profiles are available for auto-discovery",
+        {
+          candidates: localDiscovery.candidates,
+          failures: localDiscovery.failures
+        }
+      );
+    }
+  }
+  if (options.allowLegacyHostFallback ?? true) {
+    const legacyHost = options.legacyHost ?? "localhost:9222";
+    try {
+      return {
+        wsUrl: await deps.getLegacyBrowserWebSocketUrl(legacyHost),
+        source: "json-version"
+      };
+    } catch (error) {
+      throw new BrowserEndpointResolutionError(
+        "browser-not-found",
+        "Could not resolve a browser endpoint",
+        {
+          candidates: localDiscovery?.candidates,
+          failures: localDiscovery?.failures,
+          legacyError: error instanceof Error ? error : new Error(String(error)),
+          legacyHost
+        }
+      );
+    }
+  }
+  throw new BrowserEndpointResolutionError(
+    "browser-not-found",
+    "Could not resolve a browser endpoint",
+    {
+      candidates: localDiscovery?.candidates,
+      failures: localDiscovery?.failures
+    }
+  );
+}
+
+// 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) {
+    let connectOptions = options;
+    if (options.provider === "generic" && !options.wsUrl) {
+      const endpoint = await resolveBrowserEndpoint({
+        channel: options.channel,
+        userDataDir: options.userDataDir,
+        allowLocalDiscovery: true,
+        allowLegacyHostFallback: true
+      });
+      connectOptions = {
+        ...options,
+        wsUrl: endpoint.wsUrl
+      };
+    }
+    const provider = createProvider(connectOptions);
+    const session = await provider.createSession(connectOptions.session);
+    const cdp = await createCDPClient(session.wsUrl, {
+      debug: connectOptions.debug,
+      timeout: connectOptions.timeout
+    });
+    return new _Browser(cdp, provider, session, connectOptions);
+  }
+  /**
+   * 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 {
+  BrowserEndpointResolutionError,
+  resolveBrowserEndpoint,
+  Browser,
+  connect
+};