autokap 1.0.6 → 1.0.8

package/dist/server-project-webhooks.d.ts

@@ -0,0 +1,59 @@
+import type { SupabaseClient } from '@supabase/supabase-js';
+export interface ProjectWebhookConfig {
+    project_id: string;
+    url: string;
+    signing_secret: string | null;
+    created_at: string;
+    updated_at: string;
+}
+export interface CaptureWebhookPayloadResult {
+    url: string;
+    lang: string;
+    theme: 'light' | 'dark';
+    captureType?: 'fullpage' | 'element';
+    elementName?: string;
+    targetId?: string;
+    targetLabel?: string;
+    deviceFrame?: string;
+    success: boolean;
+    assessment: string;
+    iterations: number;
+    finalScreenshotUrl?: string;
+}
+export interface CaptureWebhookPayload {
+    event: 'capture.completed';
+    run_id: string;
+    project_id: string;
+    preset_id: string | null;
+    completed_at: string;
+    total_captures: number;
+    success_count: number;
+    results: CaptureWebhookPayloadResult[];
+    /** IDs of screenshot_endpoints affected by this capture run (for proxy cache invalidation). */
+    affected_endpoint_ids: string[];
+}
+export interface EndpointChangedWebhookPayload {
+    event: 'endpoint.changed';
+    project_id: string;
+    preset_id: string | null;
+    timestamp: string;
+    created_endpoint_ids: string[];
+    deleted_endpoint_ids: string[];
+    /** Full list of currently active endpoint IDs for the project. */
+    current_endpoint_ids: string[];
+}
+export type WebhookPayload = CaptureWebhookPayload | EndpointChangedWebhookPayload;
+export declare function getProjectWebhookConfig(supabase: SupabaseClient, projectId: string): Promise<ProjectWebhookConfig | null>;
+export declare function buildCaptureWebhookPayload(params: {
+    runId: string;
+    projectId: string;
+    presetId?: string | null;
+    completedAt?: string;
+    results: CaptureWebhookPayloadResult[];
+    affectedEndpointIds?: string[];
+}): CaptureWebhookPayload;
+export declare function dispatchProjectCaptureWebhook(params: {
+    config: ProjectWebhookConfig;
+    payload: WebhookPayload;
+}): Promise<void>;
+export declare function encryptProjectWebhookSigningSecret(plaintext: string): string;

package/dist/server-project-webhooks.js

