browser-pilot 0.0.1

package/dist/chunk-R3PS4PCM.mjs

@@ -0,0 +1,207 @@
+// 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
+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") {
+  const protocol = host.includes("://") ? "" : "http://";
+  const response = await fetch(`${protocol}${host}/json/list`);
+  if (!response.ok) {
+    throw new Error(`Failed to discover targets: ${response.status}`);
+  }
+  return await response.json();
+}
+async function getBrowserWebSocketUrl(host = "localhost:9222") {
+  const protocol = host.includes("://") ? "" : "http://";
+  const response = await fetch(`${protocol}${host}/json/version`);
+  if (!response.ok) {
+    throw new Error(`Failed to get browser info: ${response.status}`);
+  }
+  const info = await response.json();
+  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}`);
+  }
+}
+
+export {
+  BrowserBaseProvider,
+  BrowserlessProvider,
+  GenericProvider,
+  discoverTargets,
+  getBrowserWebSocketUrl,
+  createProvider
+};

package/dist/chunk-YEHK2XY3.mjs

@@ -0,0 +1,250 @@
+// src/actions/executor.ts
+var DEFAULT_TIMEOUT = 3e4;
+var BatchExecutor = class {
+  page;
+  constructor(page) {
+    this.page = page;
+  }
+  /**
+   * Execute a batch of steps
+   */
+  async execute(steps, options = {}) {
+    const { timeout = DEFAULT_TIMEOUT, onFail = "stop" } = options;
+    const results = [];
+    const startTime = Date.now();
+    for (let i = 0; i < steps.length; i++) {
+      const step = steps[i];
+      const stepStart = Date.now();
+      try {
+        const result = await this.executeStep(step, timeout);
+        results.push({
+          index: i,
+          action: step.action,
+          selector: step.selector,
+          selectorUsed: result.selectorUsed,
+          success: true,
+          durationMs: Date.now() - stepStart,
+          result: result.value,
+          text: result.text
+        });
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        results.push({
+          index: i,
+          action: step.action,
+          selector: step.selector,
+          success: false,
+          durationMs: Date.now() - stepStart,
+          error: errorMessage
+        });
+        if (onFail === "stop" && !step.optional) {
+          return {
+            success: false,
+            stoppedAtIndex: i,
+            steps: results,
+            totalDurationMs: Date.now() - startTime
+          };
+        }
+      }
+    }
+    const allSuccess = results.every((r) => r.success || steps[r.index]?.optional);
+    return {
+      success: allSuccess,
+      steps: results,
+      totalDurationMs: Date.now() - startTime
+    };
+  }
+  /**
+   * Execute a single step
+   */
+  async executeStep(step, defaultTimeout) {
+    const timeout = step.timeout ?? defaultTimeout;
+    const optional = step.optional ?? false;
+    switch (step.action) {
+      case "goto": {
+        if (!step.url) throw new Error("goto requires url");
+        await this.page.goto(step.url, { timeout, optional });
+        return {};
+      }
+      case "click": {
+        if (!step.selector) throw new Error("click requires selector");
+        if (step.waitForNavigation) {
+          const navPromise = this.page.waitForNavigation({ timeout, optional });
+          await this.page.click(step.selector, { timeout, optional });
+          await navPromise;
+        } else {
+          await this.page.click(step.selector, { timeout, optional });
+        }
+        return { selectorUsed: this.getUsedSelector(step.selector) };
+      }
+      case "fill": {
+        if (!step.selector) throw new Error("fill requires selector");
+        if (typeof step.value !== "string") throw new Error("fill requires string value");
+        await this.page.fill(step.selector, step.value, {
+          timeout,
+          optional,
+          clear: step.clear ?? true
+        });
+        return { selectorUsed: this.getUsedSelector(step.selector) };
+      }
+      case "type": {
+        if (!step.selector) throw new Error("type requires selector");
+        if (typeof step.value !== "string") throw new Error("type requires string value");
+        await this.page.type(step.selector, step.value, {
+          timeout,
+          optional,
+          delay: step.delay ?? 50
+        });
+        return { selectorUsed: this.getUsedSelector(step.selector) };
+      }
+      case "select": {
+        if (step.trigger && step.option && typeof step.value === "string") {
+          await this.page.select(
+            {
+              trigger: step.trigger,
+              option: step.option,
+              value: step.value,
+              match: step.match
+            },
+            { timeout, optional }
+          );
+          return { selectorUsed: this.getUsedSelector(step.trigger) };
+        }
+        if (!step.selector) throw new Error("select requires selector");
+        if (!step.value) throw new Error("select requires value");
+        await this.page.select(step.selector, step.value, { timeout, optional });
+        return { selectorUsed: this.getUsedSelector(step.selector) };
+      }
+      case "check": {
+        if (!step.selector) throw new Error("check requires selector");
+        await this.page.check(step.selector, { timeout, optional });
+        return { selectorUsed: this.getUsedSelector(step.selector) };
+      }
+      case "uncheck": {
+        if (!step.selector) throw new Error("uncheck requires selector");
+        await this.page.uncheck(step.selector, { timeout, optional });
+        return { selectorUsed: this.getUsedSelector(step.selector) };
+      }
+      case "submit": {
+        if (!step.selector) throw new Error("submit requires selector");
+        await this.page.submit(step.selector, {
+          timeout,
+          optional,
+          method: step.method ?? "enter+click"
+        });
+        return { selectorUsed: this.getUsedSelector(step.selector) };
+      }
+      case "press": {
+        if (!step.key) throw new Error("press requires key");
+        await this.page.press(step.key);
+        return {};
+      }
+      case "focus": {
+        if (!step.selector) throw new Error("focus requires selector");
+        await this.page.focus(step.selector, { timeout, optional });
+        return { selectorUsed: this.getUsedSelector(step.selector) };
+      }
+      case "hover": {
+        if (!step.selector) throw new Error("hover requires selector");
+        await this.page.hover(step.selector, { timeout, optional });
+        return { selectorUsed: this.getUsedSelector(step.selector) };
+      }
+      case "scroll": {
+        if (step.x !== void 0 || step.y !== void 0) {
+          await this.page.scroll("body", { x: step.x, y: step.y, timeout, optional });
+          return {};
+        }
+        if (!step.selector && (step.direction || step.amount !== void 0)) {
+          const amount = step.amount ?? 500;
+          const direction = step.direction ?? "down";
+          const deltaY = direction === "down" ? amount : direction === "up" ? -amount : 0;
+          const deltaX = direction === "right" ? amount : direction === "left" ? -amount : 0;
+          await this.page.evaluate(`window.scrollBy(${deltaX}, ${deltaY})`);
+          return {};
+        }
+        if (!step.selector) throw new Error("scroll requires selector, coordinates, or direction");
+        await this.page.scroll(step.selector, { timeout, optional });
+        return { selectorUsed: this.getUsedSelector(step.selector) };
+      }
+      case "wait": {
+        if (!step.selector && !step.waitFor) {
+          const delay = step.timeout ?? 1e3;
+          await new Promise((resolve) => setTimeout(resolve, delay));
+          return {};
+        }
+        if (step.waitFor === "navigation") {
+          await this.page.waitForNavigation({ timeout, optional });
+          return {};
+        }
+        if (step.waitFor === "networkIdle") {
+          await this.page.waitForNetworkIdle({ timeout, optional });
+          return {};
+        }
+        if (!step.selector)
+          throw new Error(
+            "wait requires selector (or waitFor: navigation/networkIdle, or timeout for simple delay)"
+          );
+        await this.page.waitFor(step.selector, {
+          timeout,
+          optional,
+          state: step.waitFor ?? "visible"
+        });
+        return { selectorUsed: this.getUsedSelector(step.selector) };
+      }
+      case "snapshot": {
+        const snapshot = await this.page.snapshot();
+        return { value: snapshot };
+      }
+      case "screenshot": {
+        const data = await this.page.screenshot({
+          format: step.format,
+          quality: step.quality,
+          fullPage: step.fullPage
+        });
+        return { value: data };
+      }
+      case "evaluate": {
+        if (typeof step.value !== "string")
+          throw new Error("evaluate requires string value (expression)");
+        const result = await this.page.evaluate(step.value);
+        return { value: result };
+      }
+      case "text": {
+        const selector = Array.isArray(step.selector) ? step.selector[0] : step.selector;
+        const text = await this.page.text(selector);
+        return { text, selectorUsed: selector };
+      }
+      case "switchFrame": {
+        if (!step.selector) throw new Error("switchFrame requires selector");
+        await this.page.switchToFrame(step.selector, { timeout, optional });
+        return { selectorUsed: this.getUsedSelector(step.selector) };
+      }
+      case "switchToMain": {
+        await this.page.switchToMain();
+        return {};
+      }
+      default:
+        throw new Error(
+          `Unknown action: ${step.action}. Run 'bp actions' for available actions.`
+        );
+    }
+  }
+  /**
+   * Get the first selector if multiple were provided
+   * (actual used selector tracking would need to be implemented in Page)
+   */
+  getUsedSelector(selector) {
+    return Array.isArray(selector) ? selector[0] : selector;
+  }
+};
+function addBatchToPage(page) {
+  const executor = new BatchExecutor(page);
+  return Object.assign(page, {
+    batch: (steps, options) => executor.execute(steps, options)
+  });
+}
+
+export {
+  BatchExecutor,
+  addBatchToPage
+};

package/dist/chunk-ZIQA4JOT.mjs

@@ -0,0 +1,226 @@
+// src/emulation/devices.ts
+var devices = {
+  "iPhone 14": {
+    name: "iPhone 14",
+    viewport: {
+      width: 390,
+      height: 844,
+      deviceScaleFactor: 3,
+      isMobile: true,
+      hasTouch: true
+    },
+    userAgent: {
+      userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 16_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.0 Mobile/15E148 Safari/604.1",
+      platform: "iPhone",
+      userAgentMetadata: {
+        mobile: true,
+        platform: "iOS",
+        platformVersion: "16.0"
+      }
+    }
+  },
+  "iPhone 14 Pro Max": {
+    name: "iPhone 14 Pro Max",
+    viewport: {
+      width: 430,
+      height: 932,
+      deviceScaleFactor: 3,
+      isMobile: true,
+      hasTouch: true
+    },
+    userAgent: {
+      userAgent: "Mozilla/5.0 (iPhone; CPU iPhone OS 16_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.0 Mobile/15E148 Safari/604.1",
+      platform: "iPhone"
+    }
+  },
+  "Pixel 7": {
+    name: "Pixel 7",
+    viewport: {
+      width: 412,
+      height: 915,
+      deviceScaleFactor: 2.625,
+      isMobile: true,
+      hasTouch: true
+    },
+    userAgent: {
+      userAgent: "Mozilla/5.0 (Linux; Android 13; Pixel 7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Mobile Safari/537.36",
+      platform: "Linux armv8l",
+      userAgentMetadata: {
+        mobile: true,
+        platform: "Android",
+        platformVersion: "13",
+        model: "Pixel 7"
+      }
+    }
+  },
+  "iPad Pro 11": {
+    name: "iPad Pro 11",
+    viewport: {
+      width: 834,
+      height: 1194,
+      deviceScaleFactor: 2,
+      isMobile: true,
+      hasTouch: true
+    },
+    userAgent: {
+      userAgent: "Mozilla/5.0 (iPad; CPU OS 16_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/16.0 Mobile/15E148 Safari/604.1",
+      platform: "iPad"
+    }
+  },
+  "Desktop Chrome": {
+    name: "Desktop Chrome",
+    viewport: {
+      width: 1920,
+      height: 1080,
+      deviceScaleFactor: 1,
+      isMobile: false,
+      hasTouch: false
+    },
+    userAgent: {
+      userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+      platform: "Win32",
+      userAgentMetadata: {
+        brands: [
+          { brand: "Not_A Brand", version: "8" },
+          { brand: "Chromium", version: "120" },
+          { brand: "Google Chrome", version: "120" }
+        ],
+        platform: "Windows",
+        platformVersion: "10.0.0",
+        architecture: "x86",
+        bitness: "64",
+        mobile: false
+      }
+    }
+  },
+  "Desktop Firefox": {
+    name: "Desktop Firefox",
+    viewport: {
+      width: 1920,
+      height: 1080,
+      deviceScaleFactor: 1,
+      isMobile: false,
+      hasTouch: false
+    },
+    userAgent: {
+      userAgent: "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0",
+      platform: "Win32"
+    }
+  }
+};
+
+// src/trace/tracer.ts
+var LEVEL_ORDER = {
+  debug: 0,
+  info: 1,
+  warn: 2,
+  error: 3
+};
+var Tracer = class _Tracer {
+  options;
+  constructor(options = {}) {
+    this.options = {
+      enabled: options.enabled ?? false,
+      output: options.output ?? "console",
+      callback: options.callback,
+      level: options.level ?? "info",
+      includeTimings: options.includeTimings ?? true
+    };
+  }
+  /**
+   * Emit a trace event
+   */
+  emit(event) {
+    if (!this.options.enabled) return;
+    if (LEVEL_ORDER[event.level] < LEVEL_ORDER[this.options.level]) {
+      return;
+    }
+    const fullEvent = {
+      ...event,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    switch (this.options.output) {
+      case "console":
+        this.logToConsole(fullEvent);
+        break;
+      case "callback":
+        this.options.callback?.(fullEvent);
+        break;
+      case "silent":
+        break;
+    }
+  }
+  /**
+   * Log event to console
+   */
+  logToConsole(event) {
+    const { level, category, action, selectorUsed, success, durationMs, error } = event;
+    const icon = success === true ? "\u2713" : success === false ? "\u2717" : "\u25CB";
+    const timing = this.options.includeTimings && durationMs !== void 0 ? ` (${durationMs}ms)` : "";
+    const selector = selectorUsed ? ` ${selectorUsed}` : "";
+    const errorStr = error ? ` - ${error}` : "";
+    const message = `[${level.toUpperCase()}] [${category}] ${icon} ${action}${selector}${timing}${errorStr}`;
+    switch (level) {
+      case "debug":
+        console.debug(message);
+        break;
+      case "info":
+        console.info(message);
+        break;
+      case "warn":
+        console.warn(message);
+        break;
+      case "error":
+        console.error(message);
+        break;
+    }
+  }
+  /**
+   * Create a child tracer with modified options
+   */
+  child(options) {
+    return new _Tracer({ ...this.options, ...options });
+  }
+  /**
+   * Enable tracing
+   */
+  enable() {
+    this.options.enabled = true;
+  }
+  /**
+   * Disable tracing
+   */
+  disable() {
+    this.options.enabled = false;
+  }
+  /**
+   * Check if tracing is enabled
+   */
+  get isEnabled() {
+    return this.options.enabled;
+  }
+};
+var globalTracer = null;
+function getTracer() {
+  if (!globalTracer) {
+    globalTracer = new Tracer({ enabled: false });
+  }
+  return globalTracer;
+}
+function enableTracing(options = {}) {
+  globalTracer = new Tracer({ ...options, enabled: true });
+  return globalTracer;
+}
+function disableTracing() {
+  if (globalTracer) {
+    globalTracer.disable();
+  }
+}
+
+export {
+  devices,
+  Tracer,
+  getTracer,
+  enableTracing,
+  disableTracing
+};