autokap 1.4.0 → 1.4.2

package/dist/crm/run-campaign.js

@@ -0,0 +1,405 @@
+import fs from 'node:fs/promises';
+import { chromium } from 'playwright';
+import { findEmail } from './email-fallback.js';
+import { scrapeBetaListLaunches } from './scrape-betalist.js';
+import { scrapeLanding } from './scrape-landing.js';
+import { LandingShotEndpointMissingError, uploadLandingShot } from './storage-upload.js';
+const CRAWLER_UA = 'AutoKap-Crawler/1.0 (+https://autokap.app/crawler)';
+// TODO(parent): read CRM vision model from a config slot after Phase B settles.
+const DEFAULT_VISION_MODEL = 'openai/gpt-5.2-mini';
+export async function runCampaign(opts, deps = {}) {
+    const fetchImpl = deps.fetch ?? globalThis.fetch;
+    const apiBaseUrl = opts.apiBaseUrl.replace(/\/+$/, '');
+    const logger = opts.logger;
+    let browser = null;
+    const context = {
+        apiBaseUrl,
+        runId: opts.runId,
+        runToken: opts.runToken,
+        logger,
+        fetchImpl,
+    };
+    try {
+        await postCheckpoint(context, { type: 'run_start', message: 'CLI booted, fetching launches' });
+        const launches = await (deps.scrapeLaunches ?? scrapeBetaListLaunches)({
+            lookbackDays: opts.lookbackDays,
+            userAgent: CRAWLER_UA,
+            logger,
+        });
+        if (launches.length === 0) {
+            await postCheckpoint(context, { type: 'page_fetched', scraped_count: 0 });
+            await postFinish(context, 'completed');
+            return { scraped: 0, inserted: 0, disqualified: 0, skipped: 0 };
+        }
+        await postCheckpoint(context, {
+            type: 'page_fetched',
+            scraped_count: launches.length,
+            message: `Found ${launches.length} launches`,
+        });
+        browser = deps.launchBrowser
+            ? await deps.launchBrowser()
+            : await chromium.launch({
+                args: process.platform === 'linux'
+                    ? ['--no-sandbox', '--disable-setuid-sandbox', '--disable-dev-shm-usage']
+                    : [],
+                headless: true,
+            });
+        const counters = { inserted: 0, disqualified: 0, skipped: 0 };
+        let lastProgressAt = 0;
+        const sendProgress = async (force = false) => {
+            const now = Date.now();
+            if (!force && now - lastProgressAt < 5_000)
+                return;
+            lastProgressAt = now;
+            await postCheckpoint(context, {
+                type: 'progress',
+                scraped_count: launches.length,
+                inserted_count: counters.inserted,
+                disqualified_count: counters.disqualified,
+                skipped_count: counters.skipped,
+            });
+        };
+        await processWithConcurrency(launches, 2, async (launch) => {
+            await processLaunch({
+                launch,
+                browser: browser,
+                counters,
+                context,
+                scrapeLandingFn: deps.scrapeLanding ?? scrapeLanding,
+                findEmailFn: deps.findEmail ?? findEmail,
+            });
+            await sendProgress();
+        });
+        await sendProgress(true);
+        await postFinish(context, 'completed');
+        return {
+            scraped: launches.length,
+            inserted: counters.inserted,
+            disqualified: counters.disqualified,
+            skipped: counters.skipped,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        await postCheckpoint(context, { type: 'error', errorMessage: message, message });
+        await postFinish(context, 'failed', message);
+        throw error;
+    }
+    finally {
+        if (browser) {
+            await browser.close().catch((error) => {
+                logger.warn(`[crm-run] Browser close failed: ${error.message}`);
+            });
+        }
+    }
+}
+async function processLaunch(args) {
+    const { launch, counters, context, scrapeLandingFn, findEmailFn } = args;
+    const noFitReason = disqualifyReason(launch);
+    if (noFitReason) {
+        const response = await postProspect(context, {
+            ...baseProspect(launch),
+            status: 'closed_no_fit',
+            signals: { is_web_app: false },
+            free_signals: [{ label: noFitReason, weight: 0 }],
+        });
+        if (response?.status === 201)
+            counters.disqualified += 1;
+        else if (response?.status === 200)
+            counters.skipped += 1;
+        await postCheckpoint(context, {
+            type: 'launch_disqualified',
+            disqualified_count: counters.disqualified,
+            skipped_count: counters.skipped,
+            message: `${launch.productName} disqualified: ${noFitReason}`,
+        });
+        return;
+    }
+    const productUrl = launch.productUrl;
+    const scrape = await scrapeLandingFn({
+        productUrl,
+        userAgent: CRAWLER_UA,
+        logger: context.logger,
+        browser: args.browser,
+    });
+    if (scrape.error === 'robots_disallowed' || scrape.screenshotPath === null) {
+        const contact = await findEmailFn({
+            betaListLaunchUrl: launch.sourceUrl,
+            productUrl: launch.productUrl,
+            logger: context.logger,
+        });
+        const response = await postProspect(context, {
+            ...baseProspect(launch),
+            creator_email: contact.email ?? launch.creatorEmail,
+            creator_handle: contact.handle ?? launch.creatorHandle,
+            creator_lang: contact.lang ?? launch.creatorLang,
+            status: 'to_contact',
+            signals: { is_web_app: scrape.isWebApp, scrape_blocked: true },
+            free_signals: [{ label: 'scrape_blocked', weight: 0 }],
+        });
+        countInsertedOrSkipped(response, counters);
+        await postCheckpoint(context, {
+            type: 'launch_inserted',
+            inserted_count: counters.inserted,
+            skipped_count: counters.skipped,
+            message: `${launch.productName} inserted with scrape blocked`,
+        });
+        return;
+    }
+    const vision = await analyzeWithOptionalVision(context, launch, scrape);
+    const contact = await findEmailFn({
+        betaListLaunchUrl: launch.sourceUrl,
+        productUrl: launch.productUrl,
+        logger: context.logger,
+    });
+    const signals = mergeSignals(scrape, vision);
+    const freeSignals = sanitizeFreeSignals(vision?.free_signals ?? []);
+    const email = contact.email ?? launch.creatorEmail;
+    const response = await postProspect(context, {
+        ...baseProspect(launch),
+        creator_email: email,
+        creator_handle: contact.handle ?? launch.creatorHandle,
+        creator_lang: contact.lang ?? vision?.creator_lang_guess ?? launch.creatorLang,
+        status: email ? 'to_contact' : 'email_missing',
+        signals,
+        free_signals: freeSignals,
+    });
+    countInsertedOrSkipped(response, counters);
+    await postCheckpoint(context, {
+        type: 'launch_inserted',
+        inserted_count: counters.inserted,
+        skipped_count: counters.skipped,
+        message: `${launch.productName} inserted`,
+    });
+}
+function disqualifyReason(launch) {
+    if (!launch.productUrl)
+        return 'no_product_url';
+    const text = `${launch.productName} ${launch.tagline ?? ''}`;
+    if (/\b(iOS only|App Store only|iPhone only|iPad only|Android only|Google Play only|hardware|physical product)\b/i.test(text)) {
+        return 'not_web_app';
+    }
+    return null;
+}
+function baseProspect(launch) {
+    return {
+        source_url: launch.sourceUrl,
+        product_name: launch.productName,
+        product_url: launch.productUrl,
+        creator_name: launch.creatorName,
+        creator_email: launch.creatorEmail,
+        creator_lang: launch.creatorLang,
+        creator_handle: launch.creatorHandle,
+    };
+}
+function countInsertedOrSkipped(response, counters) {
+    if (response?.status === 201)
+        counters.inserted += 1;
+    else if (response?.status === 200)
+        counters.skipped += 1;
+}
+async function analyzeWithOptionalVision(context, launch, scrape) {
+    if (!scrape.screenshotPath)
+        return null;
+    try {
+        const pngBuffer = await fs.readFile(scrape.screenshotPath);
+        const upload = await uploadLandingShot({
+            runId: context.runId,
+            sourceUrl: launch.sourceUrl,
+            pngBuffer,
+            apiBaseUrl: context.apiBaseUrl,
+            runToken: context.runToken,
+        });
+        return await analyzeLandingWithVision({
+            signedUrl: upload.signedUrl,
+            rawText: scrape.rawText,
+            model: DEFAULT_VISION_MODEL,
+            fetchImpl: context.fetchImpl,
+        });
+    }
+    catch (error) {
+        if (error instanceof LandingShotEndpointMissingError || error.message === 'LANDING_SHOT_ENDPOINT_MISSING') {
+            context.logger.warn('[crm-run] Landing-shot endpoint missing; vision skipped');
+            return null;
+        }
+        context.logger.warn(`[crm-run] Vision analysis skipped for ${launch.sourceUrl}: ${error.message}`);
+        return null;
+    }
+}
+function mergeSignals(scrape, vision) {
+    return {
+        n_screenshots: clampInt(vision?.n_screenshots ?? scrape.htmlSignals.n_screenshots_html ?? 0, 0, 50),
+        has_video: vision?.has_video ?? scrape.htmlSignals.has_video_html ?? false,
+        has_docs: vision?.has_docs ?? scrape.htmlSignals.has_docs_html ?? false,
+        has_dashboard: vision?.has_dashboard ?? scrape.htmlSignals.has_dashboard_html ?? false,
+        beta_list_quality: vision?.beta_list_quality_inferred,
+        is_web_app: vision?.is_web_app ?? scrape.isWebApp,
+    };
+}
+function sanitizeFreeSignals(value) {
+    return value.slice(0, 8).map((signal) => ({
+        label: signal.label.slice(0, 120),
+        weight: clampInt(signal.weight, -5, 5),
+    })).filter((signal) => signal.label.trim().length > 0);
+}
+function clampInt(value, min, max) {
+    const int = Math.trunc(Number.isFinite(value) ? value : min);
+    return Math.max(min, Math.min(max, int));
+}
+async function postCheckpoint(context, body) {
+    try {
+        const response = await context.fetchImpl(`${context.apiBaseUrl}/api/cli/crm/runs/${context.runId}/checkpoint`, {
+            method: 'POST',
+            headers: jsonAuthHeaders(context.runToken),
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(15_000),
+        });
+        if (!response.ok) {
+            const responseBody = await response.text().catch(() => response.statusText);
+            context.logger.warn(`[crm-run] checkpoint POST failed: status=${response.status} body=${responseBody.slice(0, 300)}`);
+        }
+    }
+    catch (error) {
+        context.logger.warn(`[crm-run] checkpoint POST errored: ${error.message}`);
+    }
+}
+async function postProspect(context, body) {
+    try {
+        const response = await context.fetchImpl(`${context.apiBaseUrl}/api/cli/crm/runs/${context.runId}/prospect`, {
+            method: 'POST',
+            headers: jsonAuthHeaders(context.runToken),
+            body: JSON.stringify(body),
+            signal: AbortSignal.timeout(15_000),
+        });
+        const text = await response.text().catch(() => '');
+        const json = text ? JSON.parse(text) : null;
+        if (!response.ok) {
+            context.logger.warn(`[crm-run] prospect POST failed: status=${response.status} body=${text.slice(0, 500)}`);
+            return null;
+        }
+        return { status: response.status, json };
+    }
+    catch (error) {
+        context.logger.warn(`[crm-run] prospect POST errored: ${error.message}`);
+        return null;
+    }
+}
+async function postFinish(context, status, errorMessage) {
+    try {
+        const response = await context.fetchImpl(`${context.apiBaseUrl}/api/cli/crm/runs/${context.runId}/finish`, {
+            method: 'POST',
+            headers: jsonAuthHeaders(context.runToken),
+            body: JSON.stringify(errorMessage ? { status, errorMessage } : { status }),
+            signal: AbortSignal.timeout(15_000),
+        });
+        if (!response.ok) {
+            const body = await response.text().catch(() => response.statusText);
+            context.logger.warn(`[crm-run] finish POST failed: status=${response.status} body=${body.slice(0, 300)}`);
+        }
+    }
+    catch (error) {
+        context.logger.warn(`[crm-run] finish POST errored: ${error.message}`);
+    }
+}
+function jsonAuthHeaders(runToken) {
+    return {
+        Authorization: `Bearer ${runToken}`,
+        'Content-Type': 'application/json',
+    };
+}
+async function processWithConcurrency(items, concurrency, worker) {
+    let nextIndex = 0;
+    const workers = Array.from({ length: Math.min(concurrency, items.length) }, async () => {
+        while (nextIndex < items.length) {
+            const item = items[nextIndex];
+            nextIndex += 1;
+            if (item !== undefined)
+                await worker(item);
+        }
+    });
+    await Promise.all(workers);
+}
+async function analyzeLandingWithVision(args) {
+    const apiKey = process.env.OPENROUTER_API_KEY;
+    if (!apiKey)
+        throw new Error('OPENROUTER_API_KEY missing');
+    const fetchImpl = args.fetchImpl ?? globalThis.fetch;
+    const response = await fetchImpl('https://openrouter.ai/api/v1/chat/completions', {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            'Content-Type': 'application/json',
+            'HTTP-Referer': 'https://autokap.app',
+            'X-Title': 'AutoKap CRM Scraper',
+        },
+        body: JSON.stringify({
+            model: args.model,
+            messages: [
+                {
+                    role: 'system',
+                    content: 'Analyze a SaaS product landing page screenshot and text. Return one JSON object with EXACT keys: n_screenshots (int 0..50, count product-screenshot-like images visible), has_video (bool, demo or product video), has_docs (bool, link to docs/api docs visible), has_dashboard (bool, mentions or shows a dashboard/app interface), is_web_app (bool, false if iOS/Android/hardware-only), beta_list_quality_inferred ("clean" | "sloppy", based on visual polish), free_signals (array of { label: string<=120, weight: int -5..5 } for notable strengths or weaknesses, max 6), creator_lang_guess ("fr" | "en" | null). Be terse and respond ONLY with JSON.',
+                },
+                {
+                    role: 'user',
+                    content: [
+                        { type: 'text', text: args.rawText.slice(0, 4000) },
+                        { type: 'image_url', image_url: { url: args.signedUrl } },
+                    ],
+                },
+            ],
+            response_format: { type: 'json_object' },
+            temperature: 0,
+        }),
+        signal: AbortSignal.timeout(60_000),
+    });
+    if (!response.ok) {
+        const body = await response.text().catch(() => response.statusText);
+        throw new Error(`OpenRouter HTTP ${response.status}: ${body.slice(0, 300)}`);
+    }
+    const json = await response.json().catch(() => null);
+    const content = json?.choices?.[0]?.message?.content;
+    if (typeof content !== 'string')
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+    return validateVisionAnalysis(parsed);
+}
+function validateVisionAnalysis(value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    const input = value;
+    const output = {};
+    if (typeof input.n_screenshots === 'number')
+        output.n_screenshots = clampInt(input.n_screenshots, 0, 50);
+    if (typeof input.has_video === 'boolean')
+        output.has_video = input.has_video;
+    if (typeof input.has_docs === 'boolean')
+        output.has_docs = input.has_docs;
+    if (typeof input.has_dashboard === 'boolean')
+        output.has_dashboard = input.has_dashboard;
+    if (typeof input.is_web_app === 'boolean')
+        output.is_web_app = input.is_web_app;
+    if (input.beta_list_quality_inferred === 'clean' || input.beta_list_quality_inferred === 'sloppy') {
+        output.beta_list_quality_inferred = input.beta_list_quality_inferred;
+    }
+    if (input.creator_lang_guess === 'fr' || input.creator_lang_guess === 'en' || input.creator_lang_guess === null) {
+        output.creator_lang_guess = input.creator_lang_guess;
+    }
+    if (Array.isArray(input.free_signals)) {
+        output.free_signals = sanitizeFreeSignals(input.free_signals.flatMap((item) => {
+            if (!item || typeof item !== 'object')
+                return [];
+            const signal = item;
+            if (typeof signal.label !== 'string' || typeof signal.weight !== 'number')
+                return [];
+            return [{ label: signal.label, weight: signal.weight }];
+        }).slice(0, 6));
+    }
+    return output;
+}
+//# sourceMappingURL=run-campaign.js.map

