autokap 1.0.6 → 1.0.7

package/dist/video-variant-state.js

@@ -0,0 +1,80 @@
+import { evaluateRequestedLanguageState, evaluateRequestedThemeState as evaluateRequestedThemeStateRich, } from './session-profile.js';
+function normalizeConfidenceScore(confidence) {
+    switch (confidence) {
+        case 'high':
+            return 1;
+        case 'medium':
+            return 0.78;
+        case 'low':
+        default:
+            return 0.58;
+    }
+}
+export function scoreLocaleSignals(signals, requestedLang) {
+    if (!requestedLang)
+        return { score: 1, reasons: [], ambiguous: false };
+    const languageState = evaluateRequestedLanguageState({
+        currentUrl: signals.url,
+        requestedLang,
+        signals,
+    });
+    if (languageState.active) {
+        return {
+            score: normalizeConfidenceScore(languageState.confidence),
+            reasons: languageState.reasons,
+            ambiguous: false,
+        };
+    }
+    if (languageState.ambiguous) {
+        return {
+            score: languageState.confidence === 'high' ? 0.45 : languageState.confidence === 'medium' ? 0.32 : 0.18,
+            reasons: languageState.reasons,
+            ambiguous: true,
+        };
+    }
+    return {
+        score: 0,
+        reasons: languageState.reasons,
+        ambiguous: false,
+    };
+}
+export function evaluateRequestedThemeState(signals, requestedTheme) {
+    const themeState = evaluateRequestedThemeStateRich({
+        requestedTheme,
+        signals,
+    });
+    return {
+        detected: themeState.detected,
+        active: themeState.active,
+        ambiguous: themeState.ambiguous,
+        reason: themeState.reasons.join('; ') || 'no_theme_signal',
+    };
+}
+export async function detectVariantStateDeterministic(browser, requestedLang, requestedTheme) {
+    const signals = await browser.capturePageSignals();
+    const languageState = evaluateRequestedLanguageState({
+        currentUrl: signals.url,
+        requestedLang,
+        signals,
+    });
+    const themeState = evaluateRequestedThemeStateRich({
+        requestedTheme,
+        signals,
+    });
+    return {
+        lang: {
+            requested: requestedLang,
+            detected: languageState.detected,
+            active: requestedLang ? languageState.active : true,
+            ambiguous: requestedLang ? languageState.ambiguous : false,
+        },
+        theme: {
+            requested: requestedTheme,
+            detected: themeState.detected,
+            active: requestedTheme ? themeState.active : true,
+            ambiguous: requestedTheme ? themeState.ambiguous : false,
+        },
+        pageSignals: signals,
+    };
+}
+//# sourceMappingURL=video-variant-state.js.map

package/dist/vision-model.d.ts

@@ -0,0 +1,17 @@
+export declare class VisionModelUnsupportedError extends Error {
+    requestedModel: string;
+    fallbackModel?: string;
+    constructor(requestedModel: string, fallbackModel?: string);
+}
+export declare function isImageInputUnsupportedError(err: unknown): boolean;
+export declare function buildVisionModelUnavailableMessage(requestedModel: string, fallbackModel?: string): string;
+export declare function callVisionCapableModel<T>(params: {
+    primaryModel: string;
+    fallbackModel?: string;
+    callModel: (model: string) => Promise<T>;
+    onFallbackActivated?: (model: string, reason: string) => void;
+}): Promise<{
+    result: T;
+    model: string;
+    fellBack: boolean;
+}>;

package/dist/vision-model.js

@@ -0,0 +1,74 @@
+export class VisionModelUnsupportedError extends Error {
+    requestedModel;
+    fallbackModel;
+    constructor(requestedModel, fallbackModel) {
+        super(buildVisionModelUnavailableMessage(requestedModel, fallbackModel));
+        this.name = 'VisionModelUnsupportedError';
+        this.requestedModel = requestedModel;
+        this.fallbackModel = fallbackModel;
+    }
+}
+function extractNestedErrorMessage(err) {
+    if (!err || typeof err !== 'object')
+        return '';
+    const errorRecord = err;
+    const directMessage = typeof errorRecord.message === 'string' ? errorRecord.message : '';
+    const nestedError = errorRecord.error;
+    const nestedMessage = nestedError && typeof nestedError === 'object' && typeof nestedError.message === 'string'
+        ? nestedError.message
+        : '';
+    if (nestedMessage && nestedMessage === directMessage)
+        return directMessage;
+    return [directMessage, nestedMessage].filter(Boolean).join(' ');
+}
+export function isImageInputUnsupportedError(err) {
+    if (!err || typeof err !== 'object')
+        return false;
+    const errorRecord = err;
+    const status = typeof errorRecord.status === 'number' ? errorRecord.status : undefined;
+    const message = extractNestedErrorMessage(err).toLowerCase();
+    if (!message)
+        return false;
+    const mentionsImageEndpoint = message.includes('no endpoints found that support image input')
+        || message.includes('no providers that support image input')
+        || (message.includes('image input') && message.includes('no') && message.includes('support'))
+        || (message.includes('image input') && message.includes('endpoint') && message.includes('no'));
+    if (!mentionsImageEndpoint)
+        return false;
+    return status === undefined || status === 400 || status === 404 || status === 422;
+}
+export function buildVisionModelUnavailableMessage(requestedModel, fallbackModel) {
+    const fallbackHint = fallbackModel && fallbackModel !== requestedModel
+        ? ` Automatic fallback to "${fallbackModel}" also failed or was unavailable.`
+        : '';
+    return `The model "${requestedModel}" has no available endpoint that supports image input.${fallbackHint} Configure a vision-capable default/fallback model or retry later if the provider is degraded.`;
+}
+export async function callVisionCapableModel(params) {
+    const { primaryModel, fallbackModel, callModel, onFallbackActivated } = params;
+    let fallbackReason = '';
+    try {
+        const result = await callModel(primaryModel);
+        return { result, model: primaryModel, fellBack: false };
+    }
+    catch (err) {
+        if (!isImageInputUnsupportedError(err)) {
+            throw err;
+        }
+        fallbackReason = extractNestedErrorMessage(err) || 'image input unsupported';
+        if (!fallbackModel || fallbackModel === primaryModel) {
+            throw new VisionModelUnsupportedError(primaryModel, fallbackModel);
+        }
+    }
+    try {
+        const result = await callModel(fallbackModel);
+        onFallbackActivated?.(fallbackModel, fallbackReason);
+        return { result, model: fallbackModel, fellBack: true };
+    }
+    catch (fallbackErr) {
+        if (isImageInputUnsupportedError(fallbackErr)) {
+            throw new VisionModelUnsupportedError(primaryModel, fallbackModel);
+        }
+        throw fallbackErr;
+    }
+}
+//# sourceMappingURL=vision-model.js.map

