salesprompter-cli 0.1.77 → 0.1.79

package/README.md

@@ -44,10 +44,22 @@ For headless or automation use, generate a CLI token in the app and run `salespr
 
 The checkpoint, shortlist and review exports refresh after every completed search, so long runs expose saved progress immediately. Company labels with punctuation, such as `(TKMS)`, are escaped safely in search queries.
 
+Use `--report-only` to refresh saved reports without contacting LinkedIn. The workspace-bound checkpoint is still checked. `progress` separates unique shortlisted people, review rows, review people, review-only people, pending searches, partial/unknown coverage and unresolved companies. `collectionComplete` is false while any coverage gap remains; `nextActions` explains what is left. Unrestricted geography is labeled explicitly.
+
+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.
 
 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; use a new output directory for intentionally retrying saved identity misses. `--all` removes the invocation's job-count limit, not LinkedIn pacing or per-function candidate limits. A working LinkedIn session is required; the Codex browser relay still requires a connected browser worker when used.
+
 ```json
 {
   "companies": [

package/dist/cli.js

@@ -15141,12 +15141,15 @@ program
     .requiredOption("--brief <path>", "JSON company list with verified company IDs and optional role criteria")
     .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("--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) => {
     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;
@@ -15155,12 +15158,17 @@ program
     const orgId = session.user.orgId;
     if (!orgId)
         throw new Error("Choose a Salesprompter workspace before company research.");
+    if (options.reportOnly) {
+        const report = await runCompanyResearch({ brief, outDir: path.resolve(options.outDir), scope: `${session.apiBaseUrl}:${orgId}`, maxSearches: 0, search: async () => { throw new Error("Report-only cannot collect leads."); } });
+        printOutput({ status: "ok", reportOnly: true, progress: report.progress, nextActions: report.nextActions, output: report.output, outreachStarted: false, emailEnrichmentStarted: false });
+        return;
+    }
     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),
+        isAuthError: error => error instanceof CliImportCompanySessionError || error instanceof LocalSalesNavigatorHttpError && (error.status === 401 || error.status === 403),
         refresh: async () => relay || shouldDisableLinkedInDirectLookupAutodiscovery() ? null : readLocalLinkedInExtensionDirectLookupConfig(),
         sameSession: (a, b) => a?.cookie === b?.cookie && a?.csrfToken === b?.csrfToken,
         beforeRetry: async () => {
@@ -15171,6 +15179,40 @@ program
     let startedSearches = 0;
     try {
         const report = await runCompanyResearch({ brief, outDir: path.resolve(options.outDir), scope: `${session.apiBaseUrl}:${orgId}`, maxSearches,
+            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));
@@ -15187,7 +15229,7 @@ program
                 });
             },
         });
