autokap 1.0.0

package/dist/clip-postprocess.d.ts

@@ -0,0 +1,42 @@
+import type { ClipOptions } from './types.js';
+/**
+ * Resolve the system ffmpeg binary path. Throws if not found.
+ */
+export declare function ensureFfmpegAvailable(): Promise<string>;
+/**
+ * Convert a WebM recording to an optimized GIF using a 2-pass palette approach.
+ * Pass 1: generate an optimal palette. Pass 2: encode with that palette.
+ */
+export declare function convertToGif(webmPath: string, outputPath: string, opts?: {
+    fps?: number;
+    maxWidth?: number;
+    loop?: boolean;
+}): Promise<void>;
+/**
+ * Convert a WebM recording to an MP4 with web-optimized settings.
+ */
+export declare function convertToMp4(webmPath: string, outputPath: string): Promise<void>;
+/**
+ * Extract the first frame of a WebM as a PNG thumbnail.
+ */
+export declare function extractThumbnail(webmPath: string, outputPath: string): Promise<void>;
+/**
+ * Trim a recording: skip dead frames at the start and cap duration.
+ */
+export declare function trimRecording(inputPath: string, outputPath: string, startSec?: number, maxDurationSec?: number): Promise<void>;
+/**
+ * Get the duration of a media file in milliseconds.
+ */
+export declare function getMediaDurationMs(filePath: string): Promise<number>;
+export interface ClipPostProcessResult {
+    gifPath?: string;
+    mp4Path?: string;
+    thumbnailPath?: string;
+    durationMs: number;
+    fileSizeBytes?: number;
+}
+/**
+ * Full post-processing pipeline for a single clip recording:
+ * trim → GIF and/or MP4 → thumbnail → measure.
+ */
+export declare function postProcessClipRecording(webmPath: string, outputDir: string, clipId: string, options?: ClipOptions): Promise<ClipPostProcessResult>;

package/dist/clip-postprocess.js

