@haven_ai/cli 0.1.17-alpha.0

package/dist/index.cjs

@@ -0,0 +1,681 @@
+'use strict';
+
+var promises = require('fs/promises');
+var os = require('os');
+var path = require('path');
+
+// src/args.ts
+var VALUE_FLAGS = /* @__PURE__ */ new Set([
+  "--api",
+  "--email",
+  "--safe",
+  "--agent",
+  "--limit",
+  "--direction",
+  "--format",
+  "--from",
+  "--to",
+  "--company"
+]);
+function parseArgs(argv) {
+  const positionals = [];
+  const flags = { json: false, help: false, version: false, yes: false };
+  for (let i = 0; i < argv.length; i += 1) {
+    const arg = argv[i];
+    if (arg === "--json") flags.json = true;
+    else if (arg === "--help" || arg === "-h") flags.help = true;
+    else if (arg === "--version" || arg === "-v") flags.version = true;
+    else if (arg === "--yes" || arg === "-y") flags.yes = true;
+    else if (VALUE_FLAGS.has(arg)) {
+      const value = argv[++i];
+      if (value === void 0 || value.startsWith("--")) {
+        throw new Error(`Missing value for ${arg}`);
+      }
+      if (arg === "--api") flags.api = value;
+      else if (arg === "--email") flags.email = value;
+      else if (arg === "--safe") flags.safe = value;
+      else if (arg === "--agent") flags.agent = value;
+      else if (arg === "--limit") {
+        const n = Number(value);
+        if (!Number.isInteger(n) || n <= 0) throw new Error("--limit must be a positive integer");
+        flags.limit = n;
+      } else if (arg === "--direction") {
+        if (value !== "in" && value !== "out") throw new Error('--direction must be "in" or "out"');
+        flags.direction = value;
+      } else if (arg === "--format") {
+        if (value !== "csv" && value !== "sie") throw new Error('--format must be "csv" or "sie"');
+        flags.format = value;
+      } else if (arg === "--from") flags.from = value;
+      else if (arg === "--to") flags.to = value;
+      else if (arg === "--company") flags.company = value;
+    } else if (arg.startsWith("--")) {
+      throw new Error(`Unknown option: ${arg}`);
+    } else {
+      positionals.push(arg);
+    }
+  }
+  const [command, sub, ...rest] = positionals;
+  return { command, sub, positionals: rest, flags };
+}
+function helpText() {
+  return [
+    "haven \u2014 terminal-native companion to the Haven dashboard",
+    "",
+    "Usage: haven <command> [subcommand] [options]",
+    "",
+    "Auth:",
+    "  login [--email <e>]     Sign in (password via prompt or HAVEN_PASSWORD)",
+    "  logout                  Clear the saved session",
+    "  whoami                  Show the signed-in user",
+    "",
+    "Read:",
+    "  wallets list            List your Haven wallets",
+    "  wallets balances [--safe <id|address>]   Token balances for a wallet",
+    "  agents list             List your agents",
+    "  agents show <id>        Show one agent + its budget",
+    "  budget show <agentId>   Show an agent's configured budget",
+    "  activity list [--safe <id>] [--agent <id>] [--direction in|out] [--limit <n>]",
+    "  activity export [filters]   Emit CSV to stdout (--format csv, default)",
+    "  activity export --format sie [--from <ISO>] [--to <ISO>] [--company <name>]",
+    "                          Bookkeeping-ready SIE 4I (Fortnox/Visma/Bokio)",
+    "  catalog list            List payable services",
+    "  contacts list           List your address book",
+    "",
+    "Manage (backend-only \u2014 no on-chain signing):",
+    "  agents pause|resume <id>",
+    "  agents revoke <id> --yes      Permanently revoke an agent",
+    "  agents rotate-key <id>        Issue a new API key (shown once)",
+    "  agents rename <id> <name>",
+    "  wallets rename <id> <name>",
+    "  contacts add <name> <address> | contacts remove <id>",
+    "",
+    "Options:",
+    "  --json                  Machine-readable output (for scripting)",
+    "  --yes, -y               Skip the confirmation prompt for destructive actions",
+    "  --api <url>             Backend URL (default: HAVEN_API_URL or http://localhost:3001)",
+    "  --help, --version",
+    "",
+    "On-chain actions (deploy, budgets, approvers, send) are signed in the",
+    "dashboard \u2014 this CLI reads and manages; it never holds your keys."
+  ].join("\n");
+}
+
+// src/api.ts
+var CliApiError = class extends Error {
+  status;
+  constructor(message, status) {
+    super(message);
+    this.name = "CliApiError";
+    this.status = status;
+  }
+};
+function createCliApi({ baseUrl, token, fetchImpl = fetch }) {
+  const root = baseUrl.replace(/\/+$/, "");
+  async function request(method, path, body) {
+    const headers = { Accept: "application/json" };
+    if (token) headers.Authorization = `Bearer ${token}`;
+    if (body !== void 0) headers["Content-Type"] = "application/json";
+    let res;
+    try {
+      res = await fetchImpl(`${root}${path}`, {
+        method,
+        headers,
+        body: body !== void 0 ? JSON.stringify(body) : void 0
+      });
+    } catch (err) {
+      throw new CliApiError(
+        `Could not reach Haven at ${root}: ${err instanceof Error ? err.message : String(err)}`,
+        0
+      );
+    }
+    if (res.status === 401) {
+      throw new CliApiError("Not authenticated. Run `haven login` first.", 401);
+    }
+    const text = await res.text();
+    const payload = text ? safeParse(text) : void 0;
+    if (!res.ok) {
+      const message = (payload && typeof payload === "object" && "error" in payload && typeof payload.error === "string" ? payload.error : null) ?? `Request failed (HTTP ${res.status}).`;
+      throw new CliApiError(message, res.status);
+    }
+    return payload;
+  }
+  async function requestText(path) {
+    const headers = { Accept: "text/plain" };
+    if (token) headers.Authorization = `Bearer ${token}`;
+    let res;
+    try {
+      res = await fetchImpl(`${root}${path}`, { method: "GET", headers });
+    } catch (err) {
+      throw new CliApiError(
+        `Could not reach Haven at ${root}: ${err instanceof Error ? err.message : String(err)}`,
+        0
+      );
+    }
+    if (res.status === 401) {
+      throw new CliApiError("Not authenticated. Run `haven login` first.", 401);
+    }
+    const text = await res.text();
+    if (!res.ok) {
+      const payload = text ? safeParse(text) : void 0;
+      const message = (payload && typeof payload === "object" && "error" in payload && typeof payload.error === "string" ? payload.error : null) ?? `Request failed (HTTP ${res.status}).`;
+      throw new CliApiError(message, res.status);
+    }
+    return text;
+  }
+  return {
+    get: (path) => request("GET", path),
+    post: (path, body) => request("POST", path, body),
+    put: (path, body) => request("PUT", path, body),
+    del: (path) => request("DELETE", path),
+    getText: (path) => requestText(path)
+  };
+}
+function safeParse(text) {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return void 0;
+  }
+}
+function sessionDir(homeDir) {
+  return path.resolve(homeDir, ".haven");
+}
+function sessionPath(homeDir = os.homedir()) {
+  return path.join(sessionDir(homeDir), "session.json");
+}
+function createSessionStore(homeDir = os.homedir()) {
+  const path = sessionPath(homeDir);
+  return {
+    path,
+    async load() {
+      try {
+        const raw = await promises.readFile(path, "utf8");
+        const parsed = JSON.parse(raw);
+        if (!parsed.token || !parsed.apiBaseUrl || !parsed.user) return null;
+        return parsed;
+      } catch {
+        return null;
+      }
+    },
+    async save(session) {
+      await promises.mkdir(sessionDir(homeDir), { recursive: true, mode: 448 });
+      await promises.writeFile(path, `${JSON.stringify(session, null, 2)}
+`, { mode: 384 });
+      await promises.chmod(path, 384).catch(() => void 0);
+    },
+    async clear() {
+      await promises.rm(path, { force: true });
+    }
+  };
+}
+
+// src/format.ts
+function table(headers, rows) {
+  const widths = headers.map(
+    (h, i) => Math.max(h.length, ...rows.map((r) => (r[i] ?? "").length))
+  );
+  const line = (cells) => cells.map((c, i) => (c ?? "").padEnd(widths[i])).join("  ").trimEnd();
+  return [line(headers), line(widths.map((w) => "-".repeat(w))), ...rows.map(line)].join("\n");
+}
+function truncateAddress(address) {
+  if (!address || address.length <= 12) return address;
+  return `${address.slice(0, 6)}\u2026${address.slice(-4)}`;
+}
+var CHAIN_NAMES = { 100: "Gnosis", 8453: "Base" };
+function chainName(chainId) {
+  return CHAIN_NAMES[chainId] ?? `chain ${chainId}`;
+}
+
+// src/csv.ts
+function csvField(value) {
+  let v = value;
+  if (/^[=+\-@\t\r]/.test(v)) v = `'${v}`;
+  return `"${v.replace(/"/g, '""')}"`;
+}
+function toCsv(headers, rows) {
+  const lines = [headers.join(","), ...rows.map((r) => r.map(csvField).join(","))];
+  return lines.join("\r\n");
+}
+
+// src/commands.ts
+var DEFAULT_API = "https://havenbackend-production-8a00.up.railway.app";
+var CLI_VERSION = "0.1.17-alpha.0";
+async function run(argv, deps = {}) {
+  const d = {
+    sessionStore: deps.sessionStore ?? createSessionStore(),
+    makeApi: deps.makeApi ?? ((baseUrl, token) => createCliApi({ baseUrl, token })),
+    promptPassword: deps.promptPassword ?? (() => Promise.reject(new Error("No password input available"))),
+    out: deps.out ?? ((l) => process.stdout.write(`${l}
+`)),
+    err: deps.err ?? ((l) => process.stderr.write(`${l}
+`)),
+    env: deps.env ?? process.env
+  };
+  let args;
+  try {
+    args = parseArgs(argv);
+  } catch (e) {
+    d.err(e instanceof Error ? e.message : String(e));
+    return 1;
+  }
+  if (args.flags.version) {
+    d.out(CLI_VERSION);
+    return 0;
+  }
+  if (args.flags.help || !args.command) {
+    d.out(helpText());
+    return 0;
+  }
+  try {
+    return await dispatch(args, d);
+  } catch (e) {
+    if (e instanceof CliApiError) {
+      d.err(e.message);
+      return e.status === 401 ? 2 : 1;
+    }
+    d.err(e instanceof Error ? e.message : String(e));
+    return 1;
+  }
+}
+async function dispatch(args, d) {
+  const key = args.sub ? `${args.command} ${args.sub}` : args.command;
+  switch (key) {
+    case "login":
+      return cmdLogin(args, d);
+    case "logout":
+      return cmdLogout(d);
+    case "whoami":
+      return cmdWhoami(args, d);
+    case "wallets list":
+      return cmdWalletsList(args, d);
+    case "wallets balances":
+      return cmdWalletsBalances(args, d);
+    case "agents list":
+      return cmdAgentsList(args, d);
+    case "agents show":
+      return cmdAgentsShow(args, d);
+    case "agents pause":
+      return cmdAgentLifecycle(args, d, "pause");
+    case "agents resume":
+      return cmdAgentLifecycle(args, d, "resume");
+    case "agents revoke":
+      return cmdAgentRevoke(args, d);
+    case "agents rotate-key":
+      return cmdAgentRotateKey(args, d);
+    case "agents rename":
+      return cmdAgentRename(args, d);
+    case "budget show":
+      return cmdBudgetShow(args, d);
+    case "wallets rename":
+      return cmdWalletRename(args, d);
+    case "activity list":
+      return cmdActivityList(args, d);
+    case "activity export":
+      return cmdActivityExport(args, d);
+    case "catalog list":
+      return cmdCatalogList(args, d);
+    case "contacts list":
+      return cmdContactsList(args, d);
+    case "contacts add":
+      return cmdContactsAdd(args, d);
+    case "contacts remove":
+      return cmdContactsRemove(args, d);
+    default:
+      d.err(`Unknown command: ${key}. Run \`haven --help\`.`);
+      return 1;
+  }
+}
+function baseUrlFor(args, d, session) {
+  return args.flags.api ?? session?.apiBaseUrl ?? d.env.HAVEN_API_URL ?? DEFAULT_API;
+}
+async function authed(args, d) {
+  const session = await d.sessionStore.load();
+  if (!session) throw new CliApiError("Not authenticated. Run `haven login` first.", 401);
+  return { session, api: d.makeApi(baseUrlFor(args, d, session), session.token) };
+}
+function emit(d, json, data, human) {
+  d.out(json ? JSON.stringify(data, null, 2) : human());
+}
+async function cmdLogin(args, d) {
+  const email = args.flags.email ?? d.env.HAVEN_EMAIL;
+  if (!email) {
+    d.err("Provide an email with --email (or HAVEN_EMAIL).");
+    return 1;
+  }
+  const password = d.env.HAVEN_PASSWORD ?? await d.promptPassword();
+  if (!password) {
+    d.err("A password is required.");
+    return 1;
+  }
+  const baseUrl = baseUrlFor(args, d, null);
+  const api = d.makeApi(baseUrl);
+  const res = await api.post("/auth/login", { email, password });
+  await d.sessionStore.save({ token: res.token, apiBaseUrl: baseUrl, user: res.user });
+  emit(d, args.flags.json, { user: res.user, apiBaseUrl: baseUrl }, () => `Signed in as ${res.user.email}.`);
+  return 0;
+}
+async function cmdLogout(d) {
+  await d.sessionStore.clear();
+  d.out("Signed out.");
+  return 0;
+}
+async function cmdWhoami(args, d) {
+  const { api } = await authed(args, d);
+  const user = await api.get("/auth/me");
+  emit(d, args.flags.json, user, () => `${user.email}${user.name ? ` (${user.name})` : ""}`);
+  return 0;
+}
+async function cmdWalletsList(args, d) {
+  const { api } = await authed(args, d);
+  const { safes } = await api.get("/user/safes");
+  emit(
+    d,
+    args.flags.json,
+    safes,
+    () => safes.length === 0 ? "No Haven wallets yet." : table(
+      ["NAME", "NETWORK", "ADDRESS", "DEFAULT"],
+      safes.map((s) => [s.name, chainName(s.chain_id), truncateAddress(s.safe_address), s.is_default ? "\u2713" : ""])
+    )
+  );
+  return 0;
+}
+async function cmdWalletsBalances(args, d) {
+  const { api } = await authed(args, d);
+  const { safes } = await api.get("/user/safes");
+  const safe = pickSafe(safes, args.flags.safe);
+  if (!safe) {
+    d.err(args.flags.safe ? `No wallet matches "${args.flags.safe}".` : "No Haven wallet found.");
+    return 1;
+  }
+  const { balances } = await api.get(
+    `/balances/${safe.safe_address}?chain_id=${safe.chain_id}`
+  );
+  emit(
+    d,
+    args.flags.json,
+    { safe: safe.name, chainId: safe.chain_id, balances },
+    () => [
+      `${safe.name} \xB7 ${chainName(safe.chain_id)} \xB7 ${truncateAddress(safe.safe_address)}`,
+      balances.length === 0 ? "  (no balances)" : table(["TOKEN", "BALANCE"], balances.map((b) => [b.symbol, b.formatted]))
+    ].join("\n")
+  );
+  return 0;
+}
+function pickSafe(safes, ref) {
+  if (!ref) return safes.find((s) => s.is_default) ?? safes[0];
+  const lower = ref.toLowerCase();
+  return safes.find((s) => s.id === ref || s.safe_address.toLowerCase() === lower);
+}
+async function cmdAgentsList(args, d) {
+  const { api } = await authed(args, d);
+  const { agents } = await api.get("/agents");
+  emit(
+    d,
+    args.flags.json,
+    agents,
+    () => agents.length === 0 ? "No agents yet." : table(
+      ["ID", "NAME", "STATUS", "BUDGETS"],
+      agents.map((a) => [a.id, a.name, a.status, budgetSummary(a.allowances)])
+    )
+  );
+  return 0;
+}
+async function cmdAgentsShow(args, d) {
+  const id = args.positionals[0];
+  if (!id) {
+    d.err("Usage: haven agents show <id>");
+    return 1;
+  }
+  const { api } = await authed(args, d);
+  const agent = await api.get(`/agents/${id}`);
+  emit(
+    d,
+    args.flags.json,
+    agent,
+    () => [
+      `${agent.name}  [${agent.status}]`,
+      `id: ${agent.id}`,
+      `budget: ${budgetSummary(agent.allowances)}`
+    ].join("\n")
+  );
+  return 0;
+}
+async function cmdBudgetShow(args, d) {
+  const id = args.positionals[0];
+  if (!id) {
+    d.err("Usage: haven budget show <agentId>");
+    return 1;
+  }
+  const { api } = await authed(args, d);
+  const agent = await api.get(`/agents/${id}`);
+  const allowances = agent.allowances ?? [];
+  emit(
+    d,
+    args.flags.json,
+    allowances,
+    () => allowances.length === 0 ? `${agent.name} has no configured budget.` : table(
+      ["TOKEN", "AMOUNT", "RESETS"],
+      allowances.map((a) => [a.token_symbol, a.allowance_amount, resetLabel(a.reset_period_min)])
+    )
+  );
+  return 0;
+}
+function budgetSummary(allowances) {
+  if (!allowances || allowances.length === 0) return "\u2014";
+  return allowances.map((a) => `${a.allowance_amount} ${a.token_symbol}`).join(", ");
+}
+function resetLabel(mins) {
+  if (mins === 0) return "one-time";
+  if (mins === 1440) return "daily";
+  if (mins === 10080) return "weekly";
+  if (mins === 43200) return "monthly";
+  return `every ${mins}m`;
+}
+async function cmdAgentLifecycle(args, d, action) {
+  const id = args.positionals[0];
+  if (!id) {
+    d.err(`Usage: haven agents ${action} <id>`);
+    return 1;
+  }
+  const { api } = await authed(args, d);
+  await api.post(`/agents/${id}/${action}`);
+  d.out(`Agent ${id} ${action === "pause" ? "paused" : "resumed"}.`);
+  return 0;
+}
+async function cmdAgentRevoke(args, d) {
+  const id = args.positionals[0];
+  if (!id) {
+    d.err("Usage: haven agents revoke <id> --yes");
+    return 1;
+  }
+  if (!args.flags.yes) {
+    d.err(`This permanently revokes agent ${id}. Re-run with --yes to confirm.`);
+    return 1;
+  }
+  const { api } = await authed(args, d);
+  await api.post(`/agents/${id}/revoke`);
+  d.out(`Agent ${id} revoked. To also remove its on-chain allowance, use the dashboard.`);
+  return 0;
+}
+async function cmdAgentRotateKey(args, d) {
+  const id = args.positionals[0];
+  if (!id) {
+    d.err("Usage: haven agents rotate-key <id>");
+    return 1;
+  }
+  const { api } = await authed(args, d);
+  const res = await api.post(`/agents/${id}/rotate-key`);
+  if (args.flags.json) {
+    d.out(JSON.stringify(res, null, 2));
+  } else {
+    d.out("New API key (shown once \u2014 store it now; the old key stops working):");
+    d.out(res.api_key);
+  }
+  return 0;
+}
+async function cmdAgentRename(args, d) {
+  const [id, ...nameParts] = args.positionals;
+  const name = nameParts.join(" ").trim();
+  if (!id || !name) {
+    d.err("Usage: haven agents rename <id> <name>");
+    return 1;
+  }
+  const { api } = await authed(args, d);
+  await api.put(`/agents/${id}`, { name });
+  d.out(`Agent ${id} renamed to "${name}".`);
+  return 0;
+}
+async function cmdWalletRename(args, d) {
+  const [id, ...nameParts] = args.positionals;
+  const name = nameParts.join(" ").trim();
+  if (!id || !name) {
+    d.err("Usage: haven wallets rename <id> <name>");
+    return 1;
+  }
+  const { api } = await authed(args, d);
+  await api.put(`/user/safes/${id}`, { name });
+  d.out(`Wallet ${id} renamed to "${name}".`);
+  return 0;
+}
+async function cmdActivityList(args, d) {
+  const { api } = await authed(args, d);
+  const params = new URLSearchParams({ offset: "0", limit: String(args.flags.limit ?? 25) });
+  if (args.flags.safe) params.set("safeId", args.flags.safe);
+  if (args.flags.agent) params.set("agentId", args.flags.agent);
+  const { transactions } = await api.get(`/transactions?${params.toString()}`);
+  const visible = args.flags.direction ? transactions.filter((t) => t.direction === args.flags.direction) : transactions;
+  emit(
+    d,
+    args.flags.json,
+    visible,
+    () => visible.length === 0 ? "No activity." : table(
+      ["DATE", "DIR", "AMOUNT", "TYPE", "ACCOUNT"],
+      visible.map((t) => [
+        new Date(t.timestamp * 1e3).toISOString().slice(0, 10),
+        t.direction === "in" ? "in" : "out",
+        `${t.direction === "in" ? "+" : "-"}${t.valueFormatted} ${t.asset}`,
+        t.source ?? "transfer",
+        t.safeName ?? ""
+      ])
+    )
+  );
+  return 0;
+}
+async function cmdActivityExport(args, d) {
+  if (args.flags.format === "sie") return exportSie(args, d);
+  const { api } = await authed(args, d);
+  const params = new URLSearchParams({ offset: "0", limit: String(args.flags.limit ?? 1e3) });
+  if (args.flags.safe) params.set("safeId", args.flags.safe);
+  if (args.flags.agent) params.set("agentId", args.flags.agent);
+  const { transactions } = await api.get(`/transactions?${params.toString()}`);
+  const visible = args.flags.direction ? transactions.filter((t) => t.direction === args.flags.direction) : transactions;
+  const headers = [
+    "date",
+    "type",
+    "status",
+    "direction",
+    "amount",
+    "token_symbol",
+    "token_address",
+    "counterparty_address",
+    "safe_address",
+    "agent_name",
+    "tx_hash",
+    "chain_id"
+  ];
+  const rows = visible.map((t) => [
+    new Date(t.timestamp * 1e3).toISOString(),
+    exportType(t),
+    exportStatus(t),
+    t.direction,
+    t.valueFormatted,
+    t.tokenSymbol ?? t.asset ?? "",
+    t.tokenAddress ?? "",
+    (t.direction === "in" ? t.from : t.to) ?? "",
+    t.safeAddress ?? "",
+    t.agentName ?? "",
+    t.hash,
+    t.chainId != null ? String(t.chainId) : ""
+  ]);
+  d.out(toCsv(headers, rows));
+  return 0;
+}
+function exportType(t) {
+  if (t.activityType === "delegate_sweep") return "allowance funding";
+  if (t.source === "x402") return "x402";
+  if (t.source === "mpp_demo") return "mpp";
+  return t.direction === "in" ? "receive" : "send";
+}
+function exportStatus(t) {
+  if (t.isError) return "failed";
+  if (t.paymentFlowStatus === "confirming_merchant") return "pending";
+  return "executed";
+}
+async function exportSie(args, d) {
+  const { api } = await authed(args, d);
+  const params = new URLSearchParams({ format: "sie" });
+  if (args.flags.from) params.set("from", args.flags.from);
+  if (args.flags.to) params.set("to", args.flags.to);
+  if (args.flags.company) params.set("company", args.flags.company);
+  const content = await api.getText(`/accounting/export?${params.toString()}`);
+  d.out(content);
+  return 0;
+}
+async function cmdCatalogList(args, d) {
+  const { api } = await authed(args, d);
+  const { entries } = await api.get("/catalog");
+  emit(
+    d,
+    args.flags.json,
+    entries,
+    () => entries.length === 0 ? "Catalog is empty." : table(
+      ["NAME", "CATEGORY", "RAIL", "PRICE", "STATUS"],
+      entries.map((e) => [e.name, e.category, e.rail, e.price_display ?? "\u2014", e.status])
+    )
+  );
+  return 0;
+}
+async function cmdContactsList(args, d) {
+  const { api } = await authed(args, d);
+  const { contacts } = await api.get("/contacts");
+  emit(
+    d,
+    args.flags.json,
+    contacts,
+    () => contacts.length === 0 ? "No contacts yet." : table(["ID", "NAME", "ADDRESS"], contacts.map((c) => [c.id, c.name, truncateAddress(c.address)]))
+  );
+  return 0;
+}
+async function cmdContactsAdd(args, d) {
+  const [address, ...nameParts] = [...args.positionals].reverse();
+  const name = nameParts.reverse().join(" ").trim();
+  if (!name || !address) {
+    d.err("Usage: haven contacts add <name> <address>");
+    return 1;
+  }
+  const { api } = await authed(args, d);
+  const contact = await api.post("/contacts", { name, address });
+  emit(d, args.flags.json, contact, () => `Added contact "${contact.name}" (${truncateAddress(contact.address)}).`);
+  return 0;
+}
+async function cmdContactsRemove(args, d) {
+  const id = args.positionals[0];
+  if (!id) {
+    d.err("Usage: haven contacts remove <id>");
+    return 1;
+  }
+  const { api } = await authed(args, d);
+  await api.del(`/contacts/${id}`);
+  d.out(`Contact ${id} removed.`);
+  return 0;
+}
+
+exports.CliApiError = CliApiError;
+exports.createCliApi = createCliApi;
+exports.createSessionStore = createSessionStore;
+exports.helpText = helpText;
+exports.parseArgs = parseArgs;
+exports.run = run;
+exports.sessionPath = sessionPath;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map