@series-a/cli 0.7.1 → 0.15.1

package/src/commands/insights.mjs

@@ -1,9 +1,38 @@
 import { readFile, writeFile } 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";
 
 const n = (v) => (v == null ? "" : String(v));
 
+/** Minimal CSV reader: header row + quoted fields. */
+function parseCsvLite(text) {
+  const lines = String(text).split(/\r?\n/).filter((l) => l.trim().length);
+  if (!lines.length) return [];
+  const split = (line) => {
+    const out = []; let cur = ""; let q = false;
+    for (let i = 0; i < line.length; i++) {
+      const c = line[i];
+      if (q) {
+        if (c === '"' && line[i + 1] === '"') { cur += '"'; i++; }
+        else if (c === '"') q = false;
+        else cur += c;
+      } else if (c === ",") { out.push(cur); cur = ""; }
+      else if (c === '"') q = true;
+      else cur += c;
+    }
+    out.push(cur);
+    return out.map((x) => x.trim());
+  };
+  const headers = split(lines[0]).map((h) => h.toLowerCase());
+  return lines.slice(1).map((line) => {
+    const cells = split(line);
+    const row = {};
+    headers.forEach((h, i) => { row[h] = cells[i] ?? ""; });
+    return row;
+  });
+}
+
+
 function findGroup(program, name) {
   return program.commands.find((c) => c.name() === name);
 }
@@ -608,6 +637,65 @@ export function registerAudiences(program) {
       } catch (e) { fail(e); }
     });
 
