brex-cli 0.1.0

package/dist/main.js

@@ -0,0 +1,2455 @@
+#!/usr/bin/env bun
+// @bun
+
+// sources/config.ts
+var {existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync} = (() => ({}));
+
+// node:os
+var homedir = function() {
+  return "/";
+};
+
+// node:path
+function assertPath(path) {
+  if (typeof path !== "string")
+    throw TypeError("Path must be a string. Received " + JSON.stringify(path));
+}
+function normalizeStringPosix(path, allowAboveRoot) {
+  var res = "", lastSegmentLength = 0, lastSlash = -1, dots = 0, code;
+  for (var i = 0;i <= path.length; ++i) {
+    if (i < path.length)
+      code = path.charCodeAt(i);
+    else if (code === 47)
+      break;
+    else
+      code = 47;
+    if (code === 47) {
+      if (lastSlash === i - 1 || dots === 1)
+        ;
+      else if (lastSlash !== i - 1 && dots === 2) {
+        if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 || res.charCodeAt(res.length - 2) !== 46) {
+          if (res.length > 2) {
+            var lastSlashIndex = res.lastIndexOf("/");
+            if (lastSlashIndex !== res.length - 1) {
+              if (lastSlashIndex === -1)
+                res = "", lastSegmentLength = 0;
+              else
+                res = res.slice(0, lastSlashIndex), lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+              lastSlash = i, dots = 0;
+              continue;
+            }
+          } else if (res.length === 2 || res.length === 1) {
+            res = "", lastSegmentLength = 0, lastSlash = i, dots = 0;
+            continue;
+          }
+        }
+        if (allowAboveRoot) {
+          if (res.length > 0)
+            res += "/..";
+          else
+            res = "..";
+          lastSegmentLength = 2;
+        }
+      } else {
+        if (res.length > 0)
+          res += "/" + path.slice(lastSlash + 1, i);
+        else
+          res = path.slice(lastSlash + 1, i);
+        lastSegmentLength = i - lastSlash - 1;
+      }
+      lastSlash = i, dots = 0;
+    } else if (code === 46 && dots !== -1)
+      ++dots;
+    else
+      dots = -1;
+  }
+  return res;
+}
+function _format(sep, pathObject) {
+  var dir = pathObject.dir || pathObject.root, base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
+  if (!dir)
+    return base;
+  if (dir === pathObject.root)
+    return dir + base;
+  return dir + sep + base;
+}
+function resolve() {
+  var resolvedPath = "", resolvedAbsolute = false, cwd;
+  for (var i = arguments.length - 1;i >= -1 && !resolvedAbsolute; i--) {
+    var path;
+    if (i >= 0)
+      path = arguments[i];
+    else {
+      if (cwd === undefined)
+        cwd = process.cwd();
+      path = cwd;
+    }
+    if (assertPath(path), path.length === 0)
+      continue;
+    resolvedPath = path + "/" + resolvedPath, resolvedAbsolute = path.charCodeAt(0) === 47;
+  }
+  if (resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute), resolvedAbsolute)
+    if (resolvedPath.length > 0)
+      return "/" + resolvedPath;
+    else
+      return "/";
+  else if (resolvedPath.length > 0)
+    return resolvedPath;
+  else
+    return ".";
+}
+function normalize(path) {
+  if (assertPath(path), path.length === 0)
+    return ".";
+  var isAbsolute = path.charCodeAt(0) === 47, trailingSeparator = path.charCodeAt(path.length - 1) === 47;
+  if (path = normalizeStringPosix(path, !isAbsolute), path.length === 0 && !isAbsolute)
+    path = ".";
+  if (path.length > 0 && trailingSeparator)
+    path += "/";
+  if (isAbsolute)
+    return "/" + path;
+  return path;
+}
+function isAbsolute(path) {
+  return assertPath(path), path.length > 0 && path.charCodeAt(0) === 47;
+}
+function join() {
+  if (arguments.length === 0)
+    return ".";
+  var joined;
+  for (var i = 0;i < arguments.length; ++i) {
+    var arg = arguments[i];
+    if (assertPath(arg), arg.length > 0)
+      if (joined === undefined)
+        joined = arg;
+      else
+        joined += "/" + arg;
+  }
+  if (joined === undefined)
+    return ".";
+  return normalize(joined);
+}
+function relative(from, to) {
+  if (assertPath(from), assertPath(to), from === to)
+    return "";
+  if (from = resolve(from), to = resolve(to), from === to)
+    return "";
+  var fromStart = 1;
+  for (;fromStart < from.length; ++fromStart)
+    if (from.charCodeAt(fromStart) !== 47)
+      break;
+  var fromEnd = from.length, fromLen = fromEnd - fromStart, toStart = 1;
+  for (;toStart < to.length; ++toStart)
+    if (to.charCodeAt(toStart) !== 47)
+      break;
+  var toEnd = to.length, toLen = toEnd - toStart, length = fromLen < toLen ? fromLen : toLen, lastCommonSep = -1, i = 0;
+  for (;i <= length; ++i) {
+    if (i === length) {
+      if (toLen > length) {
+        if (to.charCodeAt(toStart + i) === 47)
+          return to.slice(toStart + i + 1);
+        else if (i === 0)
+          return to.slice(toStart + i);
+      } else if (fromLen > length) {
+        if (from.charCodeAt(fromStart + i) === 47)
+          lastCommonSep = i;
+        else if (i === 0)
+          lastCommonSep = 0;
+      }
+      break;
+    }
+    var fromCode = from.charCodeAt(fromStart + i), toCode = to.charCodeAt(toStart + i);
+    if (fromCode !== toCode)
+      break;
+    else if (fromCode === 47)
+      lastCommonSep = i;
+  }
+  var out = "";
+  for (i = fromStart + lastCommonSep + 1;i <= fromEnd; ++i)
+    if (i === fromEnd || from.charCodeAt(i) === 47)
+      if (out.length === 0)
+        out += "..";
+      else
+        out += "/..";
+  if (out.length > 0)
+    return out + to.slice(toStart + lastCommonSep);
+  else {
+    if (toStart += lastCommonSep, to.charCodeAt(toStart) === 47)
+      ++toStart;
+    return to.slice(toStart);
+  }
+}
+function _makeLong(path) {
+  return path;
+}
+function dirname(path) {
+  if (assertPath(path), path.length === 0)
+    return ".";
+  var code = path.charCodeAt(0), hasRoot = code === 47, end = -1, matchedSlash = true;
+  for (var i = path.length - 1;i >= 1; --i)
+    if (code = path.charCodeAt(i), code === 47) {
+      if (!matchedSlash) {
+        end = i;
+        break;
+      }
+    } else
+      matchedSlash = false;
+  if (end === -1)
+    return hasRoot ? "/" : ".";
+  if (hasRoot && end === 1)
+    return "//";
+  return path.slice(0, end);
+}
+function basename(path, ext) {
+  if (ext !== undefined && typeof ext !== "string")
+    throw TypeError('"ext" argument must be a string');
+  assertPath(path);
+  var start = 0, end = -1, matchedSlash = true, i;
+  if (ext !== undefined && ext.length > 0 && ext.length <= path.length) {
+    if (ext.length === path.length && ext === path)
+      return "";
+    var extIdx = ext.length - 1, firstNonSlashEnd = -1;
+    for (i = path.length - 1;i >= 0; --i) {
+      var code = path.charCodeAt(i);
+      if (code === 47) {
+        if (!matchedSlash) {
+          start = i + 1;
+          break;
+        }
+      } else {
+        if (firstNonSlashEnd === -1)
+          matchedSlash = false, firstNonSlashEnd = i + 1;
+        if (extIdx >= 0)
+          if (code === ext.charCodeAt(extIdx)) {
+            if (--extIdx === -1)
+              end = i;
+          } else
+            extIdx = -1, end = firstNonSlashEnd;
+      }
+    }
+    if (start === end)
+      end = firstNonSlashEnd;
+    else if (end === -1)
+      end = path.length;
+    return path.slice(start, end);
+  } else {
+    for (i = path.length - 1;i >= 0; --i)
+      if (path.charCodeAt(i) === 47) {
+        if (!matchedSlash) {
+          start = i + 1;
+          break;
+        }
+      } else if (end === -1)
+        matchedSlash = false, end = i + 1;
+    if (end === -1)
+      return "";
+    return path.slice(start, end);
+  }
+}
+function extname(path) {
+  assertPath(path);
+  var startDot = -1, startPart = 0, end = -1, matchedSlash = true, preDotState = 0;
+  for (var i = path.length - 1;i >= 0; --i) {
+    var code = path.charCodeAt(i);
+    if (code === 47) {
+      if (!matchedSlash) {
+        startPart = i + 1;
+        break;
+      }
+      continue;
+    }
+    if (end === -1)
+      matchedSlash = false, end = i + 1;
+    if (code === 46) {
+      if (startDot === -1)
+        startDot = i;
+      else if (preDotState !== 1)
+        preDotState = 1;
+    } else if (startDot !== -1)
+      preDotState = -1;
+  }
+  if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1)
+    return "";
+  return path.slice(startDot, end);
+}
+function format(pathObject) {
+  if (pathObject === null || typeof pathObject !== "object")
+    throw TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof pathObject);
+  return _format("/", pathObject);
+}
+function parse(path) {
+  assertPath(path);
+  var ret = { root: "", dir: "", base: "", ext: "", name: "" };
+  if (path.length === 0)
+    return ret;
+  var code = path.charCodeAt(0), isAbsolute2 = code === 47, start;
+  if (isAbsolute2)
+    ret.root = "/", start = 1;
+  else
+    start = 0;
+  var startDot = -1, startPart = 0, end = -1, matchedSlash = true, i = path.length - 1, preDotState = 0;
+  for (;i >= start; --i) {
+    if (code = path.charCodeAt(i), code === 47) {
+      if (!matchedSlash) {
+        startPart = i + 1;
+        break;
+      }
+      continue;
+    }
+    if (end === -1)
+      matchedSlash = false, end = i + 1;
+    if (code === 46) {
+      if (startDot === -1)
+        startDot = i;
+      else if (preDotState !== 1)
+        preDotState = 1;
+    } else if (startDot !== -1)
+      preDotState = -1;
+  }
+  if (startDot === -1 || end === -1 || preDotState === 0 || preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+    if (end !== -1)
+      if (startPart === 0 && isAbsolute2)
+        ret.base = ret.name = path.slice(1, end);
+      else
+        ret.base = ret.name = path.slice(startPart, end);
+  } else {
+    if (startPart === 0 && isAbsolute2)
+      ret.name = path.slice(1, startDot), ret.base = path.slice(1, end);
+    else
+      ret.name = path.slice(startPart, startDot), ret.base = path.slice(startPart, end);
+    ret.ext = path.slice(startDot, end);
+  }
+  if (startPart > 0)
+    ret.dir = path.slice(0, startPart - 1);
+  else if (isAbsolute2)
+    ret.dir = "/";
+  return ret;
+}
+var sep = "/";
+var delimiter = ":";
+var posix = ((p) => (p.posix = p, p))({ resolve, normalize, isAbsolute, join, relative, _makeLong, dirname, basename, extname, format, parse, sep, delimiter, win32: null, posix: null });
+
+// sources/config.ts
+var CONFIG_DIR = join(homedir(), ".brex");
+var TOKEN_PATH = join(CONFIG_DIR, "token");
+var CONFIG_PATH = join(CONFIG_DIR, "config.json");
+function ensureConfigDir() {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { mode: 448, recursive: true });
+  }
+}
+function loadToken() {
+  if (!existsSync(TOKEN_PATH)) {
+    return null;
+  }
+  try {
+    const value = readFileSync(TOKEN_PATH, "utf-8").trim();
+    return value.length > 0 ? value : null;
+  } catch {
+    return null;
+  }
+}
+function saveToken(token) {
+  ensureConfigDir();
+  writeFileSync(TOKEN_PATH, token.trim(), { mode: 384 });
+}
+function clearToken() {
+  if (existsSync(TOKEN_PATH)) {
+    unlinkSync(TOKEN_PATH);
+  }
+}
+function loadConfig() {
+  if (!existsSync(CONFIG_PATH)) {
+    return {};
+  }
+  try {
+    return JSON.parse(readFileSync(CONFIG_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function getApiBaseUrl() {
+  const config = loadConfig();
+  return config.apiBaseUrl ?? "https://platform.brexapis.com";
+}
+
+// sources/client.ts
+class BrexApiError extends Error {
+  status;
+  body;
+  constructor(status, body) {
+    super(body.message ?? body.error ?? `HTTP ${status}`);
+    this.name = "BrexApiError";
+    this.status = status;
+    this.body = body;
+  }
+}
+function createBrexClient() {
+  const token = loadToken();
+  const baseUrl = getApiBaseUrl();
+  return {
+    baseUrl,
+    token,
+    fetch: async (path, init) => {
+      if (!token) {
+        throw new Error("Not authenticated. Run 'brex login' first.");
+      }
+      const url = path.startsWith("http") ? path : `${baseUrl}${path}`;
+      const response = await fetch(url, {
+        ...init,
+        headers: {
+          Authorization: `Bearer ${token}`,
+          "Content-Type": "application/json",
+          Accept: "application/json",
+          ...init?.headers
+        }
+      });
+      if (!response.ok) {
+        let body;
+        try {
+          body = await response.json();
+        } catch {
+          body = { error: `HTTP ${response.status}`, message: response.statusText };
+        }
+        throw new BrexApiError(response.status, body);
+      }
+      if (response.status === 204) {
+        return;
+      }
+      return response.json();
+    }
+  };
+}
+
+// sources/commands/login/index.ts
+var USAGE = `brex login --token <API_TOKEN>
+brex login --token-stdin`;
+var loginCommand = {
+  name: "login",
+  description: "Authenticate with your Brex API token.",
+  usage: USAGE,
+  run: async (args) => {
+    const options = parseLoginArgs(args);
+    if (options.tokenStdin && options.token) {
+      throw new Error("Use either --token or --token-stdin, not both.");
+    }
+    let token = options.token;
+    if (options.tokenStdin) {
+      token = await readTokenFromStdin();
+    }
+    if (!token) {
+      const existingToken = loadToken();
+      if (existingToken) {
+        console.log("Already authenticated. Use 'brex logout' to disconnect.");
+        return;
+      }
+      throw new Error("Missing token. Use --token <TOKEN> or --token-stdin.");
+    }
+    token = token.trim();
+    if (!token) {
+      throw new Error("Token cannot be empty.");
+    }
+    saveToken(token);
+    console.log("Authenticated successfully. Token saved to ~/.brex/token");
+  }
+};
+function parseLoginArgs(args) {
+  let token;
+  let tokenStdin = false;
+  const positionals = [];
+  for (let i = 0;i < args.length; i += 1) {
+    const arg = args[i];
+    if (arg === undefined)
+      continue;
+    if (arg === "--token") {
+      const value = args[i + 1];
+      if (value === undefined) {
+        throw new Error("--token requires a value");
+      }
+      token = value;
+      i += 1;
+      continue;
+    }
+    if (arg === "--token-stdin") {
+      tokenStdin = true;
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+    positionals.push(arg);
+  }
+  if (positionals.length > 0) {
+    throw new Error(`Unexpected arguments: ${positionals.join(" ")}`);
+  }
+  return { token, tokenStdin };
+}
+async function readTokenFromStdin() {
+  const chunks = [];
+  for await (const chunk of process.stdin) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks).toString("utf-8").trim();
+}
+
+// sources/commands/logout/index.ts
+var USAGE2 = "brex logout";
+var logoutCommand = {
+  name: "logout",
+  description: "Remove stored authentication token.",
+  usage: USAGE2,
+  run: async () => {
+    const token = loadToken();
+    if (!token) {
+      console.log("Not currently authenticated.");
+      return;
+    }
+    clearToken();
+    console.log("Logged out. Token removed from ~/.brex/token");
+  }
+};
+
+// sources/commands/status/index.ts
+var USAGE3 = "brex status";
+var statusCommand = {
+  name: "status",
+  description: "Show current authentication and configuration status.",
+  usage: USAGE3,
+  run: async () => {
+    const token = loadToken();
+    const config = loadConfig();
+    const baseUrl = getApiBaseUrl();
+    console.log("Brex CLI Status");
+    console.log("──────────────────");
+    console.log(`Authenticated: ${token ? "Yes" : "No"}`);
+    if (token) {
+      const masked = token.slice(0, 10) + "..." + token.slice(-4);
+      console.log(`Token: ${masked}`);
+    }
+    console.log(`API Base URL: ${baseUrl}`);
+    if (config.defaultAccountId) {
+      console.log(`Default Account: ${config.defaultAccountId}`);
+    }
+  }
+};
+
+// sources/client.ts
+class BrexApiError2 extends Error {
+  status;
+  body;
+  constructor(status, body) {
+    super(body.message ?? body.error ?? `HTTP ${status}`);
+    this.name = "BrexApiError";
+    this.status = status;
+    this.body = body;
+  }
+}
+
+// sources/output.ts
+function parseOutputFlag(args) {
+  let format2 = "table";
+  const remaining = [];
+  for (const arg of args) {
+    if (arg === "--json") {
+      format2 = "json";
+      continue;
+    }
+    remaining.push(arg);
+  }
+  return { format: format2, args: remaining };
+}
+function printJson(data) {
+  console.log(JSON.stringify(data, null, 2));
+}
+function printTable(rows, columns) {
+  if (rows.length === 0) {
+    console.log("No results.");
+    return;
+  }
+  const widths = columns.map((col) => {
+    const headerWidth = col.header.length;
+    const maxDataWidth = rows.reduce((max, row) => {
+      const value = col.format ? col.format(row[col.key]) : String(row[col.key] ?? "");
+      return Math.max(max, value.length);
+    }, 0);
+    return col.width ?? Math.min(Math.max(headerWidth, maxDataWidth), 50);
+  });
+  const headerLine = columns.map((col, i) => col.header.padEnd(widths[i])).join("  ");
+  console.log(headerLine);
+  console.log(columns.map((_, i) => "─".repeat(widths[i])).join("  "));
+  for (const row of rows) {
+    const line = columns.map((col, i) => {
+      const value = col.format ? col.format(row[col.key]) : String(row[col.key] ?? "");
+      return value.slice(0, widths[i]).padEnd(widths[i]);
+    }).join("  ");
+    console.log(line);
+  }
+}
+function formatAmount(amount, currency = "USD") {
+  if (amount === null || amount === undefined)
+    return "-";
+  const numeric = typeof amount === "string" ? Number(amount) : amount;
+  if (!Number.isFinite(numeric)) {
+    return String(amount);
+  }
+  return new Intl.NumberFormat("en-US", {
+    style: "currency",
+    currency
+  }).format(numeric);
+}
+function formatDate(isoString) {
+  if (!isoString)
+    return "-";
+  const date = new Date(isoString);
+  return date.toLocaleDateString("en-US", {
+    year: "numeric",
+    month: "short",
+    day: "numeric"
+  });
+}
+function formatDateTime(isoString) {
+  if (!isoString)
+    return "-";
+  const date = new Date(isoString);
+  return date.toLocaleString("en-US", {
+    year: "numeric",
+    month: "short",
+    day: "numeric",
+    hour: "2-digit",
+    minute: "2-digit"
+  });
+}
+function truncate(str, maxLen) {
+  if (str.length <= maxLen)
+    return str;
+  return str.slice(0, maxLen - 3) + "...";
+}
+
+// sources/commands/accounts/index.ts
+var USAGE4 = `brex accounts
+brex accounts list [--type cash|card|all] [--cursor <cursor>]
+brex accounts get <account-id> [--type cash|card]
+brex accounts --json`;
+var accountsCommand = {
+  name: "accounts",
+  description: "List and view Brex cash/card accounts.",
+  usage: USAGE4,
+  aliases: ["account", "acc"],
+  run: async (args, context) => {
+    const { format: format2, args: remaining } = parseOutputFlag(args);
+    const subcommand = remaining[0] ?? "list";
+    switch (subcommand) {
+      case "list":
+        await listAccounts(context, parseListOptions(remaining.slice(1)), format2);
+        return;
+      case "get": {
+        const accountId = remaining[1];
+        if (!accountId) {
+          throw new Error("Missing account ID. Usage: brex accounts get <account-id> [--type cash|card]");
+        }
+        await getAccount(context, accountId, parseGetOptions(remaining.slice(2)), format2);
+        return;
+      }
+      default:
+        throw new Error(`Unknown subcommand: ${subcommand}. Use 'list' or 'get'.`);
+    }
+  }
+};
+function parseListOptions(args) {
+  let type = "all";
+  let cursor;
+  for (let i = 0;i < args.length; i += 1) {
+    const arg = args[i];
+    if (!arg)
+      continue;
+    if (arg === "--type") {
+      const value = args[++i];
+      if (!value || value !== "cash" && value !== "card" && value !== "all") {
+        throw new Error("--type must be one of: cash, card, all");
+      }
+      type = value;
+      continue;
+    }
+    if (arg === "--cursor") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--cursor requires a value");
+      cursor = value;
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+  }
+  if (type === "all" && cursor) {
+    throw new Error("--cursor can only be used with --type cash or --type card");
+  }
+  return { type, cursor };
+}
+function parseGetOptions(args) {
+  let type;
+  for (let i = 0;i < args.length; i += 1) {
+    const arg = args[i];
+    if (!arg)
+      continue;
+    if (arg === "--type") {
+      const value = args[++i];
+      if (!value || value !== "cash" && value !== "card") {
+        throw new Error("--type must be one of: cash, card");
+      }
+      type = value;
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+  }
+  return { type };
+}
+async function listAccounts(context, options, format2) {
+  const cashPath = withCursor("/v2/accounts/cash", options.cursor);
+  const cardPath = withCursor("/v2/accounts/card", options.cursor);
+  if (options.type === "cash") {
+    const cashResponse2 = await context.client.fetch(cashPath);
+    const cashAccounts2 = extractItems(cashResponse2, ["items", "cash_accounts", "accounts"]);
+    if (format2 === "json") {
+      printJson({ items: cashAccounts2, nextCursor: cashResponse2.next_cursor ?? null });
+      return;
+    }
+    printAccountsTable(cashAccounts2.map((account) => toAccountRow(account, "cash")));
+    if (cashResponse2.next_cursor) {
+      console.log(`
+Next cursor: ${cashResponse2.next_cursor}`);
+    }
+    return;
+  }
+  if (options.type === "card") {
+    const cardResponse2 = await context.client.fetch(cardPath);
+    const cardAccounts2 = extractItems(cardResponse2, ["items", "card_accounts", "accounts"]);
+    if (format2 === "json") {
+      printJson({ items: cardAccounts2, nextCursor: cardResponse2.next_cursor ?? null });
+      return;
+    }
+    printAccountsTable(cardAccounts2.map((account) => toAccountRow(account, "card")));
+    if (cardResponse2.next_cursor) {
+      console.log(`
+Next cursor: ${cardResponse2.next_cursor}`);
+    }
+    return;
+  }
+  const [cashResponse, cardResponse] = await Promise.all([
+    context.client.fetch(cashPath),
+    context.client.fetch(cardPath)
+  ]);
+  const cashAccounts = extractItems(cashResponse, ["items", "cash_accounts", "accounts"]);
+  const cardAccounts = extractItems(cardResponse, ["items", "card_accounts", "accounts"]);
+  if (format2 === "json") {
+    printJson({
+      cash: { items: cashAccounts, nextCursor: cashResponse.next_cursor ?? null },
+      card: { items: cardAccounts, nextCursor: cardResponse.next_cursor ?? null }
+    });
+    return;
+  }
+  const rows = [
+    ...cashAccounts.map((account) => toAccountRow(account, "cash")),
+    ...cardAccounts.map((account) => toAccountRow(account, "card"))
+  ];
+  printAccountsTable(rows);
+}
+async function getAccount(context, accountId, options, format2) {
+  const fetchCash = async () => context.client.fetch(`/v2/accounts/cash/${accountId}`);
+  const fetchCard = async () => context.client.fetch(`/v2/accounts/card/${accountId}`);
+  if (options.type === "cash") {
+    const account = await fetchCash();
+    renderAccount(account, "cash", format2);
+    return;
+  }
+  if (options.type === "card") {
+    const account = await fetchCard();
+    renderAccount(account, "card", format2);
+    return;
+  }
+  try {
+    const account = await fetchCash();
+    renderAccount(account, "cash", format2);
+    return;
+  } catch (error) {
+    if (!(error instanceof BrexApiError2) || error.status !== 404) {
+      throw error;
+    }
+  }
+  const cardAccount = await fetchCard();
+  renderAccount(cardAccount, "card", format2);
+}
+function renderAccount(account, type, format2) {
+  if (format2 === "json") {
+    printJson(account);
+    return;
+  }
+  const row = toAccountRow(account, type);
+  console.log("Account Details");
+  console.log("───────────────");
+  console.log(`ID:              ${row.id}`);
+  console.log(`Name:            ${row.name}`);
+  console.log(`Type:            ${row.type}`);
+  console.log(`Status:          ${row.status}`);
+  if (row.accountNumber !== "-")
+    console.log(`Account Number:  ${row.accountNumber}`);
+  if (row.routingNumber !== "-")
+    console.log(`Routing Number:  ${row.routingNumber}`);
+  console.log(`Available:       ${row.available}`);
+  console.log(`Current:         ${row.current}`);
+}
+function toAccountRow(account, type) {
+  const availableBalance = "available_balance" in account ? account.available_balance : undefined;
+  const currentBalance = account.current_balance;
+  const status = account.status ?? "-";
+  const accountName = account.account_name ?? "-";
+  const accountType = account.account_type ?? type;
+  return {
+    id: account.id,
+    name: accountName,
+    type: accountType,
+    status,
+    accountNumber: "account_number" in account ? account.account_number ?? "-" : "-",
+    routingNumber: "routing_number" in account ? account.routing_number ?? "-" : "-",
+    available: formatMoney(availableBalance ?? currentBalance),
+    current: formatMoney(currentBalance)
+  };
+}
+function formatMoney(balance) {
+  if (!balance)
+    return "-";
+  return formatAmount(balance.amount, balance.currency);
+}
+function withCursor(path, cursor) {
+  if (!cursor)
+    return path;
+  return `${path}?cursor=${encodeURIComponent(cursor)}`;
+}
+function extractItems(response, keys) {
+  for (const key of keys) {
+    const value = response[key];
+    if (Array.isArray(value))
+      return value;
+  }
+  return [];
+}
+function printAccountsTable(rows) {
+  if (rows.length === 0) {
+    console.log("No accounts found.");
+    return;
+  }
+  printTable(rows, [
+    { key: "id", header: "ID", width: 36 },
+    { key: "name", header: "Name", width: 22 },
+    { key: "type", header: "Type", width: 12 },
+    { key: "status", header: "Status", width: 10 },
+    { key: "accountNumber", header: "Account #", width: 12 },
+    { key: "available", header: "Available", width: 14 },
+    { key: "current", header: "Current", width: 14 }
+  ]);
+}
+
+// sources/commands/transactions/index.ts
+var USAGE5 = `brex transactions <account-id> [--type cash|card] [--limit <N>] [--cursor <cursor>] [--start-time <ISO>] [--end-time <ISO>]
+brex transactions get <account-id> <transaction-id> [--type cash|card]
+brex transactions --json`;
+var transactionsCommand = {
+  name: "transactions",
+  description: "List and view Brex account transactions.",
+  usage: USAGE5,
+  aliases: ["tx", "txn"],
+  run: async (args, context) => {
+    const { format: format2, args: remaining } = parseOutputFlag(args);
+    if (remaining.length === 0) {
+      throw new Error("Missing account ID. Usage: brex transactions <account-id>");
+    }
+    const firstArg = remaining[0];
+    if (firstArg === "get") {
+      const accountId2 = remaining[1];
+      const transactionId = remaining[2];
+      if (!accountId2 || !transactionId) {
+        throw new Error("Usage: brex transactions get <account-id> <transaction-id> [--type cash|card]");
+      }
+      await getTransaction(context, accountId2, transactionId, parseGetOptions2(remaining.slice(3)), format2);
+      return;
+    }
+    if (firstArg === "send") {
+      throw new Error("Brex sends money via Transfers API. Use `brex transfer` instead.");
+    }
+    const accountId = firstArg;
+    const options = parseListOptions2(remaining.slice(1));
+    await listTransactions(context, accountId, options, format2);
+  }
+};
+function parseListOptions2(args) {
+  const options = { type: "cash" };
+  for (let i = 0;i < args.length; i += 1) {
+    const arg = args[i];
+    if (!arg)
+      continue;
+    if (arg === "--type") {
+      const value = args[++i];
+      if (!value || value !== "cash" && value !== "card") {
+        throw new Error("--type must be one of: cash, card");
+      }
+      options.type = value;
+      continue;
+    }
+    if (arg === "--limit") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--limit requires a value");
+      const parsed = parseInt(value, 10);
+      if (Number.isNaN(parsed) || parsed <= 0) {
+        throw new Error("--limit must be a positive integer");
+      }
+      options.limit = parsed;
+      continue;
+    }
+    if (arg === "--cursor") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--cursor requires a value");
+      options.cursor = value;
+      continue;
+    }
+    if (arg === "--start-time" || arg === "--start") {
+      const value = args[++i];
+      if (!value)
+        throw new Error(`${arg} requires a value`);
+      options.startTime = value;
+      continue;
+    }
+    if (arg === "--end-time" || arg === "--end") {
+      const value = args[++i];
+      if (!value)
+        throw new Error(`${arg} requires a value`);
+      options.endTime = value;
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+  }
+  return options;
+}
+function parseGetOptions2(args) {
+  let type = "cash";
+  for (let i = 0;i < args.length; i += 1) {
+    const arg = args[i];
+    if (!arg)
+      continue;
+    if (arg === "--type") {
+      const value = args[++i];
+      if (!value || value !== "cash" && value !== "card") {
+        throw new Error("--type must be one of: cash, card");
+      }
+      type = value;
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+  }
+  return { type };
+}
+async function listTransactions(context, accountId, options, format2) {
+  const pathBase = options.type === "cash" ? `/v2/accounts/cash/${accountId}/transactions` : `/v2/accounts/card/${accountId}/transactions`;
+  const path = withQuery(pathBase, options);
+  const response = await context.client.fetch(path);
+  const transactions = response.items ?? response.transactions ?? [];
+  if (format2 === "json") {
+    printJson({ items: transactions, nextCursor: response.next_cursor ?? null });
+    return;
+  }
+  if (transactions.length === 0) {
+    console.log("No transactions found.");
+    return;
+  }
+  printTable(transactions.map((tx) => toTableRow(tx)), [
+    { key: "id", header: "ID", width: 36 },
+    { key: "type", header: "Type", width: 16 },
+    { key: "status", header: "Status", width: 12 },
+    { key: "amount", header: "Amount", width: 14 },
+    { key: "counterparty", header: "Counterparty", width: 25 },
+    { key: "postedAt", header: "Posted", width: 20 }
+  ]);
+  if (response.next_cursor) {
+    console.log(`
+Next cursor: ${response.next_cursor}`);
+  }
+}
+async function getTransaction(context, accountId, transactionId, options, format2) {
+  const path = options.type === "cash" ? `/v2/accounts/cash/${accountId}/transactions/${transactionId}` : `/v2/accounts/card/${accountId}/transactions/${transactionId}`;
+  const response = await context.client.fetch(path);
+  const transaction = response.cash_transaction ?? response.card_transaction ?? response.transaction ?? response.item;
+  if (!transaction) {
+    throw new Error("Brex API returned an empty transaction payload.");
+  }
+  if (format2 === "json") {
+    printJson(transaction);
+    return;
+  }
+  const amount = transaction.amount ? formatAmount(transaction.amount.amount, transaction.amount.currency) : "-";
+  console.log("Transaction Details");
+  console.log("───────────────────");
+  console.log(`ID:              ${transaction.id}`);
+  console.log(`Type:            ${transaction.transaction_type ?? "-"}`);
+  console.log(`Source Type:     ${transaction.transaction_source_type ?? "-"}`);
+  console.log(`Status:          ${transaction.status ?? "-"}`);
+  console.log(`Amount:          ${amount}`);
+  console.log(`Counterparty:    ${transaction.counterparty_name ?? transaction.merchant_name ?? "-"}`);
+  console.log(`Description:     ${transaction.description ?? "-"}`);
+  console.log(`Memo:            ${transaction.memo ?? "-"}`);
+  console.log(`Initiated At:    ${formatDateTime(transaction.initiated_at)}`);
+  console.log(`Posted At:       ${formatDateTime(transaction.posted_at)}`);
+}
+function withQuery(path, options) {
+  const params = new URLSearchParams;
+  if (options.limit)
+    params.set("limit", String(options.limit));
+  if (options.cursor)
+    params.set("cursor", options.cursor);
+  if (options.startTime)
+    params.set("start_time", options.startTime);
+  if (options.endTime)
+    params.set("end_time", options.endTime);
+  const query = params.toString();
+  return query ? `${path}?${query}` : path;
+}
+function toTableRow(transaction) {
+  return {
+    id: transaction.id,
+    type: truncate(transaction.transaction_type ?? "-", 16),
+    status: transaction.status ?? "-",
+    amount: transaction.amount ? formatAmount(transaction.amount.amount, transaction.amount.currency) : "-",
+    counterparty: truncate(transaction.counterparty_name ?? transaction.merchant_name ?? "-", 25),
+    postedAt: formatDateTime(transaction.posted_at ?? transaction.initiated_at)
+  };
+}
+
+// sources/commands/transfer/index.ts
+var USAGE6 = `brex transfer --from <cash-account-id> --to <counterparty-id> --amount <decimal> --idempotency-key <key> [--currency <code>]
+brex transfer get <transfer-id>
+brex transfer list [--cursor <cursor>] [--limit <N>] [--status <status>] [--from-account-id <id>] [--to-counterparty-id <id>]
+brex transfer --json`;
+var transferCommand = {
+  name: "transfer",
+  description: "Create and inspect transfers.",
+  usage: USAGE6,
+  run: async (args, context) => {
+    const { format: format2, args: remaining } = parseOutputFlag(args);
+    const subcommand = remaining[0];
+    if (subcommand === "get") {
+      const transferId = remaining[1];
+      if (!transferId)
+        throw new Error("Usage: brex transfer get <transfer-id>");
+      await getTransfer(context, transferId, format2);
+      return;
+    }
+    if (subcommand === "list") {
+      await listTransfers(context, parseListTransferOptions(remaining.slice(1)), format2);
+      return;
+    }
+    const options = parseCreateTransferOptions(remaining);
+    await createTransfer(context, options, format2);
+  }
+};
+function parseCreateTransferOptions(args) {
+  let fromAccountId;
+  let toCounterpartyId;
+  let amount;
+  let currency = "USD";
+  let idempotencyKey;
+  for (let i = 0;i < args.length; i += 1) {
+    const arg = args[i];
+    if (!arg)
+      continue;
+    if (arg === "--from") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--from requires a value");
+      fromAccountId = value;
+      continue;
+    }
+    if (arg === "--to") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--to requires a value");
+      toCounterpartyId = value;
+      continue;
+    }
+    if (arg === "--amount") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--amount requires a value");
+      const parsed = Number(value);
+      if (!Number.isFinite(parsed) || parsed <= 0) {
+        throw new Error("--amount must be a positive number (e.g. 125.50)");
+      }
+      amount = parsed.toFixed(2);
+      continue;
+    }
+    if (arg === "--currency") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--currency requires a value");
+      currency = value.toUpperCase();
+      continue;
+    }
+    if (arg === "--idempotency-key") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--idempotency-key requires a value");
+      idempotencyKey = value;
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+  }
+  if (!fromAccountId)
+    throw new Error("Missing required --from");
+  if (!toCounterpartyId)
+    throw new Error("Missing required --to");
+  if (!amount)
+    throw new Error("Missing required --amount");
+  if (!idempotencyKey)
+    throw new Error("Missing required --idempotency-key");
+  return { fromAccountId, toCounterpartyId, amount, currency, idempotencyKey };
+}
+function parseListTransferOptions(args) {
+  const options = {};
+  for (let i = 0;i < args.length; i += 1) {
+    const arg = args[i];
+    if (!arg)
+      continue;
+    if (arg === "--cursor") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--cursor requires a value");
+      options.cursor = value;
+      continue;
+    }
+    if (arg === "--limit") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--limit requires a value");
+      const parsed = parseInt(value, 10);
+      if (Number.isNaN(parsed) || parsed <= 0) {
+        throw new Error("--limit must be a positive integer");
+      }
+      options.limit = parsed;
+      continue;
+    }
+    if (arg === "--status") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--status requires a value");
+      options.status = value;
+      continue;
+    }
+    if (arg === "--from-account-id") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--from-account-id requires a value");
+      options.fromAccountId = value;
+      continue;
+    }
+    if (arg === "--to-counterparty-id") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--to-counterparty-id requires a value");
+      options.toCounterpartyId = value;
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+  }
+  return options;
+}
+async function createTransfer(context, options, format2) {
+  const body = {
+    from_account: {
+      cash_account: {
+        id: options.fromAccountId
+      }
+    },
+    recipient: {
+      payment_counterparty: {
+        id: options.toCounterpartyId
+      }
+    },
+    amount: {
+      amount: options.amount,
+      currency: options.currency
+    },
+    idempotency_key: options.idempotencyKey
+  };
+  const response = await context.client.fetch("/v1/transfers", {
+    method: "POST",
+    headers: {
+      "Idempotency-Key": options.idempotencyKey
+    },
+    body: JSON.stringify(body)
+  });
+  const transfer = response.transfer ?? response.item ?? response;
+  if (format2 === "json") {
+    printJson(transfer);
+    return;
+  }
+  printTransferDetails(transfer, "Transfer Created");
+}
+async function getTransfer(context, transferId, format2) {
+  const response = await context.client.fetch(`/v1/transfers/${transferId}`);
+  const transfer = response.transfer ?? response.item ?? response;
+  if (format2 === "json") {
+    printJson(transfer);
+    return;
+  }
+  printTransferDetails(transfer, "Transfer Details");
+}
+async function listTransfers(context, options, format2) {
+  const params = new URLSearchParams;
+  if (options.cursor)
+    params.set("cursor", options.cursor);
+  if (options.limit)
+    params.set("limit", String(options.limit));
+  if (options.status)
+    params.set("status", options.status);
+  if (options.fromAccountId)
+    params.set("from_account_id", options.fromAccountId);
+  if (options.toCounterpartyId)
+    params.set("to_counterparty_id", options.toCounterpartyId);
+  const query = params.toString();
+  const path = query ? `/v1/transfers?${query}` : "/v1/transfers";
+  const response = await context.client.fetch(path);
+  const transfers = response.items ?? response.transfers ?? [];
+  if (format2 === "json") {
+    printJson({ items: transfers, nextCursor: response.next_cursor ?? null });
+    return;
+  }
+  if (transfers.length === 0) {
+    console.log("No transfers found.");
+    return;
+  }
+  printTable(transfers.map((transfer) => ({
+    id: transfer.id,
+    from: transfer.from_account?.cash_account?.id ?? "-",
+    to: transfer.recipient?.payment_counterparty?.id ?? "-",
+    amount: transfer.amount ? formatAmount(transfer.amount.amount, transfer.amount.currency) : "-",
+    status: transfer.status ?? "-"
+  })), [
+    { key: "id", header: "Transfer ID", width: 36 },
+    { key: "from", header: "From Account", width: 36 },
+    { key: "to", header: "To Counterparty", width: 36 },
+    { key: "amount", header: "Amount", width: 14 },
+    { key: "status", header: "Status", width: 14 }
+  ]);
+  if (response.next_cursor) {
+    console.log(`
+Next cursor: ${response.next_cursor}`);
+  }
+}
+function printTransferDetails(transfer, title) {
+  console.log(title);
+  console.log("──────────────────");
+  console.log(`ID:          ${transfer.id}`);
+  console.log(`From Account:${" "}${transfer.from_account?.cash_account?.id ?? "-"}`);
+  console.log(`To Recipient:${" "}${transfer.recipient?.payment_counterparty?.id ?? "-"}`);
+  console.log(`Amount:      ${transfer.amount ? formatAmount(transfer.amount.amount, transfer.amount.currency) : "-"}`);
+  console.log(`Status:      ${transfer.status ?? "-"}`);
+  if (transfer.idempotency_key) {
+    console.log(`Idempotency: ${transfer.idempotency_key}`);
+  }
+}
+
+// sources/commands/recipients/index.ts
+var USAGE7 = `brex recipients
+brex recipients list [--limit <N>] [--cursor <cursor>] [--name <name>]
+brex recipients get <counterparty-id>
+brex recipients add --name <name> --account <number> --routing <number> [--account-type CHECKING|SAVINGS]
+brex recipients delete <counterparty-id>
+brex recipients --json`;
+var recipientsCommand = {
+  name: "recipients",
+  description: "Manage payment counterparties.",
+  usage: USAGE7,
+  aliases: ["recipient", "recip"],
+  run: async (args, context) => {
+    const { format: format2, args: remaining } = parseOutputFlag(args);
+    const subcommand = remaining[0] ?? "list";
+    switch (subcommand) {
+      case "list":
+        await listRecipients(context, parseListOptions3(remaining.slice(1)), format2);
+        return;
+      case "get": {
+        const recipientId = remaining[1];
+        if (!recipientId)
+          throw new Error("Missing recipient ID. Usage: brex recipients get <counterparty-id>");
+        await getRecipient(context, recipientId, format2);
+        return;
+      }
+      case "add":
+        await addRecipient(context, parseAddOptions(remaining.slice(1)), format2);
+        return;
+      case "delete": {
+        const recipientId = remaining[1];
+        if (!recipientId)
+          throw new Error("Missing recipient ID. Usage: brex recipients delete <counterparty-id>");
+        await deleteRecipient(context, recipientId);
+        return;
+      }
+      default:
+        throw new Error(`Unknown subcommand: ${subcommand}. Use 'list', 'get', 'add', or 'delete'.`);
+    }
+  }
+};
+function parseListOptions3(args) {
+  const options = {};
+  for (let i = 0;i < args.length; i += 1) {
+    const arg = args[i];
+    if (!arg)
+      continue;
+    if (arg === "--limit") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--limit requires a value");
+      const parsed = parseInt(value, 10);
+      if (Number.isNaN(parsed) || parsed <= 0) {
+        throw new Error("--limit must be a positive integer");
+      }
+      options.limit = parsed;
+      continue;
+    }
+    if (arg === "--cursor") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--cursor requires a value");
+      options.cursor = value;
+      continue;
+    }
+    if (arg === "--name") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--name requires a value");
+      options.name = value;
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+  }
+  return options;
+}
+function parseAddOptions(args) {
+  let name;
+  let accountNumber;
+  let routingNumber;
+  let accountType;
+  let country;
+  let currency;
+  for (let i = 0;i < args.length; i += 1) {
+    const arg = args[i];
+    if (!arg)
+      continue;
+    if (arg === "--name") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--name requires a value");
+      name = value;
+      continue;
+    }
+    if (arg === "--account") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--account requires a value");
+      accountNumber = value;
+      continue;
+    }
+    if (arg === "--routing") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--routing requires a value");
+      routingNumber = value;
+      continue;
+    }
+    if (arg === "--account-type") {
+      const value = args[++i];
+      if (!value || value !== "CHECKING" && value !== "SAVINGS") {
+        throw new Error("--account-type must be CHECKING or SAVINGS");
+      }
+      accountType = value;
+      continue;
+    }
+    if (arg === "--country") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--country requires a value");
+      country = value;
+      continue;
+    }
+    if (arg === "--currency") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--currency requires a value");
+      currency = value;
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+  }
+  if (!name)
+    throw new Error("Missing required --name");
+  if (!accountNumber)
+    throw new Error("Missing required --account");
+  if (!routingNumber)
+    throw new Error("Missing required --routing");
+  return { name, accountNumber, routingNumber, accountType, country, currency };
+}
+async function listRecipients(context, options, format2) {
+  const params = new URLSearchParams;
+  if (options.limit)
+    params.set("limit", String(options.limit));
+  if (options.cursor)
+    params.set("cursor", options.cursor);
+  if (options.name)
+    params.set("name", options.name);
+  const query = params.toString();
+  const path = query ? `/v1/payment_counterparties?${query}` : "/v1/payment_counterparties";
+  const response = await context.client.fetch(path);
+  const recipients = response.items ?? response.payment_counterparties ?? [];
+  if (format2 === "json") {
+    printJson({ items: recipients, nextCursor: response.next_cursor ?? null });
+    return;
+  }
+  if (recipients.length === 0) {
+    console.log("No recipients found.");
+    return;
+  }
+  printTable(recipients.map((recipient) => {
+    const bank = recipient.payment_instruments?.[0]?.bank_transfer;
+    return {
+      id: recipient.id,
+      name: truncate(recipient.name ?? "-", 30),
+      account: bank?.account_number ? `...${bank.account_number.slice(-4)}` : "-",
+      routing: bank?.routing_number ?? "-",
+      bank: truncate(bank?.bank_name ?? "-", 20)
+    };
+  }), [
+    { key: "id", header: "ID", width: 36 },
+    { key: "name", header: "Name", width: 30 },
+    { key: "account", header: "Account", width: 12 },
+    { key: "routing", header: "Routing", width: 12 },
+    { key: "bank", header: "Bank", width: 20 }
+  ]);
+  if (response.next_cursor) {
+    console.log(`
+Next cursor: ${response.next_cursor}`);
+  }
+}
+async function getRecipient(context, recipientId, format2) {
+  const response = await context.client.fetch(`/v1/payment_counterparties/${recipientId}`);
+  const recipient = response.payment_counterparty ?? response.item ?? response;
+  if (format2 === "json") {
+    printJson(recipient);
+    return;
+  }
+  const bank = recipient.payment_instruments?.[0]?.bank_transfer;
+  console.log("Recipient Details");
+  console.log("─────────────────");
+  console.log(`ID:             ${recipient.id}`);
+  console.log(`Name:           ${recipient.name ?? "-"}`);
+  console.log(`Account Number: ${bank?.account_number ?? "-"}`);
+  console.log(`Routing Number: ${bank?.routing_number ?? "-"}`);
+  if (bank?.bank_name)
+    console.log(`Bank Name:      ${bank.bank_name}`);
+  if (bank?.account_type)
+    console.log(`Account Type:   ${bank.account_type}`);
+  if (bank?.country)
+    console.log(`Country:        ${bank.country}`);
+  if (bank?.currency)
+    console.log(`Currency:       ${bank.currency}`);
+}
+async function addRecipient(context, options, format2) {
+  const body = {
+    name: options.name,
+    payment_instrument: {
+      bank_transfer: {
+        account_number: options.accountNumber,
+        routing_number: options.routingNumber,
+        ...options.accountType ? { account_type: options.accountType } : {},
+        ...options.country ? { country: options.country } : {},
+        ...options.currency ? { currency: options.currency } : {}
+      }
+    }
+  };
+  const response = await context.client.fetch("/v1/payment_counterparties", {
+    method: "POST",
+    body: JSON.stringify(body)
+  });
+  const recipient = response.payment_counterparty ?? response.item ?? response;
+  if (format2 === "json") {
+    printJson(recipient);
+    return;
+  }
+  console.log("Recipient Created");
+  console.log("─────────────────");
+  console.log(`ID:   ${recipient.id}`);
+  console.log(`Name: ${recipient.name ?? "-"}`);
+}
+async function deleteRecipient(context, recipientId) {
+  await context.client.fetch(`/v1/payment_counterparties/${recipientId}`, {
+    method: "DELETE"
+  });
+  console.log(`Recipient ${recipientId} deleted.`);
+}
+
+// sources/commands/cards/index.ts
+var USAGE8 = `brex cards [list] [--user-id <user-id>] [--cursor <cursor>] [--limit <N>]
+brex cards get <card-id>
+brex cards --json`;
+var cardsCommand = {
+  name: "cards",
+  description: "List and view cards.",
+  usage: USAGE8,
+  aliases: ["card"],
+  run: async (args, context) => {
+    const { format: format2, args: remaining } = parseOutputFlag(args);
+    const subcommand = remaining[0] ?? "list";
+    if (subcommand === "get") {
+      const cardId = remaining[1];
+      if (!cardId) {
+        throw new Error("Usage: brex cards get <card-id>");
+      }
+      await getCard(context, cardId, format2);
+      return;
+    }
+    if (subcommand !== "list" && !subcommand.startsWith("-")) {
+      await getCard(context, subcommand, format2);
+      return;
+    }
+    const listArgs = subcommand === "list" ? remaining.slice(1) : remaining;
+    await listCards(context, parseListOptions4(listArgs), format2);
+  }
+};
+function parseListOptions4(args) {
+  let userId;
+  let cursor;
+  let limit;
+  for (let i = 0;i < args.length; i += 1) {
+    const arg = args[i];
+    if (!arg)
+      continue;
+    if (arg === "--user-id") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--user-id requires a value");
+      userId = value;
+      continue;
+    }
+    if (arg === "--cursor") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--cursor requires a value");
+      cursor = value;
+      continue;
+    }
+    if (arg === "--limit") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--limit requires a value");
+      const parsed = parseInt(value, 10);
+      if (Number.isNaN(parsed) || parsed <= 0) {
+        throw new Error("--limit must be a positive integer");
+      }
+      limit = parsed;
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+  }
+  return { userId, cursor, limit };
+}
+async function listCards(context, options, format2) {
+  const params = new URLSearchParams;
+  if (options.userId)
+    params.set("user_id", options.userId);
+  if (options.cursor)
+    params.set("cursor", options.cursor);
+  if (options.limit)
+    params.set("limit", String(options.limit));
+  const query = params.toString();
+  const path = query ? `/v2/cards?${query}` : "/v2/cards";
+  const response = await context.client.fetch(path);
+  const cards = response.items ?? response.cards ?? [];
+  if (format2 === "json") {
+    printJson({ items: cards, nextCursor: response.next_cursor ?? null });
+    return;
+  }
+  if (cards.length === 0) {
+    console.log("No cards found.");
+    return;
+  }
+  printTable(cards.map((card) => ({
+    id: card.id,
+    name: card.card_name ?? "-",
+    last4: card.last_four ?? card.last_4 ?? "-",
+    status: card.status ?? "-",
+    expires: formatExpiration(card.expiration_month, card.expiration_year),
+    userId: card.cardholder?.user_id ?? "-"
+  })), [
+    { key: "id", header: "Card ID", width: 36 },
+    { key: "name", header: "Name", width: 22 },
+    { key: "last4", header: "Last 4", width: 8 },
+    { key: "status", header: "Status", width: 12 },
+    { key: "expires", header: "Expires", width: 10 },
+    { key: "userId", header: "User ID", width: 36 }
+  ]);
+  if (response.next_cursor) {
+    console.log(`
+Next cursor: ${response.next_cursor}`);
+  }
+}
+async function getCard(context, cardId, format2) {
+  const response = await context.client.fetch(`/v2/cards/${cardId}`);
+  const card = response.card ?? response.item ?? response;
+  if (format2 === "json") {
+    printJson(card);
+    return;
+  }
+  console.log("Card Details");
+  console.log("────────────");
+  console.log(`ID:         ${card.id}`);
+  console.log(`Name:       ${card.card_name ?? "-"}`);
+  console.log(`Status:     ${card.status ?? "-"}`);
+  console.log(`Last 4:     ${card.last_four ?? card.last_4 ?? "-"}`);
+  console.log(`Expires:    ${formatExpiration(card.expiration_month, card.expiration_year)}`);
+  console.log(`User ID:    ${card.cardholder?.user_id ?? "-"}`);
+}
+function formatExpiration(month, year) {
+  if (!month || !year)
+    return "-";
+  const mm = String(month).padStart(2, "0");
+  const yy = String(year);
+  return `${mm}/${yy}`;
+}
+
+// sources/commands/statements/index.ts
+var USAGE9 = `brex statements [--scope primary|additional] [--account-id <additional-card-account-id>] [--cursor <cursor>]
+brex statements get <statement-id> [--scope primary|additional] [--account-id <additional-card-account-id>]
+brex statements --json`;
+var statementsCommand = {
+  name: "statements",
+  description: "List and view card account statements.",
+  usage: USAGE9,
+  aliases: ["statement"],
+  run: async (args, context) => {
+    const { format: format2, args: remaining } = parseOutputFlag(args);
+    const firstArg = remaining[0] ?? "list";
+    if (firstArg === "get") {
+      const statementId = remaining[1];
+      if (!statementId) {
+        throw new Error("Usage: brex statements get <statement-id> [--scope primary|additional] [--account-id <id>]");
+      }
+      const options2 = parseSharedOptions(remaining.slice(2));
+      await getStatement(context, statementId, options2, format2);
+      return;
+    }
+    const options = parseListOptions5(remaining.slice(firstArg === "list" ? 1 : 0));
+    await listStatements(context, options, format2);
+  }
+};
+function parseListOptions5(args) {
+  const shared = parseSharedOptions(args);
+  let cursor;
+  for (let i = 0;i < args.length; i += 1) {
+    const arg = args[i];
+    if (!arg)
+      continue;
+    if (arg === "--cursor") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--cursor requires a value");
+      cursor = value;
+    }
+  }
+  return { ...shared, cursor };
+}
+function parseSharedOptions(args) {
+  let scope = "primary";
+  let accountId;
+  for (let i = 0;i < args.length; i += 1) {
+    const arg = args[i];
+    if (!arg)
+      continue;
+    if (arg === "--scope") {
+      const value = args[++i];
+      if (!value || value !== "primary" && value !== "additional") {
+        throw new Error("--scope must be one of: primary, additional");
+      }
+      scope = value;
+      continue;
+    }
+    if (arg === "--account-id") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--account-id requires a value");
+      accountId = value;
+      continue;
+    }
+    if (arg === "--cursor") {
+      i += 1;
+      continue;
+    }
+    if (arg === "list") {
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+  }
+  if (scope === "additional" && !accountId) {
+    throw new Error("--account-id is required when --scope additional");
+  }
+  return { scope, accountId };
+}
+async function listStatements(context, options, format2) {
+  const path = options.scope === "primary" ? withCursor2("/v2/accounts/card/primary/statements", options.cursor) : withCursor2(`/v2/accounts/card/additional/${options.accountId}/statements`, options.cursor);
+  const response = await context.client.fetch(path);
+  const statements = response.items ?? response.statements ?? [];
+  if (format2 === "json") {
+    printJson({ items: statements, nextCursor: response.next_cursor ?? null });
+    return;
+  }
+  if (statements.length === 0) {
+    console.log("No statements found.");
+    return;
+  }
+  printTable(statements.map((statement) => ({
+    id: statement.id,
+    status: statement.statement_status ?? "-",
+    start: formatDate(statement.period_start_date),
+    end: formatDate(statement.period_end_date),
+    due: formatDate(statement.due_date),
+    downloadUrl: statement.download_url ?? "-"
+  })), [
+    { key: "id", header: "Statement ID", width: 36 },
+    { key: "status", header: "Status", width: 12 },
+    { key: "start", header: "Start", width: 12 },
+    { key: "end", header: "End", width: 12 },
+    { key: "due", header: "Due", width: 12 },
+    { key: "downloadUrl", header: "Download URL", width: 50 }
+  ]);
+  if (response.next_cursor) {
+    console.log(`
+Next cursor: ${response.next_cursor}`);
+  }
+}
+async function getStatement(context, statementId, options, format2) {
+  const path = options.scope === "primary" ? `/v2/accounts/card/primary/statements/${statementId}` : `/v2/accounts/card/additional/${options.accountId}/statements/${statementId}`;
+  const response = await context.client.fetch(path);
+  const statement = response.account_statement ?? response.statement ?? response.item;
+  if (!statement) {
+    throw new Error("Brex API returned an empty statement payload.");
+  }
+  if (format2 === "json") {
+    printJson(statement);
+    return;
+  }
+  console.log("Statement Details");
+  console.log("─────────────────");
+  console.log(`ID:          ${statement.id}`);
+  console.log(`Status:      ${statement.statement_status ?? "-"}`);
+  console.log(`Period Start:${" "}${formatDate(statement.period_start_date)}`);
+  console.log(`Period End:  ${formatDate(statement.period_end_date)}`);
+  console.log(`Due Date:    ${formatDate(statement.due_date)}`);
+  console.log(`Download:    ${statement.download_url ?? "-"}`);
+}
+function withCursor2(path, cursor) {
+  if (!cursor)
+    return path;
+  return `${path}?cursor=${encodeURIComponent(cursor)}`;
+}
+
+// sources/commands/webhooks/index.ts
+var USAGE10 = `brex webhooks
+brex webhooks list [--cursor <cursor>] [--limit <N>]
+brex webhooks get <webhook-id>
+brex webhooks create --url <url> [--status <status>] [--events <event1,event2>]
+brex webhooks update <webhook-id> [--url <url>] [--status <status>] [--events <event1,event2>]
+brex webhooks delete <webhook-id>
+brex webhooks --json`;
+var webhooksCommand = {
+  name: "webhooks",
+  description: "Manage webhook endpoints.",
+  usage: USAGE10,
+  aliases: ["webhook", "wh"],
+  run: async (args, context) => {
+    const { format: format2, args: remaining } = parseOutputFlag(args);
+    const subcommand = remaining[0] ?? "list";
+    switch (subcommand) {
+      case "list":
+        await listWebhooks(context, parseListOptions6(remaining.slice(1)), format2);
+        return;
+      case "get": {
+        const webhookId = remaining[1];
+        if (!webhookId)
+          throw new Error("Missing webhook ID. Usage: brex webhooks get <webhook-id>");
+        await getWebhook(context, webhookId, format2);
+        return;
+      }
+      case "create":
+        await createWebhook(context, parseCreateOptions(remaining.slice(1)), format2);
+        return;
+      case "update": {
+        const webhookId = remaining[1];
+        if (!webhookId)
+          throw new Error("Missing webhook ID. Usage: brex webhooks update <webhook-id> ...");
+        await updateWebhook(context, webhookId, parseUpdateOptions(remaining.slice(2)), format2);
+        return;
+      }
+      case "delete": {
+        const webhookId = remaining[1];
+        if (!webhookId)
+          throw new Error("Missing webhook ID. Usage: brex webhooks delete <webhook-id>");
+        await deleteWebhook(context, webhookId);
+        return;
+      }
+      case "verify":
+        throw new Error("`brex webhooks verify` is not available in the current Brex Webhooks API.");
+      default:
+        throw new Error(`Unknown subcommand: ${subcommand}`);
+    }
+  }
+};
+function parseListOptions6(args) {
+  const options = {};
+  for (let i = 0;i < args.length; i += 1) {
+    const arg = args[i];
+    if (!arg)
+      continue;
+    if (arg === "--cursor") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--cursor requires a value");
+      options.cursor = value;
+      continue;
+    }
+    if (arg === "--limit") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--limit requires a value");
+      const parsed = parseInt(value, 10);
+      if (Number.isNaN(parsed) || parsed <= 0) {
+        throw new Error("--limit must be a positive integer");
+      }
+      options.limit = parsed;
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+  }
+  return options;
+}
+function parseCreateOptions(args) {
+  let url;
+  let status;
+  let events;
+  for (let i = 0;i < args.length; i += 1) {
+    const arg = args[i];
+    if (!arg)
+      continue;
+    if (arg === "--url") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--url requires a value");
+      url = value;
+      continue;
+    }
+    if (arg === "--status") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--status requires a value");
+      status = value;
+      continue;
+    }
+    if (arg === "--events") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--events requires a value");
+      events = value.split(",").map((eventType) => eventType.trim()).filter(Boolean);
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+  }
+  if (!url)
+    throw new Error("Missing required --url");
+  return { url, status, events };
+}
+function parseUpdateOptions(args) {
+  const options = {};
+  for (let i = 0;i < args.length; i += 1) {
+    const arg = args[i];
+    if (!arg)
+      continue;
+    if (arg === "--url") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--url requires a value");
+      options.url = value;
+      continue;
+    }
+    if (arg === "--status") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--status requires a value");
+      options.status = value;
+      continue;
+    }
+    if (arg === "--events") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--events requires a value");
+      options.events = value.split(",").map((eventType) => eventType.trim()).filter(Boolean);
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+  }
+  return options;
+}
+async function listWebhooks(context, options, format2) {
+  const params = new URLSearchParams;
+  if (options.cursor)
+    params.set("cursor", options.cursor);
+  if (options.limit)
+    params.set("limit", String(options.limit));
+  const query = params.toString();
+  const path = query ? `/v1/webhooks?${query}` : "/v1/webhooks";
+  const response = await context.client.fetch(path);
+  const webhooks = response.items ?? response.webhooks ?? [];
+  if (format2 === "json") {
+    printJson({ items: webhooks, nextCursor: response.next_cursor ?? null });
+    return;
+  }
+  if (webhooks.length === 0) {
+    console.log("No webhooks configured.");
+    return;
+  }
+  printTable(webhooks.map((webhook) => ({
+    id: webhook.id,
+    url: truncate(webhook.url ?? "-", 40),
+    status: webhook.status ?? "-",
+    events: truncate((webhook.subscriptions ?? []).map((subscription) => subscription.event_type).filter((eventType) => Boolean(eventType)).join(", ") || "-", 35)
+  })), [
+    { key: "id", header: "ID", width: 36 },
+    { key: "url", header: "URL", width: 40 },
+    { key: "status", header: "Status", width: 12 },
+    { key: "events", header: "Events", width: 35 }
+  ]);
+  if (response.next_cursor) {
+    console.log(`
+Next cursor: ${response.next_cursor}`);
+  }
+}
+async function getWebhook(context, webhookId, format2) {
+  const response = await context.client.fetch(`/v1/webhooks/${webhookId}`);
+  const webhook = response.webhook ?? response.item ?? response;
+  if (format2 === "json") {
+    printJson(webhook);
+    return;
+  }
+  const events = (webhook.subscriptions ?? []).map((subscription) => subscription.event_type).filter((eventType) => Boolean(eventType));
+  console.log("Webhook Details");
+  console.log("───────────────");
+  console.log(`ID:      ${webhook.id}`);
+  console.log(`URL:     ${webhook.url ?? "-"}`);
+  console.log(`Status:  ${webhook.status ?? "-"}`);
+  console.log(`Events:  ${events.length > 0 ? events.join(", ") : "-"}`);
+}
+async function createWebhook(context, options, format2) {
+  const body = {
+    url: options.url
+  };
+  if (options.status)
+    body.status = options.status;
+  if (options.events && options.events.length > 0) {
+    body.subscriptions = options.events.map((eventType) => ({
+      event_type: eventType,
+      status: "ACTIVE"
+    }));
+  }
+  const response = await context.client.fetch("/v1/webhooks", {
+    method: "POST",
+    body: JSON.stringify(body)
+  });
+  const webhook = response.webhook ?? response.item ?? response;
+  if (format2 === "json") {
+    printJson(webhook);
+    return;
+  }
+  console.log("Webhook Created");
+  console.log("───────────────");
+  console.log(`ID:     ${webhook.id}`);
+  console.log(`URL:    ${webhook.url ?? "-"}`);
+  console.log(`Status: ${webhook.status ?? "-"}`);
+}
+async function updateWebhook(context, webhookId, options, format2) {
+  const body = {};
+  if (options.url)
+    body.url = options.url;
+  if (options.status)
+    body.status = options.status;
+  if (options.events && options.events.length > 0) {
+    body.subscriptions = options.events.map((eventType) => ({
+      event_type: eventType,
+      status: "ACTIVE"
+    }));
+  }
+  const response = await context.client.fetch(`/v1/webhooks/${webhookId}`, {
+    method: "PUT",
+    body: JSON.stringify(body)
+  });
+  const webhook = response.webhook ?? response.item ?? response;
+  if (format2 === "json") {
+    printJson(webhook);
+    return;
+  }
+  console.log("Webhook Updated");
+  console.log("───────────────");
+  console.log(`ID:     ${webhook.id}`);
+  console.log(`URL:    ${webhook.url ?? "-"}`);
+  console.log(`Status: ${webhook.status ?? "-"}`);
+}
+async function deleteWebhook(context, webhookId) {
+  await context.client.fetch(`/v1/webhooks/${webhookId}`, { method: "DELETE" });
+  console.log(`Webhook ${webhookId} deleted.`);
+}
+
+// sources/commands/events/index.ts
+var USAGE11 = `brex events
+brex events list [--event-type <type>] [--after-date <ISO>] [--before-date <ISO>] [--cursor <cursor>] [--limit <N>]
+brex events get <event-id>
+brex events --json`;
+var eventsCommand = {
+  name: "events",
+  description: "List and view webhook events.",
+  usage: USAGE11,
+  aliases: ["event"],
+  run: async (args, context) => {
+    const { format: format2, args: remaining } = parseOutputFlag(args);
+    const subcommand = remaining[0] ?? "list";
+    if (subcommand === "list") {
+      await listEvents(context, parseListOptions7(remaining.slice(1)), format2);
+      return;
+    }
+    if (subcommand === "get") {
+      const eventId = remaining[1];
+      if (!eventId)
+        throw new Error("Missing event ID. Usage: brex events get <event-id>");
+      await getEvent(context, eventId, format2);
+      return;
+    }
+    if (!subcommand.startsWith("-")) {
+      await getEvent(context, subcommand, format2);
+      return;
+    }
+    throw new Error(`Unknown subcommand: ${subcommand}`);
+  }
+};
+function parseListOptions7(args) {
+  const options = {};
+  for (let i = 0;i < args.length; i += 1) {
+    const arg = args[i];
+    if (!arg)
+      continue;
+    if (arg === "--event-type") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--event-type requires a value");
+      options.eventType = value;
+      continue;
+    }
+    if (arg === "--after-date") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--after-date requires a value");
+      options.afterDate = value;
+      continue;
+    }
+    if (arg === "--before-date") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--before-date requires a value");
+      options.beforeDate = value;
+      continue;
+    }
+    if (arg === "--cursor") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--cursor requires a value");
+      options.cursor = value;
+      continue;
+    }
+    if (arg === "--limit") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--limit requires a value");
+      const parsed = parseInt(value, 10);
+      if (Number.isNaN(parsed) || parsed <= 0) {
+        throw new Error("--limit must be a positive integer");
+      }
+      options.limit = parsed;
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+  }
+  return options;
+}
+async function listEvents(context, options, format2) {
+  const params = new URLSearchParams;
+  if (options.eventType)
+    params.set("event_type", options.eventType);
+  if (options.afterDate)
+    params.set("after_date", options.afterDate);
+  if (options.beforeDate)
+    params.set("before_date", options.beforeDate);
+  if (options.cursor)
+    params.set("cursor", options.cursor);
+  if (options.limit)
+    params.set("limit", String(options.limit));
+  const query = params.toString();
+  const path = query ? `/v1/events?${query}` : "/v1/events";
+  const response = await context.client.fetch(path);
+  const events = response.items ?? response.events ?? [];
+  if (format2 === "json") {
+    printJson({ items: events, nextCursor: response.next_cursor ?? null });
+    return;
+  }
+  if (events.length === 0) {
+    console.log("No events found.");
+    return;
+  }
+  printTable(events.map((event) => ({
+    id: event.id,
+    type: truncate(event.event_type ?? "-", 30),
+    occurredAt: formatDateTime(event.occurred_at),
+    webhookId: truncate(event.webhook_id ?? "-", 36)
+  })), [
+    { key: "id", header: "Event ID", width: 36 },
+    { key: "type", header: "Type", width: 30 },
+    { key: "occurredAt", header: "Occurred", width: 20 },
+    { key: "webhookId", header: "Webhook ID", width: 36 }
+  ]);
+  if (response.next_cursor) {
+    console.log(`
+Next cursor: ${response.next_cursor}`);
+  }
+}
+async function getEvent(context, eventId, format2) {
+  const response = await context.client.fetch(`/v1/events/${eventId}`);
+  const event = response.event ?? response.item ?? response;
+  if (format2 === "json") {
+    printJson(event);
+    return;
+  }
+  console.log("Event Details");
+  console.log("─────────────");
+  console.log(`ID:         ${event.id}`);
+  console.log(`Type:       ${event.event_type ?? "-"}`);
+  console.log(`Occurred:   ${formatDateTime(event.occurred_at)}`);
+  console.log(`Webhook ID: ${event.webhook_id ?? "-"}`);
+  console.log("Payload:");
+  console.log(JSON.stringify(event.payload ?? {}, null, 2));
+}
+
+// sources/commands/organization/index.ts
+var USAGE12 = `brex organization
+brex org
+brex organization --json`;
+var organizationCommand = {
+  name: "organization",
+  description: "Get organization details.",
+  usage: USAGE12,
+  aliases: ["org"],
+  run: async (args, context) => {
+    const { format: format2 } = parseOutputFlag(args);
+    const response = await context.client.fetch("/v2/company");
+    const company = response.company ?? response.item ?? response;
+    if (format2 === "json") {
+      printJson(company);
+      return;
+    }
+    const primaryLocation = company.location ?? company.locations?.[0];
+    console.log("Organization Details");
+    console.log("────────────────────");
+    console.log(`ID:          ${company.id ?? "-"}`);
+    console.log(`Legal Name:  ${company.legal_name ?? "-"}`);
+    if (company.dba_name)
+      console.log(`DBA Name:    ${company.dba_name}`);
+    if (company.tax_id)
+      console.log(`Tax ID:      ${company.tax_id}`);
+    if (company.status)
+      console.log(`Status:      ${company.status}`);
+    if (primaryLocation) {
+      console.log(`Address:     ${primaryLocation.address_line_1 ?? "-"}`);
+      if (primaryLocation.address_line_2) {
+        console.log(`             ${primaryLocation.address_line_2}`);
+      }
+      const cityRegion = [primaryLocation.city, primaryLocation.state].filter(Boolean).join(", ");
+      const postal = primaryLocation.postal_code ?? "";
+      const firstLine = [cityRegion, postal].filter(Boolean).join(" ");
+      if (firstLine)
+        console.log(`             ${firstLine}`);
+      if (primaryLocation.country)
+        console.log(`             ${primaryLocation.country}`);
+    }
+  }
+};
+
+// sources/commands/users/index.ts
+var USAGE13 = `brex users [list] [--cursor <cursor>] [--email <email>]
+brex users get <user-id>
+brex users --json`;
+var usersCommand = {
+  name: "users",
+  description: "List and view organization users.",
+  usage: USAGE13,
+  aliases: ["user"],
+  run: async (args, context) => {
+    const { format: format2, args: remaining } = parseOutputFlag(args);
+    const subcommand = remaining[0] ?? "list";
+    switch (subcommand) {
+      case "list":
+        await listUsers(context, parseListOptions8(remaining.slice(1)), format2);
+        return;
+      case "get": {
+        const userId = remaining[1];
+        if (!userId)
+          throw new Error("Missing user ID. Usage: brex users get <user-id>");
+        await getUser(context, userId, format2);
+        return;
+      }
+      default:
+        if (!subcommand.startsWith("-")) {
+          await getUser(context, subcommand, format2);
+          return;
+        }
+        throw new Error(`Unknown subcommand: ${subcommand}`);
+    }
+  }
+};
+function parseListOptions8(args) {
+  let cursor;
+  let email;
+  for (let i = 0;i < args.length; i += 1) {
+    const arg = args[i];
+    if (!arg)
+      continue;
+    if (arg === "--cursor") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--cursor requires a value");
+      cursor = value;
+      continue;
+    }
+    if (arg === "--email") {
+      const value = args[++i];
+      if (!value)
+        throw new Error("--email requires a value");
+      email = value;
+      continue;
+    }
+    if (arg.startsWith("-")) {
+      throw new Error(`Unknown option: ${arg}`);
+    }
+  }
+  return { cursor, email };
+}
+async function listUsers(context, options, format2) {
+  const params = new URLSearchParams;
+  if (options.cursor)
+    params.set("cursor", options.cursor);
+  if (options.email)
+    params.set("email", options.email);
+  const query = params.toString();
+  const path = query ? `/v2/users?${query}` : "/v2/users";
+  const response = await context.client.fetch(path);
+  const users = response.items ?? response.users ?? [];
+  if (format2 === "json") {
+    printJson({ items: users, nextCursor: response.next_cursor ?? null });
+    return;
+  }
+  if (users.length === 0) {
+    console.log("No users found.");
+    return;
+  }
+  printTable(users.map((user) => ({
+    id: user.id,
+    firstName: user.first_name ?? "-",
+    lastName: user.last_name ?? "-",
+    email: user.email ?? "-",
+    department: user.department ?? "-",
+    status: user.status ?? "-"
+  })), [
+    { key: "id", header: "ID", width: 36 },
+    { key: "firstName", header: "First Name", width: 14 },
+    { key: "lastName", header: "Last Name", width: 14 },
+    { key: "email", header: "Email", width: 30 },
+    { key: "department", header: "Department", width: 15 },
+    { key: "status", header: "Status", width: 10 }
+  ]);
+  if (response.next_cursor) {
+    console.log(`
+Next cursor: ${response.next_cursor}`);
+  }
+}
+async function getUser(context, userId, format2) {
+  const response = await context.client.fetch(`/v2/users/${userId}`);
+  const user = response.user ?? response.item ?? response;
+  if (format2 === "json") {
+    printJson(user);
+    return;
+  }
+  console.log("User Details");
+  console.log("────────────");
+  console.log(`ID:         ${user.id}`);
+  console.log(`Name:       ${user.first_name ?? "-"} ${user.last_name ?? "-"}`);
+  console.log(`Email:      ${user.email ?? "-"}`);
+  console.log(`Department: ${user.department ?? "-"}`);
+  console.log(`Status:     ${user.status ?? "-"}`);
+  if (user.manager_id) {
+    console.log(`Manager ID: ${user.manager_id}`);
+  }
+}
+
+// sources/commands/categories/index.ts
+var USAGE14 = `brex categories`;
+var categoriesCommand = {
+  name: "categories",
+  description: "Not supported by Brex public APIs in this CLI.",
+  usage: USAGE14,
+  aliases: ["category", "cat"],
+  run: async () => {
+    throw new Error("The Brex APIs currently used by this CLI do not expose a direct transaction categories endpoint. See https://developer.brex.com/ for available resources.");
+  }
+};
+
+// sources/commands/version/index.ts
+var VERSION = "0.1.0";
+var versionCommand = {
+  name: "version",
+  description: "Show brex-cli version.",
+  usage: "brex version",
+  aliases: ["v"],
+  run: async () => {
+    console.log(`brex-cli v${VERSION}`);
+  }
+};
+
+// sources/main.ts
+var BIN = "brex";
+var commands = [
+  loginCommand,
+  logoutCommand,
+  statusCommand,
+  accountsCommand,
+  transactionsCommand,
+  transferCommand,
+  recipientsCommand,
+  cardsCommand,
+  statementsCommand,
+  webhooksCommand,
+  eventsCommand,
+  organizationCommand,
+  usersCommand,
+  categoriesCommand,
+  versionCommand
+];
+var commandIndex = new Map;
+for (const command of commands) {
+  commandIndex.set(command.name, command);
+  if (command.aliases) {
+    for (const alias of command.aliases) {
+      commandIndex.set(alias, command);
+    }
+  }
+}
+function isHelpFlag(value) {
+  return value === "-h" || value === "--help";
+}
+function printHelp() {
+  console.log(`${BIN} <command> [options]`);
+  console.log("");
+  console.log("Commands:");
+  for (const command of commands) {
+    const aliasText = command.aliases && command.aliases.length > 0 ? ` (${command.aliases.join(", ")})` : "";
+    console.log(`  ${command.name.padEnd(16)}${command.description}${aliasText}`);
+  }
+  console.log("");
+  console.log("Global options:");
+  console.log("  --json          Output as JSON");
+  console.log("  -h, --help      Show help");
+  console.log("  -v, --version   Show version");
+  console.log("");
+  console.log(`Run "${BIN} <command> --help" for command-specific help.`);
+}
+function printCommandHelp(command) {
+  console.log(command.usage);
+  console.log("");
+  console.log(command.description);
+}
+async function runCli() {
+  const args = process.argv.slice(2);
+  const firstArg = args[0];
+  if (!firstArg || isHelpFlag(firstArg)) {
+    printHelp();
+    return;
+  }
+  if (firstArg === "--version" || firstArg === "-v") {
+    await versionCommand.run([], createContext());
+    return;
+  }
+  const commandName = firstArg;
+  const command = commandIndex.get(commandName);
+  if (!command) {
+    console.error(`Unknown command: ${commandName}`);
+    printHelp();
+    process.exitCode = 1;
+    return;
+  }
+  const commandArgs = args.slice(1);
+  if (commandArgs.some(isHelpFlag)) {
+    printCommandHelp(command);
+    return;
+  }
+  try {
+    const context = createContext();
+    await command.run(commandArgs, context);
+  } catch (error) {
+    if (error instanceof Error) {
+      console.error(`Error: ${error.message}`);
+    } else {
+      console.error("Unexpected error");
+    }
+    process.exitCode = 1;
+  }
+}
+function createContext() {
+  return {
+    client: createBrexClient()
+  };
+}
+runCli();