salesprompter-cli 0.1.78 → 0.1.80

package/README.md

@@ -48,10 +48,23 @@ Use `--report-only` to refresh saved reports without contacting LinkedIn. The wo
 
 For a manually verified legal-name alias, add `verifiedEmployerAliases: [{ "name": "Exact source employer name", "evidenceUrl": "https://official.example/legal" }]` to that company. The CLI records the evidence link but does not independently verify its contents. Aliases never bypass the numeric current-company ID check and are never inferred from similar names. Changing the brief requires a new output directory; no existing review rows are silently promoted.
 
-If LinkedIn rejects the saved session, the command tries a different local extension-synced session once and keeps completed searches. If none works, reconnect the extension or use `--browser-relay-port` with a signed-in browser worker. Rate limits stop the run without switching sessions.
+LinkedIn credentials are loaded only when a pending request needs them; a completed checkpoint can be reopened without LinkedIn credentials (Salesprompter workspace authentication still applies). If LinkedIn rejects the saved session, the command tries refreshed local extension credentials for the same LinkedIn identity once and keeps completed searches. Add `--wait-for-session 300` to wait up to five minutes for that refresh, with progress notices. The CLI does not log in to LinkedIn for you. If none arrives, reconnect the extension and rerun, or use `--browser-relay-port` with a signed-in browser worker. Rate limits stop the run without switching sessions. Session waiting and browser relay are mutually exclusive.
 
 Create a JSON brief with verified numeric LinkedIn company IDs. Use each subsidiary's own ID; names alone are not an employer match. Missing IDs stay in the coverage report as unresolved.
 