@@ -0,0 +1,192 @@
+import { execFile } from 'node:child_process';
+import { stat } from 'node:fs/promises';
+import path from 'node:path';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+// ── Default values ──────────────────────────────────────────────────
+const DEFAULT_GIF_FPS = 15;
+const DEFAULT_GIF_MAX_WIDTH = 800;
+const DEFAULT_MAX_DURATION_SEC = 8;
+const DEFAULT_TRIM_START_SEC = 0.3;
+// ── ffmpeg detection ────────────────────────────────────────────────
+let cachedFfmpegPath = null;
+/**
+ * Resolve the system ffmpeg binary path. Throws if not found.
+ */
+export async function ensureFfmpegAvailable() {
+    if (cachedFfmpegPath)
+        return cachedFfmpegPath;
+    try {
+        const { stdout } = await execFileAsync('which', ['ffmpeg']);
+        const ffmpegPath = stdout.trim();
+        if (!ffmpegPath)
+            throw new Error('ffmpeg not found');
+        cachedFfmpegPath = ffmpegPath;
+        return ffmpegPath;
+    }
+    catch {
+        throw new Error('ffmpeg is required for clip post-processing but was not found on your system. ' +
+            'Install it via: brew install ffmpeg (macOS) or apt install ffmpeg (Linux).');
+    }
+}
+// ── Conversion functions ────────────────────────────────────────────
+/**
+ * Convert a WebM recording to an optimized GIF using a 2-pass palette approach.
+ * Pass 1: generate an optimal palette. Pass 2: encode with that palette.
+ */
+export async function convertToGif(webmPath, outputPath, opts = {}) {
+    const ffmpeg = await ensureFfmpegAvailable();
+    const fps = opts.fps ?? DEFAULT_GIF_FPS;
+    const maxWidth = opts.maxWidth ?? DEFAULT_GIF_MAX_WIDTH;
+    const loopFlag = (opts.loop ?? true) ? '0' : '-1';
+    const paletteDir = path.dirname(outputPath);
+    const palettePath = path.join(paletteDir, `_palette_${Date.now()}.png`);
+    const scaleFilter = `fps=${fps},scale=${maxWidth}:-1:flags=lanczos`;
+    // Pass 1: Generate palette
+    await execFileAsync(ffmpeg, [
+        '-i', webmPath,
+        '-vf', `${scaleFilter},palettegen=stats_mode=diff`,
+        '-y', palettePath,
+    ]);
+    // Pass 2: Encode GIF with palette
+    try {
+        await execFileAsync(ffmpeg, [
+            '-i', webmPath,
+            '-i', palettePath,
+            '-lavfi', `${scaleFilter}[x];[x][1:v]paletteuse=dither=bayer:bayer_scale=3`,
+            '-loop', loopFlag,
+            '-y', outputPath,
+        ]);
+    }
+    finally {
+        // Clean up palette file
+        try {
+            await stat(palettePath).then(() => execFileAsync('rm', [palettePath]));
+        }
+        catch { /* ignore */ }
+    }
+}
+/**
+ * Convert a WebM recording to an MP4 with web-optimized settings.
+ */
+export async function convertToMp4(webmPath, outputPath) {
+    const ffmpeg = await ensureFfmpegAvailable();
+    await execFileAsync(ffmpeg, [
+        '-i', webmPath,
+        '-c:v', 'libx264',
+        '-preset', 'slow',
+        '-crf', '22',
+        '-pix_fmt', 'yuv420p',
+        '-movflags', '+faststart',
+        '-an',
+        '-y', outputPath,
+    ]);
+}
+/**
+ * Extract the first frame of a WebM as a PNG thumbnail.
+ */
+export async function extractThumbnail(webmPath, outputPath) {
+    const ffmpeg = await ensureFfmpegAvailable();
+    await execFileAsync(ffmpeg, [
+        '-i', webmPath,
+        '-frames:v', '1',
+        '-y', outputPath,
+    ]);
+}
+/**
+ * Trim a recording: skip dead frames at the start and cap duration.
+ */
+export async function trimRecording(inputPath, outputPath, startSec = DEFAULT_TRIM_START_SEC, maxDurationSec = DEFAULT_MAX_DURATION_SEC) {
+    const ffmpeg = await ensureFfmpegAvailable();
+    await execFileAsync(ffmpeg, [
+        '-ss', String(startSec),
+        '-i', inputPath,
+        '-t', String(maxDurationSec),
+        '-c', 'copy',
+        '-y', outputPath,
+    ]);
+}
+/**
+ * Get the duration of a media file in milliseconds.
+ */
+export async function getMediaDurationMs(filePath) {
+    const ffmpeg = await ensureFfmpegAvailable();
+    const ffprobe = ffmpeg.replace(/ffmpeg$/, 'ffprobe');
+    const { stdout } = await execFileAsync(ffprobe, [
+        '-v', 'error',
+        '-show_entries', 'format=duration',
+        '-of', 'default=noprint_wrappers=1:nokey=1',
+        filePath,
+    ]);
+    return Math.round(parseFloat(stdout.trim()) * 1000);
+}
+/**
+ * Freeze the last frame of a video for `durationSec` additional seconds.
+ * Uses ffmpeg's tpad filter to hold the final frame in place.
+ */
+async function freezeLastFrame(inputPath, outputPath, durationSec) {
+    const ffmpeg = await ensureFfmpegAvailable();
+    const stopDurationMs = Math.round(durationSec * 1000);
+    await execFileAsync(ffmpeg, [
+        '-i', inputPath,
+        '-vf', `tpad=stop_mode=clone:stop_duration=${stopDurationMs}ms`,
+        '-c:v', 'libvpx-vp9',
+        '-crf', '30',
+        '-b:v', '0',
+        '-an',
+        '-y', outputPath,
+    ]);
+}
+/**
+ * Full post-processing pipeline for a single clip recording:
+ * trim → GIF and/or MP4 → thumbnail → measure.
+ */
+export async function postProcessClipRecording(webmPath, outputDir, clipId, options = {}) {
+    const maxDuration = options.maxDurationSec ?? DEFAULT_MAX_DURATION_SEC;
+    // Step 1: Trim the recording — cut the setup phase (page load, overlay dismiss)
+    const trimStart = options.trimStartSec ?? DEFAULT_TRIM_START_SEC;
+    const trimmedPath = path.join(outputDir, `${clipId}_trimmed.webm`);
+    await trimRecording(webmPath, trimmedPath, trimStart, maxDuration);
+    // Step 1b: Optionally freeze the last frame for a pause before looping
+    const holdSec = Math.min(Math.max(options.holdLastFrameSec ?? 0, 0), 10);
+    let sourcePath = trimmedPath;
+    if (holdSec > 0) {
+        const paddedPath = path.join(outputDir, `${clipId}_padded.webm`);
+        await freezeLastFrame(trimmedPath, paddedPath, holdSec);
+        sourcePath = paddedPath;
+    }
+    const durationMs = await getMediaDurationMs(sourcePath);
+    const result = { durationMs };
+    // Step 2: Always persist both a GIF and an MP4.
+    // The GIF remains useful for delivery and embeds, while the MP4 is the
+    // high-fidelity source for Studio playback and downstream re-renders.
+    const gifPath = path.join(outputDir, `${clipId}.gif`);
+    await convertToGif(sourcePath, gifPath, {
+        fps: options.gifFps,
+        maxWidth: options.gifMaxWidth,
+        loop: options.loop,
+    });
+    result.gifPath = gifPath;
+    const gifStat = await stat(gifPath);
+    result.fileSizeBytes = gifStat.size;
+    const mp4Path = path.join(outputDir, `${clipId}.mp4`);
+    await convertToMp4(sourcePath, mp4Path);
+    result.mp4Path = mp4Path;
+    // Step 3: Extract thumbnail
+    const thumbnailPath = path.join(outputDir, `${clipId}_thumb.png`);
+    await extractThumbnail(sourcePath, thumbnailPath);
+    result.thumbnailPath = thumbnailPath;
+    // Clean up intermediate files
+    try {
+        await execFileAsync('rm', [trimmedPath]);
+    }
+    catch { /* ignore */ }
+    if (sourcePath !== trimmedPath) {
+        try {
+            await execFileAsync('rm', [sourcePath]);
+        }
+        catch { /* ignore */ }
+    }
+    return result;
+}
+//# sourceMappingURL=clip-postprocess.js.map