package/dist/crm/scrape-betalist.d.ts

@@ -0,0 +1,20 @@
+export type BetaListLaunch = {
+    sourceUrl: string;
+    productName: string;
+    productUrl: string | null;
+    creatorName: string | null;
+    creatorEmail: string | null;
+    creatorHandle: string | null;
+    creatorLang: string | null;
+    tagline?: string | null;
+};
+export interface ScrapeBetaListOptions {
+    lookbackDays: number;
+    userAgent: string;
+    logger: {
+        info(msg: string): void;
+        warn(msg: string): void;
+        error(msg: string): void;
+    };
+}
+export declare function scrapeBetaListLaunches(opts: ScrapeBetaListOptions): Promise<BetaListLaunch[]>;

package/dist/crm/scrape-betalist.js

@@ -0,0 +1,194 @@
+const BETALIST_ORIGIN = 'https://betalist.com/';
+export async function scrapeBetaListLaunches(opts) {
+    let html;
+    try {
+        const response = await fetch(BETALIST_ORIGIN, {
+            headers: {
+                Accept: 'text/html',
+                'User-Agent': opts.userAgent,
+            },
+            signal: AbortSignal.timeout(15_000),
+        });
+        if (!response.ok) {
+            opts.logger.warn(`[crm-betalist] BetaList fetch returned HTTP ${response.status}`);
+            return [];
+        }
+        html = await response.text();
+    }
+    catch (error) {
+        opts.logger.warn(`[crm-betalist] BetaList fetch failed: ${error.message}`);
+        return [];
+    }
+    const cheerio = await loadCheerio();
+    const $ = cheerio.load(html);
+    const launches = [];
+    const seen = new Set();
+    $('a[href^="/startups/"], a[href*="betalist.com/startups/"]').each((_, anchor) => {
+        const href = $(anchor).attr('href');
+        if (!href)
+            return;
+        const sourceUrl = canonicalBetaListUrl(href);
+        if (!sourceUrl || seen.has(sourceUrl))
+            return;
+        const container = closestLaunchContainer($, anchor);
+        const productName = extractProductName($, anchor, container);
+        if (!productName) {
+            opts.logger.warn(`[crm-betalist] Missing product name for ${sourceUrl}`);
+            return;
+        }
+        const launchDate = parseLaunchDateForRow($, container);
+        if (launchDate && !isWithinLookback(launchDate, opts.lookbackDays))
+            return;
+        const productUrl = extractProductUrl($, container, sourceUrl);
+        const text = container.text().replace(/\s+/g, ' ').trim();
+        const creatorHandle = extractHandleFromHtml(container.html() ?? '');
+        launches.push({
+            sourceUrl,
+            productName,
+            productUrl,
+            creatorName: extractCreatorName($, container),
+            creatorEmail: extractEmail(text),
+            creatorHandle,
+            creatorLang: null,
+            tagline: extractTagline($, container, productName),
+        });
+        seen.add(sourceUrl);
+    });
+    if (launches.length === 0) {
+        opts.logger.warn('[crm-betalist] No BetaList launch links found on homepage');
+    }
+    return launches;
+}
+function canonicalBetaListUrl(href) {
+    try {
+        const url = new URL(href, BETALIST_ORIGIN);
+        if (url.hostname !== 'betalist.com' && url.hostname !== 'www.betalist.com')
+            return null;
+        if (!url.pathname.startsWith('/startups/'))
+            return null;
+        url.hash = '';
+        url.search = '';
+        return url.toString();
+    }
+    catch {
+        return null;
+    }
+}
+async function loadCheerio() {
+    const importer = new Function('specifier', 'return import(specifier)');
+    return importer('cheerio');
+}
+function closestLaunchContainer($, anchor) {
+    const candidates = $(anchor).parents('article, li, tr, div, section').toArray();
+    for (const candidate of candidates) {
+        const row = $(candidate);
+        const text = row.text().replace(/\s+/g, ' ').trim();
+        if (row.find('a[href^="/startups/"], a[href*="betalist.com/startups/"]').length >= 1 && text.length > 0) {
+            return row;
+        }
+    }
+    return $(anchor).parent();
+}
+function extractProductName($, anchor, container) {
+    const direct = $(anchor).text().replace(/\s+/g, ' ').trim();
+    if (direct && direct.length <= 200)
+        return direct;
+    const heading = container.find('h1, h2, h3, h4, [class*="title"], [class*="name"]').first().text().replace(/\s+/g, ' ').trim();
+    if (heading && heading.length <= 200)
+        return heading;
+    return null;
+}
+function extractProductUrl($, container, sourceUrl) {
+    const links = container.find('a[href]').toArray();
+    for (const link of links) {
+        const href = $(link).attr('href');
+        if (!href)
+            continue;
+        const text = $(link).text().replace(/\s+/g, ' ').trim().toLowerCase();
+        if (!text.includes('visit') && !text.includes('website'))
+            continue;
+        const resolved = resolveExternalUrl(href);
+        if (resolved && resolved !== sourceUrl)
+            return resolved;
+    }
+    for (const link of links) {
+        const href = $(link).attr('href');
+        const resolved = href ? resolveExternalUrl(href) : null;
+        if (resolved && !resolved.includes('betalist.com/startups/'))
+            return resolved;
+    }
+    return null;
+}
+function resolveExternalUrl(href) {
+    try {
+        const url = new URL(href, BETALIST_ORIGIN);
+        if (url.hostname === 'betalist.com' || url.hostname === 'www.betalist.com')
+            return null;
+        return url.toString();
+    }
+    catch {
+        return null;
+    }
+}
+function parseLaunchDateForRow($, container) {
+    const time = container.find('time[datetime]').first().attr('datetime');
+    const parsedTime = parseDate(time);
+    if (parsedTime)
+        return parsedTime;
+    const localDate = parseDate(container.find('time').first().text());
+    if (localDate)
+        return localDate;
+    const previous = container.prevAll('h1, h2, h3, h4, time, [datetime]').slice(0, 5).toArray();
+    for (const element of previous) {
+        const value = $(element).attr('datetime') ?? $(element).text();
+        const parsed = parseDate(value);
+        if (parsed)
+            return parsed;
+    }
+    const parentPrevious = container.parent().prevAll('h1, h2, h3, h4, time, [datetime]').slice(0, 5).toArray();
+    for (const element of parentPrevious) {
+        const value = $(element).attr('datetime') ?? $(element).text();
+        const parsed = parseDate(value);
+        if (parsed)
+            return parsed;
+    }
+    return null;
+}
+function parseDate(value) {
+    const trimmed = value?.replace(/\s+/g, ' ').trim();
+    if (!trimmed)
+        return null;
+    const normalized = trimmed
+        .replace(/^today$/i, new Date().toISOString())
+        .replace(/^yesterday$/i, new Date(Date.now() - 86_400_000).toISOString());
+    const parsed = new Date(normalized);
+    return Number.isNaN(parsed.getTime()) ? null : parsed;
+}
+function isWithinLookback(date, lookbackDays) {
+    const cutoff = new Date();
+    cutoff.setHours(0, 0, 0, 0);
+    cutoff.setDate(cutoff.getDate() - Math.max(1, lookbackDays));
+    return date >= cutoff;
+}
+function extractCreatorName($, container) {
+    const relAuthor = container.find('[rel="author"], [class*="creator"], [class*="maker"], a[href^="/makers/"]').first().text();
+    const normalized = relAuthor.replace(/\s+/g, ' ').trim();
+    return normalized || null;
+}
+function extractTagline($, container, productName) {
+    const selectors = ['[class*="tagline"]', '[class*="description"]', 'p'];
+    for (const selector of selectors) {
+        const text = container.find(selector).first().text().replace(/\s+/g, ' ').trim();
+        if (text && text !== productName && text.length <= 500)
+            return text;
+    }
+    return null;
+}
+function extractEmail(text) {
+    return text.match(/[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/)?.[0] ?? null;
+}
+function extractHandleFromHtml(html) {
+    const match = html.match(/(?:twitter\.com|x\.com)\/([A-Za-z0-9_]{1,20})/i);
+    return match ? `@${match[1]}` : null;
+}
+//# sourceMappingURL=scrape-betalist.js.map

package/dist/crm/scrape-landing.d.ts

@@ -0,0 +1,24 @@
+import type { Browser } from 'playwright';
+export type LandingScrape = {
+    htmlSignals: {
+        n_screenshots_html?: number;
+        has_video_html?: boolean;
+        has_docs_html?: boolean;
+        has_dashboard_html?: boolean;
+    };
+    screenshotPath: string | null;
+    isWebApp: boolean;
+    rawText: string;
+    error?: string;
+};
+export interface ScrapeLandingOptions {
+    productUrl: string;
+    userAgent: string;
+    logger: {
+        info(msg: string): void;
+        warn(msg: string): void;
+        error(msg: string): void;
+    };
+    browser: Browser;
+}
+export declare function scrapeLanding(opts: ScrapeLandingOptions): Promise<LandingScrape>;