@series-a/cli 0.6.2 → 0.13.1

package/src/commands/resources.mjs

@@ -1,6 +1,6 @@
 import { readFile } from "node:fs/promises";
 import { call } from "../api.mjs";
-import { emit, fail, ctxFrom, withCommonOpts, table, truncate } from "../ui.mjs";
+import { emit, fail, ctxFrom, withCommonOpts, table, truncate, confirmDestructive } from "../ui.mjs";
 
 function parseCsv(text) {
   // Tiny CSV parser: header row + comma-separated values, quoted fields supported.
@@ -174,8 +174,10 @@ export function registerLeads(program) {
 
   withCommonOpts(leads.command("delete <id>"))
     .description("Delete a lead")
+    .option("-y, --yes", "skip the confirmation prompt")
     .action(async function (id) {
       try {
+        await confirmDestructive(this, `Delete lead ${id}. This cannot be undone.`);
         const r = await call("leads", "delete", { id }, ctxFrom(this));
         emit(this, r, () => process.stdout.write(`✓ Deleted ${id}\n`));
       } catch (e) { fail(e); }
@@ -291,11 +293,56 @@ export function registerCampaigns(program) {
       } catch (e) { fail(e); }
     });
 
-  withCommonOpts(c.command("launch <id>"))
-    .description("Activate a campaign (status → active)")
+  withCommonOpts(c.command("remove-leads <campaignId>"))
+    .description("Un-enrol leads from a campaign")
+    .option("--lead-ids <ids>", "comma-separated lead ids")
+    .option("--all", "remove every enrolled lead")
+    .option("-y, --yes", "skip the confirmation prompt")
+    .option("--dry-run", "show what would be removed")
+    .action(async function (campaignId, opts) {
+      try {
+        const ids = opts.leadIds ? opts.leadIds.split(",").map((s) => s.trim()).filter(Boolean) : [];
+        if (!ids.length && !opts.all) return fail(new Error("--lead-ids or --all required"));
+        const params = { campaign_id: campaignId, lead_ids: ids, all: !!opts.all };
+        if (opts.dryRun) {
+          const d = await call("campaigns", "remove_leads", { ...params, dry_run: true }, ctxFrom(this));
+          return emit(this, d, (x) => process.stdout.write(`Would remove ${x.would_remove} lead(s) from ${campaignId}\n`));
+        }
+        await confirmDestructive(this, `Remove ${opts.all ? "ALL enrolled leads" : `${ids.length} lead(s)`} from campaign ${campaignId}.`);
+        const r = await call("campaigns", "remove_leads", params, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Removed ${d.removed} lead(s)\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(c.command("preflight <id>"))
+    .description("Check whether a campaign is safe to launch (read-only)")
     .action(async function (id) {
       try {
-        const r = await call("campaigns", "launch", { campaign_id: id }, ctxFrom(this));
+        const r = await call("campaigns", "preflight", { campaign_id: id }, ctxFrom(this));
+        emit(this, r, renderPreflight);
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(c.command("launch <id>"))
+    .description("Activate a campaign — runs preflight first, then requires --confirm")
+    .option("--confirm", "actually launch (without it, this is a dry run)")
+    .option("--force", "launch even if preflight found blockers")
+    .action(async function (id, opts) {
+      try {
+        if (!opts.confirm) {
+          const d = await call("campaigns", "launch", { campaign_id: id, dry_run: true }, ctxFrom(this));
+          return emit(this, d, (x) => {
+            renderPreflight(x.preflight ?? x);
+            process.stdout.write(
+              x.preflight?.ok
+                ? `\nDry run only. Re-run with --confirm to launch.\n`
+                : `\nDry run only. Fix the blockers above, then re-run with --confirm.\n`,
+            );
+          });
+        }
+        const r = await call(
+          "campaigns", "launch", { campaign_id: id, force: !!opts.force }, ctxFrom(this),
+        );
         emit(this, r, (d) => process.stdout.write(`✓ ${d.campaign?.name ?? id} → ${d.campaign?.status}\n`));
       } catch (e) { fail(e); }
     });
@@ -311,14 +358,84 @@ export function registerCampaigns(program) {
 
   withCommonOpts(c.command("resume <id>"))
     .description("Resume a paused campaign")
-    .action(async function (id) {
+    .option("--confirm", "required — resuming restarts sending")
+    .option("--force", "resume even if preflight found blockers")
+    .action(async function (id, opts) {
       try {
-        const r = await call("campaigns", "resume", { campaign_id: id }, ctxFrom(this));
+        if (!opts.confirm) {
+          const d = await call("campaigns", "resume", { campaign_id: id, dry_run: true }, ctxFrom(this));
+          return emit(this, d, (x) => {
+            renderPreflight(x.preflight ?? x);
+            process.stdout.write(`\nDry run only. Re-run with --confirm to resume.\n`);
+          });
+        }
+        const r = await call("campaigns", "resume", { campaign_id: id, force: !!opts.force }, ctxFrom(this));
         emit(this, r, (d) => process.stdout.write(`✓ ${d.campaign?.name ?? id} → ${d.campaign?.status}\n`));
       } catch (e) { fail(e); }
     });
+
+  withCommonOpts(c.command("archive <id>"))
+    .description("Archive a campaign (reversible, keeps history)")
+    .option("-y, --yes", "skip the confirmation prompt")
+    .action(async function (id) {
+      try {
+        await confirmDestructive(this, `Archive campaign ${id}. It will stop sending.`);
+        const r = await call("campaigns", "archive", { campaign_id: id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ ${d.campaign?.name ?? id} → archived\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(c.command("clone <id>"))
+    .description("Duplicate a campaign as a fresh draft (no leads, no history)")
+    .option("--name <name>", "name for the copy")
+    .action(async function (id, opts) {
+      try {
+        const r = await call("campaigns", "clone", { campaign_id: id, name: opts.name }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Cloned to ${d.campaign?.id} — ${d.campaign?.name}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(c.command("delete <id>"))
+    .description("Permanently delete a campaign and its enrolments")
+    .option("-y, --yes", "skip the confirmation prompt")
+    .option("--dry-run", "show what would be deleted")
+    .option("--force", "delete even when the campaign has dispatch history")
+    .action(async function (id, opts) {
+      try {
+        if (opts.dryRun) {
+          const d = await call("campaigns", "delete", { campaign_id: id, dry_run: true }, ctxFrom(this));
+          return emit(this, d, (x) =>
+            process.stdout.write(
+              `Would delete campaign ${x.campaign?.name ?? id} (${x.dispatches} dispatched actions)\n`,
+            ));
+        }
+        await confirmDestructive(
+          this,
+          `Permanently delete campaign ${id} and every lead enrolment on it. This cannot be undone.`,
+          { expect: id.slice(0, 8) },
+        );
+        const r = await call(
+          "campaigns", "delete", { campaign_id: id, force: !!opts.force }, ctxFrom(this),
+        );
+        emit(this, r, (d) => process.stdout.write(`✓ Deleted ${d.name ?? id}\n`));
+      } catch (e) { fail(e); }
+    });
 }
 
+function renderPreflight(p) {
+  if (!p) return;
+  process.stdout.write(
+    `${p.ok ? "✓ Ready to launch" : "✖ Not ready"} — ${p.name ?? p.campaign_id} (${p.status})\n`,
+  );
+  const c = p.checks ?? {};
+  process.stdout.write(
+    `  leads: ${c.leads_enrolled}   steps: ${c.sequence_steps}   senders: ${c.sender_accounts}   daily limit: ${c.daily_send_limit ?? "—"}\n`,
+  );
+  for (const b of p.blockers ?? []) process.stdout.write(`  ✖ ${b}\n`);
+  for (const w of p.warnings ?? []) process.stdout.write(`  ! ${w}\n`);
+}
+
+
 export function registerSequences(program) {
   const s = program.command("sequences").description("Manage LinkedIn sequences");
 
@@ -501,8 +618,68 @@ export function registerSequences(program) {
         });
       } catch (e) { fail(e); }
     });
+
+  withCommonOpts(s.command("update-step <stepId>"))
+    .description("Patch one step in place (message, delay, variant, channel, action)")
+    .option("--action <action>", "step action")
+    .option("--message <text>", "message_content")
+    .option("--delay <days>", "delay_days")
+    .option("--variant <v>", "variant")
+    .option("--channel <c>", "channel")
+    .action(async function (stepId, opts) {
+      try {
+        const params = { step_id: stepId };
+        if (opts.action !== undefined) params.action = opts.action;
+        if (opts.message !== undefined) params.message_content = opts.message;
+        if (opts.delay !== undefined) params.delay_days = Number(opts.delay);
+        if (opts.variant !== undefined) params.variant = opts.variant;
+        if (opts.channel !== undefined) params.channel = opts.channel;
+        const r = await call("sequences", "update_step", params, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Updated step ${d.step?.id ?? stepId} (${d.step?.action})\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(s.command("delete-step <stepId>"))
+    .description("Delete one step; its children are re-parented")
+    .option("-y, --yes", "skip the confirmation prompt")
+    .option("--dry-run", "show what would change")
+    .action(async function (stepId, opts) {
+      try {
+        if (opts.dryRun) {
+          const d = await call("sequences", "delete_step", { step_id: stepId, dry_run: true }, ctxFrom(this));
+          return emit(this, d, (x) =>
+            process.stdout.write(`Would delete step ${stepId}; ${x.reparented_children} child step(s) re-parented\n`));
+        }
+        await confirmDestructive(this, `Delete sequence step ${stepId}. Child steps will be re-parented.`);
+        const r = await call("sequences", "delete_step", { step_id: stepId }, ctxFrom(this));
+        emit(this, r, (d) =>
+          process.stdout.write(`✓ Deleted step ${stepId} (${d.reparented_children} child step(s) re-parented)\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(s.command("delete <id>"))
+    .description("Delete a sequence and all its steps")
+    .option("-y, --yes", "skip the confirmation prompt")
+    .option("--dry-run", "show what would be deleted")
+    .option("--force", "delete even if campaigns still use it (they are detached)")
+    .action(async function (id, opts) {
+      try {
+        if (opts.dryRun) {
+          const d = await call("sequences", "delete", { id, dry_run: true }, ctxFrom(this));
+          return emit(this, d, (x) =>
+            process.stdout.write(
+              `Would delete sequence ${x.sequence?.name ?? id}; used by ${x.used_by_campaigns?.length ?? 0} campaign(s)\n`,
+            ));
+        }
+        await confirmDestructive(this, `Delete sequence ${id} and every step on it. This cannot be undone.`);
+        const r = await call("sequences", "delete", { id, force: !!opts.force }, ctxFrom(this));
+        emit(this, r, (d) =>
+          process.stdout.write(`✓ Deleted sequence ${d.sequence_id} (${d.detached_campaigns} campaign(s) detached)\n`));
+      } catch (e) { fail(e); }
+    });
 }
 
+
 function parseSnoozeDuration(s) {
   // Accepts e.g. "30m", "2h", "1d", "45" (minutes). Returns minutes (int).
   if (!s) return null;
@@ -872,11 +1049,27 @@ export function registerContent(program) {
     });
 
   withCommonOpts(c.command("schedule <id> <isoTimestamp>"))
-    .description("Schedule a content item")
-    .action(async function (id, ts) {
+    .description("Schedule a content item (Taplio when connected, otherwise built-in cron)")
+    .option("--channel <c>", "linkedin | blog | newsletter")
+    .option("--publish-as <p>", "personal | company")
+    .option("--company-page <id>", "company page id when publishing as company")
+    .option("--timezone <tz>", "IANA timezone label to store")
+    .action(async function (id, ts, opts) {
+      try {
+        const r = await call("content", "schedule", {
+          id, scheduled_for: ts, channel: opts.channel,
+          publish_as: opts.publishAs, company_page_id: opts.companyPage, timezone: opts.timezone,
+        }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Scheduled via ${d.engine} for ${d.scheduled_for}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(c.command("unschedule <id>"))
+    .description("Cancel a scheduled content item on whichever engine holds it")
+    .action(async function (id) {
       try {
-        const r = await call("content", "schedule", { id, scheduled_date: ts }, ctxFrom(this));
-        emit(this, r, (d) => process.stdout.write(`✓ Scheduled ${d.content?.id} → ${d.content?.scheduled_date}\n`));
+        const r = await call("content", "unschedule", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Unscheduled ${d.unscheduled ?? id}${d.engine ? ` (${d.engine})` : ""}\n`));
       } catch (e) { fail(e); }
     });
 
@@ -889,19 +1082,64 @@ export function registerContent(program) {
       } catch (e) { fail(e); }
     });
 
+  withCommonOpts(c.command("bulk-approve [ids...]"))
+    .description("Approve many content items (all pending when no ids given)")
+    .option("--campaign <id>", "only pending items in this campaign")
+    .option("-y, --yes", "skip the confirmation prompt")
+    .action(async function (ids, opts) {
+      try {
+        if (!ids?.length) await confirmDestructive(this, "Approve every pending content item in this workspace.");
+        const r = await call("content", "bulk_approve", {
+          ids: ids?.length ? ids : undefined, campaign_id: opts.campaign,
+        }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Approved ${d.approved} items\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(c.command("bulk-schedule <ids...>"))
+    .description("Schedule several content items on a cadence via the live engine")
+    .option("--start <iso>", "first slot (default: in 1 hour)")
+    .option("--interval-hours <n>", "hours between posts", "24")
+    .option("--channel <c>", "linkedin | blog | newsletter")
+    .option("--publish-as <p>", "personal | company")
+    .action(async function (ids, opts) {
+      try {
+        const r = await call("content", "bulk_schedule", {
+          ids, start: opts.start, interval_hours: Number(opts.intervalHours),
+          channel: opts.channel, publish_as: opts.publishAs,
+        }, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(table(
+            ["id", "ok", "engine", "when / error"],
+            (d.results || []).map((x) => [truncate(x.id, 8), x.ok ? "yes" : "no", x.engine ?? "—", x.scheduled_for ?? truncate(x.error ?? "", 50)]),
+          ) + `\n${d.scheduled} scheduled, ${d.failed} failed\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
   withCommonOpts(c.command("publish <id>"))
-    .description("Dispatch publication via agent-content-posting")
-    .action(async function (id) {
+    .description("Publish a content item immediately")
+    .option("--channel <c>", "linkedin | blog | newsletter")
+    .option("--publish-as <p>", "personal | company")
+    .option("--company-page <id>", "company page id when publishing as company")
+    .option("-y, --yes", "skip the confirmation prompt")
+    .action(async function (id, opts) {
       try {
-        const r = await call("content", "publish", { id }, ctxFrom(this));
-        emit(this, r, (d) => process.stdout.write(JSON.stringify(d.publish, null, 2) + "\n"));
+        await confirmDestructive(this, `Publish content item ${id} right now.`);
+        const r = await call("content", "publish_now", {
+          id, channel: opts.channel, publish_as: opts.publishAs, company_page_id: opts.companyPage,
+        }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Published via ${d.worker}\n`));
       } catch (e) { fail(e); }
     });
 
+
   withCommonOpts(c.command("delete <id>"))
     .description("Delete a content item")
+    .option("-y, --yes", "skip the confirmation prompt")
     .action(async function (id) {
       try {
+        await confirmDestructive(this, `Delete content item ${id}. This cannot be undone.`);
         const r = await call("content", "delete", { id }, ctxFrom(this));
         emit(this, r, (d) => process.stdout.write(`✓ Deleted ${d.deleted}\n`));
       } catch (e) { fail(e); }
@@ -1002,11 +1240,13 @@ export function registerCalendar(program) {
     .option("--cta <text>", "call to action")
     .option("--campaign <id>", "campaign_id")
     .option("--status <s>", "draft | scheduled | published", "draft")
+    .option("--at <iso>", "ISO timestamp — schedules the post immediately via the live engine")
     .action(async function (opts) {
       try {
         let content = opts.content;
         if (opts.contentFile) content = await readFile(opts.contentFile, "utf8");
         const r = await call("calendar", "create", {
+          scheduled_for: opts.at,
           title: opts.title, scheduled_date: opts.date, scheduled_time: opts.time,
           platform: opts.platform, content: content ?? "",
           hashtags: opts.hashtags ? opts.hashtags.split(",").map((s) => s.trim()) : undefined,
@@ -1042,15 +1282,99 @@ export function registerCalendar(program) {
     });
 
   withCommonOpts(cal.command("delete <id>"))
-    .description("Delete a calendar post")
+    .description("Delete a calendar post (cancels it on Taplio first when applicable)")
+    .option("-y, --yes", "skip the confirmation prompt")
     .action(async function (id) {
       try {
+        await confirmDestructive(this, `Delete calendar post ${id}. This cannot be undone.`);
         const r = await call("calendar", "delete", { id }, ctxFrom(this));
-        emit(this, r, (d) => process.stdout.write(`✓ Deleted ${d.deleted}\n`));
+        emit(this, r, (d) => process.stdout.write(`✓ Deleted ${d.deleted ?? d.unscheduled ?? id}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(cal.command("engine"))
+    .description("Show which scheduler is live for this workspace (Taplio or built-in cron)")
+    .option("--channel <c>", "linkedin | blog | newsletter", "linkedin")
+    .action(async function (opts) {
+      try {
+        const r = await call("calendar", "engine", { channel: opts.channel }, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(
+            `Engine:            ${d.engine}\n` +
+            `Channel:           ${d.channel}\n` +
+            `Taplio connected:  ${d.taplio_connected ? "yes" : "no"}\n` +
+            `Dispatch worker:   ${d.dispatch_worker}\n` +
+            `Reason:            ${d.reason}\n` +
+            `Pending scheduled: ${d.scheduled_pending}\n` +
+            (d.recent_failures?.length
+              ? `\nRecent failures:\n` + table(
+                ["id", "when", "attempts", "error"],
+                d.recent_failures.map((f) => [truncate(f.id, 8), f.scheduled_for ?? "—", f.dispatch_attempts ?? 0, truncate(f.dispatch_error ?? "", 60)]),
+              ) + "\n"
+              : ""),
+          );
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(cal.command("schedule <id>"))
+    .description("Schedule (or reschedule) a calendar post via the live engine")
+    .requiredOption("--at <iso>", "ISO timestamp, e.g. 2026-09-10T09:00:00Z")
+    .option("--channel <c>", "linkedin | blog | newsletter")
+    .option("--publish-as <p>", "personal | company")
+    .option("--company-page <id>", "company page id when publishing as company")
+    .option("--timezone <tz>", "IANA timezone label to store")
+    .action(async function (id, opts) {
+      try {
+        const r = await call("calendar", "schedule", {
+          id, scheduled_for: opts.at, channel: opts.channel,
+          publish_as: opts.publishAs, company_page_id: opts.companyPage, timezone: opts.timezone,
+        }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Scheduled via ${d.engine} for ${d.scheduled_for}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(cal.command("unschedule <id>"))
+    .description("Cancel a scheduled calendar post (cancels on Taplio when it owns it)")
+    .action(async function (id) {
+      try {
+        const r = await call("calendar", "unschedule", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Unscheduled ${d.unscheduled} (${d.engine})\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(cal.command("publish-now <id>"))
+    .description("Publish a calendar post immediately")
+    .option("-y, --yes", "skip the confirmation prompt")
+    .action(async function (id) {
+      try {
+        await confirmDestructive(this, `Publish calendar post ${id} right now.`);
+        const r = await call("calendar", "publish_now", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`✓ Published via ${d.worker}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(cal.command("bulk-schedule <ids...>"))
+    .description("Schedule several calendar posts on a cadence")
+    .option("--start <iso>", "first slot (default: in 1 hour)")
+    .option("--interval-hours <n>", "hours between posts", "24")
+    .option("--channel <c>", "linkedin | blog | newsletter")
+    .action(async function (ids, opts) {
+      try {
+        const r = await call("calendar", "bulk_schedule", {
+          ids, start: opts.start, interval_hours: Number(opts.intervalHours), channel: opts.channel,
+        }, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(table(
+            ["id", "ok", "engine", "when / error"],
+            (d.results || []).map((x) => [truncate(x.id, 8), x.ok ? "yes" : "no", x.engine ?? "—", x.scheduled_for ?? truncate(x.error ?? "", 50)]),
+          ) + `\n${d.scheduled} scheduled, ${d.failed} failed\n`);
+        });
       } catch (e) { fail(e); }
     });
 }
 
+
 export function registerSignals(program) {
   const s = program.command("signals").description("Read and manage market intelligence signals");
 
@@ -1152,8 +1476,10 @@ export function registerSignals(program) {
 
   withCommonOpts(s.command("delete <id>"))
     .description("Delete a signal")
+    .option("-y, --yes", "skip the confirmation prompt")
     .action(async function (id) {
       try {
+        await confirmDestructive(this, `Delete signal ${id}. This cannot be undone.`);
         const r = await call("signals", "delete", { id }, ctxFrom(this));
         emit(this, r, (d) => process.stdout.write(`✓ Deleted ${d.deleted}\n`));
       } catch (e) { fail(e); }
@@ -1283,8 +1609,10 @@ export function registerPipelines(program) {
 
   withCommonOpts(p.command("delete <id>"))
     .description("Delete an opportunity")
+    .option("-y, --yes", "skip the confirmation prompt")
     .action(async function (id) {
       try {
+        await confirmDestructive(this, `Delete pipeline record ${id}. This cannot be undone.`);
         const r = await call("pipelines", "delete", { id }, ctxFrom(this));
         emit(this, r, (d) => process.stdout.write(`✓ Deleted ${d.deleted}\n`));
       } catch (e) { fail(e); }
@@ -1472,8 +1800,10 @@ export function registerAgents(program) {
 
   withCommonOpts(a.command("delete <id>"))
     .description("Delete an agent")
+    .option("-y, --yes", "skip the confirmation prompt")
     .action(async function (id) {
       try {
+        await confirmDestructive(this, `Delete agent ${id}. This cannot be undone.`);
         const r = await call("agents", "delete", { id }, ctxFrom(this));
         emit(this, r, (d) => process.stdout.write(`✓ Deleted ${d.deleted}\n`));
       } catch (e) { fail(e); }