autokap 1.0.2 → 1.0.3

package/dist/mouse-animation.js

@@ -1,100 +0,0 @@
-/** Ease-in-out cubic timing function */
-function easeInOut(t) {
-    return t < 0.5 ? 4 * t * t * t : 1 - Math.pow(-2 * t + 2, 3) / 2;
-}
-/** Cubic Bezier interpolation */
-function cubicBezier(p0, p1, p2, p3, t) {
-    const mt = 1 - t;
-    return {
-        x: mt ** 3 * p0.x + 3 * mt ** 2 * t * p1.x + 3 * mt * t ** 2 * p2.x + t ** 3 * p3.x,
-        y: mt ** 3 * p0.y + 3 * mt ** 2 * t * p1.y + 3 * mt * t ** 2 * p2.y + t ** 3 * p3.y,
-    };
-}
-function randomOffset(scale) {
-    return (Math.random() - 0.5) * 2 * scale;
-}
-/**
- * Move the mouse from `from` to `to` along a cubic Bezier curve with natural
- * human-like motion: ease-in-out timing, randomized control points, micro-jitter.
- */
-export async function moveMouse(page, from, to, options = {}) {
-    const dx = to.x - from.x;
-    const dy = to.y - from.y;
-    const distance = Math.sqrt(dx * dx + dy * dy);
-    if (distance < 2)
-        return; // Already there
-    const steps = options.steps ?? 30;
-    const durationMs = options.durationMs ?? Math.min(900, Math.max(350, distance * 1.2));
-    const msPerStep = durationMs / steps;
-    // Randomize control points to create a natural curve.
-    // Enforce a minimum arc so short-distance moves still curve visibly.
-    const perpScale = Math.max(30, Math.min(distance * 0.3, 80));
-    const p1 = {
-        x: from.x + dx * 0.25 + randomOffset(perpScale),
-        y: from.y + dy * 0.25 + randomOffset(perpScale),
-    };
-    const p2 = {
-        x: from.x + dx * 0.75 + randomOffset(perpScale),
-        y: from.y + dy * 0.75 + randomOffset(perpScale),
-    };
-    for (let i = 1; i <= steps; i++) {
-        const linearT = i / steps;
-        const t = easeInOut(linearT);
-        const point = cubicBezier(from, p1, p2, to, t);
-        // Add micro-jitter to simulate hand imprecision
-        const jitter = Math.max(0, 1 - linearT) * 1.5; // jitter decreases near destination
-        const jx = randomOffset(jitter);
-        const jy = randomOffset(jitter);
-        await page.mouse.move(point.x + jx, point.y + jy);
-        if (msPerStep > 1) {
-            await page.waitForTimeout(msPerStep);
-        }
-    }
-    // Final move to exact destination (no jitter)
-    await page.mouse.move(to.x, to.y);
-}
-/**
- * Move the mouse to `target` with Bezier curve animation and click.
- *
- * @param fromCurrent - Optional current mouse position. If omitted, the click
- *   is performed at `target` without a preceding Bezier move (first action).
- */
-export async function animatedClick(page, target, fromCurrent, options = {}) {
-    if (fromCurrent) {
-        await moveMouse(page, fromCurrent, target, options);
-    }
-    else {
-        await page.mouse.move(target.x, target.y);
-    }
-    // Brief hover pause before clicking (human-like)
-    await page.waitForTimeout(80 + Math.random() * 80);
-    await page.mouse.down();
-    await page.waitForTimeout(70);
-    await page.mouse.up();
-}
-/**
- * Move the mouse to `target` (for hover/highlight actions) without clicking.
- */
-export async function animatedHover(page, target, fromCurrent, options = {}) {
-    if (fromCurrent) {
-        await moveMouse(page, fromCurrent, target, options);
-    }
-    else {
-        await page.mouse.move(target.x, target.y);
-    }
-    // Brief pause at hover position
-    await page.waitForTimeout(200 + Math.random() * 200);
-}
-/**
- * Type text into the currently focused element at a human-like typing speed.
- * Assumes the field is already focused (via a preceding click).
- */
-export async function humanType(page, text) {
-    for (const char of text) {
-        await page.keyboard.type(char);
-        // 60–120 WPM → ~80–130ms between characters (5 chars per word)
-        const delay = 60 + Math.random() * 80;
-        await page.waitForTimeout(delay);
-    }
-}
-//# sourceMappingURL=mouse-animation.js.map

package/dist/overlay-utils.d.ts

@@ -1,14 +0,0 @@
-import type { Browser } from './browser.js';
-type OverlayLogCallback = (entry: {
-    level: 'error';
-    message: string;
-    timestamp: number;
-}) => void;
-export declare function dismissOverlaysWithLogging(browser: Browser, params: {
-    context: string;
-    onLog?: OverlayLogCallback;
-}): Promise<{
-    dismissed: boolean;
-    method: string | null;
-}>;
-export {};

package/dist/overlay-utils.js