@@ -0,0 +1,123 @@
+import crypto from 'node:crypto';
+import { decrypt, encrypt, isEncryptedEnvelope, } from './capture-encryption.js';
+function getWebhookEncryptionSecret() {
+    const secret = process.env.WEBHOOK_SECRET_ENCRYPTION_SECRET;
+    if (!secret) {
+        throw new Error('Missing WEBHOOK_SECRET_ENCRYPTION_SECRET for webhook secret encryption');
+    }
+    return secret;
+}
+function decryptSigningSecret(stored) {
+    if (!stored)
+        return null;
+    try {
+        const parsed = JSON.parse(stored);
+        if (isEncryptedEnvelope(parsed)) {
+            return decrypt(parsed, getWebhookEncryptionSecret());
+        }
+    }
+    catch {
+        // Plaintext fallback for legacy rows.
+    }
+    return stored;
+}
+export async function getProjectWebhookConfig(supabase, projectId) {
+    const { data, error } = await supabase
+        .from('project_webhooks')
+        .select('*')
+        .eq('project_id', projectId)
+        .maybeSingle();
+    if (error) {
+        if (error.code === '42P01') {
+            return null;
+        }
+        throw new Error(error.message);
+    }
+    if (!data)
+        return null;
+    const config = data;
+    return {
+        ...config,
+        signing_secret: decryptSigningSecret(config.signing_secret),
+    };
+}
+export function buildCaptureWebhookPayload(params) {
+    return {
+        event: 'capture.completed',
+        run_id: params.runId,
+        project_id: params.projectId,
+        preset_id: params.presetId ?? null,
+        completed_at: params.completedAt ?? new Date().toISOString(),
+        total_captures: params.results.length,
+        success_count: params.results.filter((result) => result.success).length,
+        results: params.results.map((result) => ({
+            url: result.url,
+            lang: result.lang,
+            theme: result.theme,
+            captureType: result.captureType,
+            elementName: result.elementName,
+            targetId: result.targetId,
+            targetLabel: result.targetLabel,
+            deviceFrame: result.deviceFrame,
+            success: result.success,
+            assessment: result.assessment,
+            iterations: result.iterations,
+            finalScreenshotUrl: result.finalScreenshotUrl,
+        })),
+        affected_endpoint_ids: params.affectedEndpointIds ?? [],
+    };
+}
+const WEBHOOK_RETRY_DELAYS = [0, 1_000, 3_000, 9_000];
+const WEBHOOK_TIMEOUT_MS = 10_000;
+export async function dispatchProjectCaptureWebhook(params) {
+    const body = JSON.stringify(params.payload);
+    const timestamp = Math.floor(Date.now() / 1000).toString();
+    const headers = {
+        'Content-Type': 'application/json',
+        'X-AutoKap-Event': params.payload.event,
+        'X-AutoKap-Timestamp': timestamp,
+    };
+    if (params.config.signing_secret) {
+        const signature = crypto
+            .createHmac('sha256', params.config.signing_secret)
+            .update(`${timestamp}.${body}`, 'utf8')
+            .digest('hex');
+        headers['X-AutoKap-Signature'] = signature;
+    }
+    let lastError = null;
+    for (let attempt = 0; attempt < WEBHOOK_RETRY_DELAYS.length; attempt++) {
+        if (attempt > 0) {
+            await new Promise((resolve) => setTimeout(resolve, WEBHOOK_RETRY_DELAYS[attempt]));
+        }
+        try {
+            const response = await fetch(params.config.url, {
+                method: 'POST',
+                headers,
+                body,
+                signal: AbortSignal.timeout(WEBHOOK_TIMEOUT_MS),
+            });
+            if (response.ok)
+                return;
+            // Don't retry on 4xx client errors (except 429 rate limiting)
+            if (response.status >= 400 && response.status < 500 && response.status !== 429) {
+                const responseText = await response.text().catch(() => '');
+                throw new Error(`Webhook responded with ${response.status}${responseText ? `: ${responseText.slice(0, 300)}` : ''}`);
+            }
+            // 5xx or 429 — retry
+            const responseText = await response.text().catch(() => '');
+            lastError = new Error(`Webhook responded with ${response.status}${responseText ? `: ${responseText.slice(0, 300)}` : ''}`);
+        }
+        catch (error) {
+            lastError = error;
+            // Network errors and timeouts are retryable
+            if (error.name === 'AbortError') {
+                lastError = new Error(`Webhook timed out after ${WEBHOOK_TIMEOUT_MS}ms`);
+            }
+        }
+    }
+    throw lastError ?? new Error('Webhook delivery failed after retries');
+}
+export function encryptProjectWebhookSigningSecret(plaintext) {
+    return JSON.stringify(encrypt(plaintext, getWebhookEncryptionSecret()));
+}
+//# sourceMappingURL=server-project-webhooks.js.map

package/dist/server-screenshot-watermark.d.ts

@@ -0,0 +1,7 @@
+export interface WatermarkBillingPlan {
+    entitlements: {
+        watermarkScreenshots: boolean;
+    };
+}
+export declare function applyScreenshotWatermark(buffer: Buffer, label?: string): Promise<Buffer>;
+export declare function applyPlanScreenshotWatermark(plan: WatermarkBillingPlan, buffer: Buffer): Promise<Buffer>;

package/dist/server-screenshot-watermark.js

@@ -0,0 +1,60 @@
+import sharp from 'sharp';
+function escapeXml(value) {
+    return value
+        .replaceAll('&', '&')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;')
+        .replaceAll('"', '&quot;')
+        .replaceAll('\'', '&apos;');
+}
+/** LRU cache for watermark SVG overlays — avoids regenerating tiles for repeated dimensions. */
+const SVG_CACHE_MAX = 20;
+const svgOverlayCache = new Map();
+function getOrBuildSvgOverlay(width, height, label) {
+    const cacheKey = `${width}:${height}:${label}`;
+    const cached = svgOverlayCache.get(cacheKey);
+    if (cached) {
+        // Move to end (LRU refresh)
+        svgOverlayCache.delete(cacheKey);
+        svgOverlayCache.set(cacheKey, cached);
+        return cached;
+    }
+    const fontSize = Math.max(18, Math.round(Math.min(width, height) * 0.035));
+    const tileGap = fontSize * 4;
+    const safeLabel = escapeXml(label);
+    const tiles = [];
+    for (let y = -height; y < height * 2; y += tileGap) {
+        for (let x = -width; x < width * 2; x += tileGap * 1.6) {
+            tiles.push(`<text x="${x}" y="${y}" fill="rgba(255,255,255,0.18)" font-family="Arial, sans-serif" font-size="${fontSize}" font-weight="700">${safeLabel}</text>`);
+        }
+    }
+    const overlay = Buffer.from(`<svg width="${width}" height="${height}" viewBox="0 0 ${width} ${height}" xmlns="http://www.w3.org/2000/svg">
+      <rect x="0" y="0" width="${width}" height="${height}" fill="rgba(0,0,0,0.02)" />
+      <g transform="rotate(-24 ${width / 2} ${height / 2})">
+        ${tiles.join('')}
+      </g>
+    </svg>`);
+    // Evict oldest entry if cache is full
+    if (svgOverlayCache.size >= SVG_CACHE_MAX) {
+        const firstKey = svgOverlayCache.keys().next().value;
+        if (firstKey !== undefined)
+            svgOverlayCache.delete(firstKey);
+    }
+    svgOverlayCache.set(cacheKey, overlay);
+    return overlay;
+}
+export async function applyScreenshotWatermark(buffer, label = 'AutoKap Free') {
+    const image = sharp(buffer);
+    const metadata = await image.metadata();
+    const width = metadata.width ?? 1440;
+    const height = metadata.height ?? 900;
+    const overlay = getOrBuildSvgOverlay(width, height, label);
+    return image.composite([{ input: overlay }]).png().toBuffer();
+}
+export async function applyPlanScreenshotWatermark(plan, buffer) {
+    if (!plan.entitlements.watermarkScreenshots) {
+        return buffer;
+    }
+    return applyScreenshotWatermark(buffer);
+}
+//# sourceMappingURL=server-screenshot-watermark.js.map

