@arcsend/cli 1.0.0

package/dist/index.js

@@ -0,0 +1,2105 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/api.ts
+import chalk2 from "chalk";
+
+// src/config.ts
+import { homedir } from "os";
+import { join } from "path";
+import { readFileSync, writeFileSync, mkdirSync, existsSync, chmodSync } from "fs";
+var DEFAULT_URL = "https://send.highsend.io";
+var CONFIG_DIR = join(homedir(), ".arcsend");
+var CONFIG_PATH = join(CONFIG_DIR, "config.txt");
+function loadConfig(keyOverride, urlOverride) {
+  let apiKey = keyOverride || process.env.ARCSEND_API_KEY || "";
+  let baseUrl = urlOverride || process.env.ARCSEND_URL || "";
+  if ((!apiKey || !baseUrl) && existsSync(CONFIG_PATH)) {
+    for (const line of readFileSync(CONFIG_PATH, "utf8").split("\n")) {
+      const idx = line.indexOf("=");
+      if (idx < 0) continue;
+      const key = line.slice(0, idx).trim();
+      const val = line.slice(idx + 1).trim();
+      if (!apiKey && key === "api_key") apiKey = val;
+      if (!baseUrl && (key === "instance_url" || key === "url")) baseUrl = val;
+    }
+  }
+  baseUrl = (baseUrl || DEFAULT_URL).replace(/\/+$/, "");
+  return { apiKey, baseUrl };
+}
+function saveConfig(apiKey, url) {
+  mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(
+    CONFIG_PATH,
+    `api_key=${apiKey}
+instance_url=${url.replace(/\/+$/, "")}
+`,
+    { mode: 384 }
+  );
+  try {
+    chmodSync(CONFIG_PATH, 384);
+  } catch {
+  }
+}
+
+// src/output.ts
+import chalk from "chalk";
+import Table from "cli-table3";
+var DRY = false;
+var QUIET = false;
+function setDryRun(v) {
+  DRY = v;
+}
+function setQuiet(v) {
+  QUIET = v;
+}
+function fail(msg) {
+  if (!QUIET) console.error(chalk.red(`\u2717 ${msg}`));
+  process.exit(1);
+}
+function ok(msg) {
+  if (DRY || QUIET) return;
+  console.log(chalk.green.bold("\u2713") + " " + msg);
+}
+function dim(s) {
+  return chalk.dim(s);
+}
+var STATUS_COLS = /* @__PURE__ */ new Set(["status", "lead_status", "health_status", "sentiment_category", "is_active"]);
+function statusColor(v) {
+  switch (v) {
+    case "active":
+    case "connected":
+    case "healthy":
+    case "interested":
+    case "sent":
+    case "delivered":
+    case "won":
+    case "closed_won":
+    case "true":
+      return chalk.green(v);
+    case "paused":
+    case "warning":
+    case "medium":
+    case "not_now":
+    case "pending":
+    case "syncing":
+    case "connecting":
+    case "processing":
+    case "question":
+      return chalk.yellow(v);
+    case "draft":
+    case "scheduled":
+    case "skipped":
+    case "false":
+      return chalk.dim(v);
+    case "completed":
+    case "meeting_booked":
+    case "follow_up":
+      return chalk.blue(v);
+    case "error":
+    case "failed":
+    case "disconnected":
+    case "bounced":
+    case "bounce":
+    case "not_interested":
+    case "lost":
+    case "closed_lost":
+    case "critical":
+    case "unsubscribe":
+    case "unsubscribed":
+      return chalk.red(v);
+    case "archived":
+    case "out_of_office":
+      return chalk.gray(v);
+    default:
+      return v;
+  }
+}
+function getPath(obj, path) {
+  return path.split(".").reduce((o, k) => o == null ? o : o[k], obj);
+}
+var MAXLEN = 200;
+function truncate(s) {
+  const flat = s.replace(/\s+/g, " ").trim();
+  return flat.length > MAXLEN ? flat.slice(0, MAXLEN) + dim(`\u2026 (${flat.length} chars \u2014 use -j for full)`) : flat;
+}
+function fmtCell(v) {
+  if (v == null || v === "") return "\u2014";
+  if (Array.isArray(v)) {
+    if (!v.length) return "\u2014";
+    if (v.every((x) => x && typeof x === "object")) return dim(`${v.length} item(s) \u2014 see below or use -j`);
+    return v.join(", ");
+  }
+  if (typeof v === "object") return Object.keys(v).length ? truncate(JSON.stringify(v)) : "\u2014";
+  return truncate(String(v));
+}
+function renderArrayTable(arr) {
+  const rows = arr.slice(0, 25);
+  const cols = Array.from(new Set(rows.flatMap((r) => Object.keys(r))));
+  const t = new Table({ head: cols.map((c) => chalk.dim(c)), style: { head: [], border: [] } });
+  for (const r of rows) t.push(cols.map((c) => valCell(c, r[c])));
+  let s = t.toString().split("\n").map((l) => "  " + l).join("\n");
+  if (arr.length > 25) s += "\n  " + dim(`\u2026 ${arr.length - 25} more`);
+  return s;
+}
+function csvEsc(v) {
+  const s = fmtCell(v);
+  return /[",\n]/.test(s) ? `"${s.replace(/"/g, '""')}"` : s;
+}
+function unwrap(data) {
+  if (data && typeof data === "object" && !Array.isArray(data) && "data" in data && ("object" in data || "pagination" in data)) {
+    return { payload: data.data, pagination: data.pagination ?? (typeof data.total === "number" ? { total: data.total } : void 0) };
+  }
+  if (typeof data?.total === "number" && Array.isArray(data?.data)) {
+    return { payload: data.data, pagination: { total: data.total } };
+  }
+  return { payload: data, pagination: void 0 };
+}
+function out(ctx2, data, columns, headers, noun = "row(s)") {
+  if (ctx2.dryRun) return;
+  if (ctx2.quiet) return;
+  if (ctx2.json) {
+    console.log(JSON.stringify(data, null, 2));
+    return;
+  }
+  if (typeof data === "string") {
+    console.log(data);
+    return;
+  }
+  if (data == null) {
+    console.log(dim(`No ${noun}.`));
+    return;
+  }
+  const { payload, pagination } = unwrap(data);
+  if (Array.isArray(payload)) {
+    renderList(ctx2, payload, columns, headers, noun, pagination);
+    return;
+  }
+  if (payload && typeof payload === "object") {
+    renderDetail(ctx2, payload);
+    return;
+  }
+  console.log(fmtCell(payload));
+}
+function renderDetail(ctx2, obj) {
+  const keys = Object.keys(obj);
+  if (!keys.length) {
+    console.log(dim("(empty)"));
+    return;
+  }
+  if (ctx2.csv) {
+    console.log("field,value");
+    for (const k of keys) console.log(`${csvEsc(k)},${csvEsc(obj[k])}`);
+    return;
+  }
+  const width = Math.max(...keys.map((k) => k.length));
+  const lines = [];
+  for (const k of keys) {
+    const label = chalk.dim(k.padEnd(width));
+    const v = obj[k];
+    if (Array.isArray(v) && v.length && v.every((x) => x && typeof x === "object")) {
+      lines.push(`${label}  ${dim(`(${v.length})`)}`);
+      lines.push(renderArrayTable(v));
+    } else if (v && typeof v === "object" && !Array.isArray(v) && Object.keys(v).length) {
+      lines.push(`${label}  `);
+      const sub = v;
+      const sw = Math.max(...Object.keys(sub).map((s) => s.length));
+      for (const sk of Object.keys(sub)) lines.push(`  ${chalk.dim(sk.padEnd(sw))}  ${valCell(sk, sub[sk])}`);
+    } else {
+      lines.push(`${label}  ${valCell(k, v)}`);
+    }
+  }
+  console.log(lines.join("\n"));
+}
+function valCell(key, v) {
+  const s = fmtCell(v);
+  if (s !== "\u2014" && (STATUS_COLS.has(key) || key.endsWith("_status"))) return statusColor(s);
+  return s;
+}
+function renderList(ctx2, list, columns, headers, noun, pagination) {
+  const useFields = ctx2.fields && ctx2.fields.length ? ctx2.fields : void 0;
+  let cols = useFields || columns;
+  if (!cols || !cols.length) {
+    cols = list.length ? Object.keys(list[0]) : [];
+    headers = void 0;
+  }
+  const hdrs = useFields || headers || cols;
+  if (ctx2.csv) {
+    console.log(hdrs.map(csvEsc).join(","));
+    for (const r of list) console.log(cols.map((c) => csvEsc(getPath(r, c))).join(","));
+    return;
+  }
+  if (!list.length) {
+    console.log(dim(`No ${noun}.`));
+    return;
+  }
+  const table = new Table({ head: hdrs.map((h) => chalk.dim(h)), style: { head: [], border: [] } });
+  for (const r of list) table.push(cols.map((c) => valCell(c, getPath(r, c))));
+  console.log(table.toString());
+  const total = pagination?.total;
+  if (typeof total === "number") {
+    const parts = [`${list.length} shown`];
+    if (pagination.page && pagination.total_pages) parts.push(`page ${pagination.page}/${pagination.total_pages}`);
+    parts.push(`${total} total`);
+    console.log(dim(parts.join(" \xB7 ")));
+  }
+}
+
+// src/api.ts
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function extractError(data, text, status) {
+  let d = data && (data.detail ?? data.error ?? data.message);
+  if (d && typeof d === "object") {
+    if (Array.isArray(d)) d = d.map((e) => e?.msg ?? e?.message ?? JSON.stringify(e)).join("; ");
+    else d = d.message ?? d.msg ?? JSON.stringify(d);
+  }
+  return typeof d === "string" && d || text || `HTTP ${status}`;
+}
+function buildQuery(params) {
+  if (!params) return "";
+  const parts = [];
+  for (const [k, v] of Object.entries(params)) {
+    if (v === void 0 || v === null || v === "") continue;
+    parts.push(`${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`);
+  }
+  return parts.length ? "?" + parts.join("&") : "";
+}
+var Api = class {
+  keyOverride;
+  urlOverride;
+  apiKey = "";
+  baseUrl = "";
+  ready = false;
+  dryRun;
+  constructor(opts = {}) {
+    this.keyOverride = opts.apiKey;
+    this.urlOverride = opts.url;
+    this.dryRun = !!opts.dryRun;
+  }
+  ensure() {
+    if (this.ready) return;
+    const { apiKey, baseUrl } = loadConfig(this.keyOverride, this.urlOverride);
+    if (!apiKey) {
+      fail("No API key. Use --api-key, set ARCSEND_API_KEY, or run `arcsend auth setup --key <key>`.");
+    }
+    this.apiKey = apiKey;
+    this.baseUrl = `${baseUrl}/api/external`;
+    this.ready = true;
+  }
+  get(path, params) {
+    return this.request("GET", path, { params });
+  }
+  post(path, body) {
+    return this.request("POST", path, { body });
+  }
+  put(path, body) {
+    return this.request("PUT", path, { body });
+  }
+  patch(path, body) {
+    return this.request("PATCH", path, { body });
+  }
+  del(path, params) {
+    return this.request("DELETE", path, { params });
+  }
+  async request(method, path, opts = {}) {
+    if (this.dryRun && method !== "GET") {
+      const b = opts.body !== void 0 ? "  " + JSON.stringify(opts.body).slice(0, 300) : "";
+      console.log(chalk2.yellow(`[dry-run] would ${method} ${path}${b}`));
+      return { dry_run: true, method, path, body: opts.body ?? null };
+    }
+    this.ensure();
+    const url = `${this.baseUrl}${path}${buildQuery(opts.params)}`;
+    const idempotent = method === "GET" || method === "DELETE";
+    const attempts = 4;
+    let lastErr = "";
+    for (let attempt = 1; attempt <= attempts; attempt++) {
+      let resp;
+      try {
+        resp = await fetch(url, {
+          method,
+          headers: {
+            Authorization: `Bearer ${this.apiKey}`,
+            ...opts.body !== void 0 ? { "Content-Type": "application/json" } : {}
+          },
+          body: opts.body !== void 0 ? JSON.stringify(opts.body) : void 0
+        });
+      } catch (e) {
+        lastErr = e?.message || String(e);
+        if (attempt < attempts && idempotent) {
+          await sleep(Math.min(2 ** attempt, 8) * 1e3);
+          continue;
+        }
+        fail(`connection error: ${lastErr}`);
+      }
+      if (resp.status === 429 && attempt < attempts) {
+        const ra = Number(resp.headers.get("retry-after")) || Math.min(2 ** attempt, 8);
+        await sleep(ra * 1e3);
+        continue;
+      }
+      if (resp.status >= 500 && attempt < attempts && idempotent) {
+        await sleep(Math.min(2 ** attempt, 8) * 1e3);
+        continue;
+      }
+      const text = await resp.text();
+      let data = null;
+      try {
+        data = text ? JSON.parse(text) : null;
+      } catch {
+        data = text;
+      }
+      if (!resp.ok) {
+        let msg = extractError(data, text, resp.status);
+        const s = resp.status;
+        if (s === 401 || s === 403) msg += " \u2014 run `arcsend auth setup` or check ARCSEND_API_KEY";
+        else if (s === 404 && !/not.?found/i.test(msg)) msg = `Not found \u2014 ${msg}`;
+        else if (s === 429) msg = `Rate limited \u2014 ${msg}`;
+        fail(msg);
+      }
+      return data;
+    }
+    return fail(`request failed: ${lastErr}`);
+  }
+  /** Multipart file upload (for material uploads). */
+  async upload(path, filePath, fields = {}) {
+    if (this.dryRun) {
+      console.log(`[dry-run] would POST ${path}  (upload ${filePath})`);
+      return { dry_run: true, method: "POST", path };
+    }
+    this.ensure();
+    const { readFileSync: readFileSync3 } = await import("fs");
+    const { basename } = await import("path");
+    const fd = new FormData();
+    fd.append("file", new Blob([readFileSync3(filePath)]), basename(filePath));
+    for (const [k, v] of Object.entries(fields)) fd.append(k, v);
+    const resp = await fetch(`${this.baseUrl}${path}`, {
+      method: "POST",
+      headers: { Authorization: `Bearer ${this.apiKey}` },
+      body: fd
+    });
+    const text = await resp.text();
+    let data = null;
+    try {
+      data = text ? JSON.parse(text) : null;
+    } catch {
+      data = text;
+    }
+    if (!resp.ok) fail(extractError(data, text, resp.status));
+    return data;
+  }
+  /** Fetch every page (--all) or a single page, matching the API's {data,total,page} shape. */
+  async paged(path, params, page, limit, all) {
+    if (!all) return this.get(path, { ...params, page, page_size: limit });
+    const collected = [];
+    let p = 1;
+    let total = 0;
+    for (; ; ) {
+      const res = await this.get(path, { ...params, page: p, page_size: 200 });
+      const chunk = Array.isArray(res) ? res : res?.data || [];
+      total = res?.pagination?.total ?? res?.total ?? total;
+      collected.push(...chunk);
+      if (res?.pagination?.has_more === false || chunk.length < 200) break;
+      p += 1;
+    }
+    return { object: "list", data: collected, total: total || collected.length };
+  }
+};
+
+// src/confirm.ts
+import readline from "readline";
+async function confirmAction(prompt, opts) {
+  if (opts.yes || opts.dryRun) return true;
+  const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
+  const answer = await new Promise((res) => {
+    rl.question(`${prompt} [y/N]: `, (a) => {
+      rl.close();
+      res(a);
+    });
+  });
+  return /^y(es)?$/i.test(answer.trim());
+}
+
+// src/core/validate.ts
+import { z } from "zod";
+function check(schema, values, label) {
+  const r = schema.safeParse(values);
+  if (!r.success) {
+    const lines = r.error.issues.map((i) => (i.path.length ? `${i.path.join(".")}: ` : "") + i.message).join("\n  ");
+    fail(`${label}
+  ${lines}`);
+  }
+}
+var int = () => z.coerce.number().int();
+var validators = {
+  // Sequence step: step ≥1, every step needs a body, step 1 needs a subject,
+  // variant A/B, split weight 1–100. (Matches backend preflight + sequence rules.)
+  "sequence.add"(v) {
+    check(
+      z.object({
+        step: int().min(1, "step number must be \u2265 1"),
+        subject: z.string().optional(),
+        body: z.string().min(1, "body is required \u2014 every sequence step needs a body"),
+        variant: z.enum(["A", "B", "C", "D"]).optional(),
+        splitWeight: int().min(1).max(100, "split weight must be 1\u2013100").optional(),
+        delayDays: int().min(0).optional(),
+        delayHours: int().min(0).optional()
+      }).superRefine((d, ctx2) => {
+        if (d.step === 1 && !d.subject?.trim()) {
+          ctx2.addIssue({ code: z.ZodIssueCode.custom, path: ["subject"], message: "step 1 requires a subject line" });
+        }
+      }),
+      v,
+      "Invalid sequence step:"
+    );
+  },
+  "sequence.update"(v) {
+    check(
+      z.object({
+        body: z.string().min(1, "body cannot be empty").optional(),
+        variant: z.enum(["A", "B"]).optional(),
+        splitWeight: int().min(1).max(100, "split weight must be 1\u2013100").optional(),
+        step: int().min(1, "step number must be \u2265 1").optional()
+      }),
+      v,
+      "Invalid sequence step update:"
+    );
+  },
+  // Per-campaign daily limit has no upper cap but must be ≥ 1.
+  "campaign.save"(v) {
+    check(
+      z.object({ dailyLimit: int().min(1, "daily send limit must be \u2265 1").optional() }),
+      v,
+      "Invalid campaign settings:"
+    );
+  },
+  // Account daily limit is 1–50 (the CLI cannot change it above the server ceiling).
+  "account.update"(v) {
+    check(
+      z.object({ dailyLimit: int().min(1).max(50, "daily limit must be 1\u201350").optional() }),
+      v,
+      "Invalid account update:"
+    );
+  },
+  // Warmup hard caps: sends 1–50 (MS is really 1–5, enforced server-side by provider),
+  // receives 6–10, reply rate 0–100.
+  "warmup.settings"(v) {
+    check(
+      z.object({
+        sendTarget: int().min(1).max(50, "warmup send target must be 1\u201350 (MS accounts cap at 5)").optional(),
+        receiveTarget: int().min(6).max(10, "warmup receive target must be 6\u201310").optional(),
+        replyRate: int().min(0).max(100, "reply rate must be 0\u2013100").optional()
+      }),
+      v,
+      "Invalid warmup settings:"
+    );
+  },
+  // AI config temperature is 0.0–1.0.
+  "ai.config"(v) {
+    check(
+      z.object({ temperature: z.coerce.number().min(0).max(1, "temperature must be 0.0\u20131.0").optional() }),
+      v,
+      "Invalid AI config:"
+    );
+  }
+};
+
+// src/util.ts
+import { readFileSync as readFileSync2 } from "fs";
+function splitCsv(s) {
+  if (!s) return void 0;
+  const parts = s.split(",").map((x) => x.trim()).filter(Boolean);
+  return parts.length ? parts : void 0;
+}
+function parseJsonOpt(s) {
+  if (!s) return void 0;
+  try {
+    return JSON.parse(s);
+  } catch {
+    fail(`invalid JSON: ${s.slice(0, 60)}`);
+  }
+}
+function loadJsonFile(path) {
+  try {
+    const raw = path === "-" ? readFileSync2(0, "utf8") : readFileSync2(path, "utf8");
+    return JSON.parse(raw);
+  } catch (e) {
+    fail(`could not read JSON ${path === "-" ? "from stdin" : `file ${path}`}: ${e?.message || e}`);
+  }
+}
+function timeToMinutes(s) {
+  if (!s) return void 0;
+  const m = /^(\d{1,2})(?::(\d{2}))?$/.exec(s.trim());
+  if (!m) fail(`invalid time "${s}" (use HH:MM, e.g. 09:00)`);
+  const h = Number(m[1]);
+  const min = m[2] ? Number(m[2]) : 0;
+  if (h > 23 || min > 59) fail(`invalid time "${s}"`);
+  return h * 60 + min;
+}
+var DAY_BITS = {
+  mon: 1,
+  tue: 2,
+  wed: 4,
+  thu: 8,
+  fri: 16,
+  sat: 32,
+  sun: 64
+};
+function daysToBitmask(s) {
+  if (!s) return void 0;
+  const low = s.trim().toLowerCase();
+  if (low === "weekdays") return 31;
+  if (low === "all" || low === "everyday") return 127;
+  let mask = 0;
+  for (const d of low.split(",").map((x) => x.trim()).filter(Boolean)) {
+    const bit = DAY_BITS[d.slice(0, 3)];
+    if (bit === void 0) fail(`invalid day "${d}" (use mon,tue,wed,thu,fri,sat,sun)`);
+    mask |= bit;
+  }
+  return mask || void 0;
+}
+
+// src/core/registry.ts
+function snake(s) {
+  return s.replace(/[A-Z]/g, (m) => "_" + m.toLowerCase());
+}
+function kebab(s) {
+  return s.replace(/[A-Z]/g, (m) => "-" + m.toLowerCase());
+}
+function camelOfFlag(flag) {
+  const long = flag.replace(/^--/, "").replace(/\s+.*$/, "");
+  return long.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+function coerce(p, v) {
+  if (v === void 0 || v === null || v === "") return void 0;
+  switch (p.type) {
+    case "number":
+      return typeof v === "number" ? v : Number(v);
+    case "csv":
+      return Array.isArray(v) ? v : splitCsv(String(v));
+    case "json":
+      return typeof v === "string" ? parseJsonOpt(v) : v;
+    case "jsonfile":
+      return typeof v === "string" ? loadJsonFile(v) : v;
+    case "minutes":
+      return typeof v === "number" ? v : timeToMinutes(String(v));
+    case "days":
+      return typeof v === "number" ? v : daysToBitmask(String(v));
+    default:
+      return v;
+  }
+}
+function appendQuery(path, query) {
+  const parts = [];
+  for (const [k, v] of Object.entries(query)) {
+    if (v === void 0 || v === null || v === "") continue;
+    parts.push(`${encodeURIComponent(k)}=${encodeURIComponent(String(v))}`);
+  }
+  if (!parts.length) return path;
+  return path + (path.includes("?") ? "&" : "?") + parts.join("&");
+}
+function assemble(def, values) {
+  let path = def.path;
+  const query = {};
+  const body = {};
+  let bodyRoot;
+  let hasRoot = false;
+  let fileParam;
+  let fileValue;
+  for (const p of def.params ?? []) {
+    if (p.type === "file") {
+      const fv = values[p.name];
+      if (fv !== void 0) {
+        fileParam = p;
+        fileValue = String(fv);
+      }
+      continue;
+    }
+    if (p.type === "boolean") {
+      const raw = values[p.name];
+      if (!p.always && !raw) continue;
+      const bv = p.invert ? !raw : !!raw;
+      const bloc = p.loc ?? (def.method === "GET" ? "query" : "body");
+      if (bloc === "query") query[p.apiName ?? snake(p.name)] = bv;
+      else if (bloc === "bodyRoot") {
+        bodyRoot = bv;
+        hasRoot = true;
+      } else body[p.apiName ?? snake(p.name)] = bv;
+      continue;
+    }
+    const val = coerce(p, values[p.name]);
+    if (val === void 0) continue;
+    const loc = p.loc ?? (p.positional ? "path" : def.method === "GET" ? "query" : "body");
+    if (loc === "path") {
+      path = path.replace(`:${p.name}`, encodeURIComponent(String(val)));
+      if (p.echoBody) body[p.apiName ?? snake(p.name)] = val;
+    } else if (loc === "query") {
+      query[p.apiName ?? snake(p.name)] = val;
+    } else if (loc === "bodyRoot") {
+      bodyRoot = val;
+      hasRoot = true;
+    } else {
+      body[p.apiName ?? snake(p.name)] = val;
+    }
+  }
+  return { path, query, body: hasRoot ? bodyRoot : body, fileParam, fileValue };
+}
+async function runCommand(def, values, ctx2) {
+  const a = assemble(def, values);
+  if (def.upload && a.fileValue) {
+    const fields = {};
+    for (const [k, v] of Object.entries(a.body)) fields[k] = String(v);
+    if (!("name" in fields)) fields.name = a.fileValue.split(/[\\/]/).pop() || a.fileValue;
+    const res2 = await ctx2.api.upload(a.path, a.fileValue, fields);
+    out(ctx2, res2, def.output?.columns, def.output?.headers, def.output?.noun);
+    if (def.success) ok(def.success);
+    return res2;
+  }
+  const mpath = appendQuery(a.path, a.query);
+  let res;
+  if (def.method === "GET") {
+    if (def.paged) {
+      const page = Number(values.page ?? 1);
+      const limit = Number(values.limit ?? 50);
+      res = await ctx2.api.paged(a.path, a.query, page, limit, !!values.all);
+    } else {
+      res = await ctx2.api.get(a.path, a.query);
+    }
+  } else if (def.method === "DELETE") {
+    res = await ctx2.api.del(a.path, a.query);
+  } else if (def.method === "POST") {
+    res = await ctx2.api.post(mpath, a.body);
+  } else if (def.method === "PUT") {
+    res = await ctx2.api.put(mpath, a.body);
+  } else {
+    res = await ctx2.api.patch(mpath, a.body);
+  }
+  out(ctx2, res, def.output?.columns, def.output?.headers, def.output?.noun);
+  if (def.success) ok(def.success);
+  return res;
+}
+function flagFor(p) {
+  const base = `--${kebab(p.name)}`;
+  if (p.type === "boolean" || p.type === "tri") return base;
+  const ph = p.type === "number" || p.type === "minutes" || p.type === "days" ? "<n>" : p.type === "csv" ? "<a,b,c>" : p.type === "file" ? "<path>" : "<value>";
+  return `${base} ${ph}`;
+}
+function addCommand(parent, def, ctxFactory) {
+  const cmd = parent.command(def.name).description(def.summary);
+  const positionals = (def.params ?? []).filter((p) => p.positional);
+  const options = (def.params ?? []).filter((p) => !p.positional);
+  for (const p of positionals) {
+    cmd.argument(p.required === false ? `[${snake(p.name)}]` : `<${snake(p.name)}>`, p.desc);
+  }
+  for (const p of options) {
+    if (p.required && p.type !== "boolean" && p.type !== "tri") {
+      cmd.requiredOption(flagFor(p), p.desc, p.default);
+    } else {
+      cmd.option(flagFor(p), p.desc, p.default);
+    }
+    if (p.type === "tri" && p.negFlag) cmd.option(p.negFlag, `(opposite of --${kebab(p.name)})`);
+  }
+  if (def.paged) {
+    cmd.option("--page <n>", "page number", "1");
+    cmd.option("--limit <n>", "rows per page", "50");
+    cmd.option("--all", "fetch every page");
+  }
+  if (def.confirm) cmd.option("--yes", "skip the confirmation prompt");
+  cmd.action(async (...args) => {
+    const command = args.pop();
+    const opts = args.pop() ?? {};
+    const posVals = args;
+    const ctx2 = ctxFactory();
+    const values = {};
+    positionals.forEach((p, i) => values[p.name] = posVals[i]);
+    for (const p of options) {
+      if (p.type === "tri") {
+        const pos = opts[p.name];
+        const neg = p.negFlag ? opts[camelOfFlag(p.negFlag)] : void 0;
+        values[p.name] = pos ? true : neg ? false : void 0;
+      } else {
+        values[p.name] = opts[p.name];
+      }
+    }
+    if (def.paged) {
+      values.page = opts.page;
+      values.limit = opts.limit;
+      values.all = opts.all;
+    }
+    if (def.validate) validators[def.validate]?.(values);
+    if (def.confirm && !await confirmAction(def.confirm, { yes: opts.yes, dryRun: ctx2.dryRun })) return;
+    await runCommand(def, values, ctx2);
+  });
+}
+function registerGroup(program2, group, ctxFactory) {
+  const g = program2.command(group.name).description(group.summary);
+  for (const c of group.commands) addCommand(g, c, ctxFactory);
+  for (const sg of group.subgroups ?? []) {
+    const s = g.command(sg.name).description(sg.summary);
+    for (const c of sg.commands) addCommand(s, c, ctxFactory);
+  }
+}
+
+// src/defs/campaigns.ts
+var REPLY_COLS = ["id", "from_email", "subject", "sentiment_category", "lead_status", "read_at"];
+var REPLY_HDRS = ["ID", "From", "Subject", "Sentiment", "Status", "Read"];
+var replyFilters = [
+  { name: "interested", type: "tri", negFlag: "--not-interested", apiName: "is_interested", desc: "only interested / not-interested replies" },
+  { name: "read", type: "tri", negFlag: "--unread", apiName: "is_read", desc: "only read / unread replies" },
+  { name: "ooo", type: "tri", negFlag: "--exclude-ooo", apiName: "is_out_of_office", desc: "only / exclude out-of-office auto-replies" },
+  { name: "sentiment", apiName: "sentiment_category", desc: "interested|not_interested|not_now|out_of_office|referral|question|unsubscribe|bounce" },
+  { name: "status", apiName: "lead_status", desc: "lead status: none|interested|not_interested|meeting_booked|follow_up|closed_won|closed_lost" },
+  { name: "search", desc: "match sender/subject/body" },
+  { name: "since", desc: "ISO datetime lower bound" },
+  { name: "archived", type: "boolean", apiName: "include_archived", desc: "include archived replies" }
+];
+var campaigns = {
+  name: "campaigns",
+  summary: "Campaigns \u2014 create, schedule, launch, monitor. A campaign sends a sequence to its contacts from its assigned accounts, on a schedule.",
+  commands: [
+    {
+      name: "list",
+      summary: "List campaigns (draft/active/paused/completed/archived).",
+      method: "GET",
+      path: "/campaigns",
+      paged: true,
+      params: [
+        { name: "status", desc: "draft|active|paused|completed|archived" },
+        { name: "tag", desc: "filter by tag" },
+        { name: "search", desc: "match campaign name" }
+      ],
+      output: { columns: ["id", "name", "status", "daily_send_limit", "created_at"], headers: ["ID", "Name", "Status", "Daily", "Created"], noun: "campaign(s)" }
+    },
+    {
+      name: "get",
+      summary: "Show one campaign in full.",
+      method: "GET",
+      path: "/campaigns/:id",
+      params: [{ name: "id", positional: true, desc: "campaign id" }]
+    },
+    {
+      name: "create",
+      summary: "Create a campaign (starts in draft). Set the schedule here or via `update`; add a sequence + contacts + accounts before activating.",
+      method: "POST",
+      path: "/campaigns",
+      params: [
+        { name: "name", required: true, desc: "campaign name" },
+        { name: "dailyLimit", type: "number", apiName: "daily_send_limit", desc: "per-campaign emails/day (default 50, no upper cap)" },
+        { name: "timezone", desc: "IANA tz for the send window (default America/New_York)" },
+        { name: "startTime", type: "minutes", apiName: "send_start_hour", desc: "send window start, HH:MM (default 09:00)" },
+        { name: "endTime", type: "minutes", apiName: "send_end_hour", desc: "send window end, HH:MM (default 17:00)" },
+        { name: "days", type: "days", apiName: "send_days", desc: "sending days e.g. mon,tue,fri or 'weekdays' (default weekdays)" },
+        { name: "tags", type: "csv", desc: "comma-separated tags" }
+      ],
+      validate: "campaign.save",
+      success: "Campaign created (draft)."
+    },
+    {
+      name: "update",
+      summary: "Update a draft/paused campaign's name, daily limit, or schedule (only fields you pass change). Use activate/pause to change status.",
+      method: "PATCH",
+      path: "/campaigns/:id",
+      params: [
+        { name: "id", positional: true, desc: "campaign id" },
+        { name: "name", desc: "new name" },
+        { name: "dailyLimit", type: "number", apiName: "daily_send_limit", desc: "per-campaign emails/day" },
+        { name: "timezone", desc: "IANA tz" },
+        { name: "startTime", type: "minutes", apiName: "send_start_hour", desc: "send window start HH:MM" },
+        { name: "endTime", type: "minutes", apiName: "send_end_hour", desc: "send window end HH:MM" },
+        { name: "days", type: "days", apiName: "send_days", desc: "sending days e.g. mon,tue,fri" }
+      ],
+      validate: "campaign.save",
+      success: "Updated."
+    },
+    {
+      name: "activate",
+      summary: "Activate a campaign and START SENDING. Runs preflight first (needs a sequence, contacts, and \u22651 connected non-paused account).",
+      method: "POST",
+      path: "/campaigns/:id/activate",
+      confirm: "Activate this campaign and START SENDING emails?",
+      params: [{ name: "id", positional: true, desc: "campaign id" }],
+      success: "Activated."
+    },
+    {
+      name: "pause",
+      summary: "Pause an active campaign (cancels pending sends, resets scheduled contacts to pending).",
+      method: "POST",
+      path: "/campaigns/:id/pause",
+      params: [{ name: "id", positional: true, desc: "campaign id" }],
+      success: "Paused."
+    },
+    {
+      name: "archive",
+      summary: "Archive a campaign (must not be active).",
+      method: "POST",
+      path: "/campaigns/:id/archive",
+      params: [{ name: "id", positional: true, desc: "campaign id" }],
+      success: "Archived."
+    },
+    {
+      name: "unarchive",
+      summary: "Unarchive a campaign (returns it to paused).",
+      method: "POST",
+      path: "/campaigns/:id/unarchive",
+      params: [{ name: "id", positional: true, desc: "campaign id" }],
+      success: "Unarchived."
+    },
+    {
+      name: "duplicate",
+      summary: "Duplicate a campaign (copies sequence + settings, not contacts).",
+      method: "POST",
+      path: "/campaigns/:id/duplicate",
+      params: [{ name: "id", positional: true, desc: "campaign id" }],
+      success: "Duplicated."
+    },
+    {
+      name: "delete",
+      summary: "Delete a campaign permanently.",
+      method: "DELETE",
+      path: "/campaigns/:id",
+      confirm: "Delete this campaign permanently?",
+      params: [{ name: "id", positional: true, desc: "campaign id" }],
+      success: "Deleted."
+    },
+    {
+      name: "bulk-action",
+      summary: "Apply one action (pause/archive/delete) to many campaigns.",
+      method: "POST",
+      path: "/campaigns/bulk-action",
+      confirm: "Apply this action to all listed campaigns?",
+      params: [
+        { name: "ids", type: "csv", required: true, apiName: "campaign_ids", desc: "comma-separated campaign ids" },
+        { name: "action", required: true, desc: "pause|archive|delete" }
+      ],
+      success: "Applied."
+    },
+    {
+      name: "tags",
+      summary: "Replace a campaign's tags.",
+      method: "PATCH",
+      path: "/campaigns/:id/tags",
+      params: [
+        { name: "id", positional: true, desc: "campaign id" },
+        { name: "tags", type: "csv", loc: "bodyRoot", required: true, desc: "comma-separated tags (replaces all)" }
+      ],
+      success: "Tags updated."
+    },
+    // Read-only reports
+    {
+      name: "preflight",
+      summary: "Pre-activation readiness check (what's blocking send). DNS warnings are advisory, not blocking.",
+      method: "GET",
+      path: "/campaigns/:id/preflight",
+      params: [{ name: "id", positional: true, desc: "campaign id" }]
+    },
+    {
+      name: "stats",
+      summary: "Send/open/reply/bounce summary.",
+      method: "GET",
+      path: "/campaigns/:id/stats",
+      params: [{ name: "id", positional: true, desc: "campaign id" }]
+    },
+    {
+      name: "timeseries",
+      summary: "Daily stats over a window.",
+      method: "GET",
+      path: "/campaigns/:id/stats/timeseries",
+      params: [{ name: "id", positional: true, desc: "campaign id" }, { name: "days", type: "number", default: "30", desc: "how many days back (default 30)" }]
+    },
+    {
+      name: "queue",
+      summary: "Scheduled/queued sends for the campaign.",
+      method: "GET",
+      path: "/campaigns/:id/queue",
+      params: [{ name: "id", positional: true, desc: "campaign id" }, { name: "status", desc: "pending|processing|sent|failed" }],
+      output: { columns: ["scheduled_for", "status", "error_message"], headers: ["Scheduled", "Status", "Error"], noun: "queued send(s)" }
+    },
+    {
+      name: "ab",
+      summary: "A/B variant results (winner declared at \u226530 sends/variant, >5% reply-rate gap).",
+      method: "GET",
+      path: "/campaigns/:id/ab-results",
+      params: [{ name: "id", positional: true, desc: "campaign id" }]
+    },
+    {
+      name: "step-performance",
+      summary: "Per-step reply/bounce performance.",
+      method: "GET",
+      path: "/campaigns/:id/step-performance",
+      params: [{ name: "id", positional: true, desc: "campaign id" }]
+    },
+    {
+      name: "esp",
+      summary: "ESP breakdown of the recipient list (Gmail/Outlook/other).",
+      method: "GET",
+      path: "/campaigns/:id/esp-breakdown",
+      params: [{ name: "id", positional: true, desc: "campaign id" }]
+    },
+    {
+      name: "dns",
+      summary: "SPF/DKIM/DMARC status of the assigned sending accounts.",
+      method: "GET",
+      path: "/campaigns/:id/dns-status",
+      params: [{ name: "id", positional: true, desc: "campaign id" }]
+    },
+    {
+      name: "export",
+      summary: "Export campaign contacts as CSV.",
+      method: "GET",
+      path: "/campaigns/:id/contacts/export",
+      params: [{ name: "id", positional: true, desc: "campaign id" }]
+    },
+    {
+      name: "replies",
+      summary: "List replies for one campaign, with sentiment/status filters.",
+      method: "GET",
+      path: "/campaigns/:id/replies",
+      paged: true,
+      params: [{ name: "id", positional: true, desc: "campaign id" }, ...replyFilters],
+      output: { columns: REPLY_COLS, headers: REPLY_HDRS, noun: "reply(ies)" }
+    },
+    // Account assignment
+    {
+      name: "accounts",
+      summary: "List sending accounts assigned to a campaign.",
+      method: "GET",
+      path: "/campaigns/:id/accounts",
+      params: [{ name: "id", positional: true, desc: "campaign id" }],
+      output: { columns: ["id", "email", "status", "daily_limit"], headers: ["ID", "Email", "Status", "Limit"], noun: "account(s)" }
+    },
+    {
+      name: "assign",
+      summary: "Set the campaign's sending accounts (REPLACES the current set).",
+      method: "POST",
+      path: "/campaigns/:id/accounts",
+      params: [
+        { name: "id", positional: true, echoBody: true, apiName: "campaign_id", desc: "campaign id" },
+        { name: "ids", type: "csv", required: true, apiName: "account_ids", desc: "comma-separated account ids (full replace set)" }
+      ],
+      success: "Accounts assigned."
+    },
+    {
+      name: "unassign",
+      summary: "Remove specific sending accounts from a campaign.",
+      method: "POST",
+      path: "/campaigns/:id/accounts/batch-unassign",
+      params: [
+        { name: "id", positional: true, desc: "campaign id" },
+        { name: "ids", type: "csv", required: true, apiName: "account_ids", desc: "comma-separated account ids to remove" }
+      ],
+      success: "Accounts unassigned."
+    }
+  ],
+  subgroups: [
+    {
+      name: "sequence",
+      summary: "Sequence steps \u2014 the ordered emails a campaign sends. Step 1 needs a subject; every step needs a body. Follow-ups thread as 'Re:'.",
+      commands: [
+        {
+          name: "list",
+          summary: "List a campaign's sequence steps.",
+          method: "GET",
+          path: "/campaigns/:id/sequences",
+          params: [{ name: "id", positional: true, desc: "campaign id" }],
+          output: { columns: ["id", "step_number", "subject", "variant", "delay_days"], headers: ["ID", "Step", "Subject", "Variant", "Delay(d)"], noun: "step(s)" }
+        },
+        {
+          name: "add",
+          summary: "Add one sequence step. Spintax {a|b} and {{variables}} are supported in subject/body.",
+          method: "POST",
+          path: "/sequences",
+          params: [
+            { name: "campaignId", positional: true, loc: "body", apiName: "campaign_id", desc: "campaign id" },
+            { name: "step", type: "number", required: true, apiName: "step_number", desc: "step number (1 = first email)" },
+            { name: "subject", desc: "subject line (required on step 1; follow-ups reuse the thread subject if blank)" },
+            { name: "body", required: true, desc: "email body (plain text; spintax + {{vars}} allowed)" },
+            { name: "delayDays", type: "number", apiName: "delay_days", desc: "days to wait after the previous step (min 1 on follow-ups)" },
+            { name: "delayHours", type: "number", apiName: "delay_hours", desc: "additional hours to wait" },
+            { name: "variant", desc: "A/B test variant: A, B, C, or D (default A). Same --step, different variant = the variants of that step." },
+            { name: "splitWeight", type: "number", apiName: "split_weight", desc: "A/B weight 1-100 (blank = equal split)" }
+          ],
+          validate: "sequence.add",
+          success: "Step added."
+        },
+        {
+          name: "update",
+          summary: "Update one sequence step (only fields you pass change).",
+          method: "PATCH",
+          path: "/sequences/:id",
+          params: [
+            { name: "id", positional: true, desc: "sequence step id" },
+            { name: "subject", desc: "subject line" },
+            { name: "body", desc: "email body" },
+            { name: "delayDays", type: "number", apiName: "delay_days", desc: "days after previous step" },
+            { name: "delayHours", type: "number", apiName: "delay_hours", desc: "additional hours" },
+            { name: "step", type: "number", apiName: "step_number", desc: "step number" },
+            { name: "splitWeight", type: "number", apiName: "split_weight", desc: "A/B weight 1-100" }
+          ],
+          validate: "sequence.update",
+          success: "Step updated."
+        },
+        {
+          name: "delete",
+          summary: "Delete a sequence step.",
+          method: "DELETE",
+          path: "/sequences/:id",
+          confirm: "Delete this sequence step?",
+          params: [{ name: "id", positional: true, desc: "sequence step id" }],
+          success: "Step deleted."
+        },
+        {
+          name: "test",
+          summary: "Send a test of one step from a real account to an address you choose.",
+          method: "POST",
+          path: "/campaigns/:id/sequences/:step/test",
+          params: [
+            { name: "id", positional: true, desc: "campaign id" },
+            { name: "step", positional: true, desc: "step number" },
+            { name: "account", required: true, apiName: "account_id", desc: "account id to send from" },
+            { name: "to", required: true, apiName: "to_email", desc: "where to send the test" },
+            { name: "sample", type: "json", apiName: "sample_data", desc: "sample contact JSON for {{variables}}" }
+          ],
+          success: "Test sent."
+        }
+      ]
+    },
+    {
+      name: "material",
+      summary: "Campaign materials \u2014 files/links the AI reply agent can reference or attach.",
+      commands: [
+        {
+          name: "list",
+          summary: "List a campaign's materials.",
+          method: "GET",
+          path: "/campaigns/:id/materials",
+          params: [{ name: "id", positional: true, desc: "campaign id" }],
+          output: { columns: ["id", "name", "type", "ai_enabled", "attachable"], headers: ["ID", "Name", "Type", "AI", "Attach"], noun: "material(s)" }
+        },
+        {
+          name: "link",
+          summary: "Attach a URL as a material.",
+          method: "POST",
+          path: "/campaigns/:id/materials/link",
+          params: [
+            { name: "id", positional: true, desc: "campaign id" },
+            { name: "name", required: true, desc: "display name" },
+            { name: "linkUrl", apiName: "url", required: true, desc: "link URL" }
+          ],
+          success: "Linked."
+        },
+        {
+          name: "upload",
+          summary: "Upload a file material (PDF/DOCX/TXT/CSV/PNG/JPEG).",
+          method: "POST",
+          path: "/campaigns/:id/materials/upload",
+          upload: true,
+          params: [
+            { name: "id", positional: true, desc: "campaign id" },
+            { name: "file", type: "file", positional: true, desc: "path to the file" },
+            { name: "name", desc: "material name (defaults to filename)" }
+          ],
+          success: "Uploaded."
+        },
+        {
+          name: "download",
+          summary: "Get a short-lived signed download URL for a material.",
+          method: "GET",
+          path: "/materials/:id/download",
+          params: [{ name: "id", positional: true, desc: "material id" }]
+        },
+        {
+          name: "update",
+          summary: "Update a material's name / AI / attachable flags.",
+          method: "PATCH",
+          path: "/materials/:id",
+          params: [
+            { name: "id", positional: true, desc: "material id" },
+            { name: "name", desc: "new name" },
+            { name: "aiEnabled", type: "tri", negFlag: "--ai-disabled", apiName: "ai_enabled", desc: "let the AI reply agent use this material" },
+            { name: "attachable", type: "tri", negFlag: "--not-attachable", apiName: "attachable", desc: "allow attaching this file to replies" }
+          ],
+          success: "Updated."
+        },
+        {
+          name: "delete",
+          summary: "Delete a material.",
+          method: "DELETE",
+          path: "/materials/:id",
+          confirm: "Delete this material?",
+          params: [{ name: "id", positional: true, desc: "material id" }],
+          success: "Deleted."
+        }
+      ]
+    }
+  ]
+};
+
+// src/defs/accounts.ts
+var accounts = {
+  name: "accounts",
+  summary: "Sending accounts (mailboxes). Connect/reconnect happens in the app; here you list, inspect, edit, scan, and remove them.",
+  commands: [
+    {
+      name: "list",
+      summary: "List sending accounts with operational filters.",
+      method: "GET",
+      path: "/accounts",
+      paged: true,
+      params: [
+        { name: "status", desc: "connected|connecting|disconnected|error" },
+        { name: "domain", desc: "filter by sending domain" },
+        { name: "tag", desc: "filter by tag" },
+        { name: "search", desc: "match email" },
+        { name: "minBounceRate", type: "number", apiName: "min_bounce_rate", desc: "min bounce rate %, 0\u2013100 (e.g. 3 = 3%)" },
+        { name: "maxBounceRate", type: "number", apiName: "max_bounce_rate", desc: "max bounce rate %, 0\u2013100 (e.g. 5 = 5%)" },
+        { name: "reputation", desc: "tier (just health_score buckets): excellent 85+ | good 65-84 | fair 40-64 | low <40" },
+        { name: "warmupEnabled", type: "tri", negFlag: "--warmup-off", apiName: "warmup_enabled", desc: "only warming / only not-warming accounts" }
+      ],
+      output: { columns: ["email", "status", "daily_limit", "health_score", "bounce_count", "total_sent", "warmup_enabled"], headers: ["Email", "Status", "Limit", "Score", "Bounces", "Sent", "Warmup"], noun: "account(s)" }
+    },
+    {
+      name: "get",
+      summary: "Show one account in full.",
+      method: "GET",
+      path: "/accounts/:id",
+      params: [{ name: "id", positional: true, desc: "account id" }]
+    },
+    {
+      name: "stats",
+      summary: "Sending stats for one account.",
+      method: "GET",
+      path: "/accounts/:id/stats",
+      params: [{ name: "id", positional: true, desc: "account id" }]
+    },
+    {
+      name: "update",
+      summary: "Edit an account: sender name, daily limit (1\u201350), pause state, or tags.",
+      method: "PATCH",
+      path: "/accounts/:id",
+      params: [
+        { name: "id", positional: true, desc: "account id" },
+        { name: "senderName", apiName: "sender_name", desc: "the From display name" },
+        { name: "dailyLimit", type: "number", apiName: "daily_limit", desc: "emails/day, 1\u201350 (default 5)" },
+        { name: "paused", type: "tri", negFlag: "--active", apiName: "is_paused", desc: "pause (stop sending) / re-activate the account" },
+        { name: "tags", type: "csv", desc: "replace the account's tags" }
+      ],
+      validate: "account.update",
+      success: "Account updated."
+    },
+    {
+      name: "bulk-action",
+      summary: "Apply one action (pause/unpause/delete) to up to 200 accounts.",
+      method: "POST",
+      path: "/accounts/bulk-action",
+      confirm: "Apply this action to all listed accounts?",
+      params: [
+        { name: "ids", type: "csv", required: true, apiName: "account_ids", desc: "comma-separated account ids (1\u2013200)" },
+        { name: "action", required: true, desc: "pause|unpause|delete" }
+      ],
+      success: "Applied."
+    },
+    {
+      name: "dns-check",
+      summary: "Run an SPF/DKIM/DMARC check on the account's sending domain.",
+      method: "POST",
+      path: "/accounts/:id/dns-check",
+      params: [{ name: "id", positional: true, desc: "account id" }],
+      success: "DNS check run."
+    },
+    {
+      name: "delete",
+      summary: "Delete (disconnect) an account.",
+      method: "DELETE",
+      path: "/accounts/:id",
+      confirm: "Delete this account?",
+      params: [{ name: "id", positional: true, desc: "account id" }],
+      success: "Deleted."
+    }
+  ]
+};
+
+// src/defs/leads.ts
+var LEAD_COLS = ["id", "email", "first_name", "company", "status"];
+var LEAD_HDRS = ["ID", "Email", "First", "Company", "Status"];
+var leadFields = [
+  { name: "firstName", apiName: "first_name", desc: "first name" },
+  { name: "lastName", apiName: "last_name", desc: "last name" },
+  { name: "company", desc: "company name" },
+  { name: "title", desc: "job title" },
+  { name: "linkedin", desc: "LinkedIn URL" },
+  { name: "website", desc: "company website (used by AI web-scrape enrichment)" },
+  { name: "customFields", type: "json", apiName: "custom_fields", desc: "JSON object of custom fields (merged, never overwritten)" }
+];
+var leads = {
+  name: "leads",
+  summary: "Leads / contacts. A contact belongs to a campaign; its assigned sending account is fixed once and never changes.",
+  commands: [
+    {
+      name: "list",
+      summary: "List the leads in a campaign.",
+      method: "GET",
+      path: "/campaigns/:campaign/leads",
+      paged: true,
+      params: [
+        { name: "campaign", positional: true, desc: "campaign id" },
+        { name: "status", desc: "pending|scheduled|active|completed|replied|bounced|failed|unsubscribed|won|lost|..." },
+        { name: "search", desc: "match email/name/company" }
+      ],
+      output: { columns: LEAD_COLS, headers: LEAD_HDRS, noun: "lead(s)" }
+    },
+    {
+      name: "search",
+      summary: "Search leads across the whole workspace.",
+      method: "GET",
+      path: "/leads/search",
+      paged: true,
+      params: [
+        { name: "q", required: true, desc: "email, name, or company" },
+        { name: "campaign", apiName: "campaign_id", desc: "restrict to one campaign" },
+        { name: "status", desc: "contact status" }
+      ],
+      output: { columns: LEAD_COLS, headers: LEAD_HDRS, noun: "lead(s)" }
+    },
+    {
+      name: "get",
+      summary: "Show one lead.",
+      method: "GET",
+      path: "/leads/:id",
+      params: [{ name: "id", positional: true, desc: "lead id" }]
+    },
+    {
+      name: "add",
+      summary: "Add one lead to a campaign.",
+      method: "POST",
+      path: "/leads",
+      params: [
+        { name: "campaign", positional: true, loc: "body", apiName: "campaign_id", desc: "campaign id" },
+        { name: "email", required: true, desc: "lead email" },
+        ...leadFields
+      ],
+      success: "Lead added."
+    },
+    {
+      name: "upsert",
+      summary: "Create or update a lead by email within a campaign.",
+      method: "POST",
+      path: "/leads/upsert",
+      params: [
+        { name: "campaign", positional: true, loc: "body", apiName: "campaign_id", desc: "campaign id" },
+        { name: "email", required: true, desc: "lead email (match key)" },
+        ...leadFields
+      ],
+      success: "Lead upserted."
+    },
+    {
+      name: "bulk-add",
+      summary: "Bulk-add leads to a campaign from a JSON file (max 10,000).",
+      method: "POST",
+      path: "/leads/bulk",
+      params: [
+        { name: "campaign", positional: true, loc: "body", apiName: "campaign_id", desc: "campaign id" },
+        { name: "file", type: "jsonfile", loc: "body", apiName: "leads", required: true, desc: "path to a JSON array of lead objects (or - to read from stdin / a pipe)" }
+      ],
+      success: "Leads bulk-added."
+    },
+    {
+      name: "update",
+      summary: "Update a lead (only fields you pass change).",
+      method: "PATCH",
+      path: "/leads/:id",
+      params: [
+        { name: "id", positional: true, desc: "lead id" },
+        { name: "email", desc: "new email" },
+        { name: "status", desc: "contact status" },
+        ...leadFields
+      ],
+      success: "Lead updated."
+    },
+    {
+      name: "delete",
+      summary: "Delete a lead.",
+      method: "DELETE",
+      path: "/leads/:id",
+      confirm: "Delete this lead?",
+      params: [{ name: "id", positional: true, desc: "lead id" }],
+      success: "Deleted."
+    },
+    {
+      name: "bulk-status",
+      summary: "Set the status on many leads at once.",
+      method: "PATCH",
+      path: "/leads/bulk-status",
+      params: [
+        { name: "ids", type: "csv", required: true, apiName: "lead_ids", desc: "comma-separated lead ids" },
+        { name: "status", required: true, desc: "new contact status" }
+      ],
+      success: "Status updated."
+    },
+    {
+      name: "bulk-delete",
+      summary: "Bulk-delete contacts from a campaign.",
+      method: "POST",
+      path: "/campaigns/:campaign/contacts/bulk-delete",
+      confirm: "Delete these contacts?",
+      params: [
+        { name: "campaign", positional: true, desc: "campaign id" },
+        { name: "ids", type: "csv", required: true, apiName: "contact_ids", desc: "comma-separated contact ids" }
+      ],
+      success: "Contacts deleted."
+    },
+    {
+      name: "retry",
+      summary: "Retry failed contacts in a campaign (omit --ids for all failed).",
+      method: "POST",
+      path: "/campaigns/:campaign/contacts/retry",
+      params: [
+        { name: "campaign", positional: true, desc: "campaign id" },
+        { name: "ids", type: "csv", apiName: "contact_ids", desc: "specific contact ids (optional)" }
+      ],
+      success: "Retrying."
+    },
+    {
+      name: "unsubscribe",
+      summary: "Unsubscribe a lead (adds to suppression).",
+      method: "POST",
+      path: "/leads/:id/unsubscribe",
+      params: [{ name: "id", positional: true, desc: "lead id" }],
+      success: "Unsubscribed."
+    },
+    {
+      name: "emails",
+      summary: "List emails sent to a lead.",
+      method: "GET",
+      path: "/leads/:id/emails",
+      params: [{ name: "id", positional: true, desc: "lead id" }]
+    },
+    {
+      name: "replies",
+      summary: "List replies from a lead.",
+      method: "GET",
+      path: "/leads/:id/replies",
+      params: [{ name: "id", positional: true, desc: "lead id" }],
+      output: { columns: ["from_email", "subject", "sentiment_category", "received_at"], headers: ["From", "Subject", "Sentiment", "Received"], noun: "reply(ies)" }
+    },
+    {
+      name: "timeline",
+      summary: "Full activity timeline for a contact.",
+      method: "GET",
+      path: "/contacts/:id/timeline",
+      params: [{ name: "id", positional: true, desc: "contact id" }]
+    },
+    {
+      name: "mark-replied",
+      summary: "Manually mark a contact as replied (stops follow-ups).",
+      method: "POST",
+      path: "/contacts/:id/mark-replied",
+      params: [{ name: "id", positional: true, desc: "contact id" }],
+      success: "Marked replied."
+    }
+  ]
+};
+
+// src/defs/inbox.ts
+var REPLY_COLS2 = ["id", "from_email", "subject", "sentiment_category", "lead_status", "read_at"];
+var REPLY_HDRS2 = ["ID", "From", "Subject", "Sentiment", "Status", "Read"];
+var inbox = {
+  name: "inbox",
+  summary: "Inbox / replies. Sentiment is AI-classified (8 categories); lead status is an editable tag. The AI reply agent only ever drafts \u2014 it never auto-sends.",
+  commands: [
+    {
+      name: "list",
+      summary: "List replies with sentiment / status filters.",
+      method: "GET",
+      path: "/replies",
+      paged: true,
+      params: [
+        { name: "campaign", apiName: "campaign_id", desc: "restrict to one campaign" },
+        { name: "interested", type: "tri", negFlag: "--not-interested", apiName: "is_interested", desc: "only interested / not-interested" },
+        { name: "read", type: "tri", negFlag: "--unread", apiName: "is_read", desc: "only read / unread" },
+        { name: "ooo", type: "tri", negFlag: "--exclude-ooo", apiName: "is_out_of_office", desc: "only / exclude out-of-office" },
+        { name: "sentiment", apiName: "sentiment_category", desc: "interested|not_interested|not_now|out_of_office|referral|question|unsubscribe|bounce" },
+        { name: "status", apiName: "lead_status", desc: "lead status filter" },
+        { name: "search", desc: "match sender/subject/body" },
+        { name: "since", desc: "ISO datetime lower bound" },
+        { name: "archived", type: "boolean", apiName: "include_archived", desc: "include archived" }
+      ],
+      output: { columns: REPLY_COLS2, headers: REPLY_HDRS2, noun: "reply(ies)" }
+    },
+    {
+      name: "get",
+      summary: "Show one reply.",
+      method: "GET",
+      path: "/replies/:id",
+      params: [{ name: "id", positional: true, desc: "reply id" }]
+    },
+    {
+      name: "thread",
+      summary: "Show the full conversation thread for a reply.",
+      method: "GET",
+      path: "/replies/:id/thread",
+      params: [{ name: "id", positional: true, desc: "reply id" }]
+    },
+    {
+      name: "reply",
+      summary: "Send a reply in the thread.",
+      method: "POST",
+      path: "/replies/:id/reply",
+      params: [
+        { name: "id", positional: true, desc: "reply id" },
+        { name: "body", required: true, desc: "reply text" },
+        { name: "cc", type: "csv", desc: "comma-separated CC addresses" }
+      ],
+      success: "Reply sent."
+    },
+    {
+      name: "interested",
+      summary: "Mark a reply interested (or --not-interested).",
+      method: "PATCH",
+      path: "/replies/:id/interested",
+      params: [
+        { name: "id", positional: true, desc: "reply id" },
+        { name: "notInterested", type: "boolean", apiName: "is_interested", invert: true, always: true, desc: "mark NOT interested instead" }
+      ],
+      success: "Updated."
+    },
+    {
+      name: "read",
+      summary: "Mark a reply read (or --unread).",
+      method: "PATCH",
+      path: "/replies/:id/read",
+      params: [
+        { name: "id", positional: true, desc: "reply id" },
+        { name: "unread", type: "boolean", apiName: "is_read", invert: true, always: true, desc: "mark unread instead" }
+      ],
+      success: "Updated."
+    },
+    {
+      name: "status",
+      summary: "Set the lead status on a reply (none|interested|not_interested|meeting_booked|follow_up|closed_won|closed_lost, or a custom slug).",
+      method: "PATCH",
+      path: "/replies/:id/status",
+      params: [
+        { name: "id", positional: true, desc: "reply id" },
+        { name: "status", required: true, desc: "lead status" }
+      ],
+      success: "Status set."
+    },
+    {
+      name: "archive",
+      summary: "Archive a reply (archives the whole conversation).",
+      method: "POST",
+      path: "/replies/:id/archive",
+      params: [{ name: "id", positional: true, desc: "reply id" }],
+      success: "Archived."
+    },
+    {
+      name: "delete",
+      summary: "Delete a reply.",
+      method: "DELETE",
+      path: "/replies/:id",
+      confirm: "Delete this reply?",
+      params: [{ name: "id", positional: true, desc: "reply id" }],
+      success: "Deleted."
+    },
+    {
+      name: "draft",
+      summary: "Save a human draft on a reply (does not send).",
+      method: "PUT",
+      path: "/replies/:id/draft",
+      params: [
+        { name: "id", positional: true, desc: "reply id" },
+        { name: "body", apiName: "draft", required: true, desc: "draft text to save" }
+      ],
+      success: "Draft saved."
+    },
+    {
+      name: "ai-regenerate",
+      summary: "Regenerate the AI draft for a reply (draft only \u2014 never sends).",
+      method: "POST",
+      path: "/replies/:id/ai-regenerate",
+      params: [{ name: "id", positional: true, desc: "reply id" }]
+    },
+    {
+      name: "ai-discard",
+      summary: "Discard the AI draft for a reply.",
+      method: "POST",
+      path: "/replies/:id/ai-discard",
+      params: [{ name: "id", positional: true, desc: "reply id" }]
+    },
+    {
+      name: "attachment",
+      summary: "Fetch reply attachment metadata (signed download URL).",
+      method: "GET",
+      path: "/replies/:reply/attachments/:attachment",
+      params: [
+        { name: "reply", positional: true, desc: "reply id" },
+        { name: "attachment", positional: true, desc: "attachment id" }
+      ]
+    },
+    { name: "mark-all-read", summary: "Mark every reply as read.", method: "POST", path: "/inbox/mark-all-read", success: "All marked read." },
+    { name: "unread-count", summary: "Count unread replies.", method: "GET", path: "/inbox/unread-count" }
+  ]
+};
+
+// src/defs/warmup.ts
+var warmupSettings = [
+  { name: "sendTarget", type: "number", apiName: "daily_send_target", desc: "warmup sends/day (MS 1\u20135, Google 1\u201350)" },
+  { name: "receiveTarget", type: "number", apiName: "daily_receive_target", desc: "warmup receives/day (6\u201310)" },
+  { name: "replyRate", type: "number", apiName: "reply_rate", desc: "reply rate % (0\u2013100, default 50)" },
+  { name: "rampUp", type: "tri", negFlag: "--ramp-up-off", apiName: "ramp_up_enabled", desc: "enable / disable gradual ramp-up" },
+  { name: "rampStart", type: "number", apiName: "ramp_up_start", desc: "ramp-up starting volume" },
+  { name: "rampDays", type: "number", apiName: "ramp_up_days", desc: "days to reach full volume" }
+];
+var warmup = {
+  name: "warmup",
+  summary: "Warmup. Accounts warm cross-workspace (never same workspace); an account is campaign-ready at warmup score \u226580 AND \u22655 days warming.",
+  commands: [
+    {
+      name: "list",
+      summary: "List accounts with their warmup status.",
+      method: "GET",
+      path: "/warmup/accounts",
+      paged: true,
+      params: [{ name: "active", type: "tri", negFlag: "--inactive", apiName: "is_active", desc: "only warming / only not-warming" }],
+      output: { columns: ["id", "email", "warmup_enabled", "warmup_score"], headers: ["ID", "Email", "Enabled", "Score"], noun: "account(s)" }
+    },
+    {
+      name: "get",
+      summary: "Show one account's warmup detail.",
+      method: "GET",
+      path: "/warmup/accounts/:id",
+      params: [{ name: "id", positional: true, desc: "account id" }]
+    },
+    {
+      name: "enable",
+      summary: "Enable warmup for an account (must be connected). Optionally set targets.",
+      method: "POST",
+      path: "/warmup/accounts/:id/enable",
+      params: [{ name: "id", positional: true, desc: "account id" }, ...warmupSettings],
+      validate: "warmup.settings",
+      success: "Warmup enabled."
+    },
+    {
+      name: "disable",
+      summary: "Disable warmup for an account (cancels pending warmup sends).",
+      method: "POST",
+      path: "/warmup/accounts/:id/disable",
+      params: [{ name: "id", positional: true, desc: "account id" }],
+      success: "Warmup disabled."
+    },
+    {
+      name: "settings",
+      summary: "Update warmup targets for an account.",
+      method: "PATCH",
+      path: "/warmup/accounts/:id/settings",
+      params: [{ name: "id", positional: true, desc: "account id" }, ...warmupSettings],
+      validate: "warmup.settings",
+      success: "Warmup settings updated."
+    },
+    { name: "pool-stats", summary: "Warmup pool statistics (size, capacity, placement).", method: "GET", path: "/warmup/pool/stats" },
+    {
+      name: "history",
+      summary: "Warmup send/receive history for an account.",
+      method: "GET",
+      path: "/warmup/history/:id",
+      params: [{ name: "id", positional: true, desc: "account id" }, { name: "limit", type: "number", default: "50", desc: "rows (default 50)" }]
+    }
+  ]
+};
+
+// src/defs/blacklist.ts
+var blacklist = {
+  name: "blacklist",
+  summary: "Blocklist / do-not-contact. Suppresses sending to specific emails or whole domains.",
+  commands: [
+    {
+      name: "list",
+      summary: "List blocklisted emails and domains.",
+      method: "GET",
+      path: "/blacklist",
+      paged: true,
+      params: [
+        { name: "type", desc: "email|domain" },
+        { name: "search", desc: "match address/domain" },
+        { name: "reason", desc: "manual|bounce|complaint|unsubscribe" }
+      ],
+      output: { columns: ["email", "domain", "reason", "created_at"], headers: ["Email", "Domain", "Reason", "Added"], noun: "entr(ies)" }
+    },
+    {
+      name: "add-email",
+      summary: "Blocklist one email.",
+      method: "POST",
+      path: "/blacklist/emails",
+      params: [
+        { name: "email", positional: true, loc: "body", desc: "email to block" },
+        { name: "reason", default: "manual", desc: "manual|bounce|complaint|unsubscribe" }
+      ],
+      success: "Blocked."
+    },
+    {
+      name: "bulk-emails",
+      summary: "Blocklist many emails at once.",
+      method: "POST",
+      path: "/blacklist/emails/bulk",
+      params: [
+        { name: "emails", type: "csv", required: true, desc: "comma-separated emails" },
+        { name: "reason", default: "manual", desc: "reason for all" }
+      ],
+      success: "Blocked."
+    },
+    {
+      name: "remove-email",
+      summary: "Remove an email from the blocklist.",
+      method: "DELETE",
+      path: "/blacklist/emails/:email",
+      params: [{ name: "email", positional: true, desc: "email to unblock" }],
+      success: "Removed."
+    },
+    {
+      name: "add-domain",
+      summary: "Blocklist a whole domain.",
+      method: "POST",
+      path: "/blacklist/domains",
+      params: [
+        { name: "domain", positional: true, loc: "body", desc: "domain to block" },
+        { name: "reason", default: "manual", desc: "reason" }
+      ],
+      success: "Blocked."
+    },
+    {
+      name: "remove-domain",
+      summary: "Remove a domain from the blocklist.",
+      method: "DELETE",
+      path: "/blacklist/domains/:domain",
+      params: [{ name: "domain", positional: true, desc: "domain to unblock" }],
+      success: "Removed."
+    }
+  ]
+};
+
+// src/defs/deliverability.ts
+var deliverability = {
+  name: "deliverability",
+  summary: "Deliverability \u2014 bounces and domain health.",
+  commands: [
+    {
+      name: "bounces",
+      summary: "List bounced/failed emails with SMTP error detail.",
+      method: "GET",
+      path: "/deliverability/bounces",
+      params: [
+        { name: "campaign", apiName: "campaign_id", desc: "restrict to one campaign" },
+        { name: "severity", desc: "harmful|warning|benign" },
+        { name: "category", desc: "bounce category" },
+        { name: "since", desc: "ISO datetime lower bound" },
+        { name: "page", type: "number", default: "1", desc: "page number" },
+        { name: "pageSize", type: "number", apiName: "page_size", default: "50", desc: "rows per page" }
+      ],
+      output: { columns: ["contact_email", "severity", "category", "smtp_code", "bounced_at"], headers: ["Email", "Severity", "Category", "Code", "When"], noun: "bounce(s)" }
+    },
+    {
+      name: "bounces-summary",
+      summary: "Bounce summary over a window.",
+      method: "GET",
+      path: "/deliverability/bounces/summary",
+      params: [
+        { name: "campaign", apiName: "campaign_id", desc: "restrict to one campaign" },
+        { name: "days", type: "number", default: "30", desc: "days back (default 30)" }
+      ]
+    },
+    {
+      name: "domains",
+      summary: "Domain health list.",
+      method: "GET",
+      path: "/deliverability/domains",
+      output: { columns: ["domain", "total_accounts", "health_status"], headers: ["Domain", "Accounts", "Health"], noun: "domain(s)" }
+    },
+    {
+      name: "domain",
+      summary: "Health of one domain.",
+      method: "GET",
+      path: "/deliverability/domains/:domain",
+      params: [{ name: "domain", positional: true, desc: "domain" }]
+    },
+    {
+      name: "error-codes",
+      summary: "Reference of SMTP error codes.",
+      method: "GET",
+      path: "/deliverability/error-codes",
+      params: [{ name: "severity", desc: "filter by severity" }, { name: "category", desc: "filter by category" }]
+    }
+  ]
+};
+
+// src/defs/analytics.ts
+var analytics = {
+  name: "analytics",
+  summary: "Analytics \u2014 workspace and dashboard metrics.",
+  commands: [
+    {
+      name: "dashboard",
+      summary: "Workspace dashboard metrics.",
+      method: "GET",
+      path: "/analytics/dashboard",
+      params: [{ name: "days", type: "number", desc: "window in days, max 365 (default 14)" }]
+    },
+    {
+      name: "workspace",
+      summary: "Workspace-level analytics.",
+      method: "GET",
+      path: "/analytics/workspace",
+      params: [{ name: "days", type: "number", desc: "window in days, max 365 (default 30)" }]
+    }
+  ]
+};
+
+// src/defs/templates.ts
+var templates = {
+  name: "templates",
+  summary: "Sequence templates \u2014 reusable multi-step sequences you can save and apply to campaigns.",
+  commands: [
+    {
+      name: "list",
+      summary: "List sequence templates.",
+      method: "GET",
+      path: "/templates",
+      paged: true,
+      params: [{ name: "category", desc: "filter by category" }, { name: "search", desc: "match name" }],
+      output: { columns: ["id", "name", "category"], headers: ["ID", "Name", "Category"], noun: "template(s)" }
+    },
+    {
+      name: "get",
+      summary: "Show one template.",
+      method: "GET",
+      path: "/templates/:id",
+      params: [{ name: "id", positional: true, desc: "template id" }]
+    },
+    {
+      name: "create",
+      summary: "Create a template from a JSON sequence file.",
+      method: "POST",
+      path: "/templates",
+      params: [
+        { name: "name", required: true, desc: "template name" },
+        { name: "description", desc: "description" },
+        { name: "category", desc: "category" },
+        { name: "sequencesFile", type: "jsonfile", apiName: "sequences", required: true, desc: "path to a JSON array of sequence-step objects" },
+        { name: "tags", type: "csv", desc: "comma-separated tags" }
+      ],
+      success: "Template created."
+    },
+    {
+      name: "from-campaign",
+      summary: "Save a campaign's sequence as a template.",
+      method: "POST",
+      path: "/templates/from-campaign/:campaign",
+      params: [
+        { name: "campaign", positional: true, desc: "campaign id" },
+        { name: "name", required: true, desc: "template name" },
+        { name: "description", desc: "description" }
+      ],
+      success: "Saved as template."
+    },
+    {
+      name: "apply",
+      summary: "Apply a template's sequence to a campaign.",
+      method: "POST",
+      path: "/templates/:template/apply/:campaign",
+      params: [
+        { name: "template", positional: true, desc: "template id" },
+        { name: "campaign", positional: true, desc: "campaign id" },
+        { name: "replace", type: "boolean", desc: "replace the campaign's existing steps" }
+      ],
+      success: "Template applied."
+    },
+    {
+      name: "delete",
+      summary: "Delete a template.",
+      method: "DELETE",
+      path: "/templates/:id",
+      confirm: "Delete this template?",
+      params: [{ name: "id", positional: true, desc: "template id" }],
+      success: "Deleted."
+    }
+  ]
+};
+
+// src/defs/webhooks.ts
+var EVENTS = "email.sent, email.bounced, email.failed, email.opened, email.clicked, lead.replied, lead.unsubscribed, lead.status_changed, campaign.activated, campaign.paused, campaign.completed, account.connected, account.disconnected";
+var webhooks = {
+  name: "webhooks",
+  summary: "Outgoing webhooks \u2014 subscribe an external URL to real-time ArcSend events.",
+  commands: [
+    {
+      name: "list",
+      summary: "List webhooks.",
+      method: "GET",
+      path: "/webhooks",
+      output: { columns: ["id", "url", "events", "is_active"], headers: ["ID", "URL", "Events", "Active"], noun: "webhook(s)" }
+    },
+    {
+      name: "get",
+      summary: "Show one webhook.",
+      method: "GET",
+      path: "/webhooks/:id",
+      params: [{ name: "id", positional: true, desc: "webhook id" }]
+    },
+    {
+      name: "create",
+      summary: "Create a webhook.",
+      method: "POST",
+      path: "/webhooks",
+      params: [
+        { name: "endpoint", apiName: "url", required: true, desc: "destination URL" },
+        { name: "events", type: "csv", required: true, desc: `comma-separated. Valid: ${EVENTS}` }
+      ],
+      success: "Webhook created."
+    },
+    {
+      name: "update",
+      summary: "Update a webhook (events replace the existing set).",
+      method: "PATCH",
+      path: "/webhooks/:id",
+      params: [
+        { name: "id", positional: true, desc: "webhook id" },
+        { name: "endpoint", apiName: "url", desc: "destination URL" },
+        { name: "events", type: "csv", desc: "replacement event list" },
+        { name: "active", type: "tri", negFlag: "--inactive", apiName: "is_active", desc: "enable / disable" }
+      ],
+      success: "Webhook updated."
+    },
+    {
+      name: "delete",
+      summary: "Delete a webhook.",
+      method: "DELETE",
+      path: "/webhooks/:id",
+      confirm: "Delete this webhook?",
+      params: [{ name: "id", positional: true, desc: "webhook id" }],
+      success: "Deleted."
+    },
+    {
+      name: "test",
+      summary: "Send a test event to a webhook.",
+      method: "POST",
+      path: "/webhooks/:id/test",
+      params: [{ name: "id", positional: true, desc: "webhook id" }],
+      success: "Test sent."
+    },
+    {
+      name: "deliveries",
+      summary: "List recent delivery attempts (newest first).",
+      method: "GET",
+      path: "/webhooks/:id/deliveries",
+      params: [{ name: "id", positional: true, desc: "webhook id" }, { name: "status", desc: "pending|delivered|failed" }],
+      output: { columns: ["id", "event_type", "status", "response_code", "attempts", "created_at"], headers: ["ID", "Event", "Status", "HTTP", "Tries", "Created"], noun: "delivery(ies)" }
+    },
+    {
+      name: "replay",
+      summary: "Resend a past delivery (re-signs + re-POSTs the original payload).",
+      method: "POST",
+      path: "/webhooks/deliveries/:id/replay",
+      params: [{ name: "id", positional: true, desc: "delivery id" }],
+      success: "Replayed."
+    }
+  ]
+};
+
+// src/defs/team.ts
+var team = {
+  name: "team",
+  summary: "Team members + invitations. Roles: owner (the workspace creator, fixed), admin, member.",
+  commands: [
+    {
+      name: "members",
+      summary: "List team members.",
+      method: "GET",
+      path: "/team/members",
+      output: { columns: ["id", "email", "role", "status"], headers: ["ID", "Email", "Role", "Status"], noun: "member(s)" }
+    },
+    {
+      name: "invite",
+      summary: "Invite a member by email.",
+      method: "POST",
+      path: "/team/invitations",
+      params: [
+        { name: "email", required: true, desc: "invitee email" },
+        { name: "role", default: "member", desc: "admin|member" },
+        { name: "permissions", type: "json", desc: "permissions object as JSON" },
+        { name: "workspaces", type: "csv", apiName: "workspace_ids", desc: "comma-separated workspace ids" }
+      ],
+      success: "Invited."
+    },
+    {
+      name: "revoke-invite",
+      summary: "Revoke a pending invitation.",
+      method: "DELETE",
+      path: "/team/invitations/:id",
+      params: [{ name: "id", positional: true, desc: "invitation id" }],
+      success: "Revoked."
+    },
+    {
+      name: "set-role",
+      summary: "Set a member's role.",
+      method: "PATCH",
+      path: "/team/members/:id/role",
+      params: [{ name: "id", positional: true, desc: "member id" }, { name: "role", required: true, desc: "admin|member" }],
+      success: "Role updated."
+    },
+    {
+      name: "set-permissions",
+      summary: "Set a member's granular permissions.",
+      method: "PATCH",
+      path: "/team/members/:id/permissions",
+      params: [{ name: "id", positional: true, desc: "member id" }, { name: "permissions", type: "json", required: true, desc: "permissions object as JSON" }],
+      success: "Permissions updated."
+    },
+    {
+      name: "remove",
+      summary: "Remove a team member.",
+      method: "DELETE",
+      path: "/team/members/:id",
+      confirm: "Remove this member?",
+      params: [{ name: "id", positional: true, desc: "member id" }],
+      success: "Removed."
+    }
+  ]
+};
+
+// src/defs/workspaces.ts
+var workspaces = {
+  name: "workspaces",
+  summary: "Workspaces \u2014 the ones this key can see, plus team-workspace CRUD. Your API key is scoped to one workspace.",
+  commands: [
+    {
+      name: "list",
+      summary: "List workspaces this key can see.",
+      method: "GET",
+      path: "/workspaces",
+      output: { columns: ["id", "name"], headers: ["ID", "Workspace"], noun: "workspace(s)" }
+    },
+    {
+      name: "team-list",
+      summary: "List team workspaces.",
+      method: "GET",
+      path: "/team/workspaces",
+      output: { columns: ["id", "name", "slug"], headers: ["ID", "Name", "Slug"], noun: "workspace(s)" }
+    },
+    {
+      name: "create",
+      summary: "Create a team workspace.",
+      method: "POST",
+      path: "/team/workspaces",
+      params: [{ name: "name", required: true, desc: "workspace name" }, { name: "slug", desc: "optional slug" }],
+      success: "Workspace created."
+    },
+    {
+      name: "update",
+      summary: "Update a team workspace.",
+      method: "PATCH",
+      path: "/team/workspaces/:id",
+      params: [{ name: "id", positional: true, desc: "workspace id" }, { name: "name", desc: "new name" }, { name: "slug", desc: "new slug" }],
+      success: "Workspace updated."
+    },
+    {
+      name: "delete",
+      summary: "Delete a team workspace.",
+      method: "DELETE",
+      path: "/team/workspaces/:id",
+      confirm: "Delete this workspace?",
+      params: [{ name: "id", positional: true, desc: "workspace id" }],
+      success: "Deleted."
+    }
+  ]
+};
+
+// src/defs/index.ts
+var groups = [
+  workspaces,
+  campaigns,
+  accounts,
+  leads,
+  inbox,
+  warmup,
+  blacklist,
+  deliverability,
+  analytics,
+  templates,
+  webhooks,
+  team
+];
+
+// src/commands/auth.ts
+function registerAuth(program2) {
+  const auth = program2.command("auth").description("API key setup + identity");
+  auth.command("setup").description("Save your API key + instance URL to ~/.arcsend/config.txt (chmod 600)").requiredOption("--key <key>", "Your arc_ API key").option("--url <url>", "Instance URL", DEFAULT_URL).action((opts) => {
+    saveConfig(opts.key, opts.url);
+    ok(`Saved credentials to ${CONFIG_PATH}`);
+  });
+  auth.command("whoami").description("Show the workspace this key belongs to").action(async () => {
+    const c = ctx();
+    out(c, await c.api.get("/workspaces"), ["id", "name"], ["ID", "Workspace"], "workspace(s)");
+  });
+}
+
+// src/commands/extras.ts
+function registerExtras(program2) {
+  const campaigns2 = program2.commands.find((c) => c.name() === "campaigns");
+  const seq = campaigns2?.commands.find((c) => c.name() === "sequence");
+  if (seq) {
+    seq.command("set").description("Add an entire sequence at once from a JSON file (one create call per step).").argument("<campaign_id>").requiredOption("--file <path>", "JSON array of step objects (step_number, subject, body, delay_days, \u2026)").action(async (id, o) => {
+      const c = ctx();
+      const steps = loadJsonFile(o.file);
+      if (!Array.isArray(steps)) fail("--file must contain a JSON array of step objects");
+      for (const s of steps) await c.api.post("/sequences", { campaign_id: id, ...s });
+      ok(`Created ${steps.length} step(s).`);
+    });
+  }
+}
+
+// src/index.ts
+var program = new Command();
+program.name("arcsend").description(
+  "ArcSend \u2014 cold email automation from your terminal.\n\nAuth: run `arcsend auth setup --key <arc_...>`, or set ARCSEND_API_KEY.\nOutput: default = table; -j = JSON; --csv = spreadsheet; --fields a,b,c = pick columns.\nSafety: --dry-run previews any change without doing it. Flags work before OR after the command."
+).version("1.0.0", "-v, --version").option("-j, --json", "Output raw JSON (for scripts / pipes)").option("--csv", "Output CSV (opens in Excel/Sheets)").option("--fields <cols>", "Comma-separated columns to show on list output").option("--api-key <key>", "Override the API key for this command").option("--url <url>", "Override the instance URL for this command").option("--dry-run", "Preview any change (create/update/delete/activate/send) WITHOUT executing").option("-q, --quiet", "Suppress output; use the exit code only (for scripts)");
+function ctx() {
+  const o = program.opts();
+  const dryRun = !!o.dryRun;
+  const quiet = !!o.quiet;
+  setDryRun(dryRun);
+  setQuiet(quiet);
+  return {
+    api: new Api({ apiKey: o.apiKey, url: o.url, dryRun }),
+    json: !!o.json,
+    csv: !!o.csv,
+    quiet,
+    fields: o.fields ? String(o.fields).split(",").map((s) => s.trim()).filter(Boolean) : void 0,
+    dryRun
+  };
+}
+registerAuth(program);
+for (const g of groups) registerGroup(program, g, ctx);
+registerExtras(program);
+var HOIST_BOOL = /* @__PURE__ */ new Set(["-j", "--json", "--csv", "--dry-run", "-q", "--quiet"]);
+var HOIST_VAL = /* @__PURE__ */ new Set(["--fields"]);
+function hoist(argv) {
+  const front = [];
+  const rest = [];
+  for (let i = 0; i < argv.length; i++) {
+    const a = argv[i];
+    if (HOIST_BOOL.has(a)) front.push(a);
+    else if (HOIST_VAL.has(a)) {
+      front.push(a);
+      if (i + 1 < argv.length) front.push(argv[++i]);
+    } else if (a.startsWith("--fields=")) front.push(a);
+    else rest.push(a);
+  }
+  return [...front, ...rest];
+}
+program.parseAsync(["node", "arcsend", ...hoist(process.argv.slice(2))]).catch((e) => {
+  console.error(e?.message || e);
+  process.exit(1);
+});
+export {
+  ctx,
+  program
+};