autokap 1.0.7 → 1.0.8

package/dist/ws-auth.js

@@ -33,12 +33,15 @@ export async function validateApiKey(rawKey) {
     const supabase = getSupabase();
     const { data, error } = await supabase
         .from('api_keys')
-        .select('id, user_id, scopes, project_id')
+        .select('id, user_id, scopes, project_id, expires_at')
         .eq('key_hash', hash)
         .eq('revoked', false)
         .single();
     if (error || !data)
         return null;
+    // Reject expired keys
+    if (data.expires_at && new Date(data.expires_at) < new Date())
+        return null;
     // Update last_used_at (fire-and-forget)
     supabase
         .from('api_keys')

package/dist/ws-broadcast.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Broadcast publisher for CLI capture events.
+ *
+ * Bridges WS-handler capture events to the web UI via Supabase Realtime
+ * Broadcast channels.  The web client subscribes to the same channel
+ * name (`capture-live:{runId}`) and receives SSEEvent-shaped payloads
+ * that feed directly into the existing captureReducer.
+ *
+ * All broadcast calls are fire-and-forget — a broadcast failure must
+ * never block or fail the capture.
+ */
+import type { SupabaseClient } from '@supabase/supabase-js';
+/** Matches web/lib/types.ts SSEEvent shape. */
+interface BroadcastSSEEvent {
+    type: string;
+    data: Record<string, unknown>;
+}
+export interface CaptureBroadcast {
+    /** Fire-and-forget: sends an SSEEvent to the web UI. */
+    send(event: BroadcastSSEEvent): void;
+    /**
+     * Resize a base64 screenshot to a small thumbnail and broadcast it.
+     * The resizing is async but errors are swallowed.
+     */
+    sendScreenshot(base64: string, meta?: {
+        lang?: string;
+        theme?: string;
+        targetId?: string;
+    }): void;
+    /** Unsubscribe and clean up the channel. */
+    close(): void;
+}
+export declare function createCaptureBroadcast(runId: string, supabase: SupabaseClient): CaptureBroadcast;
+export {};

package/dist/ws-broadcast.js

@@ -0,0 +1,85 @@
+/**
+ * Broadcast publisher for CLI capture events.
+ *
+ * Bridges WS-handler capture events to the web UI via Supabase Realtime
+ * Broadcast channels.  The web client subscribes to the same channel
+ * name (`capture-live:{runId}`) and receives SSEEvent-shaped payloads
+ * that feed directly into the existing captureReducer.
+ *
+ * All broadcast calls are fire-and-forget — a broadcast failure must
+ * never block or fail the capture.
+ */
+import sharp from 'sharp';
+import { logger } from './logger.js';
+const THUMBNAIL_WIDTH = 400;
+const THUMBNAIL_QUALITY = 60;
+async function resizeScreenshot(base64) {
+    const buf = Buffer.from(base64, 'base64');
+    const resized = await sharp(buf)
+        .resize({ width: THUMBNAIL_WIDTH, withoutEnlargement: true })
+        .jpeg({ quality: THUMBNAIL_QUALITY })
+        .toBuffer();
+    return resized.toString('base64');
+}
+export function createCaptureBroadcast(runId, supabase) {
+    const channelName = `capture-live:${runId}`;
+    let channel = null;
+    let ready = false;
+    // Subscribe asynchronously — events before subscription completes are dropped.
+    try {
+        channel = supabase.channel(channelName);
+        channel.subscribe((status) => {
+            if (status === 'SUBSCRIBED') {
+                ready = true;
+            }
+        });
+    }
+    catch (err) {
+        logger.debug(`[broadcast] Failed to create channel: ${err.message}`);
+    }
+    function broadcast(event) {
+        if (!ready || !channel)
+            return;
+        try {
+            channel.send({
+                type: 'broadcast',
+                event: 'capture_event',
+                payload: event,
+            });
+        }
+        catch {
+            // Swallow — broadcast must never affect capture.
+        }
+    }
+    return {
+        send(event) {
+            broadcast(event);
+        },
+        sendScreenshot(base64, meta) {
+            // Resize asynchronously, then broadcast.
+            resizeScreenshot(base64)
+                .then((thumbnail) => {
+                broadcast({
+                    type: 'screenshot_update',
+                    data: { base64: thumbnail, ...meta },
+                });
+            })
+                .catch(() => {
+                // Swallow resize errors.
+            });
+        },
+        close() {
+            if (channel) {
+                try {
+                    supabase.removeChannel(channel);
+                }
+                catch {
+                    // Best effort.
+                }
+                channel = null;
+                ready = false;
+            }
+        },
+    };
+}
+//# sourceMappingURL=ws-broadcast.js.map

package/dist/ws-connection-limits.d.ts

@@ -0,0 +1,12 @@
+/**
+ * In-memory connection tracking for per-IP and per-user WS limits.
+ * Separate module to avoid circular imports between ws-server and ws-handler.
+ */
+import type { WebSocket } from 'ws';
+export declare const MAX_CONNECTIONS_PER_IP = 10;
+export declare function incrementIpConnections(ip: string): number;
+export declare function decrementIpConnections(ip: string): void;
+export declare function getIpConnectionCount(ip: string): number;
+export declare function trackUserConnection(userId: string, ws: WebSocket): void;
+export declare function untrackUserConnection(userId: string, ws: WebSocket): void;
+export declare function getUserConnectionCount(userId: string): number;

package/dist/ws-connection-limits.js

@@ -0,0 +1,44 @@
+/**
+ * In-memory connection tracking for per-IP and per-user WS limits.
+ * Separate module to avoid circular imports between ws-server and ws-handler.
+ */
+// ── Per-IP connection tracking ─────────────────────────────────────
+export const MAX_CONNECTIONS_PER_IP = 10;
+const ipConnectionCounts = new Map();
+export function incrementIpConnections(ip) {
+    const count = (ipConnectionCounts.get(ip) ?? 0) + 1;
+    ipConnectionCounts.set(ip, count);
+    return count;
+}
+export function decrementIpConnections(ip) {
+    const current = ipConnectionCounts.get(ip) ?? 1;
+    if (current <= 1)
+        ipConnectionCounts.delete(ip);
+    else
+        ipConnectionCounts.set(ip, current - 1);
+}
+export function getIpConnectionCount(ip) {
+    return ipConnectionCounts.get(ip) ?? 0;
+}
+// ── Per-user connection tracking ───────────────────────────────────
+const userConnections = new Map();
+export function trackUserConnection(userId, ws) {
+    let conns = userConnections.get(userId);
+    if (!conns) {
+        conns = new Set();
+        userConnections.set(userId, conns);
+    }
+    conns.add(ws);
+}
+export function untrackUserConnection(userId, ws) {
+    const conns = userConnections.get(userId);
+    if (conns) {
+        conns.delete(ws);
+        if (conns.size === 0)
+            userConnections.delete(userId);
+    }
+}
+export function getUserConnectionCount(userId) {
+    return userConnections.get(userId)?.size ?? 0;
+}
+//# sourceMappingURL=ws-connection-limits.js.map

package/dist/ws-handler-utils.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Standalone utility functions extracted from ws-handler.ts.
+ * These have zero closure dependencies and can be safely imported by any module.
+ */
+import type { SupabaseClient } from '@supabase/supabase-js';
+import type { RemoteBrowser } from './remote-browser.js';
+import type { AgentResult, AgentRunHint, BrowserStorageState, BrowserSessionStorageState, CaptureHandoffContext, ExecutedAction, ValidatedSessionProfile } from './types.js';
+export type PageRun = {
+    url: string;
+    prompt: string;
+    pageId: string | null;
+};
+export declare function urlsRoughlyMatch(left: string | null | undefined, right: string | null | undefined): boolean;
+export declare function loadRunHints(supabase: SupabaseClient, presetId: string): Promise<AgentRunHint[] | undefined>;
+export declare function buildPersistableProfile(previousProfile: ValidatedSessionProfile | undefined, storageState: BrowserStorageState | undefined, sessionStorage: BrowserSessionStorageState | undefined, currentUrl: string, lang: string, theme: 'light' | 'dark'): ValidatedSessionProfile;
+export declare function inferAuthState(storageState: BrowserStorageState | undefined, sessionStorage: BrowserSessionStorageState | undefined): ValidatedSessionProfile['authState'];
+export declare function buildPreverifiedAgentResult(assessment: string, verification: NonNullable<AgentResult['verification']>): AgentResult;
+export declare function makeFailedAgentResult(message: string): AgentResult;
+export declare function buildHandoffContext(params: {
+    browser: RemoteBrowser;
+    pageRun: PageRun;
+    profile: ValidatedSessionProfile;
+    lang: string;
+    theme: 'light' | 'dark';
+    selectorMemory: Record<string, string[]>;
+    actions?: ExecutedAction[];
+    agentResult?: AgentResult;
+}): Promise<CaptureHandoffContext>;
+export declare function restorePreparedPageState(browser: RemoteBrowser, viewport: {
+    width: number;
+    height: number;
+}, preparedPageUrl: string): Promise<void>;

package/dist/ws-handler-utils.js

@@ -0,0 +1,139 @@
+/**
+ * Standalone utility functions extracted from ws-handler.ts.
+ * These have zero closure dependencies and can be safely imported by any module.
+ */
+import { buildAgentRunHints } from './session-profile.js';
+import { urlsPointToSameCaptureState, } from './capture-request-plan.js';
+import { lockCaptureViewport, } from './capture-viewport-lock.js';
+import { buildSequentialHandoffArtifacts, mergeSelectorMemory, } from './capture-run-optimizer.js';
+import { isTerminalAgentResultSuccess, isStrongCheckpointVerified, } from './types.js';
+export function urlsRoughlyMatch(left, right) {
+    return urlsPointToSameCaptureState(left, right);
+}
+export async function loadRunHints(supabase, presetId) {
+    try {
+        const { data } = await supabase
+            .from('agent_errors')
+            .select('error_type, message, user_response, created_at')
+            .eq('preset_id', presetId)
+            .order('created_at', { ascending: false })
+            .limit(10);
+        const hints = buildAgentRunHints((data ?? []));
+        return hints.length > 0 ? hints : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function buildPersistableProfile(previousProfile, storageState, sessionStorage, currentUrl, lang, theme) {
+    return {
+        storageState,
+        sessionStorage,
+        authState: previousProfile?.authState ?? inferAuthState(storageState, sessionStorage),
+        accountLabel: previousProfile?.accountLabel ?? null,
+        detectedLang: lang,
+        detectedTheme: theme,
+        validatedStartUrl: previousProfile?.validatedStartUrl ?? currentUrl,
+        lastKnownUrl: currentUrl,
+        summary: previousProfile?.summary ?? 'Validated browser state captured from a successful WS-driven run.',
+        validationStatus: previousProfile?.validationStatus ?? 'unknown',
+        lastUsedAt: new Date().toISOString(),
+        profileVersion: previousProfile?.profileVersion ?? 1,
+    };
+}
+export function inferAuthState(storageState, sessionStorage) {
+    const structuredStorageState = storageState && typeof storageState === 'object' && !Array.isArray(storageState)
+        ? storageState
+        : undefined;
+    const cookieCount = structuredStorageState?.cookies?.length ?? 0;
+    const originCount = structuredStorageState?.origins?.length ?? 0;
+    const sessionOriginCount = sessionStorage ? Object.keys(sessionStorage).length : 0;
+    return cookieCount > 0 || originCount > 0 || sessionOriginCount > 0
+        ? 'authenticated'
+        : 'unknown';
+}
+export function buildPreverifiedAgentResult(assessment, verification) {
+    return {
+        success: true,
+        screenshotPath: null,
+        screenshots: [],
+        iterations: 0,
+        actions: [],
+        assessment,
+        usage: verification.usage,
+        runtimeStrategy: 'preverified_handoff',
+        deterministicRecoveryUsed: false,
+        evaluatorUsed: false,
+        verification,
+    };
+}
+export function makeFailedAgentResult(message) {
+    return {
+        success: false,
+        screenshotPath: null,
+        assessment: message,
+        iterations: 0,
+        actions: [],
+        screenshots: [],
+        usage: [],
+    };
+}
+function resolvePersistedHandoffTrust(params) {
+    const agentResult = params.agentResult;
+    if (!agentResult
+        || !isTerminalAgentResultSuccess(agentResult)
+        || !isStrongCheckpointVerified(agentResult?.verification?.checkpointEvidence)) {
+        return 'degraded';
+    }
+    if (params.profile.validationStatus === 'repaired'
+        || agentResult.deterministicRecoveryUsed
+        || agentResult.evaluatorUsed
+        || agentResult.runtimeStrategy === 'action_replay'
+        || agentResult.runtimeStrategy === 'action_replay_fallback') {
+        return 'degraded';
+    }
+    return 'verified';
+}
+export async function buildHandoffContext(params) {
+    const handoffArtifacts = buildSequentialHandoffArtifacts(params.actions ?? []);
+    const trust = resolvePersistedHandoffTrust({
+        profile: params.profile,
+        agentResult: params.agentResult,
+    });
+    const derivedFromRepair = params.profile.validationStatus === 'repaired'
+        || params.agentResult?.deterministicRecoveryUsed === true
+        || params.agentResult?.evaluatorUsed === true;
+    const evidence = params.agentResult?.verification?.checkpointEvidence ?? null;
+    return {
+        previousPageId: params.pageRun.pageId,
+        previousPrompt: params.pageRun.prompt,
+        currentUrl: params.browser.currentPage.url() || params.pageRun.url,
+        pageTitle: await params.browser.currentPage.title().catch(() => null),
+        authState: params.profile.authState,
+        accountLabel: params.profile.accountLabel ?? null,
+        currentLang: params.lang,
+        currentTheme: params.theme,
+        summary: [
+            `Continue from ${params.pageRun.pageId ?? 'main'}.`,
+            `trust=${trust}`,
+            derivedFromRepair ? 'repair-derived=true' : null,
+            evidence?.strongSurfaceSignature ? `surface=${evidence.strongSurfaceSignature}` : null,
+            `url=${params.browser.currentPage.url() || params.pageRun.url}`,
+        ].filter(Boolean).join(' '),
+        selectorHints: handoffArtifacts.selectorHints,
+        navigationHints: [],
+        selectorMemory: mergeSelectorMemory(params.selectorMemory, handoffArtifacts.selectorMemory),
+        trust,
+        strongCheckpointId: null,
+        derivedFromRepair,
+    };
+}
+export async function restorePreparedPageState(browser, viewport, preparedPageUrl) {
+    await lockCaptureViewport(browser, viewport, { settleMs: 0 });
+    if (!urlsRoughlyMatch(browser.currentPage.url(), preparedPageUrl)) {
+        await browser.navigateTo(preparedPageUrl);
+    }
+    await browser.dismissOverlays().catch(() => undefined);
+    await browser.wait(250);
+}
+//# sourceMappingURL=ws-handler-utils.js.map