autokap 1.3.31 → 1.4.2

package/dist/crm/email-fallback.js

@@ -0,0 +1,217 @@
+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

@@ -0,0 +1,28 @@
+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;
+}>;

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[]>;