autokap 1.6.6 → 1.6.8

package/dist/browser-bar.js

@@ -155,11 +155,14 @@ function attr(s) {
 }
 // ── Chrome generator (SVG, for sharp compositing — no Playwright) ──────
 // Produces a self-contained SVG string rasterizable by @resvg/resvg-js.
-/** SF Pro font CSS for embedding inside SVG <defs><style>. No local() — resvg only supports url(). */
-const SVG_BB_FONT_CSS = `
-@font-face{font-family:'SF Pro Text';src:url('${SF_PRO_TEXT_REGULAR}') format('woff2');font-weight:400;font-style:normal}
-@font-face{font-family:'SF Pro Text';src:url('${SF_PRO_TEXT_SEMIBOLD}') format('woff2');font-weight:600;font-style:normal}
-`;
+// SF Pro fonts for the SVG output are NOT embedded inline — Resvg-js 2.6.2
+// does not honor `@font-face url(data:font/woff2;base64,…)` declarations
+// inside an SVG <defs><style> block. They must instead be supplied via the
+// `font.fontFiles` Resvg option, which is the job of
+// `mockup.ts::rasterizeSvg` + `sf-pro-resvg-fonts.ts`. The `font-family`
+// declarations on the <text> elements below remain as a hint for any
+// downstream consumer that DOES honor CSS @font-face (e.g. a future Resvg
+// release, or a different SVG renderer entirely).
 const SVG_BB_FF = "'SF Pro Text',system-ui,sans-serif";
 /**
  * Generate a self-contained SVG string for the Chrome browser bar.
@@ -215,7 +218,6 @@ export function generateChromeBrowserBarSvg(options) {
     // and hide the colored circles underneath.
     return `<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="${width}" height="${height}" viewBox="0 0 ${iw} ${REF_H}" fill="none">
 <defs>
-<style>${SVG_BB_FONT_CSS}</style>
 <linearGradient id="bb_profile_grad" x1="${profileX + 15}" y1="109.5" x2="${profileX + 15}" y2="79.5" gradientUnits="userSpaceOnUse">
 <stop stop-color="#D5D8E4"/><stop offset="0.45" stop-color="#D1CAD6"/><stop offset="1" stop-color="#B7BAD1"/>
 </linearGradient>

package/dist/cli-config.d.ts

@@ -2,6 +2,7 @@ export interface AutokapConfig {
     apiKey: string;
     apiBaseUrl: string;
     wsUrl: string;
+    exportDebugLogs?: boolean;
 }
 declare const DEFAULT_API_BASE_URL = "https://autokap.app";
 declare const DEFAULT_WS_URL = "wss://autokap.app/ws";
@@ -12,6 +13,8 @@ declare const RUN_TOKEN_ENV_VAR = "AUTOKAP_RUN_TOKEN";
 declare const API_BASE_URL_ENV_VAR = "AUTOKAP_API_BASE_URL";
 declare const WS_URL_ENV_VAR = "AUTOKAP_WS_URL";
 declare const ALLOW_UNSAFE_SERVER_ORIGIN_ENV_VAR = "AUTOKAP_ALLOW_UNSAFE_SERVER_ORIGIN";
+declare const EXPORT_DEBUG_LOGS_ENV_VAR = "AUTOKAP_EXPORT_DEBUG_LOGS";
+export declare function resolveExportDebugLogs(stored: boolean | undefined): boolean;
 export declare function getConfigDir(): string;
 export declare function getConfigPath(): string;
 export declare function getDefaultApiBaseUrl(): string;
@@ -20,4 +23,4 @@ export declare function readConfig(): Promise<AutokapConfig | null>;
 export declare function writeConfig(config: AutokapConfig): Promise<void>;
 export declare function deleteConfig(): Promise<void>;
 export declare function requireConfig(): Promise<AutokapConfig>;
-export { DEFAULT_API_BASE_URL, DEFAULT_WS_URL, LOCAL_API_BASE_URL, LOCAL_WS_URL, API_KEY_ENV_VAR, RUN_TOKEN_ENV_VAR, API_BASE_URL_ENV_VAR, WS_URL_ENV_VAR, ALLOW_UNSAFE_SERVER_ORIGIN_ENV_VAR, };
+export { DEFAULT_API_BASE_URL, DEFAULT_WS_URL, LOCAL_API_BASE_URL, LOCAL_WS_URL, API_KEY_ENV_VAR, RUN_TOKEN_ENV_VAR, API_BASE_URL_ENV_VAR, WS_URL_ENV_VAR, ALLOW_UNSAFE_SERVER_ORIGIN_ENV_VAR, EXPORT_DEBUG_LOGS_ENV_VAR, };

package/dist/cli-config.js

@@ -24,6 +24,15 @@ const RUN_TOKEN_ENV_VAR = 'AUTOKAP_RUN_TOKEN';
 const API_BASE_URL_ENV_VAR = 'AUTOKAP_API_BASE_URL';
 const WS_URL_ENV_VAR = 'AUTOKAP_WS_URL';
 const ALLOW_UNSAFE_SERVER_ORIGIN_ENV_VAR = 'AUTOKAP_ALLOW_UNSAFE_SERVER_ORIGIN';
+const EXPORT_DEBUG_LOGS_ENV_VAR = 'AUTOKAP_EXPORT_DEBUG_LOGS';
+export function resolveExportDebugLogs(stored) {
+    const envRaw = process.env[EXPORT_DEBUG_LOGS_ENV_VAR]?.trim().toLowerCase();
+    if (envRaw === '0' || envRaw === 'false')
+        return false;
+    if (envRaw === '1' || envRaw === 'true')
+        return true;
+    return stored !== false;
+}
 export function getConfigDir() {
     return path.join(os.homedir(), '.autokap');
 }
@@ -82,6 +91,7 @@ export async function readConfig() {
         return null;
     const storedApiBaseUrlRaw = typeof record.apiBaseUrl === 'string' ? record.apiBaseUrl : null;
     const storedWsUrlRaw = typeof record.wsUrl === 'string' ? record.wsUrl : null;
+    const storedExportDebugLogs = typeof record.exportDebugLogs === 'boolean' ? record.exportDebugLogs : undefined;
     const envApiBaseUrl = normalizeUrl(process.env[API_BASE_URL_ENV_VAR]);
     const envWsUrl = normalizeUrl(process.env[WS_URL_ENV_VAR]);
     const storedApiBaseUrl = normalizeUrl(storedApiBaseUrlRaw) ?? DEFAULT_API_BASE_URL;
@@ -98,6 +108,7 @@ export async function readConfig() {
         apiKey: record.apiKey,
         apiBaseUrl,
         wsUrl,
+        exportDebugLogs: storedExportDebugLogs,
     };
 }
 export async function writeConfig(config) {
@@ -116,6 +127,9 @@ export async function writeConfig(config) {
         ...config,
         apiBaseUrl: normalizeUrl(config.apiBaseUrl) ?? DEFAULT_API_BASE_URL,
         wsUrl: normalizeUrl(config.wsUrl) ?? deriveWsUrl(config.apiBaseUrl),
+        ...(typeof config.exportDebugLogs === 'boolean'
+            ? { exportDebugLogs: config.exportDebugLogs }
+            : {}),
     };
     // Atomic write — see packages/core/src/config.ts for the canonical impl.
     const tmpPath = `${configPath}.${process.pid}.${crypto.randomBytes(4).toString('hex')}.tmp`;
@@ -215,5 +229,5 @@ function assertAllowedApiOrigin(candidateUrl, baselineUrl, envVar) {
     }
     throw new Error(`Refusing unsafe server override to ${candidateOrigin}. Set ${ALLOW_UNSAFE_SERVER_ORIGIN_ENV_VAR}=1 to allow ${envVar ?? 'this override'} explicitly.`);
 }
-export { DEFAULT_API_BASE_URL, DEFAULT_WS_URL, LOCAL_API_BASE_URL, LOCAL_WS_URL, API_KEY_ENV_VAR, RUN_TOKEN_ENV_VAR, API_BASE_URL_ENV_VAR, WS_URL_ENV_VAR, ALLOW_UNSAFE_SERVER_ORIGIN_ENV_VAR, };
+export { DEFAULT_API_BASE_URL, DEFAULT_WS_URL, LOCAL_API_BASE_URL, LOCAL_WS_URL, API_KEY_ENV_VAR, RUN_TOKEN_ENV_VAR, API_BASE_URL_ENV_VAR, WS_URL_ENV_VAR, ALLOW_UNSAFE_SERVER_ORIGIN_ENV_VAR, EXPORT_DEBUG_LOGS_ENV_VAR, };
 //# sourceMappingURL=cli-config.js.map

package/dist/cli-runner-local.d.ts

@@ -13,4 +13,5 @@ export declare function runLocal(presetId: string, opts: {
     allowUploadFailure?: boolean;
     dry?: boolean;
     regenerateTts?: boolean;
+    exportLogs?: boolean;
 }): Promise<void>;

package/dist/cli-runner-local.js

@@ -33,6 +33,7 @@ export async function runLocal(presetId, opts) {
         dryRun: opts.dry,
         regenerateTts: opts.regenerateTts,
         headed: opts.headed,
+        exportDebugLogs: opts.exportLogs,
         onProgress: (event) => {
             const prefix = `[capture][${event.variantId}]`;
             switch (event.type) {

package/dist/cli-runner.d.ts

@@ -45,6 +45,11 @@ export interface CLIRunnerOptions {
     abortSignal?: AbortSignal;
     /** Progress callback */
     onProgress?: (event: ProgressEvent) => void;
