autokap 1.0.5 → 1.0.7

package/dist/capture-variant-state.js

@@ -0,0 +1,156 @@
+import { inferCapturePageIdentity } from "./capture-page-identity.js";
+function normalizePageId(pageId) {
+    return pageId ?? "main";
+}
+export function createVariantCaptureState(pageRuns, precomputedIdentities) {
+    const pageIdentities = precomputedIdentities ?? Object.fromEntries(pageRuns.map((pageRun) => [
+        normalizePageId(pageRun.pageId),
+        inferCapturePageIdentity(pageRun),
+    ]));
+    return {
+        expectedPageIds: pageRuns.map((pageRun) => normalizePageId(pageRun.pageId)),
+        pageIdentities,
+        validatedCaptures: [],
+        captureStatuses: Object.fromEntries(pageRuns.map((pageRun) => [normalizePageId(pageRun.pageId), "pending"])),
+        lastCheckpointId: null,
+        blockedReasons: {},
+        recoveryAttempts: {},
+        repairHistory: [],
+    };
+}
+export function buildVariantManifestContext(params) {
+    const currentPageId = normalizePageId(params.currentPageRun.pageId);
+    const completedPages = params.state.validatedCaptures.map((capture) => capture.pageId);
+    return {
+        expectedPageIds: [...params.state.expectedPageIds],
+        currentPageId,
+        currentPageIdentity: params.state.pageIdentities[currentPageId] ?? null,
+        completedPages,
+        remainingPages: params.state.expectedPageIds.filter((pageId) => !completedPages.includes(pageId)),
+        previousValidatedCaptures: [...params.state.validatedCaptures],
+        captureStatuses: { ...params.state.captureStatuses },
+        lastCheckpointId: params.state.lastCheckpointId,
+        blockedReason: params.state.blockedReasons[currentPageId] ?? null,
+        recoveryAttempts: { ...params.state.recoveryAttempts },
+        repairHistory: [...params.state.repairHistory],
+    };
+}
+export function recordValidatedVariantCapture(params) {
+    const pageId = normalizePageId(params.capture.pageId);
+    const duplicateOfPageId = params.capture.fingerprint
+        ? params.state.validatedCaptures.find((existing) => existing.pageId !== pageId
+            && existing.fingerprint
+            && existing.fingerprint === params.capture.fingerprint)?.pageId ?? null
+        : null;
+    const nextValidated = [
+        ...params.state.validatedCaptures.filter((existing) => existing.pageId !== pageId),
+        {
+            ...params.capture,
+            pageId,
+        },
+    ];
+    return {
+        state: {
+            expectedPageIds: [...params.state.expectedPageIds],
+            pageIdentities: { ...params.state.pageIdentities },
+            validatedCaptures: nextValidated,
+            captureStatuses: {
+                ...params.state.captureStatuses,
+                [pageId]: "completed",
+            },
+            lastCheckpointId: params.checkpointId ?? params.state.lastCheckpointId,
+            blockedReasons: {
+                ...params.state.blockedReasons,
+                [pageId]: null,
+            },
+            recoveryAttempts: { ...params.state.recoveryAttempts },
+            repairHistory: [...params.state.repairHistory],
+        },
+        duplicateOfPageId,
+    };
+}
+export function validateVariantCaptureState(state) {
+    const missingPages = state.expectedPageIds.filter((pageId) => !state.validatedCaptures.some((capture) => capture.pageId === pageId)
+        && state.captureStatuses[pageId] !== "blocked");
+    const blockedPages = state.expectedPageIds
+        .filter((pageId) => state.captureStatuses[pageId] === "blocked")
+        .map((pageId) => ({ pageId, reason: state.blockedReasons[pageId] ?? null }));
+    const duplicatePageIds = [];
+    const seenFingerprints = new Map();
+    for (const capture of state.validatedCaptures) {
+        if (!capture.fingerprint)
+            continue;
+        const existingPageId = seenFingerprints.get(capture.fingerprint);
+        if (existingPageId && existingPageId !== capture.pageId) {
+            duplicatePageIds.push({ pageId: capture.pageId, duplicateOfPageId: existingPageId });
+            continue;
+        }
+        seenFingerprints.set(capture.fingerprint, capture.pageId);
+    }
+    return {
+        ok: missingPages.length === 0 && blockedPages.length === 0 && duplicatePageIds.length === 0,
+        missingPages,
+        blockedPages,
+        duplicatePageIds,
+    };
+}
+export function hasValidatedVariantPage(state, pageId) {
+    const normalized = normalizePageId(pageId);
+    return state.validatedCaptures.some((capture) => capture.pageId === normalized);
+}
+export function getVariantCaptureStatus(state, pageId) {
+    const normalized = normalizePageId(pageId);
+    return state.captureStatuses[normalized] ?? "pending";
+}
+export function markVariantCaptureInProgress(state, pageId) {
+    const normalized = normalizePageId(pageId);
+    return {
+        ...state,
+        captureStatuses: {
+            ...state.captureStatuses,
+            [normalized]: "in_progress",
+        },
+        blockedReasons: {
+            ...state.blockedReasons,
+            [normalized]: null,
+        },
+    };
+}
+export function markVariantCaptureBlocked(params) {
+    const normalized = normalizePageId(params.pageId);
+    return {
+        ...params.state,
+        captureStatuses: {
+            ...params.state.captureStatuses,
+            [normalized]: "blocked",
+        },
+        blockedReasons: {
+            ...params.state.blockedReasons,
+            [normalized]: params.reason,
+        },
+    };
+}
+export function recordVariantRecoveryAttempt(state, pageId) {
+    const normalized = normalizePageId(pageId);
+    return {
+        ...state,
+        recoveryAttempts: {
+            ...state.recoveryAttempts,
+            [normalized]: (state.recoveryAttempts[normalized] ?? 0) + 1,
+        },
+    };
+}
+export function recordVariantRepair(params) {
+    const nextHistory = [...params.state.repairHistory, params.repair];
+    return {
+        ...params.state,
+        repairHistory: nextHistory.slice(-12),
+    };
+}
+export function recordVariantCheckpoint(params) {
+    return {
+        ...params.state,
+        lastCheckpointId: params.checkpoint.id,
+    };
+}
+//# sourceMappingURL=capture-variant-state.js.map

