indiecrm-cli 0.1.0 → 0.2.1

package/dist/engine.js

@@ -0,0 +1,216 @@
+import { z } from "zod";
+import { SAMPLE_COMPANIES, SAMPLE_CONTACTS, SAMPLE_SIGNALS, SAMPLE_TECH } from "./sample-data.js";
+function pickByIndex(items, index) {
+    const item = items[index % items.length];
+    if (item === undefined) {
+        throw new Error("sample data invariant violated");
+    }
+    return item;
+}
+function normalizeCompanySize(employeeCount) {
+    if (employeeCount < 50) {
+        return "1-49";
+    }
+    if (employeeCount < 200) {
+        return "50-199";
+    }
+    if (employeeCount < 500) {
+        return "200-499";
+    }
+    return "500+";
+}
+function deriveCompanyNameFromDomain(domain) {
+    const normalizedDomain = domain
+        .toLowerCase()
+        .replace(/^https?:\/\//, "")
+        .replace(/^www\./, "")
+        .split("/")[0];
+    const hostname = normalizedDomain.split(".")[0] ?? normalizedDomain;
+    return hostname
+        .split(/[-_]/)
+        .filter((part) => part.length > 0)
+        .map((part) => `${part[0]?.toUpperCase() ?? ""}${part.slice(1)}`)
+        .join(" ");
+}
+function normalizeDomain(domain) {
+    return domain
+        .toLowerCase()
+        .replace(/^https?:\/\//, "")
+        .replace(/^www\./, "")
+        .split("/")[0] ?? domain;
+}
+function buildTargetCompany(target, fallback, icp) {
+    const domain = target.companyDomain?.trim().toLowerCase();
+    if (domain === undefined) {
+        return {
+            ...fallback,
+            keywords: [fallback.industry.toLowerCase(), fallback.region.toLowerCase()],
+            sources: ["sample-company-dataset"]
+        };
+    }
+    return {
+        companyName: target.companyName?.trim() || deriveCompanyNameFromDomain(domain),
+        domain,
+        industry: icp.industries[0] ?? fallback.industry,
+        region: icp.regions[0] ?? fallback.region,
+        employeeCount: fallback.employeeCount,
+        keywords: [domain.split(".")[0] ?? domain, ...(icp.industries.length > 0 ? [icp.industries[0] ?? ""] : [])].filter((value) => value.length > 0),
+        sources: ["domain-input", "icp-overrides"]
+    };
+}
+export class HeuristicCompanyProvider {
+    name = "heuristic-company";
+    mode = "fallback";
+    async resolveCompany(target, icp) {
+        const domain = target.companyDomain?.trim();
+        if (domain !== undefined && domain.length === 0) {
+            throw new Error("company domain cannot be empty");
+        }
+        const fallbackCompany = SAMPLE_COMPANIES.find((company) => company.domain === normalizeDomain(domain ?? "")) ?? SAMPLE_COMPANIES[0];
+        if (fallbackCompany === undefined) {
+            throw new Error("sample company invariant violated");
+        }
+        return buildTargetCompany({
+            ...target,
+            companyDomain: domain ? normalizeDomain(domain) : undefined
+        }, fallbackCompany, icp);
+    }
+}
+export class HeuristicPeopleSearchProvider {
+    name = "heuristic-people-search";
+    mode = "fallback";
+    async findPeople(account, icp, count) {
+        return Array.from({ length: count }, (_, index) => {
+            const contact = pickByIndex(SAMPLE_CONTACTS, index + 1);
+            const signals = [pickByIndex(SAMPLE_SIGNALS, index), pickByIndex(SAMPLE_SIGNALS, index + 2)];
+            const industry = icp.industries[index % Math.max(icp.industries.length, 1)] ?? account.industry;
+            const region = icp.regions[index % Math.max(icp.regions.length, 1)] ?? account.region;
+            const title = icp.titles[index % Math.max(icp.titles.length, 1)] ?? contact.title;
+            return {
+                companyName: account.companyName,
+                domain: account.domain,
+                industry,
+                region,
+                employeeCount: account.employeeCount,
+                contactName: contact.contactName,
+                title,
+                email: `${contact.contactName.toLowerCase().replaceAll(" ", ".")}@${account.domain}`,
+                source: account.sources.includes("domain-input") ? "heuristic-target-account" : "heuristic-seed",
+                signals
+            };
+        });
+    }
+}
+export class AccountLeadProvider {
+    companyProvider;
+    peopleSearchProvider;
+    constructor(companyProvider, peopleSearchProvider) {
+        this.companyProvider = companyProvider;
+        this.peopleSearchProvider = peopleSearchProvider;
+    }
+    async generateLeads(icp, count, target = {}) {
+        const account = await this.companyProvider.resolveCompany(target, icp);
+        const leads = await this.peopleSearchProvider.findPeople(account, icp, count);
+        const warnings = [];
+        if (this.companyProvider.mode === "fallback" || this.peopleSearchProvider.mode === "fallback") {
+            warnings.push("Using fallback providers. Leads are modeled contacts until a real company and people data provider is configured.");
+        }
+        return {
+            provider: `${this.companyProvider.name}+${this.peopleSearchProvider.name}`,
+            mode: this.companyProvider.mode === "real" && this.peopleSearchProvider.mode === "real" ? "real" : "fallback",
+            account,
+            leads,
+            warnings
+        };
+    }
+}
+export class HeuristicEnrichmentProvider {
+    async enrichLeads(leads) {
+        return leads.map((lead, index) => ({
+            ...lead,
+            techStack: [pickByIndex(SAMPLE_TECH, index), pickByIndex(SAMPLE_TECH, index + 3)],
+            crmFit: lead.employeeCount > 200 ? "high" : lead.employeeCount > 100 ? "medium" : "low",
+            outreachFit: lead.signals.some((signal) => signal.includes("outbound")) ? "high" : "medium",
+            buyingStage: lead.signals.some((signal) => signal.includes("funding")) ? "active-evaluation" : "solution-aware",
+            notes: [
+                `${lead.companyName} matches the ${lead.industry} segment.`,
+                `${lead.contactName} is likely close to revenue tooling decisions.`
+            ]
+        }));
+    }
+}
+export class HeuristicScoringProvider {
+    async scoreLeads(icp, leads) {
+        return leads.map((lead) => {
+            const rationale = [];
+            let score = 40;
+            if (icp.industries.includes(lead.industry)) {
+                score += 20;
+                rationale.push("Industry matches ICP.");
+            }
+            if (icp.regions.includes(lead.region)) {
+                score += 10;
+                rationale.push("Region matches ICP.");
+            }
+            const normalizedSize = normalizeCompanySize(lead.employeeCount);
+            if (icp.companySizes.includes(normalizedSize)) {
+                score += 10;
+                rationale.push("Company size matches ICP.");
+            }
+            if (icp.titles.includes(lead.title)) {
+                score += 10;
+                rationale.push("Contact title matches ICP.");
+            }
+            const requiredMatches = icp.requiredSignals.filter((signal) => lead.signals.includes(signal));
+            score += Math.min(requiredMatches.length * 5, 10);
+            if (requiredMatches.length > 0) {
+                rationale.push(`Matched ${requiredMatches.length} required buying signals.`);
+            }
+            const excludedMatches = icp.excludedSignals.filter((signal) => lead.signals.includes(signal));
+            score -= excludedMatches.length * 15;
+            if (excludedMatches.length > 0) {
+                rationale.push(`Matched ${excludedMatches.length} excluded signals.`);
+            }
+            if (lead.crmFit === "high") {
+                score += 5;
+                rationale.push("Strong CRM fit.");
+            }
+            if (lead.outreachFit === "high") {
+                score += 5;
+                rationale.push("Strong outreach fit.");
+            }
+            const clampedScore = z.number().int().min(0).max(100).parse(score);
+            const grade = clampedScore >= 85 ? "A" : clampedScore >= 70 ? "B" : clampedScore >= 55 ? "C" : "D";
+            return {
+                ...lead,
+                score: clampedScore,
+                grade,
+                rationale
+            };
+        });
+    }
+}
+export class DryRunSyncProvider {
+    async sync(target, leads, _options) {
+        return {
+            target,
+            synced: leads.length,
+            dryRun: true,
+            provider: "dry-run"
+        };
+    }
+}
+export class RoutedSyncProvider {
+    fallbackProvider;
+    instantlyProvider;
+    constructor(fallbackProvider, instantlyProvider) {
+        this.fallbackProvider = fallbackProvider;
+        this.instantlyProvider = instantlyProvider;
+    }
+    async sync(target, leads, options) {
+        if (target === "instantly") {
+            return this.instantlyProvider.sync(target, leads, options);
+        }
+        return this.fallbackProvider.sync(target, leads, options);
+    }
+}

package/dist/historical-queries.js

@@ -0,0 +1,189 @@
+function decodeQuery(rawQuery) {
+    return decodeURIComponent(rawQuery);
+}
+function detectQueryKind(decodedQuery) {
+    if (decodedQuery.includes("/sales/search/people")) {
+        return "sales-people";
+    }
+    if (decodedQuery.includes("/sales/search/company")) {
+        return "sales-company";
+    }
+    if (decodedQuery.includes("/search/results/people/")) {
+        return "people";
+    }
+    return "other";
+}
+function normalizeText(text) {
+    return text.replaceAll("%20", " ").replaceAll("%2C", ",").replaceAll("%2B", "+").replaceAll("%2F", "/").trim();
+}
+function extractStructuredValues(decodedQuery, filterType) {
+    const values = [];
+    const seen = new Set();
+    function pushValue(value) {
+        const key = `${value.text}|${value.selection}`;
+        if (!seen.has(key)) {
+            seen.add(key);
+            values.push(value);
+        }
+    }
+    for (const match of decodedQuery.matchAll(new RegExp(`type:${filterType},values:List\\((.*?)\\)\\)`, "g"))) {
+        const block = match[1] ?? "";
+        for (const fullMatch of block.matchAll(/id:([^,\)]+),text:([^,\)]+),selectionType:([A-Z]+)/g)) {
+            pushValue({
+                id: fullMatch[1] ?? null,
+                text: normalizeText(fullMatch[2] ?? ""),
+                selection: fullMatch[3] ?? ""
+            });
+        }
+        for (const fullMatch of block.matchAll(/text:([^,\)]+),selectionType:([A-Z]+)/g)) {
+            pushValue({
+                id: null,
+                text: normalizeText(fullMatch[1] ?? ""),
+                selection: fullMatch[2] ?? ""
+            });
+        }
+    }
+    return values;
+}
+function extractDepartmentHeadcount(decodedQuery) {
+    return Array.from(decodedQuery.matchAll(/type:DEPARTMENT_HEADCOUNT,rangeValue:\(min:([^,\)]+),max:([^\)]+)\),selectedSubFilter:([^,\)]+)/g), (match) => ({
+        departmentId: match[3] ?? "",
+        min: match[1] ?? "",
+        max: match[2] ?? ""
+    }));
+}
+export function parseHistoricalQuery(rawQuery) {
+    const decodedQuery = decodeQuery(rawQuery);
+    const filterTypes = Array.from(new Set(Array.from(decodedQuery.matchAll(/type:([A-Z_]+)/g), (match) => match[1] ?? ""))).filter((value) => value.length > 0);
+    return {
+        queryKind: detectQueryKind(decodedQuery),
+        rawQuery,
+        decodedQuery,
+        filterTypes,
+        functionFilters: extractStructuredValues(decodedQuery, "FUNCTION"),
+        titleFilters: extractStructuredValues(decodedQuery, "CURRENT_TITLE"),
+        seniorityFilters: extractStructuredValues(decodedQuery, "SENIORITY_LEVEL"),
+        regionFilters: extractStructuredValues(decodedQuery, "REGION"),
+        headquartersFilters: extractStructuredValues(decodedQuery, "COMPANY_HEADQUARTERS"),
+        headcountFilters: extractStructuredValues(decodedQuery, "COMPANY_HEADCOUNT"),
+        departmentHeadcountFilters: extractDepartmentHeadcount(decodedQuery)
+    };
+}
+function includesConfiguredFunction(parsed, functionTexts) {
+    if (functionTexts.length === 0) {
+        return true;
+    }
+    const normalizedNeedles = functionTexts.map((value) => value.trim().toLowerCase()).filter((value) => value.length > 0);
+    return parsed.functionFilters.some((filter) => filter.selection === "INCLUDED" && normalizedNeedles.includes(filter.text.toLowerCase()));
+}
+export function analyzeHistoricalQueries(rows, options = {}) {
+    const selectedRows = rows.filter((row) => {
+        const parsed = parseHistoricalQuery(row.query);
+        const searchKindOk = options.searchKind === undefined || options.searchKind === "all" ? true : parsed.queryKind === options.searchKind;
+        const functionOk = includesConfiguredFunction(parsed, options.includeFunctionText ?? []);
+        return searchKindOk && functionOk;
+    });
+    const filterTypeCounts = new Map();
+    const functionCounts = new Map();
+    const titleCounts = new Map();
+    const seniorityCounts = new Map();
+    const regionCounts = new Map();
+    const headquartersCounts = new Map();
+    const headcountCounts = new Map();
+    const departmentHeadcountCounts = new Map();
+    const queryKinds = {
+        people: 0,
+        "sales-people": 0,
+        "sales-company": 0,
+        other: 0
+    };
+    for (const row of selectedRows) {
+        const parsed = parseHistoricalQuery(row.query);
+        queryKinds[parsed.queryKind] += row.freq;
+        for (const filterType of parsed.filterTypes) {
+            filterTypeCounts.set(filterType, (filterTypeCounts.get(filterType) ?? 0) + row.freq);
+        }
+        for (const filter of parsed.functionFilters) {
+            const key = `${filter.text}|${filter.selection}`;
+            functionCounts.set(key, (functionCounts.get(key) ?? 0) + row.freq);
+        }
+        for (const filter of parsed.titleFilters) {
+            const key = `${filter.text}|${filter.selection}`;
+            titleCounts.set(key, (titleCounts.get(key) ?? 0) + row.freq);
+        }
+        for (const filter of parsed.seniorityFilters) {
+            const key = `${filter.text}|${filter.selection}`;
+            seniorityCounts.set(key, (seniorityCounts.get(key) ?? 0) + row.freq);
+        }
+        for (const filter of parsed.regionFilters) {
+            const key = `${filter.text}|${filter.selection}`;
+            regionCounts.set(key, (regionCounts.get(key) ?? 0) + row.freq);
+        }
+        for (const filter of parsed.headquartersFilters) {
+            const key = `${filter.text}|${filter.selection}`;
+            headquartersCounts.set(key, (headquartersCounts.get(key) ?? 0) + row.freq);
+        }
+        for (const filter of parsed.headcountFilters) {
+            const key = `${filter.text}|${filter.selection}`;
+            headcountCounts.set(key, (headcountCounts.get(key) ?? 0) + row.freq);
+        }
+        for (const filter of parsed.departmentHeadcountFilters) {
+            const key = `${filter.departmentId}|${filter.min}|${filter.max}`;
+            departmentHeadcountCounts.set(key, (departmentHeadcountCounts.get(key) ?? 0) + row.freq);
+        }
+    }
+    function topPairs(map) {
+        return Array.from(map.entries())
+            .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+            .map(([key, count]) => ({ key, count }));
+    }
+    return {
+        sourceTables: Array.from(new Set(selectedRows.map((row) => row.sourceTable))),
+        distinctQueryRowsAnalyzed: selectedRows.length,
+        weightedQueryVolume: selectedRows.reduce((sum, row) => sum + row.freq, 0),
+        queryKinds,
+        filterTypeCountsTop: topPairs(filterTypeCounts).slice(0, 30).map(({ key, count }) => ({ filterType: key, count })),
+        functionValuesTop: topPairs(functionCounts)
+            .slice(0, 40)
+            .map(({ key, count }) => {
+            const [text, selection] = key.split("|");
+            return { text: text ?? "", selection: selection ?? "", count };
+        }),
+        titleValuesTop: topPairs(titleCounts)
+            .slice(0, 60)
+            .map(({ key, count }) => {
+            const [text, selection] = key.split("|");
+            return { text: text ?? "", selection: selection ?? "", count };
+        }),
+        seniorityValuesTop: topPairs(seniorityCounts)
+            .slice(0, 40)
+            .map(({ key, count }) => {
+            const [text, selection] = key.split("|");
+            return { text: text ?? "", selection: selection ?? "", count };
+        }),
+        regionValuesTop: topPairs(regionCounts)
+            .slice(0, 40)
+            .map(({ key, count }) => {
+            const [text, selection] = key.split("|");
+            return { text: text ?? "", selection: selection ?? "", count };
+        }),
+        headquartersValuesTop: topPairs(headquartersCounts)
+            .slice(0, 40)
+            .map(({ key, count }) => {
+            const [text, selection] = key.split("|");
+            return { text: text ?? "", selection: selection ?? "", count };
+        }),
+        headcountValuesTop: topPairs(headcountCounts)
+            .slice(0, 40)
+            .map(({ key, count }) => {
+            const [text, selection] = key.split("|");
+            return { text: text ?? "", selection: selection ?? "", count };
+        }),
+        departmentHeadcountTop: topPairs(departmentHeadcountCounts)
+            .slice(0, 20)
+            .map(({ key, count }) => {
+            const [departmentId, min, max] = key.split("|");
+            return { departmentId: departmentId ?? "", min: min ?? "", max: max ?? "", count };
+        })
+    };
+}