package/dist/cookie-dismiss.d.ts

@@ -0,0 +1,5 @@
+import type { Page } from 'playwright';
+export declare function dismissCookiesAndWidgets(page: Page): Promise<{
+    dismissed: boolean;
+    method: string | null;
+}>;

package/dist/cookie-dismiss.js

@@ -0,0 +1,172 @@
+import { logger } from './logger.js';
+// Known CMP (Consent Management Platform) accept buttons
+const CMP_SELECTORS = [
+    // OneTrust
+    '#onetrust-accept-btn-handler',
+    '.onetrust-close-btn-handler',
+    // Cookiebot
+    '#CybotCookiebotDialogBodyLevelButtonLevelOptinAllowAll',
+    '#CybotCookiebotDialogBodyButtonAccept',
+    // Quantcast
+    '.qc-cmp2-summary-buttons button[mode="primary"]',
+    // Didomi
+    '#didomi-notice-agree-button',
+    // Axeptio
+    '.axeptio_btn_acceptAll',
+    // Iubenda
+    '.iubenda-cs-accept-btn',
+    // HubSpot
+    '#hs-eu-confirmation-button',
+    // Cookie Notice plugin
+    '.cookie-notice-container .cn-set-cookie',
+    // Cookie Consent (Osano)
+    '.cc-compliance .cc-btn.cc-allow',
+    '.cc-btn.cc-dismiss',
+    // Klaro
+    '.klaro .cm-btn-accept',
+    // Complianz
+    '#cmplz-cookiebanner-container .cmplz-btn.cmplz-accept',
+    // Generic patterns
+    '[data-cookiefirst-action="accept"]',
+    '[data-testid="cookie-accept"]',
+    '[data-testid="accept-cookies"]',
+];
+// Multilingual accept button text patterns
+const ACCEPT_PATTERNS = [
+    /^accept\s*(all|cookies)?$/i,
+    /^i\s*agree$/i,
+    /^agree(\s*(&|and)\s*close)?$/i,
+    /^allow\s*(all|cookies)?$/i,
+    /^got\s*it$/i,
+    /^ok$/i,
+    /^continue$/i,
+    // French
+    /^accepter\s*(tout|les cookies)?$/i,
+    /^tout\s*accepter$/i,
+    /^j.accepte$/i,
+    /^continuer$/i,
+    // German
+    /^(alle\s*)?akzeptieren$/i,
+    /^alle\s*zulassen$/i,
+    /^zustimmen$/i,
+    // Spanish
+    /^aceptar\s*(todo|cookies)?$/i,
+    // Portuguese
+    /^aceitar\s*(tudo|cookies)?$/i,
+    // Italian
+    /^accetta\s*(tutto|i cookie)?$/i,
+    // Dutch
+    /^(alles\s*)?accepteren$/i,
+];
+// Elements to always hide via CSS injection
+const HIDE_SELECTORS = [
+    // Chat widgets
+    '#intercom-container', '.intercom-lightweight-app', '#intercom-frame',
+    '#drift-widget', '#drift-frame-controller',
+    '.crisp-client', '#crisp-chatbox',
+    '#launcher', '#webWidget', // Zendesk
+    '#hubspot-messages-iframe-container',
+    '#tidio-chat', '#tidio-chat-iframe',
+    '.fb-customerchat', '.fb_dialog', // Facebook Messenger
+    '#chat-widget-container',
+    // Feedback widgets
+    '#_hj_feedback_container', '._hj-widget-container', // Hotjar
+    '#usersnap-button', '#usersnap-panel',
+    // Generic
+    '[class*="chat-widget"]', '[class*="chatWidget"]',
+    '[id*="chat-widget"]', '[id*="chatWidget"]',
+    // Cookie banners (CSS fallback)
+    '[class*="cookie-banner"]', '[class*="cookie-consent"]',
+    '[id*="cookie-banner"]', '[id*="cookie-consent"]',
+    '[class*="cookieBanner"]', '[class*="cookieConsent"]',
+    '[id*="cookieBanner"]', '[id*="cookieConsent"]',
+    '[class*="gdpr"]', '[id*="gdpr"]',
+];
+export async function dismissCookiesAndWidgets(page) {
+    // Strategy 1: Click known CMP buttons
+    for (const selector of CMP_SELECTORS) {
+        try {
+            const button = page.locator(selector).first();
+            if (await button.isVisible({ timeout: 500 })) {
+                await button.click({ timeout: 2000 });
+                logger.info(`Cookie dismissed via CMP selector: ${selector}`);
+                await page.waitForTimeout(500);
+                await injectHideCSS(page);
+                return { dismissed: true, method: `cmp:${selector}` };
+            }
+        }
+        catch {
+            // Selector not found or not clickable, try next
+        }
+    }
+    // Strategy 2: Find accept buttons by text in cookie-like containers
+    try {
+        const dismissed = await page.evaluate((patterns) => {
+            const regexPatterns = patterns.map(p => {
+                const match = p.match(/^\/(.*)\/([gimsuy]*)$/);
+                return match ? new RegExp(match[1], match[2]) : new RegExp(p, 'i');
+            });
+            // Find all visible buttons and links
+            const candidates = document.querySelectorAll('button, a, [role="button"], input[type="submit"]');
+            for (const el of candidates) {
+                const htmlEl = el;
+                const text = (htmlEl.textContent || htmlEl.getAttribute('value') || '').trim();
+                if (!text || text.length > 40)
+                    continue;
+                // Check if text matches an accept pattern
+                const matches = regexPatterns.some(rx => rx.test(text));
+                if (!matches)
+                    continue;
+                // Check if it's inside a cookie/consent container.
+                // Only match containers that explicitly identify as cookie/consent/GDPR
+                // via ID, class, role, or aria-label. Do NOT match on position:fixed/sticky
+                // alone — that's too broad and can match unrelated sticky CTAs.
+                let parent = htmlEl;
+                let isCookieContainer = false;
+                for (let depth = 0; depth < 8 && parent; depth++) {
+                    const id = (parent.id || '').toLowerCase();
+                    const className = (parent.className || '').toString().toLowerCase();
+                    const role = (parent.getAttribute('role') || '').toLowerCase();
+                    const ariaLabel = (parent.getAttribute('aria-label') || '').toLowerCase();
+                    const combinedAttrs = `${id} ${className} ${ariaLabel}`;
+                    if (combinedAttrs.includes('cookie') || combinedAttrs.includes('consent') ||
+                        combinedAttrs.includes('gdpr') || combinedAttrs.includes('privacy') ||
+                        combinedAttrs.includes('banner') ||
+                        ((role === 'dialog' || role === 'alertdialog') && combinedAttrs.includes('co'))) {
+                        isCookieContainer = true;
+                        break;
+                    }
+                    parent = parent.parentElement;
+                }
+                if (isCookieContainer) {
+                    htmlEl.click();
+                    return text;
+                }
+            }
+            return null;
+        }, ACCEPT_PATTERNS.map(rx => rx.toString()));
+        if (dismissed) {
+            logger.info(`Cookie dismissed via text match: "${dismissed}"`);
+            await page.waitForTimeout(500);
+            await injectHideCSS(page);
+            return { dismissed: true, method: `text:${dismissed}` };
+        }
+    }
+    catch {
+        // Text-based search failed
+    }
+    // Strategy 3: Always inject CSS to hide known overlays and widgets
+    await injectHideCSS(page);
+    return { dismissed: false, method: null };
+}
+async function injectHideCSS(page) {
+    try {
+        await page.addStyleTag({
+            content: HIDE_SELECTORS.map(s => `${s} { display: none !important; visibility: hidden !important; pointer-events: none !important; }`).join('\n'),
+        });
+    }
+    catch {
+        // Page might have navigated away
+    }
+}
+//# sourceMappingURL=cookie-dismiss.js.map