package/dist/ws-auth.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Lightweight auth module for the WS server.
+ * Mirrors web/lib/cli-auth.ts + web/lib/api-keys.ts logic
+ * but runs outside the Next.js context.
+ */
+import { type SupabaseClient } from '@supabase/supabase-js';
+export interface WsAuthResult {
+    userId: string;
+    apiKeyId: string;
+    scopes: string[];
+    projectId: string | null;
+}
+export declare function getSupabase(): SupabaseClient;
+export declare function validateApiKey(rawKey: string): Promise<WsAuthResult | null>;
+/**
+ * Check that the key has the required scope.
+ * CLI keys (scopes = []) have implicit full access — skip the check.
+ * API keys must have the scope explicitly listed.
+ */
+export declare function requireScope(scopes: string[], required: string): void;

package/dist/ws-auth.js

@@ -0,0 +1,67 @@
+/**
+ * Lightweight auth module for the WS server.
+ * Mirrors web/lib/cli-auth.ts + web/lib/api-keys.ts logic
+ * but runs outside the Next.js context.
+ */
+import crypto from 'node:crypto';
+import { createClient } from '@supabase/supabase-js';
+// ── Supabase service client ────────────────────────────────────────
+let _client = null;
+export function getSupabase() {
+    if (!_client) {
+        const url = process.env.SUPABASE_URL ?? process.env.NEXT_PUBLIC_SUPABASE_URL;
+        const key = process.env.SUPABASE_SERVICE_ROLE_KEY;
+        if (!url || !key) {
+            throw new Error('Missing SUPABASE_URL or SUPABASE_SERVICE_ROLE_KEY');
+        }
+        _client = createClient(url, key);
+    }
+    return _client;
+}
+// ── Key validation ─────────────────────────────────────────────────
+const VALID_PREFIXES = ['ak_cli_', 'ak_api_', 'ak_live_'];
+function isValidKeyFormat(key) {
+    return VALID_PREFIXES.some(p => key.startsWith(p));
+}
+function hashKey(key) {
+    return crypto.createHash('sha256').update(key).digest('hex');
+}
+export async function validateApiKey(rawKey) {
+    if (!isValidKeyFormat(rawKey))
+        return null;
+    const hash = hashKey(rawKey);
+    const supabase = getSupabase();
+    const { data, error } = await supabase
+        .from('api_keys')
+        .select('id, user_id, scopes, project_id')
+        .eq('key_hash', hash)
+        .eq('revoked', false)
+        .single();
+    if (error || !data)
+        return null;
+    // Update last_used_at (fire-and-forget)
+    supabase
+        .from('api_keys')
+        .update({ last_used_at: new Date().toISOString() })
+        .eq('id', data.id)
+        .then(() => { });
+    return {
+        userId: data.user_id,
+        apiKeyId: data.id,
+        scopes: data.scopes ?? [],
+        projectId: data.project_id ?? null,
+    };
+}
+/**
+ * Check that the key has the required scope.
+ * CLI keys (scopes = []) have implicit full access — skip the check.
+ * API keys must have the scope explicitly listed.
+ */
+export function requireScope(scopes, required) {
+    if (scopes.length === 0)
+        return; // CLI keys: full access
+    if (!scopes.includes(required)) {
+        throw new Error(`Missing required scope: ${required}`);
+    }
+}
+//# sourceMappingURL=ws-auth.js.map

package/dist/ws-handler.d.ts

@@ -0,0 +1,10 @@
+/**
+ * WS handler — orchestrates a capture run for a single CLI connection.
+ *
+ * The CLI stays a thin RPC adapter around a local Playwright browser.
+ * The orchestration stays server-side and reuses shared capture helpers
+ * so the WS flow does not drift from the HTTP capture flow.
+ */
+import type { WebSocket } from 'ws';
+import type { IncomingMessage } from 'node:http';
+export declare function handleConnection(ws: WebSocket, req: IncomingMessage): Promise<void>;