autokap 1.0.7 → 1.0.8

package/dist/semantic-resolver.js

@@ -0,0 +1,161 @@
+/**
+ * Capture Agent — Semantic Target Resolver
+ *
+ * Resolves a SemanticTarget to a concrete Playwright locator.
+ * This is the core mechanism that allows opcodes to work WITHOUT CSS selectors.
+ *
+ * Resolution cascade:
+ * 1. CSS selector (if provided, fast path)
+ * 2. Playwright semantic locators (getByRole, getByText, getByLabel, getByPlaceholder)
+ * 3. Selector alternates
+ * 4. Composite: role + name + near (for disambiguation)
+ *
+ * All resolution happens via Playwright's built-in locator API — no AKTree needed.
+ */
+/**
+ * Resolves an element on the page using the best available method.
+ * Returns the first visible locator found, or null if nothing matches.
+ */
+export async function resolveTarget(page, options) {
+    const timeout = options.timeoutMs ?? 3000;
+    // 1. Primary CSS selector
+    if (options.selector) {
+        const locator = page.locator(options.selector).first();
+        if (await isVisible(locator, timeout)) {
+            return { locator, method: 'selector' };
+        }
+    }
+    // 2. Semantic locators from target
+    if (options.target) {
+        const resolved = await resolveSemanticTarget(page, options.target, timeout);
+        if (resolved)
+            return resolved;
+    }
+    // 3. Alternate selectors
+    if (options.selectorAlternates) {
+        for (const alt of options.selectorAlternates) {
+            const locator = page.locator(alt).first();
+            if (await isVisible(locator, timeout)) {
+                return { locator, method: 'alternate' };
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Resolves a SemanticTarget using Playwright's semantic locator API.
+ */
+async function resolveSemanticTarget(page, target, timeout) {
+    const exact = target.exact ?? false;
+    // Strategy A: getByRole with name (most precise)
+    if (target.role && (target.text || target.label)) {
+        const name = target.label || target.text;
+        try {
+            let locator = page.getByRole(target.role, {
+                name: name,
+                exact,
+            });
+            if (target.near) {
+                locator = narrowByNear(page, locator, target.near);
+            }
+            locator = locator.first();
+            if (await isVisible(locator, timeout)) {
+                return { locator, method: 'role' };
+            }
+        }
+        catch {
+            // Invalid role or no match
+        }
+    }
+    // Strategy B: getByRole without name
+    if (target.role && !target.text && !target.label) {
+        try {
+            let locator = page.getByRole(target.role);
+            if (target.near) {
+                locator = narrowByNear(page, locator, target.near);
+            }
+            locator = locator.first();
+            if (await isVisible(locator, timeout)) {
+                return { locator, method: 'role' };
+            }
+        }
+        catch {
+            // Invalid role
+        }
+    }
+    // Strategy C: getByText
+    if (target.text) {
+        let locator = page.getByText(target.text, { exact });
+        if (target.near) {
+            locator = narrowByNear(page, locator, target.near);
+        }
+        locator = locator.first();
+        if (await isVisible(locator, timeout)) {
+            return { locator, method: 'text' };
+        }
+    }
+    // Strategy D: getByLabel
+    if (target.label) {
+        let locator = page.getByLabel(target.label, { exact });
+        if (target.near) {
+            locator = narrowByNear(page, locator, target.near);
+        }
+        locator = locator.first();
+        if (await isVisible(locator, timeout)) {
+            return { locator, method: 'label' };
+        }
+    }
+    // Strategy E: getByPlaceholder (for inputs)
+    if (target.placeholder) {
+        let locator = page.getByPlaceholder(target.placeholder, { exact });
+        if (target.near) {
+            locator = narrowByNear(page, locator, target.near);
+        }
+        locator = locator.first();
+        if (await isVisible(locator, timeout)) {
+            return { locator, method: 'placeholder' };
+        }
+    }
+    // Strategy F: Composite — try role-based with looser matching
+    if (target.role) {
+        try {
+            const allByRole = page.getByRole(target.role);
+            const count = await allByRole.count();
+            for (let i = 0; i < Math.min(count, 10); i++) {
+                const candidate = allByRole.nth(i);
+                if (await isVisible(candidate, 500)) {
+                    const text = await candidate.textContent().catch(() => null);
+                    if (text && target.text && text.toLowerCase().includes(target.text.toLowerCase())) {
+                        return { locator: candidate, method: 'composite' };
+                    }
+                }
+            }
+        }
+        catch {
+            // No match
+        }
+    }
+    return null;
+}
+/**
+ * Narrows a locator to one near a specific text/heading on the page.
+ * Uses Playwright's `.filter()` with a parent locator containing the near text.
+ */
+function narrowByNear(page, locator, nearText) {
+    // Find a section/container that contains the near text
+    const container = page.locator(`section:has-text("${escapeForSelector(nearText)}"), div:has-text("${escapeForSelector(nearText)}"), [role="region"]:has-text("${escapeForSelector(nearText)}")`).first();
+    return container.locator(locator);
+}
+async function isVisible(locator, timeout) {
+    try {
+        await locator.waitFor({ state: 'visible', timeout });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function escapeForSelector(text) {
+    return text.replace(/"/g, '\\"').replace(/\n/g, ' ');
+}
+//# sourceMappingURL=semantic-resolver.js.map

package/dist/server-capture-runtime.d.ts

@@ -1,5 +1,5 @@
 import type { SupabaseClient } from '@supabase/supabase-js';
-export type BillingPlanId = 'free' | 'starter' | 'pro' | 'business';
+export type BillingPlanId = 'free' | 'maker' | 'team';
 export interface BillingPlanEntitlements {
     creditsPerMonth: number;
     maxProjects: number | null;
@@ -16,13 +16,15 @@ export interface BillingPlanEntitlements {
     maxParallelCaptures: number;
     teamMembers: boolean;
     aiDailyCostLimitUsd: number;
-    maxApiKeys: number;
     apiRateLimitRpm: number;
+    maxDevLinks: number | null;
+    maxCompositions: number | null;
+    maxTeamMembersPerProject: number | null;
 }
 export interface BillingPlan {
     id: BillingPlanId;
     nameKey: BillingPlanId;
-    descriptionKey: 'forEvaluation' | 'forSoloOperators' | 'forProductTeams' | 'forOperationsHeavyTeams';
+    descriptionKey: 'forEvaluation' | 'forMakers' | 'forTeams';
     monthlyPriceEur: number;
     yearlyPriceEur: number;
     highlighted?: boolean;

package/dist/server-capture-runtime.js

@@ -11,9 +11,8 @@ export class PlanLimitError extends Error {
 export const SCREENSHOT_CREDIT_COST = 1;
 const CREDIT_OVERAGE_CENTS = {
     free: 0,
-    starter: 6,
-    pro: 5,
-    business: 4,
+    maker: 6,
+    team: 5,
 };
 const STRIPE_ACTIVE_STATUSES = new Set(['active', 'trialing', 'past_due']);
 const BILLING_PLANS = [
@@ -24,11 +23,11 @@ const BILLING_PLANS = [
         monthlyPriceEur: 0,
         yearlyPriceEur: 0,
         previewCurrent: true,
-        highlights: ['credits', 'projects', 'presets', 'captureMode', 'retention'],
+        highlights: ['credits', 'projects', 'devLinks', 'retention', 'support'],
         entitlements: {
-            creditsPerMonth: 10,
+            creditsPerMonth: 25,
             maxProjects: 1,
-            maxPresetsPerProject: 3,
+            maxPresetsPerProject: 2,
             allowFullPageCapture: true,
             allowElementCapture: true,
             retentionDays: 7,
@@ -41,22 +40,24 @@ const BILLING_PLANS = [
             maxParallelCaptures: 1,
             teamMembers: false,
             aiDailyCostLimitUsd: 0.05,
-            maxApiKeys: 2,
             apiRateLimitRpm: 10,
+            maxDevLinks: 1,
+            maxCompositions: 2,
+            maxTeamMembersPerProject: null,
         },
     },
     {
-        id: 'starter',
-        nameKey: 'starter',
-        descriptionKey: 'forSoloOperators',
-        monthlyPriceEur: 19,
-        yearlyPriceEur: 190,
+        id: 'maker',
+        nameKey: 'maker',
+        descriptionKey: 'forMakers',
+        monthlyPriceEur: 15,
+        yearlyPriceEur: 144,
         highlighted: true,
-        highlights: ['credits', 'projects', 'presets', 'captureMode', 'retention'],
+        highlights: ['credits', 'projects', 'devLinks', 'retention', 'parallelCaptures', 'captureCompleteWebhook', 'support'],
         entitlements: {
-            creditsPerMonth: 300,
+            creditsPerMonth: 100,
             maxProjects: 3,
-            maxPresetsPerProject: 10,
+            maxPresetsPerProject: 5,
             allowFullPageCapture: true,
             allowElementCapture: true,
             retentionDays: 30,
@@ -64,24 +65,26 @@ const BILLING_PLANS = [
             maxLanguages: null,
             maxThemes: null,
             apiAccess: true,
-            captureCompleteWebhook: false,
+            captureCompleteWebhook: true,
             priorityQueue: false,
-            maxParallelCaptures: 1,
+            maxParallelCaptures: 2,
             teamMembers: false,
-            aiDailyCostLimitUsd: 0.1,
-            maxApiKeys: 5,
+            aiDailyCostLimitUsd: 0.10,
             apiRateLimitRpm: 60,
+            maxDevLinks: 10,
+            maxCompositions: 10,
+            maxTeamMembersPerProject: null,
         },
     },
     {
-        id: 'pro',
-        nameKey: 'pro',
-        descriptionKey: 'forProductTeams',
-        monthlyPriceEur: 59,
-        yearlyPriceEur: 590,
-        highlights: ['credits', 'projects', 'presets', 'retention', 'captureCompleteWebhook'],
+        id: 'team',
+        nameKey: 'team',
+        descriptionKey: 'forTeams',
+        monthlyPriceEur: 49,
+        yearlyPriceEur: 468,
+        highlights: ['credits', 'projects', 'devLinks', 'retention', 'parallelCaptures', 'teamMembers', 'priorityQueue', 'support'],
         entitlements: {
-            creditsPerMonth: 1000,
+            creditsPerMonth: 500,
             maxProjects: null,
             maxPresetsPerProject: null,
             allowFullPageCapture: true,
@@ -92,48 +95,14 @@ const BILLING_PLANS = [
             maxThemes: null,
             apiAccess: true,
             captureCompleteWebhook: true,
-            priorityQueue: false,
-            maxParallelCaptures: 1,
-            teamMembers: false,
-            aiDailyCostLimitUsd: 0.15,
-            maxApiKeys: 10,
-            apiRateLimitRpm: 120,
-        },
-    },
-    {
-        id: 'business',
-        nameKey: 'business',
-        descriptionKey: 'forOperationsHeavyTeams',
-        monthlyPriceEur: 149,
-        yearlyPriceEur: 1490,
-        highlights: [
-            'credits',
-            'projects',
-            'presets',
-            'retention',
-            'captureCompleteWebhook',
-            'priorityQueue',
-            'parallelCaptures',
-            'teamMembers',
-        ],
-        entitlements: {
-            creditsPerMonth: 2500,
-            maxProjects: null,
-            maxPresetsPerProject: null,
-            allowFullPageCapture: true,
-            allowElementCapture: true,
-            retentionDays: 365,
-            watermarkScreenshots: false,
-            maxLanguages: null,
-            maxThemes: null,
-            apiAccess: true,
-            captureCompleteWebhook: true,
             priorityQueue: true,
-            maxParallelCaptures: 4,
+            maxParallelCaptures: 5,
             teamMembers: true,
             aiDailyCostLimitUsd: 0.15,
-            maxApiKeys: 25,
-            apiRateLimitRpm: 300,
+            apiRateLimitRpm: 200,
+            maxDevLinks: null,
+            maxCompositions: null,
+            maxTeamMembersPerProject: 5,
         },
     },
 ];
@@ -145,31 +114,19 @@ export function coerceBillingPlanId(value) {
         return null;
     switch (value) {
         case 'free':
-        case 'starter':
-        case 'pro':
-        case 'business':
+        case 'maker':
+        case 'team':
             return value;
         default:
             return null;
     }
 }
-function getMetadataBillingPlanId(user) {
-    const metadata = user?.user_metadata;
-    if (!metadata)
-        return null;
-    for (const key of ['billingPlan', 'billing_plan', 'plan']) {
-        const planId = coerceBillingPlanId(metadata[key]);
-        if (planId)
-            return planId;
-    }
-    return null;
-}
 function getServerDefaultBillingPlanId() {
     return (coerceBillingPlanId(process.env.DEFAULT_BILLING_PLAN)
         ?? coerceBillingPlanId(process.env.NEXT_PUBLIC_DEFAULT_BILLING_PLAN)
         ?? 'free');
 }
-function resolvePlanFromBillingAccount(account, metadataPlanId, defaultPlanId) {
+function resolvePlanFromBillingAccount(account, defaultPlanId) {
     const adminPlanId = coerceBillingPlanId(account?.admin_override_plan_id);
     if (adminPlanId) {
         return { planId: adminPlanId, source: 'admin_override' };
@@ -178,9 +135,6 @@ function resolvePlanFromBillingAccount(account, metadataPlanId, defaultPlanId) {
     if (stripePlanId && shouldUseStripePlan(account?.stripe_subscription_status)) {
         return { planId: stripePlanId, source: 'stripe' };
     }
-    if (metadataPlanId) {
-        return { planId: metadataPlanId, source: 'metadata' };
-    }
     return { planId: defaultPlanId, source: 'default' };
 }
 export async function getBillingAccountForUser(supabase, userId) {
@@ -198,13 +152,8 @@ export async function getBillingAccountForUser(supabase, userId) {
     return data ?? null;
 }
 async function getResolvedBillingPlanForUserId(supabase, userId) {
-    const { data, error } = await supabase.auth.admin.getUserById(userId);
-    if (error) {
-        throw new Error(`Failed to load user billing plan: ${error.message}`);
-    }
-    const metadataPlanId = getMetadataBillingPlanId(data.user);
     const account = await getBillingAccountForUser(supabase, userId);
-    const resolved = resolvePlanFromBillingAccount(account, metadataPlanId, getServerDefaultBillingPlanId());
+    const resolved = resolvePlanFromBillingAccount(account, getServerDefaultBillingPlanId());
     return getBillingPlan(resolved.planId);
 }
 export async function getProjectOwnerBillingContext(supabase, projectId) {
@@ -234,12 +183,10 @@ export function isYearlySubscription(account) {
 }
 export function getStripeOveragePriceIdForPlan(planId) {
     switch (planId) {
-        case 'starter':
-            return process.env.STRIPE_PRICE_ID_STARTER_OVERAGE ?? null;
-        case 'pro':
-            return process.env.STRIPE_PRICE_ID_PRO_OVERAGE ?? null;
-        case 'business':
-            return process.env.STRIPE_PRICE_ID_BUSINESS_OVERAGE ?? null;
+        case 'maker':
+            return process.env.STRIPE_PRICE_ID_MAKER_OVERAGE ?? null;
+        case 'team':
+            return process.env.STRIPE_PRICE_ID_TEAM_OVERAGE ?? null;
         case 'free':
             return null;
     }

package/dist/server-credit-usage.d.ts

@@ -1,8 +1,8 @@
 import type { SupabaseClient } from '@supabase/supabase-js';
-export type CreditUsageType = 'screenshot' | 'clip' | 'video' | 'preset_analysis' | 'ai_chat';
+export type CreditUsageType = 'screenshot' | 'clip' | 'video' | 'preset_analysis' | 'ai_chat' | 'interactive_demo_state';
 export declare function recordCreditUsage(supabase: SupabaseClient, params: {
     userId: string;
-    projectId: string;
+    projectId: string | null;
     presetId?: string | null;
     type: CreditUsageType;
     credits: number;

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

@@ -29,7 +29,20 @@ export interface CaptureWebhookPayload {
     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;
@@ -37,9 +50,10 @@ export declare function buildCaptureWebhookPayload(params: {
     presetId?: string | null;
     completedAt?: string;
     results: CaptureWebhookPayloadResult[];
+    affectedEndpointIds?: string[];
 }): CaptureWebhookPayload;
 export declare function dispatchProjectCaptureWebhook(params: {
     config: ProjectWebhookConfig;
-    payload: CaptureWebhookPayload;
+    payload: WebhookPayload;
 }): Promise<void>;
 export declare function encryptProjectWebhookSigningSecret(plaintext: string): string;

package/dist/server-project-webhooks.js

@@ -64,8 +64,11 @@ export function buildCaptureWebhookPayload(params) {
             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();
@@ -81,15 +84,38 @@ export async function dispatchProjectCaptureWebhook(params) {
             .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)}` : ''}`);
+    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()));

package/dist/server-screenshot-watermark.js

@@ -7,11 +7,18 @@ function escapeXml(value) {
         .replaceAll('"', '"')
         .replaceAll('\'', ''');
 }
-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;
+/** 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);
@@ -27,6 +34,21 @@ export async function applyScreenshotWatermark(buffer, label = 'AutoKap Free') {
         ${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) {