autokap 1.3.6 → 1.3.8

package/dist/browser.d.ts

@@ -96,7 +96,6 @@ export declare class Browser {
     private browser;
     private context;
     private page;
-    private nativeVideoStartedAt;
     private elementMap;
     private akNodeIndex;
     private poolContext;
@@ -111,15 +110,15 @@ export declare class Browser {
      * Create a Browser dedicated to clip capture. Frames are pulled via CDP
      * `Page.captureScreenshot` in a tight loop by `ClipCaptureLoop` — NOT via
      * Playwright's built-in `recordVideo` (which plateaus at 27 FPS with ~12%
-     * duplicates due to the CDP screencast throttler).
+     * duplicates due to the CDP screencast throttler, and on cloud Linux runs
+     * the WebM encoder on the compositor thread → frame drops to ~4 fps under
+     * software rasterization).
      *
      * Preserves the HiDPI rendering path (`--force-device-scale-factor` +
      * `--window-size`) so the captured frames match viewport × DSF pixels, and
      * the cursor overlay script so clicks/hover moments are visible.
      */
-    static forClipCapture(options: BrowserOptions, cursorScript: string, recording?: {
-        nativeVideoDir?: string;
-    }): Promise<Browser>;
+    static forClipCapture(options: BrowserOptions, cursorScript: string): Promise<Browser>;
     /**
      * Close only the browser context (not the browser process).
      * Used by clip capture to release the context promptly after the CDP loop
@@ -335,7 +334,6 @@ export declare class Browser {
     resizeViewport(width: number, height: number): Promise<void>;
     get currentPage(): Page;
     get browserContext(): BrowserContext;
-    get nativeVideoStartTime(): number | null;
     /**
      * Observation pass for mock data generation.
      * Navigates to the given URL, waits for network idle, and records all JSON API responses.

package/dist/browser.js

@@ -772,7 +772,6 @@ export class Browser {
     browser = null;
     context = null;
     page = null;
-    nativeVideoStartedAt = null;
     elementMap = new Map();
     akNodeIndex = new Map();
     poolContext = false;
@@ -799,33 +798,57 @@ export class Browser {
      * Create a Browser dedicated to clip capture. Frames are pulled via CDP
      * `Page.captureScreenshot` in a tight loop by `ClipCaptureLoop` — NOT via
      * Playwright's built-in `recordVideo` (which plateaus at 27 FPS with ~12%
-     * duplicates due to the CDP screencast throttler).
+     * duplicates due to the CDP screencast throttler, and on cloud Linux runs
+     * the WebM encoder on the compositor thread → frame drops to ~4 fps under
+     * software rasterization).
      *
      * Preserves the HiDPI rendering path (`--force-device-scale-factor` +
      * `--window-size`) so the captured frames match viewport × DSF pixels, and
      * the cursor overlay script so clicks/hover moments are visible.
      */
