autokap 1.2.0 → 1.3.1

package/dist/cli-runner.js

@@ -21,17 +21,86 @@ import { executeProgram } from './opcode-runner.js';
 import { RecoveryChainImpl } from './recovery-chain.js';
 import { parseProgram } from './execution-schema.js';
 import { buildCursorOverlayScript } from './cursor-overlay-script.js';
-import { CLI_VERSION_HEADER } from './cli-contract.js';
+import { CLI_VERSION_HEADER, } from './cli-contract.js';
 import { logger } from './logger.js';
 import { callLLM } from './llm-provider.js';
 import { APP_VERSION } from './version.js';
 import { normalizeAllowedOrigins, normalizeHttpOrigin, verifySignedExecutionProgramEnvelope, } from './program-signing.js';
 const MAX_CLIP_CAPTURE_DEVICE_SCALE_FACTOR = 1;
+const DEFAULT_VIDEO_DELIVERY_RESOLUTION = { width: 1920, height: 1080 };
+const DEFAULT_VIDEO_CAPTURE_RESOLUTION = DEFAULT_VIDEO_DELIVERY_RESOLUTION;
 const FETCH_PROGRAM_MAX_ATTEMPTS = 4;
 const FETCH_PROGRAM_RETRY_DELAYS_MS = [1000, 3000, 5000];
 const DEFAULT_SCREENSHOT_ARTIFACT_UPLOAD_CONCURRENCY = 4;
 const DEFAULT_MEDIA_ARTIFACT_UPLOAD_CONCURRENCY = 2;
 const MAX_ARTIFACT_UPLOAD_CONCURRENCY = 8;
