autokap 1.0.6 → 1.0.8

package/dist/capture-page-identity.js

@@ -0,0 +1,352 @@
+const TOKEN_STOP_WORDS = new Set([
+    "the",
+    "and",
+    "for",
+    "with",
+    "from",
+    "that",
+    "this",
+    "your",
+    "into",
+    "onto",
+    "page",
+    "pages",
+    "state",
+    "screen",
+    "capture",
+    "captures",
+    "screenshot",
+    "screenshots",
+    "open",
+    "opened",
+    "currently",
+    "current",
+    "already",
+    "visible",
+    "show",
+    "showing",
+    "display",
+    "displayed",
+    "view",
+    "interface",
+    "workflow",
+    "project",
+    "projects",
+    "user",
+    "step",
+    "steps",
+    "then",
+    "after",
+    "before",
+    "dans",
+    "pour",
+    "avec",
+    "page",
+    "pages",
+    "etat",
+    "état",
+    "capture",
+    "captures",
+    "ecran",
+    "écran",
+    "ouverte",
+    "ouvert",
+    "affiche",
+    "affiché",
+    "affichee",
+    "affichée",
+    "courante",
+    "actuelle",
+    "deja",
+    "déjà",
+    "interface",
+    "etape",
+    "étape",
+    "click",
+    "clicked",
+    "clicking",
+    "tap",
+    "tapped",
+    "press",
+    "pressed",
+    "navigate",
+    "navigation",
+    "go",
+    "goto",
+    "open",
+    "opening",
+    "wait",
+    "waiting",
+    "load",
+    "loaded",
+    "loading",
+    "select",
+    "selected",
+    "choose",
+    "chosen",
+    "pick",
+    "picked",
+    "launch",
+    "launched",
+    "continue",
+    "continuing",
+    "stop",
+    "stopping",
+    "first",
+    "second",
+    "third",
+    "next",
+    "previous",
+    "left",
+    "right",
+    "top",
+    "bottom",
+    "header",
+    "footer",
+    "sidebar",
+    "toolbar",
+    "menu",
+    "menus",
+    "button",
+    "buttons",
+    "link",
+    "links",
+    "new",
+    "exact",
+    "exactly",
+    "fully",
+    "ensure",
+    "make",
+    "sure",
+    "should",
+    "must",
+    "still",
+    "just",
+    "true",
+    "real",
+    "launching",
+    "lance",
+    "lancer",
+    "ouvrir",
+    "ouvrez",
+    "navigue",
+    "naviguer",
+    "clique",
+    "cliquez",
+    "attend",
+    "attendre",
+    "charge",
+    "charger",
+    "selectionne",
+    "sélectionne",
+    "selectionner",
+    "sélectionner",
+    "choisir",
+    "choisis",
+    "premier",
+    "premiere",
+    "première",
+    "gauche",
+    "droite",
+    "haut",
+    "bas",
+    "menu",
+    "sidebar",
+    "header",
+    "bouton",
+    "boutons",
+    "nouveau",
+    "nouvelle",
+    "exacte",
+    "exactement",
+    "entierement",
+    "entièrement",
+    "assure",
+    "assurez",
+    "doit",
+    "encore",
+    "arrete",
+    "arrête",
+    "arreter",
+    "arrêter",
+]);
+const PAGE_ID_STOP_WORDS = new Set([
+    ...TOKEN_STOP_WORDS,
+    "form",
+    "editor",
+    "edit",
+    "modal",
+    "dialog",
+    "route",
+    "screen",
+    "detail",
+    "details",
+    "config",
+    "configuration",
+    "preview",
+]);
+const COLLECTION_RE = /\b(gallery|grid|list|overview|results?|catalog|library|feed|table|items?|cards?)\b/i;
+const MODAL_RE = /\b(modal|dialog|popup|drawer|overlay)\b/i;
+const SELECTION_RE = /\b(select|selection|choose|pick|picker|library|options?|templates?)\b/i;
+const CONFIGURATION_RE = /\b(edit|editor|editing|config|configuration|configure|settings|details|detail|instructions|textarea|form|modifier|modification|edition|customi[sz]e|compose)\b/i;
+const FOCUSED_DETAIL_RE = /\b(first|selected|opened|individual|single|preview|inspect|expanded|zoom(?:ed)?|detail view|item details?)\b/i;
+const STRONG_ROUTE_PROMPT_RE = /\b(route|dedicated page|full page|editor page|edit page|detail page|screen|view|section)\b/i;
+const PASSIVE_STATE_RE = /\b(currently open|already open|currently displayed|already displayed|without launching|ne la lance pas|sans la lancer|deja ouverte|ouverte actuellement)\b/i;
+function uniqueInOrder(values) {
+    const seen = new Set();
+    const out = [];
+    for (const value of values) {
+        if (seen.has(value))
+            continue;
+        seen.add(value);
+        out.push(value);
+    }
+    return out;
+}
+function tokenize(value) {
+    return value
+        .toLowerCase()
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .split(/[^a-z0-9]+/g)
+        .map((part) => part.trim())
+        .filter((part) => part.length >= 3 && !TOKEN_STOP_WORDS.has(part));
+}
+export function normalizeCaptureIdentityTokens(values, options = {}) {
+    const stopWords = options.stopWords ?? TOKEN_STOP_WORDS;
+    const tokens = [];
+    for (const value of values) {
+        if (!value)
+            continue;
+        const parts = value
+            .toLowerCase()
+            .normalize("NFD")
+            .replace(/[\u0300-\u036f]/g, "")
+            .split(/[^a-z0-9]+/g)
+            .map((part) => part.trim())
+            .filter((part) => part.length >= 3 && !stopWords.has(part));
+        tokens.push(...parts);
+    }
+    return uniqueInOrder(tokens);
+}
+function normalizeUrlPath(rawUrl) {
+    try {
+        return new URL(rawUrl).pathname.toLowerCase();
+    }
+    catch {
+        return rawUrl.toLowerCase();
+    }
+}
+export function buildCapturePageIdentitySummary(kind, tokens, urlPath) {
+    const tokenSummary = tokens.slice(0, 4).join(",");
+    const pathSummary = urlPath.replace(/\/+/g, "/").slice(0, 80) || "/";
+    return `${kind}:${tokenSummary || "none"}@${pathSummary}`;
+}
+function normalizeForMatching(value) {
+    return value
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .toLowerCase();
+}
+function extractPromptSurfaceHints(rawPrompt) {
+    const patterns = [
+        /select ([^.]+?),?\s+and capture/i,
+        /select ([^.]+?) and stop/i,
+        /capture the currently open ([^.]+)/i,
+        /capture the ([^.]+?) with [^.]+ visible/i,
+        /the page should show ([^.]+)/i,
+        /the detail view should show ([^.]+)/i,
+        /the page must show ([^.]+)/i,
+        /stop (?:only )?when ([^.]+)/i,
+        /with ([^.]+?) visible/i,
+        /show the full ([^.]+)/i,
+    ];
+    const hints = [];
+    for (const pattern of patterns) {
+        const match = rawPrompt.match(pattern);
+        if (match?.[1]) {
+            hints.push(match[1]);
+        }
+    }
+    const quoted = Array.from(rawPrompt.matchAll(/["“]([^"”]+)["”]/g), (match) => match[1]);
+    hints.push(...quoted);
+    return uniqueInOrder(hints.filter(Boolean));
+}
+function extractPathMeaningfulTokens(urlPath) {
+    const segments = urlPath
+        .split("/")
+        .map((segment) => segment.trim())
+        .filter(Boolean)
+        .filter((segment) => !/^\d+$/.test(segment) && !/^[a-f0-9]{8,}$/i.test(segment));
+    return normalizeCaptureIdentityTokens(segments, { stopWords: TOKEN_STOP_WORDS });
+}
+export function inferCapturePageIdentity(pageRun) {
+    const rawPrompt = pageRun.prompt.trim();
+    const prompt = normalizeForMatching(rawPrompt);
+    const pageId = pageRun.pageId ?? "main";
+    const urlPath = normalizeUrlPath(pageRun.url);
+    const context = normalizeForMatching(`${pageId} ${rawPrompt} ${urlPath}`);
+    // For dialog/modal detection, only use the prompt and URL — page IDs are user-defined
+    // identifiers that often contain "modal" or "dialog" as naming convention, not as DOM intent.
+    const promptAndUrl = normalizeForMatching(`${rawPrompt} ${urlPath}`);
+    const pathSegments = urlPath.split("/").filter(Boolean);
+    const hasSpecificPath = pathSegments.length >= 2
+        || pathSegments.some((segment) => /[0-9]/.test(segment) || segment.length >= 12);
+    const mentionsCollection = COLLECTION_RE.test(context);
+    const mentionsModal = MODAL_RE.test(promptAndUrl);
+    const mentionsSelection = SELECTION_RE.test(promptAndUrl);
+    const mentionsConfiguration = CONFIGURATION_RE.test(context);
+    const mentionsFocusedDetail = FOCUSED_DETAIL_RE.test(prompt);
+    const passiveState = PASSIVE_STATE_RE.test(prompt);
+    const mentionsDedicatedRoute = !mentionsModal
+        && !passiveState
+        && (STRONG_ROUTE_PROMPT_RE.test(prompt)
+            || (hasSpecificPath && mentionsConfiguration));
+    let kind = "unknown";
+    if (mentionsModal && mentionsSelection && !mentionsConfiguration) {
+        kind = "modal_selection";
+    }
+    else if (mentionsModal && (mentionsConfiguration || passiveState)) {
+        kind = "modal_configuration";
+    }
+    else if (mentionsCollection && mentionsFocusedDetail && !mentionsModal) {
+        kind = "detail_route";
+    }
+    else if (mentionsCollection && !mentionsConfiguration && !mentionsModal && !mentionsSelection) {
+        kind = "gallery";
+    }
+    else if (mentionsConfiguration && mentionsDedicatedRoute && !mentionsModal) {
+        kind = "editor_route";
+    }
+    else if (mentionsConfiguration && (mentionsModal || mentionsSelection || passiveState)) {
+        kind = "modal_configuration";
+    }
+    else if (mentionsModal || mentionsSelection) {
+        kind = "modal_selection";
+    }
+    else if (mentionsConfiguration) {
+        kind = "detail_route";
+    }
+    else if (mentionsCollection) {
+        kind = "gallery";
+    }
+    const promptSurfaceHints = extractPromptSurfaceHints(rawPrompt);
+    const promptSubjectTokens = normalizeCaptureIdentityTokens(promptSurfaceHints.length > 0 ? promptSurfaceHints : [rawPrompt]);
+    const pathSubjectTokens = extractPathMeaningfulTokens(urlPath);
+    const pageIdSubjectTokens = normalizeCaptureIdentityTokens([pageId], {
+        stopWords: PAGE_ID_STOP_WORDS,
+    });
+    const subjectTokens = uniqueInOrder([
+        ...promptSubjectTokens,
+        ...pathSubjectTokens,
+        ...pageIdSubjectTokens,
+    ]).slice(0, 10);
+    return {
+        kind,
+        summary: buildCapturePageIdentitySummary(kind, subjectTokens, urlPath),
+        subjectTokens,
+        dialogTarget: kind === "modal_selection" || kind === "modal_configuration",
+        dedicatedRoute: kind === "editor_route" || (kind === "detail_route" && hasSpecificPath),
+    };
+}
+//# sourceMappingURL=capture-page-identity.js.map

package/dist/capture-preset-credentials.d.ts

@@ -0,0 +1,62 @@
+import { type EncryptedEnvelope } from './capture-encryption.js';
+export interface StoredPresetCredentials {
+    loginUrl?: string;
+    email?: string;
+    password?: string;
+}
+export interface StoredPresetAuthCookie {
+    name: string;
+    value: string;
+    domain: string;
+    path?: string;
+}
+export type StoredPresetAuthCookies = StoredPresetAuthCookie[];
+export interface StoredPresetAuthCookiesMeta {
+    count: number;
+    domains: string[];
+}
+export declare function normalizePresetCredentials(credentials?: Partial<StoredPresetCredentials> | null): StoredPresetCredentials | undefined;
+export declare function hasStoredCredentials(raw: unknown): boolean;
+export declare function encryptPresetCredentials(credentials: StoredPresetCredentials): EncryptedEnvelope;
+export declare function decryptPresetCredentials(value: unknown): StoredPresetCredentials | undefined;
+export declare function normalizePresetAuthCookies(value: unknown): StoredPresetAuthCookies | undefined;
+export declare function encryptPresetAuthCookies(cookies: StoredPresetAuthCookies): EncryptedEnvelope;
+export declare function decryptPresetAuthCookies(value: unknown): StoredPresetAuthCookies | undefined;
+export declare function hasStoredAuthCookies(raw: unknown): boolean;
+export declare function buildAuthCookiesMeta(cookies: StoredPresetAuthCookies): StoredPresetAuthCookiesMeta;
+export interface StorageStateCookie {
+    name: string;
+    value: string;
+    domain: string;
+    path: string;
+    expires: number;
+    httpOnly: boolean;
+    secure: boolean;
+    sameSite: 'Strict' | 'Lax' | 'None';
+}
+export interface StorageStateOrigin {
+    origin: string;
+    localStorage: Array<{
+        name: string;
+        value: string;
+    }>;
+}
+export interface PlaywrightStorageState {
+    cookies: StorageStateCookie[];
+    origins: StorageStateOrigin[];
+}
+/**
+ * Normalize a Playwright storageState payload, dropping anything that doesn't
+ * match the expected shape. Returns undefined if the payload is empty (no
+ * cookies and no origin data).
+ */
+export declare function normalizeStorageState(value: unknown): PlaywrightStorageState | undefined;
+export declare function encryptStorageState(state: PlaywrightStorageState): EncryptedEnvelope;
+export declare function decryptStorageState(value: unknown): PlaywrightStorageState | undefined;
+export declare function summarizeStorageState(state: PlaywrightStorageState): {
+    cookieCount: number;
+    originCount: number;
+    domains: string[];
+};
+export declare function preparePresetConfigForStorage<T extends Record<string, unknown>>(config: T): T;
+export declare function hydratePresetConfigFromStorage<T extends Record<string, unknown>>(raw: unknown): T;

package/dist/capture-preset-credentials.js

@@ -0,0 +1,184 @@
+import { decrypt, encrypt, isEncryptedEnvelope } from './capture-encryption.js';
+function getSecret() {
+    const secret = process.env.PRESET_CREDENTIALS_ENCRYPTION_SECRET;
+    if (!secret) {
+        throw new Error('Missing PRESET_CREDENTIALS_ENCRYPTION_SECRET for preset credential encryption');
+    }
+    return secret;
+}
+export function normalizePresetCredentials(credentials) {
+    if (!credentials)
+        return undefined;
+    const loginUrl = credentials.loginUrl?.trim() || undefined;
+    const email = credentials.email?.trim() || undefined;
+    const password = credentials.password || undefined;
+    if (!loginUrl && !email && !password)
+        return undefined;
+    return {
+        ...(loginUrl ? { loginUrl } : {}),
+        ...(email ? { email } : {}),
+        ...(password ? { password } : {}),
+    };
+}
+export function hasStoredCredentials(raw) {
+    if (!raw || typeof raw !== 'object')
+        return false;
+    return raw.credentials != null;
+}
+export function encryptPresetCredentials(credentials) {
+    return encrypt(JSON.stringify(credentials), getSecret());
+}
+export function decryptPresetCredentials(value) {
+    if (!value)
+        return undefined;
+    if (isEncryptedEnvelope(value)) {
+        const decrypted = decrypt(value, getSecret());
+        return normalizePresetCredentials(JSON.parse(decrypted));
+    }
+    return normalizePresetCredentials(value);
+}
+export function normalizePresetAuthCookies(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const cleaned = [];
+    for (const entry of value) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const candidate = entry;
+        const name = typeof candidate.name === 'string' ? candidate.name.trim() : '';
+        const cookieValue = typeof candidate.value === 'string' ? candidate.value : '';
+        const domain = typeof candidate.domain === 'string' ? candidate.domain.trim().toLowerCase() : '';
+        if (!name || !cookieValue || !domain)
+            continue;
+        const path = typeof candidate.path === 'string' && candidate.path.trim()
+            ? candidate.path.trim()
+            : undefined;
+        cleaned.push({
+            name,
+            value: cookieValue,
+            domain,
+            ...(path ? { path } : {}),
+        });
+    }
+    return cleaned.length > 0 ? cleaned : undefined;
+}
+export function encryptPresetAuthCookies(cookies) {
+    return encrypt(JSON.stringify(cookies), getSecret());
+}
+export function decryptPresetAuthCookies(value) {
+    if (!value)
+        return undefined;
+    if (isEncryptedEnvelope(value)) {
+        const decrypted = decrypt(value, getSecret());
+        return normalizePresetAuthCookies(JSON.parse(decrypted));
+    }
+    return normalizePresetAuthCookies(value);
+}
+export function hasStoredAuthCookies(raw) {
+    if (!raw || typeof raw !== 'object')
+        return false;
+    return raw.authCookies != null;
+}
+export function buildAuthCookiesMeta(cookies) {
+    const domainSet = new Set();
+    for (const cookie of cookies) {
+        if (cookie.domain)
+            domainSet.add(cookie.domain);
+    }
+    return {
+        count: cookies.length,
+        domains: Array.from(domainSet),
+    };
+}
+/**
+ * Normalize a Playwright storageState payload, dropping anything that doesn't
+ * match the expected shape. Returns undefined if the payload is empty (no
+ * cookies and no origin data).
+ */
+export function normalizeStorageState(value) {
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const candidate = value;
+    const cookies = Array.isArray(candidate.cookies)
+        ? candidate.cookies
+            .filter((c) => !!c && typeof c === 'object' && typeof c.name === 'string' && typeof c.value === 'string' && typeof c.domain === 'string')
+            .map((c) => ({
+            name: c.name,
+            value: c.value,
+            domain: c.domain,
+            path: typeof c.path === 'string' ? c.path : '/',
+            expires: typeof c.expires === 'number' ? c.expires : -1,
+            httpOnly: !!c.httpOnly,
+            secure: !!c.secure,
+            sameSite: c.sameSite === 'Strict' || c.sameSite === 'Lax' || c.sameSite === 'None'
+                ? c.sameSite
+                : 'Lax',
+        }))
+        : [];
+    const origins = Array.isArray(candidate.origins)
+        ? candidate.origins
+            .filter((o) => !!o && typeof o === 'object' && typeof o.origin === 'string')
+            .map((o) => ({
+            origin: o.origin,
+            localStorage: Array.isArray(o.localStorage)
+                ? o.localStorage
+                    .filter((entry) => entry && typeof entry === 'object' && typeof entry.name === 'string')
+                    .map((entry) => ({ name: entry.name, value: typeof entry.value === 'string' ? entry.value : '' }))
+                : [],
+        }))
+        : [];
+    if (cookies.length === 0 && origins.length === 0)
+        return undefined;
+    return { cookies, origins };
+}
+export function encryptStorageState(state) {
+    return encrypt(JSON.stringify(state), getSecret());
+}
+export function decryptStorageState(value) {
+    if (!value)
+        return undefined;
+    if (isEncryptedEnvelope(value)) {
+        const decrypted = decrypt(value, getSecret());
+        return normalizeStorageState(JSON.parse(decrypted));
+    }
+    return normalizeStorageState(value);
+}
+export function summarizeStorageState(state) {
+    const domainSet = new Set();
+    for (const cookie of state.cookies) {
+        if (cookie.domain)
+            domainSet.add(cookie.domain);
+    }
+    return {
+        cookieCount: state.cookies.length,
+        originCount: state.origins.length,
+        domains: Array.from(domainSet),
+    };
+}
+export function preparePresetConfigForStorage(config) {
+    const credentials = normalizePresetCredentials(config.credentials);
+    const authCookies = normalizePresetAuthCookies(config.authCookies);
+    return {
+        ...config,
+        ...(credentials
+            ? { credentials: encryptPresetCredentials(credentials) }
+            : { credentials: undefined }),
+        ...(authCookies
+            ? {
+                authCookies: encryptPresetAuthCookies(authCookies),
+                authCookiesMeta: buildAuthCookiesMeta(authCookies),
+            }
+            : { authCookies: undefined, authCookiesMeta: undefined }),
+    };
+}
+export function hydratePresetConfigFromStorage(raw) {
+    const config = (raw && typeof raw === 'object' ? raw : {});
+    const credentials = decryptPresetCredentials(config.credentials);
+    const authCookies = decryptPresetAuthCookies(config.authCookies);
+    return {
+        ...config,
+        ...(credentials ? { credentials } : { credentials: undefined }),
+        ...(authCookies ? { authCookies } : { authCookies: undefined }),
+    };
+}
+//# sourceMappingURL=capture-preset-credentials.js.map

package/dist/capture-request-plan.d.ts

@@ -0,0 +1,58 @@
+import { type ScreenshotPageRunInput, type ScreenshotVariantExecution } from "./capture-run-optimizer.js";
+export type CaptureTheme = "light" | "dark";
+export interface CaptureViewport {
+    width: number;
+    height: number;
+}
+export interface CaptureTargetLike {
+    id: string;
+    label: string;
+    viewport: CaptureViewport;
+    deviceFrame?: string;
+    mockupOptions?: {
+        orientation?: "portrait" | "landscape" | string;
+    } | null;
+}
+export interface CapturePageDefinitionLike {
+    id?: string | null;
+    prompt?: string | null;
+    url?: string | null;
+}
+export interface CaptureRequestPlanInput<TTarget extends CaptureTargetLike = CaptureTargetLike, TElement = unknown> {
+    url: string;
+    prompt?: string | null;
+    targets?: TTarget[] | null;
+    viewports?: CaptureViewport[] | null;
+    deviceFrame?: string | null;
+    mockupOptions?: TTarget["mockupOptions"];
+    outputScale?: number | null;
+    langs?: string[] | null;
+    themes?: Array<CaptureTheme> | null;
+    elements?: TElement[] | null;
+    pages?: CapturePageDefinitionLike[] | null;
+}
+export interface CaptureRequestPlan<TTarget extends CaptureTargetLike = CaptureTargetLike, TElement = unknown> {
+    targets: TTarget[];
+    outputScale: number;
+    langs: string[];
+    themes: Array<CaptureTheme>;
+    elements: TElement[];
+    pageRuns: ScreenshotPageRunInput[];
+    variantPlan: ScreenshotVariantExecution[];
+    requestedCaptureCount: number;
+    totalCaptures: number;
+    /** Warnings about non-fatal issues (e.g. unknown device frames). */
+    warnings: string[];
+}
+export declare function hasNonEmptyCapturePrompt(prompt: string | null | undefined): boolean;
+export declare function getCapturePromptValidationError(input: Pick<CaptureRequestPlanInput, "url" | "prompt" | "pages">): string | null;
+export declare function normalizeOutputScale(scale?: number | null): number;
+export declare function resolveCaptureLangs(raw: unknown): string[];
+export declare function resolveCaptureThemes(raw: unknown): Array<CaptureTheme>;
+export declare function buildCapturePageRuns(input: Pick<CaptureRequestPlanInput, "url" | "prompt" | "pages">): ScreenshotPageRunInput[];
+export declare function normalizeCaptureTargets<TTarget extends CaptureTargetLike = CaptureTargetLike>(input: Pick<CaptureRequestPlanInput<TTarget>, "targets" | "viewports" | "deviceFrame" | "mockupOptions">): Promise<TTarget[]>;
+export declare function sanitizeStorageSegment(value: string | null | undefined): string;
+export declare function getCaptureUrlHostname(value: string | null | undefined): string;
+export declare function normalizeComparableUrl(value: string | null | undefined): string;
+export declare function urlsPointToSameCaptureState(left: string | null | undefined, right: string | null | undefined): boolean;
+export declare function resolveCaptureRequestPlan<TTarget extends CaptureTargetLike = CaptureTargetLike, TElement = unknown>(input: CaptureRequestPlanInput<TTarget, TElement>): Promise<CaptureRequestPlan<TTarget, TElement>>;