autokap 1.0.7 → 1.0.8

package/dist/ws-handler.js

@@ -6,33 +6,43 @@
  * so the WS flow does not drift from the HTTP capture flow.
  */
 import crypto from 'node:crypto';
+import os from 'node:os';
+import path from 'node:path';
 import { chromium } from 'playwright';
 import { replayAgent, runAgent, verifyCaptureReadiness } from './agent.js';
-import { buildAgentRunHints } from './session-profile.js';
+import { performDeterministicSessionRepair } from './session-profile.js';
 import { captureIsolatedElement } from './element-capture.js';
-import { getCapturePromptValidationError, getCaptureUrlHostname, resolveCaptureRequestPlan, sanitizeStorageSegment, urlsPointToSameCaptureState, } from './capture-request-plan.js';
+import { getCapturePromptValidationError, getCaptureUrlHostname, resolveCaptureRequestPlan, sanitizeStorageSegment, } from './capture-request-plan.js';
+import { lockCaptureViewport, takeViewportLockedScreenshot, } from './capture-viewport-lock.js';
+import { CHROMIUM_ARGS } from './browser-pool.js';
 import { insertCostLogs, resolveAllCosts, updateCostLogCaptureContext, } from './cost-logging.js';
 import { insertScreenshotOperationLog, reconcilePendingBillingOperationCosts, } from './billing-operation-logging.js';
 import { generateAltText } from './capture-alt-text.js';
 import { ensureScreenshotVariantLanguage } from './capture-language-preflight.js';
 import { inferPageIdentitiesWithLLM } from './capture-llm-page-identity.js';
 import { resolveRunModels } from './capture-model-resolution.js';
+import { decideCaptureTransition } from './capture-transition-engine.js';
 import { extractSelectorUpdates, loadScreenshotSelectorMemory, persistScreenshotSelectorMemoryUpdates, } from './capture-selector-memory.js';
 import { hydratePresetConfigFromStorage } from './capture-preset-credentials.js';
-import { applySelectorMemoryUpdates, buildSequentialHandoffArtifacts, buildSessionBootstrapProfile, deriveRunSharedAuthProfile, getUrlOrigin, mergeSelectorMemory, resolveIsolatedElementAssignments, resolveScopedSelectorMemory, scopeSelectorMemoryUpdates, shouldReuseLivePageState, shouldUseSequentialPageHandoff, urlMatchesCaptureTarget, } from './capture-run-optimizer.js';
+import { applySelectorMemoryUpdates, buildSessionBootstrapProfile, deriveRunSharedAuthProfile, getUrlOrigin, mergeSelectorMemory, resolveIsolatedElementAssignments, resolveScopedSelectorMemory, scopeSelectorMemoryUpdates, shouldNormalizeDialogsBeforeTargetReuse, urlMatchesCaptureTarget, } from './capture-run-optimizer.js';
 import { decryptSessionField, encryptSessionField, } from './capture-session-profile-encryption.js';
 import { buildVariantManifestContext, createVariantCaptureState, markVariantCaptureBlocked, markVariantCaptureInProgress, recordValidatedVariantCapture, validateVariantCaptureState, } from './capture-variant-state.js';
 import { syncStudioVariantAfterCapture } from './capture-studio-sync.js';
 import { applyDeviceFrame, invalidateDeviceConfigCache } from './mockup.js';
 import { localizeStatusBar } from './status-bar-l10n.js';
-import { logger } from './logger.js';
+import { logger, runWithLoggerCallbacks } from './logger.js';
+import { createCaptureBroadcast } from './ws-broadcast.js';
+import { APP_VERSION } from './version.js';
+import { isTerminalAgentResultSuccess, isTerminalVerificationSuccess, } from './types.js';
+import { buildHandoffContext, buildPersistableProfile, buildPreverifiedAgentResult, loadRunHints, makeFailedAgentResult, restorePreparedPageState, } from './ws-handler-utils.js';
 import { getRemoteBrowserCompatibilityError, RemoteBrowser, } from './remote-browser.js';
-import { recordCreditUsage } from './server-credit-usage.js';
+import { recordCreditUsage, revokeCreditUsage } from './server-credit-usage.js';
 import { cleanupExpiredCapturesForOwner, ensureCaptureConfigAllowed, ensureMonthlyCreditsQuota, ensureResourceNotLocked, getBillingAccountForUser, getCaptureOverageState, getBillingPlan, getIncrementalOverageCount, getLockedResourceIds, getOwnerBillingUsage, getProjectOwnerBillingContext, getRemainingOverageCredits, getSignupBonusCredits, getStripeOveragePriceIdForPlan, isYearlySubscription, PlanLimitError, recordStripeMeterEvent, SCREENSHOT_CREDIT_COST, shouldUseStripePlan, } from './server-capture-runtime.js';
 import { buildCaptureWebhookPayload, dispatchProjectCaptureWebhook, getProjectWebhookConfig, } from './server-project-webhooks.js';
 import { getServerPostHog } from './server-posthog.js';
 import { applyPlanScreenshotWatermark } from './server-screenshot-watermark.js';
 import { validateApiKey, requireScope, getSupabase } from './ws-auth.js';
