autokap 1.0.7 → 1.0.8

package/dist/clip-orchestrator.js

@@ -1,4 +1,4 @@
-import { mkdtemp } from 'node:fs/promises';
+import { mkdtemp, rm } from 'node:fs/promises';
 import os from 'node:os';
 import path from 'node:path';
 import { logger } from './logger.js';
@@ -891,8 +891,9 @@ async function runClipVariantAttempt(clip, target, lang, theme, navResult, confi
         clipOptions,
         parentSignal: config.abortSignal,
         run: async (_signal, _attempt, _phaseContext) => {
+            let outputDir = null;
             try {
-                const outputDir = await mkdtemp(path.join(os.tmpdir(), `clip-${clip.id}-`));
+                outputDir = await mkdtemp(path.join(os.tmpdir(), `clip-${clip.id}-`));
                 const outputScale = config.outputScale ?? 1;
                 const postResult = await postProcessClipRecording(recordResult.videoPath, outputDir, `${clip.id}_${variantId.replace(/:/g, '_')}`, {
                     ...clipOptions,
@@ -906,6 +907,12 @@ async function runClipVariantAttempt(clip, target, lang, theme, navResult, confi
                 logger.error(`Post-processing failed for clip "${clip.name}" variant ${variantId}: ${err.message}`);
                 return { ok: false, reason: `Post-processing failed: ${err.message}` };
             }
+            finally {
+                // Clean up temp directory to avoid orphaned files
+                if (outputDir) {
+                    rm(outputDir, { recursive: true, force: true }).catch(() => { });
+                }
+            }
         },
     });
     if (!postprocessPhase.ok) {

package/dist/clip-postprocess.js

@@ -1,5 +1,5 @@
 import { execFile } from 'node:child_process';
-import { stat } from 'node:fs/promises';
+import { rm, stat } from 'node:fs/promises';
 import path from 'node:path';
 import { promisify } from 'node:util';
 const execFileAsync = promisify(execFile);
@@ -9,24 +9,33 @@ const DEFAULT_GIF_MAX_WIDTH = 800;
 const DEFAULT_MAX_DURATION_SEC = 8;
 const DEFAULT_TRIM_START_SEC = 0.3;
 // ── ffmpeg detection ────────────────────────────────────────────────
-let cachedFfmpegPath = null;
+const cachedBinaryPaths = {};
+async function ensureBinaryAvailable(binaryName) {
+    const cached = cachedBinaryPaths[binaryName];
+    if (cached)
+        return cached;
+    const resolver = process.platform === 'win32' ? 'where' : 'which';
+    const { stdout } = await execFileAsync(resolver, [binaryName]);
+    const resolvedPath = stdout
+        .split(/\r?\n/)
+        .map(line => line.trim())
+        .find(Boolean);
+    if (!resolvedPath) {
+        throw new Error(`${binaryName} not found`);
+    }
+    cachedBinaryPaths[binaryName] = resolvedPath;
+    return resolvedPath;
+}
 /**
  * Resolve the system ffmpeg binary path. Throws if not found.
  */
 export async function ensureFfmpegAvailable() {
-    if (cachedFfmpegPath)
-        return cachedFfmpegPath;
     try {
-        const { stdout } = await execFileAsync('which', ['ffmpeg']);
-        const ffmpegPath = stdout.trim();
-        if (!ffmpegPath)
-            throw new Error('ffmpeg not found');
-        cachedFfmpegPath = ffmpegPath;
-        return ffmpegPath;
+        return await ensureBinaryAvailable('ffmpeg');
     }
     catch {
         throw new Error('ffmpeg is required for clip post-processing but was not found on your system. ' +
-            'Install it via: brew install ffmpeg (macOS) or apt install ffmpeg (Linux).');
+            'Install it via: brew install ffmpeg (macOS), apt install ffmpeg (Linux), or choco install ffmpeg (Windows).');
     }
 }
 // ── Conversion functions ────────────────────────────────────────────
@@ -61,7 +70,8 @@ export async function convertToGif(webmPath, outputPath, opts = {}) {
     finally {
         // Clean up palette file
         try {
-            await stat(palettePath).then(() => execFileAsync('rm', [palettePath]));
+            await stat(palettePath);
+            await rm(palettePath, { force: true });
         }
         catch { /* ignore */ }
     }
@@ -110,8 +120,7 @@ export async function trimRecording(inputPath, outputPath, startSec = DEFAULT_TR
  * Get the duration of a media file in milliseconds.
  */
 export async function getMediaDurationMs(filePath) {
-    const ffmpeg = await ensureFfmpegAvailable();
-    const ffprobe = ffmpeg.replace(/ffmpeg$/, 'ffprobe');
+    const ffprobe = await ensureBinaryAvailable('ffprobe');
     const { stdout } = await execFileAsync(ffprobe, [
         '-v', 'error',
         '-show_entries', 'format=duration',
@@ -178,12 +187,12 @@ export async function postProcessClipRecording(webmPath, outputDir, clipId, opti
     result.thumbnailPath = thumbnailPath;
     // Clean up intermediate files
     try {
-        await execFileAsync('rm', [trimmedPath]);
+        await rm(trimmedPath, { force: true });
     }
     catch { /* ignore */ }
     if (sourcePath !== trimmedPath) {
         try {
-            await execFileAsync('rm', [sourcePath]);
+            await rm(sourcePath, { force: true });
         }
         catch { /* ignore */ }
     }

package/dist/cookie-dismiss.d.ts

@@ -1,4 +1,6 @@
 import type { Page } from 'playwright';
+export declare function getCaptureHideCSS(): string;
+export declare function ensureCaptureHideStyles(page: Page): Promise<void>;
 export declare function dismissCookiesAndWidgets(page: Page): Promise<{
     dismissed: boolean;
     method: string | null;

package/dist/cookie-dismiss.js

@@ -82,6 +82,51 @@ const HIDE_SELECTORS = [
     '[id*="cookieBanner"]', '[id*="cookieConsent"]',
     '[class*="gdpr"]', '[id*="gdpr"]',
 ];
+// Dev-only chrome that should never appear in captures
+const DEV_TOOL_SELECTORS = [
+    // Next.js dev indicator / devtools
+    'nextjs-portal',
+    '#__next-build-watcher',
+    '[data-next-badge-root]',
+    // Astro dev toolbar
+    'astro-dev-toolbar',
+    // Vite overlays
+    'vite-error-overlay',
+    'vite-plugin-checker-error-overlay',
+    // Nuxt devtools
+    'nuxt-devtools',
+    'nuxt-devtools-frame',
+    '#nuxt-devtools-anchor',
+    '#nuxt-devtools-container',
+];
+const CAPTURE_HIDE_STYLE_ID = 'autokap-capture-hide-style';
+export function getCaptureHideCSS() {
+    return [...HIDE_SELECTORS, ...DEV_TOOL_SELECTORS].map(selector => `${selector} { display: none !important; visibility: hidden !important; pointer-events: none !important; }`).join('\n');
+}
+export async function ensureCaptureHideStyles(page) {
+    try {
+        await page.evaluate(({ styleId, css }) => {
+            const parent = document.head ?? document.documentElement;
+            if (!parent)
+                return;
+            let style = document.getElementById(styleId);
+            if (!style) {
+                style = document.createElement('style');
+                style.id = styleId;
+                parent.appendChild(style);
+            }
+            if (style.textContent !== css) {
+                style.textContent = css;
+            }
+        }, {
+            styleId: CAPTURE_HIDE_STYLE_ID,
+            css: getCaptureHideCSS(),
+        });
+    }
+    catch {
+        // Page might have navigated away
+    }
+}
 export async function dismissCookiesAndWidgets(page) {
     // Strategy 1: Click known CMP buttons
     for (const selector of CMP_SELECTORS) {
@@ -91,7 +136,7 @@ export async function dismissCookiesAndWidgets(page) {
                 await button.click({ timeout: 2000 });
                 logger.info(`Cookie dismissed via CMP selector: ${selector}`);
                 await page.waitForTimeout(500);
-                await injectHideCSS(page);
+                await ensureCaptureHideStyles(page);
                 return { dismissed: true, method: `cmp:${selector}` };
             }
         }
@@ -148,7 +193,7 @@ export async function dismissCookiesAndWidgets(page) {
         if (dismissed) {
             logger.info(`Cookie dismissed via text match: "${dismissed}"`);
             await page.waitForTimeout(500);
-            await injectHideCSS(page);
+            await ensureCaptureHideStyles(page);
             return { dismissed: true, method: `text:${dismissed}` };
         }
     }
@@ -156,17 +201,7 @@ export async function dismissCookiesAndWidgets(page) {
         // Text-based search failed
     }
     // Strategy 3: Always inject CSS to hide known overlays and widgets
-    await injectHideCSS(page);
+    await ensureCaptureHideStyles(page);
     return { dismissed: false, method: null };
 }
-async function injectHideCSS(page) {
-    try {
-        await page.addStyleTag({
-            content: HIDE_SELECTORS.map(s => `${s} { display: none !important; visibility: hidden !important; pointer-events: none !important; }`).join('\n'),
-        });
-    }
-    catch {
-        // Page might have navigated away
-    }
-}
 //# sourceMappingURL=cookie-dismiss.js.map

package/dist/cost-logging.d.ts

@@ -21,6 +21,14 @@ export declare function updateCostLogCaptureContext(supabase: SupabaseClient, co
     viewportWidth?: number | null;
     viewportHeight?: number | null;
 }): Promise<void>;
+/**
+ * Retry resolution for previously failed cost logs.
+ * Designed to be called by a reconciliation cron job.
+ */
+export declare function reconcileUnresolvedCosts(supabase: SupabaseClient, apiKey: string): Promise<{
+    retried: number;
+    resolved: number;
+}>;
 export declare function resolveAllCosts(supabase: SupabaseClient, entries: Array<{
     costLogId: string;
     generationId: string | null;

package/dist/cost-logging.js

@@ -1,49 +1,88 @@
+function isFiniteInteger(value) {
+    return typeof value === 'number' && Number.isInteger(value);
+}
+function normalizeUsageForCostLog(step, index) {
+    const normalizedStepNumber = isFiniteInteger(step.stepNumber) && step.stepNumber >= 0
+        ? step.stepNumber
+        : index + 1;
+    const normalizedStepType = typeof step.stepType === 'string' && step.stepType.trim().length > 0
+        ? step.stepType
+        : 'agent_iteration';
+    const normalizedModelRequested = typeof step.modelRequested === 'string' && step.modelRequested.trim().length > 0
+        ? step.modelRequested
+        : step.modelUsed ?? 'unknown';
+    const normalizedImagesInPrompt = typeof step.imagesInPrompt === 'number' && Number.isFinite(step.imagesInPrompt)
+        ? step.imagesInPrompt
+        : 0;
+    if (normalizedStepNumber !== step.stepNumber
+        || normalizedStepType !== step.stepType
+        || normalizedModelRequested !== step.modelRequested
+        || normalizedImagesInPrompt !== step.imagesInPrompt) {
+        console.warn('Normalizing invalid cost log usage entry:', JSON.stringify({
+            stepNumber: step.stepNumber ?? null,
+            stepType: step.stepType ?? null,
+            modelRequested: step.modelRequested ?? null,
+            modelUsed: step.modelUsed ?? null,
+            fallbackStepNumber: normalizedStepNumber,
+        }));
+    }
+    return {
+        ...step,
+        stepNumber: normalizedStepNumber,
+        stepType: normalizedStepType,
+        modelRequested: normalizedModelRequested,
+        imagesInPrompt: normalizedImagesInPrompt,
+    };
+}
 export async function insertCostLogs(supabase, ctx, steps) {
     if (steps.length === 0)
         return [];
-    const rows = steps.map((step) => ({
-        id: crypto.randomUUID(),
-        run_id: ctx.runId,
-        user_id: ctx.userId,
-        project_id: ctx.projectId ?? null,
-        preset_id: ctx.presetId ?? null,
-        capture_id: ctx.captureId ?? null,
-        step_number: step.stepNumber,
-        step_type: step.stepType,
-        model_requested: step.modelRequested,
-        model_used: step.modelUsed,
-        generation_id: step.generationId,
-        prompt_tokens: step.promptTokens,
-        completion_tokens: step.completionTokens,
-        total_tokens: step.totalTokens,
-        cost_resolved: false,
-        images_in_prompt: step.imagesInPrompt,
-        lang: ctx.lang ?? null,
-        theme: ctx.theme ?? null,
-        capture_type: ctx.captureType ?? null,
-        element_name: ctx.elementName ?? null,
-        target_id: ctx.targetId ?? null,
-        viewport_width: ctx.viewportWidth ?? null,
-        viewport_height: ctx.viewportHeight ?? null,
-        system_prompt_chars: step.systemPromptChars ?? null,
-        tool_schema_chars: step.toolSchemaChars ?? null,
-        user_payload_chars: step.userPayloadChars ?? null,
-        accessibility_chars: step.accessibilityChars ?? null,
-        interactive_element_count: step.interactiveElementCount ?? null,
-        action_history_count: step.actionHistoryCount ?? null,
-        elements_chars: step.elementsChars ?? null,
-        session_summary_chars: step.sessionSummaryChars ?? null,
-        selector_memory_chars: step.selectorMemoryChars ?? null,
-        agent_context_chars: step.agentContextChars ?? null,
-        profile_validation_status: step.profileValidationStatus ?? null,
-        session_profile_source: step.sessionProfileSource ?? null,
-        repair_path_used: step.repairPathUsed ?? null,
-        evaluator_used: step.evaluatorUsed ?? false,
-        cache_read_tokens: step.cacheReadTokens ?? null,
-        cache_write_tokens: step.cacheWriteTokens ?? null,
-        session_profile_reused: step.sessionProfileReused ?? false,
-        action_replay_used: step.actionReplayUsed ?? false,
-    }));
+    const rows = steps.map((rawStep, index) => {
+        const step = normalizeUsageForCostLog(rawStep, index);
+        return {
+            id: crypto.randomUUID(),
+            run_id: ctx.runId,
+            user_id: ctx.userId,
+            project_id: ctx.projectId ?? null,
+            preset_id: ctx.presetId ?? null,
+            capture_id: ctx.captureId ?? null,
+            step_number: step.stepNumber,
+            step_type: step.stepType,
+            model_requested: step.modelRequested,
+            model_used: step.modelUsed,
+            generation_id: step.generationId,
+            prompt_tokens: step.promptTokens,
+            completion_tokens: step.completionTokens,
+            total_tokens: step.totalTokens,
+            cost_resolved: false,
+            images_in_prompt: step.imagesInPrompt,
+            lang: ctx.lang ?? null,
+            theme: ctx.theme ?? null,
+            capture_type: ctx.captureType ?? null,
+            element_name: ctx.elementName ?? null,
+            target_id: ctx.targetId ?? null,
+            viewport_width: ctx.viewportWidth ?? null,
+            viewport_height: ctx.viewportHeight ?? null,
+            system_prompt_chars: step.systemPromptChars ?? null,
+            tool_schema_chars: step.toolSchemaChars ?? null,
+            user_payload_chars: step.userPayloadChars ?? null,
+            accessibility_chars: step.accessibilityChars ?? null,
+            interactive_element_count: step.interactiveElementCount ?? null,
+            action_history_count: step.actionHistoryCount ?? null,
+            elements_chars: step.elementsChars ?? null,
+            session_summary_chars: step.sessionSummaryChars ?? null,
+            selector_memory_chars: step.selectorMemoryChars ?? null,
+            agent_context_chars: step.agentContextChars ?? null,
+            profile_validation_status: step.profileValidationStatus ?? null,
+            session_profile_source: step.sessionProfileSource ?? null,
+            repair_path_used: step.repairPathUsed ?? null,
+            evaluator_used: step.evaluatorUsed ?? false,
+            cache_read_tokens: step.cacheReadTokens ?? null,
+            cache_write_tokens: step.cacheWriteTokens ?? null,
+            session_profile_reused: step.sessionProfileReused ?? false,
+            action_replay_used: step.actionReplayUsed ?? false,
+        };
+    });
     try {
         const { error } = await supabase.from('cost_logs').insert(rows);
         if (error) {
@@ -79,9 +118,21 @@ export async function updateCostLogCaptureContext(supabase, costLogIds, params)
     }
 }
 async function resolveCost(updateClient, generationId, costLogId, apiKey) {
-    const delays = [10_000, 20_000, 40_000];
+    const delays = [10_000, 20_000, 40_000, 80_000, 160_000];
     for (let attempt = 0; attempt < delays.length; attempt += 1) {
         await new Promise((resolve) => setTimeout(resolve, delays[attempt]));
+        // Track resolution attempt (best-effort)
+        try {
+            await updateClient
+                .from('cost_logs')
+                .update({
+                resolution_attempts: attempt + 1,
+                last_resolution_attempt_at: new Date().toISOString(),
+                cost_resolution_status: 'pending',
+            })
+                .eq('id', costLogId);
+        }
+        catch { /* best-effort tracking */ }
         try {
             const response = await fetch(`https://openrouter.ai/api/v1/generation?id=${generationId}`, { headers: { Authorization: `Bearer ${apiKey}` } });
             if (response.status === 404 && attempt < delays.length - 1) {
@@ -89,13 +140,19 @@ async function resolveCost(updateClient, generationId, costLogId, apiKey) {
             }
             if (!response.ok) {
                 console.error(`OpenRouter generation lookup failed (${generationId}): HTTP ${response.status}`);
-                return;
+                if (attempt === delays.length - 1) {
+                    await markCostResolutionFailed(updateClient, costLogId, `HTTP ${response.status}`);
+                }
+                continue;
             }
             const generation = await response.json();
             const totalCost = generation.data?.total_cost ?? null;
             if (totalCost == null) {
                 console.warn(`OpenRouter returned no total_cost for generation ${generationId}`);
-                return;
+                if (attempt === delays.length - 1) {
+                    await markCostResolutionFailed(updateClient, costLogId, 'no total_cost in response');
+                }
+                continue;
             }
             const { error } = await updateClient
                 .from('cost_logs')
@@ -103,6 +160,7 @@ async function resolveCost(updateClient, generationId, costLogId, apiKey) {
                 cost_usd: totalCost,
                 cost_resolved: true,
                 resolved_at: new Date().toISOString(),
+                cost_resolution_status: 'resolved',
             })
                 .eq('id', costLogId);
             if (error) {
@@ -113,10 +171,66 @@ async function resolveCost(updateClient, generationId, costLogId, apiKey) {
         catch (error) {
             if (attempt === delays.length - 1) {
                 console.error(`Cost resolution failed for ${generationId}:`, error.message);
+                await markCostResolutionFailed(updateClient, costLogId, error.message);
             }
         }
     }
 }
+async function markCostResolutionFailed(updateClient, costLogId, reason) {
+    try {
+        await updateClient
+            .from('cost_logs')
+            .update({ cost_resolution_status: 'failed' })
+            .eq('id', costLogId);
+        console.error(`Cost resolution marked as failed for ${costLogId}: ${reason}`);
+    }
+    catch {
+        // best-effort — don't fail the caller
+    }
+}
+/**
+ * Retry resolution for previously failed cost logs.
+ * Designed to be called by a reconciliation cron job.
+ */
+export async function reconcileUnresolvedCosts(supabase, apiKey) {
+    const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000).toISOString();
+    const { data: failedLogs, error } = await supabase
+        .from('cost_logs')
+        .select('id, generation_id')
+        .eq('cost_resolution_status', 'failed')
+        .gt('created_at', sevenDaysAgo)
+        .not('generation_id', 'is', null)
+        .limit(100);
+    if (error || !failedLogs?.length) {
+        return { retried: 0, resolved: 0 };
+    }
+    let resolved = 0;
+    for (const log of failedLogs) {
+        try {
+            const response = await fetch(`https://openrouter.ai/api/v1/generation?id=${log.generation_id}`, { headers: { Authorization: `Bearer ${apiKey}` } });
+            if (!response.ok)
+                continue;
+            const generation = await response.json();
+            const totalCost = generation.data?.total_cost ?? null;
+            if (totalCost == null)
+                continue;
+            await supabase
+                .from('cost_logs')
+                .update({
+                cost_usd: totalCost,
+                cost_resolved: true,
+                resolved_at: new Date().toISOString(),
+                cost_resolution_status: 'resolved',
+            })
+                .eq('id', log.id);
+            resolved += 1;
+        }
+        catch {
+            // skip this entry, will be retried next run
+        }
+    }
+    return { retried: failedLogs.length, resolved };
+}
 export function resolveAllCosts(supabase, entries, apiKey, serviceClient) {
     const toResolve = entries.filter((entry) => entry.generationId != null);
     if (toResolve.length === 0) {

package/dist/cost-resolution-monitor.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Cost resolution monitoring — exposes metrics for alerting
+ * when the failure rate of OpenRouter cost lookups exceeds thresholds.
+ */
+import type { SupabaseClient } from '@supabase/supabase-js';
+export interface CostResolutionStats {
+    /** Number of cost logs with status 'failed' in the last hour. */
+    failedLastHour: number;
+    /** Total cost logs created in the last hour. */
+    totalLastHour: number;
+    /** Failure rate as a percentage (0-100). */
+    failureRate: number;
+    /** Number of cost logs still pending (older than 5 minutes). */
+    stalePending: number;
+}
+export declare function getCostResolutionStats(supabase: SupabaseClient): Promise<CostResolutionStats>;

package/dist/cost-resolution-monitor.js

@@ -0,0 +1,34 @@
+/**
+ * Cost resolution monitoring — exposes metrics for alerting
+ * when the failure rate of OpenRouter cost lookups exceeds thresholds.
+ */
+export async function getCostResolutionStats(supabase) {
+    const oneHourAgo = new Date(Date.now() - 60 * 60 * 1000).toISOString();
+    const fiveMinutesAgo = new Date(Date.now() - 5 * 60 * 1000).toISOString();
+    const [failedResult, totalResult, staleResult] = await Promise.all([
+        supabase
+            .from('cost_logs')
+            .select('*', { count: 'exact', head: true })
+            .eq('cost_resolution_status', 'failed')
+            .gt('created_at', oneHourAgo),
+        supabase
+            .from('cost_logs')
+            .select('*', { count: 'exact', head: true })
+            .gt('created_at', oneHourAgo)
+            .not('generation_id', 'is', null),
+        supabase
+            .from('cost_logs')
+            .select('*', { count: 'exact', head: true })
+            .eq('cost_resolution_status', 'pending')
+            .lt('created_at', fiveMinutesAgo)
+            .not('generation_id', 'is', null),
+    ]);
+    const failedLastHour = failedResult.count ?? 0;
+    const totalLastHour = totalResult.count ?? 0;
+    const stalePending = staleResult.count ?? 0;
+    const failureRate = totalLastHour > 0
+        ? Math.round((failedLastHour / totalLastHour) * 10000) / 100
+        : 0;
+    return { failedLastHour, totalLastHour, failureRate, stalePending };
+}
+//# sourceMappingURL=cost-resolution-monitor.js.map

package/dist/credential-templates.js

@@ -47,9 +47,9 @@ export function resolveActionCredentialArgs(action, args, credentials) {
     if (!credentials)
         return args;
     const resolved = { ...args };
-    if (action === "type_text" && typeof resolved.text === "string") {
+    if ((action === "type_text" || action === "type") && typeof resolved.text === "string") {
         resolved.text = resolveCredentialTemplates(resolved.text, credentials);
-        ensureNoCredentialTemplate("type_text.text", resolved.text);
+        ensureNoCredentialTemplate(`${action}.text`, resolved.text);
     }
     if (action === "navigate_to" && typeof resolved.url === "string") {
         resolved.url = resolveCredentialTemplates(resolved.url, credentials);

package/dist/cursor-overlay-script.d.ts

@@ -0,0 +1,6 @@
+import type { VideoCursorTheme } from './types.js';
+/**
+ * JavaScript injected via `context.addInitScript()` to show a visible animated
+ * cursor in Playwright video recordings (the native OS cursor is invisible).
+ */
+export declare function buildCursorOverlayScript(theme?: VideoCursorTheme): string;