browser-pilot 0.0.13 → 0.0.14

package/dist/{chunk-A2ZRAEO3.mjs → chunk-XMJABKCF.mjs}

@@ -2,6 +2,230 @@ import {
   CDPError
 } from "./chunk-JXAUPHZM.mjs";
 
+// src/actions/executor.ts
+import * as fs from "fs";
+import { join } from "path";
+
+// src/recording/redaction.ts
+var REDACTED_VALUE = "[REDACTED]";
+var SENSITIVE_AUTOCOMPLETE_TOKENS = [
+  "current-password",
+  "new-password",
+  "one-time-code",
+  "cc-number",
+  "cc-csc",
+  "cc-exp",
+  "cc-exp-month",
+  "cc-exp-year"
+];
+function autocompleteTokens(autocomplete) {
+  if (!autocomplete) return [];
+  return autocomplete.toLowerCase().split(/\s+/).map((token) => token.trim()).filter(Boolean);
+}
+function isSensitiveFieldMetadata(metadata) {
+  if (!metadata) return false;
+  if (metadata.sensitiveValue) return true;
+  const inputType = metadata.inputType?.toLowerCase();
+  if (inputType === "password" || inputType === "hidden") {
+    return true;
+  }
+  const sensitiveAutocompleteTokens = new Set(SENSITIVE_AUTOCOMPLETE_TOKENS);
+  return autocompleteTokens(metadata.autocomplete).some(
+    (token) => sensitiveAutocompleteTokens.has(token)
+  );
+}
+function redactValueForRecording(value, metadata) {
+  if (value === void 0) return void 0;
+  return isSensitiveFieldMetadata(metadata) ? REDACTED_VALUE : value;
+}
+
+// src/browser/action-highlight.ts
+var HIGHLIGHT_STYLES = {
+  click: { outline: "3px solid rgba(229,57,53,0.8)", badge: "#e53935", marker: "crosshair" },
+  fill: { outline: "3px solid rgba(33,150,243,0.8)", badge: "#2196f3" },
+  type: { outline: "3px solid rgba(33,150,243,0.6)", badge: "#2196f3" },
+  select: { outline: "3px solid rgba(156,39,176,0.8)", badge: "#9c27b0" },
+  hover: { outline: "2px dashed rgba(158,158,158,0.5)", badge: "#9e9e9e" },
+  scroll: { outline: "none", badge: "#607d8b", marker: "arrow" },
+  navigate: { outline: "none", badge: "#4caf50" },
+  submit: { outline: "3px solid rgba(255,152,0,0.8)", badge: "#ff9800" },
+  "assert-pass": { outline: "3px solid rgba(76,175,80,0.8)", badge: "#4caf50", marker: "check" },
+  "assert-fail": { outline: "3px solid rgba(244,67,54,0.8)", badge: "#f44336", marker: "cross" },
+  evaluate: { outline: "none", badge: "#ffc107" },
+  focus: { outline: "3px dotted rgba(33,150,243,0.6)", badge: "#2196f3" }
+};
+function buildHighlightScript(options) {
+  const style = HIGHLIGHT_STYLES[options.kind];
+  const label = options.label ? options.label.slice(0, 80) : void 0;
+  const escapedLabel = label ? label.replace(/\\/g, "\\\\").replace(/'/g, "\\'").replace(/\n/g, "\\n") : "";
+  return `(function() {
+    // Remove any existing highlight
+    var existing = document.getElementById('__bp-action-highlight');
+    if (existing) existing.remove();
+
+    var container = document.createElement('div');
+    container.id = '__bp-action-highlight';
+    container.style.cssText = 'position:fixed;top:0;left:0;width:100%;height:100%;pointer-events:none;z-index:99999;';
+
+    ${options.bbox ? `
+    // Element outline
+    var outline = document.createElement('div');
+    outline.style.cssText = 'position:fixed;' +
+      'left:${options.bbox.x}px;top:${options.bbox.y}px;' +
+      'width:${options.bbox.width}px;height:${options.bbox.height}px;' +
+      '${style.outline !== "none" ? `outline:${style.outline};outline-offset:-1px;` : ""}' +
+      'pointer-events:none;box-sizing:border-box;';
+    container.appendChild(outline);
+    ` : ""}
+
+    ${options.point && style.marker === "crosshair" ? `
+    // Crosshair at click point
+    var hLine = document.createElement('div');
+    hLine.style.cssText = 'position:fixed;left:${options.point.x - 12}px;top:${options.point.y}px;' +
+      'width:24px;height:2px;background:${style.badge};pointer-events:none;';
+    var vLine = document.createElement('div');
+    vLine.style.cssText = 'position:fixed;left:${options.point.x}px;top:${options.point.y - 12}px;' +
+      'width:2px;height:24px;background:${style.badge};pointer-events:none;';
+    // Dot at center
+    var dot = document.createElement('div');
+    dot.style.cssText = 'position:fixed;left:${options.point.x - 4}px;top:${options.point.y - 4}px;' +
+      'width:8px;height:8px;border-radius:50%;background:${style.badge};pointer-events:none;';
+    container.appendChild(hLine);
+    container.appendChild(vLine);
+    container.appendChild(dot);
+    ` : ""}
+
+    ${label ? `
+    // Badge with label
+    var badge = document.createElement('div');
+    badge.style.cssText = 'position:fixed;' +
+      ${options.bbox ? `'left:${options.bbox.x}px;top:${Math.max(0, options.bbox.y - 28)}px;'` : options.kind === "navigate" ? "'left:50%;top:8px;transform:translateX(-50%);'" : "'right:8px;top:8px;'"} +
+      'background:${style.badge};color:white;padding:4px 8px;' +
+      'font-family:monospace;font-size:12px;font-weight:bold;' +
+      'border-radius:3px;white-space:nowrap;max-width:400px;overflow:hidden;text-overflow:ellipsis;' +
+      'pointer-events:none;';
+    badge.textContent = '${escapedLabel}';
+    container.appendChild(badge);
+    ` : ""}
+
+    ${style.marker === "check" && options.bbox ? `
+    // Checkmark
+    var check = document.createElement('div');
+    check.style.cssText = 'position:fixed;left:${options.bbox.x + options.bbox.width / 2 - 10}px;' +
+      'top:${options.bbox.y + options.bbox.height / 2 - 10}px;' +
+      'width:20px;height:20px;font-size:18px;color:${style.badge};pointer-events:none;text-align:center;line-height:20px;';
+    check.textContent = '\\u2713';
+    container.appendChild(check);
+    ` : ""}
+
+    ${style.marker === "cross" && options.bbox ? `
+    // Cross mark
+    var cross = document.createElement('div');
+    cross.style.cssText = 'position:fixed;left:${options.bbox.x + options.bbox.width / 2 - 10}px;' +
+      'top:${options.bbox.y + options.bbox.height / 2 - 10}px;' +
+      'width:20px;height:20px;font-size:18px;color:${style.badge};pointer-events:none;text-align:center;line-height:20px;font-weight:bold;';
+    cross.textContent = '\\u2717';
+    container.appendChild(cross);
+    ` : ""}
+
+    document.body.appendChild(container);
+    window.__bpRemoveActionHighlight = function() {
+      var el = document.getElementById('__bp-action-highlight');
+      if (el) el.remove();
+      delete window.__bpRemoveActionHighlight;
+    };
+  })();`;
+}
+async function injectActionHighlight(page, options) {
+  try {
+    await page.evaluate(buildHighlightScript(options));
+  } catch {
+  }
+}
+async function removeActionHighlight(page) {
+  try {
+    await page.evaluate(`(function() {
+      if (window.__bpRemoveActionHighlight) {
+        window.__bpRemoveActionHighlight();
+      }
+    })()`);
+  } catch {
+  }
+}
+function stepToHighlightKind(step) {
+  switch (step.action) {
+    case "click":
+      return "click";
+    case "fill":
+      return "fill";
+    case "type":
+      return "type";
+    case "select":
+      return "select";
+    case "hover":
+      return "hover";
+    case "scroll":
+      return "scroll";
+    case "goto":
+      return "navigate";
+    case "submit":
+      return "submit";
+    case "focus":
+      return "focus";
+    case "evaluate":
+    case "press":
+    case "shortcut":
+      return "evaluate";
+    case "assertVisible":
+    case "assertExists":
+    case "assertText":
+    case "assertUrl":
+    case "assertValue":
+      return step.success ? "assert-pass" : "assert-fail";
+    // Observation-only actions — no highlight
+    case "wait":
+    case "snapshot":
+    case "forms":
+    case "text":
+    case "screenshot":
+    case "newTab":
+    case "closeTab":
+    case "switchFrame":
+    case "switchToMain":
+      return null;
+    default:
+      return null;
+  }
+}
+function getHighlightLabel(step, result, targetMetadata) {
+  switch (step.action) {
+    case "fill":
+    case "type":
+      return typeof step.value === "string" ? `"${redactValueForRecording(step.value, targetMetadata)}"` : void 0;
+    case "select":
+      return redactValueForRecording(
+        typeof step.value === "string" ? step.value : void 0,
+        targetMetadata
+      );
+    case "goto":
+      return step.url;
+    case "evaluate":
+      return "JS";
+    case "press":
+      return step.key;
+    case "shortcut":
+      return step.combo;
+    case "assertText":
+    case "assertUrl":
+    case "assertValue":
+    case "assertVisible":
+    case "assertExists":
+      return result.success ? "\u2713" : "\u2717";
+    default:
+      return void 0;
+  }
+}
+
 // src/browser/actionability.ts
 var ActionabilityError = class extends Error {
   failureType;
@@ -616,6 +840,13 @@ var NavigationError = class extends Error {
 
 // src/actions/executor.ts
 var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_RECORDING_SKIP_ACTIONS = [
+  "wait",
+  "snapshot",
+  "forms",
+  "text",
+  "screenshot"
+];
 function classifyFailure(error) {
   if (error instanceof ElementNotFoundError) {
     return { reason: "missing" };
@@ -695,6 +926,9 @@ var BatchExecutor = class {
     const { timeout = DEFAULT_TIMEOUT, onFail = "stop" } = options;
     const results = [];
     const startTime = Date.now();
+    const recording = options.record ? this.createRecordingContext(options.record) : null;
+    const startUrl = recording ? await this.getPageUrlSafe() : "";
+    let stoppedAtIndex;
     for (let i = 0; i < steps.length; i++) {
       const step = steps[i];
       const stepStart = Date.now();
@@ -707,8 +941,9 @@ var BatchExecutor = class {
           await new Promise((resolve) => setTimeout(resolve, retryDelay));
         }
         try {
+          this.page.resetLastActionPosition();
           const result = await this.executeStep(step, timeout);
-          results.push({
+          const stepResult = {
             index: i,
             action: step.action,
             selector: step.selector,
@@ -716,8 +951,15 @@ var BatchExecutor = class {
             success: true,
             durationMs: Date.now() - stepStart,
             result: result.value,
-            text: result.text
-          });
+            text: result.text,
+            timestamp: Date.now(),
+            coordinates: this.page.getLastActionCoordinates() ?? void 0,
+            boundingBox: this.page.getLastActionBoundingBox() ?? void 0
+          };
+          if (recording && !recording.skipActions.has(step.action)) {
+            await this.captureRecordingFrame(step, stepResult, recording);
+          }
+          results.push(stepResult);
           succeeded = true;
           break;
         } catch (error) {
@@ -738,7 +980,7 @@ var BatchExecutor = class {
           } catch {
           }
         }
-        results.push({
+        const failedResult = {
           index: i,
           action: step.action,
           selector: step.selector,
@@ -748,24 +990,176 @@ var BatchExecutor = class {
           hints,
           failureReason: reason,
           coveringElement,
-          suggestion: getSuggestion(reason)
-        });
+          suggestion: getSuggestion(reason),
+          timestamp: Date.now()
+        };
+        if (recording && !recording.skipActions.has(step.action)) {
+          await this.captureRecordingFrame(step, failedResult, recording);
+        }
+        results.push(failedResult);
         if (onFail === "stop" && !step.optional) {
-          return {
-            success: false,
-            stoppedAtIndex: i,
-            steps: results,
-            totalDurationMs: Date.now() - startTime
-          };
+          stoppedAtIndex = i;
+          break;
         }
       }
     }
-    const allSuccess = results.every((r) => r.success || steps[r.index]?.optional);
+    const totalDurationMs = Date.now() - startTime;
+    const allSuccess = stoppedAtIndex === void 0 && results.every((result) => result.success || steps[result.index]?.optional);
+    let recordingManifest;
+    if (recording) {
+      recordingManifest = await this.writeRecordingManifest(
+        recording,
+        startTime,
+        startUrl,
+        allSuccess
+      );
+    }
     return {
       success: allSuccess,
+      stoppedAtIndex,
       steps: results,
-      totalDurationMs: Date.now() - startTime
+      totalDurationMs,
+      recordingManifest
+    };
+  }
+  createRecordingContext(record) {
+    const baseDir = record.outputDir ?? join(process.cwd(), ".browser-pilot");
+    const screenshotDir = join(baseDir, "screenshots");
+    const manifestPath = join(baseDir, "recording.json");
+    let existingFrames = [];
+    try {
+      const existing = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+      if (existing.frames && Array.isArray(existing.frames)) {
+        existingFrames = existing.frames;
+      }
+    } catch {
+    }
+    fs.mkdirSync(screenshotDir, { recursive: true });
+    return {
+      baseDir,
+      screenshotDir,
+      sessionId: record.sessionId ?? this.page.targetId,
+      frames: existingFrames,
+      format: record.format ?? "webp",
+      quality: Math.max(0, Math.min(100, record.quality ?? 40)),
+      highlights: record.highlights !== false,
+      skipActions: new Set(record.skipActions ?? DEFAULT_RECORDING_SKIP_ACTIONS)
+    };
+  }
+  async getPageUrlSafe() {
+    try {
+      return await this.page.url();
+    } catch {
+      return "";
+    }
+  }
+  /**
+   * Capture a recording screenshot frame with optional highlight overlay
+   */
+  async captureRecordingFrame(step, stepResult, recording) {
+    const targetMetadata = this.page.getLastActionTargetMetadata();
+    let highlightInjected = false;
+    try {
+      const ts = Date.now();
+      const seq = String(recording.frames.length + 1).padStart(4, "0");
+      const filename = `${seq}-${ts}-${stepResult.action}.${recording.format}`;
+      const filepath = join(recording.screenshotDir, filename);
+      if (recording.highlights) {
+        const kind = stepToHighlightKind(stepResult);
+        if (kind) {
+          await injectActionHighlight(this.page, {
+            kind,
+            bbox: stepResult.boundingBox,
+            point: stepResult.coordinates,
+            label: getHighlightLabel(step, stepResult, targetMetadata)
+          });
+          highlightInjected = true;
+        }
+      }
+      const base64 = await this.page.screenshot({
+        format: recording.format,
+        quality: recording.quality
+      });
+      const buffer = Buffer.from(base64, "base64");
+      fs.writeFileSync(filepath, buffer);
+      stepResult.screenshotPath = filepath;
+      let pageUrl;
+      let pageTitle;
+      try {
+        pageUrl = await this.page.url();
+        pageTitle = await this.page.title();
+      } catch {
+      }
+      recording.frames.push({
+        seq: recording.frames.length + 1,
+        timestamp: ts,
+        action: stepResult.action,
+        selector: stepResult.selectorUsed ?? (Array.isArray(step.selector) ? step.selector[0] : step.selector),
+        value: redactValueForRecording(
+          typeof step.value === "string" ? step.value : void 0,
+          targetMetadata
+        ),
+        url: step.url,
+        coordinates: stepResult.coordinates,
+        boundingBox: stepResult.boundingBox,
+        success: stepResult.success,
+        durationMs: stepResult.durationMs,
+        error: stepResult.error,
+        screenshot: filename,
+        pageUrl,
+        pageTitle
+      });
+    } catch {
+    } finally {
+      if (recording.highlights || highlightInjected) {
+        await removeActionHighlight(this.page);
+      }
+    }
+  }
+  /**
+   * Write recording manifest to disk
+   */
+  async writeRecordingManifest(recording, startTime, startUrl, success) {
+    let endUrl = startUrl;
+    let viewport = { width: 1280, height: 720 };
+    try {
+      endUrl = await this.page.url();
+    } catch {
+    }
+    try {
+      const metrics = await this.page.cdpClient.send("Page.getLayoutMetrics");
+      viewport = {
+        width: metrics.cssVisualViewport.clientWidth,
+        height: metrics.cssVisualViewport.clientHeight
+      };
+    } catch {
+    }
+    const manifestPath = join(recording.baseDir, "recording.json");
+    let recordedAt = new Date(startTime).toISOString();
+    let originalStartUrl = startUrl;
+    try {
+      const existing = JSON.parse(fs.readFileSync(manifestPath, "utf-8"));
+      if (existing.recordedAt) recordedAt = existing.recordedAt;
+      if (existing.startUrl) originalStartUrl = existing.startUrl;
+    } catch {
+    }
+    const firstFrameTime = recording.frames[0]?.timestamp ?? startTime;
+    const totalDurationMs = Date.now() - Math.min(firstFrameTime, startTime);
+    const manifest = {
+      version: 1,
+      recordedAt,
+      sessionId: recording.sessionId,
+      startUrl: originalStartUrl,
+      endUrl,
+      viewport,
+      format: recording.format,
+      quality: recording.quality,
+      totalDurationMs,
+      success,
+      frames: recording.frames
     };
+    fs.writeFileSync(manifestPath, JSON.stringify(manifest, null, 2));
+    return manifestPath;
   }
   /**
    * Execute a single step