package/dist/session-profile.d.ts

@@ -0,0 +1,86 @@
+import { Browser } from './browser.js';
+import type { AgentContextEntry, AgentRunHint, LoginCredentials, SessionProfileAuthState, SessionValidationDiagnostic, SessionValidationDiagnosticConfidence, SessionProfileValidationStatus, ValidatedSessionProfile, VideoPageSignals } from './types.js';
+export interface SessionValidationResult {
+    validationStatus: Exclude<SessionProfileValidationStatus, 'repaired'>;
+    authState: SessionProfileAuthState;
+    authMatches: boolean;
+    langMatches: boolean | null;
+    themeMatches: boolean | null;
+    urlMatches: boolean;
+    authDiagnostic: SessionValidationDiagnostic;
+    langDiagnostic: SessionValidationDiagnostic;
+    themeDiagnostic: SessionValidationDiagnostic;
+    urlDiagnostic: SessionValidationDiagnostic;
+    detectedLang: string | null;
+    detectedTheme: 'light' | 'dark' | null;
+    accountLabel: string | null;
+    issues: Array<'auth' | 'lang' | 'theme' | 'url'>;
+    summary: string;
+}
+export interface RequestedLanguageState {
+    requested: string | null;
+    detected: string | null;
+    active: boolean;
+    ambiguous: boolean;
+    confidence: SessionValidationDiagnosticConfidence;
+    reasons: string[];
+}
+export interface RequestedThemeState {
+    requested: 'light' | 'dark' | null;
+    detected: 'light' | 'dark' | null;
+    active: boolean;
+    ambiguous: boolean;
+    confidence: SessionValidationDiagnosticConfidence;
+    reasons: string[];
+}
+export interface DeterministicSelectorUpdate {
+    stepSignature: string;
+    selector: string;
+    source: 'deterministic';
+    success: boolean;
+}
+export declare function evaluateRequestedLanguageState(params: {
+    currentUrl: string;
+    requestedLang?: string;
+    signals: VideoPageSignals;
+}): RequestedLanguageState;
+export declare function evaluateRequestedThemeState(params: {
+    requestedTheme?: 'light' | 'dark';
+    signals: VideoPageSignals;
+}): RequestedThemeState;
+export declare function buildAgentRunHints(entries: AgentContextEntry[]): AgentRunHint[];
+export declare function validateSessionProfile(params: {
+    currentUrl: string;
+    startUrl?: string;
+    requestedLang?: string;
+    requestedTheme?: 'light' | 'dark';
+    signals: VideoPageSignals;
+    profile?: ValidatedSessionProfile;
+}): SessionValidationResult;
+export declare function collectValidatedSessionProfile(browser: Browser, params: {
+    requestedLang?: string;
+    requestedTheme?: 'light' | 'dark';
+    startUrl?: string;
+    existingProfile?: ValidatedSessionProfile;
+    includeStorageSnapshots?: boolean;
+}): Promise<{
+    profile: ValidatedSessionProfile;
+    validation: SessionValidationResult;
+}>;
+export declare function performDeterministicSessionRepair(browser: Browser, params: {
+    startUrl?: string;
+    requestedLang?: string;
+    requestedTheme?: 'light' | 'dark';
+    credentials?: LoginCredentials;
+    profile?: ValidatedSessionProfile;
+    selectorMemory?: Record<string, string[]>;
+}): Promise<{
+    repaired: boolean;
+    validation: SessionValidationResult;
+    pathUsed: string | null;
+    updates: DeterministicSelectorUpdate[];
+}>;
+export declare function buildProfileSelectorUpdates(signals: VideoPageSignals, params: {
+    requestedLang?: string;
+    requestedTheme?: 'light' | 'dark';
+}): DeterministicSelectorUpdate[];