autokap 1.9.8 → 1.9.9

package/dist/browser-pool.js

@@ -48,6 +48,12 @@ export const CHROMIUM_ARGS = [
 const MAX_CONCURRENT = parseInt(process.env.BROWSER_POOL_MAX_CONCURRENT ?? '5', 10);
 /** Restart the shared browser process after this many captures to prevent memory leaks. */
 const MAX_CAPTURES_BEFORE_RESTART = 100;
+/**
+ * Default per-action Playwright timeout for pooled contexts. Below the 30s
+ * CAPTURE_SCREENSHOT global deadline so a starved call fails with budget left
+ * for recovery instead of eating the whole variant. See usage in acquireContext.
+ */
+const POOL_CONTEXT_ACTION_TIMEOUT_MS = 25000;
 function normalizeDeviceScaleFactor(value) {
     if (!Number.isFinite(value))
         return 2;
@@ -79,6 +85,12 @@ class BrowserPool {
             // any conflict). See PRIVACY_HEADERS / installAnalyticsBlock (AUT-234).
             extraHTTPHeaders: { ...PRIVACY_HEADERS, ...(extra ?? {}) },
         });
+        // Stop every Playwright call from inheriting the built-in 30 000 ms default.
+        // Pooled captures run many variants per Cloud Run container; under CPU
+        // contention a starved call (e.g. page.screenshot) would otherwise block the
+        // full 30s — equal to the CAPTURE_SCREENSHOT global deadline — leaving no
+        // budget for recovery and voiding the variant. 25s sits under that cap.
+        context.setDefaultTimeout(POOL_CONTEXT_ACTION_TIMEOUT_MS);
         // Block third-party analytics so pooled (server-side) captures don't
         // register a phantom visit in the captured site's analytics (AUT-234).
         // Skippable per-project via blockAnalytics === false.

package/dist/browser.js

@@ -209,6 +209,29 @@ async function seedCloudChromiumPreferences(userDataDir) {
     };
     await writeFile(preferencesPath, `${JSON.stringify(preferences)}\n`, 'utf8');
 }
+/**
+ * Default per-action timeout applied to every Playwright context we create.
+ * Without this, calls (page.screenshot / page.title / locator actions) inherit
+ * Playwright's built-in 30 000 ms default. Under Cloud Run CPU contention (many
+ * variants per container) a single starved call would then block for the full
+ * 30s — which equals the CAPTURE_SCREENSHOT global deadline, leaving zero budget
+ * for recovery/recapture and voiding the whole variant. 25s sits just under that
+ * global cap so a hung call fails with budget left for a clean, bounded error.
+ * NAVIGATE keeps its own bounded path — we intentionally do NOT touch
+ * navigationTimeout here.
+ */
+const CONTEXT_ACTION_TIMEOUT_MS = 25000;
+/**
+ * Explicit ceiling for the heavy screenshot primitives. Below the context
+ * default so an already-abandoned capture (the runner gives up earlier, ~12s)
+ * stops burning renderer CPU quickly instead of contending with sibling
+ * variants until the 25s default fires.
+ */
+const SCREENSHOT_PRIMITIVE_TIMEOUT_MS = 20000;
+/** Apply our engine-wide Playwright defaults to a freshly created context. */
+function applyContextDefaults(context) {
+    context.setDefaultTimeout(CONTEXT_ACTION_TIMEOUT_MS);
+}
 async function withHelperTimeout(label, timeoutMs, work) {
     if (!timeoutMs || timeoutMs <= 0) {
         return work();
@@ -1085,6 +1108,7 @@ export class Browser {
                 headless: false,
                 args: clipArgs,
             });
+            applyContextDefaults(instance.context);
             instance.browser = instance.context.browser();
             instance.persistentContext = true;
             // launchPersistentContext opens an initial about:blank page automatically.
@@ -1110,6 +1134,7 @@ export class Browser {
                 args: clipArgs,
             });
             instance.context = await instance.browser.newContext(contextOptions);
+            applyContextDefaults(instance.context);
         }
         // Block third-party analytics beacons so clip/video capture doesn't
         // register a phantom visit either (AUT-234). Context-level so it covers
@@ -1253,6 +1278,7 @@ export class Browser {
             args: CHROMIUM_ARGS,
         });
         this.context = await this.browser.newContext(this.buildContextOptions());
