trackrev 0.1.0 → 0.2.0

package/src/commands/links.js

@@ -0,0 +1,203 @@
+// Link management. Every command here works on the free plan too — the API
+// enforces the same 50-link cap the dashboard does.
+import { readFileSync, writeFileSync } from "node:fs";
+import { die, warn, EXIT } from "../lib/api.js";
+import { emit, emitRecord } from "../lib/output.js";
+import { confirm } from "../lib/prompt.js";
+import { intFlag } from "./analytics.js";
+
+const MAX_PAGES = 200;
+
+const LINK_COLUMNS = [
+  { header: "slug",        value: (r) => r.slug },
+  { header: "channel",     value: (r) => r.channel },
+  { header: "url",         value: (r) => r.url },
+  { header: "destination", value: (r) => r.destination?.url ?? null },
+  { header: "expires",     value: (r) => r.expires_at },
+  { header: "password",    value: (r) => r.password_protected },
+  { header: "id",          value: (r) => r.id },
+];
+
+/** Shared flag → API-field mapping for create and update. */
+function settingsFromFlags(flags) {
+  const out = {};
+  if (flags.slug !== undefined) out.slug = flags.slug;
+  if (flags.campaign !== undefined) out.campaign = flags.campaign;
+  if (flags.expires !== undefined) out.expires_at = flags.expires;
+  if (flags["max-clicks"] !== undefined) {
+    out.max_clicks = intFlag("max-clicks", flags["max-clicks"], { max: 1000000000 });
+  }
+  if (flags["expired-url"] !== undefined) out.expired_redirect_url = flags["expired-url"];
+  if (flags.password !== undefined) out.password = flags.password;
+  if (flags.retarget !== undefined) {
+    if (flags.retarget !== "on" && flags.retarget !== "off") {
+      die("--retarget takes on or off.", EXIT.USAGE);
+    }
+    out.retargeting = flags.retarget === "on";
+  }
+  if (flags["mobile-url"] !== undefined || flags["desktop-url"] !== undefined) {
+    out.targeting = {
+      ...(flags["mobile-url"] !== undefined && { mobile: flags["mobile-url"] }),
+      ...(flags["desktop-url"] !== undefined && { desktop: flags["desktop-url"] }),
+    };
+  }
+  return out;
+}
+
+export async function list({ flags, api }) {
+  const pageSize = flags.limit === undefined ? 100 : intFlag("limit", flags.limit, { max: 500 });
+  const rows = [];
+  let cursor = null;
+  let pages = 0;
+
+  do {
+    const params = new URLSearchParams({ view: "records", limit: String(pageSize) });
+    if (cursor) params.set("cursor", cursor);
+    if (flags.channel) params.set("channel", flags.channel);
+    if (flags.q) params.set("q", flags.q);
+
+    const page = await api.get(`/links?${params}`);
+    rows.push(...page.links);
+    cursor = page.next_cursor;
+
+    if (++pages >= MAX_PAGES && cursor) {
+      warn(`Stopped after ${MAX_PAGES} pages (${rows.length} links). Narrow it with --channel or --q.`);
+      break;
+    }
+  } while (flags.all && cursor);
+
+  emit(LINK_COLUMNS, rows, { links: rows }, {
+    json: flags.json,
+    empty: "No links yet. Create one with: trackrev links create",
+  });
+}
+
+export async function create({ flags, api }) {
+  if (!flags.url || !flags.name) die("--url and --name are required.", EXIT.USAGE);
+  if (!flags.smart && !(flags.channel && flags.channel.length)) {
+    die("Pass at least one --channel, or --smart for a single Smart Link.", EXIT.USAGE);
+  }
+
+  const body = {
+    url: flags.url,
+    name: flags.name,
+    channels: flags.channel ?? [],
+    smart: Boolean(flags.smart),
+    tags: flags.tag ?? [],
+    folder_id: flags.folder ?? null,
+    external: Boolean(flags.external),
+    ...settingsFromFlags(flags),
+  };
+
+  const result = await api.post("/links", body);
+  emit(LINK_COLUMNS, result.links, result, { json: flags.json });
+}
+
+export async function get({ args, flags, api }) {
+  const [key] = args;
+  const link = await api.get(`/links/${encodeURIComponent(key)}`);
+  emitRecord(
+    [
+      ["id", link.id],
+      ["slug", link.slug],
+      ["short_code", link.short_code],
+      ["url", link.url],
+      ["channel", link.channel],
+      ["destination", link.destination?.url],
+      ["name", link.destination?.name],
+      ["tags", (link.destination?.tags ?? []).join(", ")],
+      ["utm_campaign", link.utm_campaign],
+      ["utm_term", link.utm_term],
+      ["utm_content", link.utm_content],
+      ["expires_at", link.expires_at],
+      ["max_clicks", link.max_clicks],
+      ["expired_redirect_url", link.expired_redirect_url],
+      ["password", link.password_protected],
+      ["retargeting", link.retargeting_enabled],
+      ["mobile_url", link.targeting?.mobile],
+      ["desktop_url", link.targeting?.desktop],
+      ["created_at", link.created_at],
+    ],
+    link,
+    { json: flags.json },
+  );
+}
+
+export async function update({ args, flags, api }) {
+  const [id] = args;
+  const body = settingsFromFlags(flags);
+  if (flags.term !== undefined) body.utm_term = flags.term;
+  if (flags.content !== undefined) body.utm_content = flags.content;
+  if (flags.campaign !== undefined) {
+    // On update the flag means the link's utm_campaign field, not the
+    // create-time default for a whole new campaign.
+    body.utm_campaign = flags.campaign;
+    delete body.campaign;
+  }
+  if (flags["clear-password"]) body.password = null;
+  if (flags["clear-expiry"]) {
+    body.expires_at = null;
+    body.max_clicks = null;
+    body.expired_redirect_url = null;
+  }
+  if (Object.keys(body).length === 0) {
+    die("Nothing to change. Run: trackrev links update --help", EXIT.USAGE);
+  }
+
+  const link = await api.patch(`/links/${encodeURIComponent(id)}`, body);
+  emit(LINK_COLUMNS, [link], link, { json: flags.json });
+}
+
+export async function remove({ args, flags, api }) {
+  const [id] = args;
+  // Resolve first so the confirmation names the real link, and so a slug works
+  // here even though DELETE takes an id.
+  const link = await api.get(`/links/${encodeURIComponent(id)}`);
+  const ok = await confirm(
+    `Delete ${link.url} (${link.channel})? Clicks and attribution on it are lost.`,
+    { yes: flags.yes },
+  );
+  if (!ok) die("Cancelled.", EXIT.USAGE);
+
+  const result = await api.del(`/links/${encodeURIComponent(link.id)}`);
+  if (flags.json) console.log(JSON.stringify(result, null, 2));
+  else warn(`Deleted ${link.slug}.`);
+}
+
+export async function bulk({ flags, api }) {
+  if (!flags.file) die("--file is required (use - for stdin).", EXIT.USAGE);
+  let csv;
+  try {
+    csv = readFileSync(flags.file === "-" ? 0 : flags.file, "utf8");
+  } catch (err) {
+    die(`Could not read ${flags.file}: ${err.message}`, EXIT.USAGE);
+  }
+
+  const result = await api.post("/links/bulk", csv);
+  emit(
+    [
+      { header: "row",   value: (r) => r.index + 1, align: "right" },
+      { header: "ok",    value: (r) => r.ok },
+      { header: "slug",  value: (r) => r.slug ?? null },
+      { header: "error", value: (r) => r.error ?? null },
+    ],
+    result.rows,
+    result,
+    { json: flags.json },
+  );
+  if (!flags.json) warn(`${result.created} created, ${result.errors} failed.`);
+  // Nothing landed: make the shell notice.
+  if (result.errors > 0 && result.created === 0) process.exitCode = EXIT.FAIL;
+}
+
+export async function qr({ args, flags, api }) {
+  const [key] = args;
+  const size = flags.size === undefined ? 512 : intFlag("size", flags.size, { max: 2048 });
+  const svg = await api.get(`/links/${encodeURIComponent(key)}/qr?size=${size}`);
+  if (flags.out) {
+    writeFileSync(flags.out, svg);
+    warn(`Wrote ${flags.out}`);
+  } else {
+    process.stdout.write(svg);
+  }
+}

