salesprompter-cli 0.1.50 → 0.1.52

package/README.md

@@ -70,6 +70,12 @@ salesprompter leads:collect \
   --linkedin-url "$SALES_NAV_PEOPLE_URL" \
   --max-results 1000
 
+# Enrich one or more stored imports: Sales Navigator company -> official domain -> Hunter email
+# This updates workspace data only. It does not create or start outreach.
+# Stale imported company ids fall back to exact-name Account Search automatically.
+salesprompter leads:enrich-import \
+  --run-id "$CLI_IMPORT_RUN_ID"
+
 salesprompter affiliate:launch \
   --affiliate-link "https://example.com/?ref=you" \
   --linkedin-url "https://www.linkedin.com/sales/search/people?query=..." \

package/dist/cli.js

@@ -258,6 +258,51 @@ const CliEmailEnrichmentCompaniesResponseSchema = z.object({
         linkedinCompanyPage: z.string().nullable()
     }))
 });
+const CliImportCompanyCandidateSchema = z.object({
+    companyKey: z.string().min(1),
+    companyId: z.string().nullable(),
+    companyName: z.string().nullable(),
+    salesNavCompanyUrl: z.string().nullable(),
+    linkedinCompanyUrl: z.string().nullable(),
+    personCount: z.number().int().nonnegative(),
+    profileStatus: z.string().nullable(),
+    profileDomain: z.string().nullable()
+});
+const CliImportCompanyCandidatesResponseSchema = z.object({
+    companies: z.array(CliImportCompanyCandidateSchema)
+});
+const CliImportCompanySaveResponseSchema = z.object({
+    saved: z.number().int().nonnegative(),
+    enriched: z.number().int().nonnegative(),
+    domains: z.number().int().nonnegative(),
+    notFound: z.number().int().nonnegative(),
+    failed: z.number().int().nonnegative()
+});
+const CliImportHunterBatchResponseSchema = z.object({
+    selected: z.number().int().nonnegative(),
+    processed: z.number().int().nonnegative(),
+    found: z.number().int().nonnegative(),
+    notFound: z.number().int().nonnegative(),
+    failed: z.number().int().nonnegative(),
+    halted: z.boolean(),
+    error: z.string().nullable()
+});
+const CliImportEnrichmentStatusSchema = z.object({
+    runCount: z.coerce.number().int().nonnegative(),
+    memberships: z.coerce.number().int().nonnegative(),
+    uniquePeople: z.coerce.number().int().nonnegative(),
+    distinctCompanies: z.coerce.number().int().nonnegative(),
+    companiesEnriched: z.coerce.number().int().nonnegative(),
+    companiesNotFound: z.coerce.number().int().nonnegative(),
+    companiesFailed: z.coerce.number().int().nonnegative(),
+    domainsFound: z.coerce.number().int().nonnegative(),
+    peopleWithDomain: z.coerce.number().int().nonnegative(),
+    emailsFound: z.coerce.number().int().nonnegative(),
+    emailsNotFound: z.coerce.number().int().nonnegative(),
+    emailsFailed: z.coerce.number().int().nonnegative(),
+    emailsProcessing: z.coerce.number().int().nonnegative(),
+    emailsPending: z.coerce.number().int().nonnegative()
+});
 const SalesNavigatorLaunchDiagnosticsSchema = z.object({
     orderedCandidateAgentIds: z.array(z.string().min(1)),
     runningAgentIds: z.array(z.string().min(1)),
@@ -479,6 +524,7 @@ const cliPacks = [
         commands: [
             "leads:discover",
             "leads:collect",
+            "leads:enrich-import",
             "search:run",
             "search:status",
             "search:export",
@@ -517,6 +563,7 @@ const helpAliasByCommandName = new Map([
     ["linkedin-products:scrape", "market:scrape"],
     ["salesnav:from-product-category", "leads:discover"],
     ["salesnav:people:collect", "leads:collect"],
+    ["salesnav:people:enrich", "leads:enrich-import"],
     ["salesnav:crawl", "search:run"],
     ["salesnav:crawl:status", "search:status"],
     ["salesnav:export", "search:export"],
@@ -562,6 +609,7 @@ const helpVisibleCommandNames = new Set([
     "linkedin-products:scrape",
     "salesnav:from-product-category",
     "salesnav:people:collect",
+    "salesnav:people:enrich",
     "salesnav:crawl",
     "salesnav:crawl:status",
     "salesnav:export",
@@ -6696,6 +6744,29 @@ async function enrichDirectEmailCompaniesViaApp(session, payload) {
     }), CliEmailEnrichmentCompaniesResponseSchema);
     return value;
 }
+async function runCliImportEnrichmentAction(session, body, schema) {
+    const { value } = await fetchCliJson(session, (currentSession) => fetch(`${currentSession.apiBaseUrl}/api/cli/leads/imports/enrichment`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${currentSession.accessToken}`
+        },
+        body: JSON.stringify(body)
+    }), schema);
+    return value;
+}
+async function getCliImportCompanyCandidatesViaApp(session, input) {
+    return runCliImportEnrichmentAction(session, { action: "company-candidates", ...input }, CliImportCompanyCandidatesResponseSchema);
+}
+async function saveCliImportCompanyProfilesViaApp(session, profiles) {
+    return runCliImportEnrichmentAction(session, { action: "save-companies", profiles }, CliImportCompanySaveResponseSchema);
+}
+async function runCliImportHunterBatchViaApp(session, input) {
+    return runCliImportEnrichmentAction(session, { action: "hunter", ...input }, CliImportHunterBatchResponseSchema);
+}
+async function getCliImportEnrichmentStatusViaApp(session, runIds) {
+    return runCliImportEnrichmentAction(session, { action: "status", runIds }, CliImportEnrichmentStatusSchema);
+}
 async function fetchLinkedInCompaniesBackfillStatus(session, payload) {
     const url = new URL('/api/cli/linkedin-companies/status', session.apiBaseUrl);
     url.searchParams.set('clientId', String(payload.clientId));
@@ -6726,6 +6797,16 @@ class LocalSalesNavigatorRateLimitError extends Error {
         this.retryAfterMs = retryAfterMs;
     }
 }
+class LocalSalesNavigatorHttpError extends Error {
+    status;
+    body;
+    constructor(status, body, message) {
+        super(message);
+        this.name = "LocalSalesNavigatorHttpError";
+        this.status = status;
+        this.body = body;
+    }
+}
 function stripShellQuotes(value) {
     const trimmed = value.trim();
     if (trimmed.length >= 2) {
@@ -7798,7 +7879,7 @@ async function createLocalAccountSearchBrowserRelay(requestedPort) {
                     const recovery = status === 401 || status === 403
                         ? " Refresh the Sales Navigator search, capture the current csrf-token from a native Lead Search request, and replay this task with the supplied headers."
                         : "";
-                    current.reject(new Error(`Sales Navigator browser relay failed with HTTP ${status}: ${bodyPreview}.${recovery}`));
+                    current.reject(new LocalSalesNavigatorHttpError(status, body, `Sales Navigator browser relay failed with HTTP ${status}: ${bodyPreview}.${recovery}`));
                     writeLocalAccountSearchRelayJson(response, 200, {
                         status: "failed",
                     });
@@ -7840,8 +7921,9 @@ async function createLocalAccountSearchBrowserRelay(requestedPort) {
             const parsedUrl = new URL(request.url);
             if (!/(^|\.)linkedin\.com$/i.test(parsedUrl.hostname) ||
                 !(parsedUrl.pathname.includes("/sales-api/salesApiAccountSearch") ||
-                    parsedUrl.pathname.includes("/sales-api/salesApiLeadSearch"))) {
-                throw new Error("Browser relay only accepts LinkedIn Account or Lead Search API URLs.");
+                    parsedUrl.pathname.includes("/sales-api/salesApiLeadSearch") ||
+                    parsedUrl.pathname.includes("/sales-api/salesApiCompanies"))) {
+                throw new Error("Browser relay only accepts LinkedIn Account Search, Lead Search, or company-detail API URLs.");
             }
             const headers = Object.fromEntries(Object.entries(request.headers)
                 .map(([name, value]) => [name.toLowerCase(), value])
@@ -7861,9 +7943,7 @@ async function createLocalAccountSearchBrowserRelay(requestedPort) {
                     requestId: `sales-nav-search-${requestSequence}`,
                     url: request.url,
                     headers,
-                    requiredHeaders: parsedUrl.pathname.includes("salesApiLeadSearch")
-                        ? ["csrf-token"]
-                        : [],
+                    requiredHeaders: ["csrf-token"],
                     resolve,
                     reject,
                 };
@@ -13343,6 +13423,707 @@ async function runSalesNavigatorPeopleCollectCommand(options) {
         await writeJsonFile(options.out, payload);
     return payload;
 }
+class CliImportCompanyRateLimitError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "CliImportCompanyRateLimitError";
+    }
+}
+function collectRunId(value, previous) {
+    return [...previous, ...value.split(",")]
+        .map((entry) => entry.trim())
+        .filter(Boolean);
+}
+function normalizeCompanyWebsite(value) {
+    const trimmed = value?.trim() ?? "";
+    if (!trimmed)
+        return null;
+    try {
+        return new URL(trimmed.includes("://") ? trimmed : `https://${trimmed}`).toString();
+    }
+    catch {
+        return null;
+    }
+}
+const CLI_IMPORT_COMPANY_DECORATION = "(entityUrn,name,employeeCount,employeeDisplayCount,employeeCountRange,account(saved,noteCount,listCount,crmStatus,starred),pictureInfo,companyPictureDisplayImage,companyBackgroundCoverImage,description,industry,location,headquarters,website,revenueRange,crmOpportunities,flagshipCompanyUrl,employeeGrowthPercentages,employees*~fs_salesProfile(entityUrn,firstName,lastName,fullName,pictureInfo,profilePictureDisplayImage),specialties,type,yearFounded)";
+class CliImportCompanySessionError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "CliImportCompanySessionError";
+    }
+}
+function buildCliImportAccountSearchUrl(companyName) {
+    const baseUrl = process.env.SALESPROMPTER_LINKEDIN_SALES_API_BASE_URL?.trim() ||
+        "https://www.linkedin.com";
+    return (`${baseUrl.replace(/\/+$/, "")}/sales-api/salesApiAccountSearch` +
+        `?q=searchQuery&query=(spellCorrectionEnabled:true,keywords:${encodeLinkedInRestliValue(companyName)})` +
+        "&start=0&count=25" +
+        "&decorationId=com.linkedin.sales.deco.desktop.searchv2.AccountSearchResult-4");
+}
+function encodeLinkedInRestliValue(value) {
+    return encodeURIComponent(value)
+        .replace(/\(/g, "%28")
+        .replace(/\)/g, "%29");
+}
+function buildCliImportCompanyDetailsUrl(companyIds) {
+    const baseUrl = process.env.SALESPROMPTER_LINKEDIN_SALES_API_BASE_URL?.trim() ||
+        "https://www.linkedin.com";
+    return (`${baseUrl.replace(/\/+$/, "")}/sales-api/salesApiCompanies` +
+        `?ids=List(${companyIds.map((companyId) => encodeURIComponent(companyId)).join(",")})` +
+        `&decoration=${encodeLinkedInRestliValue(CLI_IMPORT_COMPANY_DECORATION)}`);
+}
+function buildCliImportCompanyHeaders(config, companyId) {
+    return {
+        ...buildLinkedInSalesNavigatorAccountSearchHeaders(config),
+        referer: companyId
+            ? `https://www.linkedin.com/sales/company/${companyId}`
+            : "https://www.linkedin.com/sales/search/company",
+    };
+}
+async function fetchCliImportSalesNavigatorJson(params) {
+    if (params.browserRelay) {
+        try {
+            const result = await params.browserRelay.request({
+                url: params.url,
+                headers: params.config
+                    ? buildCliImportCompanyHeaders(params.config, params.companyId)
+                    : {},
+            });
+            const body = cliImportCompanyRecord(result.body);
+            return { status: 200, body, finalUrl: params.url };
+        }
+        catch (error) {
+            if (error instanceof LocalSalesNavigatorRateLimitError) {
+                throw new CliImportCompanyRateLimitError(error.message);
+            }
+            if (error instanceof LocalSalesNavigatorHttpError) {
+                if (error.status === 401 || error.status === 403) {
+                    throw new CliImportCompanySessionError(error.message);
+                }
+                return {
+                    status: error.status,
+                    body: cliImportCompanyRecord(error.body),
+                    finalUrl: params.url,
+                };
+            }
+            throw error;
+        }
+    }
+    if (!params.config) {
+        throw new Error("Company enrichment requires a LinkedIn session or --browser-relay-port.");
+    }
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), params.timeoutMs);
+    try {
+        const response = await fetch(params.url, {
+            method: "GET",
+            signal: controller.signal,
+            headers: buildCliImportCompanyHeaders(params.config, params.companyId),
+        });
+        const finalUrl = response.url || params.url;
+        if (response.status === 429 || response.status === 999) {
+            throw new CliImportCompanyRateLimitError(`LinkedIn rate limited ${params.label} (${response.status}). Resume the same command after cooldown.`);
+        }
+        if (response.status === 401 ||
+            response.status === 403 ||
+            /\/uas\/login|\/checkpoint\/challenge|\/authwall/i.test(finalUrl)) {
+            throw new CliImportCompanySessionError(`LinkedIn rejected ${params.label}. Refresh the Sales Navigator session, then rerun the same command.`);
+        }
+        const text = await response.text();
+        if (/sign in to linkedin|authwall|checkpoint\/challenge/i.test(text)) {
+            throw new CliImportCompanySessionError(`LinkedIn redirected ${params.label} to authentication. Refresh the Sales Navigator session, then rerun the same command.`);
+        }
+        let body = null;
+        if (text.trim()) {
+            try {
+                const parsed = JSON.parse(text);
+                body =
+                    typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)
+                        ? parsed
+                        : null;
+            }
+            catch {
+                if (response.ok) {
+                    throw new Error(`${params.label} returned a non-JSON response (${response.status}).`);
+                }
+            }
+        }
+        return { status: response.status, body, finalUrl };
+    }
+    catch (error) {
+        if (error instanceof CliImportCompanyRateLimitError ||
+            error instanceof CliImportCompanySessionError) {
+            throw error;
+        }
+        if (error instanceof Error && error.name === "AbortError") {
+            throw new Error(`${params.label} timed out after ${params.timeoutMs}ms.`);
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+function exactCliImportAccountMatch(candidate, accounts) {
+    const sourceName = candidate.companyName ?? "";
+    const expectedNames = new Set([sourceName, aggressivelyCleanLookupCompanyName(sourceName)]
+        .map((value) => normalizeLooseMatchText(value))
+        .filter(Boolean));
+    if (expectedNames.size === 0)
+        return null;
+    return (accounts.find((account) => {
+        const companyName = typeof account.companyName === "string" ? account.companyName : "";
+        const normalizedNames = [
+            companyName,
+            aggressivelyCleanLookupCompanyName(companyName),
+        ].map((value) => normalizeLooseMatchText(value));
+        return normalizedNames.some((value) => value && expectedNames.has(value));
+    }) ?? null);
+}
+async function resolveCliImportCompanyIdentity(candidate, config, timeoutMs, browserRelay) {
+    let resolvedCompanyId = candidate.companyId && /^\d+$/.test(candidate.companyId)
+        ? candidate.companyId
+        : null;
+    let salesNavCompanyUrl = candidate.salesNavCompanyUrl;
+    let linkedinCompanyUrl = candidate.linkedinCompanyUrl;
+    let matchedCompanyName = null;
+    let accountSearchUsed = false;
+    let account = null;
+    if (!resolvedCompanyId && candidate.companyName) {
+        accountSearchUsed = true;
+        const queryUrl = buildCliImportAccountSearchUrl(candidate.companyName);
+        const response = await fetchCliImportSalesNavigatorJson({
+            url: queryUrl,
+            config,
+            browserRelay,
+            timeoutMs,
+            label: `Sales Navigator Account Search for ${candidate.companyName}`,
+        });
+        if (response.status < 200 || response.status >= 300) {
+            throw new Error(`Sales Navigator Account Search for ${candidate.companyName} returned ${response.status}.`);
+        }
+        if (response.status >= 200 && response.status < 300 && response.body) {
+            const accounts = extractLocalSalesNavigatorElements(response.body)
+                .map((element) => typeof element === "object" && element !== null && !Array.isArray(element)
+                ? normalizeLocalSalesNavigatorAccount(element, queryUrl)
+                : null)
+                .filter((value) => value !== null);
+            account = exactCliImportAccountMatch(candidate, accounts);
+        }
+        salesNavCompanyUrl =
+            (typeof account?.salesNavCompanyUrl === "string"
+                ? account.salesNavCompanyUrl
+                : null) ?? salesNavCompanyUrl;
+        linkedinCompanyUrl =
+            (typeof account?.linkedinCompanyUrl === "string"
+                ? account.linkedinCompanyUrl
+                : null) ?? linkedinCompanyUrl;
+        matchedCompanyName =
+            typeof account?.companyName === "string" ? account.companyName : null;
+        resolvedCompanyId =
+            (typeof account?.companyId === "string" && /^\d+$/.test(account.companyId)
+                ? account.companyId
+                : null) ??
+                extractLinkedInCompanyIdFromUrl(salesNavCompanyUrl) ??
+                extractLinkedInCompanyIdFromUrl(linkedinCompanyUrl) ??
+                null;
+    }
+    if (!linkedinCompanyUrl && resolvedCompanyId) {
+        linkedinCompanyUrl = normalizeLinkedInCompanyPage(resolvedCompanyId);
+    }
+    if (!salesNavCompanyUrl && resolvedCompanyId) {
+        salesNavCompanyUrl = `https://www.linkedin.com/sales/company/${resolvedCompanyId}`;
+    }
+    return {
+        candidate,
+        resolvedCompanyId,
+        salesNavCompanyUrl,
+        linkedinCompanyUrl,
+        matchedCompanyName,
+        accountSearchUsed,
+        account,
+    };
+}
+function cliImportCompanyProfileCommon(resolution) {
+    return {
+        companyKey: resolution.candidate.companyKey,
+        sourceCompanyId: resolution.candidate.companyId,
+        resolvedCompanyId: resolution.resolvedCompanyId,
+        sourceCompanyName: resolution.candidate.companyName,
+        companyName: resolution.matchedCompanyName ?? resolution.candidate.companyName,
+        salesNavCompanyUrl: resolution.salesNavCompanyUrl,
+        linkedinCompanyUrl: resolution.linkedinCompanyUrl,
+        enrichmentSource: resolution.accountSearchUsed
+            ? "sales_api_account_search+sales_api_company_detail"
+            : "sales_api_company_detail",
+    };
+}
+function formatCliImportCompanyLocation(value) {
+    if (typeof value === "string")
+        return normalizeLookupWhitespace(value) || null;
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return null;
+    }
+    const record = value;
+    const orderedKeys = [
+        "line1",
+        "line2",
+        "city",
+        "geographicArea",
+        "postalCode",
+        "country",
+    ];
+    return (orderedKeys
+        .map((key) => typeof record[key] === "string"
+        ? normalizeLookupWhitespace(record[key])
+        : "")
+        .filter(Boolean)
+        .join(", ") || null);
+}
+function normalizeCliImportCompanyDomain(website) {
+    if (!website)
+        return null;
+    try {
+        const hostname = new URL(website).hostname.replace(/^www\./i, "").toLowerCase();
+        return hostname && !/(^|\.)linkedin\.com$/i.test(hostname) ? hostname : null;
+    }
+    catch {
+        return null;
+    }
+}
+function compactCliImportCompanyString(value) {
+    return typeof value === "string" ? normalizeLookupWhitespace(value) || null : null;
+}
+function cliImportCompanyRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : null;
+}
+function buildCliImportCompanyProfile(resolution, detail, input) {
+    const common = cliImportCompanyProfileCommon(resolution);
+    if (!detail) {
+        return {
+            ...common,
+            status: input.status === 404 || input.status === 410 ? "not_found" : "failed",
+            error: input.error ??
+                `Sales Navigator company detail returned ${input.status || "no result"}`,
+            rawPayload: {
+                accountSearchUsed: resolution.accountSearchUsed,
+                httpStatus: input.status,
+            },
+        };
+    }
+    const accountRaw = cliImportCompanyRecord(resolution.account?.rawLocalSalesNavigatorAccountResult);
+    const accountWebsite = compactCliImportCompanyString(resolution.account?.website);
+    const website = normalizeCompanyWebsite(compactCliImportCompanyString(detail.website) ?? accountWebsite ?? undefined);
+    const specialties = Array.isArray(detail.specialties)
+        ? detail.specialties
+            .filter((value) => typeof value === "string")
+            .map((value) => normalizeLookupWhitespace(value))
+            .filter(Boolean)
+            .join(", ") || null
+        : compactCliImportCompanyString(detail.specialties);
+    const foundedCandidate = detail.yearFounded ?? detail.foundedYear;
+    const founded = typeof foundedCandidate === "number" && Number.isInteger(foundedCandidate)
+        ? foundedCandidate
+        : typeof foundedCandidate === "string" && /^\d{4}$/.test(foundedCandidate)
+            ? Number(foundedCandidate)
+            : null;
+    const revenueRange = cliImportCompanyRecord(detail.revenueRange);
+    const employeeGrowthPercentages = Array.isArray(detail.employeeGrowthPercentages)
+        ? detail.employeeGrowthPercentages.filter((value) => typeof value === "object" && value !== null && !Array.isArray(value))
+        : [];
+    const flagshipCompanyUrl = normalizeCompanyWebsite(compactCliImportCompanyString(detail.flagshipCompanyUrl) ?? undefined);
+    const linkedinCompanyUrl = flagshipCompanyUrl && /(^|\.)linkedin\.com$/i.test(new URL(flagshipCompanyUrl).hostname)
+        ? flagshipCompanyUrl
+        : resolution.linkedinCompanyUrl;
+    const accountEmployeeCount = typeof resolution.account?.employeeCount === "number"
+        ? resolution.account.employeeCount
+        : typeof detail.employeeDisplayCount === "number"
+            ? Math.max(0, Math.trunc(detail.employeeDisplayCount))
+            : typeof detail.employeeCount === "number"
+                ? Math.max(0, Math.trunc(detail.employeeCount))
+                : null;
+    const followerCount = typeof resolution.account?.followerCount === "number"
+        ? resolution.account.followerCount
+        : null;
+    return {
+        ...common,
+        companyName: compactCliImportCompanyString(detail.name) ?? common.companyName,
+        linkedinCompanyUrl,
+        website,
+        domain: normalizeCliImportCompanyDomain(website),
+        industry: compactCliImportCompanyString(detail.industry) ??
+            compactCliImportCompanyString(resolution.account?.industry),
+        companySize: extractFirstNestedStringByKeys(accountRaw, [
+            "employeeCountRange",
+            "companySize",
+        ]) ?? compactCliImportCompanyString(detail.employeeCountRange),
+        companyType: compactCliImportCompanyString(detail.type),
+        location: formatCliImportCompanyLocation(detail.location) ??
+            compactCliImportCompanyString(resolution.account?.location),
+        headquarters: formatCliImportCompanyLocation(detail.headquarters) ??
+            compactCliImportCompanyString(resolution.account?.headquarters),
+        employeesOnLinkedIn: accountEmployeeCount,
+        followerCount,
+        description: compactCliImportCompanyString(detail.description) ??
+            compactCliImportCompanyString(resolution.account?.description),
+        tagline: null,
+        specialties,
+        founded,
+        revenueRange,
+        employeeGrowthPercentages,
+        logoUrl: buildLinkedInImageUrl(detail.companyPictureDisplayImage) ??
+            buildLinkedInImageUrl(detail.pictureInfo),
+        bannerUrl: buildLinkedInImageUrl(detail.companyBackgroundCoverImage),
+        flagshipCompanyUrl,
+        status: "enriched",
+        error: null,
+        rawPayload: {
+            accountSearchUsed: resolution.accountSearchUsed,
+            httpStatus: input.status,
+            detail,
+            accountSearchResult: accountRaw,
+        },
+    };
+}
+async function runSalesNavigatorImportEnrichmentCommand(options) {
+    if (options.companiesOnly && options.hunterOnly) {
+        throw new Error("Use either --companies-only or --hunter-only, not both.");
+    }
+    const runIds = Array.from(new Set(options.runId.map((runId) => z.string().uuid().parse(runId))));
+    const companyTimeoutMs = z.coerce.number().int().min(1000).max(120000).parse(options.companyTimeoutMs);
+    const companyDelayMinMs = z.coerce.number().int().min(0).parse(options.companyDelayMinMs);
+    const companyDelayMaxMs = z.coerce.number().int().min(companyDelayMinMs).parse(options.companyDelayMaxMs);
+    const browserRelayPort = options.browserRelayPort == null
+        ? null
+        : z.coerce.number().int().min(0).max(65535).parse(options.browserRelayPort);
+    const maxCompanies = z.coerce.number().int().min(0).max(1000).parse(options.maxCompanies);
+    const companySaveBatchSize = z.coerce.number().int().min(1).max(200).parse(options.companySaveBatchSize);
+    const hunterBatchSize = z.coerce.number().int().min(1).max(150).parse(options.hunterBatchSize);
+    const maxHunterBatches = z.coerce.number().int().min(0).max(100000).parse(options.maxHunterBatches);
+    const session = await requireAuthSession();
+    const startedAt = new Date().toISOString();
+    const initialStatus = await getCliImportEnrichmentStatusViaApp(session, runIds);
+    if (options.dryRun) {
+        const companyCandidates = options.hunterOnly
+            ? []
+            : (await getCliImportCompanyCandidatesViaApp(session, {
+                runIds,
+                limit: 1000,
+                retry: options.retryCompanies
+            })).companies.slice(0, maxCompanies || undefined);
+        return {
+            status: "ok",
+            dryRun: true,
+            runIds,
+            initial: initialStatus,
+            companyCandidates: companyCandidates.length,
+            next: options.companiesOnly
+                ? "company enrichment only"
+                : options.hunterOnly
+                    ? "Hunter enrichment only"
+                    : "company profiles, verified domains, then Hunter"
+        };
+    }
+    let companies = {
+        selected: 0,
+        saved: 0,
+        enriched: 0,
+        domains: 0,
+        notFound: 0,
+        failed: 0
+    };
+    if (!options.hunterOnly) {
+        const companyCandidates = (await getCliImportCompanyCandidatesViaApp(session, {
+            runIds,
+            limit: 1000,
+            retry: options.retryCompanies
+        })).companies.slice(0, maxCompanies || undefined);
+        companies.selected = companyCandidates.length;
+        if (companyCandidates.length > 0) {
+            const browserRelay = browserRelayPort == null
+                ? null
+                : await createLocalAccountSearchBrowserRelay(browserRelayPort);
+            try {
+                const config = browserRelay ? null : await readLinkedInDirectLookupConfig();
+                let pendingProfiles = [];
+                const flushCompanyProfiles = async () => {
+                    while (pendingProfiles.length > 0) {
+                        const batch = pendingProfiles.splice(0, companySaveBatchSize);
+                        const saved = await saveCliImportCompanyProfilesViaApp(session, batch);
+                        companies = {
+                            ...companies,
+                            saved: companies.saved + saved.saved,
+                            enriched: companies.enriched + saved.enriched,
+                            domains: companies.domains + saved.domains,
+                            notFound: companies.notFound + saved.notFound,
+                            failed: companies.failed + saved.failed
+                        };
+                        writeProgress(`Company enrichment: ${companies.saved}/${companyCandidates.length} saved, ${companies.domains} domains.`);
+                    }
+                };
+                const detailCache = new Map();
+                const companyIdsWithDetails = new Set();
+                const enrichResolvedCompanies = async (resolutions) => {
+                    const resolutionBatchSize = 20;
+                    for (let offset = 0; offset < resolutions.length; offset += resolutionBatchSize) {
+                        const resolutionBatch = resolutions.slice(offset, offset + resolutionBatchSize);
+                        const ids = Array.from(new Set(resolutionBatch
+                            .map((resolution) => resolution.resolvedCompanyId)
+                            .filter((value) => Boolean(value)))).filter((companyId) => !detailCache.has(companyId));
+                        if (ids.length > 0) {
+                            const response = await fetchCliImportSalesNavigatorJson({
+                                url: buildCliImportCompanyDetailsUrl(ids),
+                                config,
+                                browserRelay,
+                                timeoutMs: companyTimeoutMs,
+                                label: `Sales Navigator company details ${companies.saved + 1}-${companies.saved + resolutionBatch.length}`,
+                                companyId: ids[0] ?? null,
+                            });
+                            const results = cliImportCompanyRecord(response.body?.results) ?? {};
+                            const errors = cliImportCompanyRecord(response.body?.errors) ?? {};
+                            const statuses = cliImportCompanyRecord(response.body?.statuses) ?? {};
+                            for (const companyId of ids) {
+                                const detail = cliImportCompanyRecord(results[companyId]);
+                                const statusValue = statuses[companyId];
+                                const status = typeof statusValue === "number"
+                                    ? statusValue
+                                    : typeof statusValue === "string" && /^\d+$/.test(statusValue)
+                                        ? Number(statusValue)
+                                        : response.status;
+                                const errorValue = errors[companyId];
+                                detailCache.set(companyId, {
+                                    detail,
+                                    status,
+                                    error: errorValue
+                                        ? JSON.stringify(errorValue).slice(0, 3000)
+                                        : response.status >= 200 && response.status < 300
+                                            ? null
+                                            : `Sales Navigator company details returned ${response.status}`,
+                                });
+                            }
+                        }
+                        const fallbackResolutions = [];
+                        for (let index = 0; index < resolutionBatch.length; index += 1) {
+                            const resolution = resolutionBatch[index];
+                            const cached = detailCache.get(resolution.resolvedCompanyId ?? "");
+                            if (cached?.detail && resolution.resolvedCompanyId) {
+                                companyIdsWithDetails.add(resolution.resolvedCompanyId);
+                            }
+                            if (!cached?.detail &&
+                                cached?.status === 404 &&
+                                !resolution.accountSearchUsed &&
+                                resolution.candidate.companyName) {
+                                try {
+                                    const fallback = await resolveCliImportCompanyIdentity({
+                                        ...resolution.candidate,
+                                        companyId: null,
+                                        salesNavCompanyUrl: null,
+                                        linkedinCompanyUrl: null,
+                                    }, config, companyTimeoutMs, browserRelay);
+                                    if (fallback.resolvedCompanyId) {
+                                        fallbackResolutions.push(fallback);
+                                    }
+                                    else {
+                                        pendingProfiles.push(buildCliImportCompanyProfile(fallback, null, {
+                                            status: 404,
+                                            error: "No exact LinkedIn company was found by Account Search",
+                                        }));
+                                    }
+                                }
+                                catch (error) {
+                                    if (error instanceof CliImportCompanyRateLimitError ||
+                                        error instanceof CliImportCompanySessionError) {
+                                        throw error;
+                                    }
+                                    pendingProfiles.push(buildCliImportCompanyProfile(resolution, null, {
+                                        status: 500,
+                                        error: error instanceof Error ? error.message : String(error),
+                                    }));
+                                }
+                                if (index < resolutionBatch.length - 1 &&
+                                    companyDelayMaxMs > 0) {
+                                    await delay(randomIntegerBetween(companyDelayMinMs, companyDelayMaxMs));
+                                }
+                                continue;
+                            }
+                            pendingProfiles.push(buildCliImportCompanyProfile(resolution, cached?.detail ?? null, {
+                                status: cached?.status ?? 500,
+                                error: cached?.error ?? "Sales Navigator returned no company detail",
+                            }));
+                        }
+                        await flushCompanyProfiles();
+                        if (fallbackResolutions.length > 0) {
+                            await enrichResolvedCompanies(fallbackResolutions);
+                        }
+                        if (offset + resolutionBatchSize < resolutions.length &&
+                            companyDelayMaxMs > 0) {
+                            await delay(randomIntegerBetween(companyDelayMinMs, companyDelayMaxMs));
+                        }
+                    }
+                };
+                const knownCandidates = companyCandidates.filter((candidate) => candidate.companyId && /^\d+$/.test(candidate.companyId));
+                const knownResolutions = await Promise.all(knownCandidates.map((candidate) => resolveCliImportCompanyIdentity(candidate, config, companyTimeoutMs, browserRelay)));
+                await enrichResolvedCompanies(knownResolutions);
+                const knownByAlias = new Map();
+                for (const candidate of knownCandidates) {
+                    if (!candidate.companyId ||
+                        !companyIdsWithDetails.has(candidate.companyId)) {
+                        continue;
+                    }
+                    for (const alias of [
+                        candidate.companyName ?? "",
+                        aggressivelyCleanLookupCompanyName(candidate.companyName ?? ""),
+                    ]) {
+                        const key = normalizeLooseMatchText(alias);
+                        if (!key)
+                            continue;
+                        const entries = knownByAlias.get(key) ?? [];
+                        entries.push(candidate);
+                        knownByAlias.set(key, entries);
+                    }
+                }
+                const unresolvedCandidates = [];
+                const localAliasResolutions = [];
+                for (const candidate of companyCandidates) {
+                    if (candidate.companyId && /^\d+$/.test(candidate.companyId))
+                        continue;
+                    const matches = new Map();
+                    for (const alias of [
+                        candidate.companyName ?? "",
+                        aggressivelyCleanLookupCompanyName(candidate.companyName ?? ""),
+                    ]) {
+                        const key = normalizeLooseMatchText(alias);
+                        for (const match of knownByAlias.get(key) ?? []) {
+                            if (match.companyId)
+                                matches.set(match.companyId, match);
+                        }
+                    }
+                    if (matches.size === 1) {
+                        const match = Array.from(matches.values())[0];
+                        localAliasResolutions.push({
+                            candidate,
+                            resolvedCompanyId: match.companyId,
+                            salesNavCompanyUrl: match.salesNavCompanyUrl ??
+                                `https://www.linkedin.com/sales/company/${match.companyId}`,
+                            linkedinCompanyUrl: match.linkedinCompanyUrl ??
+                                normalizeLinkedInCompanyPage(match.companyId),
+                            matchedCompanyName: match.companyName,
+                            accountSearchUsed: false,
+                            account: null,
+                        });
+                    }
+                    else {
+                        unresolvedCandidates.push(candidate);
+                    }
+                }
+                await enrichResolvedCompanies(localAliasResolutions);
+                writeProgress(`Company identities: ${knownResolutions.length} imported IDs, ${localAliasResolutions.length} local aliases, ${unresolvedCandidates.length} Account Search candidates.`);
+                const accountSearchGroupSize = 5;
+                let accountSearches = 0;
+                for (let offset = 0; offset < unresolvedCandidates.length; offset += accountSearchGroupSize) {
+                    const group = unresolvedCandidates.slice(offset, offset + accountSearchGroupSize);
+                    const resolvedGroup = [];
+                    for (let index = 0; index < group.length; index += 1) {
+                        const candidate = group[index];
+                        let resolution = null;
+                        try {
+                            resolution = await resolveCliImportCompanyIdentity(candidate, config, companyTimeoutMs, browserRelay);
+                        }
+                        catch (error) {
+                            if (error instanceof CliImportCompanyRateLimitError ||
+                                error instanceof CliImportCompanySessionError) {
+                                throw error;
+                            }
+                            pendingProfiles.push(buildCliImportCompanyProfile({
+                                candidate,
+                                resolvedCompanyId: null,
+                                salesNavCompanyUrl: candidate.salesNavCompanyUrl,
+                                linkedinCompanyUrl: candidate.linkedinCompanyUrl,
+                                matchedCompanyName: null,
+                                accountSearchUsed: true,
+                                account: null,
+                            }, null, {
+                                status: 500,
+                                error: error instanceof Error
+                                    ? error.message
+                                    : String(error),
+                            }));
+                        }
+                        accountSearches += 1;
+                        if (resolution?.resolvedCompanyId) {
+                            resolvedGroup.push(resolution);
+                        }
+                        else if (resolution) {
+                            pendingProfiles.push(buildCliImportCompanyProfile(resolution, null, {
+                                status: 404,
+                                error: "No exact LinkedIn company was found by Account Search",
+                            }));
+                        }
+                        if (index < group.length - 1 &&
+                            companyDelayMaxMs > 0) {
+                            await delay(randomIntegerBetween(companyDelayMinMs, companyDelayMaxMs));
+                        }
+                    }
+                    await flushCompanyProfiles();
+                    await enrichResolvedCompanies(resolvedGroup);
+                    writeProgress(`Account Search: ${Math.min(offset + group.length, unresolvedCandidates.length)}/${unresolvedCandidates.length} checked (${accountSearches} requests).`);
+                }
+            }
+            finally {
+                await browserRelay?.close();
+            }
+        }
+    }
+    let hunter = {
+        batches: 0,
+        selected: 0,
+        processed: 0,
+        found: 0,
+        notFound: 0,
+        failed: 0
+    };
+    if (!options.companiesOnly) {
+        const retryBefore = options.retryEmails ? startedAt : null;
+        while (maxHunterBatches === 0 || hunter.batches < maxHunterBatches) {
+            const batch = await runCliImportHunterBatchViaApp(session, {
+                runIds,
+                limit: hunterBatchSize,
+                retryBefore
+            });
+            if (batch.selected === 0)
+                break;
+            hunter = {
+                batches: hunter.batches + 1,
+                selected: hunter.selected + batch.selected,
+                processed: hunter.processed + batch.processed,
+                found: hunter.found + batch.found,
+                notFound: hunter.notFound + batch.notFound,
+                failed: hunter.failed + batch.failed
+            };
+            writeProgress(`Hunter enrichment: ${hunter.processed} checked, ${hunter.found} emails found.`);
+            if (batch.halted) {
+                throw new Error(`Hunter enrichment stopped: ${batch.error ?? "provider unavailable"}. Saved progress will be reused.`);
+            }
+        }
+    }
+    const finalStatus = await getCliImportEnrichmentStatusViaApp(session, runIds);
+    const payload = {
+        status: "ok",
+        dryRun: false,
+        runIds,
+        companies,
+        hunter,
+        before: initialStatus,
+        after: finalStatus,
+        outreachStarted: false,
+        workspaceUrl: `${session.apiBaseUrl}/leads/cli-imports?runId=${encodeURIComponent(runIds[0])}`
+    };
+    if (options.out)
+        await writeJsonFile(options.out, payload);
+    return payload;
+}
 async function runAffiliateLaunchCommand(options) {
     const affiliateLink = z.string().url().parse(options.affiliateLink);
     const linkedInUrl = z.string().url().parse(options.linkedinUrl);
@@ -13444,6 +14225,28 @@ program
     .action(async (options) => {
     printOutput(await runSalesNavigatorPeopleCollectCommand(options));
 });
+program
+    .command("salesnav:people:enrich")
+    .alias("leads:enrich-import")
+    .description("Enrich stored CLI imports with company profiles, verified domains, and Hunter emails.")
+    .requiredOption("--run-id <uuid>", "Workspace import run id; repeat the option or pass comma-separated ids", collectRunId, [])
+    .option("--browser-relay-port <number>", "Use the signed-in browser for Account Search and company-detail requests")
+    .option("--company-timeout-ms <number>", "Timeout for each company lookup", "20000")
+    .option("--company-delay-min-ms <number>", "Minimum delay between LinkedIn company lookups", "1500")
+    .option("--company-delay-max-ms <number>", "Maximum delay between LinkedIn company lookups", "3000")
+    .option("--max-companies <number>", "Maximum companies for this invocation; 0 processes all eligible companies", "0")
+    .option("--company-save-batch-size <number>", "Company rows saved per request", "50")
+    .option("--hunter-batch-size <number>", "Hunter contacts checked per request", "100")
+    .option("--max-hunter-batches <number>", "Maximum Hunter batches; 0 continues until no eligible people remain", "0")
+    .option("--companies-only", "Stop after company profiles and domains", false)
+    .option("--hunter-only", "Skip company lookup and use already stored domains", false)
+    .option("--retry-companies", "Retry previously saved company failures", false)
+    .option("--retry-emails", "Retry previously checked unresolved emails once", false)
+    .option("--dry-run", "Show scope without LinkedIn or Hunter requests", false)
+    .option("--out <path>", "Optional JSON result path")
+    .action(async (options) => {
+    printOutput(await runSalesNavigatorImportEnrichmentCommand(options));
+});
 addAffiliateAudienceOptions(program
     .command("affiliate:launch")
     .description("Build an affiliate audience from an affiliate link and LinkedIn search URL."))

package/dist/linkedin-companies.js

@@ -135,8 +135,20 @@ export function parseLinkedInCompanyPage(html, requestUrl) {
         normalizeWhitespace($("h1").first().text()) ||
         normalizeWhitespace($('meta[property="og:title"]').attr("content")) ||
         undefined;
-    const website = normalizeWhitespace(String(jsonLd?.url ?? "")) ||
-        normalizeWhitespace(definitions.get("website")) ||
+    const jsonLdUrl = normalizeWhitespace(String(jsonLd?.url ?? ""));
+    const jsonLdWebsite = (() => {
+        if (!jsonLdUrl)
+            return undefined;
+        try {
+            const hostname = new URL(jsonLdUrl).hostname;
+            return /(^|\.)linkedin\.com$/i.test(hostname) ? undefined : jsonLdUrl;
+        }
+        catch {
+            return undefined;
+        }
+    })();
+    const website = normalizeWhitespace(definitions.get("website")) ||
+        jsonLdWebsite ||
         undefined;
     const description = normalizeWhitespace(String(jsonLd?.description ?? "")) ||
         normalizeWhitespace($('meta[name="description"]').attr("content")) ||

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "salesprompter-cli",
-  "version": "0.1.50",
+  "version": "0.1.52",
   "description": "Sales workflow CLI for guided lead generation, enrichment, scoring, and sync.",
   "author": "Daniel Sinewe <hello@danielsinewe.com>",
   "type": "module",