+        applyContextDefaults(this.context);
         if (this.options.blockAnalytics !== false) {
             await installAnalyticsBlock(this.context);
         }
@@ -1345,6 +1371,7 @@ export class Browser {
             this.context = null;
         }
         this.context = await this.browser.newContext(this.buildContextOptions());
+        applyContextDefaults(this.context);
         if (this.options.blockAnalytics !== false) {
             await installAnalyticsBlock(this.context);
         }
@@ -1840,7 +1867,7 @@ export class Browser {
         // terminal block where ANSI escape literals were producing tofu boxes).
         await stripInvisibleControlChars(page);
         await logFontDiagnostics(page, 'before screenshot');
-        const screenshot = Buffer.from(await page.screenshot({ type: 'png', fullPage: false }));
+        const screenshot = Buffer.from(await page.screenshot({ type: 'png', fullPage: false, timeout: SCREENSHOT_PRIMITIVE_TIMEOUT_MS }));
         await logCaptureRenderDiagnostics(page, screenshot, this.options, 'after screenshot');
         return screenshot;
     }
@@ -5330,7 +5357,7 @@ export class Browser {
         try {
             await this.waitForFontsBeforeScreenshot(page);
             await logFontDiagnostics(page, 'before region screenshot');
-            const fullPage = Buffer.from(await page.screenshot({ type: 'png', fullPage: true }));
+            const fullPage = Buffer.from(await page.screenshot({ type: 'png', fullPage: true, timeout: SCREENSHOT_PRIMITIVE_TIMEOUT_MS }));
             const image = sharp(fullPage);
             const meta = await image.metadata();
             const imageWidth = meta.width ?? 0;
@@ -5453,7 +5480,7 @@ export class Browser {
             const dpr = pageInfo.dpr;
             await this.waitForFontsBeforeScreenshot(page);
             await logFontDiagnostics(page, 'before selector screenshot');
-            const fullPage = Buffer.from(await page.screenshot({ type: 'png', fullPage: true }));
+            const fullPage = Buffer.from(await page.screenshot({ type: 'png', fullPage: true, timeout: SCREENSHOT_PRIMITIVE_TIMEOUT_MS }));
             const image = sharp(fullPage);
             const meta = await image.metadata();
             const imgW = meta.width ?? 0;
@@ -5517,7 +5544,7 @@ export class Browser {
             const dpr = pageInfo.dpr;
             await this.waitForFontsBeforeScreenshot(page);
             await logFontDiagnostics(page, 'before bounding-region screenshot');
-            const fullPage = Buffer.from(await page.screenshot({ type: 'png', fullPage: true }));
+            const fullPage = Buffer.from(await page.screenshot({ type: 'png', fullPage: true, timeout: SCREENSHOT_PRIMITIVE_TIMEOUT_MS }));
             const image = sharp(fullPage);
             const meta = await image.metadata();
             const imgW = meta.width ?? 0;

package/dist/opcode-runner.js

@@ -55,6 +55,15 @@ export class NoOpRecoveryChain {
 }
 const MIN_CLIP_FINALIZATION_TIMEOUT_MS = 30000;
 const DEFAULT_VIDEO_RECORDING_RESOLUTION = { width: 1920, height: 1080 };
+/**
+ * Per-call bounds for the CAPTURE_SCREENSHOT action, kept well under the ~30s
+ * global capture deadline so a hung Playwright call fails early and leaves budget
+ * for recovery/recapture instead of voiding the variant. Fixed constants because
+ * executeOpcodeAction has no access to the deadline; 12s + 3×3s worst case still
+ * leaves >=12s of the 30s budget for the recovery path.
+ */
+const CAPTURE_BUFFER_TIMEOUT_MS = 12000;
+const CAPTURE_METADATA_TIMEOUT_MS = 3000;
 /**
  * The compiled per-opcode action budget. For CAPTURE_SCREENSHOT this governs
  * ONLY the deterministic capture (visual stabilize + screenshot + favicon/title
@@ -463,9 +472,12 @@ async function executeOpcode(opcode, index, adapter, verifier, breaker, recovery
             error: `recovery succeeded but produced no ${opcode.kind === 'END_CLIP' ? 'clip' : 'screenshot'} artifact: ${reason}`,
         };
     };
-    // Track page context for circuit breaker
+    // Track page context for circuit breaker. Bounded + best-effort: this runs on
+    // EVERY opcode inside its global-deadline window, so a getCurrentUrl starved by
+    // CPU contention must not eat the budget the capture + recovery need (it would
+    // otherwise be capped only by the 25s context default).
     try {
-        const url = await adapter.getCurrentUrl();
+        const url = await withTimeout(() => adapter.getCurrentUrl(), CAPTURE_METADATA_TIMEOUT_MS);
         breaker.setPage(url);
     }
     catch { /* ignore */ }
@@ -879,25 +891,43 @@ async function executeOpcodeAction(opcode, opcodeIndex, adapter, artifacts, tele
                     lowConfidenceReasons.push(`captured before visual stability: ${stability.reason}`);
                 }
                 const captureLowConfidenceReason = lowConfidenceReasons.join('; ') || undefined;
-                const captureUrl = await adapter.getCurrentUrl();
-                const buffer = await takeCaptureBuffer(adapter, opcode);
-                // Extract page favicon for browser bar mockup
+                // Capture the screenshot buffer FIRST and bound it — this is the only
+                // artifact-critical call. Under CPU contention (many cloud variants per
+                // container) a Playwright screenshot can otherwise block the full ~30s
+                // global deadline, leaving zero budget for recovery/recapture and voiding
+                // the variant. Failing at ~12s keeps ≥12s of the 30s budget for the
+                // recovery path (handleFailure → recapture in `failWithRecovery`).
+                const buffer = await withTimeout(() => takeCaptureBuffer(adapter, opcode), CAPTURE_BUFFER_TIMEOUT_MS);
+                // Everything below is best-effort browser-mockup metadata. The buffer is
+                // already in hand, so a slow/hung metadata call must NEVER throw out of
+                // the action and discard a good screenshot. Each is individually bounded
+                // and degrades gracefully (empty URL / no favicon / hostname title).
+                let captureUrl = '';
+                try {
+                    captureUrl = await withTimeout(() => adapter.getCurrentUrl(), CAPTURE_METADATA_TIMEOUT_MS);
+                }
+                catch { /* empty captureUrl is tolerated downstream */ }
                 let tabIconData;
                 let tabIconMimeType;
                 if (adapter.extractFavicon) {
-                    const favicon = await adapter.extractFavicon();
-                    if (favicon) {
-                        tabIconData = favicon.buffer;
-                        tabIconMimeType = favicon.mimeType;
+                    try {
+                        const favicon = await withTimeout(() => adapter.extractFavicon(), CAPTURE_METADATA_TIMEOUT_MS);
+                        if (favicon) {
+                            tabIconData = favicon.buffer;
+                            tabIconMimeType = favicon.mimeType;
+                        }
                     }
+                    catch { /* ship the screenshot without a favicon */ }
                 }
-                // Capture document title so browser mockups can render the real tab
-                // title instead of falling back to the hostname.
+                // Real tab title for the browser mockup; falls back to hostname when null.
                 let pageTitle;
                 if (adapter.getPageTitle) {
-                    const resolved = await adapter.getPageTitle();
-                    if (resolved)
-                        pageTitle = resolved;
+                    try {
+                        const resolved = await withTimeout(() => adapter.getPageTitle(), CAPTURE_METADATA_TIMEOUT_MS);
+                        if (resolved)
+                            pageTitle = resolved;
+                    }
+                    catch { /* fall back to the hostname mockup */ }
                 }
                 artifacts.push({
                     mediaMode: 'screenshot',

package/dist/web-playwright-local.js

@@ -194,7 +194,15 @@ export class WebPlaywrightLocal {
     async getPageTitle() {
         const page = await this.browser.currentPage;
         try {
-            const raw = await page.title();
+            // Metadata for the browser-mockup tab, not the artifact itself. page.title()
+            // takes no timeout and inherits Playwright's 30s default; under CPU
+            // contention (Cloud Run) it can swallow the whole capture action budget
+            // AFTER the screenshot buffer was already produced, discarding a good shot.
+            // Bound it tightly and degrade to the hostname fallback (null) on timeout.
+            const raw = await Promise.race([
+                page.title(),
+                new Promise((resolve) => setTimeout(() => resolve(null), 2000)),
+            ]);
             const trimmed = raw?.trim();
             if (!trimmed)
                 return null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autokap",
-  "version": "1.9.8",
+  "version": "1.9.9",
   "description": "AI-powered CLI tool for capturing clean screenshots of websites",
   "type": "module",
   "main": "./dist/index.js",