+For a name-only list, the executable end-to-end research mode is:
+
+```bash
+salesprompter leads:at-companies --brief companies.json --out-dir ./research --resolve-companies --all
+```
+
+The CLI first collects prepared IDs, then resolves missing IDs through paginated Account Search and immediately collects their contacts. It accepts only one exact-name identity from a fully read result set of at most 1,000 companies; fuzzy, shared-ID, oversized and ambiguous matches remain unresolved. Resolutions and misses are saved in the workspace-bound checkpoint and `company-resolutions.json`, without editing the input brief. Repeat the command to resume. Add `--retry-unresolved --resolve-companies` to intentionally retry saved identity misses in the same directory without repeating successful resolutions or completed searches. `--all` removes the invocation's job-count limit, not LinkedIn pacing or per-function candidate limits. A working LinkedIn session is required for new requests; the Codex browser relay still requires a connected browser worker when used.
+
+```bash
+salesprompter leads:at-companies --brief companies.json --out-dir ./research \
+  --resolve-companies --retry-unresolved --all --wait-for-session 300
+```
+
 ```json
 {
   "companies": [

package/dist/cli.js

@@ -16,7 +16,7 @@ import { Command } from "commander";
 import { z } from "zod";
 import { AffiliateCopyReviewSchema, renderAffiliateCopyReview } from "./affiliate-copy.js";
 import { CompanyBriefSchema, planCompanySearches, runCompanyResearch } from "./company-leads.js";
-import { createSessionRecovery } from "./session-recovery.js";
+import { createLazySessionRecovery, waitForFreshSession, isFreshSessionForIdentity } from "./session-recovery.js";
 import { clearAuthSession, loginWithBrowserConnect, loginWithDeviceFlow, loginWithToken, readAuthSession, requireAuthSession, shouldBypassAuth, verifySession, writeAuthSession } from "./auth.js";
 import { buildBigQueryLeadLookupSql, executeBigQuerySql, normalizeBigQueryLeadRows, runBigQueryQuery, runBigQueryRows } from "./bigquery.js";
 import { AccountProfileSchema, EnrichedLeadSchema, IcpSchema, LeadSchema, ScoredLeadSchema, SyncTargetSchema } from "./domain.js";
@@ -15142,12 +15142,21 @@ program
     .option("--out-dir <path>", "Private output directory and resume checkpoint", "./company-leads")
     .option("--max-searches <number>", "Maximum company/function searches this invocation", "12")
     .option("--report-only", "Refresh saved research reports without contacting LinkedIn", false)
+    .option("--all", "Process all pending company/function searches in this invocation", false)
+    .option("--resolve-companies", "Resolve unique exact company names and collect their contacts in the same run", false)
+    .option("--retry-unresolved", "Retry cached identity misses without discarding completed searches (requires --resolve-companies)", false)
+    .option("--wait-for-session <seconds>", "Wait for a refreshed extension session after an auth failure; never retry rate limits", "0")
     .option("--browser-relay-port <number>", "Use the signed-in Codex browser through a loopback relay")
     .option("--dry-run", "Preview targeting and unresolved companies without network calls", false)
     .action(async (options) => {
+    if (options.retryUnresolved && !options.resolveCompanies)
+        throw new Error("--retry-unresolved requires --resolve-companies.");
+    const waitMs = z.coerce.number().int().min(0).max(3600).parse(options.waitForSession) * 1000;
+    if (waitMs && options.browserRelayPort)
+        throw new Error("--wait-for-session refreshes extension credentials, not a browser relay. Use one connection mode.");
     const brief = await readJsonFile(path.resolve(options.brief), CompanyBriefSchema);
     const jobs = planCompanySearches(brief);
-    const maxSearches = z.coerce.number().int().min(1).max(10000).parse(options.maxSearches);
+    const maxSearches = options.all ? Number.MAX_SAFE_INTEGER : z.coerce.number().int().min(1).max(10000).parse(options.maxSearches);
     if (options.dryRun) {
         printOutput({ status: "ok", dryRun: true, searches: jobs, unresolvedCompanies: brief.companies.filter(c => !c.companyId), maxSearches, outreachStarted: false, emailEnrichmentStarted: false });
         return;
@@ -15163,11 +15172,34 @@ program
     }
     const port = options.browserRelayPort == null ? null : z.coerce.number().int().min(1).max(65535).parse(options.browserRelayPort);
     const relay = port == null ? null : await createLocalAccountSearchBrowserRelay(port);
-    const config = relay ? null : await readLinkedInDirectLookupConfig();
-    const recoverSession = createSessionRecovery({
-        initial: config,
-        isAuthError: error => error instanceof LocalSalesNavigatorHttpError && (error.status === 401 || error.status === 403),
-        refresh: async () => relay || shouldDisableLinkedInDirectLookupAutodiscovery() ? null : readLocalLinkedInExtensionDirectLookupConfig(),
+    let currentConfig = null;
+    const refresh = async () => {
+        if (relay || shouldDisableLinkedInDirectLookupAutodiscovery())
+            return null;
+        return waitForFreshSession({
+            read: readLocalLinkedInExtensionDirectLookupConfig,
+            accept: next => isFreshSessionForIdentity(currentConfig, next),
+            waitMs,
+            onWaiting: () => writeProgress("Waiting for a refreshed Sales Navigator session from the same LinkedIn identity. Reconnect the Salesprompter extension; the pending search is preserved."),
+        });
+    };
+    const recoverSession = createLazySessionRecovery(async () => {
+        if (relay)
+            return null;
+        try {
+            currentConfig = await readLinkedInDirectLookupConfig();
+        }
+        catch (error) {
+            if (!waitMs || !(error instanceof Error) || !error.message.startsWith("Missing LinkedIn direct lookup session"))
+                throw error;
+            currentConfig = await refresh();
+            if (!currentConfig)
+                throw new Error("No LinkedIn session arrived before the wait expired. Reconnect the extension and rerun with the same --out-dir; saved work is preserved.");
+        }
+        return currentConfig;
+    }, {
+        isAuthError: error => error instanceof CliImportCompanySessionError || error instanceof LocalSalesNavigatorHttpError && (error.status === 401 || error.status === 403),
+        refresh,
         sameSession: (a, b) => a?.cookie === b?.cookie && a?.csrfToken === b?.csrfToken,
         beforeRetry: async () => {
             writeProgress("Saved LinkedIn session was rejected; trying the latest extension-synced session once.");
@@ -15176,7 +15208,41 @@ program
     });
     let startedSearches = 0;
     try {
-        const report = await runCompanyResearch({ brief, outDir: path.resolve(options.outDir), scope: `${session.apiBaseUrl}:${orgId}`, maxSearches,
+        const report = await runCompanyResearch({ brief, outDir: path.resolve(options.outDir), scope: `${session.apiBaseUrl}:${orgId}`, maxSearches, retryUnresolved: options.retryUnresolved,
+            resolveCompany: !options.resolveCompanies ? undefined : async (company) => {
+                if (startedSearches++ > 0)
+                    await delay(randomIntegerBetween(5000, 8000));
+                writeProgress(`Resolving ${company.name}`);
+                const queryUrl = buildCliImportAccountSearchUrl(company.name);
+                const response = await recoverSession(activeConfig => fetchCliImportSalesNavigatorJson({ url: queryUrl, config: activeConfig, browserRelay: relay, timeoutMs: 30000, label: `Company identity for ${company.name}` }));
+                if (response.status !== 200 || !response.body)
+                    throw new Error(`Company identity search failed (${response.status}).`);
+                const elements = extractLocalSalesNavigatorElements(response.body);
+                const total = extractLocalSalesNavigatorTotalResults(response.body);
+                // A truncated or unknown result set cannot establish a unique identity.
+                if (total == null || total > 1000)
+                    return null;
+                for (let start = 25; start < total; start += 25) {
+                    await delay(randomIntegerBetween(5000, 8000));
+                    const pageUrl = queryUrl.replace(/([?&])start=\d+/, `$1start=${start}`);
+                    const page = await recoverSession(activeConfig => fetchCliImportSalesNavigatorJson({ url: pageUrl, config: activeConfig, browserRelay: relay, timeoutMs: 30000, label: `Company identity for ${company.name}` }));
+                    if (page.status !== 200 || !page.body)
+                        throw new Error(`Company identity page failed (${page.status}).`);
+                    const rows = extractLocalSalesNavigatorElements(page.body);
+                    if (!rows.length)
+                        return null;
+                    elements.push(...rows);
+                }
+                if (elements.length < total)
+                    return null;
+                const accounts = elements.map(element => normalizeLocalSalesNavigatorAccount(element, queryUrl)).filter(Boolean);
+                const exact = accounts.filter(account => normalizeLooseMatchText(String(account.companyName ?? "")) === normalizeLooseMatchText(company.name));
+                const ids = new Set(exact.map(account => String(account.companyId ?? "")).filter(id => /^[1-9]\d*$/.test(id)));
+                if (ids.size !== 1)
+                    return null;
+                const companyId = [...ids][0];
+                return { companyId, companyName: company.name, evidenceUrl: `https://www.linkedin.com/sales/company/${companyId}` };
+            },
             search: async (job) => {
                 if (startedSearches++ > 0)
                     await delay(randomIntegerBetween(5000, 8000));

package/dist/company-leads.js

@@ -217,18 +217,46 @@ async function runCompanyResearchLocked(input) {
             throw e;
     }
     const save = async (file, value) => { await writeFile(file + ".tmp", value, { mode: 0o600 }); await chmod(file + ".tmp", 0o600); await rename(file + ".tmp", file); };
-    const publish = async () => { const report = shortlistCompanyLeads(brief, state.results); await save(path.join(outDir, "contacts.csv"), companyLeadCsv(report.selected)); await save(path.join(outDir, "review.csv"), companyLeadCsv(report.review)); await save(path.join(outDir, "coverage.json"), JSON.stringify(report, null, 2)); return report; };
+    const effectiveBrief = () => CompanyBriefSchema.parse({ ...brief, companies: brief.companies.map((company, index) => {
+            const resolution = state.resolutions?.[String(index)];
+            return !company.companyId && resolution ? { ...company, companyId: resolution.companyId } : company;
+        }) });
+    const publish = async () => { const report = shortlistCompanyLeads(effectiveBrief(), state.results); await save(path.join(outDir, "contacts.csv"), companyLeadCsv(report.selected)); await save(path.join(outDir, "review.csv"), companyLeadCsv(report.review)); await save(path.join(outDir, "coverage.json"), JSON.stringify(report, null, 2)); await save(path.join(outDir, "company-resolutions.json"), JSON.stringify(state.resolutions ?? {}, null, 2)); return report; };
     let performed = 0;
     try {
-        for (const job of planCompanySearches(brief)) {
-            if (state.results[job.key])
-                continue;
-            if (performed >= input.maxSearches)
-                break;
-            state.results[job.key] = await input.search(job);
-            performed++;
-            await save(checkpoint, JSON.stringify(state));
-            await publish();
+        // Known IDs run first; an unresolved identity cannot block already prepared work.
+        const collect = async () => {
+            for (const job of planCompanySearches(effectiveBrief())) {
+                if (state.results[job.key])
+                    continue;
+                if (performed >= input.maxSearches)
+                    break;
+                state.results[job.key] = await input.search(job);
+                performed++;
+                await save(checkpoint, JSON.stringify(state));
+                await publish();
+            }
+        };
+        await collect();
+        if (input.resolveCompany) {
+            let resolutionsPerformed = 0;
+            for (const [index, company] of brief.companies.entries()) {
+                if (performed >= input.maxSearches || resolutionsPerformed >= input.maxSearches)
+                    break;
+                const savedResolution = state.resolutions?.[String(index)];
+                if (company.companyId || (Object.hasOwn(state.resolutions ?? {}, String(index)) && !(input.retryUnresolved && savedResolution === null)))
+                    continue;
+                const resolution = await input.resolveCompany(company);
+                resolutionsPerformed++;
+                if (resolution && (!/^[1-9]\d*$/.test(resolution.companyId) || words(resolution.companyName) !== words(company.name)))
+                    throw new Error("Company resolver returned a non-exact identity.");
+                const occupied = new Set(effectiveBrief().companies.map(c => c.companyId).filter(Boolean));
+                state.resolutions ??= {};
+                state.resolutions[String(index)] = resolution && !occupied.has(resolution.companyId) ? resolution : null;
+                await save(checkpoint, JSON.stringify(state));
+                await publish();
+                await collect();
+            }
         }
     }
     catch (e) {
@@ -236,5 +264,5 @@ async function runCompanyResearchLocked(input) {
         throw e;
     }
     const report = await publish();
-    return { status: "ok", ...report, completedSearches: Object.keys(state.results).length, totalSearches: planCompanySearches(brief).length, output: outDir, resumable: true };
+    return { status: "ok", ...report, completedSearches: Object.keys(state.results).length, totalSearches: planCompanySearches(effectiveBrief()).length, output: outDir, resumable: true };
 }

package/dist/session-recovery.js

@@ -1,3 +1,34 @@
+export function isFreshSessionForIdentity(current, next) {
+    return current === null || next.identity === current.identity && (next.cookie !== current.cookie || next.csrfToken !== current.csrfToken);
+}
+/** Poll only the configured credential source. No provider requests or identity rotation. */
+export async function waitForFreshSession(options) {
+    const now = options.now ?? Date.now;
+    const sleep = options.sleep ?? (ms => new Promise(resolve => setTimeout(resolve, ms)));
+    const deadline = now() + options.waitMs;
+    let nextNotice = now();
+    while (true) {
+        const value = await options.read();
+        if (value !== null && options.accept(value))
+            return value;
+        const remaining = deadline - now();
+        if (remaining <= 0)
+            return null;
+        if (now() >= nextNotice) {
+            options.onWaiting?.();
+            nextNotice = now() + 30000;
+        }
+        await sleep(Math.min(5000, remaining));
+    }
+}
+/** Delay credential access until collection really needs it (cached runs need none). */
+export function createLazySessionRecovery(load, options) {
+    let runner;
+    return async (collect) => {
+        runner ??= createSessionRecovery({ ...options, initial: await load() });
+        return runner(collect);
+    };
+}
 /** One credential refresh per run; never rotate on rate limits or other failures. */
 export function createSessionRecovery(options) {
     let current = options.initial;

package/package.json

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