package/src/commands/me.js

@@ -0,0 +1,25 @@
+import { emitRecord } from "../lib/output.js";
+
+const metric = (m) => (m.limit === null ? `${m.used} / unlimited` : `${m.used} / ${m.limit}`);
+
+export async function me({ flags, api, auth }) {
+  const body = await api.get("/me");
+  emitRecord(
+    [
+      ["workspace", `${body.workspace.name} (${body.workspace.slug})`],
+      ["workspace_id", body.workspace.id],
+      ["domain", body.workspace.primary_domain],
+      ["attribution", `${body.workspace.attribution_model} · ${body.workspace.attribution_window}d`],
+      ["plan", body.plan.covered_by ? `${body.plan.name} (via ${body.plan.covered_by.workspace})` : body.plan.name],
+      ["status", body.plan.status],
+      ["links", metric(body.plan.limits.links)],
+      ["events", metric(body.plan.limits.events)],
+      ["commission", metric(body.plan.limits.commission)],
+      ["key", body.key.label ? `${body.key.label} (${body.key.scopes.join(",")})` : body.key.scopes.join(",")],
+      ["key_source", auth.source],
+      ["api", auth.apiUrl],
+    ],
+    body,
+    { json: flags.json },
+  );
+}

package/src/commands/money.js

@@ -0,0 +1,96 @@
+// The commission ledger and payout batches.
+import { die, warn, EXIT } from "../lib/api.js";
+import { emit } from "../lib/output.js";
+import { confirm } from "../lib/prompt.js";
+import { intFlag } from "./analytics.js";
+
+const COMMISSION_COLUMNS = [
+  { header: "ts",       value: (r) => (r.ts ?? "").slice(0, 16).replace("T", " ") },
+  { header: "partner",  value: (r) => r.partner_email },
+  { header: "type",     value: (r) => r.type },
+  { header: "source",   value: (r) => r.source },
+  { header: "level",    value: (r) => r.chain_level, align: "right" },
+  { header: "sale",     value: (r) => Number(r.amount),   align: "right", fixed: 2 },
+  { header: "earned",   value: (r) => Number(r.earnings), align: "right", fixed: 2 },
+  { header: "status",   value: (r) => r.status },
+  { header: "id",       value: (r) => r.id },
+];
+
+const PAYOUT_COLUMNS = [
+  { header: "created",  value: (r) => (r.created_at ?? "").slice(0, 10) },
+  { header: "partner",  value: (r) => r.partner_email },
+  { header: "amount",   value: (r) => Number(r.amount), align: "right", fixed: 2 },
+  { header: "fee",      value: (r) => Number(r.fee),    align: "right", fixed: 2 },
+  { header: "method",   value: (r) => r.method },
+  { header: "status",   value: (r) => r.status },
+  { header: "paid",     value: (r) => (r.paid_at ?? "").slice(0, 10) || null },
+  { header: "ref",      value: (r) => r.manual_reference },
+  { header: "id",       value: (r) => r.id },
+];
+
+export async function commissions({ flags, api }) {
+  const params = new URLSearchParams();
+  if (flags.limit !== undefined) params.set("limit", String(intFlag("limit", flags.limit, { max: 500 })));
+  if (flags.status) params.set("status", flags.status);
+  if (flags.partner) params.set("partner_id", flags.partner);
+  const body = await api.get(`/commissions?${params}`);
+  emit(COMMISSION_COLUMNS, body.commissions, body, {
+    json: flags.json,
+    empty: "No commissions yet.",
+  });
+}
+
+export async function addCommission({ flags, api }) {
+  for (const f of ["program", "partner", "amount", "earnings"]) {
+    if (flags[f] === undefined) die(`--${f} is required.`, EXIT.USAGE);
+  }
+  const amount = Number(flags.amount);
+  const earnings = Number(flags.earnings);
+  if (!Number.isFinite(amount) || !Number.isFinite(earnings)) {
+    die("--amount and --earnings must be numbers.", EXIT.USAGE);
+  }
+  const c = await api.post("/commissions", {
+    program_id: flags.program,
+    partner_id: flags.partner,
+    amount,
+    earnings,
+    currency: flags.currency,
+    notes: flags.notes,
+  });
+  emit(COMMISSION_COLUMNS, [c], c, { json: flags.json });
+}
+
+export async function voidCommission({ args, flags, api }) {
+  const [id] = args;
+  const status = flags.status ?? "void";
+  const ok = await confirm(`Set commission ${id} to "${status}"?`, { yes: flags.yes });
+  if (!ok) die("Cancelled.", EXIT.USAGE);
+  const c = await api.patch(`/commissions/${encodeURIComponent(id)}`, { status });
+  emit(COMMISSION_COLUMNS, [c], c, { json: flags.json });
+}
+
+export async function payouts({ flags, api }) {
+  const params = new URLSearchParams();
+  if (flags.status) params.set("status", flags.status);
+  if (flags.limit !== undefined) params.set("limit", String(intFlag("limit", flags.limit, { max: 500 })));
+  const body = await api.get(`/payouts?${params}`);
+  emit(PAYOUT_COLUMNS, body.payouts, body, {
+    json: flags.json,
+    empty: "No payout batches yet. Create one in the dashboard.",
+  });
+  if (!flags.json && body.payouts.length) {
+    warn(`\nopen: ${body.totals.open.toFixed(2)}   paid all time: ${body.totals.paid_all_time.toFixed(2)}`);
+  }
+}
+
+export async function markPaid({ args, flags, api }) {
+  const [id] = args;
+  const ok = await confirm(
+    `Mark payout ${id} as paid? This closes out the commissions it covers.`,
+    { yes: flags.yes },
+  );
+  if (!ok) die("Cancelled.", EXIT.USAGE);
+  const p = await api.patch(`/payouts/${encodeURIComponent(id)}`, { reference: flags.reference ?? null });
+  emit(PAYOUT_COLUMNS, [p], p, { json: flags.json });
+  if (!flags.json) warn("No email was sent — the dashboard sends the 'money is on its way' one.");
+}

