browser-pilot 0.0.14 → 0.0.16

package/dist/{chunk-KIFB526Y.mjs → chunk-BVZALQT4.mjs}

@@ -168,7 +168,8 @@ function buildCDPClient(transport, options = {}) {
         pending.delete(response.id);
         clearTimeout(request.timer);
         if (response.error) {
-          request.reject(new CDPError(response.error));
+          const error = typeof response.error === "string" ? { code: -32e3, message: response.error } : response.error;
+          request.reject(new CDPError(error));
         } else {
           request.resolve(response.result);
         }
@@ -284,6 +285,9 @@ function buildCDPClient(transport, options = {}) {
     get sessionId() {
       return currentSessionId;
     },
+    setSessionId(sessionId) {
+      currentSessionId = sessionId;
+    },
     get isConnected() {
       return connected;
     }

package/dist/chunk-DTVRFXKI.mjs

@@ -0,0 +1,35 @@
+// 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/utils/json.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function stringifyUnknown(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value);
+  }
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return Object.prototype.toString.call(value);
+  }
+}
+
+export {
+  CDPError,
+  isRecord,
+  stringifyUnknown
+};

package/dist/chunk-EZNZ72VA.mjs

@@ -0,0 +1,563 @@
+import {
+  createCDPClient
+} from "./chunk-BVZALQT4.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 discoverTargets(host = "localhost:9222") {
+  return fetchDevToolsJson(host, "/json/list", "Failed to discover targets");
+}
+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}`);
+  }
+}
+
+export {
+  BrowserBaseProvider,
+  BrowserlessProvider,
+  GenericProvider,
+  discoverTargets,
+  getBrowserWebSocketUrl,
+  resolveChromeUserDataDirs,
+  buildLocalBrowserScanTargets,
+  parseDevToolsActivePortFile,
+  discoverLocalBrowsers,
+  BrowserEndpointResolutionError,
+  resolveBrowserEndpoint,
+  createProvider
+};

package/dist/{chunk-SPSZZH22.mjs → chunk-LCNFBXB5.mjs}

@@ -1,32 +1,7 @@
-// src/utils/json.ts
-function isRecord(value) {
-  return typeof value === "object" && value !== null;
-}
-function stringifyUnknown(value) {
-  if (typeof value === "string") return value;
-  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
-    return String(value);
-  }
-  if (value === null) return "null";
-  if (value === void 0) return "undefined";
-  try {
-    return JSON.stringify(value);
-  } catch {
-    return Object.prototype.toString.call(value);
-  }
-}
-
-// 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;
-  }
-};
+import {
+  CDPError,
+  isRecord
+} from "./chunk-DTVRFXKI.mjs";
 
 // src/cdp/transport.ts
 function createTransport(wsUrl, options = {}) {
@@ -176,7 +151,8 @@ function buildCDPClient(transport, options = {}) {
         pending.delete(response.id);
         clearTimeout(request.timer);
         if (response.error) {
-          request.reject(new CDPError(response.error));
+          const error = typeof response.error === "string" ? { code: -32e3, message: response.error } : response.error;
+          request.reject(new CDPError(error));
         } else {
           request.resolve(response.result);
         }
@@ -292,6 +268,9 @@ function buildCDPClient(transport, options = {}) {
     get sessionId() {
       return currentSessionId;
     },
+    setSessionId(sessionId) {
+      currentSessionId = sessionId;
+    },
     get isConnected() {
       return connected;
     }
@@ -300,9 +279,6 @@ function buildCDPClient(transport, options = {}) {
 }
 
 export {
-  CDPError,
-  isRecord,
-  stringifyUnknown,
   createCDPClientFromTransport,
   createCDPClient
 };