autokap 1.1.0 → 1.1.3

package/dist/cli-runner-local.js

@@ -24,7 +24,9 @@ export async function runLocal(presetId, opts) {
     }
     const run = await runCapture({
         presetId,
+        env: opts.env,
         program,
+        allowUploadFailure: opts.allowUploadFailure,
         headed: opts.headed,
         onProgress: (event) => {
             const prefix = `[capture][${event.variantId}]`;
@@ -73,27 +75,16 @@ async function persistArtifactsLocally(presetId, outputDirOption, variants) {
     for (const variant of variants) {
         for (let index = 0; index < variant.artifacts.length; index += 1) {
             const artifact = variant.artifacts[index];
-            const ext = artifact.mediaMode === 'dom'
-                ? 'html'
-                : artifact.mimeType === 'image/png'
-                    ? 'png'
-                    : artifact.mimeType === 'image/jpeg'
-                        ? 'jpg'
-                        : artifact.mimeType.includes('gif')
-                            ? 'gif'
-                            : artifact.mimeType.includes('mp4')
-                                ? 'mp4'
-                                : 'webm';
-            let suffix = '';
-            if (artifact.mediaMode === 'dom') {
-                if (artifact.fragmentName && artifact.parentStateName) {
-                    suffix = `-${sanitizePathToken(artifact.parentStateName)}-fragment-${sanitizePathToken(artifact.fragmentName)}`;
-                }
-                else if (artifact.stateName) {
-                    suffix = `-${sanitizePathToken(artifact.stateName)}`;
-                }
-            }
-            const fileName = `capture-${sanitizePathToken(presetId.slice(0, 8))}-${sanitizePathToken(variant.variantId)}${suffix}-${index}.${ext}`;
+            const ext = artifact.mimeType === 'image/png'
+                ? 'png'
+                : artifact.mimeType === 'image/jpeg'
+                    ? 'jpg'
+                    : artifact.mimeType.includes('gif')
+                        ? 'gif'
+                        : artifact.mimeType.includes('mp4')
+                            ? 'mp4'
+                            : 'webm';
+            const fileName = `capture-${sanitizePathToken(presetId.slice(0, 8))}-${sanitizePathToken(variant.variantId)}-${index}.${ext}`;
             const filePath = resolveContainedPath(outputDir, fileName);
             await fs.writeFile(filePath, artifact.buffer);
             logger.info(`[capture] Artifact saved locally: ${filePath}`);

package/dist/cli-runner.d.ts

@@ -15,8 +15,12 @@ import type { ExecutionProgram, RunResult } from './execution-types.js';
 export interface CLIRunnerOptions {
     /** Preset ID to run */
     presetId: string;
+    /** Project environment name used by the server to resolve capture URLs */
+    env?: string;
     /** Override: provide program directly instead of fetching from server */
     program?: ExecutionProgram;
+    /** Keep the legacy success result when upload/telemetry persistence fails */
+    allowUploadFailure?: boolean;
     /** Selector memory map (fetched from server or cached locally) */
     selectorMemory?: Record<string, string[]>;
     /** Show browser window. Default: false (headless) */

package/dist/cli-runner.js

@@ -26,6 +26,7 @@ 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 HEALER_SYSTEM_PROMPT = 'You repair failed deterministic browser opcodes. Respond only with JSON.';
 // ── Main entry point ────────────────────────────────────────────────
 export async function runCapture(options) {
@@ -46,7 +47,7 @@ export async function runCapture(options) {
         };
     }
     else {
-        const fetched = await fetchProgram(config, options.presetId);
+        const fetched = await fetchProgram(config, options.presetId, options.env);
         if (!fetched.success) {
             return { success: false, error: fetched.error };
         }
@@ -109,18 +110,26 @@ export async function runCapture(options) {
         logger.info(`[capture] Concurrency cap resolved to ${program.maxParallelCaptures} parallel variant(s)`);
     }
     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 browserOptions = {
             headed: options.headed ?? false,
             viewport: variant.viewport,
-            deviceScaleFactor: variant.deviceScaleFactor ?? program.outputScale,
+            deviceScaleFactor: runtimeDeviceScaleFactor,
             lang: variant.locale,
             colorScheme: variant.theme,
             storageState: program.preconditions.storageState,
         };
-        const recordable = program.mediaMode === 'clip';
         let recordingDir;
         let browser;
         logger.info(`[capture] Launching browser${browserOptions.headed ? ' (headed)' : ''}…`);
+        if (recordable && runtimeDeviceScaleFactor !== requestedDeviceScaleFactor) {
+            logger.info(`[capture] Clip capture scale capped at ${runtimeDeviceScaleFactor} ` +
+                `(requested ${requestedDeviceScaleFactor}) to preserve recording FPS`);
+        }
         if (recordable) {
             recordingDir = await fs.mkdtemp(path.join(os.tmpdir(), `autokap-${program.mediaMode}-`));
             browser = await Browser.forClipCapture(browserOptions, buildCursorOverlayScript(program.artifactPlan.cursorTheme ?? 'minimal'));
@@ -151,15 +160,29 @@ export async function runCapture(options) {
         logger.info(`[capture] Captures saved successfully — total ${totalDurationSec}s`);
     }
     catch (err) {
-        logger.error(`[capture] Failed to upload results: ${err instanceof Error ? err.message : String(err)}`);
+        const message = err instanceof Error ? err.message : String(err);
+        logger.error(`[capture] Failed to upload results: ${message}`);
+        if (!options.allowUploadFailure) {
+            return {
+                success: false,
+                runResult,
+                error: runResult.success
+                    ? `upload failed: ${message}`
+                    : `${runResult.error ?? 'capture failed'}; upload failed: ${message}`,
+            };
+        }
+        logger.warn('[capture] Continuing after upload failure because --allow-upload-failure was set');
     }
     return { success: runResult.success, runResult };
 }
 // ── Server communication ────────────────────────────────────────────
-async function fetchProgram(config, presetId) {
+async function fetchProgram(config, presetId, environmentName) {
     try {
-        const url = `${config.apiBaseUrl}/api/cli/programs/${presetId}`;
-        const response = await fetch(url, {
+        const url = new URL(`${config.apiBaseUrl}/api/cli/programs/${presetId}`);
+        if (environmentName) {
+            url.searchParams.set('env', environmentName);
+        }
+        const response = await fetch(url.toString(), {
             headers: {
                 'Authorization': `Bearer ${config.apiKey}`,
                 'Content-Type': 'application/json',
@@ -167,7 +190,7 @@ async function fetchProgram(config, presetId) {
             },
         });
         if (!response.ok) {
-            return { success: false, error: await formatServerError(response, url) };
+            return { success: false, error: await formatServerError(response, url.toString()) };
         }
         const data = await response.json();
         const envelope = verifySignedExecutionProgramEnvelope({
@@ -195,7 +218,7 @@ async function uploadResults(config, program, result) {
             const formData = new FormData();
             const filename = buildArtifactFilename(program.presetId, variant.variantId, artifact);
             uploadedCount += 1;
-            const label = artifact.captureName ?? artifact.clipName ?? artifact.fragmentName ?? artifact.stateName ?? filename;
+            const label = artifact.captureName ?? artifact.clipName ?? filename;
             logger.info(`[capture] Exporting capture ${uploadedCount}/${totalArtifacts}: ${label}`);
             formData.append('file', new Blob([new Uint8Array(artifact.buffer)], { type: artifact.mimeType }), filename);
             formData.append('presetId', program.presetId);
@@ -214,7 +237,10 @@ async function uploadResults(config, program, result) {
             if (variantSpec?.deviceFrame) {
                 formData.append('deviceFrame', variantSpec.deviceFrame);
             }
-            const deviceScaleFactor = variantSpec?.deviceScaleFactor ?? program.outputScale;
+            const requestedDeviceScaleFactor = variantSpec?.deviceScaleFactor ?? program.outputScale ?? 2;
+            const deviceScaleFactor = artifact.mediaMode === 'clip' && Number.isFinite(requestedDeviceScaleFactor)
+                ? Math.min(Number(requestedDeviceScaleFactor), MAX_CLIP_CAPTURE_DEVICE_SCALE_FACTOR)
+                : requestedDeviceScaleFactor;
             if (Number.isFinite(deviceScaleFactor)) {
                 formData.append('deviceScaleFactor', String(deviceScaleFactor));
             }
@@ -253,35 +279,6 @@ async function uploadResults(config, program, result) {
             if (typeof artifact.trimStartMs === 'number') {
                 formData.append('trimStartMs', String(artifact.trimStartMs));
             }
-            // ── Interactive demo (mediaMode === 'dom') ──
-            if (artifact.stateName) {
-                formData.append('stateName', artifact.stateName);
-            }
-            if (artifact.domAssetUrls && artifact.domAssetUrls.length > 0) {
-                formData.append('domAssetUrls', JSON.stringify(artifact.domAssetUrls));
-            }
-            if (artifact.domThumbnailBuffer) {
-                formData.append('domThumbnail', new Blob([new Uint8Array(artifact.domThumbnailBuffer)], { type: 'image/png' }), 'thumbnail.png');
-            }
-            // Phase 5: fragment fields
-            if (artifact.fragmentName) {
-                formData.append('fragmentName', artifact.fragmentName);
-            }
-            // Phase 8: variant of the fragment capture (defaults to 'default'
-            // server-side when omitted, but we always send it explicitly so the
-            // upload row's unique key includes it).
-            if (artifact.fragmentVariantName) {
-                formData.append('fragmentVariantName', artifact.fragmentVariantName);
-            }
-            if (artifact.parentStateName) {
-                formData.append('parentStateName', artifact.parentStateName);
-            }
-            if (artifact.mountStrategy) {
-                formData.append('mountStrategy', artifact.mountStrategy);
-            }
-            if (artifact.mountTargetSelector) {
-                formData.append('mountTargetSelector', artifact.mountTargetSelector);
-            }
             const response = await fetch(`${config.apiBaseUrl}/api/cli/artifacts`, {
                 method: 'POST',
                 headers: { 'Authorization': `Bearer ${config.apiKey}` },
@@ -438,17 +435,15 @@ function createHealerLLMProvider(llmConfig) {
     };
 }
 function buildArtifactFilename(presetId, variantId, artifact) {
-    const ext = artifact.mediaMode === 'dom'
-        ? 'html'
-        : artifact.mimeType === 'image/jpeg'
-            ? 'jpg'
-            : artifact.mimeType === 'image/png'
-                ? 'png'
-                : artifact.mimeType.includes('gif')
-                    ? 'gif'
-                    : artifact.mimeType.includes('mp4')
-                        ? 'mp4'
-                        : 'webm';
+    const ext = artifact.mimeType === 'image/jpeg'
+        ? 'jpg'
+        : artifact.mimeType === 'image/png'
+            ? 'png'
+            : artifact.mimeType.includes('gif')
+                ? 'gif'
+                : artifact.mimeType.includes('mp4')
+                    ? 'mp4'
+                    : 'webm';
     const stepToken = typeof artifact.stepIndex === 'number' ? `-${artifact.stepIndex}` : '';
     return `${sanitizeArtifactToken(presetId)}-${sanitizeArtifactToken(variantId)}${stepToken}.${ext}`;
 }
@@ -497,9 +492,6 @@ function sanitizeArtifactForTelemetry(artifact) {
         altText: redactTelemetryText(artifact.altText),
         captureUrl: redactUrl(artifact.captureUrl),
         elementSelector: undefined,
-        domAssetUrls: artifact.domAssetUrls
-            ?.map((entry) => redactUrl(entry))
-            .filter((entry) => Boolean(entry)),
     };
 }
 function sanitizeHealerPatches(patches) {

package/dist/cli.js

@@ -6,7 +6,7 @@ import fs from 'node:fs/promises';
 const require = createRequire(import.meta.url);
 const { version } = require('../package.json');
 import { logger } from './logger.js';
-import { writeConfig, deleteConfig, requireConfig, getConfigPath, DEFAULT_API_BASE_URL, getDefaultApiBaseUrl, getDefaultWsUrl, LOCAL_API_BASE_URL, LOCAL_WS_URL, API_BASE_URL_ENV_VAR, WS_URL_ENV_VAR, } from './cli-config.js';
+import { writeConfig, deleteConfig, requireConfig, getConfigPath, DEFAULT_API_BASE_URL, getDefaultApiBaseUrl, getDefaultWsUrl, LOCAL_API_BASE_URL, LOCAL_WS_URL, API_KEY_ENV_VAR, API_BASE_URL_ENV_VAR, WS_URL_ENV_VAR, } from './cli-config.js';
 import { renderSkillSingleFile, writeSkillExport } from './skill-packaging.js';
 // ── Program definition ──────────────────────────────────────────────
 export const program = new Command();
@@ -14,6 +14,12 @@ program
     .name('autokap')
     .version(version)
     .description('AI-powered screenshot capture — local Playwright proxy');
+function getProjectPrimaryUrl(project) {
+    return (project.environments.local ??
+        project.environments.staging ??
+        project.environments.prod ??
+        null);
+}
 function fatal(message) {
     logger.error(message);
     process.exit(1);
@@ -205,6 +211,8 @@ program
     .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('--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')
     .option('--program <file>', 'Path to a program JSON file')
     .option('--debug', 'Verbose logging: per-substep timing, opcode dumps, recovery strategy traces', false)
@@ -222,6 +230,59 @@ program
     const { runLocal } = await import('./cli-runner-local.js');
     await runLocal(presetId, opts);
 });
+// ── auto-recapture command ─────────────────────────────────────────
+program
+    .command('auto-recapture')
+    .description('Run every preset enabled for CI auto-recapture in a project')
+    .requiredOption('--project <id>', 'Project ID')
+    .option('--env <name>', "Project environment to capture against. Falls back to the project's default environment when omitted.")
+    .option('--headed', 'Show browser window for debugging', false)
+    .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)
+    .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.local) {
+        process.env[API_BASE_URL_ENV_VAR] = LOCAL_API_BASE_URL;
+        process.env[WS_URL_ENV_VAR] = LOCAL_WS_URL;
+        logger.info(`Using local AutoKap dev server: ${LOCAL_API_BASE_URL}`);
+    }
+    const config = await requireConfig();
+    const data = await requestJson(config, `/api/cli/projects/${opts.project}/auto-recapture-presets`, { headers: authHeaders(config) }, 'Failed to list auto-recapture presets');
+    if (data.presets.length === 0) {
+        logger.info(`[auto-recapture] No presets enabled for project ${opts.project}`);
+        process.exit(0);
+    }
+    const { runCapture } = await import('./cli-runner.js');
+    const failures = [];
+    for (const preset of data.presets) {
+        const label = preset.name ? `${preset.name} (${preset.id})` : preset.id;
+        logger.info(`[auto-recapture] Running ${label}`);
+        const result = await runCapture({
+            presetId: preset.id,
+            env: opts.env,
+            headed: opts.headed,
+            allowUploadFailure: opts.allowUploadFailure,
+        });
+        if (!result.success) {
+            const error = result.error ?? result.runResult?.error ?? 'capture failed';
+            failures.push({ id: preset.id, name: preset.name, error });
+            logger.error(`[auto-recapture] Failed ${label}: ${error}`);
+        }
+    }
+    if (failures.length > 0) {
+        logger.error(`[auto-recapture] ${failures.length}/${data.presets.length} preset(s) failed: ${failures
+            .map((failure) => failure.name ?? failure.id)
+            .join(', ')}`);
+        process.exit(1);
+    }
+    logger.success(`[auto-recapture] ${data.presets.length} preset(s) recaptured successfully`);
+    process.exit(0);
+});
 // ── project commands ───────────────────────────────────────────────
 const projectCmd = program
     .command('project')
@@ -248,16 +309,23 @@ projectCmd
     .command('create')
     .description('Create a project')
     .requiredOption('--name <name>', 'Project name')
-    .requiredOption('--url <url>', 'Project URL')
+    .requiredOption('--base-url <url>', 'Base URL of the chosen environment')
+    .option('--environment <name>', "Environment slot to seed: 'local' or 'prod'", 'local')
     .option('--description <text>', 'Project description')
     .action(async (opts) => {
     const config = await requireConfig();
+    const env = opts.environment.toLowerCase();
+    if (env !== 'local' && env !== 'prod') {
+        logger.error("--environment must be 'local' or 'prod'");
+        process.exit(1);
+    }
     const data = await requestJson(config, '/api/v1/projects', {
         method: 'POST',
         headers: authHeaders(config, { 'Content-Type': 'application/json' }),
         body: JSON.stringify({
             name: opts.name,
-            url: opts.url,
+            environment: env,
+            base_url: opts.baseUrl,
             description: opts.description,
         }),
     }, 'Failed to create project');
@@ -492,19 +560,9 @@ presetCmd
     // Build per-endpoint info with type-specific URL params
     const endpointEntries = endpoints.map((ep) => {
         const assetType = ep.asset_type ?? 'screenshot';
-        const url = assetType === 'interactive_demo'
-            ? `${cfg.apiBaseUrl}/demo/${presetId}`
-            : `${cfg.apiBaseUrl}/api/v1/assets/${ep.id}`;
+        const url = `${cfg.apiBaseUrl}/api/v1/assets/${ep.id}`;
         let urlParams;
-        if (assetType === 'interactive_demo') {
-            urlParams = {
-                embed: 'Set to "1" for iframe embedding',
-                lang: 'Language variant',
-                theme: 'Color theme ("light" or "dark")',
-                target: 'Device target ID',
-            };
-        }
-        else if (assetType === 'screenshot') {
+        if (assetType === 'screenshot') {
             urlParams = {
                 lang: 'Language variant',
                 theme: 'Color theme ("light" or "dark")',
@@ -513,8 +571,6 @@ presetCmd
                 quality: 'Image quality 1-100',
                 format: 'Output format: "webp", "png", "jpg"',
                 scale: 'Resolution multiplier (0.5-4)',
-                render: 'Set to "studio" for Studio render',
-                slot: 'Studio composition slot',
             };
         }
         else if (assetType === 'clip') {
@@ -523,14 +579,6 @@ presetCmd
                 theme: 'Color theme ("light" or "dark")',
                 target: 'Device target ID',
                 format: 'Output format: "gif" (default), "mp4"',
-                render: 'Set to "studio" for Studio render',
-                slot: 'Studio composition slot',
-            };
-        }
-        else if (assetType === 'composition') {
-            urlParams = {
-                scale: 'Resolution multiplier (0.5-4)',
-                format: 'Output format: "png", "webp", "jpg"',
             };
         }
         else {
@@ -555,12 +603,6 @@ presetCmd
         variants: { langs, themes, targets },
         endpoints: endpointEntries,
     };
-    if (captureMode === 'interactive_demo') {
-        info.interactive_demo = {
-            url: `${cfg.apiBaseUrl}/demo/${presetId}`,
-            embed_url: `${cfg.apiBaseUrl}/demo/${presetId}?embed=1`,
-        };
-    }
     console.log(JSON.stringify(info, null, 2));
     process.exit(0);
 });
@@ -617,7 +659,15 @@ authCmd
         }
         process.exit(0);
     }
-    const startUrl = opts.url || (await loadProject(cfg, projectId)).url;
+    let startUrl = opts.url;
+    if (!startUrl) {
+        const project = await loadProject(cfg, projectId);
+        startUrl = getProjectPrimaryUrl(project) ?? undefined;
+    }
+    if (!startUrl) {
+        logger.error(`No environment URL configured for project ${projectId}. Configure local/staging/prod in the AutoKap web UI, or pass --url.`);
+        process.exit(1);
+    }
     logger.info(`Opening ${startUrl}`);
     const { captureAuthSession } = await import('./auth-capture.js');
     await captureAuthSession({
@@ -840,25 +890,16 @@ const AGENT_PATHS = {
     windsurf: '.windsurf/rules/autokap-preset.md',
     copilot: '.github/instructions/autokap-preset.instructions.md',
 };
-const STUDIO_AGENT_PATHS = {
-    claude: '.claude/commands/autokap-studio.md',
-    codex: '.agents/skills/autokap-studio/SKILL.md',
-    cursor: '.cursor/rules/autokap-studio.md',
-    windsurf: '.windsurf/rules/autokap-studio.md',
-    copilot: '.github/instructions/autokap-studio.instructions.md',
-};
 program
     .command('skill')
     .description('Output or install an AutoKap skill for AI coding agents')
     .option('--output <path>', 'Write the generated skill output to this path instead of stdout')
     .option('--agent <name>', 'Target AI coding agent: claude, codex, cursor, windsurf, copilot (auto-resolves output path and packaging mode)')
-    .option('--type <type>', 'Skill type: preset (default) or studio (composition designer)')
     .option('--project-url <url>', 'Replace the project URL placeholder in the skill')
     .option('--project-id <id>', 'Replace the project ID placeholder in the skill')
     .option('--api-base-url <url>', 'Replace the API base URL placeholder (default: https://autokap.app)')
     .action(async (opts) => {
-    const skillType = opts.type === 'studio' ? 'studio' : undefined;
-    const pathMap = skillType === 'studio' ? STUDIO_AGENT_PATHS : AGENT_PATHS;
+    const pathMap = AGENT_PATHS;
     // Resolve --agent to an output path
     if (opts.agent) {
         const agentKey = opts.agent.toLowerCase();
@@ -875,7 +916,7 @@ program
     try {
         if (opts.output) {
             const result = await writeSkillExport({
-                type: skillType === 'studio' ? 'studio' : 'preset',
+                type: 'preset',
                 agent: opts.agent?.toLowerCase(),
                 outputPath: opts.output,
                 placeholders: opts,
@@ -889,7 +930,7 @@ program
         }
         else {
             const content = await renderSkillSingleFile({
-                type: skillType === 'studio' ? 'studio' : 'preset',
+                type: 'preset',
                 agent: opts.agent?.toLowerCase(),
                 placeholders: opts,
             });
@@ -916,6 +957,10 @@ program
     // If --cli-key not provided, prompt interactively
     let cliKey = opts.cliKey;
     if (!cliKey) {
+        if (process.stdin.isTTY === false) {
+            logger.error(`CLI key is required in non-interactive shells. Pass --cli-key <key> or set ${API_KEY_ENV_VAR} for CI runs.`);
+            process.exit(1);
+        }
         const readline = await import('node:readline');
         const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
         cliKey = await new Promise((resolve) => {