@@ -1,13 +0,0 @@
-import { logger } from './logger.js';
-export async function dismissOverlaysWithLogging(browser, params) {
-    try {
-        return await browser.dismissOverlays();
-    }
-    catch (error) {
-        const message = `Overlay dismissal failed during ${params.context}: ${error.message}`;
-        logger.error(message);
-        params.onLog?.({ level: 'error', message, timestamp: Date.now() });
-        return { dismissed: false, method: null };
-    }
-}
-//# sourceMappingURL=overlay-utils.js.map

package/dist/posthog.d.ts

@@ -1,4 +0,0 @@
-import { PostHog } from 'posthog-node';
-export declare const DISTINCT_ID: string;
-export declare function getPostHog(): PostHog;
-export declare function shutdownPostHog(): Promise<void>;

package/dist/posthog.js

@@ -1,26 +0,0 @@
-import { PostHog } from 'posthog-node';
-import { createHash } from 'node:crypto';
-import { hostname } from 'node:os';
-// Stable anonymous ID derived from machine hostname — no PII collected
-const machineId = createHash('sha256').update(hostname()).digest('hex').slice(0, 16);
-export const DISTINCT_ID = `cli-${machineId}`;
-// Short-lived process (CLI): flush immediately on every event
-let _client = null;
-export function getPostHog() {
-    if (!_client) {
-        _client = new PostHog(process.env.POSTHOG_API_KEY ?? '', {
-            host: process.env.POSTHOG_HOST ?? 'https://eu.i.posthog.com',
-            flushAt: 1,
-            flushInterval: 0,
-            enableExceptionAutocapture: true,
-        });
-    }
-    return _client;
-}
-export async function shutdownPostHog() {
-    if (_client) {
-        await _client.shutdown();
-        _client = null;
-    }
-}
-//# sourceMappingURL=posthog.js.map

package/dist/prompt-cache.d.ts

@@ -1,10 +0,0 @@
-export type PromptCacheStrategy = 'implicit_only' | 'explicit_breakpoints' | 'disabled';
-export interface ProviderRoutingPreference {
-    order?: string[];
-    require?: string[];
-    disallow?: string[];
-}
-export declare function resolvePromptCacheStrategy(model: string, options?: {
-    enableGeminiExplicitBreakpoints?: boolean;
-}): PromptCacheStrategy;
-export declare function hasManualMultiProviderOrder(prefs?: ProviderRoutingPreference | null): boolean;

package/dist/prompt-cache.js

@@ -1,24 +0,0 @@
-export function resolvePromptCacheStrategy(model, options = {}) {
-    const normalized = model.trim().toLowerCase();
-    if (!normalized)
-        return 'disabled';
-    if (normalized.startsWith('anthropic/'))
-        return 'explicit_breakpoints';
-    if (normalized.startsWith('google/') || normalized.includes('gemini')) {
-        return options.enableGeminiExplicitBreakpoints ? 'explicit_breakpoints' : 'implicit_only';
-    }
-    if (normalized.startsWith('x-ai/')
-        || normalized.includes('grok')
-        || normalized.startsWith('openai/')
-        || normalized.startsWith('deepseek/')
-        || normalized.startsWith('moonshot/')
-        || normalized.startsWith('moonshotai/')) {
-        return 'implicit_only';
-    }
-    return 'disabled';
-}
-export function hasManualMultiProviderOrder(prefs) {
-    const providers = prefs?.order?.map((provider) => provider.trim()).filter(Boolean) ?? [];
-    return providers.length > 1;
-}
-//# sourceMappingURL=prompt-cache.js.map

package/dist/prompts.d.ts

