hypha-debugger 0.2.0 → 0.2.2

package/dist/hypha-debugger.mjs

@@ -1972,6 +1972,23 @@ async function toJpeg(node, options = {}) {
  * 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
@@ -1981,31 +1998,34 @@ async function resizeDataUrl(dataUrl, maxWidth, maxHeight, format, quality) {
     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;
     });
 }
@@ -2045,6 +2065,7 @@ async function takeScreenshot(selector, format, quality, max_width, max_height,
             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" &&
@@ -2058,25 +2079,51 @@ async function takeScreenshot(selector, format, quality, max_width, max_height,
             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__ = {
@@ -5538,7 +5585,14 @@ async function getBrowserState(viewport_only) {
     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",