autokap 1.4.3 → 1.5.2

package/dist/opcode-actions.js

@@ -81,8 +81,12 @@ export async function executeOpcodeCoreAction(opcode, adapter, context = {}) {
                     ? opcode.textByLocale[context.currentVariant.locale] ?? opcode.text
                     : opcode.text);
                 const text = substituteCredentialPlaceholders(rawText, context.credentials);
+                const keystrokeTimestampsMs = [];
+                const onKeystroke = (timestampMs) => {
+                    keystrokeTimestampsMs.push(timestampMs);
+                };
                 try {
-                    await adapter.type(opcode.selector, text, opcode.clearFirst);
+                    await adapter.type(opcode.selector, text, opcode.clearFirst, { onKeystroke });
                 }
                 catch (error) {
                     if (!opcode.target || !adapter.typeByTarget)
@@ -91,9 +95,9 @@ export async function executeOpcodeCoreAction(opcode, adapter, context = {}) {
                         selector: opcode.selector,
                         target: opcode.target,
                         selectorAlternates: opcode.selectorAlternates,
-                    }, text, opcode.clearFirst);
+                    }, text, opcode.clearFirst, { onKeystroke });
                 }
-                break;
+                return { success: true, keystrokeTimestampsMs };
             }
             case 'PRESS_KEY':
                 await adapter.pressKey(opcode.key);

package/dist/opcode-runner.js

