@xbrowser/cli 1.20.0 → 1.22.0

package/dist/stealth-2AA2FSNN.js

@@ -0,0 +1,29 @@
+import {
+  DEFAULT_STEALTH_CONFIG,
+  StealthInjector,
+  bezierTrajectory,
+  buildStealthInitScript,
+  cosineEase,
+  deriveUaChProfileForBinary,
+  landingOffset,
+  lookupKey,
+  rand,
+  sleep,
+  typingDelay,
+  wheelDelta
+} from "./chunk-GYB5BOSP.js";
+import "./chunk-3RG5ZIWI.js";
+export {
+  DEFAULT_STEALTH_CONFIG,
+  StealthInjector,
+  bezierTrajectory,
+  buildStealthInitScript,
+  cosineEase,
+  deriveUaChProfileForBinary,
+  landingOffset,
+  lookupKey,
+  rand,
+  sleep,
+  typingDelay,
+  wheelDelta
+};

package/dist/stealth-JOXGV34D.js

@@ -0,0 +1,29 @@
+import {
+  DEFAULT_STEALTH_CONFIG,
+  StealthInjector,
+  bezierTrajectory,
+  buildStealthInitScript,
+  cosineEase,
+  deriveUaChProfileForBinary,
+  landingOffset,
+  lookupKey,
+  rand,
+  sleep,
+  typingDelay,
+  wheelDelta
+} from "./chunk-GYB5BOSP.js";
+import "./chunk-KFQGP6VL.js";
+export {
+  DEFAULT_STEALTH_CONFIG,
+  StealthInjector,
+  bezierTrajectory,
+  buildStealthInitScript,
+  cosineEase,
+  deriveUaChProfileForBinary,
+  landingOffset,
+  lookupKey,
+  rand,
+  sleep,
+  typingDelay,
+  wheelDelta
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xbrowser/cli",
-  "version": "1.20.0",
+  "version": "1.22.0",
   "description": "Browser automation CLI for web scraping, headless browsing, SEO analysis, and AI agent workflows. A command-line alternative to Playwright, Puppeteer, and Selenium.",
   "type": "module",
   "bin": {
@@ -75,6 +75,7 @@
     "lint": "eslint src/ bin/ --ext .ts",
     "lint:plugin-contract": "node lint-scripts/check-plugin-contract.mjs && node lint-scripts/check-plugin-status.mjs",
     "lint:plugin-status": "node lint-scripts/check-plugin-status.mjs --update",
+    "stealth:check": "vitest run tests/cdp-driver/stealth-health.test.ts tests/cdp-driver/stealth-audit.test.ts tests/cdp-driver/stealth-probe.test.ts",
     "lint:docs": "node lint-scripts/check-docs-consistency.mjs",
     "typecheck": "tsc --noEmit",
     "start": "node dist/cli.js",

package/dist/session-replayer-SBYJXQZZ.js

@@ -1,413 +0,0 @@
-import {
-  queryJS
-} from "./chunk-3FWLW7FS.js";
-import "./chunk-KFQGP6VL.js";
-
-// src/recorder/session-replayer.ts
-var SessionReplayer = class {
-  opts;
-  recording = null;
-  page = null;
-  constructor(opts) {
-    this.opts = {
-      cdpUrl: opts.cdpUrl,
-      page: opts.page,
-      stepDelay: opts.stepDelay ?? 500,
-      stepTimeout: opts.stepTimeout ?? 1e4,
-      onStep: opts.onStep,
-      onError: opts.onError
-    };
-  }
-  /** Load a recording from a file path or parsed JSON */
-  async load(source) {
-    if (typeof source === "string") {
-      const fs = await import("fs");
-      const raw = fs.readFileSync(source, "utf8");
-      this.recording = JSON.parse(raw);
-    } else {
-      this.recording = source;
-    }
-  }
-  /** Run the full replay */
-  async run() {
-    if (!this.recording) throw new Error("No recording loaded. Call load() first.");
-    if (this.opts.page) {
-      this.page = this.opts.page;
-    } else if (this.opts.cdpUrl) {
-      const { launch } = await import("./cdp-driver-73F5CVH2.js");
-      const { browser } = await launch({ cdpEndpoint: this.opts.cdpUrl });
-      let contexts = browser.contexts();
-      for (let i = 0; i < 10 && contexts.length === 0; i++) {
-        await new Promise((r) => setTimeout(r, 500));
-        contexts = browser.contexts();
-      }
-      const context = contexts[0];
-      if (!context) throw new Error("No browser context available");
-      const pages = context.pages();
-      this.page = pages[0];
-    }
-    if (!this.page) throw new Error("No page available. Provide cdpUrl or page.");
-    const actions = this.dedupAdjacentActions(this.recording.actions);
-    let success = 0;
-    let failed = 0;
-    let skipped = 0;
-    for (let i = 0; i < actions.length; i++) {
-      const action = actions[i];
-      this.opts.onStep?.(action, i, actions.length);
-      const pagesBefore = this.listContextPages();
-      try {
-        if (action.trajectory) {
-          await this.replayTrajectory(action.trajectory);
-        }
-        await this.replayAction(action);
-        if (action.type !== "resize" && action.type !== "clipboard" && action.type !== "visibility") {
-          try {
-            await this.page.waitForLoadState("domcontentloaded", this.opts.stepTimeout);
-          } catch {
-          }
-        }
-        success++;
-        if (action.type === "click" || action.type === "cdp-click") {
-          const pagesAfter = this.listContextPages();
-          if (pagesAfter && pagesBefore && pagesAfter.length > pagesBefore.length) {
-            const newest = pagesAfter[pagesAfter.length - 1];
-            await newest.bringToFront().catch(() => {
-            });
-            this.page = newest;
-          }
-        }
-      } catch (e) {
-        const err = e instanceof Error ? e : new Error(String(e));
-        this.opts.onError?.(action, err, i);
-        failed++;
-      }
-      if (i < actions.length - 1) {
-        await new Promise((r) => setTimeout(r, this.opts.stepDelay));
-      }
-    }
-    return { success, failed, skipped };
-  }
-  /** Replay a single action */
-  /** Pages of the replayer page's context (best-effort; null if unavailable). */
-  listContextPages() {
-    try {
-      const ctx = this.page.context?.();
-      const pages = ctx?.pages?.();
-      return Array.isArray(pages) ? pages : null;
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * Replay-time adjacent dedup (rec-duel d02/d03/d05).
-   *
-   * The recorder can emit both the real action signal AND the injected cdp
-   * command action for a single interaction when the signal flush lags behind
-   * the recorder-side dedup window (heavy snapshot capture slows polling).
-   * Replaying both executes the interaction twice. Filter here: an action is
-   * skipped when a nearby (≤15s apart) earlier action matches on
-   * type-normalized key (selector + text) AND coordinates agree — either side
-   * lacks coords (cdp actions carry none) or both are within 30px. Two real
-   * clicks on the same element at different spots (canvas buttons) survive.
-   */
-  dedupAdjacentActions(actions) {
-    const normType = (t) => t === "cdp-click" ? "click" : t === "cdp-fill" ? "input" : t;
-    const generic = (a) => (a.type === "click" || a.type === "dblclick" || a.type === "contextmenu") && (a.element?.selector === "html" || a.element?.selector === "body");
-    const keyOf = (a) => `${normType(a.type)}|${a.element?.selector || ""}|${a.element?.text || ""}`;
-    const coordsOf = (a) => typeof a.x === "number" && typeof a.y === "number" ? { x: a.x, y: a.y } : null;
-    const near = (p, q) => Math.abs(p.x - q.x) <= 30 && Math.abs(p.y - q.y) <= 30;
-    const lastKept = /* @__PURE__ */ new Map();
-    return actions.filter((a) => {
-      if (generic(a)) return false;
-      const key = keyOf(a);
-      const c = coordsOf(a);
-      const recent = lastKept.get(key) || [];
-      const dup = recent.some((e) => Math.abs(a.timestamp - e.ts) <= 15e3 && (!c || !e.c || near(c, e.c)));
-      if (dup) return false;
-      recent.push({ ts: a.timestamp, c });
-      lastKept.set(key, recent);
-      return true;
-    });
-  }
-  async replayAction(action) {
-    const page = this.page;
-    const timeout = this.opts.stepTimeout;
-    switch (action.type) {
-      // Proactive sensing actions are observations, not user actions — skip
-      // them during replay (they don't represent anything the user did).
-      case "popup_appear":
-      case "discovered_filters":
-        return;
-      case "navigation":
-        await page.goto(action.url, { waitUntil: "load", timeout });
-        break;
-      case "goto":
-        await page.goto(action.url, { waitUntil: "load", timeout });
-        break;
-      case "click":
-      case "cdp-click": {
-        const selector = await this.resolveAndWait(action);
-        if (typeof action.x === "number" && typeof action.y === "number") {
-          const hit = await page.evaluate(`
-            (function() {
-              const el = ${queryJS(selector)};
-              if (!el) return false;
-              const r = el.getBoundingClientRect();
-              return ${action.x} >= r.x - 2 && ${action.x} <= r.x + r.width + 2
-                  && ${action.y} >= r.y - 2 && ${action.y} <= r.y + r.height + 2;
-            })()
-          `).catch(() => false);
-          if (hit) {
-            await page.mouse.click(action.x, action.y, { stealth: true });
-            break;
-          }
-        }
-        await page.click(selector, { timeout });
-        break;
-      }
-      case "scroll": {
-        const [dir, distStr] = (action.value || "down:300").split(":");
-        const dist = Number(distStr) || 300;
-        const sign = dir === "up" ? -1 : dir === "left" ? 0 : 1;
-        const selector = await this.resolveAndWait(action).catch(() => void 0);
-        if (selector) {
-          await page.evaluate(`
-            (function() {
-              const el = ${queryJS(selector)};
-              if (el) el.scrollTop += ${sign * dist};
-            })()
-          `).catch(() => {
-          });
-        } else {
-          await page.evaluate(`window.scrollBy(0, ${sign * dist})`).catch(() => {
-          });
-        }
-        break;
-      }
-      case "input": {
-        const selector = await this.resolveAndWait(action);
-        await page.fill(selector, action.value ?? "", { timeout });
-        break;
-      }
-      case "cdp-fill": {
-        const selector = await this.resolveAndWait(action);
-        await page.fill(selector, action.value ?? "", { timeout });
-        break;
-      }
-      case "change": {
-        const selector = await this.resolveAndWait(action);
-        if (action.value) {
-          await page.selectOption(selector, action.value);
-        }
-        break;
-      }
-      case "filechooser": {
-        const selector = await this.resolveAndWait(action);
-        const files = this.resolveFiles(action);
-        if (files.length > 0) {
-          await page.setInputFiles(selector, files);
-        }
-        break;
-      }
-      case "keydown": {
-        const key = action.key ?? "";
-        if (key === "Enter" || key === "Tab" || key === "Escape") {
-          await page.keyboard.press(key);
-        } else if (key === "Backspace") {
-          await page.keyboard.press("Backspace");
-        } else if (key === "Delete") {
-          await page.keyboard.press("Delete");
-        } else if (key.startsWith("Arrow")) {
-          await page.keyboard.press(key);
-        } else if (key.includes("+")) {
-          await page.keyboard.press(key.replace("Meta", "Meta").replace("Ctrl", "Control"));
-        }
-        break;
-      }
-      case "dblclick": {
-        const selector = this.resolveSelector(action);
-        if (selector) {
-          await page.waitForSelector(selector, { state: "visible", timeout });
-          await page.dblclick(selector, { timeout });
-        } else if (action.x !== void 0 && action.y !== void 0) {
-          await page.mouse.dblclick(action.x, action.y);
-        }
-        break;
-      }
-      case "contextmenu": {
-        const selector = this.resolveSelector(action);
-        if (selector) {
-          await page.waitForSelector(selector, { state: "visible", timeout });
-          await page.click(selector, { button: "right", timeout });
-        } else if (action.x !== void 0 && action.y !== void 0) {
-          await page.mouse.click(action.x, action.y, { button: "right" });
-        }
-        break;
-      }
-      case "hover": {
-        const selector = await this.resolveAndWait(action);
-        if (selector) {
-          await page.hover(selector);
-        }
-        const firstPopup = action.hoverContext?.appeared?.[0];
-        if (firstPopup?.selector) {
-          try {
-            await page.waitForSelector(firstPopup.selector, {
-              state: "visible",
-              timeout: 1e3
-            });
-          } catch {
-          }
-        }
-        break;
-      }
-      case "drag": {
-        if (action.drag) {
-          const { fromX, fromY, toX, toY } = action.drag;
-          await page.mouse.move(fromX, fromY);
-          await page.mouse.down();
-          const steps = 5;
-          for (let i = 1; i <= steps; i++) {
-            await page.mouse.move(
-              fromX + (toX - fromX) * i / steps,
-              fromY + (toY - fromY) * i / steps
-            );
-            await new Promise((r) => setTimeout(r, 30));
-          }
-          await page.mouse.up();
-        }
-        break;
-      }
-      case "resize": {
-        break;
-      }
-      case "clipboard": {
-        break;
-      }
-      case "touch": {
-        if (action.touch) {
-          const { touchType, touches } = action.touch;
-          if (touchType === "start" && touches.length > 0) {
-            await page.mouse.move(touches[0].x, touches[0].y);
-            await page.mouse.down();
-          } else if (touchType === "end" && touches.length > 0) {
-            await page.mouse.move(touches[0].x, touches[0].y);
-            await page.mouse.up();
-          }
-        }
-        break;
-      }
-      case "focus": {
-        const selector = await this.resolveAndWait(action);
-        if (action.focus?.focusType === "focus") {
-          await page.locator(selector).focus();
-        }
-        break;
-      }
-      case "visibility": {
-        break;
-      }
-      case "submit": {
-        const selector = await this.resolveAndWait(action);
-        await page.evaluate((sel) => {
-          const form = document.querySelector(sel);
-          if (!form) return;
-          if (typeof form.requestSubmit === "function") {
-            form.requestSubmit();
-          } else {
-            form.dispatchEvent(new Event("submit", { bubbles: true, cancelable: true }));
-          }
-        }, selector);
-        break;
-      }
-      case "scroll": {
-        await page.evaluate(() => {
-          window.scrollBy(action.scrollX ?? 0, action.scrollY ?? 0);
-        });
-        break;
-      }
-      default:
-        break;
-    }
-  }
-  /** Replay a mouse trajectory (smooth movement between actions) */
-  async replayTrajectory(trajectory) {
-    const page = this.page;
-    const { points } = trajectory;
-    if (!points || points.length < 2) return;
-    for (let i = 0; i < points.length; i++) {
-      const { x, y, dt } = points[i];
-      if (dt > 0) {
-        await new Promise((r) => setTimeout(r, Math.min(dt, 200)));
-      }
-      await page.mouse.move(x, y);
-    }
-  }
-  /** Resolve the best selector for an action (primary selector only) */
-  resolveSelector(action) {
-    const el = action.element;
-    if (!el) return "";
-    if (el.selector) {
-      return el.selector;
-    }
-    if (el.tag) {
-      return el.tag;
-    }
-    return "";
-  }
-  /**
-   * X2: Wait for an element using the best available selector, with
-   * confidence-based fallback support.
-   *
-   * Returns the first matching selector, or throws if none match.
-   * Fallback order:
-   *   1. Primary CSS selector (always tried first)
-   *   2. textFallback selector (used when primary fails — not just for low
-   *      confidence, since high-confidence selectors from dynamic attributes
-   *      like data-spm-anchor-id can also fail on replay)
-   *   3. Tag-based fallback (last resort)
-   */
-  async resolveAndWait(action) {
-    const el = action.element;
-    if (!el) throw new Error("No element metadata");
-    const page = this.page;
-    const timeout = this.opts.stepTimeout;
-    const candidates = [];
-    if (el.selector) candidates.push(el.selector);
-    if (el.textFallback?.selector && !candidates.includes(el.textFallback.selector)) {
-      candidates.push(el.textFallback.selector);
-    }
-    if (el.tag && !candidates.includes(el.tag)) {
-      candidates.push(el.tag);
-    }
-    if (candidates.length === 0) throw new Error("No selector available for element");
-    for (const sel of candidates) {
-      try {
-        await page.waitForSelector(sel, { state: "visible", timeout });
-        return sel;
-      } catch {
-      }
-    }
-    throw new Error(`Element not found, tried: ${candidates.join(", ")}`);
-  }
-  /** Resolve file payloads from a filechooser action */
-  resolveFiles(action) {
-    if (!action.files?.fileData) return [];
-    return action.files.fileData.filter((f) => f.dataUrl).map((f) => {
-      const match = f.dataUrl.match(/^data:[^;]+;base64,(.+)$/);
-      if (!match) return null;
-      return {
-        name: f.name,
-        mimeType: f.type || "application/octet-stream",
-        buffer: Buffer.from(match[1], "base64")
-      };
-    }).filter((f) => f !== null);
-  }
-  /** Clean up */
-  async close() {
-    this.page = null;
-  }
-};
-export {
-  SessionReplayer
-};