package/src/commands/people.js

@@ -0,0 +1,94 @@
+// Visitors, orders, and CSV export.
+import { writeFileSync } from "node:fs";
+import { warn, EXIT } from "../lib/api.js";
+import { emit, emitRecord } from "../lib/output.js";
+import { intFlag } from "./analytics.js";
+
+const MAX_PAGES = 200;
+
+/** Walk a cursor-paginated list endpoint, honouring --all. */
+async function paged(api, path, key, flags) {
+  const limit = flags.limit === undefined ? 100 : intFlag("limit", flags.limit, { max: 500 });
+  const rows = [];
+  let cursor = null;
+  let pages = 0;
+  do {
+    const params = new URLSearchParams({ limit: String(limit) });
+    if (cursor) params.set("cursor", cursor);
+    if (flags.email) params.set("email", flags.email);
+    if (flags.status) params.set("status", flags.status);
+    const body = await api.get(`${path}?${params}`);
+    rows.push(...body[key]);
+    cursor = body.next_cursor;
+    if (++pages >= MAX_PAGES && cursor) {
+      warn(`Stopped after ${MAX_PAGES} pages (${rows.length} rows).`);
+      break;
+    }
+  } while (flags.all && cursor);
+  return rows;
+}
+
+export async function visitors({ flags, api }) {
+  const rows = await paged(api, "/visitors", "visitors", flags);
+  emit(
+    [
+      { header: "email",     value: (r) => r.email },
+      { header: "firstseen", value: (r) => (r.first_seen ?? "").slice(0, 16).replace("T", " ") },
+      { header: "lastseen",  value: (r) => (r.last_seen ?? "").slice(0, 16).replace("T", " ") },
+      { header: "id",        value: (r) => r.id },
+    ],
+    rows,
+    { visitors: rows },
+    { json: flags.json, empty: "No visitors yet." },
+  );
+}
+
+export async function visitor({ args, flags, api }) {
+  const [id] = args;
+  const v = await api.get(`/visitors/${encodeURIComponent(id)}`);
+  emitRecord(
+    [
+      ["id", v.id],
+      ["vid", v.vid],
+      ["email", v.email],
+      ["first_seen", v.first_seen],
+      ["last_seen", v.last_seen],
+    ],
+    v,
+    { json: flags.json },
+  );
+  if (!flags.json) warn(`\nTimeline: trackrev journey ${v.id}`);
+}
+
+export async function orders({ flags, api }) {
+  const rows = await paged(api, "/orders", "orders", flags);
+  emit(
+    [
+      { header: "ts",       value: (r) => (r.ts ?? "").slice(0, 16).replace("T", " ") },
+      { header: "email",    value: (r) => r.email },
+      { header: "amount",   value: (r) => (r.amount == null ? null : Number(r.amount)), align: "right", fixed: 2 },
+      { header: "currency", value: (r) => r.currency },
+      { header: "status",   value: (r) => r.status },
+      { header: "visitor",  value: (r) => r.visitor_id },
+    ],
+    rows,
+    { orders: rows },
+    { json: flags.json, empty: "No orders yet." },
+  );
+}
+
+export async function exportCsv({ flags, api }) {
+  const kind = flags.kind ?? "channels";
+  const params = new URLSearchParams({ kind });
+  if (flags.from) params.set("from", flags.from);
+  if (flags.to) params.set("to", flags.to);
+  if (!flags.from && !flags.to) params.set("days", flags.days ?? "30");
+
+  const csv = await api.get(`/export?${params}`);
+  if (flags.out) {
+    writeFileSync(flags.out, csv);
+    warn(`Wrote ${flags.out}`);
+  } else {
+    process.stdout.write(csv);
+  }
+}

