@xbrowser/cli 1.10.0 → 1.11.0

package/dist/{chunk-4452SPFI.js → chunk-NODRQGOK.js}

@@ -1093,6 +1093,33 @@ var ACTION_SIGNAL_SCRIPT = `
     }
   }, true);
 
+  // \u2500\u2500 Pointer-based drag (modern sliders, sortable lists) \u2500\u2500
+  // HTML5 dragstart/drop never fires for pointer-driven drags \u2014 capture via
+  // pointerdown/pointerup with a movement threshold instead (rec-duel d08).
+  var __xb_ptr_down = null;
+  document.addEventListener('pointerdown', function(e) {
+    var t = actualTarget(e);
+    __xb_ptr_down = { x: e.clientX, y: e.clientY, element: describe(t), ts: Date.now() };
+  }, true);
+  document.addEventListener('pointerup', function(e) {
+    if (!__xb_ptr_down) return;
+    var start = __xb_ptr_down;
+    __xb_ptr_down = null;
+    var dx = e.clientX - start.x, dy = e.clientY - start.y;
+    if (Math.abs(dx) < 15 && Math.abs(dy) < 15) return; // tap/click, not a drag
+    pushAction('drag', {
+      x: e.clientX,
+      y: e.clientY,
+      element: start.element,
+      drag: {
+        fromX: start.x,
+        fromY: start.y,
+        toX: e.clientX,
+        toY: e.clientY,
+      },
+    });
+  }, true);
+
   // \u2500\u2500 Drag & drop \u2500\u2500
   var __xb_drag_source = null;
   var __xb_drag_start_pos = null;
@@ -1985,8 +2012,7 @@ var SessionRecorder = class _SessionRecorder {
     "resize",
     "clipboard",
     "touch",
-    "contextmenu",
-    "drag"
+    "contextmenu"
   ]);
   constructor(context, page, sessionName) {
     this.context = context;
@@ -2003,8 +2029,8 @@ var SessionRecorder = class _SessionRecorder {
   async recordCommandAction(action) {
     const dedupFromAction = this.dedupKey(action.type, action.selector, action.element?.tag, action.value);
     if (dedupFromAction) {
-      const expires = this.dedupMap.get(dedupFromAction);
-      if (expires && Date.now() < expires) {
+      const entry = this.dedupMap.get(dedupFromAction);
+      if (entry && entry.origin === "signal" && Date.now() < entry.expires) {
         return;
       }
     }
@@ -2021,19 +2047,25 @@ var SessionRecorder = class _SessionRecorder {
       value: action.value
     };
     this.actions.push(actionToPush);
-    actionToPush.elementScreenshot = await this.captureElementScreenshot(this.page, {
-      type: action.type,
-      element: actionToPush.element
-    });
-    await this.captureAutoSnapshot(this.page, actionToPush, "after").catch(() => {
-    });
+    actionToPush.elementScreenshot = await Promise.race([
+      this.captureElementScreenshot(this.page, {
+        type: action.type,
+        element: actionToPush.element
+      }).catch(() => void 0),
+      new Promise((r) => setTimeout(r, 3e3))
+    ]);
+    await Promise.race([
+      this.captureAutoSnapshot(this.page, actionToPush, "after").catch(() => {
+      }),
+      new Promise((r) => setTimeout(r, 6e3))
+    ]);
     this.lastActionTs = ts;
-    this.dedupMap.set(dedupFromAction, Date.now() + 2e3);
+    this.dedupMap.set(dedupFromAction, { expires: Date.now() + 4e3, origin: "command" });
     this.dedupActionCount++;
     if (this.dedupActionCount % 200 === 0) {
       const now = Date.now();
       for (const [k, v] of this.dedupMap) {
-        if (now >= v) this.dedupMap.delete(k);
+        if (now >= v.expires) this.dedupMap.delete(k);
       }
     }
     if (action.url && action.url !== "about:blank") {
@@ -2746,8 +2778,8 @@ var SessionRecorder = class _SessionRecorder {
       }
       const dedupFromSignal = this.dedupKey(raw.type, raw.element?.selector, raw.element?.tag, raw.value);
       if (dedupFromSignal) {
-        const expires = this.dedupMap.get(dedupFromSignal);
-        if (expires && Date.now() < expires) {
+        const entry = this.dedupMap.get(dedupFromSignal);
+        if (entry && entry.origin === "command" && Date.now() < entry.expires) {
           continue;
         }
       }
@@ -2790,7 +2822,10 @@ var SessionRecorder = class _SessionRecorder {
         // run before the last sample lands — passthrough keeps whatever has
         // been collected so far.
         hoverContext: raw.hoverContext,
-        files: raw.files
+        files: raw.files,
+        // Pointer-drag payload (fromX/fromY/toX/toY) — replayer replays the
+        // drag from these coordinates; dropping it made drags no-ops (d08)
+        drag: raw.drag
       });
       const pushed = this.actions[this.actions.length - 1];
       pushed.elementScreenshot = await this.captureElementScreenshot(page, raw);
@@ -2799,7 +2834,7 @@ var SessionRecorder = class _SessionRecorder {
       this.lastActionTs = raw.ts;
       const dedupKey = this.dedupKey(raw.type, raw.element?.selector, raw.element?.tag, raw.value);
       if (dedupKey) {
-        this.dedupMap.set(dedupKey, Date.now() + 2e3);
+        this.dedupMap.set(dedupKey, { expires: Date.now() + 4e3, origin: "signal" });
         this.dedupActionCount++;
       }
       const verifyTypes = /* @__PURE__ */ new Set(["click", "submit", "input", "change", "cdp-click", "cdp-fill"]);

package/dist/{chunk-YMUSHPU4.js → chunk-WHPBNUKB.js}

@@ -13,6 +13,7 @@ var pkg = require2("../package.json");
 var version = pkg.version;
 
 // src/client/daemon-client.ts
+import { request as httpRequest } from "http";
 var DAEMON_PORT = 9224;
 var DAEMON_BASE = `http://localhost:${DAEMON_PORT}`;
 var _ensurePromise = null;
