autokap 1.0.7 → 1.0.8

package/dist/cli-runner.js

@@ -0,0 +1,433 @@
+/**
+ * Capture Agent — CLI Runner
+ *
+ * Entry point for deterministic execution from the CLI.
+ * Flow:
+ * 1. Authenticate via stored CLI key
+ * 2. Fetch compiled program from server
+ * 3. Validate program against Zod schema
+ * 4. Launch local Playwright browser per variant
+ * 5. Execute program via opcode-runner
+ * 6. Upload artifacts + telemetry to server
+ */
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { Browser } from './browser.js';
+import { API_BASE_URL_ENV_VAR, requireConfig } from './cli-config.js';
+import { WebPlaywrightLocal } from './web-playwright-local.js';
+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 { logger } from './logger.js';
+import { callLLM } from './llm-provider.js';
+const HEALER_SYSTEM_PROMPT = 'You repair failed deterministic browser opcodes. Respond only with JSON.';
+// ── Main entry point ────────────────────────────────────────────────
+export async function runCapture(options) {
+    const config = await requireConfig();
+    // Step 1: Get the compiled program
+    let program;
+    if (options.program) {
+        program = options.program;
+    }
+    else {
+        const fetched = await fetchProgram(config, options.presetId);
+        if (!fetched.success) {
+            return { success: false, error: fetched.error };
+        }
+        program = fetched.program;
+    }
+    // Step 2: Validate the program
+    try {
+        program = parseProgram(program);
+    }
+    catch (err) {
+        return { success: false, error: `program validation failed: ${err instanceof Error ? err.message : String(err)}` };
+    }
+    // Persist against the canonical preset identifier selected by the CLI,
+    // even if the compiled program carries a human-readable preset slug/name.
+    if (program.presetId !== options.presetId) {
+        program = {
+            ...program,
+            presetId: options.presetId,
+        };
+    }
+    logger.info(`[capture] Running preset "${options.presetId}" — ${program.steps.length} opcodes, ${program.variants.length} variant(s)`);
+    const llmConfig = resolveCliLLMConfig();
+    // Step 3: Set up recovery chain
+    const recoveryChain = new RecoveryChainImpl({
+        selectorMemory: options.selectorMemory,
+        programSteps: program.steps,
+        llmProvider: llmConfig ? createHealerLLMProvider(llmConfig) : undefined,
+        credentials: program.preconditions.credentials,
+    });
+    // Step 4: Execute the program
+    const runOptions = {
+        recoveryChain,
+        abortSignal: options.abortSignal,
+        maxParallelVariants: program.maxParallelCaptures,
+        llmConfig,
+        presetName: program.presetId,
+        onProgress: (event) => {
+            if (!options.onProgress) {
+                logProgress(event);
+            }
+            options.onProgress?.(event);
+        },
+    };
+    const captureStart = Date.now();
+    if (program.maxParallelCaptures) {
+        logger.info(`[capture] Concurrency cap resolved to ${program.maxParallelCaptures} parallel variant(s)`);
+    }
+    const createAdapter = async (variant) => {
+        const browserOptions = {
+            headed: options.headed ?? false,
+            viewport: variant.viewport,
+            deviceScaleFactor: variant.deviceScaleFactor ?? program.outputScale,
+            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) {
+            recordingDir = await fs.mkdtemp(path.join(os.tmpdir(), `autokap-${program.mediaMode}-`));
+            browser = await Browser.forVideoRecording(browserOptions, recordingDir, buildCursorOverlayScript(program.artifactPlan.cursorTheme ?? 'minimal'));
+        }
+        else if (browserOptions.headed) {
+            // Headed mode: standalone browser (pool is always headless)
+            browser = new Browser(browserOptions);
+            await browser.launch();
+        }
+        else {
+            browser = await Browser.fromPool(browserOptions);
+            await browser.launch();
+        }
+        await applyPreconditions(browser, program);
+        return new WebPlaywrightLocal(browser, recordingDir);
+    };
+    const runResult = await executeProgram(program, createAdapter, runOptions);
+    if (runResult.success) {
+        logger.info(`[capture] Run completed successfully — ${runResult.telemetry.totalOpcodes} opcodes, ${runResult.telemetry.recoveredOpcodes} recovered, ${runResult.totalDurationMs}ms`);
+    }
+    else {
+        logger.error(`[capture] Run failed: ${runResult.error}`);
+    }
+    try {
+        logger.info('[capture] Saving captures, might take a few seconds...');
+        await uploadResults(config, program, runResult);
+        const totalDurationSec = ((Date.now() - captureStart) / 1000).toFixed(1);
+        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)}`);
+    }
+    return { success: runResult.success, runResult };
+}
+// ── Server communication ────────────────────────────────────────────
+async function fetchProgram(config, presetId) {
+    try {
+        const url = `${config.apiBaseUrl}/api/cli/programs/${presetId}`;
+        const response = await fetch(url, {
+            headers: {
+                'Authorization': `Bearer ${config.apiKey}`,
+                'Content-Type': 'application/json',
+            },
+        });
+        if (!response.ok) {
+            return { success: false, error: await formatServerError(response, url) };
+        }
+        const data = await response.json();
+        if (data?._meta?.stale) {
+            logger.warn('[capture] Program is stale — langs/themes changed since last compilation. Recompile to apply changes.');
+        }
+        return { success: true, program: data };
+    }
+    catch (err) {
+        return { success: false, error: `failed to fetch program: ${err instanceof Error ? err.message : String(err)}` };
+    }
+}
+async function uploadResults(config, program, result) {
+    const runId = randomUUID();
+    const totalArtifacts = result.variantResults.reduce((sum, v) => sum + v.artifacts.length, 0);
+    let uploadedCount = 0;
+    // Upload artifacts
+    for (const variant of result.variantResults) {
+        const variantSpec = program.variants.find((entry) => entry.id === variant.variantId);
+        for (const artifact of variant.artifacts) {
+            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;
+            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);
+            formData.append('programVersion', String(program.programVersion));
+            formData.append('compileFingerprint', program.compileFingerprint);
+            formData.append('runId', runId);
+            formData.append('variantId', variant.variantId);
+            formData.append('targetId', variantSpec?.targetId ?? variant.variantId);
+            formData.append('targetLabel', variantSpec?.targetLabel ?? variantSpec?.deviceFrame ?? variant.variantId);
+            formData.append('mediaMode', artifact.mediaMode);
+            formData.append('mimeType', artifact.mimeType);
+            formData.append('captureType', artifact.captureType ?? 'fullpage');
+            formData.append('captureUrl', artifact.captureUrl ?? program.baseUrl);
+            formData.append('lang', variantSpec?.locale ?? 'en');
+            formData.append('theme', variantSpec?.theme ?? 'light');
+            if (variantSpec?.deviceFrame) {
+                formData.append('deviceFrame', variantSpec.deviceFrame);
+            }
+            formData.append('viewport', JSON.stringify(variantSpec?.viewport ?? null));
+            formData.append('artifactPlan', JSON.stringify(program.artifactPlan));
+            if (artifact.altText) {
+                formData.append('altText', artifact.altText);
+            }
+            if (artifact.elementSelector) {
+                formData.append('elementSelector', artifact.elementSelector);
+            }
+            if (artifact.captureId) {
+                formData.append('captureId', artifact.captureId);
+            }
+            if (artifact.captureName) {
+                formData.append('captureName', artifact.captureName);
+            }
+            if (artifact.clipId) {
+                formData.append('clipId', artifact.clipId);
+            }
+            if (artifact.clipName) {
+                formData.append('clipName', artifact.clipName);
+            }
+            if (artifact.stepDescription) {
+                formData.append('stepDescription', artifact.stepDescription);
+            }
+            if (typeof artifact.stepIndex === 'number') {
+                formData.append('stepIndex', String(artifact.stepIndex));
+            }
+            if (artifact.tabIconData) {
+                formData.append('tabIcon', new Blob([new Uint8Array(artifact.tabIconData)], { type: artifact.tabIconMimeType ?? 'image/png' }), 'favicon');
+            }
+            if (typeof artifact.durationMs === 'number') {
+                formData.append('durationMs', String(artifact.durationMs));
+            }
+            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}` },
+                body: formData,
+            });
+            if (!response.ok) {
+                throw new Error(`artifact upload failed for ${variant.variantId}: ${await formatServerError(response, `${config.apiBaseUrl}/api/cli/artifacts`)}`);
+            }
+        }
+    }
+    // Strip binary buffers from artifacts before sending. The raw PNG/video
+    // buffers were already uploaded via /api/cli/artifacts above, and the
+    // server strips them again before persisting. Sending them in the JSON
+    // body bloats the payload (each Buffer serializes as a giant int array,
+    // ~3-4× the original byte size) and overflows Next.js' request body limit.
+    const strippedRunResult = {
+        ...result,
+        variantResults: result.variantResults.map((variant) => ({
+            ...variant,
+            artifacts: variant.artifacts.map((artifact) => {
+                const { buffer: _buffer, tabIconData: _tabIconData, ...rest } = artifact;
+                return rest;
+            }),
+        })),
+    };
+    // Upload telemetry + healer patches
+    const telemetryResponse = await fetch(`${config.apiBaseUrl}/api/cli/telemetry`, {
+        method: 'POST',
+        headers: {
+            'Authorization': `Bearer ${config.apiKey}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            runId,
+            presetId: program.presetId,
+            programVersion: program.programVersion,
+            compileFingerprint: program.compileFingerprint,
+            success: result.success,
+            mediaMode: program.mediaMode,
+            telemetry: result.telemetry,
+            healerPatches: result.healerPatches,
+            runResult: strippedRunResult,
+            totalDurationMs: result.totalDurationMs,
+            variantSummaries: result.variantResults.map(v => ({
+                variantId: v.variantId,
+                success: v.success,
+                opcodeCount: v.opcodeResults.length,
+                artifactCount: v.artifacts.length,
+                durationMs: v.durationMs,
+                error: v.error,
+            })),
+        }),
+    });
+    if (!telemetryResponse.ok) {
+        throw new Error(`telemetry upload failed: ${await formatServerError(telemetryResponse, `${config.apiBaseUrl}/api/cli/telemetry`)}`);
+    }
+}
+async function formatServerError(response, requestedUrl) {
+    const contentType = response.headers?.get?.('content-type') ?? '';
+    const rawBody = (await response.text()).trim();
+    if (!rawBody) {
+        return `server returned ${response.status}`;
+    }
+    if (contentType.includes('application/json') || rawBody.startsWith('{')) {
+        try {
+            const parsed = JSON.parse(rawBody);
+            const message = typeof parsed.error === 'string'
+                ? parsed.error
+                : typeof parsed.message === 'string'
+                    ? parsed.message
+                    : null;
+            if (message) {
+                return `server returned ${response.status}: ${message}`;
+            }
+        }
+        catch {
+            // Fall back to a condensed text preview below.
+        }
+    }
+    const isHtml = contentType.includes('text/html') || /^<!doctype html>/i.test(rawBody);
+    if (response.status === 404 && isHtml) {
+        return [
+            `server returned 404 for ${requestedUrl}.`,
+            `The configured AutoKap server (${safeOrigin(requestedUrl)}) does not expose this CLI route yet.`,
+            'This usually means the web app deployment is older than the CLI.',
+            `Point the CLI at your local dev server with \`autokap run --local <preset-id>\`, \`${API_BASE_URL_ENV_VAR}=http://localhost:3000 autokap run <preset-id>\`, or re-initialize against a local server with \`autokap init --cli-key <key> --api-base-url http://localhost:3000\`.`,
+        ].join(' ');
+    }
+    if (isHtml) {
+        return `server returned ${response.status}: unexpected HTML response from ${requestedUrl}`;
+    }
+    return `server returned ${response.status}: ${rawBody.replace(/\s+/g, ' ').slice(0, 240)}`;
+}
+function safeOrigin(url) {
+    try {
+        return new URL(url).origin;
+    }
+    catch {
+        return url;
+    }
+}
+async function applyPreconditions(browser, program) {
+    const { preconditions } = program;
+    // Auth bootstrap auto-adapts to whatever is configured on the preset.
+    // - cookies / sessionStorage / storageState are injected into the browser
+    //   context so the page starts already authenticated.
+    // - credentials are NOT applied here; they're substituted into
+    //   {{email}}/{{password}}/{{loginUrl}} placeholders inside opcodes by the
+    //   opcode runner, and the program performs the UI login itself.
+    // - If neither is set, the run is anonymous.
+    if (preconditions.cookies && preconditions.cookies.length > 0) {
+        await browser.addCookies(preconditions.cookies);
+    }
+    if (preconditions.sessionStorage && Object.keys(preconditions.sessionStorage).length > 0) {
+        await browser.prepareSessionStorage(preconditions.sessionStorage, { replace: false });
+    }
+}
+function resolveCliLLMConfig() {
+    const apiKey = process.env.OPENROUTER_API_KEY?.trim();
+    if (!apiKey)
+        return undefined;
+    return {
+        apiKey,
+        model: process.env.AUTOKAP_LLM_MODEL?.trim() || undefined,
+    };
+}
+function createHealerLLMProvider(llmConfig) {
+    return {
+        call: async (prompt, screenshot) => {
+            const llmResult = await callLLM({
+                ...llmConfig,
+                maxTokens: Math.max(llmConfig.maxTokens ?? 400, 400),
+                timeoutMs: llmConfig.timeoutMs ?? 20000,
+            }, HEALER_SYSTEM_PROMPT, prompt, screenshot);
+            return {
+                response: llmResult.text,
+                llmResult,
+            };
+        },
+    };
+}
+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 stepToken = typeof artifact.stepIndex === 'number' ? `-${artifact.stepIndex}` : '';
+    return `${presetId}-${variantId}${stepToken}.${ext}`;
+}
+// ── Progress logging ────────────────────────────────────────────────
+function logProgress(event) {
+    const prefix = `[capture][${event.variantId}]`;
+    switch (event.type) {
+        case 'variant_start':
+            logger.info(`${prefix} Starting variant`);
+            break;
+        case 'variant_end':
+            logger.info(`${prefix} ${event.status === 'ok' ? 'Completed' : 'Failed'}: ${event.message}`);
+            break;
+        case 'opcode_start':
+            logger.debug(`${prefix}[${event.opcodeIndex}] ${event.opcodeKind}: ${event.message}`);
+            break;
+        case 'opcode_end':
+            if (event.status === 'failed') {
+                logger.error(`${prefix}[${event.opcodeIndex}] FAILED: ${event.message}`);
+            }
+            else if (event.status === 'recovered') {
+                logger.warn(`${prefix}[${event.opcodeIndex}] RECOVERED: ${event.message}`);
+            }
+            break;
+        case 'recovery':
+            logger.warn(`${prefix}[${event.opcodeIndex}] Recovery: ${event.message}`);
+            break;
+        case 'breaker_trip':
+            logger.error(`${prefix} Circuit breaker tripped: ${event.message}`);
+            break;
+    }
+}
+//# sourceMappingURL=cli-runner.js.map

package/dist/cli-utils.d.ts

@@ -1,6 +1,5 @@
 export declare function replaceSkillPlaceholders(content: string, opts: {
     projectUrl?: string;
     projectId?: string;
-    apiKey?: string;
     apiBaseUrl?: string;
 }): string;

package/dist/cli-utils.js

@@ -6,12 +6,9 @@ export function replaceSkillPlaceholders(content, opts) {
     if (opts.projectId) {
         result = result.replace(/\[AUTOKAP_PROJECT_ID\]/g, opts.projectId);
     }
-    if (opts.apiKey) {
-        result = result.replace(/YOUR_API_KEY/g, opts.apiKey);
+    if (opts.apiBaseUrl) {
+        result = result.replace(/https:\/\/autokap\.app/g, opts.apiBaseUrl);
     }
-    const baseUrl = opts.apiBaseUrl ?? 'https://autokap.app';
-    result = result.replace(/https:\/\/app\.autokap\.com/g, baseUrl);
-    result = result.replace(/https:\/\/autokap\.com/g, baseUrl);
     return result;
 }
 //# sourceMappingURL=cli-utils.js.map