trackrev 0.1.0 → 0.2.0

package/package.json

@@ -1,20 +1,32 @@
 {
   "name": "trackrev",
-  "version": "0.1.0",
-  "description": "Your TrackRev link analytics, in the terminal — channels, links and the raw click stream.",
+  "version": "0.2.0",
+  "description": "TrackRev in the terminal — create and manage tracking links, pull channel analytics, the raw click stream and any visitor's journey.",
   "type": "module",
   "bin": {
     "trackrev": "src/index.js"
   },
+  "exports": {
+    ".": "./src/index.js",
+    "./registry": {
+      "types": "./src/registry.d.ts",
+      "default": "./src/registry.js"
+    }
+  },
   "files": [
     "src",
     "README.md"
   ],
+  "scripts": {
+    "test": "node --test test/*.test.js",
+    "sync-docs": "node scripts/sync-docs.mjs"
+  },
   "keywords": [
     "trackrev",
     "analytics",
     "attribution",
     "link-tracking",
+    "short-links",
     "cli"
   ],
   "homepage": "https://trackrev.io",

package/src/commands/affiliates.js

@@ -0,0 +1,162 @@
+// Programs, partners and groups.
+import { die, warn, EXIT } from "../lib/api.js";
+import { emit, emitRecord } from "../lib/output.js";
+import { confirm } from "../lib/prompt.js";
+
+const PROGRAM_COLUMNS = [
+  { header: "name",     value: (r) => r.name },
+  { header: "status",   value: (r) => r.status },
+  { header: "commission", value: (r) =>
+      r.commission_type === "percent" ? `${(r.commission_rate * 100).toFixed(1)}%` : `$${r.commission_rate}` },
+  { header: "recurring", value: (r) => (r.recurring_months ? `${r.recurring_months}mo` : null) },
+  { header: "cookie",   value: (r) => `${r.cookie_window_days}d` },
+  { header: "autoapprove", value: (r) => r.auto_approve },
+  { header: "id",       value: (r) => r.id },
+];
+
+const PARTNER_COLUMNS = [
+  { header: "email",   value: (r) => r.email },
+  { header: "status",  value: (r) => r.status },
+  { header: "clicks",  value: (r) => Number(r.total_clicks),  align: "right" },
+  { header: "sales",   value: (r) => Number(r.total_sales),   align: "right" },
+  { header: "revenue", value: (r) => Number(r.total_revenue), align: "right", fixed: 2 },
+  { header: "earned",  value: (r) => Number(r.total_earned),  align: "right", fixed: 2 },
+  { header: "partner_id", value: (r) => r.partner_id },
+];
+
+/* ── programs ─────────────────────────────────────────────────────────────── */
+
+export async function programs({ flags, api }) {
+  const q = flags.archived ? "?include=archived" : "";
+  const body = await api.get(`/programs${q}`);
+  emit(PROGRAM_COLUMNS, body.programs, body, {
+    json: flags.json,
+    empty: "No programs yet. Create one in the dashboard.",
+  });
+}
+
+export async function program({ args, flags, api }) {
+  const [id] = args;
+  const p = await api.get(`/programs/${encodeURIComponent(id)}`);
+  emitRecord(
+    [
+      ["id", p.id],
+      ["name", p.name],
+      ["slug", p.slug],
+      ["short_code", p.short_code],
+      ["status", p.status],
+      ["landing_url", p.landing_url],
+      ["commission", p.commission_type === "percent" ? `${(p.commission_rate * 100).toFixed(1)}%` : `$${p.commission_rate}`],
+      ["recurring_months", p.recurring_months],
+      ["cookie_window_days", p.cookie_window_days],
+      ["min_payout", p.min_payout],
+      ["currency", p.payment_currency],
+      ["auto_approve", p.auto_approve],
+      ["multi_tier", p.multi_tier_enabled],
+    ],
+    p,
+    { json: flags.json },
+  );
+}
+
+export async function updateProgram({ args, flags, api }) {
+  const [id] = args;
+  const patch = {};
+  if (flags.name !== undefined) patch.name = flags.name;
+  if (flags["landing-url"] !== undefined) patch.landing_url = flags["landing-url"];
+  if (flags.type !== undefined) patch.commission_type = flags.type;
+  if (flags.rate !== undefined) {
+    const n = Number(flags.rate);
+    if (!Number.isFinite(n)) die("--rate must be a number.", EXIT.USAGE);
+    patch.commission_rate = n;
+  }
+  if (flags.recurring !== undefined) patch.recurring_months = Number(flags.recurring);
+  if (flags.cookie !== undefined) patch.cookie_window_days = Number(flags.cookie);
+  if (flags["min-payout"] !== undefined) patch.min_payout = Number(flags["min-payout"]);
+  if (flags["auto-approve"] !== undefined) {
+    if (flags["auto-approve"] !== "on" && flags["auto-approve"] !== "off") {
+      die("--auto-approve takes on or off.", EXIT.USAGE);
+    }
+    patch.auto_approve = flags["auto-approve"] === "on";
+  }
+  if (flags.status !== undefined) patch.status = flags.status;
+  if (Object.keys(patch).length === 0) {
+    die("Nothing to change. Run: trackrev programs update --help", EXIT.USAGE);
+  }
+
+  const p = await api.patch(`/programs/${encodeURIComponent(id)}`, patch);
+  emit(PROGRAM_COLUMNS, [p], p, { json: flags.json });
+  if (!flags.json && patch.commission_rate !== undefined) {
+    warn("Existing commissions are unchanged; this applies to new conversions.");
+  }
+}
+
+/* ── partners ─────────────────────────────────────────────────────────────── */
+
+export async function partners({ flags, api }) {
+  const params = new URLSearchParams();
+  if (flags.program) params.set("program_id", flags.program);
+  if (flags.status) params.set("status", flags.status);
+  const body = await api.get(`/partners?${params}`);
+  emit(PARTNER_COLUMNS, body.partners, body, {
+    json: flags.json,
+    empty: "No affiliates yet.",
+  });
+}
+
+async function setStatus({ args, flags, api }, status, verb) {
+  const [partnerId] = args;
+  if (!flags.program) die("--program is required (the program id).", EXIT.USAGE);
+  if (status !== "approved") {
+    const ok = await confirm(`${verb} affiliate ${partnerId}?`, { yes: flags.yes });
+    if (!ok) die("Cancelled.", EXIT.USAGE);
+  }
+  const p = await api.post("/partners/status", {
+    program_id: flags.program,
+    partner_id: partnerId,
+    status,
+  });
+  emit(PARTNER_COLUMNS, [p], p, { json: flags.json });
+  if (!flags.json && status === "approved") {
+    warn("No approval email was sent — the dashboard sends that one.");
+  }
+}
+
+export const approve = (c) => setStatus(c, "approved", "Approve");
+export const reject  = (c) => setStatus(c, "rejected", "Reject");
+export const ban     = (c) => setStatus(c, "banned", "Ban");
+
+export async function group({ args, flags, api }) {
+  const [partnerId] = args;
+  if (!flags.program) die("--program is required (the program id).", EXIT.USAGE);
+  const p = await api.post("/partners/group", {
+    program_id: flags.program,
+    partner_id: partnerId,
+    group_id: flags.group ?? null,
+  });
+  if (flags.json) console.log(JSON.stringify(p, null, 2));
+  else warn(p.group_id ? `Moved to group ${p.group_id}.` : "Removed from their group — back on program terms.");
+}
+
+/* ── groups ───────────────────────────────────────────────────────────────── */
+
+export async function groups({ args, flags, api }) {
+  const [programId] = args;
+  const body = await api.get(`/programs/${encodeURIComponent(programId)}/groups`);
+  emit(
+    [
+      { header: "name",     value: (r) => r.name },
+      { header: "default",  value: (r) => r.is_default },
+      { header: "commission", value: (r) =>
+          r.resolved?.commission_type === "percent"
+            ? `${(r.resolved.commission_rate * 100).toFixed(1)}%`
+            : `$${r.resolved?.commission_rate ?? ""}` },
+      { header: "cookie",   value: (r) => (r.resolved ? `${r.resolved.cookie_window_days}d` : null) },
+      { header: "overrides", value: (r) => (r.resolved?.overridden ?? []).join(",") || "inherits all" },
+      { header: "id",       value: (r) => r.id },
+    ],
+    body.groups,
+    body,
+    { json: flags.json, empty: "No groups — every affiliate is on the program's own terms." },
+  );
+}

package/src/commands/analytics.js

@@ -0,0 +1,128 @@
+// The four original commands, unchanged in behaviour: channels, links perf
+// (bare `links`), clicks, journey. Paid plan only — the API 402s otherwise.
+import { die, warn, EXIT } from "../lib/api.js";
+import { emit } from "../lib/output.js";
+
+const MAX_PAGES = 200;
+
+/**
+ * The reporting window as query params. `--from`/`--to` win over `--days`:
+ * the server ignores `days` once either bound is present, so sending all three
+ * would only be noise in the request log.
+ */
+function windowParams(flags) {
+  const params = new URLSearchParams();
+  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");
+  return params;
+}
+
+/** Parse a numeric flag, failing with a usage error rather than sending NaN. */
+export function intFlag(name, rawValue, { min = 1, max }) {
+  const n = Number(rawValue);
+  if (!Number.isInteger(n) || n < min || n > max) {
+    die(`--${name} must be a whole number between ${min} and ${max}.`, EXIT.USAGE);
+  }
+  return n;
+}
+
+export async function channels({ flags, api }) {
+  const params = windowParams(flags);
+  if (flags.ltv) params.set("ltv", "1");
+  const body = await api.get(`/channels?${params}`);
+
+  const columns = [
+    { header: "channel",     value: (r) => r.channel },
+    { header: "clicks",      value: (r) => Number(r.clicks),      align: "right" },
+    { header: "visitors",    value: (r) => Number(r.visitors),    align: "right" },
+    { header: "conversions", value: (r) => Number(r.conversions), align: "right", fixed: 2 },
+    { header: "revenue",     value: (r) => Number(r.revenue),     align: "right", fixed: 2 },
+  ];
+  if (flags.ltv) columns.push({ header: "ltv", value: (r) => Number(r.ltv), align: "right", fixed: 2 });
+
+  emit(columns, body.channels, body, { json: flags.json, empty: "No rows for this window." });
+}
+
+export async function linksPerf({ flags, api }) {
+  const params = windowParams(flags);
+  if (flags.limit !== undefined) params.set("limit", String(intFlag("limit", flags.limit, { max: 500 })));
+  if (flags.settings) params.set("include", "settings");
+  const body = await api.get(`/links?${params}`);
+
+  const columns = [
+    { header: "slug",        value: (r) => r.slug },
+    { header: "channel",     value: (r) => r.channel },
+    { header: "clicks",      value: (r) => Number(r.clicks),      align: "right" },
+    { header: "visitors",    value: (r) => Number(r.visitors),    align: "right" },
+    { header: "conversions", value: (r) => Number(r.conversions), align: "right", fixed: 2 },
+    { header: "revenue",     value: (r) => Number(r.revenue),     align: "right", fixed: 2 },
+    { header: "destination", value: (r) => r.destination },
+  ];
+  if (flags.settings) {
+    columns.push(
+      { header: "url",      value: (r) => r.settings?.url ?? null },
+      { header: "expires",  value: (r) => r.settings?.expires_at ?? null },
+      { header: "password", value: (r) => r.settings?.password_protected ?? false },
+    );
+  }
+  emit(columns, body.links, body, { json: flags.json, empty: "No rows for this window." });
+}
+
+export async function clicks({ flags, api }) {
+  const pageSize = flags.limit === undefined ? 100 : intFlag("limit", flags.limit, { max: 500 });
+  const stream = [];
+  let before = null;
+  let pages = 0;
+
+  do {
+    const params = new URLSearchParams({ limit: String(pageSize) });
+    if (before) params.set("before", before);
+    if (flags.link) params.set("link_id", flags.link);
+    if (flags.bots) params.set("bots", "include");
+
+    const page = await api.get(`/clicks?${params}`);
+    stream.push(...page.clicks);
+    before = page.next_cursor;
+
+    if (++pages >= MAX_PAGES && before) {
+      warn(`Stopped after ${MAX_PAGES} pages (${stream.length} clicks). Narrow it with --link.`);
+      break;
+    }
+  } while (flags.all && before);
+
+  const columns = [
+    { header: "ts",      value: (r) => r.ts },
+    { header: "channel", value: (r) => r.channel },
+    { header: "country", value: (r) => r.country },
+    { header: "device",  value: (r) => r.device },
+    { header: "browser", value: (r) => r.browser },
+    { header: "visitor", value: (r) => r.visitor_id },
+  ];
+  if (flags.bots) columns.push({ header: "bot", value: (r) => (r.is_bot ? "yes" : "") });
+
+  emit(columns, stream, { clicks: stream }, { json: flags.json, empty: "No clicks." });
+}
+
+export async function journey({ args, flags, api }) {
+  const [id] = args;
+  const body = await api.get(`/visitors/${encodeURIComponent(id)}/journey`);
+  const who = body.visitor;
+  // Identity goes to stderr: it is a caption, not a row, so a pipe stays clean.
+  if (!flags.json) warn(`visitor ${who.id}${who.email ? ` · ${who.email}` : ""}`);
+
+  emit(
+    [
+      { header: "ts",      value: (r) => r.ts },
+      { header: "kind",    value: (r) => r.kind },
+      { header: "label",   value: (r) => r.label },
+      { header: "channel", value: (r) => r.channel },
+      { header: "link",    value: (r) => r.link_slug },
+      { header: "amount",  value: (r) => (r.amount == null ? null : Number(r.amount)), align: "right", fixed: 2 },
+      { header: "detail",  value: (r) => r.detail },
+    ],
+    body.journey,
+    body,
+    { json: flags.json, empty: "No events for this visitor." },
+  );
+}

package/src/commands/attribution.js

@@ -0,0 +1,55 @@
+// Attribution model and lookback window. Both retroactively change every
+// revenue figure, so `set` says plainly what it just altered.
+import { die, warn, EXIT } from "../lib/api.js";
+import { emit, emitRecord } from "../lib/output.js";
+import { intFlag } from "./analytics.js";
+
+export async function get({ flags, api }) {
+  const body = await api.get("/attribution");
+  if (flags.models) {
+    emit(
+      [
+        { header: "model", value: (r) => r.value },
+        { header: "credit goes to", value: (r) => r.description },
+      ],
+      body.models,
+      body,
+      { json: flags.json },
+    );
+    return;
+  }
+  emitRecord(
+    [
+      ["model", body.model],
+      ["window_days", body.window_days],
+    ],
+    body,
+    { json: flags.json },
+  );
+}
+
+export async function set({ flags, api }) {
+  const patch = {};
+  if (flags.model !== undefined) patch.model = flags.model;
+  if (flags.window !== undefined) {
+    patch.window_days = intFlag("window", flags.window, { min: 1, max: 365 });
+  }
+  if (Object.keys(patch).length === 0) {
+    die("Pass --model and/or --window. Run: trackrev attribution set --help", EXIT.USAGE);
+  }
+
+  const body = await api.patch("/attribution", patch);
+  if (flags.json) {
+    console.log(JSON.stringify(body, null, 2));
+    return;
+  }
+  emitRecord(
+    [
+      ["model", body.model],
+      ["window_days", body.window_days],
+    ],
+    body,
+    {},
+  );
+  warn("Every revenue figure is recalculated against this — past orders included.");
+}

package/src/commands/auth.js

@@ -0,0 +1,41 @@
+import { readConfig, writeConfig, deleteConfig, configPath, DEFAULT_API } from "../lib/config.js";
+import { createApi, die, warn, EXIT } from "../lib/api.js";
+import { promptSecret } from "../lib/prompt.js";
+
+/** Shape of a secret key: lk_<env>_<8 hex>_<48 hex>. See newApiKey() in the web app. */
+const SECRET_KEY_RE = /^lk_[a-z]+_[0-9a-f]{8}_[0-9a-f]{48}$/;
+
+export async function login({ flags }) {
+  const profile = flags.profile || "default";
+  const key = (flags.key || (await promptSecret("Secret key (lk_…)"))).trim();
+  if (!SECRET_KEY_RE.test(key)) {
+    die("That doesn't look like a secret key. Create one under Settings → Developers.", EXIT.USAGE);
+  }
+  const apiUrl = (flags["api-url"] || process.env.TRACKREV_API_URL || DEFAULT_API).replace(/\/$/, "");
+
+  // Prove the key before saving it — a typo should fail here, not on the next
+  // command, and /me works on every plan so this never trips the paid gate.
+  const me = await createApi({ key, apiUrl, source: "the login prompt" }).get("/me");
+
+  const cfg = readConfig();
+  cfg.profiles[profile] = { key, apiUrl };
+  cfg.current = profile;
+  writeConfig(cfg);
+
+  warn(`Logged in to ${me.workspace.name} (${me.plan.name}) as profile "${profile}".`);
+  warn(`Saved to ${configPath()}.`);
+}
+
+export async function logout({ flags }) {
+  const cfg = readConfig();
+  if (flags.profile) {
+    if (!cfg.profiles[flags.profile]) die(`No profile "${flags.profile}".`, EXIT.USAGE);
+    delete cfg.profiles[flags.profile];
+    if (cfg.current === flags.profile) cfg.current = Object.keys(cfg.profiles)[0] || "default";
+    writeConfig(cfg);
+    warn(`Forgot profile "${flags.profile}".`);
+    return;
+  }
+  deleteConfig();
+  warn("Forgot every saved login.");
+}

package/src/commands/domains.js

@@ -0,0 +1,60 @@
+// Branded short-link domains (go.brand.com).
+import { die, warn, EXIT } from "../lib/api.js";
+import { emit } from "../lib/output.js";
+import { confirm } from "../lib/prompt.js";
+
+const COLUMNS = [
+  { header: "domain",  value: (r) => r.domain },
+  { header: "status",  value: (r) => r.status },
+  { header: "dnsok",   value: (r) => !r.misconfigured },
+  { header: "added",   value: (r) => (r.created_at ?? "").slice(0, 10) },
+  { header: "id",      value: (r) => r.id },
+];
+
+/** The DNS records a pending domain still needs, printed as a caption. */
+function showVerification(d) {
+  const recs = Array.isArray(d.verification) ? d.verification : [];
+  if (d.status === "active" || recs.length === 0) return;
+  warn("\nAdd these DNS records, then run: trackrev domains verify " + d.domain);
+  for (const r of recs) warn(`  ${r.type ?? "?"}  ${r.domain ?? ""}  ${r.value ?? ""}`);
+}
+
+export async function list({ flags, api }) {
+  const body = await api.get("/domains");
+  emit(COLUMNS, body.domains, body, {
+    json: flags.json,
+    empty: "No branded domains. Add one with: trackrev domains add go.yourbrand.com",
+  });
+}
+
+export async function add({ args, flags, api }) {
+  const [domain] = args;
+  const d = await api.post("/domains", { domain });
+  emit(COLUMNS, [d], d, { json: flags.json });
+  if (!flags.json) showVerification(d);
+}
+
+export async function verify({ args, flags, api }) {
+  const [idOrName] = args;
+  const d = await api.post(`/domains/${encodeURIComponent(idOrName)}`, {});
+  emit(COLUMNS, [d], d, { json: flags.json });
+  if (!flags.json) {
+    if (d.status === "active") warn("\nActive — links now resolve on this domain.");
+    else showVerification(d);
+  }
+  if (d.status !== "active") process.exitCode = EXIT.FAIL;
+}
+
+export async function remove({ args, flags, api }) {
+  const [idOrName] = args;
+  const d = await api.get(`/domains/${encodeURIComponent(idOrName)}`);
+  const ok = await confirm(
+    `Detach ${d.domain}? Links keep working on the default short host.`,
+    { yes: flags.yes },
+  );
+  if (!ok) die("Cancelled.", EXIT.USAGE);
+
+  const res = await api.del(`/domains/${encodeURIComponent(d.id)}`);
+  if (flags.json) console.log(JSON.stringify(res, null, 2));
+  else warn(`Detached ${res.domain}.`);
+}

package/src/commands/folders.js

@@ -0,0 +1,69 @@
+// Campaign folders — the grouping above campaigns.
+import { die, warn, EXIT } from "../lib/api.js";
+import { emit } from "../lib/output.js";
+import { confirm } from "../lib/prompt.js";
+
+const COLUMNS = [
+  { header: "name",      value: (r) => r.name },
+  { header: "campaigns", value: (r) => r.campaigns ?? null, align: "right" },
+  { header: "start",     value: (r) => r.start_date },
+  { header: "end",       value: (r) => r.end_date },
+  { header: "id",        value: (r) => r.id },
+];
+
+function body(flags) {
+  const out = {};
+  if (flags.name !== undefined) out.name = flags.name;
+  if (flags.description !== undefined) out.description = flags.description;
+  if (flags.start !== undefined) out.start_date = flags.start;
+  if (flags.end !== undefined) out.end_date = flags.end;
+  return out;
+}
+
+export async function list({ flags, api }) {
+  const res = await api.get("/folders");
+  emit(COLUMNS, res.folders, res, {
+    json: flags.json,
+    empty: "No campaign folders. Create one with: trackrev folders create --name 'Q4 launch'",
+  });
+}
+
+export async function create({ flags, api }) {
+  if (!flags.name) die("--name is required.", EXIT.USAGE);
+  const res = await api.post("/folders", body(flags));
+  emit(COLUMNS, [res], res, { json: flags.json });
+}
+
+export async function update({ args, flags, api }) {
+  const [id] = args;
+  const patch = body(flags);
+  if (Object.keys(patch).length === 0) {
+    die("Nothing to change. Run: trackrev folders update --help", EXIT.USAGE);
+  }
+  const res = await api.patch(`/folders/${encodeURIComponent(id)}`, patch);
+  emit(COLUMNS, [res], res, { json: flags.json });
+}
+
+export async function remove({ args, flags, api }) {
+  const [id] = args;
+  const folder = await api.get(`/folders/${encodeURIComponent(id)}`);
+  const ok = await confirm(
+    `Delete the folder "${folder.name}"? Its campaigns are kept and become ungrouped.`,
+    { yes: flags.yes },
+  );
+  if (!ok) die("Cancelled.", EXIT.USAGE);
+
+  const res = await api.del(`/folders/${encodeURIComponent(folder.id)}`);
+  if (flags.json) console.log(JSON.stringify(res, null, 2));
+  else warn(`Deleted "${folder.name}". ${res.released} campaign(s) are now ungrouped.`);
+}
+
+export async function assign({ args, flags, api }) {
+  const [destinationId] = args;
+  const res = await api.post("/folders/assign", {
+    destination_id: destinationId,
+    folder_id: flags.folder ?? null,
+  });
+  if (flags.json) console.log(JSON.stringify(res, null, 2));
+  else warn(res.folder_id ? `Filed under ${res.folder_id}.` : "Un-filed — now ungrouped.");
+}

package/src/commands/keys.js

@@ -0,0 +1,54 @@
+// Workspace API keys. The plaintext is shown once at creation and never again.
+import { die, warn, EXIT } from "../lib/api.js";
+import { emit } from "../lib/output.js";
+import { confirm } from "../lib/prompt.js";
+
+const COLUMNS = [
+  { header: "prefix",  value: (r) => r.prefix },
+  { header: "label",   value: (r) => r.label },
+  { header: "scopes",  value: (r) => (r.scopes ?? []).join(",") },
+  { header: "created", value: (r) => (r.created_at ?? "").slice(0, 10) },
+  { header: "lastused",value: (r) => (r.last_used_at ?? "").slice(0, 10) || null },
+  { header: "revoked", value: (r) => (r.revoked_at ?? "").slice(0, 10) || null },
+  { header: "id",      value: (r) => r.id },
+];
+
+export async function list({ flags, api }) {
+  const q = flags.revoked ? "?include=revoked" : "";
+  const body = await api.get(`/keys${q}`);
+  emit(COLUMNS, body.keys, body, {
+    json: flags.json,
+    empty: "No keys. Create one with: trackrev keys create",
+  });
+}
+
+export async function create({ flags, api }) {
+  const scope = flags.scope ?? "secret";
+  if (scope !== "secret" && scope !== "public") {
+    die("--scope must be secret or public.", EXIT.USAGE);
+  }
+  const body = await api.post("/keys", { scope, label: flags.label ?? null });
+
+  if (flags.json) {
+    console.log(JSON.stringify(body, null, 2));
+    return;
+  }
+  // The key itself goes to stdout so it can be captured; everything around it
+  // is a caption on stderr, so `trackrev keys create > key.txt` holds the key
+  // and nothing else.
+  warn(`Created ${body.key.prefix}… (${scope}). This is the only time it is shown:`);
+  console.log(body.secret);
+  warn("Store it now — it is hashed, not saved.");
+}
+
+export async function revoke({ args, flags, api }) {
+  const [id] = args;
+  const ok = await confirm(`Revoke key ${id}? Anything using it stops working immediately.`, {
+    yes: flags.yes,
+  });
+  if (!ok) die("Cancelled.", EXIT.USAGE);
+
+  const key = await api.del(`/keys/${encodeURIComponent(id)}`);
+  if (flags.json) console.log(JSON.stringify(key, null, 2));
+  else warn(`Revoked ${key.prefix}.`);
+}