package/src/commands/retargeting.js

@@ -0,0 +1,49 @@
+// The workspace's ad-pixel library, fired on the consent interstitial.
+import { die, warn, EXIT } from "../lib/api.js";
+import { emit } from "../lib/output.js";
+import { confirm } from "../lib/prompt.js";
+
+export async function list({ flags, api }) {
+  const body = await api.get("/retargeting");
+  if (flags.providers) {
+    emit(
+      [
+        { header: "provider", value: (r) => r.value },
+        { header: "name",     value: (r) => r.label },
+        { header: "id looks like", value: (r) => r.example },
+        { header: "where to find it", value: (r) => r.where },
+      ],
+      body.providers,
+      body,
+      { json: flags.json },
+    );
+    return;
+  }
+  emit(
+    [
+      { header: "provider", value: (r) => r.provider },
+      { header: "pixel_id", value: (r) => r.pixel_id },
+      { header: "added",    value: (r) => (r.created_at ?? "").slice(0, 10) },
+    ],
+    body.pixels,
+    body,
+    { json: flags.json, empty: "No pixels configured. See: trackrev retargeting list --providers" },
+  );
+}
+
+export async function set({ args, flags, api }) {
+  const [provider] = args;
+  if (!flags.id) die("--id is required (the pixel/tag id).", EXIT.USAGE);
+  const p = await api.put(`/retargeting/${encodeURIComponent(provider)}`, { pixel_id: flags.id });
+  if (flags.json) console.log(JSON.stringify(p, null, 2));
+  else warn(`Set ${p.provider} → ${p.pixel_id}`);
+}
+
+export async function remove({ args, flags, api }) {
+  const [provider] = args;
+  const ok = await confirm(`Remove the ${provider} pixel?`, { yes: flags.yes });
+  if (!ok) die("Cancelled.", EXIT.USAGE);
+  const res = await api.del(`/retargeting/${encodeURIComponent(provider)}`);
+  if (flags.json) console.log(JSON.stringify(res, null, 2));
+  else warn(`Removed ${res.provider}.`);
+}

