autokap 1.4.3 → 1.5.1

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autokap",
-  "version": "1.4.3",
+  "version": "1.5.1",
   "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;
-}>;