package/dist/credential-templates.d.ts

@@ -0,0 +1,5 @@
+import type { LoginCredentials } from "./types.js";
+export declare function resolveCredentialTemplates(value: string | undefined, credentials?: LoginCredentials): string | undefined;
+export declare function ensureNoCredentialTemplate(field: string, value: string | undefined): void;
+export declare function sanitizeCredentialParams(params: Record<string, unknown>, credentials?: LoginCredentials): Record<string, unknown>;
+export declare function resolveActionCredentialArgs(action: string, args: Record<string, unknown>, credentials?: LoginCredentials): Record<string, unknown>;

package/dist/credential-templates.js

@@ -0,0 +1,60 @@
+const TEMPLATE_RE = /\{\{credential\.(loginUrl|email|password)\}\}/g;
+export function resolveCredentialTemplates(value, credentials) {
+    if (!value)
+        return value;
+    const replacements = {
+        loginUrl: credentials?.loginUrl,
+        email: credentials?.email,
+        password: credentials?.password,
+    };
+    return value.replace(TEMPLATE_RE, (match, key) => {
+        const replacement = replacements[key];
+        return typeof replacement === "string" ? replacement : match;
+    });
+}
+export function ensureNoCredentialTemplate(field, value) {
+    if (value && TEMPLATE_RE.test(value)) {
+        TEMPLATE_RE.lastIndex = 0;
+        throw new Error(`Missing credential value for ${field}`);
+    }
+    TEMPLATE_RE.lastIndex = 0;
+}
+function sanitizeCredentialString(value, credentials) {
+    if (!credentials)
+        return value;
+    if (credentials.password && value === credentials.password) {
+        return "{{credential.password}}";
+    }
+    if (credentials.email && value === credentials.email) {
+        return "{{credential.email}}";
+    }
+    if (credentials.loginUrl && value === credentials.loginUrl) {
+        return "{{credential.loginUrl}}";
+    }
+    return value;
+}
+export function sanitizeCredentialParams(params, credentials) {
+    const sanitized = {};
+    for (const [key, value] of Object.entries(params)) {
+        sanitized[key] =
+            typeof value === "string"
+                ? sanitizeCredentialString(value, credentials)
+                : value;
+    }
+    return sanitized;
+}
+export function resolveActionCredentialArgs(action, args, credentials) {
+    if (!credentials)
+        return args;
+    const resolved = { ...args };
+    if (action === "type_text" && typeof resolved.text === "string") {
+        resolved.text = resolveCredentialTemplates(resolved.text, credentials);
+        ensureNoCredentialTemplate("type_text.text", resolved.text);
+    }
+    if (action === "navigate_to" && typeof resolved.url === "string") {
+        resolved.url = resolveCredentialTemplates(resolved.url, credentials);
+        ensureNoCredentialTemplate("navigate_to.url", resolved.url);
+    }
+    return resolved;
+}
+//# sourceMappingURL=credential-templates.js.map