package/src/commands/revenue.js

@@ -0,0 +1,86 @@
+// Revenue provider connections and manual sync.
+import { die, warn, EXIT } from "../lib/api.js";
+import { emit } from "../lib/output.js";
+import { confirm } from "../lib/prompt.js";
+
+const COLUMNS = [
+  { header: "provider",  value: (r) => r.provider },
+  { header: "lastsync",  value: (r) => (r.last_sync_at ?? "").slice(0, 16).replace("T", " ") || null },
+  { header: "webhook",   value: (r) => r.webhook_configured },
+  { header: "error",     value: (r) => r.last_error },
+  { header: "id",        value: (r) => r.id },
+];
+
+export async function list({ flags, api }) {
+  const body = await api.get("/revenue/connections");
+  emit(COLUMNS, body.connections, body, {
+    json: flags.json,
+    empty: "Nothing connected. See: trackrev revenue providers",
+  });
+}
+
+export async function providers({ flags, api }) {
+  const body = await api.get("/revenue/providers");
+  emit(
+    [
+      { header: "provider", value: (r) => r.value },
+      { header: "name",     value: (r) => r.label },
+      { header: "needs",    value: (r) => r.fields.map((f) => f.key).join(",") },
+      { header: "sandbox",  value: (r) => r.supports_sandbox },
+    ],
+    body.providers,
+    body,
+    { json: flags.json },
+  );
+}
+
+export async function connect({ flags, api }) {
+  if (!flags.provider) die("--provider is required. See: trackrev revenue providers", EXIT.USAGE);
+  if (!flags.field || flags.field.length === 0) {
+    die("Pass credentials as --field key=value (repeat per field).", EXIT.USAGE);
+  }
+  const credentials = {};
+  for (const pair of flags.field) {
+    const eq = pair.indexOf("=");
+    if (eq < 1) die(`--field must be key=value, got "${pair}".`, EXIT.USAGE);
+    credentials[pair.slice(0, eq)] = pair.slice(eq + 1);
+  }
+
+  const body = await api.post("/revenue/connections", {
+    provider: flags.provider,
+    credentials,
+    sandbox: Boolean(flags.sandbox),
+  });
+  emit(COLUMNS, [body], body, { json: flags.json });
+  if (!flags.json) warn("Credentials were verified with a live read before saving.");
+}
+
+export async function sync({ flags, api }) {
+  const body = await api.post("/revenue/sync", flags.connection ? { connection_id: flags.connection } : {});
+  emit(
+    [
+      { header: "provider",   value: (r) => r.provider },
+      { header: "imported",   value: (r) => r.imported, align: "right" },
+      { header: "attributed", value: (r) => r.attributed, align: "right" },
+      { header: "error",      value: (r) => r.error ?? null },
+    ],
+    body.synced,
+    body,
+    { json: flags.json },
+  );
+  if (body.synced.some((s) => s.error)) process.exitCode = EXIT.FAIL;
+}
+
+export async function disconnect({ args, flags, api }) {
+  const [id] = args;
+  const conn = await api.get(`/revenue/connections/${encodeURIComponent(id)}`);
+  const ok = await confirm(
+    `Disconnect ${conn.provider}? New sales stop syncing; orders already imported are kept.`,
+    { yes: flags.yes },
+  );
+  if (!ok) die("Cancelled.", EXIT.USAGE);
+
+  const res = await api.del(`/revenue/connections/${encodeURIComponent(conn.id)}`);
+  if (flags.json) console.log(JSON.stringify(res, null, 2));
+  else warn(`Disconnected ${conn.provider}.`);
+}