package/dist/hunter-emailfinder.js

@@ -0,0 +1,252 @@
+import { z } from "zod";
+const nullableNumber = z.union([z.string(), z.number()]).transform((value) => Number(value)).nullable().optional()
+    .transform((value) => (value == null || Number.isNaN(value) ? null : value));
+const stringId = z.union([z.string(), z.number()]).transform((value) => String(value).trim()).refine((value) => value.length > 0);
+export const hunterEmailfinderQueueRowSchema = z.object({
+    clientId: stringId,
+    contactId: stringId,
+    companyId: stringId,
+    firstName_cleaned: z.string().trim().min(1),
+    lastName_cleaned: z.string().trim().min(1),
+    domain: z.string().trim().min(1),
+    companyScore: nullableNumber,
+    seniorityId: nullableNumber
+});
+export const hunterEmailfinderQueueRowArraySchema = z.array(hunterEmailfinderQueueRowSchema);
+export const directEmailEnrichmentInputRowArraySchema = z.array(z.object({
+    clientId: z.string().nullable(),
+    companyName: z.string().trim(),
+    fullName: z.string().trim()
+}));
+function detectLooseDelimiter(value) {
+    if (value.includes("\t")) {
+        return "\t";
+    }
+    if (value.includes(";")) {
+        return ";";
+    }
+    return ",";
+}
+function splitLooseDelimitedLine(value, delimiter) {
+    if (delimiter === "\t") {
+        return value.split("\t");
+    }
+    const parts = [];
+    let current = "";
+    let inQuotes = false;
+    for (let index = 0; index < value.length; index += 1) {
+        const char = value[index] ?? "";
+        if (char === "\"") {
+            inQuotes = !inQuotes;
+            continue;
+        }
+        if (char === delimiter && !inQuotes) {
+            parts.push(current);
+            current = "";
+            continue;
+        }
+        current += char;
+    }
+    parts.push(current);
+    return parts;
+}
+export function parseDirectEmailEnrichmentInput(content) {
+    const trimmed = content.trim();
+    if (!trimmed) {
+        return [];
+    }
+    if (trimmed.startsWith("[")) {
+        const parsed = z.array(z.object({
+            clientId: z.union([z.string(), z.number()]).nullish(),
+            companyName: z.string().nullish(),
+            fullName: z.string().nullish()
+        })).parse(JSON.parse(trimmed));
+        return parsed.map((row) => ({
+            clientId: row.clientId == null ? null : String(row.clientId).trim() || null,
+            companyName: row.companyName?.trim() ?? "",
+            fullName: row.fullName?.trim() ?? ""
+        })).filter((row) => row.companyName.length > 0 || row.fullName.length > 0);
+    }
+    const lines = trimmed
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+    if (lines.length === 0) {
+        return [];
+    }
+    const delimiter = detectLooseDelimiter(lines[0] ?? "");
+    const headerValues = splitLooseDelimitedLine(lines[0] ?? "", delimiter).map((value) => value.trim().toLowerCase());
+    const hasHeader = headerValues.includes("fullname") ||
+        headerValues.includes("full_name") ||
+        headerValues.includes("companyname") ||
+        headerValues.includes("company_name");
+    if (hasHeader) {
+        const companyNameIndex = headerValues.findIndex((value) => ["companyname", "company_name"].includes(value));
+        const fullNameIndex = headerValues.findIndex((value) => ["fullname", "full_name", "contact_name", "name"].includes(value));
+        const clientIdIndex = headerValues.findIndex((value) => ["clientid", "client_id"].includes(value));
+        return lines.slice(1)
+            .map((line) => splitLooseDelimitedLine(line, delimiter).map((value) => value.trim()))
+            .map((columns) => ({
+            clientId: clientIdIndex >= 0 ? columns[clientIdIndex] || null : null,
+            companyName: companyNameIndex >= 0 ? columns[companyNameIndex] || "" : "",
+            fullName: fullNameIndex >= 0 ? columns[fullNameIndex] || "" : ""
+        }))
+            .filter((row) => row.companyName.length > 0 || row.fullName.length > 0);
+    }
+    return lines
+        .map((line) => splitLooseDelimitedLine(line, delimiter).map((value) => value.trim()))
+        .map((columns) => {
+        if (columns.length >= 3) {
+            return {
+                clientId: columns[0] || null,
+                fullName: columns[1] || "",
+                companyName: columns[2] || ""
+            };
+        }
+        return {
+            clientId: null,
+            companyName: columns[0] || "",
+            fullName: columns[1] || ""
+        };
+    })
+        .filter((row) => row.companyName.length > 0 || row.fullName.length > 0);
+}
+export function resolveDirectEmailEnrichmentClientId(inputRows, clientIdOption) {
+    const explicitClientId = clientIdOption == null || String(clientIdOption).trim().length === 0
+        ? null
+        : z.coerce.number().int().positive().parse(clientIdOption);
+    const rowClientIds = Array.from(new Set(inputRows
+        .map((row) => row.clientId?.trim() ?? "")
+        .filter((value) => value.length > 0)));
+    if (explicitClientId != null && rowClientIds.length > 0) {
+        const mismatched = rowClientIds.some((value) => Number(value) !== explicitClientId);
+        if (mismatched) {
+            throw new Error("Input rows contain multiple or mismatched clientId values. Pass one consistent --client-id or align the input.");
+        }
+    }
+    if (explicitClientId != null) {
+        return explicitClientId;
+    }
+    if (rowClientIds.length === 1) {
+        return z.coerce.number().int().positive().parse(rowClientIds[0]);
+    }
+    if (rowClientIds.length > 1) {
+        throw new Error("Input rows contain multiple clientId values. Pass --client-id to choose one batch client.");
+    }
+    return Math.max(1, Math.trunc(Date.now() / 1000));
+}
+export function buildHunterEmailfinderQueueSql(clientId, limit) {
+    return [
+        "SELECT",
+        "  clientId,",
+        "  contactId,",
+        "  companyId,",
+        "  firstName_cleaned,",
+        "  lastName_cleaned,",
+        "  domain,",
+        "  companyScore,",
+        "  seniorityId",
+        "FROM `icpidentifier.SalesPrompter.hunter_emailFinder_input`",
+        `WHERE clientId = ${clientId}`,
+        "ORDER BY companyScore DESC NULLS LAST, seniorityId DESC NULLS LAST, contactId",
+        `LIMIT ${limit}`
+    ].join("\n");
+}
+export function buildHunterEmailfinderTriggerPayload(params) {
+    return {
+        action: "run_hunter_emailfinder",
+        workflow_target: "hunter_emailFinder",
+        app_source: "salesprompter_cli",
+        integration: "hunter",
+        integration_type: "hunter",
+        trigger_source: "cli_hunter_emailfinder_run_bq",
+        trace_id: params.traceId,
+        queue_source: "icpidentifier.SalesPrompter.hunter_emailFinder_input",
+        output_table: "icpidentifier.SalesPrompter.hunter_emailFinder_output",
+        queue_client_id: params.clientId,
+        batch_count: params.queueRows.length,
+        inputs: params.queueRows,
+        payload: {
+            trace_id: params.traceId,
+            queue_source: "icpidentifier.SalesPrompter.hunter_emailFinder_input",
+            output_table: "icpidentifier.SalesPrompter.hunter_emailFinder_output",
+            clientId: params.clientId,
+            inputs: params.queueRows
+        }
+    };
+}
+export function readHunterEmailfinderConfig(env = process.env, endpointUrlOverride) {
+    const endpointId = env.PIPEDREAM_HUNTER_EMAILFINDER_ENDPOINT_ID?.trim() || "";
+    const endpointUrl = endpointUrlOverride?.trim() ||
+        env.SALESPROMPTER_HUNTER_EMAILFINDER_ENDPOINT_URL?.trim() ||
+        env.HUNTER_EMAILFINDER_ENDPOINT_URL?.trim() ||
+        (endpointId ? `https://${endpointId}.m.pipedream.net` : "");
+    if (!endpointUrl) {
+        throw new Error("Missing email enrichment endpoint. Set --endpoint-url, SALESPROMPTER_HUNTER_EMAILFINDER_ENDPOINT_URL, HUNTER_EMAILFINDER_ENDPOINT_URL, or PIPEDREAM_HUNTER_EMAILFINDER_ENDPOINT_ID.");
+    }
+    return {
+        endpointUrl,
+        secret: env.PIPEDREAM_SECRET_KEY?.trim() || "",
+        clientId: env.PIPEDREAM_CLIENT_ID?.trim() || "",
+        projectId: env.PIPEDREAM_PROJECT_ID?.trim() || "",
+        projectEnvironment: env.PIPEDREAM_PROJECT_ENVIRONMENT?.trim() || ""
+    };
+}
+export async function triggerHunterEmailfinderWorkflow(params) {
+    const endpoint = new URL(params.config.endpointUrl);
+    if (params.config.secret) {
+        endpoint.searchParams.set("secret", params.config.secret);
+    }
+    const headers = {
+        "Content-Type": "application/json",
+        "x-pd-external-user-id": params.externalUserId
+    };
+    if (params.config.secret) {
+        headers.Authorization = `Bearer ${params.config.secret}`;
+        headers["x-pd-secret"] = params.config.secret;
+        headers["x-secret-key"] = params.config.secret;
+    }
+    if (params.config.clientId) {
+        headers["X-Client-ID"] = params.config.clientId;
+    }
+    if (params.config.projectId) {
+        headers["X-Project-ID"] = params.config.projectId;
+    }
+    if (params.config.projectEnvironment) {
+        headers["X-Environment"] = params.config.projectEnvironment;
+        headers["x-pd-environment"] = params.config.projectEnvironment;
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), params.timeoutMs);
+    try {
+        const response = await fetch(endpoint, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(params.payload),
+            signal: controller.signal
+        });
+        const bodyText = await response.text();
+        let parsedBody = null;
+        try {
+            parsedBody = bodyText ? JSON.parse(bodyText) : null;
+        }
+        catch {
+            parsedBody = bodyText;
+        }
+        return {
+            endpoint: endpoint.toString(),
+            bodyText,
+            parsedBody,
+            response
+        };
+    }
+    catch (error) {
+        if (error.name === "AbortError") {
+            throw new Error(`Email enrichment workflow timed out after ${params.timeoutMs}ms.`);
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}