autokap 1.3.5 → 1.3.7

package/dist/browser.d.ts

@@ -110,7 +110,9 @@ 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

package/dist/browser.js

@@ -798,7 +798,9 @@ 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
@@ -832,13 +834,14 @@ export class Browser {
             headless: !options.headed,
             args: clipArgs,
         });
-        instance.context = await instance.browser.newContext({
+        const contextOptions = {
             viewport: options.viewport,
             deviceScaleFactor,
             locale: langToLocale(options.lang ?? 'en'),
             colorScheme: options.colorScheme ?? 'light',
             storageState: options.storageState,
-        });
+        };
+        instance.context = await instance.browser.newContext(contextOptions);
         // Inject cursor overlay at context level — survives all navigations in this session
         await instance.context.addInitScript(cursorScript);
         // Also hide dev/prototype chrome on every document, including navigations

package/dist/cli.js

@@ -79,6 +79,40 @@ function ensureExportFormat(format) {
 function printJson(value) {
     console.log(JSON.stringify(value, null, 2));
 }
+function displayPresetName(preset) {
+    const name = preset.name?.trim();
+    return name && name.length > 0 ? name : preset.id;
+}
+function cloudCaptureProgressCheckpoint(event) {
+    switch (event.type) {
+        case 'variant_start':
+            return {
+                type: 'preset_progress',
+                message: `Capture started: ${event.variantId}`,
+            };
+        case 'variant_end':
+            return {
+                type: 'preset_progress',
+                message: event.status === 'ok'
+                    ? `Capture completed: ${event.variantId}`
+                    : `Capture failed: ${event.variantId}`,
+                status: event.status === 'failed' ? 'running' : undefined,
+            };
+        case 'upload_start':
+            return {
+                type: 'upload_start',
+                message: 'Export started',
+            };
+        case 'upload_end':
+            return {
+                type: 'upload_end',
+                message: event.status === 'failed' ? 'Export failed' : 'Export completed',
+                status: event.status === 'failed' ? 'running' : undefined,
+            };
+        default:
+            return null;
+    }
+}
 function buildEndpointAssetUrl(config, endpointId) {
     return `${config.apiBaseUrl}/api/v1/assets/${endpointId}`;
 }
@@ -282,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}`);
         }
     };
     /**
@@ -323,13 +369,57 @@ 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,
         completedPresets: 0,
         failedPresets: 0,
-        message: `planned ${data.presets.length} preset(s)`,
+        message: `Run planned: ${data.presets.length} preset(s)`,
     });
     if (data.presets.length === 0) {
         logger.info(`[auto-recapture] No presets enabled for project ${opts.project}`);
@@ -343,9 +433,10 @@ program
         totalPresets: data.presets.length,
         completedPresets: 0,
         failedPresets: 0,
-        message: `starting ${data.presets.length} preset(s)`,
+        message: `Runner started: ${data.presets.length} preset(s) to capture`,
     });
     for (const [index, preset] of data.presets.entries()) {
+        const presetDisplayName = displayPresetName(preset);
         const label = preset.name ? `${preset.name} (${preset.id})` : preset.id;
         logger.info(`[auto-recapture] Running ${label}`);
         await postCloudCheckpoint({
@@ -356,7 +447,7 @@ program
             totalPresets: data.presets.length,
             completedPresets: index,
             failedPresets: failures.length,
-            message: `running ${preset.name ?? preset.id}`,
+            message: `Preset started: ${presetDisplayName}`,
         });
         const result = await runCapture({
             presetId: preset.id,
@@ -364,23 +455,21 @@ program
             headed: opts.headed,
             allowUploadFailure: opts.allowUploadFailure,
             onProgress: (event) => {
-                const checkpointType = event.type === 'upload_start'
-                    ? 'upload_start'
-                    : event.type === 'upload_end'
-                        ? 'upload_end'
-                        : 'preset_progress';
+                const checkpoint = cloudCaptureProgressCheckpoint(event);
+                if (!checkpoint)
+                    return;
                 void postCloudCheckpoint({
-                    type: checkpointType,
+                    type: checkpoint.type,
                     presetId: preset.id,
                     presetName: preset.name ?? null,
                     presetIndex: index,
                     totalPresets: data.presets.length,
                     completedPresets: index,
                     failedPresets: failures.length,
-                    message: event.message,
+                    message: checkpoint.message,
                     progressEvent: event,
-                    status: event.status === 'failed' ? 'running' : undefined,
-                }, { throttle: checkpointType === 'preset_progress' });
+                    status: checkpoint.status,
+                });
             },
         });
         const childRunId = result.runId;
@@ -399,7 +488,7 @@ program
                 childRunId,
                 status: 'failed',
                 errorMessage: error,
-                message: `failed ${preset.name ?? preset.id}`,
+                message: `Preset failed: ${presetDisplayName}`,
             });
         }
         else {
@@ -413,7 +502,7 @@ program
                 failedPresets: failures.length,
                 childRunId,
                 status: 'completed',
-                message: `completed ${preset.name ?? preset.id}`,
+                message: `Preset completed: ${presetDisplayName}`,
             });
         }
     }
@@ -445,7 +534,7 @@ program
         completedPresets: data.presets.length,
         failedPresets: 0,
         status: 'completed',
-        message: 'cloud recapture completed',
+        message: 'Cloud recapture completed',
     });
     await notifyCloudCallback('completed', {
         totalPresets: data.presets.length,

package/dist/web-playwright-local.js

@@ -446,14 +446,15 @@ export class WebPlaywrightLocal {
             throw new Error('recording was not started');
         }
         if (this.recording.finalized) {
-            const buffer = await fs.readFile(this.recording.mp4Path);
-            const durationMs = this.recording.encodedDurationMs ?? await getMediaDurationMs(this.recording.mp4Path);
+            const sourcePath = this.recording.sourcePath ?? this.recording.mp4Path;
+            const buffer = await fs.readFile(sourcePath);
+            const durationMs = this.recording.encodedDurationMs ?? await getMediaDurationMs(sourcePath);
             this.recording.encodedDurationMs = durationMs;
             return {
                 buffer,
                 durationMs,
-                mimeType: 'video/mp4',
-                trimStartMs: this.recording.result?.trimStartMs ?? 0,
+                mimeType: this.recording.sourceMimeType ?? 'video/mp4',
+                trimStartMs: this.recording.trimStartMs ?? this.recording.result?.trimStartMs ?? 0,
             };
         }
         if (this.recordingNavWatcher) {
@@ -475,6 +476,8 @@ export class WebPlaywrightLocal {
         });
         this.recording.finalized = true;
         this.recording.result = result;
+        this.recording.sourcePath = this.recording.mp4Path;
+        this.recording.sourceMimeType = 'video/mp4';
         this.recording.encodedDurationMs = await getMediaDurationMs(this.recording.mp4Path);
         this.clipCursor = null;
         const buffer = await fs.readFile(this.recording.mp4Path);

package/package.json

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