+import { getUserConnectionCount, trackUserConnection, untrackUserConnection, } from './ws-connection-limits.js';
 const BUCKET = 'screenshots';
 function getOpenRouterKey() {
     const key = process.env.OPENROUTER_API_KEY ?? '';
@@ -74,7 +84,7 @@ async function waitForClientHello(ws, timeoutMs = 3_000) {
                     return;
                 settled = true;
                 cleanup();
-                resolve(parsed.client);
+                resolve({ client: parsed.client, apiKey: parsed.apiKey });
             }
             catch {
                 // Ignore non-JSON or non-hello messages until timeout.
@@ -87,14 +97,16 @@ async function waitForClientHello(ws, timeoutMs = 3_000) {
 }
 export async function handleConnection(ws, req) {
     const url = new URL(req.url ?? '/', `http://${req.headers.host ?? 'localhost'}`);
-    const rawKey = url.searchParams.get('key') ?? '';
     const presetId = url.searchParams.get('preset_id') ?? '';
-    const clientHelloPromise = waitForClientHello(ws);
     const sendEvent = (type, data) => {
         if (ws.readyState === ws.OPEN) {
             ws.send(JSON.stringify({ type, ...data }));
         }
     };
+    // Wait for client_hello which now carries the API key (protocol v3+).
+    // Fall back to query param for older CLIs during transition.
+    const clientHello = await waitForClientHello(ws);
+    const rawKey = clientHello?.apiKey ?? url.searchParams.get('key') ?? '';
     const auth = await validateApiKey(rawKey);
     if (!auth) {
         sendEvent('error', { message: 'Invalid API key' });
@@ -121,7 +133,7 @@ export async function handleConnection(ws, req) {
         .eq('id', presetId)
         .single();
     if (presetError || !preset) {
-        sendEvent('error', { message: `Preset not found: ${presetId}` });
+        sendEvent('error', { message: 'Preset not found' });
         ws.close(4004, 'Preset not found');
         return;
     }
@@ -140,13 +152,14 @@ export async function handleConnection(ws, req) {
         ws.close(4003, 'Forbidden');
         return;
     }
-    const clientInfo = await clientHelloPromise;
+    const clientInfo = clientHello?.client ?? null;
     const compatibilityError = getRemoteBrowserCompatibilityError(clientInfo);
     if (compatibilityError) {
         sendEvent('error', { message: compatibilityError });
         ws.close(4000, 'CLI update required');
         return;
     }
+    logger.info(`[capture] cli-version: ${clientInfo?.version ?? 'unknown'}, app-version: ${APP_VERSION}`);
     const config = hydratePresetConfigFromStorage(preset.config);
     const projectUrl = String(project.url ?? '');
     const planInput = {
@@ -161,18 +174,14 @@ export async function handleConnection(ws, req) {
         return;
     }
     invalidateDeviceConfigCache();
-    const { pageRuns: pages, pageDefinitionIssues, langs, themes, variantPlan, targets, elements, outputScale, totalCaptures, } = await resolveCaptureRequestPlan(planInput);
-    if (pageDefinitionIssues.length > 0) {
-        sendEvent('error', {
-            message: pageDefinitionIssues.map((issue) => issue.reason).join(' '),
-        });
-        ws.close(4000, 'Ambiguous capture pages');
-        return;
-    }
+    const { pageRuns: pages, langs, themes, variantPlan, targets, elements, outputScale, totalCaptures, } = await resolveCaptureRequestPlan(planInput);
     sendEvent('progress', { message: `Loaded preset "${preset.name}" for ${projectUrl}` });
     let resolvedModel = '';
     let resolvedFallback;
     let resolvedVisionModel;
+    let enableGeminiExplicitCache = false;
+    let enableCacheLayoutV2 = false;
+    let useVisionModelForAuxTasks = false;
     const providerPreferences = {};
     try {
         const { data: cfgRows } = await supabase
@@ -181,6 +190,7 @@ export async function handleConnection(ws, req) {
             .in('key', [
             'default_model', 'fallback_model', 'vision_model',
             'default_model_provider', 'fallback_model_provider', 'vision_model_provider',
+            'enable_gemini_explicit_cache', 'enable_cache_layout_v2', 'use_vision_model_for_aux_tasks',
         ]);
         const cfg = {};
         for (const row of cfgRows ?? [])
@@ -208,6 +218,9 @@ export async function handleConnection(ws, req) {
                 // Ignore invalid provider preference JSON.
             }
         }
+        enableGeminiExplicitCache = cfg.enable_gemini_explicit_cache === '1';
+        enableCacheLayoutV2 = cfg.enable_cache_layout_v2 === '1';
+        useVisionModelForAuxTasks = cfg.use_vision_model_for_aux_tasks === '1';
     }
     catch {
         // Non-blocking: the app_config table may be missing during bootstrap.
@@ -227,6 +240,18 @@ export async function handleConnection(ws, req) {
         const billingContext = await getProjectOwnerBillingContext(supabase, project.id);
         plan = billingContext.plan;
         billingOwnerUserId = billingContext.ownerUserId;
+        // Enforce per-user concurrent connection limit based on plan
+        const maxParallel = plan.entitlements.maxParallelCaptures;
+        const currentConns = getUserConnectionCount(auth.userId);
+        if (currentConns >= maxParallel) {
+            sendEvent('error', {
+                message: `Concurrent capture limit reached (${maxParallel}). Upgrade your plan for more parallel captures.`,
+            });
+            ws.close(4029, 'Concurrent capture limit reached');
+            return;
+        }
+        trackUserConnection(auth.userId, ws);
+        ws.on('close', () => untrackUserConnection(auth.userId, ws));
         const lockState = await getLockedResourceIds(supabase, billingOwnerUserId, plan);
         ensureResourceNotLocked(project.id, lockState.lockedProjectIds, 'project');
         const lockedPresets = lockState.lockedPresetIdsByProject.get(project.id);
@@ -295,16 +320,71 @@ export async function handleConnection(ws, req) {
         started_at: runStartedAt,
     });
     if (runInsertError) {
-        sendEvent('error', { message: `Failed to create run: ${runInsertError.message}` });
+        logger.error(`[capture] Failed to create run: ${runInsertError.message}`);
+        sendEvent('error', { message: 'Failed to create capture run' });
         ws.close(5000, 'Internal error');
         return;
     }
+    // ── Live broadcast bridge ─────────────────────────────────────────
+    const broadcast = createCaptureBroadcast(runId, supabase);
+    const appUrl = process.env.NEXT_PUBLIC_APP_URL ?? process.env.APP_URL ?? '';
+    if (appUrl) {
+        sendEvent('live_url', { url: `${appUrl}/capture/live?runId=${runId}` });
+    }
+    broadcast.send({ type: 'run_id', data: { runId } });
+    /** Wrap an async function with logger callbacks that forward to the broadcast. */
+    function withBroadcastCallbacks(ctx, fn) {
+        return runWithLoggerCallbacks({
+            onLog: (entry) => {
+                broadcast.send({ type: 'log', data: { ...entry, lang: ctx.lang, theme: ctx.theme, targetId: ctx.targetId } });
+                if (entry.iteration !== undefined && entry.maxIterations !== undefined) {
+                    broadcast.send({
+                        type: 'progress',
+                        data: {
+                            iteration: entry.iteration,
+                            maxIterations: entry.maxIterations,
+                            lang: ctx.lang,
+                            theme: ctx.theme,
+                            targetId: ctx.targetId,
+                        },
+                    });
+                }
+            },
+            onScreenshot: (base64) => {
+                broadcast.sendScreenshot(base64, { lang: ctx.lang, theme: ctx.theme, targetId: ctx.targetId });
+            },
+            onReasoningDelta: (delta, messageId) => {
+                broadcast.send({
+                    type: 'reasoning_delta',
+                    data: { delta, messageId, lang: ctx.lang, theme: ctx.theme, targetId: ctx.targetId },
+                });
+            },
+        }, fn);
+    }
     const remoteBrowser = new RemoteBrowser(ws);
     const abortController = new AbortController();
     let aborted = false;
+    // Idle timeout: close connection after 10 minutes of inactivity.
+    const IDLE_TIMEOUT_MS = 10 * 60 * 1000;
+    let idleTimer = setTimeout(() => {
+        logger.warn('[WS] Closing idle connection');
+        sendEvent('error', { message: 'Connection timed out due to inactivity' });
+        ws.close(4008, 'Idle timeout');
+    }, IDLE_TIMEOUT_MS);
+    const resetIdleTimer = () => {
+        clearTimeout(idleTimer);
+        idleTimer = setTimeout(() => {
+            logger.warn('[WS] Closing idle connection');
+            sendEvent('error', { message: 'Connection timed out due to inactivity' });
+            ws.close(4008, 'Idle timeout');
+        }, IDLE_TIMEOUT_MS);
+    };
+    ws.on('message', resetIdleTimer);
     ws.on('close', () => {
+        clearTimeout(idleTimer);
         aborted = true;
         abortController.abort();
+        broadcast.close();
     });
     const mockupState = {
         browser: null,
@@ -312,7 +392,10 @@ export async function handleConnection(ws, req) {
     };
     const getMockupContext = async () => {
         if (!mockupState.context) {
-            mockupState.browser = await chromium.launch({ headless: true });
+            mockupState.browser = await chromium.launch({
+                headless: true,
+                args: CHROMIUM_ARGS,
+            });
             mockupState.context = await mockupState.browser.newContext();
         }
         return mockupState.context;
@@ -540,14 +623,19 @@ export async function handleConnection(ws, req) {
     };
     const persistFullPageCapture = async (params) => {
         const { pageRun, target, lang, theme, agentResult, includeActions, includeWorkflowScreenshots } = params;
+        broadcast.send({ type: 'capture_start', data: { lang, theme, targetId: target.id, targetLabel: target.label } });
         const pageSegment = sanitizeStorageSegment(pageRun.pageId);
-        let finalBuffer = await remoteBrowser.takeScreenshot();
+        let finalBuffer = Buffer.alloc(0);
         let rawScreenshotUrl = null;
         let browserBar;
         try {
-            await remoteBrowser.resizeViewport(target.viewport.width, target.viewport.height);
-            await remoteBrowser.wait(300);
-            finalBuffer = await remoteBrowser.takeScreenshot();
+            logger.info(`[persist] target=${target.id} viewport=${target.viewport.width}x${target.viewport.height} deviceScaleFactor=${outputScale} deviceFrame=${target.deviceFrame ?? 'none'}`);
+            const lockedScreenshot = await takeViewportLockedScreenshot(remoteBrowser, target.viewport, { deviceScaleFactor: outputScale });
+            finalBuffer = lockedScreenshot.buffer;
+            logger.info(`[persist] screenshot=${lockedScreenshot.screenshotSize.width}x${lockedScreenshot.screenshotSize.height} expected=${lockedScreenshot.expectedScreenshotSize.width}x${lockedScreenshot.expectedScreenshotSize.height} repaired=${lockedScreenshot.repaired}`);
+            if (lockedScreenshot.repaired) {
+                logger.info(`Viewport lock repaired before persisting ${target.id}: expected ${lockedScreenshot.expectedScreenshotSize.width}x${lockedScreenshot.expectedScreenshotSize.height}, got ${lockedScreenshot.screenshotSize.width}x${lockedScreenshot.screenshotSize.height}.`);
+            }
             if (target.deviceFrame) {
                 const rawPath = `screenshots/${auth.userId}/${runId}/${pageSegment}/${target.id}_${lang}_${theme}_raw.png`;
                 const { error } = await supabase.storage
@@ -572,6 +660,7 @@ export async function handleConnection(ws, req) {
                     const localizedOptions = {
                         ...mockupOptions,
                         outputScale,
+                        colorScheme: theme,
                         statusBar: localizeStatusBar(mockupOptions.statusBar, lang),
                         browserBar,
                     };
@@ -590,10 +679,11 @@ export async function handleConnection(ws, req) {
             const screenshotUrl = uploadError
                 ? null
                 : supabase.storage.from(BUCKET).getPublicUrl(storagePath).data.publicUrl;
-            const persistedSuccess = agentResult.success && !!screenshotUrl;
+            const terminalAgentSuccess = isTerminalAgentResultSuccess(agentResult);
+            const persistedSuccess = terminalAgentSuccess && !!screenshotUrl;
             const persistedAssessment = persistedSuccess
                 ? agentResult.assessment
-                : agentResult.success
+                : terminalAgentSuccess
                     ? 'Capture completed but screenshot upload failed.'
                     : agentResult.assessment || 'Capture failed';
             captureResults.push({
@@ -610,6 +700,22 @@ export async function handleConnection(ws, req) {
                 iterations: agentResult.iterations,
                 finalScreenshotUrl: screenshotUrl ?? undefined,
             });
+            broadcast.send({
+                type: 'result',
+                data: {
+                    url: pageRun.url,
+                    lang,
+                    theme,
+                    targetId: target.id,
+                    targetLabel: target.label,
+                    success: persistedSuccess,
+                    assessment: persistedAssessment,
+                    iterations: agentResult.iterations,
+                    finalScreenshotUrl: screenshotUrl ?? undefined,
+                    // Omit finalScreenshot base64 — too large for broadcast.
+                    finalScreenshot: '',
+                },
+            });
             const costLogIds = await logAgentUsage({
                 usage: agentResult.usage,
                 lang,
@@ -708,7 +814,7 @@ export async function handleConnection(ws, req) {
             });
             void reconcilePendingBillingOperationCosts(supabase).catch(() => undefined);
             if (!persistedSuccess) {
-                const errorType = agentResult.success
+                const errorType = terminalAgentSuccess
                     ? 'storage_upload_failure'
                     : agentResult.actions.some((action) => action.action === 'give_up')
                         ? 'give_up'
@@ -820,6 +926,7 @@ export async function handleConnection(ws, req) {
             sendEvent('progress', {
                 message: `[${captureIndex}/${totalCaptures}] ${lang}/${theme} · ${pageRun.pageId ?? 'main'} · ${target.label}`,
             });
+            broadcast.send({ type: 'capture_complete', data: { lang, theme, targetId: target.id, success: isTerminalAgentResultSuccess(agentResult) } });
         }
     };
     const persistElementCapture = async (params) => {
@@ -1025,7 +1132,7 @@ export async function handleConnection(ws, req) {
             });
         }
     };
-    sendEvent('capture_plan', {
+    const capturePlanPayload = {
         variants: variantPlan.map((variant) => ({
             key: variant.key,
             lang: variant.lang,
@@ -1033,8 +1140,11 @@ export async function handleConnection(ws, req) {
             pages: variant.pages,
         })),
         totalCaptures,
-    });
-    const { identities: sharedPageIdentities } = await inferPageIdentitiesWithLLM(variantPlan[0]?.pages ?? [], resolvedModel, getOpenRouterKey(), Object.keys(providerPreferences).length > 0 ? providerPreferences : undefined);
+    };
+    sendEvent('capture_plan', capturePlanPayload);
+    broadcast.send({ type: 'capture_plan', data: capturePlanPayload });
+    const pageIdentityModel = (useVisionModelForAuxTasks && resolvedVisionModel) ? resolvedVisionModel : resolvedModel;
+    const { identities: sharedPageIdentities } = await inferPageIdentitiesWithLLM(variantPlan[0]?.pages ?? [], pageIdentityModel, getOpenRouterKey(), Object.keys(providerPreferences).length > 0 ? providerPreferences : undefined);
     try {
         for (const [variantIndex, variant] of variantPlan.entries()) {
             if (aborted)
@@ -1044,6 +1154,7 @@ export async function handleConnection(ws, req) {
             const firstPage = variantPages[0];
             const variantCaptureStartIndex = captureIndex;
             const expectedVariantCaptureCount = (variantPages.length * targets.length) + elements.length;
+            const variantCaptureIds = [];
             try {
                 const firstDomain = getCaptureUrlHostname(firstPage.url);
                 const persistedSessionProfile = await loadSessionProfileForVariant(firstDomain, lang, theme);
@@ -1105,6 +1216,40 @@ export async function handleConnection(ws, req) {
                     await remoteBrowser.wait(500);
                     await remoteBrowser.dismissOverlays().catch(() => undefined);
                 }
+                // Pre-authenticate before the language preflight when credentials are available.
+                // Language controls are often locked behind login — without this the preflight
+                // wastes all its iterations trying to switch language on the public page.
+                // We force login (bypassing authMatches) because the persisted session profile
+                // may report "authenticated" even though the current browser context has no
+                // active session (cookies were restored but the server session expired).
+                if (credentials?.email && credentials?.password && credentials.loginUrl) {
+                    try {
+                        await remoteBrowser.navigateTo(credentials.loginUrl);
+                        await remoteBrowser.wait(500);
+                        await performDeterministicSessionRepair(remoteBrowser, {
+                            startUrl: firstPage.url,
+                            requestedLang: lang,
+                            requestedTheme: theme,
+                            credentials,
+                            profile: activeSessionProfile,
+                            selectorMemory: variantStartSelectorMemory,
+                        });
+                        sendEvent('progress', { message: 'Pre-authenticated before language preflight.' });
+                        // Navigate back to the start page after login redirect
+                        if (!urlMatchesCaptureTarget(remoteBrowser.currentPage.url(), firstPage.url)) {
+                            await remoteBrowser.navigateTo(firstPage.url);
+                            await remoteBrowser.wait(500);
+                            await remoteBrowser.dismissOverlays().catch(() => undefined);
+                        }
+                    }
+                    catch {
+                        // Non-blocking: if pre-auth fails the language preflight will retry.
+                        if (!urlMatchesCaptureTarget(remoteBrowser.currentPage.url(), firstPage.url)) {
+                            await remoteBrowser.navigateTo(firstPage.url).catch(() => undefined);
+                            await remoteBrowser.wait(500);
+                        }
+                    }
+                }
                 const variantLanguagePreflight = await ensureScreenshotVariantLanguage({
                     browser: remoteBrowser,
                     requestedLang: lang,
@@ -1124,19 +1269,21 @@ export async function handleConnection(ws, req) {
                         await remoteBrowser.dismissOverlays().catch(() => undefined);
                     },
                     runLanguageSwitchAgent: async ({ languageState, themeState }) => {
-                        return runAgent(remoteBrowser, {
+                        return withBroadcastCallbacks({ lang, theme }, () => runAgent(remoteBrowser, {
                             url: remoteBrowser.currentPage.url() || firstPage.url,
                             prompt: [
                                 `Prepare the current page so the UI is rendered in "${lang}" and the theme is "${theme}".`,
                                 `Current inspection: language=${languageState?.detected ?? 'unknown'}; theme=${themeState?.detected ?? 'unknown'}.`,
+                                `Strategy: try navigate_to /settings first for language/theme controls; if the settings page has no such controls, look for an account/profile button (usually at the bottom of the sidebar — NOT the app logo) and open its dropdown menu. Do not click the same element more than once if it had no effect.`,
+                                config.langInstructions ? `Language switch hint: ${config.langInstructions}` : '',
                                 firstPage.prompt,
-                            ].join(' '),
+                            ].filter(Boolean).join(' '),
                             dark: theme === 'dark',
                             langs: [lang],
-                            outputDir: '/tmp/autokap-ws',
+                            outputDir: path.join(os.tmpdir(), 'autokap-ws'),
                             headed: false,
                             viewport: firstTarget.viewport,
-                            maxIterations: Math.min(maxIterations, 10),
+                            maxIterations: Math.min(maxIterations, 12),
                             model: resolvedModel,
                             fallbackModel: resolvedFallback,
                             visionModel: resolvedVisionModel,
@@ -1146,10 +1293,12 @@ export async function handleConnection(ws, req) {
                             currentTheme: theme,
                             selectorMemory: Object.keys(variantStartSelectorMemory).length > 0 ? variantStartSelectorMemory : undefined,
                             sessionProfile: activeSessionProfile,
+                            langInstructions: config.langInstructions,
+                            themeInstructions: config.themeInstructions,
                             runHints: runHints && runHints.length > 0 ? runHints : undefined,
                             runMode: 'language_preflight',
                             abortSignal: abortController.signal,
-                        }, getOpenRouterKey());
+                        }, getOpenRouterKey()));
                     },
                 });
                 if (variantLanguagePreflight.selectorUpdates.length > 0) {
@@ -1191,13 +1340,14 @@ export async function handleConnection(ws, req) {
                         pageIdentity: variantManifest.currentPageIdentity ?? null,
                         pageUrl: pageRun.url,
                     });
+                    let trustedHandoffContext;
                     const buildConfig = (viewport = firstTarget.viewport) => {
                         const nextConfig = {
                             url: pageRun.url,
                             prompt: pageRun.prompt,
                             dark: theme === 'dark',
                             langs: [lang],
-                            outputDir: '/tmp/autokap-ws',
+                            outputDir: path.join(os.tmpdir(), 'autokap-ws'),
                             headed: false,
                             viewport,
                             maxIterations,
@@ -1212,13 +1362,17 @@ export async function handleConnection(ws, req) {
                             currentTheme: theme,
                             reasoningLocale: config.reasoningLocale,
                             reasoningEffort: config.reasoningEffort ?? 'medium',
+                            reasoningCapableModels: config.reasoningCapableModels,
                             runHints: runHints && runHints.length > 0 ? runHints : undefined,
                             selectorMemory: Object.keys(selectorMemory).length > 0 ? selectorMemory : undefined,
                             sessionProfile: activeSessionProfile,
-                            handoffContext: carryoverContext,
+                            handoffContext: trustedHandoffContext,
                             variantManifest,
                             runMode: 'capture',
                             analyticsId: auth.userId,
+                            enableGeminiExplicitCache,
+                            enableCacheLayoutV2,
+                            useVisionModelForAuxTasks,
                             enableDeterministicRecovery: true,
                             enableRecoveryEvaluator: true,
                             enableSalienceCompression: true,
@@ -1236,49 +1390,90 @@ export async function handleConnection(ws, req) {
                         message: `Preparing ${lang}/${theme} · ${pageId} (${pageIndex + 1}/${variantPages.length})`,
                     });
                     let primaryAgentResult = null;
-                    const currentUrl = remoteBrowser.currentPage.url();
-                    const canUseSequentialHandoff = !!(carryoverContext
-                        && shouldUseSequentialPageHandoff({
-                            pageIndex,
-                            currentUrl,
-                            pageUrl: pageRun.url,
-                            previousPageId: carryoverContext.previousPageId,
-                            pageId: pageRun.pageId,
-                            previousPrompt: carryoverContext.previousPrompt,
-                            pagePrompt: pageRun.prompt,
-                        }));
-                    const reuseLiveState = shouldReuseLivePageState({
+                    await remoteBrowser.dismissOverlays().catch(() => undefined);
+                    let baselineObservation = await remoteBrowser.captureObservation().catch(() => null);
+                    if (shouldNormalizeDialogsBeforeTargetReuse({
+                        currentDialogCount: baselineObservation?.dialogCount,
+                        pageIdentity: variantManifest.currentPageIdentity ?? null,
+                    })) {
+                        for (let attempt = 0; attempt < 2; attempt += 1) {
+                            await remoteBrowser.pressKey('Escape').catch(() => undefined);
+                            await remoteBrowser.wait(180);
+                            baselineObservation = await remoteBrowser.captureObservation().catch(() => null);
+                            if (!shouldNormalizeDialogsBeforeTargetReuse({
+                                currentDialogCount: baselineObservation?.dialogCount,
+                                pageIdentity: variantManifest.currentPageIdentity ?? null,
+                            })) {
+                                break;
+                            }
+                        }
+                    }
+                    await remoteBrowser.wait(250);
+                    baselineObservation = baselineObservation ?? await remoteBrowser.captureObservation().catch(() => null);
+                    const baselineSignals = await remoteBrowser.capturePageSignals({
+                        timeoutMs: 1_500,
+                    }).catch(() => null);
+                    const transition = decideCaptureTransition({
                         pageIndex,
-                        presetRootUrl: projectUrl,
-                        pageUrl: pageRun.url,
-                        currentUrl,
-                        isAuthenticated: activeSessionProfile?.authState === 'authenticated',
+                        currentUrl: remoteBrowser.currentPage.url(),
+                        targetUrl: pageRun.url,
+                        pageIdentity: variantManifest.currentPageIdentity ?? null,
+                        observation: baselineObservation,
+                        pageSignals: baselineSignals,
+                        profile: activeSessionProfile,
+                        handoffContext: carryoverContext,
+                        requestedLang: lang,
+                        requestedTheme: theme,
+                    });
+                    trustedHandoffContext = transition.allowFastPath ? carryoverContext : undefined;
+                    sendEvent('progress', {
+                        message: `Transition ${lang}/${theme} · ${pageId}: ${transition.mode}`
+                            + (transition.reasons[0] ? ` (${transition.reasons[0]})` : ''),
                     });
-                    if (canUseSequentialHandoff) {
+                    if (transition.mode === 'dirty') {
+                        const storageState = await remoteBrowser.exportStorageState().catch(() => undefined)
+                            ?? activeSessionProfile?.storageState;
+                        const sessionStorage = await remoteBrowser.exportSessionStorage().catch(() => undefined)
+                            ?? activeSessionProfile?.sessionStorage;
+                        await remoteBrowser.recreateContext({
+                            viewport: firstTarget.viewport,
+                            deviceScaleFactor: outputScale,
+                            lang,
+                            colorScheme: theme,
+                            storageState,
+                        });
+                        await remoteBrowser.prepareSessionStorage(sessionStorage, { replace: false });
+                        await remoteBrowser.navigateTo(pageRun.url);
+                        await remoteBrowser.wait(500);
+                        await remoteBrowser.dismissOverlays().catch(() => undefined);
+                        trustedHandoffContext = undefined;
+                    }
+                    else if (transition.shouldNavigateToCanonical) {
+                        await remoteBrowser.navigateTo(pageRun.url);
+                        await remoteBrowser.wait(500);
+                        await remoteBrowser.dismissOverlays().catch(() => undefined);
+                        trustedHandoffContext = undefined;
+                    }
+                    if (transition.allowFastPath) {
                         const readiness = await verifyCaptureReadiness(remoteBrowser, buildConfig(), getOpenRouterKey(), {
                             assessment: 'Sequential handoff preflight: approve only if the current live page already satisfies this capture.',
                             stepNumber: 0,
                         }).catch(() => null);
-                        if (readiness?.verified) {
+                        if (readiness && isTerminalVerificationSuccess(readiness)) {
                             primaryAgentResult = buildPreverifiedAgentResult('Capture approved directly from sequential handoff state.', readiness);
                         }
                     }
-                    if (!primaryAgentResult && !canUseSequentialHandoff && !reuseLiveState && !urlMatchesCaptureTarget(currentUrl, pageRun.url)) {
-                        await remoteBrowser.navigateTo(pageRun.url);
-                        await remoteBrowser.wait(500);
-                        await remoteBrowser.dismissOverlays().catch(() => undefined);
-                    }
                     if (!primaryAgentResult && variantIndex > 0) {
                         const recordedActions = liveVariantActions.get(pageId);
                         if (recordedActions && recordedActions.length > 0) {
                             sendEvent('progress', {
                                 message: `Replaying first successful variant for ${lang}/${theme} · ${pageId}`,
                             });
-                            primaryAgentResult = await replayAgent(remoteBrowser, buildConfig(), getOpenRouterKey(), recordedActions, { allowFullAgentFallback: true }).catch((error) => makeFailedAgentResult(error.message));
+                            primaryAgentResult = await withBroadcastCallbacks({ lang, theme, targetId: firstTarget.id }, () => replayAgent(remoteBrowser, buildConfig(), getOpenRouterKey(), recordedActions, { allowFullAgentFallback: true })).catch((error) => makeFailedAgentResult(error.message));
                         }
                     }
                     if (!primaryAgentResult) {
-                        primaryAgentResult = await runAgent(remoteBrowser, buildConfig(), getOpenRouterKey()).catch((error) => makeFailedAgentResult(error.message));
+                        primaryAgentResult = await withBroadcastCallbacks({ lang, theme, targetId: firstTarget.id }, () => runAgent(remoteBrowser, buildConfig(), getOpenRouterKey())).catch((error) => makeFailedAgentResult(error.message));
                     }
                     const preparedPageUrl = remoteBrowser.currentPage.url() || pageRun.url;
                     await persistFullPageCapture({
@@ -1291,8 +1486,15 @@ export async function handleConnection(ws, req) {
                         includeWorkflowScreenshots: true,
                     });
                     for (const target of targets.slice(1)) {
-                        await remoteBrowser.resizeViewport(target.viewport.width, target.viewport.height);
-                        await remoteBrowser.wait(250);
+                        await lockCaptureViewport(remoteBrowser, target.viewport, { settleMs: 250 });
+                        // Re-navigate to force a full CSS re-layout at the new viewport width.
+                        // Without this, the page content stays rendered at firstTarget's width
+                        // and gets squeezed into the smaller viewport.
+                        const currentUrl = remoteBrowser.currentPage.url();
+                        if (currentUrl) {
+                            await remoteBrowser.navigateTo(currentUrl);
+                            await remoteBrowser.wait(500);
+                        }
                         await remoteBrowser.dismissOverlays().catch(() => undefined);
                         let targetResult;
                         const targetConfig = buildConfig(target.viewport);
@@ -1300,11 +1502,11 @@ export async function handleConnection(ws, req) {
                             assessment: 'Same-session target recheck: approve only if the resized page still satisfies the capture.',
                             stepNumber: 0,
                         }).catch(() => null);
-                        if (targetReadiness?.verified) {
+                        if (targetReadiness && isTerminalVerificationSuccess(targetReadiness)) {
                             targetResult = buildPreverifiedAgentResult('Capture approved after same-session target recheck.', targetReadiness);
                         }
                         else {
-                            targetResult = await replayAgent(remoteBrowser, targetConfig, getOpenRouterKey(), primaryAgentResult.actions, { allowFullAgentFallback: false }).catch((error) => makeFailedAgentResult(error.message));
+                            targetResult = await withBroadcastCallbacks({ lang, theme, targetId: target.id }, () => replayAgent(remoteBrowser, targetConfig, getOpenRouterKey(), primaryAgentResult.actions, { allowFullAgentFallback: false })).catch((error) => makeFailedAgentResult(error.message));
                         }
                         await persistFullPageCapture({
                             pageRun,
@@ -1317,7 +1519,7 @@ export async function handleConnection(ws, req) {
                         });
                         await restorePreparedPageState(remoteBrowser, firstTarget.viewport, preparedPageUrl);
                     }
-                    if (primaryAgentResult.success) {
+                    if (isTerminalAgentResultSuccess(primaryAgentResult)) {
                         const recorded = recordValidatedVariantCapture({
                             state: variantState,
                             capture: {
@@ -1344,7 +1546,7 @@ export async function handleConnection(ws, req) {
                             };
                         }
                     }
-                    if (primaryAgentResult.success) {
+                    if (isTerminalAgentResultSuccess(primaryAgentResult)) {
                         if (primaryAgentResult.actions.length > 0 && !liveVariantActions.has(pageId)) {
                             liveVariantActions.set(pageId, primaryAgentResult.actions);
                         }
@@ -1434,6 +1636,7 @@ export async function handleConnection(ws, req) {
                             theme,
                             selectorMemory,
                             actions: primaryAgentResult.actions,
+                            agentResult: primaryAgentResult,
                         });
                     }
                     else {
@@ -1444,6 +1647,18 @@ export async function handleConnection(ws, req) {
                         });
                         carryoverContext = undefined;
                     }
+                    // Always export storage state after each page attempt so subsequent
+                    // variants can reuse the authenticated session even if this capture failed.
+                    try {
+                        const latestStorageState = await remoteBrowser.exportStorageState();
+                        if (latestStorageState) {
+                            runSharedStorageState = latestStorageState;
+                            runSharedSessionStorage = await remoteBrowser.exportSessionStorage().catch(() => undefined);
+                        }
+                    }
+                    catch {
+                        // Best-effort: keep previous storage state
+                    }
                 }
                 const variantValidation = validateVariantCaptureState(variantState);
                 if (!variantValidation.ok) {
@@ -1462,12 +1677,17 @@ export async function handleConnection(ws, req) {
                     success: variantValidation.ok,
                     reason: variantValidation.ok ? null : 'Variant completed with blocking issues.',
                 });
+                broadcast.send({ type: 'variant_complete', data: { lang, theme, success: variantValidation.ok, reason: variantValidation.ok ? undefined : 'Variant completed with blocking issues.' } });
             }
             catch (error) {
                 if (aborted)
                     throw error;
                 const message = error.message;
                 logger.error(`Variant ${lang}/${theme} failed: ${message}`);
+                // Revoke credits for captures that were recorded during this failed variant
+                for (const failedCaptureId of variantCaptureIds) {
+                    await revokeCreditUsage(supabase, failedCaptureId).catch((err) => logger.error(`Failed to revoke credit for capture ${failedCaptureId}: ${err.message}`));
+                }
                 const consumedCaptures = captureIndex - variantCaptureStartIndex;
                 const remainingCaptures = Math.max(0, expectedVariantCaptureCount - consumedCaptures);
                 if (remainingCaptures > 0) {
@@ -1497,6 +1717,7 @@ export async function handleConnection(ws, req) {
                     success: false,
                     reason: message,
                 });
+                broadcast.send({ type: 'variant_complete', data: { lang, theme, success: false, reason: message } });
                 continue;
             }
         }
@@ -1513,6 +1734,8 @@ export async function handleConnection(ws, req) {
         })
             .eq('id', runId);
         sendEvent('error', { message });
+        broadcast.send({ type: 'error', data: { message } });
+        broadcast.close();
         await finalizeRunSideEffects();
         remoteBrowser.destroy();
         await closeMockup();
@@ -1540,6 +1763,8 @@ export async function handleConnection(ws, req) {
         },
     });
     sendEvent('done', { summary: { successes: successCount, total: totalCaptures } });
+    broadcast.send({ type: 'done', data: { totalCaptures, successCount } });
+    broadcast.close();
     if (plan.entitlements.captureCompleteWebhook) {
         try {
             const webhookConfig = await getProjectWebhookConfig(supabase, project.id);
@@ -1564,100 +1789,5 @@ export async function handleConnection(ws, req) {
     await closeMockup();
     logger.success(`Run ${runId} completed: ${successCount}/${totalCaptures}`);
 }
-function urlsRoughlyMatch(left, right) {
-    return urlsPointToSameCaptureState(left, right);
-}
-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;
-    }
-}
-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,
-    };
-}
-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';
-}
-function buildPreverifiedAgentResult(assessment, verification) {
-    return {
-        success: true,
-        screenshotPath: null,
-        screenshots: [],
-        iterations: 0,
-        actions: [],
-        assessment,
-        usage: verification.usage ? [verification.usage] : [],
-        runtimeStrategy: 'preverified_handoff',
-        deterministicRecoveryUsed: false,
-        evaluatorUsed: false,
-        verification,
-    };
-}
-function makeFailedAgentResult(message) {
-    return {
-        success: false,
-        screenshotPath: null,
-        assessment: message,
-        iterations: 0,
-        actions: [],
-        screenshots: [],
-        usage: [],
-    };
-}
-async function buildHandoffContext(params) {
-    const handoffArtifacts = buildSequentialHandoffArtifacts(params.actions ?? []);
-    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 the validated live state reached for ${params.pageRun.pageId ?? 'main'}.`,
-        selectorHints: handoffArtifacts.selectorHints,
-        navigationHints: [],
-        selectorMemory: mergeSelectorMemory(params.selectorMemory, handoffArtifacts.selectorMemory),
-    };
-}
-async function restorePreparedPageState(browser, viewport, preparedPageUrl) {
-    await browser.resizeViewport(viewport.width, viewport.height);
-    if (!urlsRoughlyMatch(browser.currentPage.url(), preparedPageUrl)) {
-        await browser.navigateTo(preparedPageUrl);
-    }
-    await browser.dismissOverlays().catch(() => undefined);
-    await browser.wait(250);
-}
+// Standalone utilities have been extracted to ws-handler-utils.ts
 //# sourceMappingURL=ws-handler.js.map