autokap 1.9.9 → 1.9.10

package/dist/browser-pool.d.ts

@@ -2,6 +2,23 @@ import { type BrowserContext } from 'playwright';
 import type { BrowserStorageState } from './types.js';
 /** Chromium flags for server-side headless operation (used by pool and standalone launches). */
 export declare const CHROMIUM_ARGS: string[];
+/**
+ * Cloud Run NVIDIA L4 GPU launch flags for HEADLESS screenshot capture. Returns
+ * null off Cloud Run (Vercel/local have no GPU → keep software rasterization).
+ *
+ * The clip path (Browser.forClipCapture) proves the L4 binds via ANGLE/Vulkan on
+ * this image; screenshots don't need Xvfb (no ffmpeg x11grab), so we use Chromium
+ * NEW headless (`--headless=new` — the OLD `--headless` has no GPU) and strip
+ * Playwright's default `--headless` so the two don't clash. Verify the binding
+ * with the `[gpu-check]` log below: "NVIDIA"/"ANGLE (NVIDIA…)" = hardware,
+ * "SwiftShader"/"llvmpipe" = it fell back to software (then we'd need Xvfb).
+ * The GPU accelerates page render/composite (the win for animated/blur-heavy
+ * pages); the final PNG encode stays CPU-bound.
+ */
+export declare function resolveCloudGpuLaunch(): {
+    args: string[];
+    ignoreDefaultArgs: string[];
+} | null;
 declare class BrowserPool {
     private browser;
     private launchPromise;

package/dist/browser-pool.js

@@ -54,6 +54,66 @@ const MAX_CAPTURES_BEFORE_RESTART = 100;
  * for recovery instead of eating the whole variant. See usage in acquireContext.
  */
 const POOL_CONTEXT_ACTION_TIMEOUT_MS = 25000;
+/**
+ * Cloud Run NVIDIA L4 GPU launch flags for HEADLESS screenshot capture. Returns
+ * null off Cloud Run (Vercel/local have no GPU → keep software rasterization).
+ *
+ * The clip path (Browser.forClipCapture) proves the L4 binds via ANGLE/Vulkan on
+ * this image; screenshots don't need Xvfb (no ffmpeg x11grab), so we use Chromium
+ * NEW headless (`--headless=new` — the OLD `--headless` has no GPU) and strip
+ * Playwright's default `--headless` so the two don't clash. Verify the binding
+ * with the `[gpu-check]` log below: "NVIDIA"/"ANGLE (NVIDIA…)" = hardware,
+ * "SwiftShader"/"llvmpipe" = it fell back to software (then we'd need Xvfb).
+ * The GPU accelerates page render/composite (the win for animated/blur-heavy
+ * pages); the final PNG encode stays CPU-bound.
+ */
+export function resolveCloudGpuLaunch() {
+    const isCloudRunner = process.env.AUTOKAP_CLOUD_RUNNER === '1';
+    if (process.platform !== 'linux' || !isCloudRunner)
+        return null;
+    return {
+        args: [
+            '--headless=new',
+            '--use-gl=angle',
+            '--use-angle=vulkan',
+            '--enable-features=Vulkan',
+            '--ignore-gpu-blocklist',
+            '--enable-gpu-rasterization',
+            '--enable-zero-copy',
+        ],
+        ignoreDefaultArgs: ['--headless'],
+    };
+}
+/** Log the active WebGL renderer once per pooled browser launch so a Cloud Run
+ *  deploy can confirm the L4 bound (NVIDIA) vs a silent SwiftShader fallback. */
+async function logPoolGpuRenderer(browser) {
+    try {
+        const context = await browser.newContext();
+        try {
+            const page = await context.newPage();
+            const info = await page.evaluate(() => {
+                const canvas = document.createElement('canvas');
+                const gl = (canvas.getContext('webgl2') || canvas.getContext('webgl'));
+                if (!gl)
+                    return { error: 'no webgl context' };
+                const ext = gl.getExtension('WEBGL_debug_renderer_info');
+                if (!ext)
+                    return { error: 'no debug_renderer_info extension' };
+                return {
+                    vendor: gl.getParameter(ext.UNMASKED_VENDOR_WEBGL),
+                    renderer: gl.getParameter(ext.UNMASKED_RENDERER_WEBGL),
+                };
+            });
+            console.info('[gpu-check] pool WebGL renderer:', JSON.stringify(info));
+        }
+        finally {
+            await context.close();
+        }
+    }
+    catch (err) {
+        console.warn('[gpu-check] pool WebGL query failed:', err.message);
+    }
+}
 function normalizeDeviceScaleFactor(value) {
     if (!Number.isFinite(value))
         return 2;
@@ -134,7 +194,24 @@ class BrowserPool {
         await this.launchPromise;
     }
     async launchBrowser() {
-        this.browser = await chromium.launch({ headless: true, args: CHROMIUM_ARGS });
+        const gpu = resolveCloudGpuLaunch();
+        if (gpu) {
+            // Cloud Run L4: drop the software-only flags and enable Vulkan/ANGLE GPU
+            // rasterization for headless screenshot capture, mirroring the clip path.
+            const args = [
+                ...CHROMIUM_ARGS.filter((a) => a !== '--disable-gpu' && a !== '--disable-gpu-sandbox'),
+                ...gpu.args,
+            ];
+            this.browser = await chromium.launch({
+                headless: true,
+                ignoreDefaultArgs: gpu.ignoreDefaultArgs,
+                args,
+            });
+            await logPoolGpuRenderer(this.browser);
+        }
+        else {
+            this.browser = await chromium.launch({ headless: true, args: CHROMIUM_ARGS });
+        }
         this.captureCount = 0;
         this.browser.on('disconnected', () => {
             // Browser crashed — active contexts are now dead, they'll throw naturally

package/dist/browser.js

@@ -222,12 +222,14 @@ async function seedCloudChromiumPreferences(userDataDir) {
  */
 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.
+ * Explicit backstop for the heavy screenshot primitives. Sits just under the 45s
+ * global screenshot deadline and ABOVE the runner's reserved action budget
+ * (~global − recovery reserve), so the runner's per-attempt bound is the real
+ * control and this only catches a screenshot that has genuinely wedged. Must not
+ * be smaller than a legitimate slow high-res capture, or it would pre-empt the
+ * runner and fail captures that would have completed.
  */
-const SCREENSHOT_PRIMITIVE_TIMEOUT_MS = 20000;
+const SCREENSHOT_PRIMITIVE_TIMEOUT_MS = 40000;
 /** Apply our engine-wide Playwright defaults to a freshly created context. */
 function applyContextDefaults(context) {
     context.setDefaultTimeout(CONTEXT_ACTION_TIMEOUT_MS);

package/dist/cli-runner.js

@@ -209,7 +209,15 @@ export async function runCapture(options) {
     // serialize variants (CPU/RAM bound on the encoder side). Only 'screenshot'
     // honors the requested concurrency.
     const isRecordable = program.mediaMode === 'clip' || program.mediaMode === 'video';
-    const maxParallelVariants = isRecordable ? 1 : program.maxParallelCaptures;
+    // AUTOKAP_MAX_PARALLEL_CAPTURES lets the RUNTIME (e.g. the Cloud Run container)
+    // clamp per-run variant concurrency below what the server compiled, decoupled
+    // from billing/queue limits. Fewer concurrent captures = more CPU/GPU per
+    // capture on a shared L4 container. Unset/invalid → honor the compiled value.
+    const runtimeConcurrencyCap = Number.parseInt(process.env.AUTOKAP_MAX_PARALLEL_CAPTURES ?? '', 10);
+    const requestedConcurrency = Number.isFinite(runtimeConcurrencyCap) && runtimeConcurrencyCap > 0
+        ? Math.min(program.maxParallelCaptures ?? runtimeConcurrencyCap, runtimeConcurrencyCap)
+        : program.maxParallelCaptures;
+    const maxParallelVariants = isRecordable ? 1 : requestedConcurrency;
     // AUT-149: collect structured logs + progress events for export on failure.
     const logCollector = new LogCollector();
     logCollector.start();

package/dist/opcode-runner.js

@@ -56,13 +56,18 @@ 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.
+ * Recovery budget reserved from the global capture deadline. The screenshot
+ * buffer (the artifact-critical call) may use the REST of the deadline, so a
+ * slow-but-completing high-res capture (e.g. a 5K device frame legitimately
+ * needing 15-30s under load) succeeds, while a truly hung one still fails with
+ * this slice left for the recovery/recapture path. Replaces the old flat 12s
+ * buffer cap, which was smaller than legitimate heavy captures and killed them
+ * (and killed the recapture too, since it re-applied the same 12s wall).
  */
-const CAPTURE_BUFFER_TIMEOUT_MS = 12000;
+const CAPTURE_RECOVERY_RESERVE_MS = 10000;
+/** Floor for the first-attempt capture budget when little global time remains. */
+const MIN_CAPTURE_ACTION_BUDGET_MS = 8000;
+/** Best-effort bound for browser-mockup metadata (URL / favicon / title). */
 const CAPTURE_METADATA_TIMEOUT_MS = 3000;
 /**
  * The compiled per-opcode action budget. For CAPTURE_SCREENSHOT this governs
@@ -510,7 +515,15 @@ async function executeOpcode(opcode, index, adapter, verifier, breaker, recovery
         const isPureWait = opcode.kind === 'WAIT_FOR';
         const usesGlobalDeadline = isPureWait || isArtifactProducingOpcode(opcode.kind);
         const actionDeadlineMs = usesGlobalDeadline ? globalDeadlineMs : deadlineMs;
-        const actionBudgetMs = getRemainingTimeMs(actionDeadlineMs);
+        let actionBudgetMs = getRemainingTimeMs(actionDeadlineMs);
+        // Reserve a slice of the global deadline for recovery/recapture on the
+        // artifact-critical CAPTURE_SCREENSHOT: the capture uses the rest (so a slow
+        // high-res shot completes) yet a hung one still leaves room to recover.
+        // END_CLIP keeps its full budget — its finalization hard-fails without a
+        // recapture, so reserving would only shorten it.
+        if (opcode.kind === 'CAPTURE_SCREENSHOT') {
+            actionBudgetMs = Math.max(MIN_CAPTURE_ACTION_BUDGET_MS, actionBudgetMs - CAPTURE_RECOVERY_RESERVE_MS);
+        }
         if (actionBudgetMs <= 0) {
             const reason = `timeout after ${effectiveTimeoutMs}ms`;
             logger.debug(`[opcode ${index}] no budget left after captureBeforeState (deadline=${actionDeadlineMs}, now=${Date.now()})`);
@@ -891,13 +904,13 @@ async function executeOpcodeAction(opcode, opcodeIndex, adapter, artifacts, tele
                     lowConfidenceReasons.push(`captured before visual stability: ${stability.reason}`);
                 }
                 const captureLowConfidenceReason = lowConfidenceReasons.join('; ') || undefined;
-                // 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);
+                // Capture the screenshot buffer FIRST — the only artifact-critical call.
+                // It is bounded by the reserved action budget (the withTimeout around this
+                // whole action in executeOpcode) and the screenshot primitive's own
+                // timeout — NOT a flat sub-cap — so a legitimately slow high-res capture
+                // can use most of the deadline while a hung one still frees the reserved
+                // recovery slice (handleFailure → recapture in `failWithRecovery`).
+                const buffer = await takeCaptureBuffer(adapter, opcode);
                 // 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

package/dist/wait-contract.js

@@ -23,7 +23,10 @@ export const WAIT_CONTRACT_VERSION = 1;
  * so it never shortens an intentionally-long opcode (`SLEEP`, `END_CLIP`).
  */
 export const GLOBAL_WAIT_CAP_MS = {
-    screenshot: 30_000,
+    // Heavy high-res captures (5K device frames, retina, animated pages) can take
+    // 15-30s under cloud CPU load with software rasterization. 45s gives them room
+    // to complete (and to reserve a recovery slice) instead of failing prematurely.
+    screenshot: 45_000,
     clip: 45_000,
     video: 60_000,
 };

package/package.json

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