package/src/commands/settings.js

@@ -0,0 +1,64 @@
+// Transactional email switches and white-label branding.
+import { die, warn, EXIT } from "../lib/api.js";
+import { emit, emitRecord } from "../lib/output.js";
+
+export async function notifications({ flags, api }) {
+  const body = await api.get("/settings/notifications");
+  emit(
+    [
+      { header: "key",      value: (r) => r.key },
+      { header: "audience", value: (r) => r.audience },
+      { header: "enabled",  value: (r) => r.enabled },
+      { header: "default",  value: (r) => r.is_default },
+      { header: "fires when", value: (r) => r.description },
+    ],
+    body.notifications,
+    body,
+    { json: flags.json },
+  );
+}
+
+export async function setNotification({ args, flags, api }) {
+  const [key] = args;
+  const on = flags.on === true;
+  const off = flags.off === true;
+  if (on === off) die("Pass --on or --off.", EXIT.USAGE);
+
+  const n = await api.patch("/settings/notifications", { key, enabled: on });
+  if (flags.json) console.log(JSON.stringify(n, null, 2));
+  else warn(`${n.key} is now ${n.enabled ? "on" : "off"}.`);
+}
+
+export async function branding({ flags, api }) {
+  const b = await api.get("/settings/branding");
+  emitRecord(
+    [
+      ["brand_logo_url", b.brand_logo_url],
+      ["brand_color", b.brand_color],
+      ["affiliate_subdomain", b.affiliate_subdomain],
+    ],
+    b,
+    { json: flags.json },
+  );
+}
+
+export async function setBranding({ flags, api }) {
+  const patch = {};
+  if (flags.logo !== undefined) patch.logo_url = flags.logo || null;
+  if (flags.color !== undefined) patch.color = flags.color || null;
+  if (flags["clear-logo"]) patch.logo_url = null;
+  if (flags["clear-color"]) patch.color = null;
+  if (Object.keys(patch).length === 0) {
+    die("Nothing to change. Run: trackrev settings set-branding --help", EXIT.USAGE);
+  }
+  const b = await api.patch("/settings/branding", patch);
+  emitRecord(
+    [
+      ["brand_logo_url", b.brand_logo_url],
+      ["brand_color", b.brand_color],
+      ["affiliate_subdomain", b.affiliate_subdomain],
+    ],
+    b,
+    { json: flags.json },
+  );
+}