+    /**
+     * Override the user/CLI `exportDebugLogs` preference for this run.
+     * When `false`, skips the failed-run debug logs export (AUT-149).
+     */
+    exportDebugLogs?: boolean;
 }
 export interface CLIRunResult {
     success: boolean;

package/dist/cli-runner.js

@@ -16,7 +16,7 @@ import path from 'node:path';
 import { createHash, randomUUID } from 'node:crypto';
 import sharp from 'sharp';
 import { Browser } from './browser.js';
-import { API_BASE_URL_ENV_VAR, requireConfig } from './cli-config.js';
+import { API_BASE_URL_ENV_VAR, requireConfig, resolveExportDebugLogs } from './cli-config.js';
 import { WebPlaywrightLocal } from './web-playwright-local.js';
 import { executeProgram } from './opcode-runner.js';
 import { ensureChromiumInstalled } from './playwright-installer.js';
@@ -32,6 +32,8 @@ 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';
+import { redactTelemetryText, redactUrl } from './telemetry-redaction.js';
+import { LogCollector } from './log-collector.js';
 const MAX_CLIP_CAPTURE_DEVICE_SCALE_FACTOR = 1;
 const DEFAULT_VIDEO_DELIVERY_RESOLUTION = { width: 1920, height: 1080 };
 const DEFAULT_VIDEO_CAPTURE_RESOLUTION = DEFAULT_VIDEO_DELIVERY_RESOLUTION;
@@ -218,6 +220,9 @@ export async function runCapture(options) {
     // honors the requested concurrency.
     const isRecordable = program.mediaMode === 'clip' || program.mediaMode === 'video';
     const maxParallelVariants = isRecordable ? 1 : program.maxParallelCaptures;
+    // AUT-149: collect structured logs + progress events for export on failure.
+    const logCollector = new LogCollector();
+    logCollector.start();
     const runOptions = {
         recoveryChain,
         abortSignal: options.abortSignal,
@@ -226,6 +231,7 @@ export async function runCapture(options) {
         presetName: program.presetId,
         dryRun: options.dryRun,
         onProgress: (event) => {
+            logCollector.onProgress(event);
             if (!options.onProgress) {
                 logProgress(event);
             }
@@ -286,59 +292,81 @@ export async function runCapture(options) {
         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}`);
-    }
-    if (options.dryRun) {
-        logger.info(`[capture] DRY RUN complete — ${runResult.telemetry.totalOpcodes} opcodes executed, 0 captures, 0 credits charged`);
-        return { success: runResult.success, runId, runResult };
-    }
+    let runResult;
+    let cliResult;
     try {
-        logger.info('[capture] Saving captures, might take a few seconds...');
-        options.onProgress?.({
-            type: 'upload_start',
-            variantId: 'run',
-            message: 'saving captures',
-        });
-        const uploadOutcome = await uploadResults(config, program, runResult, runId);
-        if (program.mediaMode === 'video' && runResult.success) {
-            await signalVideoComplete(config, program, runResult, uploadOutcome.runId, videoAudioAssets, videoAudioAssetsByLocale);
+        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}`);
+        }
+        if (options.dryRun) {
+            logger.info(`[capture] DRY RUN complete — ${runResult.telemetry.totalOpcodes} opcodes executed, 0 captures, 0 credits charged`);
+            cliResult = { success: runResult.success, runId, runResult };
+        }
+        else {
+            try {
+                logger.info('[capture] Saving captures, might take a few seconds...');
+                options.onProgress?.({
+                    type: 'upload_start',
+                    variantId: 'run',
+                    message: 'saving captures',
+                });
+                const uploadOutcome = await uploadResults(config, program, runResult, runId);
+                if (program.mediaMode === 'video' && runResult.success) {
+                    await signalVideoComplete(config, program, runResult, uploadOutcome.runId, videoAudioAssets, videoAudioAssetsByLocale);
+                }
+                const totalDurationSec = ((Date.now() - captureStart) / 1000).toFixed(1);
+                logger.info(`[capture] Captures saved successfully — total ${totalDurationSec}s`);
+                options.onProgress?.({
+                    type: 'upload_end',
+                    variantId: 'run',
+                    status: 'ok',
+                    message: 'captures saved',
+                });
+                cliResult = { success: runResult.success, runId, runResult };
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                logger.error(`[capture] Failed to upload results: ${message}`);
+                options.onProgress?.({
+                    type: 'upload_end',
+                    variantId: 'run',
+                    status: 'failed',
+                    message,
+                });
+                if (!options.allowUploadFailure) {
+                    cliResult = {
+                        success: false,
+                        runId,
+                        runResult,
+                        error: runResult.success
+                            ? `upload failed: ${message}`
+                            : `${runResult.error ?? 'capture failed'}; upload failed: ${message}`,
+                    };
+                }
+                else {
+                    logger.warn('[capture] Continuing after upload failure because --allow-upload-failure was set');
+                    cliResult = { success: runResult.success, runId, runResult };
+                }
+            }
         }
-        const totalDurationSec = ((Date.now() - captureStart) / 1000).toFixed(1);
-        logger.info(`[capture] Captures saved successfully — total ${totalDurationSec}s`);
-        options.onProgress?.({
-            type: 'upload_end',
-            variantId: 'run',
-            status: 'ok',
-            message: 'captures saved',
-        });
     }
-    catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        logger.error(`[capture] Failed to upload results: ${message}`);
-        options.onProgress?.({
-            type: 'upload_end',
-            variantId: 'run',
-            status: 'failed',
-            message,
-        });
-        if (!options.allowUploadFailure) {
-            return {
-                success: false,
-                runId,
-                runResult,
-                error: runResult.success
-                    ? `upload failed: ${message}`
-                    : `${runResult.error ?? 'capture failed'}; upload failed: ${message}`,
-            };
+    finally {
+        // AUT-149: export structured debug logs to AutoKap on capture failure.
+        // Best-effort — the LogCollector swallows network errors.
+        const shouldExport = options.exportDebugLogs !== false
+            && resolveExportDebugLogs(config.exportDebugLogs)
+            && (runResult ? !runResult.success : true);
+        if (shouldExport) {
+            logger.info('[debug-logs] Exporting debug logs to AutoKap…');
+            await logCollector.flushTo(runId, program.presetId, config.apiBaseUrl, config.apiKey, options.env);
         }
-        logger.warn('[capture] Continuing after upload failure because --allow-upload-failure was set');
+        logCollector.stop();
     }
-    return { success: runResult.success, runId, runResult };
+    return cliResult;
 }
 // ── Server communication ────────────────────────────────────────────
 async function fetchProgram(config, presetId, environmentName) {
@@ -1388,30 +1416,7 @@ function redactOpcodeForTelemetry(opcode) {
     }
     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);
-    }
-}
+// redactTelemetryText / redactUrl moved to ./telemetry-redaction
 // ── Progress logging ────────────────────────────────────────────────
 function logProgress(event) {
     const prefix = `[capture][${event.variantId}]`;

package/dist/cli.js

@@ -87,6 +87,7 @@ program
     .option('--ws-url <url>', `WebSocket server URL (env: ${WS_URL_ENV_VAR})`)
     .action(async (key, opts) => {
     const wsUrl = opts.wsUrl?.trim() || getDefaultWsUrl(opts.apiBaseUrl);
+    let exportDebugLogs;
     try {
         const res = await fetch(`${opts.apiBaseUrl}/api/cli/validate`, {
             headers: { Authorization: `Bearer ${key}` },
@@ -95,6 +96,15 @@ program
             logger.error('Invalid API key. Generate one in the AutoKap dashboard.');
             process.exit(1);
         }
+        try {
+            const body = (await res.json());
+            if (typeof body.exportDebugLogs === 'boolean') {
+                exportDebugLogs = body.exportDebugLogs;
+            }
+        }
+        catch {
+            // ignore parse failures — preference will fall back to its default
+        }
     }
     catch (err) {
         logger.error(`Cannot reach API: ${err.message}`);
@@ -104,6 +114,7 @@ program
         apiKey: key,
         apiBaseUrl: opts.apiBaseUrl,
         wsUrl,
+        ...(typeof exportDebugLogs === 'boolean' ? { exportDebugLogs } : {}),
     });
     logger.success(`Authenticated. Key stored in ${getConfigPath()}`);
     process.exit(0);
@@ -166,6 +177,7 @@ program
     .option('--dry', 'Dry run: execute all opcodes without capturing or uploading artifacts (0 credits charged)', false)
     .option('--regenerate-tts', 'Force fresh TTS synthesis for video presets — ignore cached audio segments. Reused segments become billable at full rate.', false)
     .option('--debug', 'Verbose logging: per-substep timing, opcode dumps, recovery strategy traces', false)
+    .option('--no-export-logs', 'Disable exporting debug logs to AutoKap on capture failure (overrides user/CLI setting)')
     .action(async (presetId, opts) => {
     if (opts.debug) {
         const { setDebugEnabled } = await import('./logger.js');

package/dist/log-collector.d.ts

@@ -0,0 +1,46 @@
+import type { LogEntry } from './logger.js';
+import type { ProgressEvent } from './opcode-runner.js';
+export interface OpcodeContext {
+    index: number;
+    kind: string;
+    targetId?: string;
+}
+export interface ExportedLogEntry extends LogEntry {
+    opcode?: OpcodeContext;
+    recovery?: {
+        strategy: string;
+        reason: string;
+        succeeded: boolean;
+    };
+    postcondition?: {
+        type: string;
+        reason: string;
+    };
+    meta?: Record<string, unknown>;
+}
+export interface ErrorLogsPayload {
+    runId: string;
+    presetId: string;
+    entries: ExportedLogEntry[];
+    envName?: string;
+    endedAt: string;
+}
+export declare class LogCollector {
+    private entries;
+    private previousLogCallback;
+    private started;
+    private runStartedAt;
+    start(): void;
+    stop(): void;
+    onProgress(event: ProgressEvent): void;
+    snapshot(): ExportedLogEntry[];
+    size(): number;
+    flushTo(runId: string, presetId: string, apiBaseUrl: string, apiKey: string, envName?: string): Promise<{
+        ok: boolean;
+        status?: number;
+        error?: string;
+    }>;
+    private push;
+    private mapLogEntry;
+    private captureExistingCallback;
+}

package/dist/log-collector.js

@@ -0,0 +1,120 @@
+import { setOnLog, getOnLog, logger } from './logger.js';
+import { redactTelemetryText } from './telemetry-redaction.js';
+function redactParams(params) {
+    const out = {};
+    for (const [key, value] of Object.entries(params)) {
+        if (typeof value === 'string') {
+            out[key] = redactTelemetryText(value) ?? value;
+        }
+        else {
+            out[key] = value;
+        }
+    }
+    return out;
+}
+const MAX_ENTRIES = 1000;
+const FLUSH_TIMEOUT_MS = 5000;
+export class LogCollector {
+    entries = [];
+    previousLogCallback = null;
+    started = false;
+    runStartedAt = null;
+    start() {
+        if (this.started)
+            return;
+        this.started = true;
+        this.runStartedAt = Date.now();
+        this.previousLogCallback = this.captureExistingCallback();
+        setOnLog((entry) => {
+            this.push(this.mapLogEntry(entry));
+            if (this.previousLogCallback)
+                this.previousLogCallback(entry);
+        });
+    }
+    stop() {
+        if (!this.started)
+            return;
+        this.started = false;
+        setOnLog(this.previousLogCallback);
+        this.previousLogCallback = null;
+    }
+    onProgress(event) {
+        if (!this.started)
+            return;
+        const level = event.status === 'failed' ? 'error' : event.status === 'recovered' ? 'warn' : 'info';
+        const message = redactTelemetryText(event.message) ?? '';
+        this.push({
+            level: level,
+            message,
+            timestamp: Date.now(),
+            runStartedAt: this.runStartedAt ?? undefined,
+            runElapsedMs: this.runStartedAt ? Date.now() - this.runStartedAt : undefined,
+            opcode: event.opcodeIndex !== undefined && event.opcodeKind
+                ? { index: event.opcodeIndex, kind: event.opcodeKind }
+                : undefined,
+            meta: { progressType: event.type, variantId: event.variantId, status: event.status },
+        });
+    }
+    snapshot() {
+        return [...this.entries];
+    }
+    size() {
+        return this.entries.length;
+    }
+    async flushTo(runId, presetId, apiBaseUrl, apiKey, envName) {
+        if (this.entries.length === 0) {
+            return { ok: true, status: 204 };
+        }
+        const payload = {
+            runId,
+            presetId,
+            entries: this.entries,
+            envName,
+            endedAt: new Date().toISOString(),
+        };
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), FLUSH_TIMEOUT_MS);
+        try {
+            const response = await fetch(`${apiBaseUrl}/api/cli/error-logs`, {
+                method: 'POST',
+                headers: {
+                    'Authorization': `Bearer ${apiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify(payload),
+                signal: controller.signal,
+            });
+            if (!response.ok && response.status !== 204) {
+                const text = await response.text().catch(() => '');
+                logger.warn(`[debug-logs] Export failed (HTTP ${response.status}): ${text.slice(0, 200)}`);
+                return { ok: false, status: response.status, error: text };
+            }
+            return { ok: true, status: response.status };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            logger.warn(`[debug-logs] Export error: ${message}`);
+            return { ok: false, error: message };
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    push(entry) {
+        this.entries.push(entry);
+        if (this.entries.length > MAX_ENTRIES) {
+            this.entries.splice(0, this.entries.length - MAX_ENTRIES);
+        }
+    }
+    mapLogEntry(entry) {
+        return {
+            ...entry,
+            message: redactTelemetryText(entry.message) ?? entry.message,
+            params: entry.params ? redactParams(entry.params) : entry.params,
+        };
+    }
+    captureExistingCallback() {
+        return getOnLog();
+    }
+}
+//# sourceMappingURL=log-collector.js.map

package/dist/logger.d.ts

@@ -29,6 +29,7 @@ export declare function setDebugEnabled(enabled: boolean): void;
 export declare function isDebugEnabled(): boolean;
 export declare function runWithLoggerCallbacks<T>(callbacks: LoggerContext, fn: () => Promise<T>): Promise<T>;
 export declare function setOnLog(cb: OnLogCallback | null): void;
+export declare function getOnLog(): OnLogCallback | null;
 export declare function setOnScreenshot(cb: OnScreenshotCallback | null): void;
 export declare function emitScreenshot(base64: string): void;
 export declare function emitReasoningDelta(delta: string, messageId: string): void;

package/dist/logger.js

@@ -16,6 +16,9 @@ export async function runWithLoggerCallbacks(callbacks, fn) {
 export function setOnLog(cb) {
     _onLog = cb;
 }
+export function getOnLog() {
+    return _onLog;
+}
 export function setOnScreenshot(cb) {
     _onScreenshot = cb;
 }

package/dist/mockup.js

@@ -5,6 +5,7 @@ import { fileURLToPath } from 'url';
 import { renderStatusBarBuffer } from './status-bar-render.js';
 import { generateBrowserBarSvg } from './browser-bar.js';
 import { computeMockupLayout } from './mockup-html.js';
+import { getSfProResvgFontFiles } from './sf-pro-resvg-fonts.js';
 import { logger } from './logger.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -415,11 +416,27 @@ export async function getDeviceFrame(id) {
 }
 // ── Sharp Compositing Helpers ──────────────────────────────────────────
 /** Rasterize an SVG string to a PNG buffer using resvg-js.
- *  Resolves external image references (e.g. favicon URLs) before rendering. */
+ *  Resolves external image references (e.g. favicon URLs) before rendering.
+ *
+ *  Font handling: Resvg-js 2.6.2 does NOT read fonts from `@font-face url(data:...)`
+ *  declarations embedded inside the SVG. They MUST be supplied via `font.fontFiles`
+ *  with paths to on-disk TTF/OTF files. Without this, browser-bar text falls back
+ *  to Linux system fonts (DejaVu/Liberation) on Vercel, producing the wrong glyph
+ *  shapes that the user calls "SF Pro fonts don't load". `getSfProResvgFontFiles`
+ *  decompresses the SF Pro woff2 base64 data URIs to TTF in `os.tmpdir()` and
+ *  caches the paths for the lifetime of the function instance.
+ *  `loadSystemFonts: false` keeps the render deterministic across OSes — a font
+ *  load failure produces blank text (loud) instead of fallback (silent). */
 async function rasterizeSvg(svg, width) {
     const { Resvg } = await import('@resvg/resvg-js');
+    const fontFiles = await getSfProResvgFontFiles();
     const opts = {
         fitTo: { mode: 'width', value: width },
+        font: {
+            fontFiles,
+            loadSystemFonts: false,
+            defaultFontFamily: 'SF Pro Text',
+        },
     };
     const resvg = new Resvg(svg, opts);
     // Resolve external image references (e.g. <image href="https://..."/>)

package/dist/safari-browser-bar.js

@@ -17,10 +17,13 @@ const FONT_CSS_HTML = `<style>
 @font-face{font-family:'SF Pro Text';src:local('SF Pro Text'),local('.SFNSText'),url('${SF_PRO_TEXT_REGULAR}') format('woff2');font-weight:400;font-style:normal}
 @font-face{font-family:'SF Pro Text';src:local('SF Pro Text Semibold'),local('.SFNSText-Semibold'),url('${SF_PRO_TEXT_SEMIBOLD}') format('woff2');font-weight:600;font-style:normal}
 </style>`;
-const FONT_CSS_SVG = `
-@font-face{font-family:'SF Pro Text';src:url('${SF_PRO_TEXT_REGULAR}') format('woff2');font-weight:400;font-style:normal}
-@font-face{font-family:'SF Pro Text';src:url('${SF_PRO_TEXT_SEMIBOLD}') format('woff2');font-weight:600;font-style:normal}
-`;
+// SVG output: fonts are NOT embedded inline. Resvg-js 2.6.2 does not honor
+// `@font-face url(data:font/woff2;base64,…)` declarations inside SVG style
+// blocks; fonts must instead be supplied via `font.fontFiles` to the Resvg
+// constructor. The browser-bar pipeline (mockup.ts::rasterizeSvg) loads SF
+// Pro Text from disk via `sf-pro-resvg-fonts.ts`. The `font-family` hint on
+// the URL <text> element below remains for any consumer that DOES honor
+// CSS @font-face (a future Resvg release, a different SVG renderer, etc.).
 const FF = "'SF Pro Text',-apple-system,BlinkMacSystemFont,system-ui,sans-serif";
 // ── Helpers ──────────────────────────────────────────────────────────────
 function escText(s) {
@@ -88,7 +91,6 @@ export function generateSafariBrowserBarSvg(options) {
     const inner = buildSafariSvgInner(url, isDark);
     const vb = SAFARI_TOOLBAR_VIEWBOX;
     return `<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" width="${width}" height="${height}" viewBox="${vb.x} ${vb.y} ${vb.width} ${vb.height}" preserveAspectRatio="none" fill="none">
-<defs><style>${FONT_CSS_SVG}</style></defs>
 ${inner}
 </svg>`;
 }

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

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

package/dist/sf-pro-resvg-fonts.d.ts

@@ -0,0 +1,44 @@
+/**
+ * SF Pro font files on disk for @resvg/resvg-js consumption.
+ *
+ * Why this exists: Resvg-js 2.6.2 cannot load fonts from in-memory buffers,
+ * and it does NOT honor `@font-face url('data:font/woff2;base64,…')`
+ * declarations inside an SVG `<defs><style>` block. It only reads fonts
+ * from on-disk files (`fontFiles`) or directories (`fontDirs`).
+ *
+ * The browser-bar rendering pipeline (`generateBrowserBarSvg` →
+ * `rasterizeSvg` in mockup.ts) used to rely on the SVG <defs><style>
+ * @font-face approach. That silently fell back to system fonts
+ * (DejaVu/Liberation on Vercel Linux) — empirically verified by rendering
+ * the same SVG with and without `font.fontFiles` and observing the output
+ * change only when `fontFiles` is provided.
+ *
+ * This module decompresses the SF Pro Text Regular/Semibold woff2 data URIs
+ * from `sf-pro-fonts.ts` to TTF and writes them to `os.tmpdir()`, returning
+ * the file paths so callers can pass them to `new Resvg(svg, { font:
+ * { fontFiles: paths, loadSystemFonts: false } })`.
+ *
+ * Caching: paths are memoized per-process. On Vercel Fluid Compute the
+ * instance is reused across requests so the woff2→ttf decompression and
+ * disk writes happen at most once per cold start (~200ms total).
+ *
+ * Concurrency: two requests arriving before the first decompression
+ * finishes share a single in-flight Promise (no double work, no
+ * partial-file races).
+ *
+ * Robustness: if /tmp gets wiped between requests on the same instance
+ * (rare but possible), `fs.access` detects the missing files and a fresh
+ * init re-writes them.
+ *
+ * Windows-safe: uses `os.tmpdir()` + `path.join` (no hard-coded /tmp/),
+ * `fs.chmod` is intentionally skipped (no-op on NTFS anyway), no bash-isms.
+ */
+/**
+ * Returns the absolute paths to SF Pro Text Regular + Semibold TTF files on
+ * disk, suitable for `font.fontFiles` on a `new Resvg(svg, { … })` call.
+ *
+ * First call: decompresses woff2 → TTF and writes to `os.tmpdir()`. Subsequent
+ * calls: returns cached paths in O(2) `fs.access` checks (skipped after a
+ * single confirmed lookup per process — see implementation).
+ */
+export declare function getSfProResvgFontFiles(): Promise<string[]>;

package/dist/sf-pro-resvg-fonts.js

@@ -0,0 +1,126 @@
+/**
+ * SF Pro font files on disk for @resvg/resvg-js consumption.
+ *
+ * Why this exists: Resvg-js 2.6.2 cannot load fonts from in-memory buffers,
+ * and it does NOT honor `@font-face url('data:font/woff2;base64,…')`
+ * declarations inside an SVG `<defs><style>` block. It only reads fonts
+ * from on-disk files (`fontFiles`) or directories (`fontDirs`).
+ *
+ * The browser-bar rendering pipeline (`generateBrowserBarSvg` →
+ * `rasterizeSvg` in mockup.ts) used to rely on the SVG <defs><style>
+ * @font-face approach. That silently fell back to system fonts
+ * (DejaVu/Liberation on Vercel Linux) — empirically verified by rendering
+ * the same SVG with and without `font.fontFiles` and observing the output
+ * change only when `fontFiles` is provided.
+ *
+ * This module decompresses the SF Pro Text Regular/Semibold woff2 data URIs
+ * from `sf-pro-fonts.ts` to TTF and writes them to `os.tmpdir()`, returning
+ * the file paths so callers can pass them to `new Resvg(svg, { font:
+ * { fontFiles: paths, loadSystemFonts: false } })`.
+ *
+ * Caching: paths are memoized per-process. On Vercel Fluid Compute the
+ * instance is reused across requests so the woff2→ttf decompression and
+ * disk writes happen at most once per cold start (~200ms total).
+ *
+ * Concurrency: two requests arriving before the first decompression
+ * finishes share a single in-flight Promise (no double work, no
+ * partial-file races).
+ *
+ * Robustness: if /tmp gets wiped between requests on the same instance
+ * (rare but possible), `fs.access` detects the missing files and a fresh
+ * init re-writes them.
+ *
+ * Windows-safe: uses `os.tmpdir()` + `path.join` (no hard-coded /tmp/),
+ * `fs.chmod` is intentionally skipped (no-op on NTFS anyway), no bash-isms.
+ */
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { SF_PRO_TEXT_REGULAR, SF_PRO_TEXT_SEMIBOLD } from './sf-pro-fonts.js';
+const FONT_DIR_NAME = 'autokap-sf-pro';
+// Browser bar (Chrome + Safari chrome) uses only SF Pro Text Regular/Semibold.
+// Other variants (Display, Symbols) are consumed by the Satori-based status
+// bar renderer which already handles font embedding through its own
+// in-memory buffer pipeline (see `status-bar-render.ts::getSatoriFonts`).
+const FONTS = [
+    { filename: 'SF-Pro-Text-Regular.ttf', dataUri: SF_PRO_TEXT_REGULAR },
+    { filename: 'SF-Pro-Text-Semibold.ttf', dataUri: SF_PRO_TEXT_SEMIBOLD },
+];
+let cachedPaths = null;
+let pendingInit = null;
+async function decompressWoff2DataUri(dataUri) {
+    const raw = dataUri.replace(/^data:font\/woff2;base64,/, '');
+    const woff2 = Buffer.from(raw, 'base64');
+    const { decompress } = await import('wawoff2');
+    return Buffer.from(await decompress(woff2));
+}
+async function fileExists(p) {
+    try {
+        await fs.access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Write a single TTF file atomically. If a concurrent call (same process or
+ * a sibling instance sharing the tmpdir) already produced the final file,
+ * the second `rename` overwrites identical bytes — still safe.
+ *
+ * The `.${pid}.partial` suffix prevents Resvg from reading a half-written
+ * file if it loads paths while a write is in flight.
+ */
+async function ensureFontFile(targetPath, dataUri) {
+    if (await fileExists(targetPath))
+        return;
+    const ttf = await decompressWoff2DataUri(dataUri);
+    const tmpPath = `${targetPath}.${process.pid}.partial`;
+    await fs.writeFile(tmpPath, ttf);
+    try {
+        await fs.rename(tmpPath, targetPath);
+    }
+    catch (err) {
+        // Best-effort cleanup of the .partial if rename failed for some reason
+        // (e.g. cross-device rename on exotic mounts). Swallow — the rename
+        // error is what matters and will surface to the caller.
+        await fs.rm(tmpPath, { force: true }).catch(() => { });
+        throw err;
+    }
+}
+async function initFontFiles() {
+    const dir = path.join(os.tmpdir(), FONT_DIR_NAME);
+    await fs.mkdir(dir, { recursive: true });
+    const paths = FONTS.map((f) => path.join(dir, f.filename));
+    await Promise.all(FONTS.map((f, i) => ensureFontFile(paths[i], f.dataUri)));
+    return paths;
+}
+/**
+ * Returns the absolute paths to SF Pro Text Regular + Semibold TTF files on
+ * disk, suitable for `font.fontFiles` on a `new Resvg(svg, { … })` call.
+ *
+ * First call: decompresses woff2 → TTF and writes to `os.tmpdir()`. Subsequent
+ * calls: returns cached paths in O(2) `fs.access` checks (skipped after a
+ * single confirmed lookup per process — see implementation).
+ */
+export async function getSfProResvgFontFiles() {
+    if (cachedPaths) {
+        // Defensive: ensure /tmp wasn't wiped under us.
+        const allExist = await Promise.all(cachedPaths.map(fileExists));
+        if (allExist.every(Boolean))
+            return cachedPaths;
+        cachedPaths = null;
+        pendingInit = null;
+    }
+    if (!pendingInit) {
+        pendingInit = initFontFiles().then((paths) => {
+            cachedPaths = paths;
+            return paths;
+        }, (err) => {
+            pendingInit = null;
+            throw err;
+        });
+    }
+    return pendingInit;
+}
+//# sourceMappingURL=sf-pro-resvg-fonts.js.map

package/dist/telemetry-redaction.d.ts

@@ -0,0 +1,2 @@
+export declare function redactUrl(value: string | undefined): string | undefined;
+export declare function redactTelemetryText(value: string | undefined): string | undefined;

package/dist/telemetry-redaction.js

@@ -0,0 +1,25 @@
+export 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);
+    }
+}
+export 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);
+}
+//# sourceMappingURL=telemetry-redaction.js.map

package/package.json

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