+export function resolveRecordableBrowserSettings(program, variant) {
+    const requestedDeviceScaleFactor = normalizeNumericScale(variant.deviceScaleFactor ?? program.outputScale ?? 2);
+    if (program.mediaMode !== 'video') {
+        return {
+            viewport: variant.viewport,
+            requestedDeviceScaleFactor,
+            runtimeDeviceScaleFactor: Math.min(requestedDeviceScaleFactor, MAX_CLIP_CAPTURE_DEVICE_SCALE_FACTOR),
+        };
+    }
+    return {
+        viewport: {
+            width: DEFAULT_VIDEO_DELIVERY_RESOLUTION.width,
+            height: DEFAULT_VIDEO_DELIVERY_RESOLUTION.height,
+        },
+        requestedDeviceScaleFactor,
+        runtimeDeviceScaleFactor: 1,
+    };
+}
+export function normalizeVideoCaptureProgram(program) {
+    if (program.mediaMode !== 'video')
+        return program;
+    const format = program.artifactPlan.format ?? {};
+    const deliveryResolution = DEFAULT_VIDEO_DELIVERY_RESOLUTION;
+    const captureResolution = format.captureResolution ?? DEFAULT_VIDEO_CAPTURE_RESOLUTION;
+    // Variants are normalized too so any code path that reads `variant.viewport`
+    // or `variant.deviceScaleFactor` directly (not just resolveRecordableBrowserSettings)
+    // sees consistent 1920×1080 @1× values. Legacy presets carrying
+    // viewport=2560×1440 or DPR=1.3333 would otherwise leak through.
+    const targetViewport = { width: deliveryResolution.width, height: deliveryResolution.height };
+    const variantsAlreadyNormalized = program.variants.every((v) => v.viewport.width === targetViewport.width &&
+        v.viewport.height === targetViewport.height &&
+        (v.deviceScaleFactor === undefined || v.deviceScaleFactor === 1));
+    const formatAlreadyNormalized = captureResolution.width === deliveryResolution.width &&
+        captureResolution.height === deliveryResolution.height &&
+        format.deliveryResolution?.width === deliveryResolution.width &&
+        format.deliveryResolution.height === deliveryResolution.height;
+    const outputScaleAlreadyNormalized = program.outputScale === undefined || program.outputScale === 1;
+    if (variantsAlreadyNormalized && formatAlreadyNormalized && outputScaleAlreadyNormalized) {
+        return program;
+    }
+    return {
+        ...program,
+        outputScale: 1,
+        variants: program.variants.map((v) => ({
+            ...v,
+            viewport: { ...targetViewport },
+            deviceScaleFactor: 1,
+        })),
+        artifactPlan: {
+            ...program.artifactPlan,
+            format: {
+                ...format,
+                captureResolution: {
+                    width: deliveryResolution.width,
+                    height: deliveryResolution.height,
+                },
+                deliveryResolution,
+            },
+        },
+    };
+}
+function normalizeNumericScale(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0) {
+        return 1;
+    }
+    return value;
+}
 const HEALER_SYSTEM_PROMPT = 'You repair failed deterministic browser opcodes. Respond only with JSON.';
 // ── Main entry point ────────────────────────────────────────────────
 export async function runCapture(options) {
@@ -41,7 +110,7 @@ export async function runCapture(options) {
     if (options.program) {
         let parsedProgram;
         try {
-            parsedProgram = parseProgram(options.program);
+            parsedProgram = normalizeVideoCaptureProgram(parseProgram(options.program));
         }
         catch (err) {
             return { success: false, error: `program validation failed: ${err instanceof Error ? err.message : String(err)}` };
@@ -64,7 +133,7 @@ export async function runCapture(options) {
             // Step 2: Validate the program fetched from the server.
             resolvedProgram = {
                 ...resolvedProgram,
-                program: parseProgram(resolvedProgram.program),
+                program: normalizeVideoCaptureProgram(parseProgram(resolvedProgram.program)),
             };
         }
         catch (err) {
@@ -80,12 +149,30 @@ export async function runCapture(options) {
             presetId: options.presetId,
         };
     }
+    const runId = randomUUID();
+    let videoAudioAssets;
+    let videoAudioAssetsByLocale;
     try {
         assertProgramNavigationScope(program, resolvedProgram.security);
     }
     catch (error) {
         return { success: false, error: error instanceof Error ? error.message : String(error) };
     }
+    if (!options.program && program.mediaMode === 'video') {
+        const prepareResult = await prepareVideoSpeechForRun(config, options.presetId, runId);
+        if (!prepareResult.success) {
+            return { success: false, error: prepareResult.error };
+        }
+        program = applyVideoSpeechDurations(program, prepareResult.durationsByStepId);
+        videoAudioAssets = prepareResult.audioAssets;
+        videoAudioAssetsByLocale = prepareResult.audioAssetsByLocale;
+        try {
+            program = normalizeVideoCaptureProgram(parseProgram(program));
+        }
+        catch (err) {
+            return { success: false, error: `prepared video program validation failed: ${err instanceof Error ? err.message : String(err)}` };
+        }
+    }
     logger.info(`[capture] Running preset "${options.presetId}" — ${program.steps.length} opcodes, ${program.variants.length} variant(s)`);
     logger.info(`[capture] Resolved API origin ${resolvedProgram.security.expectedApiOrigin}; navigation scope: ${resolvedProgram.security.allowedNavigationOrigins.join(', ')}`);
     const llmConfig = resolveCliLLMConfig(resolvedProgram.security);
@@ -97,9 +184,11 @@ export async function runCapture(options) {
         credentials: program.preconditions.credentials,
     });
     // Step 4: Execute the program
-    const maxParallelVariants = program.mediaMode === 'clip'
-        ? 1
-        : program.maxParallelCaptures;
+    // 'clip' and 'video' both go through the frame-capture pipeline and need to
+    // 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;
     const runOptions = {
         recoveryChain,
         abortSignal: options.abortSignal,
@@ -116,20 +205,21 @@ export async function runCapture(options) {
     const captureStart = Date.now();
     if (maxParallelVariants) {
         logger.info(`[capture] Concurrency cap resolved to ${maxParallelVariants} parallel variant(s)`);
-        if (program.mediaMode === 'clip' && program.maxParallelCaptures && program.maxParallelCaptures > 1) {
-            logger.info(`[capture] Clip capture concurrency capped at 1 ` +
+        if (isRecordable && program.maxParallelCaptures && program.maxParallelCaptures > 1) {
+            logger.info(`[capture] ${program.mediaMode} capture concurrency capped at 1 ` +
                 `(requested ${program.maxParallelCaptures}) to avoid CI CPU contention`);
         }
     }
     const createAdapter = async (variant) => {
-        const recordable = program.mediaMode === 'clip';
-        const requestedDeviceScaleFactor = variant.deviceScaleFactor ?? program.outputScale ?? 2;
-        const runtimeDeviceScaleFactor = recordable && Number.isFinite(requestedDeviceScaleFactor)
-            ? Math.min(Number(requestedDeviceScaleFactor), MAX_CLIP_CAPTURE_DEVICE_SCALE_FACTOR)
-            : requestedDeviceScaleFactor;
+        const recordable = isRecordable;
+        const recordableSettings = recordable
+            ? resolveRecordableBrowserSettings(program, variant)
+            : null;
+        const requestedDeviceScaleFactor = recordableSettings?.requestedDeviceScaleFactor ?? (variant.deviceScaleFactor ?? program.outputScale ?? 2);
+        const runtimeDeviceScaleFactor = recordableSettings?.runtimeDeviceScaleFactor ?? requestedDeviceScaleFactor;
         const browserOptions = {
             headed: options.headed ?? false,
-            viewport: variant.viewport,
+            viewport: recordableSettings?.viewport ?? variant.viewport,
             deviceScaleFactor: runtimeDeviceScaleFactor,
             lang: variant.locale,
             colorScheme: variant.theme,
@@ -138,7 +228,14 @@ export async function runCapture(options) {
         let recordingDir;
         let browser;
         logger.info(`[capture] Launching browser${browserOptions.headed ? ' (headed)' : ''}…`);
-        if (recordable && runtimeDeviceScaleFactor !== requestedDeviceScaleFactor) {
+        if (recordable) {
+            logger.info(`[capture] Recordable browser settings: mediaMode=${program.mediaMode}, ` +
+                `variant.viewport=${variant.viewport.width}x${variant.viewport.height}, ` +
+                `variant.deviceScaleFactor=${variant.deviceScaleFactor ?? 'unset'}, ` +
+                `program.outputScale=${program.outputScale ?? 'unset'} ` +
+                `→ runtime viewport=${browserOptions.viewport.width}x${browserOptions.viewport.height} @DPR=${browserOptions.deviceScaleFactor}`);
+        }
+        if (recordable && program.mediaMode === 'clip' && runtimeDeviceScaleFactor !== requestedDeviceScaleFactor) {
             logger.info(`[capture] Clip capture scale capped at ${runtimeDeviceScaleFactor} ` +
                 `(requested ${requestedDeviceScaleFactor}) to preserve recording FPS`);
         }
@@ -167,7 +264,10 @@ export async function runCapture(options) {
     }
     try {
         logger.info('[capture] Saving captures, might take a few seconds...');
-        await uploadResults(config, program, runResult);
+        const uploadOutcome = await uploadResults(config, program, runResult, runId);
+        if (program.mediaMode === 'video' && runResult.success) {
+            await signalVideoComplete(config, program, runResult, uploadOutcome.runId, videoAudioAssets, videoAudioAssetsByLocale);
+        }
         const totalDurationSec = ((Date.now() - captureStart) / 1000).toFixed(1);
         logger.info(`[capture] Captures saved successfully — total ${totalDurationSec}s`);
     }
@@ -244,12 +344,220 @@ async function fetchProgram(config, presetId, environmentName) {
             expectedApiOrigin: safeOrigin(config.apiBaseUrl),
         });
         if (envelope.meta?.stale) {
-            logger.warn('[capture] Program is stale — langs/themes changed since last compilation. Recompile to apply changes.');
+            logger.warn('[capture] Program needs regeneration — preset settings require missing or outdated opcodes. Regenerate before relying on this capture.');
         }
         return { success: true, program: envelope.program, security: envelope.security };
     }
     return { success: false, error: 'failed to fetch program: retry attempts exhausted' };
 }
+async function prepareVideoSpeechForRun(config, videoId, runId) {
+    logger.info('[capture] Generating speech, may take a few seconds...');
+    const url = `${config.apiBaseUrl}/api/cli/video-prepare`;
+    let response;
+    try {
+        response = await fetch(url, {
+            method: 'POST',
+            headers: {
+                'Authorization': `Bearer ${config.apiKey}`,
+                'Content-Type': 'application/json',
+                [CLI_VERSION_HEADER]: APP_VERSION,
+            },
+            body: JSON.stringify({ videoId, runId }),
+        });
+    }
+    catch (err) {
+        return {
+            success: false,
+            error: `failed to generate speech: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+    if (!response.ok) {
+        return {
+            success: false,
+            error: `failed to generate speech: ${await formatServerError(response, url)}`,
+        };
+    }
+    if (!response.body) {
+        return { success: false, error: 'failed to generate speech: server returned an empty stream' };
+    }
+    const decoder = new TextDecoder();
+    const reader = response.body.getReader();
+    let buffered = '';
+    let donePayload = null;
+    let streamError = null;
+    const consumeLine = (line) => {
+        const trimmed = line.trim();
+        if (!trimmed)
+            return;
+        let event;
+        try {
+            event = JSON.parse(trimmed);
+        }
+        catch (err) {
+            streamError = `failed to parse speech progress: ${err instanceof Error ? err.message : String(err)}`;
+            return;
+        }
+        if (event.type === 'tts_progress') {
+            logTtsProgress(event);
+            return;
+        }
+        if (event.type === 'error') {
+            streamError = event.error ?? 'speech generation failed';
+            return;
+        }
+        if (event.type === 'done') {
+            const durationsByStepId = parseDurationsByStepId(event.durationsByStepId);
+            const audioAssets = parseVideoAudioAssets(event.audioAssets);
+            const audioAssetsByLocale = parseVideoAudioAssetsByLocale(event.audioAssetsByLocale);
+            const hasLocaleAssets = Object.keys(audioAssetsByLocale).length > 0;
+            if (Object.keys(durationsByStepId).length === 0 || audioAssets.length === 0) {
+                streamError = 'speech generation completed without audio assets or SLEEP durations';
+                return;
+            }
+            donePayload = {
+                success: true,
+                durationsByStepId,
+                audioAssets,
+                ...(hasLocaleAssets ? { audioAssetsByLocale } : {}),
+            };
+        }
+    };
+    while (true) {
+        const { value, done } = await reader.read();
+        if (done)
+            break;
+        buffered += decoder.decode(value, { stream: true });
+        const lines = buffered.split(/\r?\n/);
+        buffered = lines.pop() ?? '';
+        for (const line of lines) {
+            consumeLine(line);
+            if (streamError)
+                break;
+        }
+        if (streamError) {
+            await reader.cancel().catch(() => undefined);
+            break;
+        }
+    }
+    buffered += decoder.decode();
+    if (!streamError && buffered.trim()) {
+        consumeLine(buffered);
+    }
+    if (streamError) {
+        return { success: false, error: streamError };
+    }
+    if (!donePayload) {
+        return { success: false, error: 'speech generation stream ended before completion' };
+    }
+    logger.info('[capture] TTS DONE');
+    return donePayload;
+}
+function logTtsProgress(event) {
+    const index = typeof event.index === 'number' ? event.index : '?';
+    const total = typeof event.total === 'number' ? event.total : '?';
+    const stepId = event.stepId ?? 'unknown-step';
+    if (event.stage === 'synthesizing') {
+        const preview = event.textPreview ? ` — "${event.textPreview}"` : '';
+        logger.info(`[capture] TTS ${index}/${total}: generating ${stepId}${preview}`);
+    }
+    else if (event.stage === 'uploading') {
+        logger.info(`[capture] TTS ${index}/${total}: uploading ${stepId}`);
+    }
+    else if (event.stage === 'done') {
+        const duration = typeof event.durationMs === 'number' ? ` (${event.durationMs}ms)` : '';
+        logger.info(`[capture] TTS ${index}/${total}: done ${stepId}${duration}`);
+    }
+}
+function parseDurationsByStepId(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return {};
+    const out = {};
+    for (const [key, value] of Object.entries(raw)) {
+        if (typeof key !== 'string' || !key)
+            continue;
+        if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0)
+            continue;
+        out[key] = Math.max(1, Math.min(60_000, Math.round(value)));
+    }
+    return out;
+}
+function parseVideoAudioAssets(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    return raw.flatMap((entry) => {
+        if (!entry || typeof entry !== 'object')
+            return [];
+        const asset = entry;
+        if (typeof asset.stepId !== 'string'
+            || !asset.stepId
+            || typeof asset.url !== 'string'
+            || !asset.url
+            || typeof asset.duration_ms !== 'number'
+            || !Number.isFinite(asset.duration_ms)
+            || asset.duration_ms <= 0) {
+            return [];
+        }
+        const word_timings = parseVideoWordTimings(asset.word_timings);
+        return [{
+                stepId: asset.stepId,
+                url: asset.url,
+                duration_ms: Math.round(asset.duration_ms),
+                ...(word_timings.length > 0 ? { word_timings } : {}),
+            }];
+    });
+}
+function parseVideoAudioAssetsByLocale(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return {};
+    const out = {};
+    for (const [locale, value] of Object.entries(raw)) {
+        if (!locale)
+            continue;
+        const assets = parseVideoAudioAssets(value);
+        if (assets.length > 0)
+            out[locale] = assets;
+    }
+    return out;
+}
+function parseVideoWordTimings(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    return raw.flatMap((entry) => {
+        if (!entry || typeof entry !== 'object')
+            return [];
+        const word = entry;
+        if (typeof word.word !== 'string'
+            || typeof word.start_ms !== 'number'
+            || typeof word.end_ms !== 'number') {
+            return [];
+        }
+        return [{
+                word: word.word,
+                start_ms: Math.max(0, Math.round(word.start_ms)),
+                end_ms: Math.max(0, Math.round(word.end_ms)),
+            }];
+    });
+}
+function applyVideoSpeechDurations(program, durationsByStepId) {
+    const steps = program.steps.map((step) => {
+        if (step.kind !== 'SLEEP')
+            return step;
+        const stepId = typeof step.stepId === 'string' ? step.stepId : null;
+        if (!stepId)
+            return step;
+        const durationMs = durationsByStepId[stepId];
+        if (!durationMs)
+            return step;
+        return {
+            ...step,
+            durationMs,
+        };
+    });
+    return {
+        ...program,
+        steps: steps,
+    };
+}
 function shouldRetryProgramFetch(status, error) {
     if ([408, 429, 500, 502, 503, 504].includes(status)) {
         return true;
@@ -272,8 +580,7 @@ function getProgramFetchRetryDelayMs(attempt) {
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
-async function uploadResults(config, program, result) {
-    const runId = randomUUID();
+async function uploadResults(config, program, result, runId = randomUUID()) {
     const artifactJobs = result.variantResults.flatMap((variant) => {
         const variantSpec = program.variants.find((entry) => entry.id === variant.variantId);
         return variant.artifacts.map((artifact) => ({
@@ -343,6 +650,93 @@ async function uploadResults(config, program, result) {
     if (!telemetryResponse.ok) {
         throw new Error(`telemetry upload failed: ${await formatServerError(telemetryResponse, `${config.apiBaseUrl}/api/cli/telemetry`)}`);
     }
+    return { runId };
+}
+/**
+ * AUT-57 PR #5 — signal `/api/cli/video-complete` after all clip artifacts
+ * have been uploaded. Builds the per-clip metadata from `RunResult.opcodeTimings`
+ * and the video clip artifacts, posts to the queue endpoint. Throws on
+ * non-2xx so the caller can surface the failure.
+ *
+ * `mp4StoragePath` is conventional — the upload step (PR #6) ranges video
+ * clips under `raw/{video_id}/{clip_id}.mp4` in the `videos` bucket so the
+ * compositor can fetch them from a stable path.
+ */
+async function signalVideoComplete(config, program, result, runId, audioAssets, audioAssetsByLocale) {
+    const videoId = program.presetId; // The CLI passes the video id in the preset id slot.
+    const clips = buildVideoClipMetadata(videoId, result, program, runId);
+    if (clips.length === 0) {
+        throw new Error('video-complete: no MP4 clips were produced — refusing to queue compositor job');
+    }
+    const payload = {
+        videoId,
+        runId,
+        clips,
+        ...(audioAssets && audioAssets.length > 0 ? { audioAssets } : {}),
+        ...(audioAssetsByLocale && Object.keys(audioAssetsByLocale).length > 0
+            ? { audioAssetsByLocale }
+            : {}),
+    };
+    const url = `${config.apiBaseUrl}/api/cli/video-complete`;
+    const response = await fetch(url, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${config.apiKey}`,
+            'Content-Type': 'application/json',
+            [CLI_VERSION_HEADER]: APP_VERSION,
+        },
+        body: JSON.stringify(payload),
+    });
+    if (!response.ok) {
+        throw new Error(`video-complete failed: ${await formatServerError(response, url)}`);
+    }
+    return (await response.json());
+}
+export function buildVideoClipMetadata(videoId, result, program, runId) {
+    const clipsByKey = new Map();
+    for (const variant of result.variantResults) {
+        const variantId = variant.variantId;
+        const variantSpec = program?.variants.find((entry) => entry.id === variantId);
+        for (const artifact of variant.artifacts) {
+            if (artifact.mediaMode !== 'video' && artifact.mediaMode !== 'clip')
+                continue;
+            if (!artifact.clipId)
+                continue;
+            // Conventional storage path; the upload route enforces the same convention.
+            const storagePath = runId
+                ? `raw/${videoId}/${runId}/${variantId}/${artifact.clipId}.mp4`
+                : `raw/${videoId}/${variantId}/${artifact.clipId}.mp4`;
+            const matchingTimings = result.opcodeTimings
+                .filter((t) => t.variantId === variantId && t.clipId === artifact.clipId)
+                .map((t) => ({
+                stepIndex: t.stepIndex,
+                stepId: t.stepId,
+                opcodeKind: t.opcodeKind,
+                timecodeStartMs: t.timecodeStartMs,
+                timecodeEndMs: t.timecodeEndMs,
+                bbox: t.bbox ?? null,
+            }));
+            clipsByKey.set(`${variantId}:${artifact.clipId}`, {
+                variantId,
+                lang: variantSpec?.locale ?? inferVariantLocale(variantId),
+                theme: variantSpec?.theme ?? inferVariantTheme(variantId),
+                clipId: artifact.clipId,
+                mp4StoragePath: storagePath,
+                durationMs: artifact.durationMs ?? 0,
+                opcodeTimings: matchingTimings,
+            });
+        }
+    }
+    return [...clipsByKey.values()];
+}
+function inferVariantLocale(variantId) {
+    const parts = variantId.split('-').filter(Boolean);
+    if (parts.length >= 2)
+        return parts[parts.length - 2];
+    return 'en';
+}
+function inferVariantTheme(variantId) {
+    return variantId.endsWith('-dark') ? 'dark' : 'light';
 }
 async function uploadArtifact(config, program, runId, totalArtifacts, uploadNumber, job) {
     const { artifact, variant, variantSpec } = job;
@@ -368,7 +762,8 @@ async function uploadArtifact(config, program, runId, totalArtifacts, uploadNumb
         formData.append('deviceFrame', variantSpec.deviceFrame);
     }
     const requestedDeviceScaleFactor = variantSpec?.deviceScaleFactor ?? program.outputScale ?? 2;
-    const deviceScaleFactor = artifact.mediaMode === 'clip' && Number.isFinite(requestedDeviceScaleFactor)
+    const isFrameCapture = artifact.mediaMode === 'clip' || artifact.mediaMode === 'video';
+    const deviceScaleFactor = isFrameCapture && Number.isFinite(requestedDeviceScaleFactor)
         ? Math.min(Number(requestedDeviceScaleFactor), MAX_CLIP_CAPTURE_DEVICE_SCALE_FACTOR)
         : requestedDeviceScaleFactor;
     if (Number.isFinite(deviceScaleFactor)) {

package/dist/cli.js

@@ -240,12 +240,17 @@ program
     .option('--local', `Use the local AutoKap dev server (${LOCAL_API_BASE_URL})`, false)
     .option('--allow-upload-failure', 'Keep a successful capture exit code even if artifact upload fails', false)
     .option('--debug', 'Verbose logging: per-substep timing, opcode dumps, recovery strategy traces', false)
+    .option('--cloud', 'Cloud runner mode: signals 4+ vCPU available, unblocks the conservative Linux FPS default (8 → 30)', false)
     .action(async (opts) => {
     if (opts.debug) {
         const { setDebugEnabled } = await import('./logger.js');
         setDebugEnabled(true);
         logger.info('[capture] Debug mode enabled — verbose logging on');
     }
+    if (opts.cloud) {
+        process.env.AUTOKAP_CLOUD_RUNNER = '1';
+        logger.info('[capture] Cloud runner mode — Linux FPS cap lifted (clips target 30 fps)');
+    }
     if (opts.local) {
         process.env[API_BASE_URL_ENV_VAR] = LOCAL_API_BASE_URL;
         process.env[WS_URL_ENV_VAR] = LOCAL_WS_URL;
@@ -606,6 +611,81 @@ presetCmd
     console.log(JSON.stringify(info, null, 2));
     process.exit(0);
 });
+// ── video commands ─────────────────────────────────────────────────
+//
+// Mirrors the preset commands but targets `/api/video-projects` (CLI-keyed
+// route used by the IDE skill flow). The payload file contains the full
+// body expected by the API (projectId, title, user_script, legacy
+// narration_voice/narration_locale aliases, narration_by_app_locale,
+// app_locale/app_locales, app_theme/app_themes, cursor_theme,
+// credentials_account_id, mockDataInjection, program). On `update`, the same payload shape is sent
+// via PATCH. TTS is generated later by `autokap run`.
+const videoCmd = program
+    .command('video')
+    .description('Manage demo videos');
+videoCmd
+    .command('create')
+    .description('Create a new demo video from a JSON payload file')
+    .requiredOption('--payload <file>', 'Path to payload JSON file (use "-" for stdin)')
+    .action(async (opts) => {
+    const cfg = await requireConfig();
+    let payload;
+    try {
+        payload = await readJsonInput(opts.payload);
+    }
+    catch (err) {
+        logger.error(`Failed to read payload: ${err.message}`);
+        process.exit(1);
+    }
+    const res = await fetch(`${cfg.apiBaseUrl}/api/video-projects`, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${cfg.apiKey}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(payload),
+    });
+    if (!res.ok) {
+        const body = await res.json().catch(() => ({ error: res.statusText }));
+        logger.error(`Failed to create video: ${body.error || res.statusText}`);
+        process.exit(1);
+    }
+    const data = await res.json();
+    // Output only the video ID so callers can chain: autokap run $(autokap video create ...)
+    console.log(data.video.id);
+    process.exit(0);
+});
+videoCmd
+    .command('update <video-id>')
+    .description('Update an existing demo video from a JSON payload file')
+    .requiredOption('--payload <file>', 'Path to payload JSON file (use "-" for stdin)')
+    .action(async (videoId, opts) => {
+    const cfg = await requireConfig();
+    let payload;
+    try {
+        payload = await readJsonInput(opts.payload);
+    }
+    catch (err) {
+        logger.error(`Failed to read payload: ${err.message}`);
+        process.exit(1);
+    }
+    const res = await fetch(`${cfg.apiBaseUrl}/api/video-projects/${videoId}`, {
+        method: 'PATCH',
+        headers: {
+            Authorization: `Bearer ${cfg.apiKey}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(payload),
+    });
+    if (!res.ok) {
+        const body = await res.json().catch(() => ({ error: res.statusText }));
+        logger.error(`Failed to update video: ${body.error || res.statusText}`);
+        process.exit(1);
+    }
+    const data = await res.json();
+    console.log(data.video.id);
+    process.exit(0);
+});
 // ── auth commands ──────────────────────────────────────────────────
 const authCmd = program
     .command('auth')

package/dist/clip-capture-loop.js

@@ -34,10 +34,19 @@ export class ClipCaptureLoop {
         this.page = opts.page;
         this.framesDir = opts.framesDir;
         this.jpegQuality = opts.jpegQuality ?? 80;
-        const targetFps = Math.max(1, Math.min(30, opts.targetFps ?? (process.platform === 'linux' ? 8 : 15)));
+        // Linux default is 8 fps to stay safe on 2 vCPU CI runners. Cloud runners
+        // (AUTOKAP_CLOUD_RUNNER=1, set by the Fly.io image and the `--cloud` CLI
+        // flag) get the same 15 fps default as macOS/Windows since they have
+        // ≥ 4 vCPU. Callers can still override via opts.targetFps.
+        const isCloudRunner = process.env.AUTOKAP_CLOUD_RUNNER === '1';
+        const linuxDefault = isCloudRunner ? 15 : 8;
+        const platformDefault = process.platform === 'linux' ? linuxDefault : 15;
+        const targetFps = Math.max(1, Math.min(30, opts.targetFps ?? platformDefault));
         this.targetFps = targetFps;
         this.targetFrameIntervalMs = 1000 / targetFps;
-        this.minRestMs = Math.max(0, Math.min(250, opts.minRestMs ?? (process.platform === 'linux' ? 50 : 16)));
+        const linuxMinRest = isCloudRunner ? 16 : 50;
+        const platformMinRest = process.platform === 'linux' ? linuxMinRest : 16;
+        this.minRestMs = Math.max(0, Math.min(250, opts.minRestMs ?? platformMinRest));
     }
     async start() {
         this.cdp = await this.page.context().newCDPSession(this.page);

package/dist/cookie-dismiss.d.ts

@@ -1,4 +1,5 @@
 import type { Page } from 'playwright';
+export declare const CAPTURE_HIDE_STYLE_ID = "autokap-capture-hide-style";
 export declare function getCaptureHideCSS(): string;
 export declare function ensureCaptureHideStyles(page: Page): Promise<void>;
 export declare function dismissCookiesAndWidgets(page: Page): Promise<{