-    static async forClipCapture(options, cursorScript, recording) {
+    static async forClipCapture(options, cursorScript) {
         const instance = new Browser(options);
         const deviceScaleFactor = normalizeDeviceScaleFactor(options.deviceScaleFactor);
         // Enable GPU compositor on non-Linux platforms so Chrome can render
-        // 2880×1800 without saturating the CPU. Linux (Docker/CI) keeps
-        // `--disable-gpu` from CHROMIUM_ARGS because GPU is rarely available there.
-        const baseArgs = process.platform === 'linux'
-            ? CHROMIUM_ARGS
-            : CHROMIUM_ARGS.filter(arg => arg !== '--disable-gpu' && arg !== '--disable-gpu-sandbox');
-        // Pin ANGLE to the platform's native graphics API. Chrome's default
+        // 2880×1800 without saturating the CPU. Linux cloud runners get
+        // SwiftShader (multi-threaded software ANGLE) instead of `--disable-gpu`
+        // because the default CPU rasterizer caps CDP screenshots at ~165 ms each
+        // → 6 fps clips on heavy React pages. SwiftShader's JIT'd SIMD raster
+        // paths use Fly's 8 vCPUs properly (measured: ~5× faster compositor).
+        // Non-cloud Linux (GitHub Actions free runners, 2 vCPU) stays on the
+        // legacy CPU path — SwiftShader has thread-pool overhead that hurts on
+        // tight CI machines.
+        const isCloudRunner = process.env.AUTOKAP_CLOUD_RUNNER === '1';
+        const isLinuxCloud = process.platform === 'linux' && isCloudRunner;
+        const baseArgs = isLinuxCloud || process.platform !== 'linux'
+            ? CHROMIUM_ARGS.filter(arg => arg !== '--disable-gpu' && arg !== '--disable-gpu-sandbox')
+            : CHROMIUM_ARGS;
+        // Pin ANGLE to the platform's fast graphics backend. Chrome's default
         // backend is OpenGL on macOS, which is far slower than Metal for the
         // compositor (measured 4 FPS vs 32 FPS at 2880×1800 on a heavy React UI).
-        // Same story on Windows where D3D11 is the native fast path.
+        // Same story on Windows where D3D11 is the native fast path. On Linux
+        // cloud, SwiftShader is the multi-threaded software backend.
         const angleArg = process.platform === 'darwin' ? '--use-angle=metal'
             : process.platform === 'win32' ? '--use-angle=d3d11'
-                : null; // Linux: skip — GPU is rarely present in CI anyway
+                : isLinuxCloud ? '--use-angle=swiftshader'
+                    : null;
+        // Cloud-Linux extras: route GL through ANGLE, opt in to SwiftShader
+        // explicitly (Chromium 124+ requires `--enable-unsafe-swiftshader` since
+        // SwiftShader was tagged unsafe for general WebGL — for our headless
+        // captures the security caveat is irrelevant), and bypass the GPU
+        // blocklist that otherwise refuses any GPU path on unrecognized headless
+        // hardware.
+        const linuxCloudGpuArgs = isLinuxCloud ? [
+            '--use-gl=angle',
+            '--enable-unsafe-swiftshader',
+            '--ignore-gpu-blocklist',
+        ] : [];
         const clipArgs = [
             ...baseArgs,
             `--force-device-scale-factor=${deviceScaleFactor}`,
             `--window-size=${Math.round(options.viewport.width)},${Math.round(options.viewport.height)}`,
             ...(angleArg ? [angleArg] : []),
+            ...linuxCloudGpuArgs,
         ];
         // Dedicated browser process for clip capture. Not pooled because clip
         // capture installs context-level init scripts (cursor overlay).
@@ -840,15 +863,6 @@ export class Browser {
             colorScheme: options.colorScheme ?? 'light',
             storageState: options.storageState,
         };
-        if (recording?.nativeVideoDir) {
-            contextOptions.recordVideo = {
-                dir: recording.nativeVideoDir,
-                size: {
-                    width: Math.round(options.viewport.width),
-                    height: Math.round(options.viewport.height),
-                },
-            };
-        }
         instance.context = await instance.browser.newContext(contextOptions);
         // Inject cursor overlay at context level — survives all navigations in this session
         await instance.context.addInitScript(cursorScript);
@@ -874,11 +888,7 @@ export class Browser {
                 document.addEventListener('DOMContentLoaded', install, { once: true });
             }
         }, { styleId: CAPTURE_HIDE_STYLE_ID, css: getCaptureHideCSS() });
-        const nativeVideoStartedAt = Date.now();
         instance.page = await instance.context.newPage();