package/dist/element-capture.d.ts

@@ -0,0 +1,53 @@
+import { Browser } from './browser.js';
+import type { IsolatedElement, ElementCaptureResult, OutscaleConfig, SelectorValidationResult } from './types.js';
+interface SearchQueryHistoryEntry {
+    candidateLines: string[];
+    domSignature: string;
+    selectors: string[];
+    hasTransientSelectors: boolean;
+    /** Best candidate bounding box for coordinate-based fallback capture. */
+    bestRegion?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    } | null;
+}
+export declare function isLooseElementCaptureRejectionReason(reason: string | null | undefined): boolean;
+export declare function isTagOnlyStructuralSelector(selector: string): boolean;
+export declare function shouldBlockUngroundedStructuralSelector(params: {
+    selector: string;
+    groundedSelectors: Iterable<string>;
+    verifierRejectedAsTooLoose: boolean;
+}): boolean;
+export declare function outscaleAddsPadding(outscale: OutscaleConfig | undefined): boolean;
+export declare function buildVerificationOutscale(outscale: OutscaleConfig | undefined): OutscaleConfig;
+export declare function shouldAcceptDomCorroboratedSelector(params: {
+    looseFailureCount: number;
+    verifierRejectedAsTooLoose: boolean;
+    validation: SelectorValidationResult;
+    viewport: {
+        width: number;
+        height: number;
+    } | null;
+    observedAsInteractive: boolean;
+    directQueryCount: number;
+    containerQueryCount: number;
+}): boolean;
+export declare function computeElementCaptureDomSignature(params: {
+    currentUrl: string;
+    interactiveElements: Array<Pick<Awaited<ReturnType<Browser['getInteractiveElements']>>[number], 'index' | 'tag' | 'role' | 'text' | 'selector' | 'visibilityState'>>;
+}): string;
+export declare function shouldAllowSearchRefresh(params: {
+    cached: SearchQueryHistoryEntry | undefined;
+    domSignature: string;
+    lastFailedTransientSelector: string | null;
+}): boolean;
+interface ElementCaptureOptions {
+    abortSignal?: AbortSignal;
+    distinctId?: string;
+    fallbackModel?: string;
+    uploadImage?: (buffer: Buffer, mimeType: 'image/jpeg' | 'image/png') => Promise<string>;
+}
+export declare function captureIsolatedElement(browser: Browser, element: IsolatedElement, apiKey: string, model: string, options?: ElementCaptureOptions): Promise<ElementCaptureResult>;
+export {};