assistme 0.9.0 → 0.9.2

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

@@ -318,6 +318,7 @@ var CDP_SETTLE_MS = 300;
 var PAGE_TRANSITION_MS = 500;
 var MAX_WAIT_MS = 5e3;
 var SCREENSHOT_QUALITY = 80;
+var SCREENSHOT_MAX_DIM_PX = 1568;
 function delay(ms) {
   return new Promise((r) => {
     setTimeout(r, ms);
@@ -809,6 +810,109 @@ 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", {
+      expression: `JSON.stringify({ width: window.innerWidth, height: window.innerHeight, dpr: window.devicePixelRatio || 1 })`,
+      returnByValue: true
+    });
+    const value = result.result?.value;
+    if (value) {
+      const parsed = JSON.parse(value);
+      const width = Number(parsed.width) || 0;
+      const height = Number(parsed.height) || 0;
+      const dpr = Number(parsed.dpr) || 1;
+      if (width > 0 && height > 0) {
+        return { width, height, dpr };
+      }
+    }
+  } catch {
+  }
+  return { width: 0, height: 0, dpr: 1 };
+}
+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;
+  }
+  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
+  };
+  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 {
   constructor(conn, snapshotEngine) {
@@ -1004,12 +1108,7 @@ var Actions = class {
     let screenshot;
     if (takeScreenshot) {
       await delay(CDP_SETTLE_MS);
-      const screenshotResult = await this.conn.send("Page.captureScreenshot", {
-        format: "png",
-        quality: SCREENSHOT_QUALITY,
-        captureBeyondViewport: false
-      });
-      screenshot = screenshotResult.data || "";
+      screenshot = await captureBoundedScreenshot(this.conn);
     }
     return { results, screenshot };
   }
@@ -1378,12 +1477,7 @@ URL: ${info.url}`;
   }
   async screenshot() {
     this.conn.ensureConnected();
-    const result = await this.conn.send("Page.captureScreenshot", {
-      format: "png",
-      quality: SCREENSHOT_QUALITY,
-      captureBeyondViewport: false
-    });
-    return result.data || "";
+    return captureBoundedScreenshot(this.conn);
   }
   async detectLoginPage() {
     try {
@@ -1833,12 +1927,7 @@ var SnapshotEngine = class {
         expression: buildAnnotationOverlayJS(refsJson)
       });
     }
-    const screenshotResult = await this.conn.send("Page.captureScreenshot", {
-      format: "png",
-      quality: SCREENSHOT_QUALITY,
-      captureBeyondViewport: false
-    });
-    const image = screenshotResult.data || "";
+    const image = await captureBoundedScreenshot(this.conn);
     if (annotate) {
       await this.conn.send("Runtime.evaluate", {
         expression: `(function() { var el = document.getElementById('__assistme_refs__'); if (el) el.remove(); })()`
@@ -1925,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) {
@@ -1950,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) {
@@ -2027,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 {
@@ -2041,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-E27P57PM.js";
+} from "./chunk-S7PYDTKE.js";
 import {
   JobRunner,
   callMcpHandler

package/dist/workers/entry.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "assistme",
-  "version": "0.9.0",
+  "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/actions.ts

@@ -25,9 +25,9 @@ import {
   KEY_PRESS_DELAY_MS,
   MAX_WAIT_MS,
   PAGE_TRANSITION_MS,
-  SCREENSHOT_QUALITY,
   SCROLL_SETTLE_MS,
 } from "./delays.js";
+import { captureBoundedScreenshot } from "./screenshot.js";
 import { clearFieldScript } from "./scripts.js";
 import type { SnapshotEngine } from "./snapshot.js";
 import type { ActionResult, ActionSpec, CDPEvalResult, RefActionResult } from "./types.js";
@@ -268,12 +268,7 @@ export class Actions {
     let screenshot: string | undefined;
     if (takeScreenshot) {
       await delay(CDP_SETTLE_MS);
-      const screenshotResult = await this.conn.send("Page.captureScreenshot", {
-        format: "png",
-        quality: SCREENSHOT_QUALITY,
-        captureBeyondViewport: false,
-      });
-      screenshot = (screenshotResult as { data?: string }).data || "";
+      screenshot = await captureBoundedScreenshot(this.conn);
     }
 
     return { results, screenshot };

package/src/browser/delays.ts

@@ -29,7 +29,19 @@ export const MAX_WAIT_MS = 5000;
 /** JPEG quality for CDP screenshots (0-100). */
 export const SCREENSHOT_QUALITY = 80;
 
+/**
+ * Maximum pixels on either side of a captured screenshot.
+ *
+ * Anthropic's Messages API rejects requests where any image exceeds 2000px
+ * per side once a conversation contains many images. Browser-agent sessions
+ * accumulate screenshots quickly, so we cap at a safe value below that limit.
+ * 1568 is also Anthropic's recommended maximum for best model performance.
+ */
+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/navigation.ts

@@ -3,7 +3,7 @@
  */
 
 import type { CDPConnection } from "./connection.js";
-import { SCREENSHOT_QUALITY } from "./delays.js";
+import { captureBoundedScreenshot } from "./screenshot.js";
 import type { CDPEvalResult } from "./types.js";
 
 export class Navigation {
@@ -100,12 +100,7 @@ export class Navigation {
 
   async screenshot(): Promise<string> {
     this.conn.ensureConnected();
-    const result = await this.conn.send("Page.captureScreenshot", {
-      format: "png",
-      quality: SCREENSHOT_QUALITY,
-      captureBeyondViewport: false,
-    });
-    return (result as { data?: string }).data || "";
+    return captureBoundedScreenshot(this.conn);
   }
 
   async detectLoginPage(): Promise<{ isLoginPage: boolean; reason: string }> {

package/src/browser/screenshot.ts

@@ -0,0 +1,180 @@
+/**
+ * Screenshot helper — captures a page screenshot via CDP while ensuring
+ * output dimensions stay within Anthropic's per-image size limit.
+ *
+ * Without this cap, high-DPI displays (Retina, 2× / 3×) produce PNGs that
+ * exceed 2000px per side. Once a conversation accumulates many images the
+ * API rejects the request with:
+ *   "An image in the conversation exceeds the dimension limit for
+ *    many-image requests (2000px)."
+ *
+ * Implementation uses CDP's native `clip.scale` so no image library is
+ * 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";
+
+interface ViewportMetrics {
+  width: number;
+  height: number;
+  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", {
+      expression: `JSON.stringify({ width: window.innerWidth, height: window.innerHeight, dpr: window.devicePixelRatio || 1 })`,
+      returnByValue: true,
+    });
+    const value = (result as CDPEvalResult).result?.value as string | undefined;
+    if (value) {
+      const parsed = JSON.parse(value) as Partial<ViewportMetrics>;
+      const width = Number(parsed.width) || 0;
+      const height = Number(parsed.height) || 0;
+      const dpr = Number(parsed.dpr) || 1;
+      if (width > 0 && height > 0) {
+        return { width, height, dpr };
+      }
+    }
+  } catch {
+    // Fall through to defaults
+  }
+  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.
+ */
+export async function captureBoundedScreenshot(
+  conn: CDPConnection,
+  maxDim: number = SCREENSHOT_MAX_DIM_PX
+): Promise<string> {
+  const { width, height, dpr } = await getViewportMetrics(conn);
+
+  // 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));
+  }
+
+  // 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 (!data) return data;
+
+    const dims = pngDimensions(data);
+    if (!dims) {
+      // Can't verify — return as-is (shouldn't happen with PNG format).
+      return 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

@@ -6,7 +6,7 @@ import { SNAPSHOT_LOAD_TIMEOUT_MS } from "../utils/constants.js";
 import { safeJsonParse } from "../utils/errors.js";
 import { log } from "../utils/logger.js";
 import type { CDPConnection } from "./connection.js";
-import { SCREENSHOT_QUALITY } from "./delays.js";
+import { captureBoundedScreenshot } from "./screenshot.js";
 import {
   buildAnnotationOverlayJS,
   buildFrameDiscoverJS,
@@ -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,
@@ -83,13 +85,8 @@ export class SnapshotEngine {
       });
     }
 
-    // 3. Take screenshot
-    const screenshotResult = await this.conn.send("Page.captureScreenshot", {
-      format: "png",
-      quality: SCREENSHOT_QUALITY,
-      captureBeyondViewport: false,
-    });
-    const image = (screenshotResult as { data?: string }).data || "";
+    // 3. Take screenshot (bounded to stay within Anthropic's many-image dim limit)
+    const image = await captureBoundedScreenshot(this.conn);
 
     // 4. Remove overlay if injected
     if (annotate) {
@@ -173,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) {
@@ -193,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) {
@@ -228,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) {
@@ -325,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;
 
@@ -338,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;
     }
   }
 }
-

package/tests/browser/snapshot.test.ts

@@ -12,6 +12,7 @@ vi.mock("../../src/utils/logger.js", () => ({
 
 vi.mock("../../src/browser/delays.js", () => ({
   SCREENSHOT_QUALITY: 80,
+  SCREENSHOT_MAX_DIM_PX: 1568,
 }));
 
 // Create mock connection