autokap 1.0.7 → 1.0.10

package/dist/cli-runner.d.ts

@@ -0,0 +1,34 @@
+/**
+ * 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 { type ProgressEvent } from './opcode-runner.js';
+import type { ExecutionProgram, RunResult } from './execution-types.js';
+export interface CLIRunnerOptions {
+    /** Preset ID to run */
+    presetId: string;
+    /** Override: provide program directly instead of fetching from server */
+    program?: ExecutionProgram;
+    /** Selector memory map (fetched from server or cached locally) */
+    selectorMemory?: Record<string, string[]>;
+    /** Show browser window. Default: false (headless) */
+    headed?: boolean;
+    /** Abort signal for cancellation */
+    abortSignal?: AbortSignal;
+    /** Progress callback */
+    onProgress?: (event: ProgressEvent) => void;
+}
+export interface CLIRunResult {
+    success: boolean;
+    runResult?: RunResult;
+    error?: string;
+}
+export declare function runCapture(options: CLIRunnerOptions): Promise<CLIRunResult>;

package/dist/cli-runner.js

@@ -0,0 +1,580 @@
+/**
+ * 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 { 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 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 resolvedProgram;
+    if (options.program) {
+        let parsedProgram;
+        try {
+            parsedProgram = parseProgram(options.program);
+        }
+        catch (err) {
+            return { success: false, error: `program validation failed: ${err instanceof Error ? err.message : String(err)}` };
+        }
+        resolvedProgram = {
+            program: parsedProgram,
+            security: deriveUnsignedProgramSecurity(parsedProgram, config.apiBaseUrl),
+        };
+    }
+    else {
+        const fetched = await fetchProgram(config, options.presetId);
+        if (!fetched.success) {
+            return { success: false, error: fetched.error };
+        }
+        resolvedProgram = {
+            program: fetched.program,
+            security: fetched.security,
+        };
+        try {
+            // Step 2: Validate the program fetched from the server.
+            resolvedProgram = {
+                ...resolvedProgram,
+                program: parseProgram(resolvedProgram.program),
+            };
+        }
+        catch (err) {
+            return { success: false, error: `program validation failed: ${err instanceof Error ? err.message : String(err)}` };
+        }
+    }
+    let { program } = resolvedProgram;
+    // 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,
+        };
+    }
+    try {
+        assertProgramNavigationScope(program, resolvedProgram.security);
+    }
+    catch (error) {
+        return { success: false, error: error instanceof Error ? error.message : String(error) };
+    }
+    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);
+    // 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.forClipCapture(browserOptions, 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',
+                [CLI_VERSION_HEADER]: APP_VERSION,
+            },
+        });
+        if (!response.ok) {
+            return { success: false, error: await formatServerError(response, url) };
+        }
+        const data = await response.json();
+        const envelope = verifySignedExecutionProgramEnvelope({
+            apiKey: config.apiKey,
+            envelope: data,
+            expectedApiOrigin: safeOrigin(config.apiBaseUrl),
+        });
+        if (envelope.meta?.stale) {
+            logger.warn('[capture] Program is stale — langs/themes changed since last compilation. Recompile to apply changes.');
+        }
+        return { success: true, program: envelope.program, security: envelope.security };
+    }
+    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);
+            }
+            const deviceScaleFactor = variantSpec?.deviceScaleFactor ?? program.outputScale;
+            if (Number.isFinite(deviceScaleFactor)) {
+                formData.append('deviceScaleFactor', String(deviceScaleFactor));
+            }
+            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;
+                const sanitizedArtifact = sanitizeArtifactForTelemetry(rest);
+                return sanitizedArtifact;
+            }),
+            error: redactTelemetryText(variant.error),
+            opcodeResults: variant.opcodeResults.map((opcodeResult) => ({
+                ...opcodeResult,
+                error: redactTelemetryText(opcodeResult.error),
+            })),
+        })),
+    };
+    const sanitizedHealerPatches = sanitizeHealerPatches(result.healerPatches);
+    // 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: sanitizedHealerPatches,
+            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(security) {
+    if (!security.runtimeLlmAllowed) {
+        return undefined;
+    }
+    const enabled = process.env.AUTOKAP_ENABLE_RUNTIME_LLM?.trim().toLowerCase();
+    if (enabled !== '1' && enabled !== 'true') {
+        return undefined;
+    }
+    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 `${sanitizeArtifactToken(presetId)}-${sanitizeArtifactToken(variantId)}${stepToken}.${ext}`;
+}
+function sanitizeArtifactToken(value) {
+    const cleaned = value.trim().replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/-+/g, '-');
+    return cleaned.length > 0 ? cleaned.slice(0, 80) : 'artifact';
+}
+function deriveUnsignedProgramSecurity(program, apiBaseUrl) {
+    return {
+        expectedApiOrigin: safeOrigin(apiBaseUrl),
+        allowedNavigationOrigins: collectAllowedNavigationOrigins(program),
+        runtimeLlmAllowed: true,
+    };
+}
+function collectAllowedNavigationOrigins(program) {
+    const candidates = [program.baseUrl];
+    if (program.preconditions.credentials?.loginUrl) {
+        candidates.push(program.preconditions.credentials.loginUrl);
+    }
+    for (const step of program.steps) {
+        if (step.kind === 'NAVIGATE') {
+            candidates.push(step.url);
+        }
+    }
+    return normalizeAllowedOrigins(candidates
+        .map((value) => normalizeHttpOrigin(value))
+        .filter((value) => Boolean(value)));
+}
+function assertProgramNavigationScope(program, security) {
+    const allowedOrigins = new Set(normalizeAllowedOrigins(security.allowedNavigationOrigins));
+    if (allowedOrigins.size === 0) {
+        throw new Error('program security metadata does not declare any navigation origins');
+    }
+    for (const step of program.steps) {
+        if (step.kind !== 'NAVIGATE')
+            continue;
+        const origin = normalizeHttpOrigin(step.url);
+        if (!origin || !allowedOrigins.has(origin)) {
+            throw new Error(`program navigation target ${step.url} is outside the signed scope (${Array.from(allowedOrigins).join(', ')})`);
+        }
+    }
+}
+function sanitizeArtifactForTelemetry(artifact) {
+    return {
+        ...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) {
+    return patches.map((patch) => ({
+        ...patch,
+        reason: redactTelemetryText(patch.reason) ?? patch.reason,
+        originalOpcode: redactOpcodeForTelemetry(patch.originalOpcode),
+        replacementOpcodes: patch.replacementOpcodes.map((opcode) => redactOpcodeForTelemetry(opcode)),
+    }));
+}
+function redactOpcodeForTelemetry(opcode) {
+    const base = {
+        ...opcode,
+        description: redactTelemetryText(opcode.description) ?? opcode.description,
+    };
+    if ('selector' in base) {
+        return {
+            ...base,
+            selector: '<redacted-selector>',
+            ...('selectorAlternates' in base ? { selectorAlternates: [] } : {}),
+        };
+    }
+    return base;
+}
+function redactTelemetryText(value) {
+    if (!value)
+        return value;
+    return value
+        .replace(/\{\{(email|password|loginUrl)\}\}/g, '<credential-placeholder>')
+        .replace(/https?:\/\/[^\s"'<>]+/gi, (match) => redactUrl(match) ?? '<redacted-url>')
+        .replace(/[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}/g, '<redacted-email>')
+        .slice(0, 512);
+}
+function redactUrl(value) {
+    if (!value)
+        return value;
+    try {
+        const parsed = new URL(value);
+        parsed.username = '';
+        parsed.password = '';
+        parsed.search = parsed.search ? '?<redacted>' : '';
+        parsed.hash = parsed.hash ? '#<redacted>' : '';
+        return parsed.toString();
+    }
+    catch {
+        return value.slice(0, 256);
+    }
+}
+// ── 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