assistme 0.9.1 → 0.9.2

package/dist/{chunk-O5K33FBW.js → chunk-S7PYDTKE.js}

@@ -811,6 +811,9 @@ async function tryDismissOverlay(conn) {
 }
 
 // src/browser/screenshot.ts
+var PNG_SIGNATURE_LEN = 8;
+var PNG_IHDR_WIDTH_OFFSET = PNG_SIGNATURE_LEN + 8;
+var PNG_IHDR_HEADER_BYTES = PNG_IHDR_WIDTH_OFFSET + 8;
 async function getViewportMetrics(conn) {
   try {
     const result = await conn.send("Runtime.evaluate", {
@@ -831,34 +834,84 @@ async function getViewportMetrics(conn) {
   }
   return { width: 0, height: 0, dpr: 1 };
 }
-async function captureBoundedScreenshot(conn, maxDim = SCREENSHOT_MAX_DIM_PX) {
-  const { width, height, dpr } = await getViewportMetrics(conn);
-  if (width === 0 || height === 0) {
-    const result2 = await conn.send("Page.captureScreenshot", {
-      format: "png",
-      quality: SCREENSHOT_QUALITY,
-      captureBeyondViewport: false
-    });
-    return result2.data || "";
-  }
-  const naturalMax = Math.max(width, height) * dpr;
-  if (naturalMax <= maxDim) {
-    const result2 = await conn.send("Page.captureScreenshot", {
-      format: "png",
-      quality: SCREENSHOT_QUALITY,
-      captureBeyondViewport: false
-    });
-    return result2.data || "";
+function pngDimensions(base64) {
+  if (!base64 || base64.length < 100) return null;
+  const b64Slice = base64.slice(0, Math.ceil(PNG_IHDR_HEADER_BYTES / 3) * 4);
+  let buf;
+  try {
+    buf = Buffer.from(b64Slice, "base64");
+  } catch {
+    return null;
   }
-  const scale = Math.min(dpr, maxDim / Math.max(width, height));
-  const result = await conn.send("Page.captureScreenshot", {
+  if (buf.length < PNG_IHDR_HEADER_BYTES) return null;
+  if (buf[0] !== 137 || buf[1] !== 80 || buf[2] !== 78 || buf[3] !== 71) {
+    return null;
+  }
+  const width = buf.readUInt32BE(PNG_IHDR_WIDTH_OFFSET);
+  const height = buf.readUInt32BE(PNG_IHDR_WIDTH_OFFSET + 4);
+  return { width, height };
+}
+async function capture(conn, clip) {
+  const params = {
     format: "png",
     quality: SCREENSHOT_QUALITY,
-    captureBeyondViewport: false,
-    clip: { x: 0, y: 0, width, height, scale }
-  });
+    captureBeyondViewport: false
+  };
+  if (clip) params.clip = clip;
+  const result = await conn.send("Page.captureScreenshot", params);
   return result.data || "";
 }
+async function captureBoundedScreenshot(conn, maxDim = SCREENSHOT_MAX_DIM_PX) {
+  const { width, height, dpr } = await getViewportMetrics(conn);
+  let currentWidth = width;
+  let currentHeight = height;
+  let currentScale = null;
+  if (width > 0 && height > 0) {
+    currentScale = Math.min(1, maxDim / (Math.max(width, height) * dpr));
+  }
+  for (let attempt = 0; attempt < 3; attempt++) {
+    const data = currentScale !== null && currentWidth > 0 && currentHeight > 0 ? await capture(conn, {
+      x: 0,
+      y: 0,
+      width: currentWidth,
+      height: currentHeight,
+      scale: currentScale
+    }) : await capture(conn);
+    if (!data) return data;
+    const dims = pngDimensions(data);
+    if (!dims) {
+      return data;
+    }
+    const longest = Math.max(dims.width, dims.height);
+    if (longest <= maxDim) {
+      return data;
+    }
+    const shrinkFactor = maxDim / longest * 0.95;
+    if (currentScale === null) {
+      currentWidth = dims.width;
+      currentHeight = dims.height;
+      currentScale = shrinkFactor;
+    } else {
+      currentScale = currentScale * shrinkFactor;
+    }
+    log.debug(
+      `Screenshot over cap (${dims.width}\xD7${dims.height}, cap ${maxDim}); retrying at scale ${currentScale.toFixed(3)}`
+    );
+    if (currentScale <= 0) {
+      return data;
+    }
+  }
+  if (currentWidth > 0 && currentHeight > 0) {
+    return capture(conn, {
+      x: 0,
+      y: 0,
+      width: currentWidth,
+      height: currentHeight,
+      scale: Math.min(currentScale ?? 0.25, 0.25)
+    });
+  }
+  return capture(conn);
+}
 
 // src/browser/actions.ts
 var Actions = class {
@@ -1961,7 +2014,9 @@ Refs:
             this.frameContexts.set(r.id, contextId);
           }
         } catch (err) {
-          log.debug(`Frame evaluation failed for frame ${frameId}: ${err instanceof Error ? err.message : err}`);
+          log.debug(
+            `Frame evaluation failed for frame ${frameId}: ${err instanceof Error ? err.message : err}`
+          );
         }
       }
     } catch (err) {
@@ -1986,7 +2041,9 @@ Refs:
             contexts.set(child.frame.id, world.executionContextId);
           }
         } catch (err) {
-          log.debug(`Frame ${child.frame.id} does not support isolated worlds: ${err instanceof Error ? err.message : err}`);
+          log.debug(
+            `Frame ${child.frame.id} does not support isolated worlds: ${err instanceof Error ? err.message : err}`
+          );
         }
       }
     } catch (err) {
@@ -2063,11 +2120,7 @@ Refs:
       });
       const value = frameResult.result?.value;
       if (!value || value === "null") return null;
