browser-pilot 0.0.11 → 0.0.13

package/dist/chunk-FAUNIZR7.mjs

@@ -1,751 +0,0 @@
-// src/browser/types.ts
-var ElementNotFoundError = class extends Error {
-  selectors;
-  hints;
-  constructor(selectors, hints) {
-    const selectorList = Array.isArray(selectors) ? selectors : [selectors];
-    let msg = `Element not found: ${selectorList.join(", ")}`;
-    if (hints?.length) {
-      msg += `. Did you mean: ${hints.slice(0, 3).map((h) => `${h.element.ref} (${h.element.role} "${h.element.name}")`).join(", ")}`;
-    }
-    msg += `. Run 'bp snapshot' to see available elements.`;
-    super(msg);
-    this.name = "ElementNotFoundError";
-    this.selectors = selectorList;
-    this.hints = hints;
-  }
-};
-var TimeoutError = class extends Error {
-  constructor(message = "Operation timed out") {
-    const msg = message.includes("bp snapshot") ? message : `${message}. Run 'bp snapshot' to check current page state.`;
-    super(msg);
-    this.name = "TimeoutError";
-  }
-};
-var NavigationError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "NavigationError";
-  }
-};
-
-// 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);
-        const hints = error instanceof ElementNotFoundError ? error.hints : void 0;
-        results.push({
-          index: i,
-          action: step.action,
-          selector: step.selector,
-          success: false,
-          durationMs: Date.now() - stepStart,
-          error: errorMessage,
-          hints
-        });
-        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 === true) {
-          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,
-          blur: step.blur
-        });
-        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",
-          waitForNavigation: step.waitForNavigation
-        });
-        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: {
-        const action = step.action;
-        const aliases = {
-          execute: "evaluate",
-          navigate: "goto",
-          input: "fill",
-          tap: "click",
-          go: "goto",
-          run: "evaluate",
-          capture: "screenshot",
-          inspect: "snapshot",
-          enter: "press",
-          open: "goto",
-          visit: "goto",
-          eval: "evaluate",
-          js: "evaluate",
-          snap: "snapshot",
-          frame: "switchFrame"
-        };
-        const suggestion = aliases[action.toLowerCase()];
-        const hint = suggestion ? ` Did you mean "${suggestion}"?` : "";
-        const valid = "goto, click, fill, type, select, check, uncheck, submit, press, focus, hover, scroll, wait, snapshot, screenshot, evaluate, text, switchFrame, switchToMain";
-        throw new Error(`Unknown action "${action}".${hint}
-
-Valid actions: ${valid}`);
-      }
-    }
-  }
-  /**
-   * Get the actual selector that matched the element.
-   * Uses the last matched selector tracked by Page, falls back to first selector if unavailable.
-   */
-  getUsedSelector(selector) {
-    const matched = this.page.getLastMatchedSelector();
-    if (matched) return matched;
-    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)
-  });
-}
-
-// src/actions/validate.ts
-function levenshtein(a, b) {
-  const m = a.length;
-  const n = b.length;
-  const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
-  for (let i = 0; i <= m; i++) dp[i][0] = i;
-  for (let j = 0; j <= n; j++) dp[0][j] = j;
-  for (let i = 1; i <= m; i++) {
-    for (let j = 1; j <= n; j++) {
-      dp[i][j] = a[i - 1] === b[j - 1] ? dp[i - 1][j - 1] : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
-    }
-  }
-  return dp[m][n];
-}
-var ACTION_ALIASES = {
-  execute: "evaluate",
-  navigate: "goto",
-  input: "fill",
-  tap: "click",
-  go: "goto",
-  run: "evaluate",
-  capture: "screenshot",
-  inspect: "snapshot",
-  enter: "press",
-  keypress: "press",
-  nav: "goto",
-  open: "goto",
-  visit: "goto",
-  browse: "goto",
-  load: "goto",
-  write: "fill",
-  set: "fill",
-  pick: "select",
-  choose: "select",
-  send: "press",
-  eval: "evaluate",
-  js: "evaluate",
-  script: "evaluate",
-  snap: "snapshot",
-  accessibility: "snapshot",
-  a11y: "snapshot",
-  image: "screenshot",
-  pic: "screenshot",
-  frame: "switchFrame",
-  iframe: "switchFrame"
-};
-var PROPERTY_ALIASES = {
-  expression: "value",
-  href: "url",
-  target: "selector",
-  element: "selector",
-  code: "value",
-  script: "value",
-  src: "url",
-  link: "url",
-  char: "key",
-  text: "value",
-  query: "selector",
-  el: "selector",
-  elem: "selector",
-  css: "selector",
-  xpath: "selector",
-  input: "value",
-  content: "value",
-  keys: "key",
-  button: "key",
-  address: "url",
-  page: "url",
-  path: "url"
-};
-var ACTION_RULES = {
-  goto: {
-    required: { url: { type: "string" } },
-    optional: {}
-  },
-  click: {
-    required: { selector: { type: "string|string[]" } },
-    optional: {
-      waitForNavigation: { type: "boolean" }
-    }
-  },
-  fill: {
-    required: { selector: { type: "string|string[]" }, value: { type: "string" } },
-    optional: {
-      blur: { type: "boolean" }
-    }
-  },
-  type: {
-    required: { selector: { type: "string|string[]" }, value: { type: "string" } },
-    optional: {
-      delay: { type: "number" }
-    }
-  },
-  select: {
-    required: {},
-    optional: {
-      selector: { type: "string|string[]" },
-      value: { type: "string|string[]" },
-      trigger: { type: "string|string[]" },
-      option: { type: "string|string[]" },
-      match: { type: "string", enum: ["text", "value", "contains"] }
-    }
-  },
-  check: {
-    required: { selector: { type: "string|string[]" } },
-    optional: {}
-  },
-  uncheck: {
-    required: { selector: { type: "string|string[]" } },
-    optional: {}
-  },
-  submit: {
-    required: { selector: { type: "string|string[]" } },
-    optional: {
-      method: { type: "string", enum: ["enter", "click", "enter+click"] },
-      waitForNavigation: { type: "boolean|auto" }
-    }
-  },
-  press: {
-    required: { key: { type: "string" } },
-    optional: {}
-  },
-  focus: {
-    required: { selector: { type: "string|string[]" } },
-    optional: {}
-  },
-  hover: {
-    required: { selector: { type: "string|string[]" } },
-    optional: {}
-  },
-  scroll: {
-    required: {},
-    optional: {
-      selector: { type: "string|string[]" },
-      x: { type: "number" },
-      y: { type: "number" },
-      direction: { type: "string", enum: ["up", "down", "left", "right"] },
-      amount: { type: "number" }
-    }
-  },
-  wait: {
-    required: {},
-    optional: {
-      selector: { type: "string|string[]" },
-      waitFor: {
-        type: "string",
-        enum: ["visible", "hidden", "attached", "detached", "navigation", "networkIdle"]
-      }
-    }
-  },
-  snapshot: {
-    required: {},
-    optional: {}
-  },
-  screenshot: {
-    required: {},
-    optional: {
-      format: { type: "string", enum: ["png", "jpeg", "webp"] },
-      quality: { type: "number" },
-      fullPage: { type: "boolean" }
-    }
-  },
-  evaluate: {
-    required: { value: { type: "string" } },
-    optional: {}
-  },
-  text: {
-    required: {},
-    optional: {
-      selector: { type: "string|string[]" }
-    }
-  },
-  switchFrame: {
-    required: { selector: { type: "string|string[]" } },
-    optional: {}
-  },
-  switchToMain: {
-    required: {},
-    optional: {}
-  }
-};
-var VALID_ACTIONS = Object.keys(ACTION_RULES);
-var VALID_ACTIONS_LIST = VALID_ACTIONS.join(", ");
-var KNOWN_STEP_FIELDS = /* @__PURE__ */ new Set([
-  "action",
-  "selector",
-  "url",
-  "value",
-  "key",
-  "waitFor",
-  "timeout",
-  "optional",
-  "method",
-  "blur",
-  "delay",
-  "waitForNavigation",
-  "trigger",
-  "option",
-  "match",
-  "x",
-  "y",
-  "direction",
-  "amount",
-  "format",
-  "quality",
-  "fullPage"
-]);
-function resolveAction(name) {
-  if (VALID_ACTIONS.includes(name)) {
-    return { action: name };
-  }
-  const lower = name.toLowerCase();
-  if (ACTION_ALIASES[lower]) {
-    return {
-      action: ACTION_ALIASES[lower],
-      suggestion: `Did you mean "${ACTION_ALIASES[lower]}"?`
-    };
-  }
-  let best = null;
-  let bestDist = Infinity;
-  for (const valid of VALID_ACTIONS) {
-    const dist = levenshtein(lower, valid);
-    if (dist < bestDist) {
-      bestDist = dist;
-      best = valid;
-    }
-  }
-  if (best && bestDist <= 2) {
-    return { action: best, suggestion: `Did you mean "${best}"?` };
-  }
-  return null;
-}
-function suggestProperty(name) {
-  if (PROPERTY_ALIASES[name]) {
-    return PROPERTY_ALIASES[name];
-  }
-  let best = null;
-  let bestDist = Infinity;
-  for (const known of KNOWN_STEP_FIELDS) {
-    if (known === "action") continue;
-    const dist = levenshtein(name, known);
-    if (dist < bestDist) {
-      bestDist = dist;
-      best = known;
-    }
-  }
-  if (best && bestDist <= 2) {
-    return best;
-  }
-  return void 0;
-}
-function checkFieldType(value, rule) {
-  switch (rule.type) {
-    case "string":
-      if (typeof value !== "string") return `expected string, got ${typeof value}`;
-      if (rule.enum && !rule.enum.includes(value)) {
-        return `must be one of: ${rule.enum.join(", ")}`;
-      }
-      return null;
-    case "string|string[]":
-      if (typeof value !== "string" && !Array.isArray(value)) {
-        return `expected string or string[], got ${typeof value}`;
-      }
-      if (Array.isArray(value) && value.some((v) => typeof v !== "string")) {
-        return "array elements must be strings";
-      }
-      return null;
-    case "number":
-      if (typeof value !== "number") return `expected number, got ${typeof value}`;
-      return null;
-    case "boolean":
-      if (typeof value !== "boolean") return `expected boolean, got ${typeof value}`;
-      return null;
-    case "boolean|auto":
-      if (typeof value !== "boolean" && value !== "auto") {
-        return `expected boolean or "auto", got ${typeof value}`;
-      }
-      return null;
-  }
-}
-function validateSteps(steps) {
-  const errors = [];
-  for (let i = 0; i < steps.length; i++) {
-    const step = steps[i];
-    if (!step || typeof step !== "object" || Array.isArray(step)) {
-      errors.push({
-        stepIndex: i,
-        field: "step",
-        message: "step must be a JSON object."
-      });
-      continue;
-    }
-    const obj = step;
-    if (!("action" in obj)) {
-      errors.push({
-        stepIndex: i,
-        field: "action",
-        message: 'missing required "action" field.'
-      });
-      continue;
-    }
-    const actionName = obj["action"];
-    if (typeof actionName !== "string") {
-      errors.push({
-        stepIndex: i,
-        field: "action",
-        message: `"action" must be a string, got ${typeof actionName}.`
-      });
-      continue;
-    }
-    const resolved = resolveAction(actionName);
-    if (!resolved) {
-      errors.push({
-        stepIndex: i,
-        field: "action",
-        message: `unknown action "${actionName}".`,
-        suggestion: `Valid actions: ${VALID_ACTIONS_LIST}`
-      });
-      continue;
-    }
-    if (resolved.suggestion) {
-      errors.push({
-        stepIndex: i,
-        field: "action",
-        message: `unknown action "${actionName}". ${resolved.suggestion}`,
-        suggestion: resolved.suggestion
-      });
-      continue;
-    }
-    const action = resolved.action;
-    const rule = ACTION_RULES[action];
-    for (const key of Object.keys(obj)) {
-      if (key === "action") continue;
-      if (!KNOWN_STEP_FIELDS.has(key)) {
-        const suggestion = suggestProperty(key);
-        errors.push({
-          stepIndex: i,
-          field: key,
-          message: suggestion ? `unknown property "${key}". Did you mean "${suggestion}"?` : `unknown property "${key}".`,
-          suggestion: suggestion ? `Did you mean "${suggestion}"?` : void 0
-        });
-      }
-    }
-    for (const [field, fieldRule] of Object.entries(rule.required)) {
-      if (!(field in obj) || obj[field] === void 0) {
-        errors.push({
-          stepIndex: i,
-          field,
-          message: `missing required "${field}" (${fieldRule.type}).`
-        });
-      } else {
-        const typeErr = checkFieldType(obj[field], fieldRule);
-        if (typeErr) {
-          errors.push({
-            stepIndex: i,
-            field,
-            message: `"${field}" ${typeErr}.`
-          });
-        }
-      }
-    }
-    for (const [field, fieldRule] of Object.entries(rule.optional)) {
-      if (field in obj && obj[field] !== void 0) {
-        const typeErr = checkFieldType(obj[field], fieldRule);
-        if (typeErr) {
-          errors.push({
-            stepIndex: i,
-            field,
-            message: `"${field}" ${typeErr}.`
-          });
-        }
-      }
-    }
-    if ("timeout" in obj && obj["timeout"] !== void 0) {
-      if (typeof obj["timeout"] !== "number") {
-        errors.push({
-          stepIndex: i,
-          field: "timeout",
-          message: `"timeout" expected number, got ${typeof obj["timeout"]}.`
-        });
-      }
-    }
-    if ("optional" in obj && obj["optional"] !== void 0) {
-      if (typeof obj["optional"] !== "boolean") {
-        errors.push({
-          stepIndex: i,
-          field: "optional",
-          message: `"optional" expected boolean, got ${typeof obj["optional"]}.`
-        });
-      }
-    }
-    if (action === "select") {
-      const hasNative = "selector" in obj && "value" in obj;
-      const hasCustom = "trigger" in obj && "option" in obj && "value" in obj;
-      if (!hasNative && !hasCustom) {
-        errors.push({
-          stepIndex: i,
-          field: "selector",
-          message: "select requires either (selector + value) for native select, or (trigger + option + value) for custom select."
-        });
-      }
-    }
-  }
-  return {
-    valid: errors.length === 0,
-    errors,
-    formatted() {
-      if (errors.length === 0) return "";
-      const lines = [`Validation failed (${errors.length} error${errors.length > 1 ? "s" : ""}):`];
-      for (const err of errors) {
-        const stepLabel = err.field === "action" || err.field === "step" ? `Step ${err.stepIndex}` : `Step ${err.stepIndex}`;
-        lines.push("");
-        lines.push(`  ${stepLabel}: ${err.message}`);
-        if (err.suggestion && !err.message.includes(err.suggestion)) {
-          lines.push(`    ${err.suggestion}`);
-        }
-        const step = steps[err.stepIndex];
-        if (step && typeof step === "object") {
-          lines.push(`    Got: ${JSON.stringify(step)}`);
-        }
-      }
-      const hasEvaluateError = errors.some((err) => {
-        const step = steps[err.stepIndex];
-        return step && typeof step === "object" && step["action"] === "evaluate";
-      });
-      if (hasEvaluateError) {
-        lines.push("");
-        lines.push(
-          "Tip: For JavaScript evaluation, use 'bp eval' instead \u2014 no JSON wrapping needed:"
-        );
-        lines.push("  bp eval 'your.expression.here'");
-      }
-      lines.push("");
-      lines.push(`Valid actions: ${VALID_ACTIONS_LIST}`);
-      return lines.join("\n");
-    }
-  };
-}
-
-export {
-  ElementNotFoundError,
-  TimeoutError,
-  NavigationError,
-  BatchExecutor,
-  addBatchToPage,
-  validateSteps
-};