@@ -287,6 +287,9 @@ async function executeOpcode(opcode, index, adapter, verifier, breaker, recovery
         const result = await withTimeout(() => executeOpcodeAction(opcode, index, adapter, artifacts, telemetry, currentVariant, executionState, artifactPlan, mockDataGroups, options, credentials), actionBudgetMs);
         logger.debug(`[opcode ${index}] action exec end — took ${Date.now() - actionStart}ms, success=${result.success}${result.error ? `, error=${result.error}` : ''}`);
         if (preTiming) {
+            const keystrokeOffsetsMs = result.keystrokeTimestampsMs && result.keystrokeTimestampsMs.length > 0
+                ? result.keystrokeTimestampsMs.map((t) => Math.max(0, t - preTiming.clipStartedAt))
+                : undefined;
             opcodeTimings.push({
                 stepIndex: index,
                 stepId: opcode.stepId,
@@ -296,6 +299,7 @@ async function executeOpcode(opcode, index, adapter, verifier, breaker, recovery
                 timecodeStartMs: preTiming.timecodeStartMs,
                 timecodeEndMs: Math.max(0, Date.now() - preTiming.clipStartedAt),
                 bbox: preTiming.bbox,
+                ...(keystrokeOffsetsMs ? { keystrokeOffsetsMs } : {}),
             });
         }
         if (!result.success) {

package/dist/types.d.ts

@@ -583,7 +583,7 @@ export interface ClipOptions {
 /** Usage metadata from a single OpenRouter API call */
 export interface StepUsage {
     stepNumber: number;
-    stepType: 'agent_iteration' | 'verification' | 'element_capture' | 'video_planning' | 'video_variant_classification' | 'video_step_verification' | 'video_step_fix' | 'assistant_chat' | 'studio_creation' | 'studio_iteration' | 'studio_capture_suggestion' | 'mock_data_generation' | 'page_identity_classification' | 'capture_verification' | 'alt_text_generation' | 'healer_invocation' | 'cron_feedback_classification' | 'tts_generation' | 'crm_landing_analysis' | 'crm_mail_generation';
+    stepType: 'agent_iteration' | 'verification' | 'element_capture' | 'video_planning' | 'video_variant_classification' | 'video_step_verification' | 'video_step_fix' | 'assistant_chat' | 'studio_creation' | 'studio_iteration' | 'studio_capture_suggestion' | 'mock_data_generation' | 'page_identity_classification' | 'capture_verification' | 'alt_text_generation' | 'healer_invocation' | 'cron_feedback_classification' | 'tts_generation';
     generationId: string | null;
     modelRequested: string;
     modelUsed: string | null;

package/dist/version-check.d.ts

@@ -0,0 +1,4 @@
+export declare function fetchLatestVersionFromRegistry(): Promise<string | null>;
+export declare function isNewerVersion(latest: string, current: string): boolean;
+export declare function getCachedOrFetchLatest(): Promise<string | null>;
+export declare function displayNewVersionNoticeIfAvailable(currentVersion: string): Promise<void>;

package/dist/version-check.js

@@ -0,0 +1,102 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { logger } from './logger.js';
+import { getConfigDir } from './cli-config.js';
+const NPM_REGISTRY_URL = 'https://registry.npmjs.org/autokap';
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+const FETCH_TIMEOUT_MS = 2500;
+const TOTAL_BUDGET_MS = 1000;
+function getCachePath() {
+    return path.join(getConfigDir(), 'version-check.json');
+}
+async function readCache() {
+    try {
+        const raw = await fs.readFile(getCachePath(), 'utf-8');
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.latestVersion !== 'string' || typeof parsed.checkedAt !== 'number') {
+            return null;
+        }
+        return { latestVersion: parsed.latestVersion, checkedAt: parsed.checkedAt };
+    }
+    catch {
+        return null;
+    }
+}
+async function writeCache(entry) {
+    try {
+        await fs.mkdir(getConfigDir(), { recursive: true });
+        await fs.writeFile(getCachePath(), JSON.stringify(entry, null, 2), 'utf-8');
+    }
+    catch {
+        // Cache write failure is non-fatal; we just won't have a cache next time
+    }
+}
+export async function fetchLatestVersionFromRegistry() {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+    try {
+        const res = await fetch(NPM_REGISTRY_URL, { signal: controller.signal });
+        if (!res.ok)
+            return null;
+        const data = (await res.json());
+        return data['dist-tags']?.latest ?? null;
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function parseSemver(version) {
+    const stripped = version.split('-')[0];
+    const parts = stripped.split('.').map(Number);
+    if (parts.length !== 3 || parts.some(n => !Number.isFinite(n)))
+        return null;
+    return [parts[0], parts[1], parts[2]];
+}
+export function isNewerVersion(latest, current) {
+    const a = parseSemver(latest);
+    const b = parseSemver(current);
+    if (!a || !b)
+        return false;
+    if (a[0] !== b[0])
+        return a[0] > b[0];
+    if (a[1] !== b[1])
+        return a[1] > b[1];
+    return a[2] > b[2];
+}
+function isPreRelease(version) {
+    return version.includes('-');
+}
+export async function getCachedOrFetchLatest() {
+    const cache = await readCache();
+    if (cache && Date.now() - cache.checkedAt < CACHE_TTL_MS) {
+        return cache.latestVersion;
+    }
+    const latest = await fetchLatestVersionFromRegistry();
+    if (latest) {
+        await writeCache({ latestVersion: latest, checkedAt: Date.now() });
+        return latest;
+    }
+    return cache?.latestVersion ?? null;
+}
+export async function displayNewVersionNoticeIfAvailable(currentVersion) {
+    if (isPreRelease(currentVersion))
+        return;
+    try {
+        const latest = await Promise.race([
+            getCachedOrFetchLatest(),
+            new Promise(resolve => setTimeout(() => resolve(null), TOTAL_BUDGET_MS)),
+        ]);
+        if (!latest)
+            return;
+        if (!isNewerVersion(latest, currentVersion))
+            return;
+        logger.info(`A new version of autokap (${latest}) is available, run npm install -g autokap@latest to update`);
+    }
+    catch {
+        // Silent failure — the version check must never block or break the CLI
+    }
+}
+//# sourceMappingURL=version-check.js.map

package/dist/web-playwright-local.d.ts

@@ -38,7 +38,9 @@ export declare class WebPlaywrightLocal implements RuntimeAdapter {
     /**
      * Type into an element using semantic target resolution.
      */
-    typeByTarget(opts: ResolveOptions, text: string, clearFirst?: boolean): Promise<void>;
+    typeByTarget(opts: ResolveOptions, text: string, clearFirst?: boolean, typeOpts?: {
+        onKeystroke?: (timestampMs: number) => void;
+    }): Promise<void>;
     /**
      * Wait for an element using semantic target resolution.
      */
@@ -47,7 +49,9 @@ export declare class WebPlaywrightLocal implements RuntimeAdapter {
      * Scroll an element into view using semantic target resolution.
      */
     scrollIntoViewByTarget(opts: ResolveOptions): Promise<void>;
-    type(selector: string, text: string, clearFirst?: boolean): Promise<void>;
+    type(selector: string, text: string, clearFirst?: boolean, opts?: {
+        onKeystroke?: (timestampMs: number) => void;
+    }): Promise<void>;
     pressKey(key: string): Promise<void>;
     scroll(direction: 'up' | 'down' | 'left' | 'right', amount?: number): Promise<void>;
     scrollIntoView(selector: string): Promise<void>;

package/dist/web-playwright-local.js

@@ -152,14 +152,14 @@ export class WebPlaywrightLocal {
     /**
      * Type into an element using semantic target resolution.
      */
-    async typeByTarget(opts, text, clearFirst = true) {
+    async typeByTarget(opts, text, clearFirst = true, typeOpts) {
         const page = await this.browser.currentPage;
         const resolved = await resolveTarget(page, opts);
         if (!resolved) {
             throw new Error(`cannot find target for typing: ${describeResolveOptions(opts)}`);
         }
         if (this.clipCursor) {
-            await this.typeIntoLocator(resolved.locator, text, clearFirst);
+            await this.typeIntoLocator(resolved.locator, text, clearFirst, typeOpts?.onKeystroke);
             return;
         }
         if (clearFirst) {
@@ -196,10 +196,10 @@ export class WebPlaywrightLocal {
         }
         await resolved.locator.scrollIntoViewIfNeeded({ timeout: 5000 });
     }
-    async type(selector, text, clearFirst = true) {
+    async type(selector, text, clearFirst = true, opts) {
         if (this.clipCursor) {
             const page = await this.browser.currentPage;
-            await this.typeIntoLocator(page.locator(selector).first(), text, clearFirst);
+            await this.typeIntoLocator(page.locator(selector).first(), text, clearFirst, opts?.onKeystroke);
             return;
         }
         await this.browser.typeText(text, { selector, clearFirst });
@@ -878,7 +878,7 @@ export class WebPlaywrightLocal {
     async close() {
         await this.browser.close();
     }
-    async typeIntoLocator(locator, text, clearFirst) {
+    async typeIntoLocator(locator, text, clearFirst, onKeystroke) {
         const page = await this.browser.currentPage;
         await locator.waitFor({ state: 'visible', timeout: 5000 });
         await locator.scrollIntoViewIfNeeded({ timeout: 5000 }).catch(() => undefined);
@@ -895,8 +895,8 @@ export class WebPlaywrightLocal {
         }
         await page.waitForTimeout(70);
         await humanType(page, text, this.clipCursor
-            ? { minDelayMs: 20, maxDelayMs: 45 }
-            : undefined);
+            ? { minDelayMs: 20, maxDelayMs: 45, onKeystroke }
+            : { onKeystroke });
     }
     async seedClipCursor(position) {
         if (!this.clipCursor)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autokap",
-  "version": "1.4.3",
+  "version": "1.5.2",
   "description": "AI-powered CLI tool for capturing clean screenshots of websites",
   "type": "module",
   "main": "./dist/index.js",
@@ -231,8 +231,7 @@
     "satori": "^0.26.0",
     "wawoff2": "^2.0.1",
     "ws": "^8.20.0",
-    "zod": "^4.3.6",
-    "cheerio": "^1.1.2"
+    "zod": "^4.3.6"
   },
   "devDependencies": {
     "@types/node": "^25.3.3",

package/dist/crm/email-fallback.d.ts

@@ -1,16 +0,0 @@
-export interface EmailFallbackOptions {
-    betaListLaunchUrl: string;
-    productUrl: string | null;
-    logger: {
-        info(msg: string): void;
-        warn(msg: string): void;
-        error(msg: string): void;
-    };
-}
-export declare function findEmail(opts: EmailFallbackOptions): Promise<{
-    email: string | null;
-    handle: string | null;
-    lang: string | null;
-}>;
-export declare function extractEmailsFromText(text: string): string[];
-export declare function pickBestEmail(emails: string[], productHostname: string | null): string | null;

package/dist/crm/email-fallback.js

@@ -1,217 +0,0 @@
-const CRAWLER_UA = 'AutoKap-Crawler/1.0 (+https://autokap.app/crawler)';
-const EMAIL_RE = /[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/g;
-const ROLE_PREFIXES = ['founder', 'contact', 'hello', 'team', 'support', 'info'];
-const FREE_MAIL_DOMAINS = new Set(['gmail.com', 'outlook.com', 'hotmail.com', 'yahoo.com', 'protonmail.com', 'icloud.com', 'proton.me']);
-const domainQueues = new Map();
-export async function findEmail(opts) {
-    const visited = [];
-    const emails = new Set();
-    let handle = null;
-    let lang = null;
-    const productHostname = opts.productUrl ? hostnameOf(opts.productUrl) : null;
-    const visit = async (url) => {
-        const page = await fetchPage(url, opts.logger);
-        if (!page)
-            return;
-        visited.push(page);
-        const cheerio = await loadCheerio();
-        const $ = cheerio.load(page.html);
-        handle ??= extractHandle($);
-        if (!lang && productHostname && hostnameOf(page.url) === productHostname && page.status === 200) {
-            lang = extractLanguage($, page.text);
-        }
-        for (const email of extractEmailsFromText(extractMailtos($).join(' ')))
-            emails.add(email);
-        for (const email of extractEmailsFromText(page.text))
-            emails.add(email);
-    };
-    await visit(opts.betaListLaunchUrl);
-    let best = pickBestEmail([...emails], productHostname);
-    if (isHighRankEmail(best, productHostname) && handle) {
-        return { email: best, handle, lang };
-    }
-    const productUrls = buildProductUrls(opts.productUrl);
-    for (const url of productUrls) {
-        if (isHighRankEmail(best, productHostname) && handle)
-            break;
-        await visit(url);
-        best = pickBestEmail([...emails], productHostname);
-    }
-    if (!lang) {
-        const combinedText = visited.map((page) => page.text).join(' ');
-        lang = inferLanguageFromText(combinedText);
-    }
-    return {
-        email: best,
-        handle,
-        lang,
-    };
-}
-export function extractEmailsFromText(text) {
-    const matches = text.match(EMAIL_RE) ?? [];
-    return [...new Set(matches.map((email) => email.toLowerCase()).filter((email) => !isJunkEmail(email)))];
-}
-export function pickBestEmail(emails, productHostname) {
-    if (emails.length === 0)
-        return null;
-    const normalized = [...new Set(emails.map((email) => email.trim().toLowerCase()).filter(Boolean))];
-    if (normalized.length === 0)
-        return null;
-    return normalized.sort((a, b) => rankEmail(a, productHostname) - rankEmail(b, productHostname))[0] ?? null;
-}
-function isJunkEmail(email) {
-    const lower = email.toLowerCase();
-    return lower.includes('example.com')
-        || lower.includes('sentry.io')
-        || lower.includes('wixpress.com')
-        || lower.includes('@2x')
-        || lower.includes('png')
-        || lower.includes('jpg')
-        || lower.includes('svg');
-}
-function rankEmail(email, productHostname) {
-    const domain = email.split('@')[1]?.toLowerCase() ?? '';
-    const local = email.split('@')[0]?.toLowerCase() ?? '';
-    const sameDomain = productHostname ? domainsMatch(domain, productHostname) : false;
-    const roleRank = ROLE_PREFIXES.indexOf(local);
-    const isRole = roleRank !== -1;
-    const isFreeMail = FREE_MAIL_DOMAINS.has(domain);
-    if (sameDomain && isRole)
-        return roleRank;
-    if (sameDomain)
-        return 100;
-    if (isFreeMail && isRole)
-        return 200 + roleRank;
-    if (isFreeMail)
-        return 300;
-    return 400;
-}
-function isHighRankEmail(email, productHostname) {
-    return email !== null && rankEmail(email, productHostname) < 200;
-}
-function domainsMatch(emailDomain, productHostname) {
-    const normalizedHost = stripWww(productHostname);
-    const normalizedEmailDomain = stripWww(emailDomain);
-    return normalizedEmailDomain === normalizedHost || etldOne(normalizedEmailDomain) === etldOne(normalizedHost);
-}
-function etldOne(hostname) {
-    const parts = stripWww(hostname).split('.').filter(Boolean);
-    return parts.length <= 2 ? parts.join('.') : parts.slice(-2).join('.');
-}
-function stripWww(hostname) {
-    return hostname.toLowerCase().replace(/^www\./, '');
-}
-function buildProductUrls(productUrl) {
-    if (!productUrl)
-        return [];
-    try {
-        const base = new URL(productUrl);
-        const urls = [base.toString()];
-        for (const pathname of ['/contact', '/about', '/legal', '/mentions-legales']) {
-            const next = new URL(base.toString());
-            next.pathname = pathname;
-            next.search = '';
-            next.hash = '';
-            urls.push(next.toString());
-        }
-        return [...new Set(urls)];
-    }
-    catch {
-        return [];
-    }
-}
-async function fetchPage(url, logger) {
-    let parsed;
-    try {
-        parsed = new URL(url);
-    }
-    catch {
-        return null;
-    }
-    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:')
-        return null;
-    await waitForDomainTurn(parsed.hostname);
-    try {
-        const response = await fetch(parsed.toString(), {
-            headers: {
-                Accept: 'text/html',
-                'User-Agent': CRAWLER_UA,
-            },
-            signal: AbortSignal.timeout(15_000),
-        });
-        if (!response.ok) {
-            logger.warn(`[crm-email] Fetch returned HTTP ${response.status} for ${parsed.toString()}`);
-            return null;
-        }
-        const html = await response.text();
-        const cheerio = await loadCheerio();
-        const $ = cheerio.load(html);
-        $('script, style, noscript, svg').remove();
-        return {
-            html,
-            text: $('body').text().replace(/\s+/g, ' ').trim(),
-            url: response.url || parsed.toString(),
-            status: response.status,
-        };
-    }
-    catch (error) {
-        logger.warn(`[crm-email] Fetch failed for ${parsed.toString()}: ${error.message}`);
-        return null;
-    }
-}
-async function waitForDomainTurn(hostname) {
-    const previous = domainQueues.get(hostname) ?? Promise.resolve();
-    let release = () => { };
-    const current = previous.then(() => new Promise((resolve) => {
-        release = resolve;
-    }));
-    domainQueues.set(hostname, current);
-    await previous;
-    setTimeout(release, 1_000);
-}
-async function loadCheerio() {
-    const importer = new Function('specifier', 'return import(specifier)');
-    return importer('cheerio');
-}
-function extractMailtos($) {
-    return $('a[href^="mailto:"]').toArray().map((anchor) => {
-        const href = $(anchor).attr('href') ?? '';
-        return decodeURIComponent(href.replace(/^mailto:/i, '').split('?')[0] ?? '');
-    });
-}
-function extractHandle($) {
-    for (const anchor of $('a[href]').toArray()) {
-        const href = $(anchor).attr('href') ?? '';
-        const twitter = href.match(/(?:twitter\.com|x\.com)\/([A-Za-z0-9_]{1,20})(?:[/?#]|$)/i);
-        if (twitter)
-            return `@${twitter[1]}`;
-        const linkedin = href.match(/linkedin\.com\/in\/([^/?#]+)/i);
-        if (linkedin)
-            return linkedin[1] ?? null;
-    }
-    return null;
-}
-function extractLanguage($, text) {
-    const lang = $('html').attr('lang')?.trim().split(/[-_]/)[0]?.toLowerCase();
-    if (lang)
-        return lang;
-    return inferLanguageFromText(text);
-}
-function inferLanguageFromText(text) {
-    if (!text)
-        return null;
-    if (/\b(bonjour|merci|à propos|mentions légales)\b/i.test(text))
-        return 'fr';
-    if (/\b(the|and|contact|about|privacy|terms|login|sign in)\b/i.test(text))
-        return 'en';
-    return null;
-}
-function hostnameOf(value) {
-    try {
-        return new URL(value).hostname;
-    }
-    catch {
-        return null;
-    }
-}
-//# sourceMappingURL=email-fallback.js.map

package/dist/crm/run-campaign.d.ts

@@ -1,28 +0,0 @@
-import { type Browser } from 'playwright';
-import { findEmail } from './email-fallback.js';
-import { scrapeBetaListLaunches } from './scrape-betalist.js';
-import { scrapeLanding } from './scrape-landing.js';
-export interface RunCampaignOptions {
-    runId: string;
-    lookbackDays: number;
-    apiBaseUrl: string;
-    runToken: string;
-    logger: {
-        info(msg: string): void;
-        warn(msg: string): void;
-        error(msg: string): void;
-    };
-}
-export interface RunCampaignDeps {
-    scrapeLaunches?: typeof scrapeBetaListLaunches;
-    scrapeLanding?: typeof scrapeLanding;
-    findEmail?: typeof findEmail;
-    fetch?: typeof fetch;
-    launchBrowser?: () => Promise<Browser>;
-}
-export declare function runCampaign(opts: RunCampaignOptions, deps?: RunCampaignDeps): Promise<{
-    scraped: number;
-    inserted: number;
-    disqualified: number;
-    skipped: number;
-}>;