autokap 1.9.9 → 2.0.0

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();