salesprompter-cli 0.1.63 → 0.1.65

package/README.md

@@ -96,10 +96,17 @@ salesprompter affiliate:launch \
 salesprompter affiliate:run \
   --affiliate-link "https://example.com/?ref=you" \
   --linkedin-url "https://www.linkedin.com/sales/search/people?query=..." \
-  --max-results 100
+  --max-results 100 \
+  --steps 3 \
+  --timing-mode custom \
+  --daily-limit 25 \
+  --send-from 09:00 \
+  --send-to 16:00
 
 # Review the persisted sequence and enrichment summary, then activate explicitly
+salesprompter affiliate:list
 salesprompter affiliate:status "$AFFILIATE_RUN_ID"
+salesprompter affiliate:analytics "$AFFILIATE_RUN_ID"
 salesprompter affiliate:regenerate-sequence "$AFFILIATE_RUN_ID"
 salesprompter affiliate:enrich "$AFFILIATE_RUN_ID"
 salesprompter affiliate:enrich "$AFFILIATE_RUN_ID" \
@@ -134,7 +141,9 @@ the app's CLI imports view.
 - Use your own authorized data access and workspace credentials.
 - Respect provider terms and customer data boundaries.
 - `affiliate:run` uses direct email enrichment first, then Phantombuster Email Finder for unresolved people before creating a draft Instantly campaign.
-- Affiliate preparation automatically creates three variants per step with spintax; `affiliate:regenerate-sequence` rebuilds and syncs them through the Salesprompter app.
+- Affiliate preparation uses exactly three emails with three observable variants per step; `affiliate:regenerate-sequence` rebuilds and syncs them through the Salesprompter app.
+- `affiliate:list` shows safe workspace summaries. `affiliate:analytics` shows aggregate and step/variant outcomes without exposing lead data; unsupported per-step meeting and won fields render as `n/a`.
+- `affiliate:run` defaults to `--timing-mode custom`, so its daily limit and weekday sending window are honored. Use `--timing-mode auto` only when capacity-derived scheduling is intended.
 - `affiliate:enrich` starts durable email recovery and adds only newly found addresses to an existing campaign. It returns a background-processing status for large audiences instead of blocking the terminal. Pass `--source-audience-run-id` to merge a newer compatible audience into that campaign without creating a duplicate campaign.
 - A draft campaign does not send until `affiliate:activate` is run.
 - The CLI is designed for interactive users and agent-assisted workflows.

package/dist/cli.js

@@ -166,7 +166,27 @@ const AffiliateCampaignLocalResultSchema = z
 })
     .passthrough();
 const DatabaseTimestampSchema = z.string().min(1);