package/dist/cli.js

@@ -10,6 +10,7 @@ import { Browser } from './browser.js';
 import { logger } from './logger.js';
 import { writeConfig, requireConfig, DEFAULT_API_BASE_URL, DEFAULT_WS_URL, } from './cli-config.js';
 import { replaceSkillPlaceholders } from './cli-utils.js';
+import { buildRemoteBrowserClientHello, } from './remote-browser.js';
 // ── Program definition ──────────────────────────────────────────────
 export const program = new Command();
 program
@@ -79,6 +80,7 @@ program
         await cleanup();
     });
     ws.on('open', () => {
+        ws.send(JSON.stringify(buildRemoteBrowserClientHello(version)));
         logger.success('Connected to AutoKap server');
     });
     ws.on('message', async (data) => {
@@ -178,6 +180,12 @@ async function executeBrowserCommand(browser, method, params) {
         case 'closeContext':
             await browser.closeContext();
             return null;
+        case 'recreateContext':
+            await browser.recreateContext(params);
+            return null;
+        case 'setDeviceScaleFactor':
+            await browser.setDeviceScaleFactor(params.deviceScaleFactor);
+            return null;
         // Navigation
         case 'navigateTo':
             await browser.navigateTo(params.url);
@@ -185,6 +193,12 @@ async function executeBrowserCommand(browser, method, params) {
         case 'addCookies':
             await browser.addCookies(params.cookies);
             return null;
+        // Page info (used by RemoteBrowser.currentPage proxy)
+        case 'getPageInfo': return {
+            url: browser.currentPage.url(),
+            viewport: browser.currentPage.viewportSize(),
+        };
+        case 'getPageTitle': return await browser.currentPage.title();
         // Screenshots — serialize buffers to base64
         case 'takeScreenshot': {
             const buf = await browser.takeScreenshot();
@@ -300,6 +314,13 @@ async function executeBrowserCommand(browser, method, params) {
         // Storage
         case 'exportStorageState': return await browser.exportStorageState();
         case 'exportSessionStorage': return await browser.exportSessionStorage();
+        case 'reloadCurrentPage':
+            await browser.reloadCurrentPage(params);
+            return null;
+        case 'writeStorageHintCandidate':
+            return await browser.writeStorageHintCandidate(params);
+        case 'probeSelector':
+            return await browser.probeSelector(params.selector);
         case 'prepareSessionStorage':
             await browser.prepareSessionStorage(params.bundle, params);
             return null;

package/dist/clip-orchestrator.d.ts

@@ -0,0 +1,148 @@
+import type { ClipDefinition, ClipOptions, LoginCredentials, VideoPlan, StepUsage, VideoPhase } from './types.js';
+export interface ClipTarget {
+    id: string;
+    label: string;
+    viewport: {
+        width: number;
+        height: number;
+    };
+}
+export interface ClipOrchestratorConfig {
+    url: string;
+    clips: ClipDefinition[];
+    targets: ClipTarget[];
+    outputScale?: number;
+    langs: string[];
+    themes: Array<'light' | 'dark'>;
+    clipOptions?: ClipOptions;
+    credentials?: LoginCredentials;
+    model: string;
+    apiKey: string;
+    runId: string;
+    presetId?: string;
+    projectId?: string;
+    langInstructions?: string;
+    themeInstructions?: string;
+    navigationInstructions?: string;
+    abortSignal?: AbortSignal;
+    /** Fallback model used when the primary model fails to produce tool calls (e.g. in repair lane). */
+    fallbackModel?: string;
+    /** Per-clip timeout in milliseconds. Default: 180_000 (3 minutes). */
+    perClipTimeoutMs?: number;
+}
+export interface ClipVariantResult {
+    clipId: string;
+    clipName: string;
+    clipScript: string;
+    targetId: string;
+    targetLabel: string;
+    viewportWidth: number;
+    viewportHeight: number;
+    lang: string;
+    theme: string;
+    success: boolean;
+    gifPath?: string;
+    mp4Path?: string;
+    thumbnailPath?: string;
+    durationMs: number;
+    fileSizeBytes?: number;
+    plan?: VideoPlan;
+    stepsExecuted: number;
+    assessment: string;
+    failedPhase?: 'preflight' | 'planning' | 'dry_run' | 'recording' | 'postprocess';
+    failedStepIndex?: number;
+    failedSubphase?: string;
+    usage: StepUsage[];
+}
+export interface ClipOrchestratorResult {
+    results: ClipVariantResult[];
+    totalClips: number;
+    successCount: number;
+}
+export interface ClipOrchestratorCallbacks {
+    onClipStart?: (data: {
+        clipId: string;
+        clipName: string;
+        variantId: string;
+        target: {
+            width: number;
+            height: number;
+        };
+        lang: string;
+        theme: string;
+        clipIndex: number;
+        totalClips: number;
+    }) => void;
+    onClipPhase?: (data: {
+        clipId: string;
+        variantId: string;
+        phase: VideoPhase;
+    }) => void;
+    onClipStep?: (data: {
+        clipId: string;
+        variantId: string;
+        stepIndex: number;
+        total: number;
+        description: string;
+        phase: 'dry_run' | 'recording';
+    }) => void;
+    onClipStepResult?: (data: {
+        clipId: string;
+        variantId: string;
+        stepIndex: number;
+        ok: boolean;
+        reason?: string;
+    }) => void;
+    onClipRecordingDone?: (data: {
+        clipId: string;
+        variantId: string;
+        success: boolean;
+        gifPath?: string;
+        mp4Path?: string;
+        thumbnailPath?: string;
+        durationMs: number;
+        fileSizeBytes?: number;
+        lang: string;
+        theme: string;
+        targetId: string;
+        targetLabel: string;
+        assessment?: string;
+        failedPhase?: 'preflight' | 'planning' | 'dry_run' | 'recording' | 'postprocess';
+        failedStepIndex?: number;
+        failedSubphase?: string;
+    }) => void;
+    onClipPostprocessStart?: (data: {
+        clipId: string;
+        variantId: string;
+    }) => void;
+    onClipPostprocessDone?: (data: {
+        clipId: string;
+        variantId: string;
+        success: boolean;
+        gifPath?: string;
+        mp4Path?: string;
+    }) => void;
+    onClipsAllDone?: (data: {
+        totalClips: number;
+        successCount: number;
+    }) => void;
+    onLog?: (entry: {
+        level: string;
+        message: string;
+        timestamp: number;
+    }) => void;
+    /** Emit a live Playwright screenshot (base64 JPEG) for real-time preview in the UI. */
+    onScreenshot?: (base64: string) => void;
+}
+/**
+ * Run the clip capture pipeline for all clips × targets × langs × themes.
+ *
+ * Hybrid pipeline:
+ * 1. For each (clip, target, lang) — navigate once with the screenshot agent
+ * 2. Share the navigation session across theme variants (light/dark)
+ * 3. For each variant: plan → validate selectors → record → post-process
+ *
+ * Navigation sharing: themes only affect `colorScheme` (a Playwright setting),
+ * so the same navigation session (cookies, localStorage, URL) is reused.
+ */
+export declare function runClipOrchestrator(config: ClipOrchestratorConfig, callbacks?: ClipOrchestratorCallbacks): Promise<ClipOrchestratorResult>;