browser-pilot 0.0.13 → 0.0.14

package/dist/{chunk-VDAMDOS6.mjs → chunk-IN5HPAPB.mjs}

@@ -1,6 +1,7 @@
 import {
-  createCDPClient
-} from "./chunk-HP6R3W32.mjs";
+  createCDPClient,
+  stringifyUnknown
+} from "./chunk-KIFB526Y.mjs";
 import {
   createProvider
 } from "./chunk-BRAFQUMG.mjs";
@@ -11,7 +12,7 @@ import {
   TimeoutError,
   ensureActionable,
   generateHints
-} from "./chunk-A2ZRAEO3.mjs";
+} from "./chunk-XMJABKCF.mjs";
 
 // src/audio/encoding.ts
 function bufferToBase64(data) {
@@ -2327,6 +2328,9 @@ var Page = class {
   brokenFrame = null;
   /** Last matched selector from findElement (for selectorUsed tracking) */
   _lastMatchedSelector;
+  _lastActionCoordinates = null;
+  _lastActionBoundingBox = null;
+  _lastActionTargetMetadata = null;
   /** Last snapshot for stale ref recovery */
   lastSnapshot;
   /** Audio input controller (lazy-initialized) */
@@ -2358,6 +2362,76 @@ var Page = class {
   getLastMatchedSelector() {
     return this._lastMatchedSelector;
   }
+  async getActionTargetMetadata(identifiers) {
+    try {
+      const objectId = identifiers.objectId ?? (identifiers.nodeId ? await this.resolveObjectId(identifiers.nodeId) : void 0);
+      if (!objectId) return null;
+      const response = await this.cdp.send("Runtime.callFunctionOn", {
+        objectId,
+        functionDeclaration: `function() {
+          const tagName = this.tagName?.toLowerCase?.() || '';
+          const inputType =
+            tagName === 'input' && typeof this.type === 'string' ? this.type.toLowerCase() : '';
+          const autocomplete =
+            typeof this.autocomplete === 'string' ? this.autocomplete.toLowerCase() : '';
+          return { tagName, inputType, autocomplete };
+        }`,
+        returnByValue: true
+      });
+      return response.result.value ?? null;
+    } catch {
+      return null;
+    }
+  }
+  async getElementPosition(identifiers) {
+    try {
+      const { quads } = await this.cdp.send(
+        "DOM.getContentQuads",
+        identifiers
+      );
+      if (quads?.length > 0) {
+        const q = quads[0];
+        const minX = Math.min(q[0], q[2], q[4], q[6]);
+        const maxX = Math.max(q[0], q[2], q[4], q[6]);
+        const minY = Math.min(q[1], q[3], q[5], q[7]);
+        const maxY = Math.max(q[1], q[3], q[5], q[7]);
+        return {
+          center: { x: (minX + maxX) / 2, y: (minY + maxY) / 2 },
+          bbox: { x: minX, y: minY, width: maxX - minX, height: maxY - minY }
+        };
+      }
+    } catch {
+    }
+    if (identifiers.nodeId) {
+      const box = await this.getBoxModel(identifiers.nodeId);
+      if (box) {
+        return {
+          center: { x: box.content[0] + box.width / 2, y: box.content[1] + box.height / 2 },
+          bbox: { x: box.content[0], y: box.content[1], width: box.width, height: box.height }
+        };
+      }
+    }
+    return null;
+  }
+  setLastActionPosition(coords, bbox) {
+    this._lastActionCoordinates = coords;
+    this._lastActionBoundingBox = bbox;
+  }
+  getLastActionCoordinates() {
+    return this._lastActionCoordinates;
+  }
+  getLastActionBoundingBox() {
+    return this._lastActionBoundingBox;
+  }
+  getLastActionTargetMetadata() {
+    return this._lastActionTargetMetadata;
+  }
+  /** Reset position tracking (call before each executor step) */
+  resetLastActionPosition() {
+    this._lastActionCoordinates = null;
+    this._lastActionBoundingBox = null;
+    this._lastActionTargetMetadata = null;
+  }
   /**
    * Initialize the page (enable required CDP domains)
    */
@@ -2525,6 +2599,14 @@ var Page = class {
           const quad = quads[0];
           clickX = (quad[0] + quad[2] + quad[4] + quad[6]) / 4;
           clickY = (quad[1] + quad[3] + quad[5] + quad[7]) / 4;
+          const minX = Math.min(quad[0], quad[2], quad[4], quad[6]);
+          const maxX = Math.max(quad[0], quad[2], quad[4], quad[6]);
+          const minY = Math.min(quad[1], quad[3], quad[5], quad[7]);
+          const maxY = Math.max(quad[1], quad[3], quad[5], quad[7]);
+          this.setLastActionPosition(
+            { x: clickX, y: clickY },
+            { x: minX, y: minY, width: maxX - minX, height: maxY - minY }
+          );
         } else {
           throw new Error("No quads");
         }
@@ -2533,6 +2615,10 @@ var Page = class {
         if (!box) throw new Error("Could not get element position");
         clickX = box.content[0] + box.width / 2;
         clickY = box.content[1] + box.height / 2;
+        this.setLastActionPosition(
+          { x: clickX, y: clickY },
+          { x: box.content[0], y: box.content[1], width: box.width, height: box.height }
+        );
       }
       const hitTargetCoordinates = this.currentFrame ? void 0 : { x: clickX, y: clickY };
       const HIT_TARGET_RETRIES = 3;
@@ -2583,13 +2669,20 @@ var Page = class {
         if (options.optional) return false;
         throw e;
       }
+      const fillPos = await this.getElementPosition({ nodeId: element.nodeId });
+      if (fillPos) this.setLastActionPosition(fillPos.center, fillPos.bbox);
       const tagInfo = await this.cdp.send("Runtime.callFunctionOn", {
         objectId,
         functionDeclaration: `function() {
-            return { tagName: this.tagName?.toLowerCase() || '', inputType: (this.type || '').toLowerCase() };
+            return {
+              tagName: this.tagName?.toLowerCase() || '',
+              inputType: (this.type || '').toLowerCase(),
+              autocomplete: typeof this.autocomplete === 'string' ? this.autocomplete.toLowerCase() : '',
+            };
           }`,
         returnByValue: true
       });
+      this._lastActionTargetMetadata = tagInfo.result.value;
       const { tagName, inputType } = tagInfo.result.value;
       const specialInputTypes = /* @__PURE__ */ new Set([
         "date",
@@ -2671,6 +2764,9 @@ var Page = class {
         if (options.optional) return false;
         throw e;
       }
+      const typePos = await this.getElementPosition({ nodeId: element.nodeId });
+      if (typePos) this.setLastActionPosition(typePos.center, typePos.bbox);
+      this._lastActionTargetMetadata = await this.getActionTargetMetadata({ objectId });
       await this.cdp.send("DOM.focus", { nodeId: element.nodeId });
       for (const char of text) {
         const def = US_KEYBOARD[char];
@@ -2750,6 +2846,9 @@ var Page = class {
         if (options.optional) return false;
         throw e;
       }
+      const selectPos = await this.getElementPosition({ nodeId: element.nodeId });
+      if (selectPos) this.setLastActionPosition(selectPos.center, selectPos.bbox);
+      this._lastActionTargetMetadata = await this.getActionTargetMetadata({ objectId });
       const metadata = await this.getNativeSelectMetadata(objectId, values);
       if (!metadata.isSelect) {
         throw new Error("select() target must be a native <select> element");
@@ -2886,6 +2985,8 @@ var Page = class {
         if (options.optional) return false;
         throw e;
       }
+      const checkPos = await this.getElementPosition({ nodeId: element.nodeId });
+      if (checkPos) this.setLastActionPosition(checkPos.center, checkPos.bbox);
       const before = await this.cdp.send("Runtime.callFunctionOn", {
         objectId: object.objectId,
         functionDeclaration: "function() { return !!this.checked; }",
@@ -2934,6 +3035,8 @@ var Page = class {
         if (options.optional) return false;
         throw e;
       }
+      const uncheckPos = await this.getElementPosition({ nodeId: element.nodeId });
+      if (uncheckPos) this.setLastActionPosition(uncheckPos.center, uncheckPos.bbox);
       const isRadio = await this.cdp.send(
         "Runtime.callFunctionOn",
         {
@@ -2989,6 +3092,8 @@ var Page = class {
         throw new ElementNotFoundError(selector, hints);
       }
       const objectId = await this.resolveObjectId(element.nodeId);
+      const submitPos = await this.getElementPosition({ nodeId: element.nodeId });
+      if (submitPos) this.setLastActionPosition(submitPos.center, submitPos.bbox);
       const isFormElement = await this.cdp.send(
         "Runtime.callFunctionOn",
         {
@@ -3085,6 +3190,8 @@ var Page = class {
       const hints = await generateHints(this, selectorList, "focus");
       throw new ElementNotFoundError(selector, hints);
     }
+    const focusPos = await this.getElementPosition({ nodeId: element.nodeId });
+    if (focusPos) this.setLastActionPosition(focusPos.center, focusPos.bbox);
     await this.cdp.send("DOM.focus", { nodeId: element.nodeId });
     return true;
   }
@@ -3120,6 +3227,14 @@ var Page = class {
           const quad = quads[0];
           x = (quad[0] + quad[2] + quad[4] + quad[6]) / 4;
           y = (quad[1] + quad[3] + quad[5] + quad[7]) / 4;
+          const minX = Math.min(quad[0], quad[2], quad[4], quad[6]);
+          const maxX = Math.max(quad[0], quad[2], quad[4], quad[6]);
+          const minY = Math.min(quad[1], quad[3], quad[5], quad[7]);
+          const maxY = Math.max(quad[1], quad[3], quad[5], quad[7]);
+          this.setLastActionPosition(
+            { x, y },
+            { x: minX, y: minY, width: maxX - minX, height: maxY - minY }
+          );
         } else {
           throw new Error("No quads");
         }
@@ -3131,6 +3246,10 @@ var Page = class {
         }
         x = box.content[0] + box.width / 2;
         y = box.content[1] + box.height / 2;
+        this.setLastActionPosition(
+          { x, y },
+          { x: box.content[0], y: box.content[1], width: box.width, height: box.height }
+        );
       }
       await this.cdp.send("Input.dispatchMouseEvent", {
         type: "mouseMoved",
@@ -3156,6 +3275,8 @@ var Page = class {
       if (options.optional) return false;
       throw new ElementNotFoundError(selector);
     }
+    const scrollPos = await this.getElementPosition({ nodeId: element.nodeId });
+    if (scrollPos) this.setLastActionPosition(scrollPos.center, scrollPos.bbox);
     await this.scrollIntoView(element.nodeId);
     return true;
   }
@@ -3917,7 +4038,7 @@ var Page = class {
       return {
         role,
         name,
-        value: value !== void 0 ? String(value) : void 0,
+        value: value !== void 0 ? stringifyUnknown(value) : void 0,
         ref,
         children: children.length > 0 ? children : void 0,
         disabled,
@@ -3979,7 +4100,7 @@ var Page = class {
           selector,
           disabled,
           checked,
-          value: value !== void 0 ? String(value) : void 0
+          value: value !== void 0 ? stringifyUnknown(value) : void 0
         });
       }
     }
@@ -4449,7 +4570,7 @@ var Page = class {
    */
   formatConsoleArgs(args) {
     return args.map((arg) => {
-      if (arg.value !== void 0) return String(arg.value);
+      if (arg.value !== void 0) return stringifyUnknown(arg.value);
       if (arg.description) return arg.description;
       return "[object]";
     }).join(" ");
@@ -5238,6 +5359,25 @@ var Browser = class _Browser {
     this.cdp = cdp;
     this.providerSession = providerSession;
   }
+  /**
+   * Create a Browser from an existing CDPClient (used by daemon fast-path).
+   * The caller is responsible for the CDP connection lifecycle.
+   */
+  static fromCDP(cdp, sessionInfo) {
+    const providerSession = {
+      wsUrl: sessionInfo.wsUrl,
+      sessionId: sessionInfo.sessionId,
+      async close() {
+      }
+    };
+    const provider = {
+      name: sessionInfo.provider ?? "daemon",
+      async createSession() {
+        return providerSession;
+      }
+    };
+    return new _Browser(cdp, provider, providerSession, { provider: "generic" });
+  }
   /**
    * Connect to a browser instance
    */

package/dist/{chunk-HP6R3W32.mjs → chunk-KIFB526Y.mjs}

@@ -2,6 +2,24 @@ import {
   CDPError
 } from "./chunk-JXAUPHZM.mjs";
 
+// src/utils/json.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function stringifyUnknown(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value);
+  }
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return Object.prototype.toString.call(value);
+  }
+}
+
 // src/cdp/transport.ts
 function createTransport(wsUrl, options = {}) {
   const { timeout = 3e4 } = options;
@@ -104,9 +122,16 @@ function getReadyStateString(state) {
 }
 
 // src/cdp/client.ts
+function createCDPClientFromTransport(transport, options = {}) {
+  return buildCDPClient(transport, options);
+}
 async function createCDPClient(wsUrl, options = {}) {
-  const { debug = false, timeout = 3e4 } = options;
+  const { timeout = 3e4 } = options;
   const transport = await createTransport(wsUrl, { timeout });
+  return buildCDPClient(transport, options);
+}
+function buildCDPClient(transport, options = {}) {
+  const { debug = false, timeout = 3e4 } = options;
   let messageId = 0;
   let currentSessionId;
   let connected = true;
@@ -116,7 +141,19 @@ async function createCDPClient(wsUrl, options = {}) {
   transport.onMessage((raw) => {
     let msg;
     try {
-      msg = JSON.parse(raw);
+      const parsed = JSON.parse(raw);
+      if (!isRecord(parsed)) {
+        if (debug) console.error("[CDP] Ignoring non-object message:", raw);
+        return;
+      }
+      if ("id" in parsed && typeof parsed["id"] === "number") {
+        msg = parsed;
+      } else if ("method" in parsed && typeof parsed["method"] === "string") {
+        msg = parsed;
+      } else {
+        if (debug) console.error("[CDP] Ignoring invalid message shape:", raw);
+        return;
+      }
     } catch {
       if (debug) console.error("[CDP] Failed to parse message:", raw);
       return;
@@ -229,6 +266,9 @@ async function createCDPClient(wsUrl, options = {}) {
     onAny(handler) {
       anyEventHandlers.add(handler);
     },
+    offAny(handler) {
+      anyEventHandlers.delete(handler);
+    },
     async close() {
       connected = false;
       await transport.close();
@@ -252,6 +292,8 @@ async function createCDPClient(wsUrl, options = {}) {
 }
 
 export {
+  stringifyUnknown,
   createTransport,
+  createCDPClientFromTransport,
   createCDPClient
 };

package/dist/chunk-LUGLEMVR.mjs

@@ -0,0 +1,11 @@
+// src/daemon/types.ts
+var DAEMON_MAX_AGE_MS = 60 * 60 * 1e3;
+var DAEMON_CONNECT_TIMEOUT_MS = 500;
+var DAEMON_IDLE_TIMEOUT_MS = 60 * 60 * 1e3;
+var DAEMON_READY_TIMEOUT_MS = 3e3;
+
+export {
+  DAEMON_MAX_AGE_MS,
+  DAEMON_CONNECT_TIMEOUT_MS,
+  DAEMON_READY_TIMEOUT_MS
+};

package/dist/chunk-SPSZZH22.mjs

@@ -0,0 +1,308 @@
+// src/utils/json.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function stringifyUnknown(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean" || typeof value === "bigint") {
+    return String(value);
+  }
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return Object.prototype.toString.call(value);
+  }
+}
+
+// src/cdp/protocol.ts
+var CDPError = class extends Error {
+  code;
+  data;
+  constructor(error) {
+    super(error.message);
+    this.name = "CDPError";
+    this.code = error.code;
+    this.data = error.data;
+  }
+};
+
+// src/cdp/transport.ts
+function createTransport(wsUrl, options = {}) {
+  const { timeout = 3e4 } = options;
+  return new Promise((resolve, reject) => {
+    const timeoutId = setTimeout(() => {
+      reject(new Error(`WebSocket connection timeout after ${timeout}ms`));
+    }, timeout);
+    const ws = new WebSocket(wsUrl);
+    const messageHandlers = [];
+    const closeHandlers = [];
+    const errorHandlers = [];
+    ws.addEventListener("open", () => {
+      clearTimeout(timeoutId);
+      const transport = {
+        send(message) {
+          if (ws.readyState === WebSocket.OPEN) {
+            ws.send(message);
+          } else {
+            throw new Error(
+              `Cannot send message, WebSocket is ${getReadyStateString(ws.readyState)}`
+            );
+          }
+        },
+        async close() {
+          return new Promise((resolveClose) => {
+            if (ws.readyState === WebSocket.CLOSED) {
+              resolveClose();
+              return;
+            }
+            let settled = false;
+            let fallbackTimer;
+            const finish = () => {
+              if (settled) return;
+              settled = true;
+              if (fallbackTimer) clearTimeout(fallbackTimer);
+              ws.removeEventListener("close", onClose);
+              resolveClose();
+            };
+            const onClose = () => {
+              finish();
+            };
+            ws.addEventListener("close", onClose);
+            try {
+              if (ws.readyState === WebSocket.OPEN || ws.readyState === WebSocket.CONNECTING) {
+                ws.close();
+              }
+            } catch {
+              finish();
+              return;
+            }
+            fallbackTimer = setTimeout(finish, 200);
+          });
+        },
+        onMessage(handler) {
+          messageHandlers.push(handler);
+        },
+        onClose(handler) {
+          closeHandlers.push(handler);
+        },
+        onError(handler) {
+          errorHandlers.push(handler);
+        }
+      };
+      resolve(transport);
+    });
+    ws.addEventListener("message", (event) => {
+      const data = typeof event.data === "string" ? event.data : String(event.data);
+      for (const handler of messageHandlers) {
+        handler(data);
+      }
+    });
+    ws.addEventListener("close", () => {
+      for (const handler of closeHandlers) {
+        handler();
+      }
+    });
+    ws.addEventListener("error", (_event) => {
+      clearTimeout(timeoutId);
+      const error = new Error("WebSocket connection error");
+      for (const handler of errorHandlers) {
+        handler(error);
+      }
+      reject(error);
+    });
+  });
+}
+function getReadyStateString(state) {
+  switch (state) {
+    case WebSocket.CONNECTING:
+      return "CONNECTING";
+    case WebSocket.OPEN:
+      return "OPEN";
+    case WebSocket.CLOSING:
+      return "CLOSING";
+    case WebSocket.CLOSED:
+      return "CLOSED";
+    default:
+      return "UNKNOWN";
+  }
+}
+
+// src/cdp/client.ts
+function createCDPClientFromTransport(transport, options = {}) {
+  return buildCDPClient(transport, options);
+}
+async function createCDPClient(wsUrl, options = {}) {
+  const { timeout = 3e4 } = options;
+  const transport = await createTransport(wsUrl, { timeout });
+  return buildCDPClient(transport, options);
+}
+function buildCDPClient(transport, options = {}) {
+  const { debug = false, timeout = 3e4 } = options;
+  let messageId = 0;
+  let currentSessionId;
+  let connected = true;
+  const pending = /* @__PURE__ */ new Map();
+  const eventHandlers = /* @__PURE__ */ new Map();
+  const anyEventHandlers = /* @__PURE__ */ new Set();
+  transport.onMessage((raw) => {
+    let msg;
+    try {
+      const parsed = JSON.parse(raw);
+      if (!isRecord(parsed)) {
+        if (debug) console.error("[CDP] Ignoring non-object message:", raw);
+        return;
+      }
+      if ("id" in parsed && typeof parsed["id"] === "number") {
+        msg = parsed;
+      } else if ("method" in parsed && typeof parsed["method"] === "string") {
+        msg = parsed;
+      } else {
+        if (debug) console.error("[CDP] Ignoring invalid message shape:", raw);
+        return;
+      }
+    } catch {
+      if (debug) console.error("[CDP] Failed to parse message:", raw);
+      return;
+    }
+    if (debug) {
+      console.log("[CDP] <--", JSON.stringify(msg, null, 2).slice(0, 500));
+    }
+    if ("id" in msg && typeof msg.id === "number") {
+      const response = msg;
+      const request = pending.get(response.id);
+      if (request) {
+        pending.delete(response.id);
+        clearTimeout(request.timer);
+        if (response.error) {
+          request.reject(new CDPError(response.error));
+        } else {
+          request.resolve(response.result);
+        }
+      }
+      return;
+    }
+    if ("method" in msg) {
+      const event = msg;
+      const params = event.params ?? {};
+      for (const handler of anyEventHandlers) {
+        try {
+          handler(event.method, params);
+        } catch (e) {
+          if (debug) console.error("[CDP] Error in any-event handler:", e);
+        }
+      }
+      const handlers = eventHandlers.get(event.method);
+      if (handlers) {
+        for (const handler of handlers) {
+          try {
+            handler(params);
+          } catch (e) {
+            if (debug) console.error(`[CDP] Error in handler for ${event.method}:`, e);
+          }
+        }
+      }
+    }
+  });
+  transport.onClose(() => {
+    connected = false;
+    for (const [id, request] of pending) {
+      clearTimeout(request.timer);
+      request.reject(new Error("WebSocket connection closed"));
+      pending.delete(id);
+    }
+  });
+  transport.onError((error) => {
+    if (debug) console.error("[CDP] Transport error:", error);
+  });
+  const client = {
+    async send(method, params, sessionId) {
+      if (!connected) {
+        throw new Error("CDP client is not connected");
+      }
+      const id = ++messageId;
+      const effectiveSessionId = sessionId === null ? void 0 : sessionId ?? currentSessionId;
+      const request = { id, method };
+      if (params !== void 0) {
+        request.params = params;
+      }
+      if (effectiveSessionId !== void 0) {
+        request.sessionId = effectiveSessionId;
+      }
+      const message = JSON.stringify(request);
+      if (debug) {
+        console.log("[CDP] -->", message.slice(0, 500));
+      }
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          pending.delete(id);
+          reject(new Error(`CDP command ${method} timed out after ${timeout}ms`));
+        }, timeout);
+        pending.set(id, {
+          resolve,
+          reject,
+          method,
+          timer
+        });
+        try {
+          transport.send(message);
+        } catch (e) {
+          pending.delete(id);
+          clearTimeout(timer);
+          reject(e);
+        }
+      });
+    },
+    on(event, handler) {
+      let handlers = eventHandlers.get(event);
+      if (!handlers) {
+        handlers = /* @__PURE__ */ new Set();
+        eventHandlers.set(event, handlers);
+      }
+      handlers.add(handler);
+    },
+    off(event, handler) {
+      const handlers = eventHandlers.get(event);
+      if (handlers) {
+        handlers.delete(handler);
+        if (handlers.size === 0) {
+          eventHandlers.delete(event);
+        }
+      }
+    },
+    onAny(handler) {
+      anyEventHandlers.add(handler);
+    },
+    offAny(handler) {
+      anyEventHandlers.delete(handler);
+    },
+    async close() {
+      connected = false;
+      await transport.close();
+    },
+    async attachToTarget(targetId) {
+      const result = await this.send("Target.attachToTarget", {
+        targetId,
+        flatten: true
+      });
+      currentSessionId = result.sessionId;
+      return result.sessionId;
+    },
+    get sessionId() {
+      return currentSessionId;
+    },
+    get isConnected() {
+      return connected;
+    }
+  };
+  return client;
+}
+
+export {
+  CDPError,
+  isRecord,
+  stringifyUnknown,
+  createCDPClientFromTransport,
+  createCDPClient
+};