@@ -207,7 +208,40 @@ async function forwardRecordSummary(session) {
   return rpcCall("record:summary", { session }, 5e3);
 }
 async function forwardReplay(file, session, slowMo) {
-  return rpcCall("replay", { file, session, slowMo }, 12e4);
+  return longRpcCall("replay", { file, session, slowMo }, 20 * 6e4);
+}
+function longRpcCall(method, params, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    const body = JSON.stringify({ method, params });
+    const req = httpRequest(
+      {
+        hostname: "127.0.0.1",
+        port: DAEMON_PORT,
+        path: "/rpc",
+        method: "POST",
+        headers: { "Content-Type": "application/json", "Content-Length": Buffer.byteLength(body) }
+      },
+      (res) => {
+        const chunks = [];
+        res.on("data", (c) => chunks.push(c));
+        res.on("end", () => {
+          try {
+            const parsed = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+            if (parsed && typeof parsed.error === "string" && Object.keys(parsed).length === 1) {
+              reject(new Error(`Daemon error: ${parsed.error}`));
+            } else {
+              resolve(parsed);
+            }
+          } catch (e) {
+            reject(e instanceof Error ? e : new Error(String(e)));
+          }
+        });
+      }
+    );
+    req.setTimeout(timeoutMs, () => req.destroy(new Error(`replay RPC timeout after ${timeoutMs}ms`)));
+    req.on("error", reject);
+    req.end(body);
+  });
 }
 async function forwardRecordCheckpoint(session, type, hint, selector) {
   return rpcCall("record:checkpoint", { session, type, hint, selector }, 1e4);

package/dist/{chunk-WSCP7QCJ.js → chunk-XKQVUFUS.js}

@@ -1,6 +1,6 @@
 import {
   launch
-} from "./chunk-RRBXV7KE.js";
+} from "./chunk-7OFM755Z.js";
 import {
   errMsg
 } from "./chunk-GDKLH7ZY.js";
@@ -275,15 +275,18 @@ function deleteSessionDiskMeta(name) {
 async function isSessionPageAlive(session) {
   const page = session.page;
   if (!page || typeof page.evaluate !== "function") return false;
-  try {
-    await Promise.race([
-      page.evaluate("1"),
-      new Promise((_, reject) => setTimeout(() => reject(new Error("liveness probe timeout")), 1500))
-    ]);
-    return true;
-  } catch {
-    return false;
+  for (let attempt = 0; attempt < 3; attempt++) {
+    try {
+      await Promise.race([
+        page.evaluate("1"),
+        new Promise((_, reject) => setTimeout(() => reject(new Error("liveness probe timeout")), 1500))
+      ]);
+      return true;
+    } catch {
+      await new Promise((r) => setTimeout(r, 400));
+    }
   }
+  return false;
 }
 async function findOrRestoreSession(name, cdpEndpoint) {
   const inMem = findSession(name);
@@ -706,7 +709,7 @@ async function closeSessionByName(name) {
       } catch {
       }
       try {
-        const { SessionRecorder } = await import("./session-recorder-QRZMKFVL.js");
+        const { SessionRecorder } = await import("./session-recorder-SLDBENVF.js");
         SessionRecorder.cleanup(session.name);
       } catch {
       }