@@ -1,167 +0,0 @@
-import type { ChatCompletionContentPart } from 'openai/resources/chat/completions';
-import type { AgentConfig, AgentRunHint, CaptureCursor, CaptureObjective, CaptureHandoffContext, ExecutedAction, InteractiveElement, LoginCredentials, RepairTicket, VariantCaptureManifest, ValidatedSessionProfile, WorkflowScreenshot } from './types.js';
-interface SystemPromptOptions {
-    reasoningLocale?: string;
-}
-export declare function buildSystemPrompt(opts?: SystemPromptOptions): string;
-interface IterationPromptMetrics {
-    elementsChars: number;
-    sessionSummaryChars: number;
-    selectorMemoryChars: number;
-    agentContextChars: number;
-}
-export interface StableAnchorUserMessageParams {
-    userPrompt: string;
-    credentials?: LoginCredentials;
-    currentLang?: string;
-    currentTheme?: 'light' | 'dark';
-    langInstructions?: string;
-    themeInstructions?: string;
-    viewports?: Array<{
-        width: number;
-        height: number;
-    }>;
-    runHints?: AgentRunHint[];
-    selectorMemory?: Record<string, string[]>;
-    sessionProfile?: ValidatedSessionProfile;
-    handoffContext?: CaptureHandoffContext;
-    variantManifest?: VariantCaptureManifest;
-}
-export interface IterationUserMessageParams {
-    userPrompt: string;
-    cleanScreenshotUrl?: string;
-    screenshotUrl: string;
-    /** In dual-model mode, the vision model's text observation replaces images. */
-    visionObservation?: string;
-    /** Simplified DOM structure — primary page context in DOM-first mode. */
-    simplifiedDOM?: string;
-    /** When true, the DOM has not changed since the previous iteration (fingerprint match).
-     *  The prompt emits a compact placeholder instead of the full DOM. */
-    domUnchanged?: boolean;
-    accessibilityTree: string;
-    interactiveElements: InteractiveElement[];
-    actionHistory?: ExecutedAction[];
-    screenshotsTaken: WorkflowScreenshot[];
-    iteration: number;
-    maxIterations: number;
-    credentials?: LoginCredentials;
-    currentLang?: string;
-    currentTheme?: 'light' | 'dark';
-    langInstructions?: string;
-    themeInstructions?: string;
-    viewports?: Array<{
-        width: number;
-        height: number;
-    }>;
-    runHints?: AgentRunHint[];
-    selectorMemory?: Record<string, string[]>;
-    sessionProfile?: ValidatedSessionProfile;
-    hasCredentials?: boolean;
-    salienceCompressionEnabled?: boolean;
-    viewport?: {
-        width: number;
-        height: number;
-    };
-    currentUrl?: string;
-    stuckLoopWarning?: string;
-    lastVerificationFailure?: string;
-    userGuidance?: string[];
-    scrollInfo?: {
-        scrollY: number;
-        scrollHeight: number;
-        viewportHeight: number;
-    };
-    expansionLevel?: number;
-    /** When true, includes the full task context (prompt, session, memory, instructions).
-     *  When false (subsequent iterations), sends only the compact page observation. */
-    isFirstIteration?: boolean;
-    /** Pre-generated action plan from the planning call. Included in first iteration and on stuck loops. */
-    taskPlan?: string;
-    /** Persistent notes stored by the agent via the `note` tool. Re-injected every iteration. */
-    agentNotes?: string[];
-    /** Current active subgoal name (set by `begin_subgoal` tool). */
-    currentSubgoal?: string;
-    /** Completed subgoals with compressed summaries (HiAgent hierarchical memory). */
-    completedSubgoals?: Array<{
-        name: string;
-        summary: string;
-    }>;
-    /** Compact deterministic log of all actions taken so far (survives conversation trimming). */
-    trajectoryLog?: string;
-    /** Live browser state handed off from the previous capture in the same run. */
-    handoffContext?: CaptureHandoffContext;
-    /** Explicit multi-page manifest for the current variant/page. */
-    variantManifest?: VariantCaptureManifest;
-    currentObjective?: CaptureObjective;
-    captureCursor?: CaptureCursor;
-    activeRepairTicket?: RepairTicket | null;
-    remainingCaptureQueue?: string[];
-    cacheLayoutV2?: boolean;
-    /** Reference from variant 1 — what state was achieved for this page in the first variant. */
-    variantReference?: {
-        finalUrl: string;
-        assessment: string;
-        pageTitle: string;
-        /** Full action sequence from variant 1 — helps the LLM retrace the path. */
-        actions?: ExecutedAction[];
-    };
-    /** Compact summary of recent failed actions — prevents the agent from repeating dead-end strategies. */
-    failedAttemptsSummary?: string;
-}
-export declare function buildStableAnchorUserMessage(params: StableAnchorUserMessageParams): {
-    content: ChatCompletionContentPart[];
-    metrics: IterationPromptMetrics;
-};
-export declare function buildIterationUserMessage(params: IterationUserMessageParams): {
-    content: ChatCompletionContentPart[];
-    metrics: IterationPromptMetrics;
-};
-export declare function buildVerificationMessage(params: {
-    userPrompt: string;
-    screenshotUrl: string;
-    previousAssessment: string;
-    runMode?: AgentConfig['runMode'];
-    currentLang?: string;
-    currentTheme?: 'light' | 'dark';
-    pageContext?: {
-        currentUrl?: string;
-        pageTitle?: string;
-    };
-    runHints?: AgentRunHint[];
-    variantManifest?: VariantCaptureManifest;
-    verificationDiagnostics?: {
-        lang?: string;
-        theme?: string;
-    };
-    identityHints?: string[];
-}): ChatCompletionContentPart[];
-export declare function buildVisionObserverPrompt(params: {
-    screenshotUrl: string;
-    currentUrl: string;
-    interactiveElements: InteractiveElement[];
-    userGoal: string;
-    currentLang?: string;
-    currentTheme?: 'light' | 'dark';
-    currentPageId?: string;
-    pageIdentitySummary?: string;
-    currentObjective?: string;
-}): ChatCompletionContentPart[];
-export declare function buildElementSystemPrompt(description: string): string;
-export declare function buildElementIterationMessage(params: {
-    elementName: string;
-    elementDescription: string;
-    accessibilityTree: string;
-    interactiveElements: InteractiveElement[];
-    simplifiedDOM?: string;
-    currentUrl: string;
-    iteration: number;
-    maxIterations: number;
-    actionHistory?: string[];
-    viewport?: {
-        width: number;
-        height: number;
-    };
-    forbiddenSearchQueries?: string[];
-    screenshotUrl?: string;
-}): ChatCompletionContentPart[];
-export {};