-        if (recording?.nativeVideoDir) {
-            instance.nativeVideoStartedAt = nativeVideoStartedAt;
-        }
         return instance;
     }
     /**
@@ -5058,9 +5068,6 @@ export class Browser {
     get browserContext() {
         return this.ensureContext();
     }
-    get nativeVideoStartTime() {
-        return this.nativeVideoStartedAt;
-    }
     /**
      * Observation pass for mock data generation.
      * Navigates to the given URL, waits for network idle, and records all JSON API responses.

package/dist/cli-runner.js

@@ -241,13 +241,7 @@ export async function runCapture(options) {
         }
         if (recordable) {
             recordingDir = await fs.mkdtemp(path.join(os.tmpdir(), `autokap-${program.mediaMode}-`));
-            const nativeCloudClipRecording = program.mediaMode === 'clip'
-                && process.env.AUTOKAP_CLOUD_RUNNER === '1'
-                && process.env.AUTOKAP_CLIP_RECORDER !== 'cdp';
-            if (nativeCloudClipRecording) {
-                logger.info('[capture] Cloud clip recorder: native Playwright video (CDP screenshot loop disabled)');
-            }
-            browser = await Browser.forClipCapture(browserOptions, buildCursorOverlayScript(program.artifactPlan.cursorTheme ?? 'minimal'), nativeCloudClipRecording ? { nativeVideoDir: recordingDir } : undefined);
+            browser = await Browser.forClipCapture(browserOptions, buildCursorOverlayScript(program.artifactPlan.cursorTheme ?? 'minimal'));
         }
         else if (browserOptions.headed) {
             // Headed mode: standalone browser (pool is always headless)

package/dist/cli.js

@@ -316,19 +316,31 @@ program
                 return;
             lastProgressCheckpointAt = now;
         }
+        // Surface failures loudly to stderr (logger.error → fly.io machine logs).
+        // Cloud→cloud HTTP can fail silently for many reasons (DNS, firewall,
+        // expired token, dashboard cold-start) and dropping a single checkpoint
+        // produces a "stuck progress bar" symptom on the dashboard with no clue.
+        // The URL + status + error code are the minimum needed to debug from
+        // `flyctl logs` after the fact.
+        const checkpointType = typeof body.type === 'string' ? body.type : 'unknown';
         try {
             const response = await fetch(checkpointUrl, {
                 method: 'POST',
                 headers: { ...authHeaders(config), 'Content-Type': 'application/json' },
                 body: JSON.stringify(body),
+                signal: AbortSignal.timeout(15_000),
             });
             if (!response.ok) {
                 const bodyText = await response.text().catch(() => response.statusText);
-                logger.warn(`[auto-recapture] Cloud checkpoint non-OK (${response.status}): ${bodyText}`);
+                logger.error(`[auto-recapture] Cloud checkpoint POST failed: status=${response.status} ` +
+                    `type=${checkpointType} url=${checkpointUrl} body=${bodyText.slice(0, 200)}`);
             }
         }
         catch (err) {
-            logger.warn(`[auto-recapture] Cloud checkpoint failed (best-effort): ${err.message}`);
+            const error = err;
+            const code = error.code ?? error.name ?? 'unknown';
+            logger.error(`[auto-recapture] Cloud checkpoint POST errored: code=${code} ` +
+                `type=${checkpointType} url=${checkpointUrl} message=${error.message}`);
         }
     };
     /**
@@ -357,7 +369,51 @@ program
             logger.warn(`[auto-recapture] Cloud callback failed (best-effort): ${err.message}`);
         }
     };
-    const data = await requestJson(config, `/api/cli/projects/${opts.project}/auto-recapture-presets`, { headers: authHeaders(config) }, 'Failed to list auto-recapture presets');
+    // Emit a CLI-side "booted" checkpoint before any other network call.
+    // The orchestrator already wrote a `run_start` "cloud runner machine
+    // started" event when it submitted the Fly machine — that event proves
+    // the machine was *scheduled*, not that the container actually booted.
+    // Emitting this from inside the container (and BEFORE the presets fetch)
+    // is the dashboard's only proof the CLI is alive. If this never arrives,
+    // the issue is container boot or fly→dashboard connectivity, not the
+    // capture pipeline.
+    const cliVersionForCheckpoint = process.env.AUTOKAP_CLI_VERSION ?? version;
+    await postCloudCheckpoint({
+        type: 'run_start',
+        status: 'running',
+        message: `CLI booted on cloud runner (autokap@${cliVersionForCheckpoint}) — fetching plan`,
+    });
+    // Fetch the presets list with a hard timeout. Without this, a slow or
+    // unreachable dashboard would leave the CLI hanging forever — the
+    // dashboard would stay stuck at "machine started" with no error surfaced.
+    const presetsPath = `/api/cli/projects/${opts.project}/auto-recapture-presets`;
+    let data;
+    try {
+        const response = await fetch(buildApiUrl(config, presetsPath), {
+            headers: authHeaders(config),
+            signal: AbortSignal.timeout(30_000),
+        });
+        if (!response.ok) {
+            const errorBody = await readApiError(response);
+            throw new Error(`HTTP ${response.status}: ${errorBody}`);
+        }
+        data = await response.json();
+    }
+    catch (error) {
+        const err = error;
+        const isTimeout = err.name === 'TimeoutError' || err.name === 'AbortError';
+        const reason = isTimeout
+            ? `presets fetch timed out after 30s — dashboard unreachable or unresponsive`
+            : `presets fetch failed: ${err.code ? `${err.code} ` : ''}${err.message}`;
+        await postCloudCheckpoint({
+            type: 'error',
+            status: 'failed',
+            message: reason,
+            errorMessage: reason,
+        });
+        await notifyCloudCallback('failed', { totalPresets: 0, failedPresets: 0, errorMessage: reason });
+        fatal(`Failed to list auto-recapture presets: ${reason}`);
+    }
     await postCloudCheckpoint({
         type: 'run_plan',
         totalPresets: data.presets.length,

package/dist/web-playwright-local.js

@@ -352,32 +352,21 @@ export class WebPlaywrightLocal {
         const cloudClipFps = isCloudRunner ? 30 : defaultFps;
         const targetFps = options.captureFps
             ?? (options.mediaMode === 'video' ? 30 : cloudClipFps);
-        const nativeClipVideo = options.mediaMode === 'clip' && isCloudRunner
-            ? page.video()
-            : null;
-        let loop = null;
-        if (nativeClipVideo) {
-            logger.info('[capture] Native cloud clip recorder enabled — using Playwright video stream instead of CDP screenshots');
-        }
-        else {
-            loop = new ClipCaptureLoop({
-                page,
-                framesDir,
-                targetFps,
-                // Cloud runners have CPU headroom — drop the Linux 50 ms idle cushion
-                // (sized for tight CI runners) to let the loop stay close to its target.
-                minRestMs: process.platform === 'linux' && !isCloudRunner ? 50 : 16,
-            });
-            await loop.start();
-        }
+        const loop = new ClipCaptureLoop({
+            page,
+            framesDir,
+            targetFps,
+            // Cloud runners have CPU headroom — drop the Linux 50 ms idle cushion
+            // (sized for tight CI runners) to let the loop stay close to its target.
+            minRestMs: process.platform === 'linux' && !isCloudRunner ? 50 : 16,
+        });
+        await loop.start();
         this.recording = {
             mediaMode: options.mediaMode,
             startedAt: Date.now(),
             framesDir,
             mp4Path: path.join(baseDir, `${options.mediaMode}.mp4`),
             loop,
-            nativeVideo: nativeClipVideo,
-            nativeVideoStartedAt: this.browser.nativeVideoStartTime,
             finalized: false,
         };
         this.clipCursor = {
@@ -472,32 +461,6 @@ export class WebPlaywrightLocal {
             this.recordingNavWatcher.detach();
             this.recordingNavWatcher = null;
         }
-        if (this.recording.nativeVideo) {
-            const video = this.recording.nativeVideo;
-            const trimStartMs = Math.max(0, this.recording.startedAt
-                - (this.recording.nativeVideoStartedAt ?? this.sessionStartedAt));
-            await this.browser.closeContext();
-            const videoPath = await video.path();
-            const durationMs = await getMediaDurationMs(videoPath);
-            logger.info(`[capture] Native clip recording finalized: source ${durationMs}ms, ` +
-                `trim start ${Math.round(trimStartMs)}ms`);
-            this.recording.finalized = true;
-            this.recording.sourcePath = videoPath;
-            this.recording.sourceMimeType = 'video/webm';
-            this.recording.trimStartMs = trimStartMs;
-            this.recording.encodedDurationMs = durationMs;
-            this.clipCursor = null;
-            const buffer = await fs.readFile(videoPath);
-            return {
-                buffer,
-                durationMs,
-                mimeType: 'video/webm',
-                trimStartMs,
-            };
-        }
-        if (!this.recording.loop) {
-            throw new Error('recording loop was not initialized');
-        }
         const result = await this.recording.loop.stop();
         logger.info(`[capture] Clip frame capture: ${result.frameCount} frame(s), ` +
             `${result.measuredFps.toFixed(1)} fps over ${(result.actualDurationMs / 1000).toFixed(2)}s ` +

package/package.json

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