autokap 1.5.7 → 1.6.1

package/dist/cli-runner.js

@@ -686,6 +686,7 @@ async function uploadResults(config, program, result, runId = randomUUID()) {
             healerPatches: sanitizedHealerPatches,
             runResult: strippedRunResult,
             totalDurationMs: result.totalDurationMs,
+            detectedAppVersion: result.detectedAppVersion ?? undefined,
             variantSummaries: result.variantResults.map(v => ({
                 variantId: v.variantId,
                 success: v.success,

package/dist/cli.js

@@ -240,12 +240,54 @@ program
     }
     process.exit(0);
 });
+async function runOutdatedPresetsLocally(opts) {
+    if (opts.output) {
+        fatal('`--output` is not supported with `--outdated`; run an individual preset when local copies are needed.');
+    }
+    const config = await requireConfig();
+    const search = new URLSearchParams({ freshness: 'outdated' });
+    const data = await requestJson(config, `/api/cli/projects/${opts.project}/auto-recapture-presets`, { headers: authHeaders(config) }, 'Failed to list outdated presets', search);
+    if (data.presets.length === 0) {
+        logger.info(`[capture] No outdated presets found for project ${opts.project}`);
+        process.exit(0);
+    }
+    const { runCapture } = await import('./cli-runner.js');
+    const failures = [];
+    logger.info(`[capture] Running ${data.presets.length} outdated preset(s)`);
+    for (const preset of data.presets) {
+        const label = preset.name ? `${preset.name} (${preset.id})` : preset.id;
+        logger.info(`[capture] Running outdated preset ${label}`);
+        const result = await runCapture({
+            presetId: preset.id,
+            env: opts.env,
+            headed: opts.headed,
+            allowUploadFailure: opts.allowUploadFailure,
+            dryRun: opts.dry,
+            regenerateTts: opts.regenerateTts,
+        });
+        if (!result.success) {
+            failures.push({
+                id: preset.id,
+                name: preset.name,
+                error: result.error ?? result.runResult?.error ?? 'capture failed',
+            });
+        }
+    }
+    if (failures.length > 0) {
+        logger.error(`[capture] ${failures.length}/${data.presets.length} outdated preset(s) failed: ${failures.map((failure) => failure.name ?? failure.id).join(', ')}`);
+        process.exit(1);
+    }
+    logger.success(`[capture] ${data.presets.length} outdated preset(s) captured successfully`);
+    process.exit(0);
+}
 // ── run command (deterministic capture engine) ───────────────────────
 program
-    .command('run <preset-id>')
+    .command('run [preset-id]')
     .description('Run a capture using the deterministic opcode engine (local Playwright)')
     .option('--headed', 'Show browser window for debugging', false)
     .option('--local', `Use the local AutoKap dev server (${LOCAL_API_BASE_URL})`, false)
+    .option('--project <id>', 'Project ID. Required with --outdated.')
+    .option('--outdated', 'Run all outdated presets in the project', false)
     .option('--env <name>', "Project environment to capture against. Falls back to the project's default environment when omitted.")
     .option('--allow-upload-failure', 'Keep a successful capture exit code even if artifact upload fails', false)
     .option('--output <dir>', 'Optional output directory for local artifact copies')
@@ -264,6 +306,19 @@ program
         process.env[WS_URL_ENV_VAR] = LOCAL_WS_URL;
         logger.info(`Using local AutoKap dev server: ${LOCAL_API_BASE_URL}`);
     }
+    if (opts.outdated) {
+        if (!opts.project) {
+            fatal('Missing --project <id> for `autokap run --outdated`.');
+        }
+        if (opts.program) {
+            fatal('`--program` cannot be combined with `--outdated`.');
+        }
+        await runOutdatedPresetsLocally(opts);
+        return;
+    }
+    if (!presetId) {
+        fatal('Missing preset ID. Use `autokap run <preset-id>` or `autokap run --outdated --project <project-id>`.');
+    }
     const { runLocal } = await import('./cli-runner-local.js');
     await runLocal(presetId, opts);
 });
@@ -279,6 +334,7 @@ program
     .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)
     .option('--preset-ids <ids>', 'Comma-separated preset IDs to capture. When omitted, captures all presets with auto_recapture_enabled=true.')