-const AffiliateOutreachRunSchema = z.object({
+const AffiliateSequenceVariantSchema = z.object({
+    subject: z.string(),
+    body: z.string()
+});
+const AffiliateHistoricalSequenceStepSchema = z.object({
+    step: z.number().int().positive(),
+    subject: z.string(),
+    body: z.string(),
+    rationale: z.string(),
+    delayDays: z.number().int().nonnegative(),
+    variants: z.array(AffiliateSequenceVariantSchema).min(1).max(3).optional()
+});
+const AffiliateStrictSequenceStepSchema = AffiliateHistoricalSequenceStepSchema.extend({
+    variants: z.array(AffiliateSequenceVariantSchema).length(3)
+});
+const AffiliateStrictSequenceSchema = z.tuple([
+    AffiliateStrictSequenceStepSchema.extend({ step: z.literal(1) }),
+    AffiliateStrictSequenceStepSchema.extend({ step: z.literal(2) }),
+    AffiliateStrictSequenceStepSchema.extend({ step: z.literal(3) })
+]);
+const AffiliateOutreachRunBaseSchema = z.object({
     id: z.string().uuid(),
     audience_run_id: z.string().uuid(),
     organization_id: z.string().min(1),
@@ -174,36 +194,7 @@ const AffiliateOutreachRunSchema = z.object({
     provider: z.literal("instantly"),
     instantly_campaign_id: z.string().min(1).nullable(),
     instantly_campaign_name: z.string().min(1).nullable(),
-    sequence: z.array(z.object({
-        step: z.number().int().positive(),
-        subject: z.string(),
-        body: z.string(),
-        rationale: z.string(),
-        delayDays: z.number().int().nonnegative(),
-        variants: z
-            .array(z.object({
-            subject: z.string(),
-            body: z.string()
-        }))
-            .min(1)
-            .max(3)
-            .optional()
-    })),
-    enriched_leads: z.array(z.object({
-        rowIndex: z.number().int().nonnegative(),
-        fullName: z.string().min(1),
-        firstName: z.string().min(1),
-        lastName: z.string().min(1),
-        jobTitle: z.string().nullable(),
-        companyName: z.string().min(1),
-        companyDomain: z.string().min(1),
-        location: z.string().nullable(),
-        profileUrl: z.string().nullable(),
-        email: z.string().email(),
-        emailScore: z.number().min(0).max(100),
-        acceptAll: z.boolean(),
-        emailSource: z.enum(["hunter", "phantombuster"]).optional()
-    })),
+    sequence: z.array(AffiliateHistoricalSequenceStepSchema),
     stats: z.record(z.string(), z.unknown()),
     settings: z.record(z.string(), z.unknown()),
     error_message: z.string().nullable(),
@@ -211,10 +202,83 @@ const AffiliateOutreachRunSchema = z.object({
     created_at: DatabaseTimestampSchema,
     updated_at: DatabaseTimestampSchema
 });
+const AffiliateOutreachRunSchema = z.discriminatedUnion("status", [
+    AffiliateOutreachRunBaseSchema.extend({ status: z.literal("preparing") }),
+    AffiliateOutreachRunBaseSchema.extend({ status: z.literal("failed") }),
+    AffiliateOutreachRunBaseSchema.extend({
+        status: z.literal("ready"),
+        sequence: AffiliateStrictSequenceSchema
+    }),
+    AffiliateOutreachRunBaseSchema.extend({
+        status: z.literal("active"),
+        sequence: AffiliateStrictSequenceSchema
+    })
+]);
 const AffiliateOutreachResponseSchema = z.object({
     status: z.literal("ok"),
     outreach: AffiliateOutreachRunSchema
 });
+const AffiliateOutreachSummarySchema = AffiliateOutreachRunBaseSchema;
+const AffiliateAudienceSummarySchema = z.object({
+    public_token: z.string().min(1),
+    status: z.enum(["launching", "running", "finished", "failed"]),
+    affiliate_link: z.string().url(),
+    product_domain: z.string().min(1),
+    source_type: z.string().min(1),
+    linkedin_url: z.string().url(),
+    max_results: z.number().int().positive(),
+    error_message: z.string().nullable(),
+    organization_id: z.string().nullable(),
+    created_at: DatabaseTimestampSchema,
+    updated_at: DatabaseTimestampSchema
+});
+const AffiliateOutreachListResponseSchema = z.object({
+    status: z.literal("ok"),
+    audiences: z.array(AffiliateAudienceSummarySchema),
+    outreach: z.array(AffiliateOutreachSummarySchema)
+});
+const AffiliateAnalyticsAggregateSchema = z.object({
+    leadsCount: z.number().int().nonnegative(),
+    contactedCount: z.number().int().nonnegative(),
+    emailsSentCount: z.number().int().nonnegative(),
+    replyCount: z.number().int().nonnegative(),
+    automaticReplyCount: z.number().int().nonnegative(),
+    humanReplyCount: z.number().int().nonnegative(),
+    humanReplyRate: z.number().nonnegative(),
+    bouncedCount: z.number().int().nonnegative(),
+    unsubscribedCount: z.number().int().nonnegative(),
+    opportunityCount: z.number().int().nonnegative(),
+    meetingCount: z.number().int().nonnegative(),
+    meetingCompletedCount: z.number().int().nonnegative(),
+    wonCount: z.number().int().nonnegative()
+});
+const AffiliateAnalyticsStepSchema = z.object({
+    step: z.number().int().positive(),
+    variant: z.number().int().nonnegative(),
+    variantLabel: z.string().trim().min(1).max(20),
+    sentCount: z.number().int().nonnegative(),
+    replyCount: z.number().int().nonnegative(),
+    automaticReplyCount: z.number().int().nonnegative(),
+    humanReplyCount: z.number().int().nonnegative(),
+    humanReplyRate: z.number().nonnegative(),
+    opportunityCount: z.number().int().nonnegative(),
+    meetingCount: z.number().int().nonnegative().nullable(),
+    wonCount: z.number().int().nonnegative().nullable(),
+    learning: z.object({
+        ready: z.boolean(),
+        reason: z.string().min(1)
+    })
+});
+const AffiliateOutreachAnalyticsResponseSchema = z.object({
+    status: z.literal("ok"),
+    runId: z.string().uuid(),
+    runStatus: z.string().min(1),
+    campaignId: z.string().min(1),
+    campaignName: z.string().min(1).nullable(),
+    campaignStatus: z.number().nullable(),
+    aggregate: AffiliateAnalyticsAggregateSchema,
+    steps: z.array(AffiliateAnalyticsStepSchema)
+});
 const AffiliateOutreachEnrichStartResponseSchema = z.object({
     status: z.literal("accepted"),
     audienceRunId: z.string().uuid(),
@@ -547,7 +611,10 @@ const cliPacks = [
         summary: "Prepare and sync qualified leads into downstream systems.",
         commands: [
             "affiliate:run",
+            "affiliate:list",
             "affiliate:status",
+            "affiliate:analytics",
+            "affiliate:regenerate-sequence",
             "affiliate:enrich",
             "affiliate:activate",
             "affiliate:launch",
@@ -602,7 +669,10 @@ const helpVisibleCommandNames = new Set([
     "leads:score",
     "leads:pipeline",
     "affiliate:run",
+    "affiliate:list",
     "affiliate:status",
+    "affiliate:analytics",
+    "affiliate:regenerate-sequence",
     "affiliate:enrich",
     "affiliate:activate",
     "affiliate:launch",
@@ -6621,6 +6691,14 @@ async function prepareAffiliateOutreachViaApp(session, payload) {
     }), AffiliateOutreachResponseSchema);
     return value.outreach;
 }
+async function listAffiliateOutreachViaApp(session) {
+    const { value } = await fetchCliJson(session, (currentSession) => fetch(`${currentSession.apiBaseUrl}/api/cli/affiliate-outreach`, {
+        headers: {
+            Authorization: `Bearer ${currentSession.accessToken}`
+        }
+    }), AffiliateOutreachListResponseSchema);
+    return value;
+}
 async function getAffiliateOutreachViaApp(session, audienceRunId) {
     const { value } = await fetchCliJson(session, (currentSession) => fetch(`${currentSession.apiBaseUrl}/api/cli/affiliate-outreach/${encodeURIComponent(audienceRunId)}`, {
         headers: {
@@ -6629,6 +6707,14 @@ async function getAffiliateOutreachViaApp(session, audienceRunId) {
     }), AffiliateOutreachResponseSchema);
     return value.outreach;
 }
+async function getAffiliateOutreachAnalyticsViaApp(session, audienceRunId) {
+    const { value } = await fetchCliJson(session, (currentSession) => fetch(`${currentSession.apiBaseUrl}/api/cli/affiliate-outreach/${encodeURIComponent(audienceRunId)}/analytics`, {
+        headers: {
+            Authorization: `Bearer ${currentSession.accessToken}`
+        }
+    }), AffiliateOutreachAnalyticsResponseSchema);
+    return value;
+}
 async function activateAffiliateOutreachViaApp(session, audienceRunId) {
     const { value } = await fetchCliJson(session, (currentSession) => fetch(`${currentSession.apiBaseUrl}/api/cli/affiliate-outreach/${encodeURIComponent(audienceRunId)}/activate`, {
         method: "POST",
@@ -13661,6 +13747,44 @@ program
         }
     });
 });
+function parseAffiliateOutreachCommandOptions(options) {
+    const parsedSteps = z.coerce.number().int().safeParse(options.steps);
+    if (!parsedSteps.success || parsedSteps.data !== 3) {
+        throw new Error("Affiliate outreach currently requires exactly 3 sequence emails. Use --steps 3.");
+    }
+    const parsedTimingMode = z.enum(["auto", "custom"]).safeParse(options.timingMode);
+    if (!parsedTimingMode.success) {
+        throw new Error("--timing-mode must be either auto or custom.");
+    }
+    const trimmedCampaignName = options.campaignName?.trim();
+    const campaignName = trimmedCampaignName
+        ? z.string().max(120, "--campaign-name must be 120 characters or fewer.").parse(trimmedCampaignName)
+        : undefined;
+    return {
+        campaignName,
+        language: z.string().trim().min(1).max(40).parse(options.language),
+        numberOfSteps: 3,
+        minEmailScore: z.coerce.number().int().min(0).max(100).parse(options.minEmailScore),
+        allowAcceptAll: Boolean(options.allowAcceptAll),
+        timingMode: parsedTimingMode.data,
+        dailyLimit: z.coerce.number().int().min(1).max(1000).parse(options.dailyLimit),
+        timezone: z.string().trim().min(1).max(100).parse(options.timezone),
+        sendFrom: z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/).parse(options.sendFrom),
+        sendTo: z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/).parse(options.sendTo)
+    };
+}
+function formatAffiliateAnalyticsForOutput(analytics) {
+    if (runtimeOutputOptions.json)
+        return analytics;
+    return {
+        ...analytics,
+        steps: analytics.steps.map((step) => ({
+            ...step,
+            meetingCount: step.meetingCount ?? "n/a",
+            wonCount: step.wonCount ?? "n/a"
+        }))
+    };
+}
 function getLocalSalesNavigatorPeopleCheckpointPath(sourceQueryUrl, maxResultsPerSearch, pageSize) {
     const key = createHash("sha256")
         .update(`${sourceQueryUrl}\n${maxResultsPerSearch}\n${pageSize}`)
@@ -14741,15 +14865,17 @@ addAffiliateAudienceOptions(program
     .description("Build an affiliate audience and prepare a reviewed Instantly campaign end to end."))
     .option("--campaign-name <name>", "Optional Instantly campaign name")
     .option("--language <language>", "Sequence language", "English")
-    .option("--steps <number>", "Number of sequence emails", "3")
+    .option("--steps <number>", "Exactly 3 sequence emails (fixed)", "3")
     .option("--min-email-score <number>", "Minimum Hunter confidence score", "80")
     .option("--allow-accept-all", "Include catch-all domains that meet the score threshold", false)
+    .option("--timing-mode <mode>", "Schedule mode: custom honors the daily limit and sending window; auto derives them from capacity", "custom")
     .option("--daily-limit <number>", "Maximum new leads contacted per day", "25")
     .option("--timezone <timezone>", "Instantly sending timezone", "America/Detroit")
     .option("--send-from <time>", "Weekday sending window start (HH:MM)", "09:00")
     .option("--send-to <time>", "Weekday sending window end (HH:MM)", "16:00")
     .option("--activate", "Activate the prepared Instantly campaign after review data is returned", false)
     .action(async (options) => {
+    const outreachOptions = parseAffiliateOutreachCommandOptions(options);
     const launched = await runAffiliateLaunchCommand(options);
     if (options.dryRun) {
         printOutput({
@@ -14757,7 +14883,8 @@ addAffiliateAudienceOptions(program
             outreach: {
                 status: "dry-run",
                 provider: "instantly",
-                activation: "not_requested"
+                activation: "not_requested",
+                settings: outreachOptions
             }
         });
         return;
@@ -14771,15 +14898,7 @@ addAffiliateAudienceOptions(program
     }
     const outreach = await prepareAffiliateOutreachViaApp(launched.session, {
         audienceRunId: z.string().uuid().parse(runId),
-        campaignName: options.campaignName?.trim() || undefined,
-        language: z.string().trim().min(1).max(40).parse(options.language),
-        numberOfSteps: z.coerce.number().int().min(1).max(6).parse(options.steps),
-        minEmailScore: z.coerce.number().int().min(0).max(100).parse(options.minEmailScore),
-        allowAcceptAll: Boolean(options.allowAcceptAll),
-        dailyLimit: z.coerce.number().int().min(1).max(1000).parse(options.dailyLimit),
-        timezone: z.string().trim().min(1).max(100).parse(options.timezone),
-        sendFrom: z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/).parse(options.sendFrom),
-        sendTo: z.string().regex(/^([01]\d|2[0-3]):[0-5]\d$/).parse(options.sendTo)
+        ...outreachOptions
     });
     const finalOutreach = options.activate
         ? await activateAffiliateOutreachViaApp(launched.session, runId)
@@ -14793,6 +14912,13 @@ addAffiliateAudienceOptions(program
             : "The Instantly campaign is active."
     });
 });
+program
+    .command("affiliate:list")
+    .description("List affiliate audiences and Instantly outreach runs in the active workspace.")
+    .action(async () => {
+    const session = await requireAuthSession();
+    printOutput(await listAffiliateOutreachViaApp(session));
+});
 program
     .command("affiliate:status <run-id>")
     .description("Show enrichment, sequence, Instantly, and activation status for an affiliate run.")
@@ -14801,16 +14927,24 @@ program
     const outreach = await getAffiliateOutreachViaApp(session, z.string().uuid().parse(runId));
     printOutput({ status: "ok", outreach });
 });
+program
+    .command("affiliate:analytics <run-id>")
+    .description("Show safe campaign and step/variant performance metrics for an affiliate run.")
+    .action(async (runId) => {
+    const session = await requireAuthSession();
+    const analytics = await getAffiliateOutreachAnalyticsViaApp(session, z.string().uuid().parse(runId));
+    printOutput(formatAffiliateAnalyticsForOutput(analytics));
+});
 program
     .command("affiliate:regenerate-sequence <run-id>")
-    .description("Regenerate sequence variants and spintax, then sync them to Instantly.")
+    .description("Regenerate observable sequence variants, then sync them to Instantly.")
     .action(async (runId) => {
     const session = await requireAuthSession();
     const outreach = await regenerateAffiliateOutreachSequenceViaApp(session, z.string().uuid().parse(runId));
     printOutput({
         status: "ok",
         outreach,
-        message: "Sequence variants and spintax were regenerated and synced to Instantly."
+        message: "Observable sequence variants were regenerated and synced to Instantly."
     });
 });
 program

package/package.json

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