salesprompter-cli 0.1.69 → 0.1.71

package/README.md

@@ -109,9 +109,10 @@ salesprompter affiliate:grow \
   --send-from 09:00 \
   --send-to 16:00
 
-# Review the persisted sequence and enrichment summary, then activate explicitly
+# Verify live campaign state, lead safety, and contact activity, then activate explicitly
 salesprompter affiliate:list
 salesprompter affiliate:status "$AFFILIATE_RUN_ID"
+salesprompter affiliate:finish "$AFFILIATE_RUN_ID"
 salesprompter affiliate:analytics "$AFFILIATE_RUN_ID"
 salesprompter affiliate:regenerate-sequence "$AFFILIATE_RUN_ID"
 salesprompter affiliate:enrich "$AFFILIATE_RUN_ID"
@@ -179,6 +180,7 @@ the app's CLI imports view.
 - `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.
+- `affiliate:finish` closes the loop: it repairs stalled verification in 1,000-lead batches, quarantines stale pending or invalid leads outside the sending campaign, accepts an explicitly audited recovery fallback, activates only a fully verified campaign, and reads the live state back. Use `--requeue-pending` only after restoring Instantly verification capacity.
 - A draft campaign does not send until `affiliate:activate` is run.
 - The CLI is designed for interactive users and agent-assisted workflows.
 - A repo-local Chrome extension compatibility copy is available in `chrome-extension/` for local LinkedIn session sync and popup copy/debug flows.

package/dist/cli.js

@@ -247,6 +247,72 @@ const AffiliateOutreachResponseSchema = z.object({
     status: z.literal("ok"),
     outreach: AffiliateOutreachRunSchema
 });
+const AffiliateOutreachHealthSchema = z.object({
+    checkedAt: DatabaseTimestampSchema,
+    liveChecked: z.boolean(),
+    done: z.boolean(),
+    verdict: z.enum([
+        "preparing",
+        "failed",
+        "unavailable",
+        "not_running",
+        "ready_to_activate",
+        "running",
+        "unsafe_running"
+    ]),
+    running: z.boolean(),
+    activationReady: z.boolean(),
+    safeToSend: z.boolean(),
+    dataPreparationComplete: z.boolean(),
+    campaign: z
+        .object({
+        id: z.string().min(1),
+        name: z.string().min(1).nullable(),
+        status: z.number().int().nullable(),
+        statusLabel: z.string().min(1),
+        dailyLimit: z.number().nonnegative().nullable(),
+        sendingAccountCount: z.number().int().nonnegative()
+    })
+        .nullable(),
+    leads: z
+        .object({
+        total: z.number().int().nonnegative(),
+        active: z.number().int().nonnegative(),
+        inactive: z.number().int().nonnegative(),
+        verified: z.number().int().nonnegative(),
+        pendingVerification: z.number().int().nonnegative(),
+        invalid: z.number().int().nonnegative(),
+        unsafe: z.number().int().nonnegative(),
+        contacted: z.number().int().nonnegative(),
+        replied: z.number().int().nonnegative(),
+        statusCounts: z.record(z.string(), z.number().int().nonnegative()),
+        verificationStatusCounts: z.record(z.string(), z.number().int().nonnegative())
+    })
+        .nullable(),
+    blockers: z.array(z.object({
+        code: z.string().min(1),
+        message: z.string().min(1),
+        count: z.number().int().nonnegative().optional()
+    }))
+});
+const AffiliateOutreachLiveStatusResponseSchema = AffiliateOutreachResponseSchema.extend({
+    health: AffiliateOutreachHealthSchema
+});
+const AffiliateVerificationRepairResponseSchema = AffiliateOutreachResponseSchema.extend({
+    repair: z.object({
+        checkedAt: DatabaseTimestampSchema,
+        beforeCount: z.number().int().nonnegative(),
+        afterCount: z.number().int().nonnegative(),
+        restoredMissing: z.number().int().nonnegative(),
+        requeuedPending: z.number().int().nonnegative(),
+        quarantinedPending: z.number().int().nonnegative(),
+        prunedInvalid: z.number().int().nonnegative(),
+        pendingAfter: z.number().int().nonnegative(),
+        invalidAfter: z.number().int().nonnegative(),
+        verifiedAfter: z.number().int().nonnegative(),
+        dataPreparationAccepted: z.boolean()
+    })
+});
 const AffiliateOutreachSummarySchema = AffiliateOutreachRunBaseSchema;
 const AffiliateAudienceSummarySchema = z.object({
     public_token: z.string().min(1),
@@ -659,6 +725,7 @@ const cliPacks = [
             "affiliate:run",
             "affiliate:list",
             "affiliate:status",
+            "affiliate:finish",
             "affiliate:analytics",
             "affiliate:regenerate-sequence",
             "affiliate:enrich",
@@ -719,6 +786,7 @@ const helpVisibleCommandNames = new Set([
     "affiliate:run",
     "affiliate:list",
     "affiliate:status",
+    "affiliate:finish",
     "affiliate:analytics",
     "affiliate:regenerate-sequence",
     "affiliate:enrich",
@@ -6765,6 +6833,91 @@ async function getAffiliateOutreachViaApp(session, audienceRunId) {
     }), AffiliateOutreachResponseSchema);
     return value.outreach;
 }
+async function getAffiliateOutreachLiveStatusViaApp(session, audienceRunId) {
+    const { value } = await fetchCliJson(session, (currentSession) => {
+        const url = new URL(`/api/cli/affiliate-outreach/${encodeURIComponent(audienceRunId)}`, currentSession.apiBaseUrl);
+        url.searchParams.set("live", "1");
+        return fetch(url, {
+            headers: {
+                Authorization: `Bearer ${currentSession.accessToken}`
+            }
+        });
+    }, AffiliateOutreachLiveStatusResponseSchema);
+    return value;
+}
+async function repairAffiliateOutreachVerificationViaApp(session, audienceRunId, options) {
+    const { value } = await fetchCliJson(session, (currentSession) => fetch(`${currentSession.apiBaseUrl}/api/cli/affiliate-outreach/${encodeURIComponent(audienceRunId)}/repair-verification`, {
+        method: "POST",
+        headers: {
+            "Content-Type": "application/json",
+            Authorization: `Bearer ${currentSession.accessToken}`
+        },
+        body: JSON.stringify({
+            ...options,
+            pruneInvalid: true
+        })
+    }), AffiliateVerificationRepairResponseSchema);
+    return value;
+}
+async function finishAffiliateOutreachViaApp(session, audienceRunId, options) {
+    let live = await getAffiliateOutreachLiveStatusViaApp(session, audienceRunId);
+    const repairs = [];
+    for (let batch = 0; batch < options.maxRepairBatches; batch += 1) {
+        if (live.outreach.status === "active" || live.health.activationReady) {
+            break;
+        }
+        if (live.outreach.status !== "ready" || !live.health.liveChecked || !live.health.leads) {
+            throw new Error(describeAffiliateOutreachHealth(live.health));
+        }
+        const beforeUnsafe = live.health.leads.unsafe;
+        const needsRepair = beforeUnsafe > 0 || !live.health.dataPreparationComplete;
+        if (!needsRepair) {
+            break;
+        }
+        const repaired = await repairAffiliateOutreachVerificationViaApp(session, audienceRunId, {
+            staleAfterMinutes: options.staleAfterMinutes,
+            maxPendingRequeues: 1_000,
+            quarantinePending: !options.requeuePending,
+            acceptIncompleteRecovery: true
+        });
+        repairs.push(repaired.repair);
+        live = await getAffiliateOutreachLiveStatusViaApp(session, audienceRunId);
+        const afterUnsafe = live.health.leads?.unsafe ?? beforeUnsafe;
+        if (!live.health.activationReady &&
+            afterUnsafe >= beforeUnsafe &&
+            live.health.dataPreparationComplete) {
+            throw new Error(`${describeAffiliateOutreachHealth(live.health)} Pending leads may not be old enough for safe automatic repair yet.`);
+        }
+    }
+    if (live.outreach.status !== "active") {
+        if (!live.health.activationReady) {
+            throw new Error(`${describeAffiliateOutreachHealth(live.health)} The safe activation gate remains closed.`);
+        }
+        await activateAffiliateOutreachViaApp(session, audienceRunId);
+        live = await getAffiliateOutreachLiveStatusViaApp(session, audienceRunId);
+    }
+    if (!live.health.running || !live.health.safeToSend) {
+        throw new Error(`Activation could not be verified safely. ${describeAffiliateOutreachHealth(live.health)}`);
+    }
+    return { live, repairs };
+}
+function describeAffiliateOutreachHealth(health) {
+    const leads = health.leads;
+    if (health.done && leads) {
+        return `Done: the campaign is running with ${leads.verified}/${leads.total} verified leads.`;
+    }
+    if (health.verdict === "unsafe_running" && leads) {
+        return `Attention: the campaign is running with ${leads.unsafe} unsafe leads.`;
+    }
+    if (health.verdict === "ready_to_activate" && leads) {
+        return `Ready to activate: ${leads.verified}/${leads.total} leads are verified.`;
+    }
+    if (health.liveChecked && leads) {
+        const campaignState = health.campaign?.statusLabel ?? "unknown";
+        return `Not done: the campaign is ${campaignState}; ${leads.verified}/${leads.total} leads are verified; ${leads.contacted} contacted.`;
+    }
+    return health.blockers[0]?.message ?? "Live campaign status could not be verified.";
+}
 async function getAffiliateOutreachAnalyticsViaApp(session, audienceRunId) {
     const { value } = await fetchCliJson(session, (currentSession) => fetch(`${currentSession.apiBaseUrl}/api/cli/affiliate-outreach/${encodeURIComponent(audienceRunId)}/analytics`, {
         headers: {
@@ -15108,11 +15261,46 @@ program
 });
 program
     .command("affiliate:status <run-id>")
-    .description("Show enrichment, sequence, Instantly, and activation status for an affiliate run.")
+    .description("Verify whether an affiliate campaign is prepared, safe, and actually running.")
     .action(async (runId) => {
     const session = await requireAuthSession();
-    const outreach = await getAffiliateOutreachViaApp(session, z.string().uuid().parse(runId));
-    printOutput({ status: "ok", outreach });
+    const result = await getAffiliateOutreachLiveStatusViaApp(session, z.string().uuid().parse(runId));
+    printOutput({
+        status: "ok",
+        done: result.health.done,
+        verdict: result.health.verdict,
+        message: describeAffiliateOutreachHealth(result.health),
+        health: result.health,
+        outreach: result.outreach
+    });
+});
+program
+    .command("affiliate:finish <run-id>")
+    .description("Repair stalled verification, activate safely, and verify the live campaign.")
+    .option("--stale-after-minutes <number>", "Age before a pending verification can be repaired or quarantined", "15")
+    .option("--max-repair-batches <number>", "Maximum 1,000-lead repair batches", "125")
+    .option("--requeue-pending", "Retry stalled verification instead of quarantining it outside the sending campaign", false)
+    .action(async (runId, options) => {
+    const session = await requireAuthSession();
+    const audienceRunId = z.string().uuid().parse(runId);
+    const result = await finishAffiliateOutreachViaApp(session, audienceRunId, {
+        staleAfterMinutes: z.coerce.number().int().min(15).max(30 * 24 * 60).parse(options.staleAfterMinutes),
+        maxRepairBatches: z.coerce.number().int().min(1).max(250).parse(options.maxRepairBatches),
+        requeuePending: Boolean(options.requeuePending)
+    });
+    const leads = result.live.health.leads;
+    printOutput({
+        status: "ok",
+        running: result.live.health.running,
+        safeToSend: result.live.health.safeToSend,
+        done: result.live.health.done,
+        repairs: result.repairs,
+        health: result.live.health,
+        outreach: result.live.outreach,
+        message: result.live.health.done
+            ? describeAffiliateOutreachHealth(result.live.health)
+            : `The campaign is active and safe with ${leads?.verified ?? 0}/${leads?.total ?? 0} verified leads; sending will begin in its configured schedule.`
+    });
 });
 program
     .command("affiliate:analytics <run-id>")

package/package.json

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