-      const parsed = safeJsonParse(
-        value,
-        null,
-        "snapshot.resolveRefInFrame"
-      );
+      const parsed = safeJsonParse(value, null, "snapshot.resolveRefInFrame");
       if (!parsed) return null;
       if (parsed.error) return parsed;
       return {
@@ -2077,7 +2130,9 @@ Refs:
         height: parsed.height
       };
     } catch (err) {
-      log.debug(`resolveRefInFrame failed for ref ${refId}: ${err instanceof Error ? err.message : err}`);
+      log.debug(
+        `resolveRefInFrame failed for ref ${refId}: ${err instanceof Error ? err.message : err}`
+      );
       return null;
     }
   }

package/dist/index.js

@@ -34,7 +34,7 @@ import {
   setSessionBusy,
   toggleScheduledTask,
   updateHeartbeat
-} from "./chunk-O5K33FBW.js";
+} from "./chunk-S7PYDTKE.js";
 import {
   JobRunner,
   callMcpHandler

package/dist/workers/entry.js

@@ -2,7 +2,7 @@
 import {
   TaskProcessor,
   getBrowser
-} from "../chunk-O5K33FBW.js";
+} from "../chunk-S7PYDTKE.js";
 import "../chunk-RRMI6RDG.js";
 import {
   setLogTransport

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "assistme",
-  "version": "0.9.1",
+  "version": "0.9.2",
   "description": "AssistMe CLI Agent - AI-powered agentic assistant for code, browser, and automation",
   "type": "module",
   "main": "dist/index.js",

package/src/browser/delays.ts

@@ -41,5 +41,7 @@ export const SCREENSHOT_MAX_DIM_PX = 1568;
 
 /** Promise-based delay helper. */
 export function delay(ms: number): Promise<void> {
-  return new Promise((r) => { setTimeout(r, ms); });
+  return new Promise((r) => {
+    setTimeout(r, ms);
+  });
 }

package/src/browser/screenshot.ts

@@ -9,10 +9,13 @@
  *    many-image requests (2000px)."
  *
  * Implementation uses CDP's native `clip.scale` so no image library is
- * needed. We read the viewport size and devicePixelRatio, then downscale
- * only when the natural capture would exceed the cap.
+ * needed. We read the viewport size and devicePixelRatio to pick an initial
+ * scale, then decode the actual PNG dimensions from its header and re-
+ * capture with a smaller scale if the output is still over the cap (guards
+ * against any DPR/scale compounding differences across Chrome builds).
  */
 
+import { log } from "../utils/logger.js";
 import type { CDPConnection } from "./connection.js";
 import { SCREENSHOT_MAX_DIM_PX, SCREENSHOT_QUALITY } from "./delays.js";
 import type { CDPEvalResult } from "./types.js";
@@ -23,6 +26,11 @@ interface ViewportMetrics {
   dpr: number;
 }
 
+/** PNG signature + IHDR header positions. See https://www.w3.org/TR/png/#5PNG-file-signature */
+const PNG_SIGNATURE_LEN = 8;
+const PNG_IHDR_WIDTH_OFFSET = PNG_SIGNATURE_LEN + 8; // 8 (sig) + 4 (IHDR length) + 4 ("IHDR")
+const PNG_IHDR_HEADER_BYTES = PNG_IHDR_WIDTH_OFFSET + 8; // width (4) + height (4)
+
 async function getViewportMetrics(conn: CDPConnection): Promise<ViewportMetrics> {
   try {
     const result = await conn.send("Runtime.evaluate", {
@@ -42,10 +50,45 @@ async function getViewportMetrics(conn: CDPConnection): Promise<ViewportMetrics>
   } catch {
     // Fall through to defaults
   }
-  // Safe defaults if viewport query fails — no clip, CDP uses natural capture
   return { width: 0, height: 0, dpr: 1 };
 }
 
+/** Decode PNG dimensions from base64 data, or null if not a PNG. */
+function pngDimensions(base64: string): { width: number; height: number } | null {
+  if (!base64 || base64.length < 100) return null;
+  // Decode just enough bytes to read IHDR.
+  // Base64 → binary: every 4 chars decodes to 3 bytes. Need PNG_IHDR_HEADER_BYTES bytes.
+  const b64Slice = base64.slice(0, Math.ceil(PNG_IHDR_HEADER_BYTES / 3) * 4);
+  let buf: Buffer;
+  try {
+    buf = Buffer.from(b64Slice, "base64");
+  } catch {
+    return null;
+  }
+  if (buf.length < PNG_IHDR_HEADER_BYTES) return null;
+  // PNG signature: 89 50 4E 47 0D 0A 1A 0A
+  if (buf[0] !== 0x89 || buf[1] !== 0x50 || buf[2] !== 0x4e || buf[3] !== 0x47) {
+    return null;
+  }
+  const width = buf.readUInt32BE(PNG_IHDR_WIDTH_OFFSET);
+  const height = buf.readUInt32BE(PNG_IHDR_WIDTH_OFFSET + 4);
+  return { width, height };
+}
+
+async function capture(
+  conn: CDPConnection,
+  clip?: { x: number; y: number; width: number; height: number; scale: number }
+): Promise<string> {
+  const params: Record<string, unknown> = {
+    format: "png",
+    quality: SCREENSHOT_QUALITY,
+    captureBeyondViewport: false,
+  };
+  if (clip) params.clip = clip;
+  const result = await conn.send("Page.captureScreenshot", params);
+  return (result as { data?: string }).data || "";
+}
+
 /**
  * Capture a PNG screenshot of the current page, downsampled so the longer
  * side does not exceed {@link SCREENSHOT_MAX_DIM_PX}. Returns base64 data.
@@ -56,39 +99,82 @@ export async function captureBoundedScreenshot(
 ): Promise<string> {
   const { width, height, dpr } = await getViewportMetrics(conn);
 
-  // If we couldn't determine metrics, fall back to unclipped capture.
-  if (width === 0 || height === 0) {
-    const result = await conn.send("Page.captureScreenshot", {
-      format: "png",
-      quality: SCREENSHOT_QUALITY,
-      captureBeyondViewport: false,
-    });
-    return (result as { data?: string }).data || "";
+  // Without viewport metrics we can't pre-scale — capture, verify, retry if needed.
+  let currentWidth = width;
+  let currentHeight = height;
+  let currentScale: number | null = null;
+
+  if (width > 0 && height > 0) {
+    // Pick an initial scale that is safe in the worst case where CDP's
+    // clip.scale compounds with the device pixel ratio (so output pixels
+    // = css × scale × dpr). If CDP instead treats scale as a pure CSS
+    // multiplier (output = css × scale), we end up smaller than necessary,
+    // but the post-capture verification below guarantees correctness either
+    // way. Cap at 1 so we never request an upscale.
+    currentScale = Math.min(1, maxDim / (Math.max(width, height) * dpr));
   }
 
-  // Natural output dimensions (what we'd get without clip): viewport CSS px × DPR.
-  const naturalMax = Math.max(width, height) * dpr;
+  // Capture + verify loop. Each retry shrinks scale based on the actual
+  // measured output, so we converge in at most a couple iterations even if
+  // CDP's scale semantics compound with DPR on this Chrome build.
+  for (let attempt = 0; attempt < 3; attempt++) {
+    const data =
+      currentScale !== null && currentWidth > 0 && currentHeight > 0
+        ? await capture(conn, {
+            x: 0,
+            y: 0,
+            width: currentWidth,
+            height: currentHeight,
+            scale: currentScale,
+          })
+        : await capture(conn);
 
-  // If the natural capture already fits under the cap, no scaling needed.
-  if (naturalMax <= maxDim) {
-    const result = await conn.send("Page.captureScreenshot", {
-      format: "png",
-      quality: SCREENSHOT_QUALITY,
-      captureBeyondViewport: false,
-    });
-    return (result as { data?: string }).data || "";
-  }
+    if (!data) return data;
 
-  // CDP clip.scale applies to CSS pixels: output = cssPx × scale.
-  // Pick the largest scale that keeps max(output) ≤ maxDim, capped at dpr
-  // so we never upscale beyond the native render.
-  const scale = Math.min(dpr, maxDim / Math.max(width, height));
+    const dims = pngDimensions(data);
+    if (!dims) {
+      // Can't verify — return as-is (shouldn't happen with PNG format).
+      return data;
+    }
 
-  const result = await conn.send("Page.captureScreenshot", {
-    format: "png",
-    quality: SCREENSHOT_QUALITY,
-    captureBeyondViewport: false,
-    clip: { x: 0, y: 0, width, height, scale },
-  });
-  return (result as { data?: string }).data || "";
+    const longest = Math.max(dims.width, dims.height);
+    if (longest <= maxDim) {
+      return data;
+    }
+
+    // Output too large — shrink. Derive a new scale from actual output size.
+    // Leave a small safety margin (0.95) so rounding doesn't push us back over.
+    const shrinkFactor = (maxDim / longest) * 0.95;
+    if (currentScale === null) {
+      // We had no viewport metrics on the first pass. Approximate a clip scale
+      // from the observed output: assume natural capture gave dims.width px
+      // at scale 1, so scale to fit.
+      currentWidth = dims.width;
+      currentHeight = dims.height;
+      currentScale = shrinkFactor;
+    } else {
+      currentScale = currentScale * shrinkFactor;
+    }
+    log.debug(
+      `Screenshot over cap (${dims.width}×${dims.height}, cap ${maxDim}); retrying at scale ${currentScale.toFixed(3)}`
+    );
+
+    // Retry with the new scale on the next iteration.
+    if (currentScale <= 0) {
+      // Sanity guard — return current data rather than infinite shrink.
+      return data;
+    }
+  }
+
+  // Last resort — capture with a very small scale so we don't block the task.
+  if (currentWidth > 0 && currentHeight > 0) {
+    return capture(conn, {
+      x: 0,
+      y: 0,
+      width: currentWidth,
+      height: currentHeight,
+      scale: Math.min(currentScale ?? 0.25, 0.25),
+    });
+  }
+  return capture(conn);
 }

package/src/browser/snapshot.ts

@@ -62,7 +62,9 @@ export class SnapshotEngine {
     });
 
     const refs: RefEntry[] = safeJsonParse<RawRefData[]>(
-      ((findResult as CDPEvalResult).result?.value as string) || "[]", [], "snapshot.findElements"
+      ((findResult as CDPEvalResult).result?.value as string) || "[]",
+      [],
+      "snapshot.findElements"
     ).map((r) => ({
       id: r.id,
       role: r.role,
@@ -168,7 +170,9 @@ export class SnapshotEngine {
           });
 
           const frameRefs = safeJsonParse<RawRefData[]>(
-            ((frameResult as CDPEvalResult).result?.value as string) || "[]", [], "snapshot.frameRefs"
+            ((frameResult as CDPEvalResult).result?.value as string) || "[]",
+            [],
+            "snapshot.frameRefs"
           );
 
           for (const r of frameRefs) {
@@ -188,7 +192,9 @@ export class SnapshotEngine {
             this.frameContexts.set(r.id, contextId);
           }
         } catch (err) {
-          log.debug(`Frame evaluation failed for frame ${frameId}: ${err instanceof Error ? err.message : err}`);
+          log.debug(
+            `Frame evaluation failed for frame ${frameId}: ${err instanceof Error ? err.message : err}`
+          );
         }
       }
     } catch (err) {
@@ -223,7 +229,9 @@ export class SnapshotEngine {
             contexts.set(child.frame.id, world.executionContextId);
           }
         } catch (err) {
-          log.debug(`Frame ${child.frame.id} does not support isolated worlds: ${err instanceof Error ? err.message : err}`);
+          log.debug(
+            `Frame ${child.frame.id} does not support isolated worlds: ${err instanceof Error ? err.message : err}`
+          );
         }
       }
     } catch (err) {
@@ -320,9 +328,13 @@ export class SnapshotEngine {
       const value = (frameResult as CDPEvalResult).result?.value as string;
       if (!value || value === "null") return null;
 
-      const parsed = safeJsonParse<{ x: number; y: number; width: number; height: number; error?: string } | null>(
-        value, null, "snapshot.resolveRefInFrame"
-      );
+      const parsed = safeJsonParse<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+        error?: string;
+      } | null>(value, null, "snapshot.resolveRefInFrame");
       if (!parsed) return null;
       if (parsed.error) return parsed;
 
@@ -333,9 +345,10 @@ export class SnapshotEngine {
         height: parsed.height,
       };
     } catch (err) {
-      log.debug(`resolveRefInFrame failed for ref ${refId}: ${err instanceof Error ? err.message : err}`);
+      log.debug(
+        `resolveRefInFrame failed for ref ${refId}: ${err instanceof Error ? err.message : err}`
+      );
       return null;
     }
   }
 }
-