salesprompter-cli 0.1.32 → 0.1.34

package/dist/cli.js

@@ -42,6 +42,32 @@ const runtimeOutputOptions = {
     quiet: false
 };
 const nullableOptionalString = z.string().min(1).nullish().transform((value) => value ?? undefined);
+const CliWorkspaceSchema = z.object({
+    id: z.string().min(1),
+    name: nullableOptionalString,
+    slug: nullableOptionalString,
+    workspaceClientId: nullableOptionalString,
+    workspaceClientName: nullableOptionalString
+});
+const CliWorkspaceListResponseSchema = z.object({
+    workspaces: z.array(CliWorkspaceSchema),
+    currentOrgId: nullableOptionalString
+});
+const CliAuthUserSchema = z.object({
+    id: z.string().min(1),
+    email: z.string().email(),
+    name: nullableOptionalString,
+    orgId: nullableOptionalString,
+    orgName: nullableOptionalString,
+    orgSlug: nullableOptionalString,
+    workspaceClientId: nullableOptionalString,
+    workspaceClientName: nullableOptionalString
+});
+const CliWorkspaceSwitchResponseSchema = z.object({
+    token: z.string().min(1),
+    expiresAt: z.string().datetime().optional(),
+    user: CliAuthUserSchema
+});
 const LinkedInCompanyBackfillClientIdStateSchema = z
     .object({
     clientId: z.number().int().positive(),
@@ -311,6 +337,7 @@ const helpVisibleCommandNames = new Set([
     "packs:add",
     "upgrade",
     "auth:login",
+    "auth:workspace",
     "wizard",
     "auth:whoami",
     "llm:ready",
@@ -2563,6 +2590,37 @@ function resolveSessionOrgId(session) {
     const orgId = session.user.orgId?.trim();
     return orgId && orgId.length > 0 ? orgId : null;
 }
+function normalizeCliApiBaseUrl(value) {
+    return value.trim().replace(/\/+$/, "");
+}
+function getWorkspaceDisplayName(workspace) {
+    return (compactOptionalText(workspace.name) ??
+        compactOptionalText(workspace.workspaceClientName) ??
+        compactOptionalText(workspace.slug) ??
+        workspace.id);
+}
+function formatCliWorkspaceLabel(workspace) {
+    const name = getWorkspaceDisplayName(workspace);
+    const details = [
+        compactOptionalText(workspace.slug),
+        compactOptionalText(workspace.workspaceClientId),
+        workspace.id
+    ].filter((value) => Boolean(value));
+    return details.length > 0 ? `${name} (${details.join(", ")})` : name;
+}
+function workspaceMatchesInput(workspace, value) {
+    const normalized = normalizeChoiceText(value);
+    return [
+        workspace.id,
+        workspace.name,
+        workspace.slug,
+        workspace.workspaceClientId,
+        workspace.workspaceClientName
+    ].some((candidate) => {
+        const compacted = compactOptionalText(candidate);
+        return compacted ? normalizeChoiceText(compacted) === normalized : false;
+    });
+}
 function writeSessionSummary(session) {
     const identity = session.user.name?.trim()
         ? `${session.user.name} (${session.user.email})`
@@ -2747,6 +2805,21 @@ async function promptChoice(rl, prompt, options, defaultValue) {
         writeWizardLine();
     }
 }
+async function withPromptReader(existingReader, run) {
+    if (existingReader) {
+        return await run(existingReader);
+    }
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    try {
+        return await run(rl);
+    }
+    finally {
+        rl.close();
+    }
+}
 async function promptText(rl, prompt, options = {}) {
     while (true) {
         const suffix = options.defaultValue !== undefined ? ` [${options.defaultValue}]` : "";
@@ -2827,7 +2900,7 @@ async function confirmWizardWorkspace(rl, session, options) {
         ? hasNamedOrg
             ? "Current cached CLI workspace"
             : "Workspace name is not available in this cached token"
-        : "Choose another workspace in the browser if this account belongs to more than one";
+        : "Select from your Salesprompter organizations in this terminal";
     const workspaceChoice = await promptChoice(rl, "Which workspace should I use?", [
         {
             value: "current",
@@ -2837,8 +2910,8 @@ async function confirmWizardWorkspace(rl, session, options) {
         },
         {
             value: "browser",
-            label: "Choose another workspace in the browser",
-            description: "Opens Salesprompter so you can pick from your organizations",
+            label: "Choose another workspace",
+            description: "Select from your Salesprompter organizations in this terminal",
             aliases: ["browser", "choose another", "switch workspace", "select organization"]
         }
     ], "current");
@@ -2847,17 +2920,150 @@ async function confirmWizardWorkspace(rl, session, options) {
         return session;
     }
     writeWizardLine();
-    writeWizardLine("Choose the workspace for this CLI session in the browser.");
-    writeWizardLine();
-    await clearAuthSession();
-    const result = await performLogin({
+    const result = await switchWorkspaceInCli({
         apiUrl: options?.apiUrl ?? session.apiBaseUrl,
-        timeoutSeconds: options?.timeoutSeconds ?? 180
+        timeoutSeconds: options?.timeoutSeconds,
+        rl
     });
     writeSessionSummary(result.session);
     writeWizardLine();
     return result.session;
 }
+async function switchWorkspaceWithBrowser(options) {
+    await clearAuthSession();
+    return (await performLogin({
+        apiUrl: options?.apiUrl,
+        timeoutSeconds: options?.timeoutSeconds ?? 180
+    })).session;
+}
+async function listCliWorkspaces(session) {
+    const { session: refreshedSession, value } = await fetchCliJson(session, async (currentSession) => await fetch(`${normalizeCliApiBaseUrl(currentSession.apiBaseUrl)}/api/cli/auth/workspaces`, {
+        method: "GET",
+        headers: {
+            Authorization: `Bearer ${currentSession.accessToken}`,
+            "X-Salesprompter-Client": "salesprompter-cli/0.2"
+        }
+    }), CliWorkspaceListResponseSchema);
+    return {
+        session: refreshedSession,
+        workspaces: value.workspaces,
+        currentOrgId: value.currentOrgId ?? null
+    };
+}
+async function selectCliWorkspace(session, orgId) {
+    const { value } = await fetchCliJson(session, async (currentSession) => await fetch(`${normalizeCliApiBaseUrl(currentSession.apiBaseUrl)}/api/cli/auth/workspaces`, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${currentSession.accessToken}`,
+            "Content-Type": "application/json",
+            "X-Salesprompter-Client": "salesprompter-cli/0.2"
+        },
+        body: JSON.stringify({ orgId })
+    }), CliWorkspaceSwitchResponseSchema);
+    const nextSession = {
+        accessToken: value.token,
+        refreshToken: session.refreshToken,
+        apiBaseUrl: session.apiBaseUrl,
+        user: value.user,
+        expiresAt: value.expiresAt,
+        createdAt: new Date().toISOString()
+    };
+    await writeAuthSession(nextSession);
+    return nextSession;
+}
+async function promptForCliWorkspace(rl, workspaces, currentOrgId, requestedWorkspace) {
+    const requested = compactOptionalText(requestedWorkspace);
+    if (requested) {
+        const matched = workspaces.find((workspace) => workspaceMatchesInput(workspace, requested));
+        if (!matched) {
+            throw new Error(`workspace not found for this account: ${requested}`);
+        }
+        return matched.id;
+    }
+    const current = currentOrgId ? workspaces.find((workspace) => workspace.id === currentOrgId) : undefined;
+    const options = workspaces.map((workspace) => ({
+        value: workspace.id,
+        label: formatCliWorkspaceLabel(workspace),
+        description: workspace.id === currentOrgId ? "Current cached CLI workspace" : undefined,
+        aliases: [workspace.name, workspace.slug, workspace.workspaceClientId, workspace.workspaceClientName].filter((value) => Boolean(compactOptionalText(value)))
+    }));
+    options.push({
+        value: "browser",
+        label: "Use browser chooser",
+        description: "Fallback if this terminal list is missing a workspace",
+        aliases: ["browser", "open browser", "web"]
+    });
+    return await promptChoice(rl, "Which workspace should I use?", options, current?.id ?? options[0]?.value ?? "browser");
+}
+async function switchWorkspaceInCli(options = {}) {
+    if (options.browser) {
+        return {
+            session: await switchWorkspaceWithBrowser(options),
+            method: "browser"
+        };
+    }
+    let session = null;
+    try {
+        session = await requireAuthSession();
+        if (options.apiUrl) {
+            session = {
+                ...session,
+                apiBaseUrl: normalizeCliApiBaseUrl(options.apiUrl)
+            };
+        }
+    }
+    catch {
+        if (!runtimeOutputOptions.quiet) {
+            writeWizardLine("No cached CLI session found. Starting browser login flow.");
+            writeWizardLine();
+        }
+        return {
+            session: await switchWorkspaceWithBrowser(options),
+            method: "browser"
+        };
+    }
+    let workspaces;
+    let currentOrgId;
+    try {
+        const listed = await listCliWorkspaces(session);
+        session = listed.session;
+        workspaces = listed.workspaces;
+        currentOrgId = listed.currentOrgId;
+    }
+    catch (error) {
+        if (!runtimeOutputOptions.quiet) {
+            const message = error instanceof Error ? error.message : String(error);
+            writeWizardLine(`Terminal workspace selection is unavailable (${message}). Starting browser chooser.`);
+            writeWizardLine();
+        }
+        return {
+            session: await switchWorkspaceWithBrowser(options),
+            method: "browser"
+        };
+    }
+    if (workspaces.length === 0) {
+        if (!runtimeOutputOptions.quiet) {
+            writeWizardLine("No Salesprompter workspaces were returned for this account. Starting browser chooser.");
+            writeWizardLine();
+        }
+        return {
+            session: await switchWorkspaceWithBrowser(options),
+            method: "browser"
+        };
+    }
+    const selectedOrgId = options.orgId ?? (await withPromptReader(options.rl, async (rl) => await promptForCliWorkspace(rl, workspaces, currentOrgId, options.workspace)));
+    if (selectedOrgId === "browser") {
+        return {
+            session: await switchWorkspaceWithBrowser(options),
+            method: "browser"
+        };
+    }
+    const nextSession = await selectCliWorkspace(session, selectedOrgId);
+    return {
+        session: nextSession,
+        method: "terminal"
+    };
+}
 async function resolveLlmAuthReadiness() {
     const apiBaseUrl = process.env.SALESPROMPTER_API_BASE_URL?.trim() || "https://salesprompter.ai";
     const envToken = resolveNonInteractiveAuthToken(process.env);
@@ -2942,6 +3148,19 @@ function buildSalesNavigatorCrawlLogPath(input) {
     const slug = slugify(input) || "salesnav-crawl";
     return `./data/${slug}-crawl.log.jsonl`;
 }
+function buildSalesNavigatorCrawlOutputPath(input) {
+    const slug = slugify(input) || "salesnav-crawl";
+    return `./data/${slug}-crawl.json`;
+}
+function isSalesNavigatorPeopleSearchUrl(input) {
+    try {
+        const parsed = new URL(input);
+        return /(^|\.)linkedin\.com$/i.test(parsed.hostname) && parsed.pathname.replace(/\/+$/, "") === "/sales/search/people";
+    }
+    catch {
+        return false;
+    }
+}
 function decodeSalesNavigatorQueryParam(url) {
     try {
         const encoded = new URL(url).searchParams.get("query");
@@ -5035,11 +5254,192 @@ async function searchTargetCompanyLeads(reference, limit) {
         limit
     });
 }
+async function runDirectSalesNavigatorSearchWizard(input) {
+    const maxResultsPerSearch = 2500;
+    const numberOfProfiles = 2500;
+    const slicePreset = "wizard-salesnav-search";
+    const maxSplitDepth = DEFAULT_SALES_NAVIGATOR_CRAWL_DIMENSIONS.length;
+    const maxSlices = 1000;
+    const maxRetries = 3;
+    const probeProfiles = 100;
+    const agentBusyWaitSeconds = 30;
+    const agentBusyMaxWaits = 20;
+    const idlePollSeconds = 10;
+    const idleMaxPolls = 180;
+    const parallelExports = 3;
+    const outPath = buildSalesNavigatorCrawlOutputPath(input);
+    const dryRun = shouldBypassAuth();
+    const logger = await createWorkflowLogger({
+        logPath: buildSalesNavigatorCrawlLogPath(input)
+    });
+    writeWizardLine("Detected a Sales Navigator people search. I will process this search directly.");
+    if (dryRun) {
+        writeWizardLine("Auth bypass is enabled, so I will preview the crawl plan instead of launching it.");
+    }
+    writeWizardLine();
+    await logger.log("salesnav.crawl.command.started", {
+        queryUrl: input,
+        jobId: null,
+        maxResultsPerSearch,
+        numberOfProfiles,
+        slicePreset,
+        maxSplitDepth,
+        maxSlices,
+        maxRetries,
+        probeProfiles,
+        agentBusyWaitSeconds,
+        agentBusyMaxWaits,
+        idlePollSeconds,
+        idleMaxPolls,
+        parallelExports,
+        dryRun
+    });
+    if (dryRun) {
+        const preview = buildSalesNavigatorCrawlPreview({
+            sourceQueryUrl: input,
+            maxResultsPerSearch,
+            numberOfProfiles,
+            slicePreset
+        });
+        const payload = {
+            status: "ok",
+            dryRun: true,
+            mode: "adaptive",
+            traceId: logger.traceId,
+            logPath: logger.logPath,
+            sourceQueryUrl: input,
+            rootQueryUrl: preview.root.slicedQueryUrl,
+            rootAppliedFilters: preview.root.appliedFilters,
+            dimensionOrder: preview.dimensions.map((dimension) => ({
+                key: dimension.key,
+                filterType: dimension.filterType,
+                valueCount: dimension.values.length
+            })),
+            firstSplitQueries: preview.firstSplit.map((attempt) => ({
+                slicedQueryUrl: attempt.slicedQueryUrl,
+                appliedFilters: attempt.appliedFilters,
+                splitTrail: attempt.splitTrail.map((entry) => ({
+                    key: entry.key,
+                    filterType: entry.filterType,
+                    valueText: entry.value.text
+                }))
+            }))
+        };
+        await logger.log("salesnav.crawl.dry-run.preview", {
+            sourceQueryUrl: input,
+            root: summarizeSalesNavigatorQuery(payload.rootQueryUrl, payload.rootAppliedFilters),
+            dimensionOrder: payload.dimensionOrder,
+            firstSplitQueries: payload.firstSplitQueries.map((attempt) => ({
+                splitTrail: attempt.splitTrail,
+                ...summarizeSalesNavigatorQuery(attempt.slicedQueryUrl, attempt.appliedFilters)
+            }))
+        });
+        await writeJsonFile(outPath, payload);
+        writeWizardLine(`Saved Sales Navigator crawl preview to ${outPath}.`);
+        writeWizardLine(`Saved logs to ${logger.logPath}.`);
+        return;
+    }
+    let session = await requireAuthSession();
+    const sessionOrgId = resolveSessionOrgId(session);
+    if (sessionOrgId) {
+        logger.setEventStore(await createSalesNavigatorCrawlEventStore({ orgId: sessionOrgId }));
+    }
+    const seed = createSalesNavigatorCrawlSeed({
+        sourceQueryUrl: input,
+        maxResultsPerSearch,
+        numberOfProfiles,
+        slicePreset
+    });
+    const created = await createOrResumeSalesNavigatorCrawlJob(session, {
+        sourceQueryUrl: input,
+        slicePreset,
+        maxResultsPerSearch,
+        numberOfProfiles,
+        rawPayload: {
+            workflow: "wizard:salesnav-search",
+            traceId: logger.traceId,
+            command: {
+                sourceQueryUrl: input,
+                slicePreset,
+                maxResultsPerSearch,
+                numberOfProfiles,
+                maxSplitDepth,
+                maxSlices,
+                maxRetries,
+                probeProfiles,
+                agentBusyWaitSeconds,
+                agentBusyMaxWaits,
+                idlePollSeconds,
+                idleMaxPolls,
+                parallelExports
+            }
+        },
+        rootSlice: {
+            slicedQueryUrl: seed.slicedQueryUrl,
+            appliedFilters: seed.appliedFilters,
+            depth: seed.depth,
+            splitTrail: seed.splitTrail,
+            rawPayload: {
+                workflow: "wizard:salesnav-search",
+                traceId: logger.traceId
+            }
+        }
+    }, logger.traceId);
+    session = created.session;
+    const jobId = created.value.job.id;
+    writeWizardLine(`${created.value.resumed ? "Resumed" : "Started"} Sales Navigator crawl ${jobId}. Processing the search now...`);
+    const crawl = await executeSalesNavigatorCrawlJob(session, jobId, {
+        maxSplitDepth,
+        maxSlices,
+        maxRetries,
+        probeProfiles,
+        agentBusyWaitSeconds,
+        agentBusyMaxWaits,
+        idlePollSeconds,
+        idleMaxPolls,
+        parallelExports,
+        traceId: logger.traceId,
+        logger
+    });
+    const payload = {
+        status: "ok",
+        dryRun: false,
+        mode: "durable",
+        traceId: logger.traceId,
+        logPath: logger.logPath,
+        jobId,
+        resumed: created.value.resumed,
+        sourceQueryUrl: crawl.job.sourceQueryUrl,
+        slicePreset: crawl.job.slicePreset,
+        maxResultsPerSearch: crawl.job.maxResultsPerSearch,
+        numberOfProfiles: crawl.job.numberOfProfiles,
+        claimedSlices: crawl.claimedSlices,
+        truncated: crawl.truncated,
+        job: crawl.job,
+        lastOutcome: crawl.lastOutcome
+    };
+    await writeJsonFile(outPath, payload);
+    writeWizardLine(`Sales Navigator crawl status: ${crawl.job.status}.`);
+    writeWizardLine(`Imported ${crawl.job.importedPeople} people across ${crawl.job.exportedSlices} exported slice${crawl.job.exportedSlices === 1 ? "" : "s"}.`);
+    if (crawl.job.failedSlices > 0 || crawl.truncated) {
+        writeWizardLine(`Some work still needs attention: ${crawl.job.failedSlices} failed slice${crawl.job.failedSlices === 1 ? "" : "s"}, truncated=${crawl.truncated}.`);
+    }
+    writeWizardLine(`Saved crawl summary to ${outPath}.`);
+    writeWizardLine(`Saved logs to ${logger.logPath}.`);
+    writeWizardLine();
+    writeWizardLine("Equivalent raw command:");
+    writeWizardLine(`  ${buildCommandLine(["salesprompter", "salesnav:crawl", "--query-url", input])}`);
+}
 async function runProductMarketWizard(rl) {
     writeWizardSection("Find leads from a product market", "Start from a company website, LinkedIn company page, product page, or category page. I will turn that into intended job titles and durable Sales Navigator crawls.");
     const input = await promptText(rl, "What company website or LinkedIn page should I start from?", {
         required: true
     });
+    if (isSalesNavigatorPeopleSearchUrl(input)) {
+        writeWizardLine();
+        await runDirectSalesNavigatorSearchWizard(input);
+        return;
+    }
     const productLimit = z.coerce.number().int().min(1).max(5000).parse(await promptText(rl, "How many products should I inspect?", { defaultValue: "25", required: true }));
     const titleLimit = z.coerce.number().int().min(1).max(1000).parse(await promptText(rl, "How many job titles should I turn into Sales Navigator crawls?", {
         defaultValue: "5",
@@ -5237,7 +5637,7 @@ async function runWizard(options) {
         throw new Error("wizard does not support --json or --quiet.");
     }
     writeWizardLine("Salesprompter");
-    writeWizardLine("Start with a company website, LinkedIn product page, or category URL. I will guide you from there.");
+    writeWizardLine("Start with a company website, LinkedIn product page, category URL, or Sales Navigator search. I will guide you from there.");
     writeWizardLine();
     const rl = createInterface({
         input: process.stdin,
@@ -5248,46 +5648,64 @@ async function runWizard(options) {
         if (wizardSession.session && wizardSession.restoredFromCache) {
             await confirmWizardWorkspace(rl, wizardSession.session, options);
         }
-        const flow = await promptChoice(rl, "What do you want help with?", [
-            {
-                value: "product-market",
-                label: "Find leads from a product market",
-                description: "Start from a company, product, or LinkedIn category and crawl Sales Navigator",
-                aliases: ["product market", "linkedin products", "category", "sales navigator", "crawl"]
-            },
-            {
-                value: "reference-company",
-                label: "Use a built-in vendor shortcut",
-                description: "Generate the saved vendor ICP and search workspace leads",
-                aliases: ["vendor", "shortcut", "vendor template", "quick template"]
-            },
-            {
-                value: "target-company",
-                label: "Find people at a specific company",
-                description: "Example: find people at company.com",
-                aliases: ["target company", "company", "find people", "people at a company", "lead generation"]
-            },
-            {
-                value: "outreach-sync",
-                label: "Push qualified leads to Instantly",
-                description: "Use a saved leads file to fill an Instantly campaign",
-                aliases: ["instantly", "outreach", "send leads", "campaign"]
+        for (;;) {
+            const flow = await promptChoice(rl, "What do you want help with?", [
+                {
+                    value: "product-market",
+                    label: "Find leads from a product market",
+                    description: "Start from a company, product, or LinkedIn category and crawl Sales Navigator",
+                    aliases: ["product market", "linkedin products", "category", "sales navigator", "crawl"]
+                },
+                {
+                    value: "reference-company",
+                    label: "Use a built-in vendor shortcut",
+                    description: "Generate the saved vendor ICP and search workspace leads",
+                    aliases: ["vendor", "shortcut", "vendor template", "quick template"]
+                },
+                {
+                    value: "target-company",
+                    label: "Find people at a specific company",
+                    description: "Example: find people at company.com",
+                    aliases: ["target company", "company", "find people", "people at a company", "lead generation"]
+                },
+                {
+                    value: "switch-workspace",
+                    label: "Switch workspace",
+                    description: "Choose Gojiberry, SelectLine, or another Salesprompter workspace",
+                    aliases: ["switch workspace", "change workspace", "gojiberry", "organization", "org"]
+                },
+                {
+                    value: "outreach-sync",
+                    label: "Push qualified leads to Instantly",
+                    description: "Use a saved leads file to fill an Instantly campaign",
+                    aliases: ["instantly", "outreach", "send leads", "campaign"]
+                }
+            ], "product-market");
+            writeWizardLine();
+            if (flow === "switch-workspace") {
+                const result = await switchWorkspaceInCli({
+                    ...options,
+                    rl
+                });
+                writeSessionSummary(result.session);
+                writeWizardLine();
+                continue;
             }
-        ], "product-market");
-        writeWizardLine();
-        if (flow === "product-market") {
-            await runProductMarketWizard(rl);
-            return;
-        }
-        if (flow === "reference-company") {
-            await runVendorShortcutWizard(rl);
-            return;
-        }
-        if (flow === "target-company") {
-            await runTargetCompanyWizard(rl);
+            if (flow === "product-market") {
+                await runProductMarketWizard(rl);
+                return;
+            }
+            if (flow === "reference-company") {
+                await runVendorShortcutWizard(rl);
+                return;
+            }
+            if (flow === "target-company") {
+                await runTargetCompanyWizard(rl);
+                return;
+            }
+            await runOutreachSyncWizard(rl);
             return;
         }
-        await runOutreachSyncWizard(rl);
     }
     finally {
         rl.close();
@@ -5605,6 +6023,32 @@ program
         expiresAt: result.session.expiresAt ?? null
     });
 });
+program
+    .command("auth:workspace")
+    .alias("auth:switch")
+    .description("Switch the active Salesprompter workspace for this CLI session.")
+    .option("--api-url <url>", "Salesprompter API base URL, defaults to SALESPROMPTER_API_BASE_URL or salesprompter.ai")
+    .option("--timeout-seconds <number>", "Browser fallback login timeout in seconds", "180")
+    .option("--org-id <id>", "Switch directly to a Clerk organization id")
+    .option("--workspace <nameOrSlug>", "Switch directly to a workspace by name, slug, client id, or org id")
+    .option("--browser", "Use the browser chooser instead of terminal workspace selection")
+    .action(async (options) => {
+    const timeoutSeconds = z.coerce.number().int().min(30).max(1800).parse(options.timeoutSeconds);
+    const result = await switchWorkspaceInCli({
+        apiUrl: options.apiUrl,
+        timeoutSeconds,
+        orgId: options.orgId,
+        workspace: options.workspace,
+        browser: Boolean(options.browser)
+    });
+    printOutput({
+        status: "ok",
+        method: result.method,
+        apiBaseUrl: result.session.apiBaseUrl,
+        user: result.session.user,
+        expiresAt: result.session.expiresAt ?? null
+    });
+});
 program
     .command("wizard")
     .alias("start")

package/package.json

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