autokap 1.6.6 → 1.6.7

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/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/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.7",
   "description": "AI-powered CLI tool for capturing clean screenshots of websites",
   "type": "module",
   "main": "./dist/index.js",