-        printOutput({ status: report.status, selected: report.selected.length, reviewRequired: report.review.length, completedSearches: report.completedSearches, totalSearches: report.totalSearches, coverage: report.coverage, output: report.output, resumable: true, outreachStarted: false, emailEnrichmentStarted: false });
+        printOutput({ status: report.status, selected: report.selected.length, reviewRequired: report.review.length, progress: report.progress, nextActions: report.nextActions, completedSearches: report.completedSearches, totalSearches: report.totalSearches, coverage: report.coverage, output: report.output, resumable: true, outreachStarted: false, emailEnrichmentStarted: false });
     }
     finally {
         await relay?.close();

package/dist/company-leads.js

@@ -14,6 +14,7 @@ export const defaultDepartments = [
 const companySchema = z.object({
     name: z.string().trim().min(1),
     companyId: z.string().regex(/^[1-9]\d*$/).optional(),
+    verifiedEmployerAliases: z.array(z.object({ name: z.string().trim().min(1), evidenceUrl: z.url() }).strict()).optional(),
     maxContacts: z.number().int().min(1).max(100).default(20),
 }).strict();
 export const CompanyBriefSchema = z.object({
@@ -115,8 +116,9 @@ export function shortlistCompanyLeads(brief, results) {
                     continue;
                 }
                 const sourceCompanyName = positions?.find(p => p.title === title)?.companyName ?? p.companyName ?? "";
-                const employerNameDiffers = Boolean(sourceCompanyName) && words(String(sourceCompanyName)) !== words(company.name);
-                const row = { profileUrl: profile, fullName: p.fullName ?? "", title, companyId: company.companyId, companyName: company.name, sourceCompanyName, department: job.department.name, location: p.location ?? "", sourceQueryUrl: job.queryUrl, observedAt: p.timestamp ?? "" };
+                const alias = company.verifiedEmployerAliases?.find(a => words(a.name) === words(String(sourceCompanyName)));
+                const employerNameDiffers = Boolean(sourceCompanyName) && words(String(sourceCompanyName)) !== words(company.name) && !alias;
+                const row = { profileUrl: profile, fullName: p.fullName ?? "", title, companyId: company.companyId, companyName: company.name, sourceCompanyName, employerAliasEvidence: alias?.evidenceUrl ?? "", department: job.department.name, location: p.location ?? "", sourceQueryUrl: job.queryUrl, observedAt: p.timestamp ?? "" };
                 if (role === "review" || employerNameDiffers) {
                     const key = `${company.companyId}:${job.department.name}:${profile}`;
                     if (!reviewSeen.has(key)) {
@@ -151,10 +153,32 @@ export function shortlistCompanyLeads(brief, results) {
             status: !company.companyId ? "unresolved_company" : jobs.some(j => !results[j.key]) ? "pending" : local.length ? "review_ready" : "no_verified_matches",
             departments: jobs.map(j => ({ name: j.department.name, selected: local.filter(p => p.department === j.department.name).length, collected: results[j.key]?.people.length ?? null, reported: results[j.key]?.totalResults ?? null, searchComplete: results[j.key]?.totalResults != null ? results[j.key].people.length >= results[j.key].totalResults : null })) });
     }
-    return { selected, review, rejected, coverage, outreachStarted: false, emailEnrichmentStarted: false };
+    const jobs = planCompanySearches(brief);
+    const completed = jobs.filter(j => results[j.key]);
+    const incomplete = completed.filter(j => results[j.key].totalResults != null && results[j.key].people.length < results[j.key].totalResults);
+    const unknown = completed.filter(j => results[j.key].totalResults == null);
+    const selectedIds = new Set(selected.map(p => String(p.profileUrl)));
+    const reviewIds = new Set(review.map(p => String(p.profileUrl)));
+    const unresolved = brief.companies.filter(c => !c.companyId);
+    const progress = {
+        selectedPeople: selectedIds.size, reviewRows: review.length, reviewPeople: reviewIds.size,
+        reviewOnlyPeople: [...reviewIds].filter(id => !selectedIds.has(id)).length,
+        candidateRows: completed.reduce((n, j) => n + results[j.key].people.length, 0),
+        completedSearches: completed.length, totalSearches: jobs.length, remainingSearches: jobs.length - completed.length,
+        partialSearches: incomplete.length, unknownCoverageSearches: unknown.length, unresolvedCompanies: unresolved.length,
+        collectionComplete: completed.length === jobs.length && !unresolved.length && !incomplete.length && !unknown.length,
+        geography: brief.regionIds.length ? "explicit_regions" : "unrestricted",
+    };
+    const nextActions = [
+        ...(progress.remainingSearches ? ["Resume the unchanged brief and output directory to collect pending searches."] : []),
+        ...(unresolved.length ? ["Verify unresolved company identities; use a new output directory after changing the brief."] : []),
+        ...(incomplete.length || unknown.length ? ["Review partial or unknown search coverage before claiming exhaustive collection."] : []),
+        ...(review.length ? ["Review roles and employer names separately. Add only evidence-backed verifiedEmployerAliases; exact company ID checks still apply."] : []),
+    ];
+    return { selected, review, rejected, coverage, progress, nextActions, outreachStarted: false, emailEnrichmentStarted: false };
 }
 export function companyLeadCsv(rows) {
-    const columns = ["companyName", "companyId", "fullName", "title", "department", "profileUrl", "location", "sourceQueryUrl", "observedAt", "sourceCompanyName", "reason"];
+    const columns = ["companyName", "companyId", "fullName", "title", "department", "profileUrl", "location", "sourceQueryUrl", "observedAt", "sourceCompanyName", "reason", "employerAliasEvidence"];
     const escape = (value) => { let s = String(value ?? ""); if (/^[=+@\-\t\r]/.test(s))
         s = "'" + s; return `"${s.replace(/"/g, '""')}"`; };
     return [columns.join(","), ...rows.map(r => columns.map(c => escape(r[c])).join(","))].join("\n") + "\n";
@@ -193,18 +217,45 @@ 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;
+                if (company.companyId || Object.hasOwn(state.resolutions ?? {}, String(index)))
+                    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) {
@@ -212,5 +263,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/package.json

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