autokap 1.0.2 → 1.0.4

package/dist/clip-postprocess.d.ts

@@ -1,42 +0,0 @@
-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

@@ -1,192 +0,0 @@
-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/credential-templates.d.ts

@@ -1,5 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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

@@ -1,53 +0,0 @@
-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 {};