+    .option('--outdated', 'Capture only outdated auto-recapture presets.', false)
     .action(async (opts) => {
     if (opts.debug) {
         const { setDebugEnabled } = await import('./logger.js');
@@ -393,9 +449,10 @@ program
     // When `--preset-ids` is provided, restrict the run to that subset
     // (per-preset recapture launched from the dashboard).
     const presetIdsArg = opts.presetIds?.trim();
+    const freshnessSuffix = opts.outdated ? '?freshness=outdated' : '';
     const presetsPath = presetIdsArg
         ? `/api/cli/projects/${opts.project}/auto-recapture-presets?preset_ids=${encodeURIComponent(presetIdsArg)}`
-        : `/api/cli/projects/${opts.project}/auto-recapture-presets`;
+        : `/api/cli/projects/${opts.project}/auto-recapture-presets${freshnessSuffix}`;
     let data;
     try {
         const response = await fetch(buildApiUrl(config, presetsPath), {

package/dist/execution-types.d.ts

@@ -605,6 +605,13 @@ export interface VariantResult {
     durationMs: number;
     /** Artifact buffers produced */
     artifacts: ArtifactResult[];
+    /**
+     * App version detected on the captured page (meta tag, window global, or
+     * data attribute). Sent to the server with telemetry so freshness tracking
+     * picks up the version live during the capture instead of waiting for the
+     * hourly cron.
+     */
+    detectedAppVersion?: string | null;
     error?: string;
 }
 export interface ArtifactResult {
@@ -725,6 +732,12 @@ export interface RunResult {
      * array for `screenshot` and `clip` modes.
      */
     opcodeTimings: OpcodeTiming[];
+    /**
+     * First non-null `detectedAppVersion` from the variants. Used by the server
+     * telemetry route to bypass the cron-detected version and stamp the preset
+     * with the version actually captured on the page.
+     */
+    detectedAppVersion?: string | null;
     error?: string;
 }
 export interface WaitCondition {
@@ -842,6 +855,12 @@ export interface RuntimeAdapter {
         buffer: Buffer;
         mimeType: string;
     } | null>;
+    /**
+     * Read the captured app's version from the live page (meta tag, window
+     * global, or data attribute). Mirrors `extractAppVersionFromHtml` server-side
+     * and `__AUTOKAP_VERSION__` lookup. Returns null if no marker is present.
+     */
+    detectAppVersion?(): Promise<string | null>;
     close(): Promise<void>;
     /** Click an element by semantic target. Falls back to selector if target not found. */
     clickByTarget?(opts: ClickByTargetOptions): Promise<void>;

package/dist/opcode-runner.js

@@ -147,6 +147,7 @@ export async function executeProgram(program, createAdapter, options = {}) {
     const completedVariantResults = variantResults.filter((result) => Boolean(result));
     const aborted = options.abortSignal?.aborted && completedVariantResults.length < program.variants.length;
     const success = !aborted && completedVariantResults.length > 0 && completedVariantResults.every(v => v.success);
+    const detectedAppVersion = completedVariantResults.reduce((acc, variantResult) => acc ?? (variantResult.detectedAppVersion ?? null), null);
     return {
         programId: program.presetId,
         success,
@@ -155,6 +156,7 @@ export async function executeProgram(program, createAdapter, options = {}) {
         healerPatches: success ? healerPatches : [], // Only propagate patches on success
         opcodeTimings,
         totalDurationMs: Date.now() - startTime,
+        detectedAppVersion,
         error: aborted ? 'aborted' : (success ? undefined : completedVariantResults.find(v => !v.success)?.error),
     };
 }
@@ -234,12 +236,25 @@ async function executeVariant(program, variant, createAdapter, recoveryChain, te
                 };
             }
         }
+        // Best-effort: read the app version from the live page so the server can
+        // stamp the preset with what we actually captured (instead of falling back
+        // to whatever the hourly cron last detected).
+        let detectedAppVersion = null;
+        if (adapter.detectAppVersion) {
+            try {
+                detectedAppVersion = await adapter.detectAppVersion();
+            }
+            catch {
+                detectedAppVersion = null;
+            }
+        }
         return {
             variantId: variant.id,
             success: true,
             opcodeResults,
             durationMs: Date.now() - startTime,
             artifacts,
+            detectedAppVersion,
         };
     }
     catch (err) {

package/dist/server-credit-usage.d.ts

@@ -1,5 +1,5 @@
 import type { SupabaseClient } from '@supabase/supabase-js';
-export type CreditUsageType = 'screenshot' | 'clip' | 'video' | 'preset_analysis' | 'cloud_recapture' | 'ai_chat' | 'studio_creation' | 'studio_iteration';
+export type CreditUsageType = 'screenshot' | 'clip' | 'video' | 'cloud_recapture' | 'ai_chat' | 'studio_creation' | 'studio_iteration';
 export declare function recordCreditUsage(supabase: SupabaseClient, params: {
     userId: string;
     projectId: string | null;

package/dist/web-playwright-local.d.ts

@@ -27,6 +27,7 @@ export declare class WebPlaywrightLocal implements RuntimeAdapter {
     constructor(browser: Browser, recordingDir?: string | undefined);
     navigate(url: string): Promise<void>;
     getCurrentUrl(): Promise<string>;
+    detectAppVersion(): Promise<string | null>;
     getAKTree(): Promise<AKTree>;
     getPageSignals(): Promise<VideoPageSignals>;
     click(selector: string, options?: ClickOptions): Promise<void>;

package/package.json

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