hypha-debugger 0.2.0 → 0.2.2

package/dist/hypha-debugger.js

@@ -13852,6 +13852,23 @@
    * Images are downscaled before being returned so agents don't receive
    * multi-megabyte base64 payloads that can crash their context window.
    */
+  /** Extract a useful string from an unknown error value. */
+  function errorMessage(err) {
+      if (!err)
+          return "Unknown error";
+      if (typeof err === "string")
+          return err;
+      if (err.message)
+          return err.message;
+      if (err instanceof Event)
+          return `Event: ${err.type}`;
+      try {
+          return JSON.stringify(err);
+      }
+      catch {
+          return String(err);
+      }
+  }
   /**
    * Resize an image data URL via a canvas. Returns a new data URL at the
    * requested format/quality. Maintains aspect ratio: fits within
@@ -13861,31 +13878,34 @@
       return new Promise((resolve, reject) => {
           const img = new Image();
           img.onload = () => {
-              const srcW = img.naturalWidth;
-              const srcH = img.naturalHeight;
-              // Compute scale to fit within bounds (but never upscale)
-              const scale = Math.min(maxWidth / srcW, maxHeight / srcH, 1);
-              const dstW = Math.max(1, Math.round(srcW * scale));
-              const dstH = Math.max(1, Math.round(srcH * scale));
-              const canvas = document.createElement("canvas");
-              canvas.width = dstW;
-              canvas.height = dstH;
-              const ctx = canvas.getContext("2d");
-              if (!ctx) {
-                  reject(new Error("Could not get 2D canvas context"));
-                  return;
+              try {
+                  const srcW = img.naturalWidth;
+                  const srcH = img.naturalHeight;
+                  const scale = Math.min(maxWidth / srcW, maxHeight / srcH, 1);
+                  const dstW = Math.max(1, Math.round(srcW * scale));
+                  const dstH = Math.max(1, Math.round(srcH * scale));
+                  const canvas = document.createElement("canvas");
+                  canvas.width = dstW;
+                  canvas.height = dstH;
+                  const ctx = canvas.getContext("2d");
+                  if (!ctx) {
+                      reject(new Error("Could not get 2D canvas context"));
+                      return;
+                  }
+                  if (format === "jpeg") {
+                      ctx.fillStyle = "#ffffff";
+                      ctx.fillRect(0, 0, dstW, dstH);
+                  }
+                  ctx.drawImage(img, 0, 0, dstW, dstH);
+                  const mime = format === "jpeg" ? "image/jpeg" : "image/png";
+                  const out = canvas.toDataURL(mime, quality);
+                  resolve({ dataUrl: out, width: dstW, height: dstH });
               }
-              // Fill white background for JPEG (no alpha support)
-              if (format === "jpeg") {
-                  ctx.fillStyle = "#ffffff";
-                  ctx.fillRect(0, 0, dstW, dstH);
+              catch (drawErr) {
+                  reject(new Error(`Canvas resize failed: ${errorMessage(drawErr)}`));
               }
-              ctx.drawImage(img, 0, 0, dstW, dstH);
-              const mime = format === "jpeg" ? "image/jpeg" : "image/png";
-              const out = canvas.toDataURL(mime, quality);
-              resolve({ dataUrl: out, width: dstW, height: dstH });
           };
-          img.onerror = () => reject(new Error("Failed to load image for resizing"));
+          img.onerror = (ev) => reject(new Error(`Failed to load captured image for resizing${ev instanceof Event ? ` (${ev.type})` : ""}`));
           img.src = dataUrl;
       });
   }
@@ -13925,6 +13945,7 @@
               pixelRatio: 1, // always capture at 1x — we'll resize after
               cacheBust: true,
               skipAutoScale: true,
+              skipFonts: true, // CORS-blocked stylesheets can hang font inlining
               filter: (el) => {
                   // Exclude the debugger overlay and cursor from screenshots
                   return (el.id !== "hypha-debugger-host" &&
@@ -13938,25 +13959,51 @@
               captureOptions.height = viewportH;
           }
           let dataUrl;
-          if (fmt === "jpeg") {
-              dataUrl = await toJpeg(node, captureOptions);
+          try {
+              const capturePromise = fmt === "jpeg" ? toJpeg(node, captureOptions) : toPng(node, captureOptions);
+              // Hard timeout: pages with cross-origin resources can make
+              // html-to-image wait indefinitely on blocked fetches.
+              const timeoutMs = 15000;
+              dataUrl = await Promise.race([
+                  capturePromise,
+                  new Promise((_, reject) => setTimeout(() => reject(new Error(`Screenshot capture timed out after ${timeoutMs}ms (likely CORS-blocked resources)`)), timeoutMs)),
+              ]);
+          }
+          catch (captureErr) {
+              return {
+                  error: `Capture failed (html-to-image): ${errorMessage(captureErr)}`,
+              };
           }
-          else {
-              dataUrl = await toPng(node, captureOptions);
+          // Resize down to fit within (maxW × maxH) and re-encode. If resize
+          // fails (e.g. data URL too large to load back into an Image), fall
+          // back to returning the original capture so the caller still gets
+          // something useful.
+          try {
+              const resized = await resizeDataUrl(dataUrl, maxW, maxH, fmt, qual);
+              const sizeKb = Math.round((resized.dataUrl.length * 0.75) / 1024);
+              return {
+                  data: resized.dataUrl,
+                  format: fmt,
+                  width: resized.width,
+                  height: resized.height,
+                  size_kb: sizeKb,
+              };
+          }
+          catch (resizeErr) {
+              const rect = node.getBoundingClientRect();
+              const sizeKb = Math.round((dataUrl.length * 0.75) / 1024);
+              return {
+                  data: dataUrl,
+                  format: fmt,
+                  width: Math.round(rect.width),
+                  height: Math.round(rect.height),
+                  size_kb: sizeKb,
+                  warning: `Resize failed, returning original: ${errorMessage(resizeErr)}`,
+              };
           }
-          // Resize down to fit within (maxW × maxH) and re-encode
-          const resized = await resizeDataUrl(dataUrl, maxW, maxH, fmt, qual);
-          const sizeKb = Math.round((resized.dataUrl.length * 0.75) / 1024); // rough base64 → bytes
-          return {
-              data: resized.dataUrl,
-              format: fmt,
-              width: resized.width,
-              height: resized.height,
-              size_kb: sizeKb,
-          };
       }
       catch (err) {
-          return { error: `Screenshot failed: ${err.message ?? err}` };
+          return { error: `Screenshot failed: ${errorMessage(err)}` };
       }
   }
   takeScreenshot.__schema__ = {
@@ -17418,7 +17465,14 @@
       if (viewport_only !== undefined) {
           ctrl.config.viewportExpansion = viewport_only ? 0 : -1;
       }
-      return ctrl.getBrowserState();
+      // Hard timeout: pages with heavy DOMs or cross-origin iframes can
+      // make the tree walk take much longer than expected. Don't leave
+      // the HTTP caller waiting forever.
+      const timeoutMs = 15000;
+      return Promise.race([
+          ctrl.getBrowserState(),
+          new Promise((_, reject) => setTimeout(() => reject(new Error(`get_browser_state timed out after ${timeoutMs}ms (complex DOM or cross-origin iframes)`)), timeoutMs)),
+      ]);
   }
   getBrowserState.__schema__ = {
       name: "getBrowserState",