+  withCommonOpts(a.command("create"))
+    .description("Create a smart audience (lead segment)")
+    .requiredOption("--name <name>", "audience name")
+    .option("--description <text>", "description")
+    .option("--type <t>", "segment type", "manual")
+    .action(async function () {
+      try {
+        const o = this.optsWithGlobals();
+        const r = await call("audiences", "create", {
+          name: o.name, description: o.description, segment_type: o.type,
+        }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`\u2714 Created audience ${d.audience?.id}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(a.command("edit <id>"))
+    .description("Rename or re-describe an audience")
+    .option("--name <name>").option("--description <text>").option("--type <t>")
+    .action(async function (id) {
+      try {
+        const o = this.optsWithGlobals();
+        const params = { id };
+        if (o.name !== undefined) params.name = o.name;
+        if (o.description !== undefined) params.description = o.description;
+        if (o.type !== undefined) params.segment_type = o.type;
+        const r = await call("audiences", "update", params, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`\u2714 Updated ${d.audience?.id ?? id}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(a.command("delete <id>"))
+    .description("Delete an audience and its membership rows")
+    .option("-y, --yes", "skip the confirmation prompt")
+    .action(async function (id) {
+      try {
+        await confirmDestructive(this, `Delete audience ${id} and its membership rows.`);
+        const r = await call("audiences", "delete", { id }, ctxFrom(this));
+        emit(this, r, () => process.stdout.write(`\u2714 Deleted ${id}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(a.command("add-leads <id> <leadIds...>"))
+    .description("Add leads to an audience")
+    .action(async function (id, leadIds) {
+      try {
+        const r = await call("audiences", "add_members", { id, lead_ids: leadIds }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`\u2714 Added ${d.added ?? 0} of ${d.candidates ?? leadIds.length}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(a.command("remove-leads <id> <leadIds...>"))
+    .description("Remove leads from an audience")
+    .action(async function (id, leadIds) {
+      try {
+        const r = await call("audiences", "remove_members", { id, lead_ids: leadIds }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`\u2714 Removed ${d.removed ?? 0}\n`));
+      } catch (e) { fail(e); }
+    });
+
   withCommonOpts(a.command("add-to-campaign <id> <campaignId>"))
     .description("Enrol every lead in an audience into a campaign")
     .action(async function (id, campaignId) {
@@ -740,6 +828,208 @@ export function registerNewsletter(program) {
         });
       } catch (e) { fail(e); }
     });
+
+  withCommonOpts(nl.command("audience-show <audienceId>"))
+    .description("Show one mailing audience with contact counts")
+    .action(async function (audienceId) {
+      try {
+        const r = await call("newsletter", "audience_get", { audience_id: audienceId }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(
+          `${d.audience?.name}\n${d.stats?.contacts ?? 0} contacts (${d.stats?.subscribed ?? 0} subscribed, ${d.stats?.unsubscribed ?? 0} unsubscribed)\n` +
+          `Resend mirror: ${d.audience?.resend_audience_id || "(none — local only)"}\n`,
+        ));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(nl.command("audience-create"))
+    .description("Create a mailing audience (mirrored to Resend when connected)")
+    .requiredOption("--name <name>", "audience name")
+    .option("--description <text>", "description")
+    .action(async function () {
+      try {
+        const o = this.optsWithGlobals();
+        const r = await call("newsletter", "audience_create", {
+          name: o.name, description: o.description,
+        }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(
+          `\u2714 Created audience ${d.audience?.id}${d.resend_mirrored ? " (mirrored to Resend)" : " (local only — Resend not connected)"}\n`,
+        ));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(nl.command("audience-edit <audienceId>"))
+    .description("Rename or re-describe a mailing audience")
+    .option("--name <name>").option("--description <text>")
+    .action(async function (audienceId) {
+      try {
+        const o = this.optsWithGlobals();
+        const params = { audience_id: audienceId };
+        if (o.name !== undefined) params.name = o.name;
+        if (o.description !== undefined) params.description = o.description;
+        const r = await call("newsletter", "audience_update", params, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`\u2714 Updated ${d.audience?.id ?? audienceId}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(nl.command("audience-delete <audienceId>"))
+    .description("Delete a mailing audience and its contacts")
+    .option("-y, --yes", "skip the confirmation prompt")
+    .action(async function (audienceId) {
+      try {
+        await confirmDestructive(this, `Delete mailing audience ${audienceId} and every contact in it.`);
+        const r = await call("newsletter", "audience_delete", { audience_id: audienceId }, ctxFrom(this));
+        emit(this, r, () => process.stdout.write(`\u2714 Deleted ${audienceId}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(nl.command("contact-add <audienceId> <email>"))
+    .description("Add one contact to a mailing audience")
+    .option("--first <name>").option("--last <name>")
+    .action(async function (audienceId, email) {
+      try {
+        const o = this.optsWithGlobals();
+        const r = await call("newsletter", "contact_add", {
+          audience_id: audienceId, email, first_name: o.first, last_name: o.last,
+        }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`\u2714 Added ${d.added} contact(s)\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(nl.command("contacts-import <audienceId>"))
+    .description("Bulk import contacts from a CSV file (email,first_name,last_name)")
+    .requiredOption("--file <path>", "CSV file path")
+    .action(async function (audienceId) {
+      try {
+        const o = this.optsWithGlobals();
+        const rows = parseCsvLite(await readFile(o.file, "utf8"));
+        const contacts = rows.map((r) => ({
+          email: r.email || r["email address"] || "",
+          first_name: r.first_name || r.first || undefined,
+          last_name: r.last_name || r.last || undefined,
+        })).filter((c) => c.email);
+        if (!contacts.length) throw new Error("No email column found in the CSV");
+        const r = await call("newsletter", "contacts_import", {
+          audience_id: audienceId, contacts, source: "cli:import",
+        }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(
+          `\u2714 Imported ${d.added} of ${d.candidates} (Resend mirrored: ${d.resend_mirrored})\n`,
+        ));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(nl.command("contact-remove <email>"))
+    .description("Delete a contact (optionally only from one audience)")
+    .option("--audience <id>", "restrict to one audience")
+    .option("-y, --yes", "skip the confirmation prompt")
+    .action(async function (email) {
+      try {
+        const o = this.optsWithGlobals();
+        await confirmDestructive(this, `Delete contact ${email}.`);
+        const r = await call("newsletter", "contact_remove", {
+          email, audience_id: o.audience,
+        }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`\u2714 Removed ${d.removed}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(nl.command("contact-unsubscribe <email>"))
+    .description("Mark a contact unsubscribed")
+    .option("--audience <id>", "restrict to one audience")
+    .action(async function (email) {
+      try {
+        const o = this.optsWithGlobals();
+        const r = await call("newsletter", "contact_unsubscribe", {
+          email, audience_id: o.audience,
+        }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`\u2714 Unsubscribed ${d.unsubscribed}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(nl.command("sync-segment <segmentId> <audienceId>"))
+    .description("Push every lead in a smart audience into a mailing audience")
+    .option("--include-unverified", "include leads without a verified email")
+    .action(async function (segmentId, audienceId) {
+      try {
+        const o = this.optsWithGlobals();
+        const r = await call("newsletter", "sync_segment", {
+          segment_id: segmentId, audience_id: audienceId, include_unverified: !!o.includeUnverified,
+        }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(
+          `\u2714 Synced: ${d.added ?? 0} added, ${d.skipped ?? 0} skipped, ${d.failed ?? 0} failed\n`,
+        ));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(nl.command("send <id>"))
+    .description("Send a newsletter now, or schedule it, to one or more mailing audiences")
+    .option("--audience <ids>", "comma-separated mailing audience ids")
+    .option("--at <isoTimestamp>", "schedule instead of sending now")
+    .option("--from <email>", "override the from address")
+    .option("-y, --yes", "skip the confirmation prompt")
+    .action(async function (id) {
+      try {
+        const o = this.optsWithGlobals();
+        const audienceIds = String(o.audience || "").split(",").map((x) => x.trim()).filter(Boolean);
+        if (!audienceIds.length) throw new Error("--audience is required (comma-separated ids)");
+        await confirmDestructive(this, o.at
+          ? `Schedule newsletter ${id} for ${o.at} to ${audienceIds.length} audience(s).`
+          : `Send newsletter ${id} now to ${audienceIds.length} audience(s).`);
+        const r = await call("newsletter", "send", {
+          id, audience_ids: audienceIds, mode: o.at ? "schedule" : "now",
+          scheduled_for: o.at, from: o.from,
+        }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`\u2714 ${d.mode === "schedule" ? "Scheduled" : "Sent"} ${id}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(nl.command("test <id> <email>"))
+    .description("Send a test copy of a newsletter to one address")
+    .action(async function (id, email) {
+      try {
+        const r = await call("newsletter", "send_test", { id, test_email: email }, ctxFrom(this));
+        emit(this, r, () => process.stdout.write(`\u2714 Test sent to ${email}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(nl.command("render <id>"))
+    .description("Render the final email HTML without sending")
+    .action(async function (id) {
+      try {
+        const r = await call("newsletter", "render", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(
+          (d.result?.html || d.result?.body_html || JSON.stringify(d.result, null, 2)) + "\n",
+        ));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(nl.command("metrics"))
+    .description("Delivery metrics and sending health for the workspace")
+    .option("--id <newsletterId>", "restrict to one newsletter")
+    .option("--limit <n>", "events to scan", "500")
+    .action(async function () {
+      try {
+        const o = this.optsWithGlobals();
+        const r = await call("newsletter", "metrics", { id: o.id, limit: Number(o.limit) }, ctxFrom(this));
+        emit(this, r, (d) => {
+          const t = d.totals || {};
+          const s = d.send_state;
+          process.stdout.write(
+            Object.keys(t).length
+              ? table(["event", "count"], Object.entries(t).map(([k, v]) => [k, String(v)])) + "\n"
+              : "No delivery events yet\n",
+          );
+          if (d.rates) {
+            process.stdout.write(`Open ${d.rates.open_rate}%  Click ${d.rates.click_rate}%  Bounce ${d.rates.bounce_rate}%\n`);
+          }
+          if (s) {
+            process.stdout.write(
+              `Daily ${s.daily_sent}/${s.daily_cap}  warmup stage ${s.warmup_stage}` +
+              (s.paused_reason ? `  PAUSED: ${s.paused_reason}` : "") + "\n",
+            );
+          }
+        });
+      } catch (e) { fail(e); }
+    });
 }
 
 export function registerVideo(program) {
@@ -782,6 +1072,115 @@ export function registerVideo(program) {
         emit(this, r, (d) => process.stdout.write(`${d.share_url ?? "not shared"}\n`));
       } catch (e) { fail(e); }
     });
+
+  withCommonOpts(v.command("avatars"))
+    .description("List the avatars curated for this workspace")
+    .action(async function () {
+      try {
+        const r = await call("video", "avatars", {}, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(table(
+            ["avatar_id", "name", "gender", "voice", "default"],
+            (d.avatars || []).map((x) => [
+              truncate(x.avatar_id, 20), truncate(x.avatar_name, 24), n(x.gender),
+              truncate(n(x.default_voice_id), 20), x.is_default ? "yes" : "",
+            ]),
+          ) + `\n${d.avatars?.length ?? 0} rows\n`);
+          if (d.note) process.stdout.write(`${d.note}\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(v.command("create"))
+    .description("Generate a new AI video (talking head or explainer)")
+    .option("--prompt <text>", "brief or script context")
+    .option("--source-url <url>", "generate an explainer from a web page")
+    .option("--content-item <id>", "generate from a content item")
+    .option("--kind <k>", "talking_head | explainer", "talking_head")
+    .option("--avatar <id>", "avatar_id (see `video avatars`)")
+    .option("--voice <id>", "voice_id")
+    .option("--style <s>", "professional | casual | educational | inspirational")
+    .option("--format <f>", "platform format (e.g. linkedin, shorts)")
+    .option("--duration <n>", "target duration in seconds")
+    .option("--script-mode <m>", "verbatim to use --prompt as the exact script")
+    .action(async function () {
+      try {
+        const o = this.optsWithGlobals();
+        if (!o.prompt && !o.sourceUrl && !o.contentItem) {
+          throw new Error("Provide --prompt, --source-url or --content-item");
+        }
+        const r = await call("video", "create", {
+          prompt: o.prompt,
+          source_url: o.sourceUrl,
+          content_item_id: o.contentItem,
+          video_kind: o.kind,
+          avatar_id: o.avatar,
+          voice_id: o.voice,
+          style: o.style,
+          video_format: o.format,
+          target_duration: o.duration ? Number(o.duration) : undefined,
+          script_mode: o.scriptMode,
+        }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(JSON.stringify(d.video ?? d, null, 2) + "\n"));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(v.command("update <id>"))
+    .description("Update video metadata (title, episode label, CTA)")
+    .option("--title <t>")
+    .option("--episode <label>")
+    .option("--cta-type <t>", "book_call | visit_site | subscribe | custom | none")
+    .option("--cta-label <l>")
+    .option("--cta-url <u>")
+    .option("--summary <s>")
+    .action(async function (id) {
+      try {
+        const o = this.optsWithGlobals();
+        const r = await call("video", "update", {
+          id, title: o.title, episode_label: o.episode,
+          cta_type: o.ctaType, cta_label: o.ctaLabel, cta_url: o.ctaUrl, summary: o.summary,
+        }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(JSON.stringify(d.video, null, 2) + "\n"));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(v.command("publish <id>"))
+    .description("Make the video publicly shareable")
+    .action(async function (id) {
+      try {
+        const r = await call("video", "publish", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`${d.share_url ?? "published"}\n`));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(v.command("unpublish <id>"))
+    .description("Revoke the public share link")
+    .action(async function (id) {
+      try {
+        const r = await call("video", "unpublish", { id }, ctxFrom(this));
+        emit(this, r, () => process.stdout.write("unpublished\n"));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(v.command("refresh <id>"))
+    .description("Re-check the render status with the provider")
+    .action(async function (id) {
+      try {
+        const r = await call("video", "refresh", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(JSON.stringify(d.video ?? d, null, 2) + "\n"));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(v.command("delete <id>"))
+    .description("Delete a video project")
+    .option("--yes", "skip confirmation")
+    .action(async function (id) {
+      try {
+        await confirmDestructive(this, `Delete video project ${id}. This cannot be undone.`);
+        const r = await call("video", "delete", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(`deleted ${d.deleted}\n`));
+      } catch (e) { fail(e); }
+    });
 }
 
 export function registerWatchlist(program) {
@@ -950,6 +1349,64 @@ export function registerActivity(program) {
     });
 }
 
+export function registerAudit(program) {
+  const a = program.command("audit").description("Audit trail of CLI / agent / assistant actions");
+
+  withCommonOpts(a.command("list"))
+    .description("List audited actions (newest first)")
+    .option("--status <s>", "ok | denied | error")
+    .option("--surface <s>", "cli | mcp | api | internal")
+    .option("--resource <r>", "e.g. leads, campaigns, content")
+    .option("--actor <email>", "filter by person")
+    .option("--writes", "only actions that changed data")
+    .option("--since <iso>", "ISO timestamp lower bound")
+    .option("--until <iso>", "ISO timestamp upper bound")
+    .option("--limit <n>", "max rows", "50")
+    .action(async function () {
+      try {
+        const o = this.optsWithGlobals();
+        const r = await call("audit", "list", {
+          status: o.status, surface: o.surface, resource: o.resource,
+          actor_email: o.actor, writes_only: !!o.writes,
+          since: o.since, until: o.until, limit: Number(o.limit),
+        }, ctxFrom(this));
+        emit(this, r, (d) => {
+          process.stdout.write(table(
+            ["when", "who", "from", "action", "status", "ms"],
+            (d.entries || []).map((x) => [
+              n(x.created_at).replace("T", " ").slice(0, 19),
+              truncate(x.actor_email || x.agent_name || "-", 24),
+              n(x.surface),
+              truncate(`${x.resource}.${x.action}`, 28),
+              n(x.status),
+              n(x.duration_ms),
+            ]),
+          ) + `\n${d.entries?.length ?? 0} rows\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(a.command("show <id>"))
+    .description("Full request and outcome for one audited action")
+    .action(async function (id) {
+      try {
+        const r = await call("audit", "get", { id }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(JSON.stringify(d.entry, null, 2) + "\n"));
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(a.command("stats"))
+    .description("Rolled-up audit summary")
+    .option("--since <iso>", "ISO timestamp lower bound")
+    .action(async function () {
+      try {
+        const o = this.optsWithGlobals();
+        const r = await call("audit", "stats", { since: o.since }, ctxFrom(this));
+        emit(this, r, (d) => process.stdout.write(JSON.stringify(d, null, 2) + "\n"));
+      } catch (e) { fail(e); }
+    });
+}
+
 export function registerWorkspacesExtras(program) {
   const w = program.command("workspaces").description("Workspaces (admin keys only)");
 
@@ -1024,11 +1481,97 @@ export function registerIntegrations(program) {
     });
 
   withCommonOpts(i.command("check <platform>"))
-    .description("Health-check one integration")
+    .description("Health-check one integration (e.g. linkedin_tool, resend)")
     .action(async function (platform) {
       try {
         const r = await call("integrations", "check", { platform }, ctxFrom(this));
         emit(this, r, (d) => process.stdout.write(JSON.stringify(d, null, 2) + "\n"));
       } catch (e) { fail(e); }
     });
+
+  withCommonOpts(i.command("health"))
+    .description("Live verdict: is Resend configured and are LinkedIn seats connected?")
+    .action(async function () {
+      try {
+        const r = await call("integrations", "health", {}, ctxFrom(this));
+        emit(this, r, (d) => {
+          const flag = d.healthy ? "✔ healthy" : "✖ issues: " + (d.issues || []).join(", ");
+          process.stdout.write(`${flag}\n`);
+          process.stdout.write(table(
+            ["integration", "state", "detail"],
+            [
+              ["resend", d.resend?.state ?? "unknown",
+                d.resend?.configured ? `from=${d.resend?.from_email ?? "?"}` : (d.resend?.detail ?? "not configured")],
+              ...(d.linkedin?.seats?.length
+                ? d.linkedin.seats.map((s) => [
+                    `linkedin:${truncate(s.display_name || s.account_id || "?", 22)}`,
+                    s.state, s.connection_status ?? "",
+                  ])
+                : [["linkedin", d.linkedin?.verdict ?? "unknown", "no seats"]]),
+            ],
+          ) + "\n");
+        });
+      } catch (e) { fail(e); }
+    });
+}
+
+export function registerReports(program) {
+  const r = program.command("reports").description("Daily workspace reports (history + on-demand generation)");
+
+  withCommonOpts(r.command("list"))
+    .description("List past daily reports (newest first)")
+    .option("--since <date>", "report date lower bound (YYYY-MM-DD)")
+    .option("--until <date>", "report date upper bound (YYYY-MM-DD)")
+    .option("--limit <n>", "max rows", "25")
+    .action(async function () {
+      try {
+        const o = this.optsWithGlobals();
+        const res = await call("daily_reports", "list", {
+          since: o.since, until: o.until, limit: Number(o.limit),
+        }, ctxFrom(this));
+        emit(this, res, (d) => {
+          process.stdout.write(table(
+            ["date", "status", "activity", "recipients", "sent", "report id"],
+            (d.reports || []).map((x) => [
+              n(x.report_date), n(x.status), n(x.activity_total),
+              n(x.recipient_count), n(x.sent_count), truncate(x.id, 13),
+            ]),
+          ) + `\n${d.reports?.length ?? 0} rows\n`);
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(r.command("show <idOrDate>"))
+    .description("Show one daily report by id or date (YYYY-MM-DD)")
+    .action(async function (idOrDate) {
+      try {
+        const isDate = /^\d{4}-\d{2}-\d{2}$/.test(idOrDate);
+        const res = await call("daily_reports", "get", isDate ? { date: idOrDate } : { id: idOrDate }, ctxFrom(this));
+        emit(this, res, (d) => {
+          const x = d.report || {};
+          process.stdout.write(`${x.london_date_label ?? x.report_date} — ${x.status}\n`);
+          process.stdout.write(`activity: ${x.activity_total ?? 0} · recipients: ${x.recipient_count ?? 0} · sent: ${x.sent_count ?? 0}\n`);
+          process.stdout.write(`url: ${x.report_url ?? "-"}\n`);
+          process.stdout.write(JSON.stringify(x.stats ?? {}, null, 2) + "\n");
+        });
+      } catch (e) { fail(e); }
+    });
+
+  withCommonOpts(r.command("generate"))
+    .description("Generate today's report now (dry-run; --send to email workspace members)")
+    .option("--send", "actually email workspace members (default: generate only)")
+    .option("--to <email>", "send only to this test address")
+    .action(async function () {
+      try {
+        const o = this.optsWithGlobals();
+        const res = await call("daily_reports", "generate", {
+          send: !!o.send, test_to: o.to,
+        }, ctxFrom(this));
+        emit(this, res, (d) => {
+          const x = d.report || {};
+          process.stdout.write(`report ${x.report_id ?? x.id ?? "?"} — sent: ${d.sent ?? 0}\n`);
+          if (x.report_url) process.stdout.write(`url: ${x.report_url}\n`);
+        });
+      } catch (e) { fail(e); }
+    });
 }