autokap 1.0.6 → 1.0.7

package/dist/server-posthog.js

@@ -0,0 +1,16 @@
+import { PostHog } from 'posthog-node';
+let client = null;
+export function getServerPostHog() {
+    const key = process.env.POSTHOG_API_KEY;
+    if (!key)
+        return null;
+    if (!client) {
+        client = new PostHog(key, {
+            host: process.env.POSTHOG_HOST ?? 'https://eu.i.posthog.com',
+            flushAt: 5,
+            flushInterval: 10_000,
+        });
+    }
+    return client;
+}
+//# sourceMappingURL=server-posthog.js.map

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

@@ -0,0 +1,45 @@
+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[];
+}
+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[];
+}): CaptureWebhookPayload;
+export declare function dispatchProjectCaptureWebhook(params: {
+    config: ProjectWebhookConfig;
+    payload: CaptureWebhookPayload;
+}): Promise<void>;
+export declare function encryptProjectWebhookSigningSecret(plaintext: string): string;

package/dist/server-project-webhooks.js

@@ -0,0 +1,97 @@
+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,
+        })),
+    };
+}
+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;
+    }
+    const response = await fetch(params.config.url, {
+        method: 'POST',
+        headers,
+        body,
+    });
+    if (!response.ok) {
+        const responseText = await response.text().catch(() => '');
+        throw new Error(`Webhook responded with ${response.status}${responseText ? `: ${responseText.slice(0, 300)}` : ''}`);
+    }
+}
+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,38 @@
+import sharp from 'sharp';
+function escapeXml(value) {
+    return value
+        .replaceAll('&', '&')
+        .replaceAll('<', '&lt;')
+        .replaceAll('>', '&gt;')
+        .replaceAll('"', '&quot;')
+        .replaceAll('\'', '&apos;');
+}
+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 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>`);
+    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[];