@bloque/cli 0.0.45

package/dist/bin.js

@@ -0,0 +1,2371 @@
+#!/usr/bin/env node
+
+// src/bin.ts
+import { Command as Command6 } from "commander";
+
+// src/commands/login.ts
+import { Command } from "commander";
+import { SDK } from "@bloque/sdk";
+import { input, password, select } from "@inquirer/prompts";
+
+// src/session/store.ts
+import fs from "fs";
+import os from "os";
+import path from "path";
+var SessionStore = class _SessionStore {
+  static SESSION_DIR = path.join(os.homedir(), ".bloque");
+  static SESSION_PATH = path.join(_SessionStore.SESSION_DIR, "session.json");
+  save(session) {
+    fs.mkdirSync(_SessionStore.SESSION_DIR, { recursive: true, mode: 448 });
+    fs.writeFileSync(
+      _SessionStore.SESSION_PATH,
+      JSON.stringify(session, null, 2),
+      { mode: 384 }
+    );
+  }
+  load() {
+    try {
+      const data = fs.readFileSync(_SessionStore.SESSION_PATH, "utf-8");
+      return JSON.parse(data);
+    } catch {
+      return null;
+    }
+  }
+  clear() {
+    try {
+      fs.unlinkSync(_SessionStore.SESSION_PATH);
+    } catch {
+    }
+  }
+  exists() {
+    return fs.existsSync(_SessionStore.SESSION_PATH);
+  }
+};
+
+// src/ui/portal.ts
+import { stdout } from "process";
+var ESC = "\x1B";
+var RESET = `${ESC}[0m`;
+var BOLD = `${ESC}[1m`;
+var HIDE_CURSOR = `${ESC}[?25l`;
+var SHOW_CURSOR = `${ESC}[?25h`;
+var PALETTE = [
+  `${ESC}[38;5;53m`,
+  //  0 — deep magenta
+  `${ESC}[38;5;54m`,
+  //  1 — dark purple
+  `${ESC}[38;5;55m`,
+  //  2 — plum
+  `${ESC}[38;5;92m`,
+  //  3 — muted violet
+  `${ESC}[38;5;93m`,
+  //  4 — violet
+  `${ESC}[38;5;129m`,
+  //  5 — purple
+  `${ESC}[38;5;135m`,
+  //  6 — light purple
+  `${ESC}[38;5;141m`,
+  //  7 — lavender
+  `${ESC}[38;5;111m`,
+  //  8 — soft blue
+  `${ESC}[38;5;75m`,
+  //  9 — sky blue
+  `${ESC}[38;5;81m`,
+  // 10 — cyan
+  `${ESC}[38;5;123m`,
+  // 11 — bright cyan
+  `${ESC}[38;5;159m`,
+  // 12 — ice blue
+  `${ESC}[38;5;195m`,
+  // 13 — pale cyan
+  `${ESC}[38;5;231m`
+  // 14 — white
+];
+var SUCCESS_COLOR = `${ESC}[38;5;49m`;
+var DIM_STAR = `${ESC}[38;5;236m`;
+var MED_STAR = `${ESC}[38;5;240m`;
+var MAX_RADIUS = 6;
+var WIDTH = 52;
+var HEIGHT = MAX_RADIUS * 2 + 3;
+var CX = Math.floor(WIDTH / 2);
+var CY = Math.floor(HEIGHT / 2);
+var ASPECT = 2.1;
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+function generateStarField() {
+  const field = [];
+  for (let y = 0; y < HEIGHT; y++) {
+    field[y] = [];
+    for (let x = 0; x < WIDTH; x++) {
+      field[y][x] = Math.random() < 0.025;
+    }
+  }
+  return field;
+}
+function renderFrame(radius, stars, shimmer = false) {
+  const lines = [];
+  for (let y = 0; y < HEIGHT; y++) {
+    let line = "";
+    for (let x = 0; x < WIDTH; x++) {
+      const dx = (x - CX) / ASPECT;
+      const dy = y - CY;
+      const dist = Math.sqrt(dx * dx + dy * dy);
+      let char = " ";
+      let color = "";
+      for (let r = 0; r <= radius; r++) {
+        const hitThreshold = r === 0 ? 0.5 : 0.6;
+        if (Math.abs(dist - r) < hitThreshold) {
+          const t = 1 - r / MAX_RADIUS;
+          const idx = Math.round(t * (PALETTE.length - 1));
+          color = PALETTE[idx];
+          if (r === 0) {
+            char = "\u2726";
+            color = BOLD + PALETTE[PALETTE.length - 1];
+          } else if (r <= 2) {
+            char = shimmer && Math.random() < 0.3 ? "\u2727" : "\u25E6";
+          } else {
+            char = shimmer && Math.random() < 0.15 ? "\u2727" : "\xB7";
+          }
+          break;
+        }
+      }
+      if (char === " " && stars[y][x]) {
+        const twinkle = shimmer && Math.random() < 0.3;
+        color = twinkle ? MED_STAR : DIM_STAR;
+        char = ".";
+      }
+      line += char !== " " ? color + char + RESET : " ";
+    }
+    lines.push(line);
+  }
+  return lines;
+}
+function renderSuccess(message) {
+  const pad = " ".repeat(Math.max(0, CX - 1));
+  return [
+    "",
+    `${pad}${BOLD}${SUCCESS_COLOR}\u25C6${RESET} ${SUCCESS_COLOR}${message}${RESET}`,
+    ""
+  ];
+}
+function writeLines(lines) {
+  stdout.write(lines.join("\n") + "\n");
+}
+function clearLines(count) {
+  stdout.write(`${ESC}[${count}A${ESC}[0J`);
+}
+async function portalAnimation(message) {
+  if (!stdout.isTTY) {
+    console.log(`
+  \u25C6 ${message}
+`);
+    return;
+  }
+  stdout.write(HIDE_CURSOR);
+  const stars = generateStarField();
+  try {
+    const frame0 = renderFrame(0, stars);
+    writeLines(frame0);
+    await sleep(120);
+    for (let r = 1; r <= MAX_RADIUS; r++) {
+      clearLines(frame0.length);
+      const frame = renderFrame(r, stars);
+      writeLines(frame);
+      await sleep(70 + r * 10);
+    }
+    for (let i = 0; i < 4; i++) {
+      clearLines(HEIGHT);
+      const frame = renderFrame(MAX_RADIUS, stars, true);
+      writeLines(frame);
+      await sleep(100);
+    }
+    for (let r = MAX_RADIUS; r >= 1; r--) {
+      clearLines(HEIGHT);
+      const frame = renderFrame(r, stars);
+      writeLines(frame);
+      await sleep(50 + r * 5);
+    }
+    clearLines(HEIGHT);
+    const dotFrame = renderFrame(0, stars);
+    writeLines(dotFrame);
+    await sleep(150);
+    clearLines(HEIGHT);
+    const successLines = renderSuccess(message);
+    writeLines(successLines);
+  } finally {
+    stdout.write(SHOW_CURSOR);
+  }
+}
+
+// src/commands/login.ts
+var store = new SessionStore();
+var OTP_CHANNELS = [
+  {
+    name: "WhatsApp",
+    value: "bloque-whatsapp",
+    prompt: "Phone number (e.g. +573001234567):",
+    sentMessage: "OTP sent via WhatsApp \u2014 check your phone."
+  },
+  {
+    name: "Email",
+    value: "bloque-email",
+    prompt: "Email address:",
+    sentMessage: "OTP sent \u2014 check your inbox."
+  }
+];
+var loginCommand = new Command("login").description("Authenticate with Bloque").option("--api-key <key>", "API key for backend authentication").option("--origin <origin>", "Origin (only needed with --api-key)").option("--alias <alias>", "Alias (required with --api-key)").option("--sandbox", "Use sandbox environment instead of production").action(async (opts) => {
+  const { apiKey, origin, alias, sandbox } = opts;
+  const mode = sandbox ? "sandbox" : "production";
+  if (apiKey) {
+    if (!alias) {
+      console.error("Error: --alias is required when using --api-key");
+      process.exit(1);
+    }
+    if (!origin) {
+      console.error("Error: --origin is required when using --api-key");
+      process.exit(1);
+    }
+    const sdk2 = new SDK({ auth: { type: "apiKey", apiKey }, mode, origin });
+    const clients2 = await sdk2.connect(alias);
+    store.save({
+      accessToken: clients2.accessToken,
+      urn: clients2.urn ?? "",
+      origin,
+      mode,
+      authType: "apiKey",
+      apiKey,
+      alias,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    await portalAnimation(`Connected as ${clients2.urn ?? alias}`);
+    return;
+  }
+  const channel = await select({
+    message: "How would you like to receive your OTP?",
+    choices: OTP_CHANNELS.map((c) => ({ name: c.name, value: c.value }))
+  });
+  const selectedChannel = OTP_CHANNELS.find((c) => c.value === channel);
+  const userAlias = await input({ message: selectedChannel.prompt });
+  let _token = null;
+  const sdk = new SDK({
+    auth: { type: "jwt" },
+    mode,
+    origin: channel,
+    tokenStorage: {
+      get: () => _token,
+      set: (t) => {
+        _token = t;
+      },
+      clear: () => {
+        _token = null;
+      }
+    }
+  });
+  await sdk.assert(channel, userAlias);
+  console.log(selectedChannel.sentMessage);
+  const code = await password({ message: "Enter OTP code:", mask: "*" });
+  const clients = await sdk.connect(channel, userAlias, code);
+  store.save({
+    accessToken: clients.accessToken,
+    urn: clients.urn ?? "",
+    origin: channel,
+    mode,
+    authType: "jwt",
+    alias: userAlias,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  await portalAnimation(`Connected as ${clients.urn ?? userAlias}`);
+});
+
+// src/commands/logout.ts
+import { Command as Command2 } from "commander";
+var store2 = new SessionStore();
+var logoutCommand = new Command2("logout").description("Clear local Bloque session").action(() => {
+  store2.clear();
+  console.log("Logged out.");
+});
+
+// src/commands/whoami.ts
+import { Command as Command3 } from "commander";
+var store3 = new SessionStore();
+var whoamiCommand = new Command3("whoami").description("Show current session info").action(() => {
+  const session = store3.load();
+  if (!session) {
+    console.error("No active session. Run `bloque login` first.");
+    process.exit(1);
+  }
+  console.log(`URN:       ${session.urn}`);
+  console.log(`Origin:    ${session.origin}`);
+  console.log(`Mode:      ${session.mode}`);
+  console.log(`Auth type: ${session.authType}`);
+  console.log(`Created:   ${session.createdAt}`);
+});
+
+// src/commands/mcp.ts
+import { Command as Command4 } from "commander";
+import { SDK as SDK2 } from "@bloque/sdk";
+
+// src/mcp/server.ts
+import { randomUUID } from "crypto";
+import { createServer } from "http";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+
+// src/mcp/tools/primitives/accounts.ts
+import { z } from "zod/v4";
+
+// src/mcp/currency.ts
+var ASSET_MAP = {
+  USD: { asset: "DUSD/6", decimals: 6 },
+  COP: { asset: "COP/2", decimals: 2 }
+};
+var REVERSE_ASSET_MAP = {
+  "DUSD/6": { currency: "USD", decimals: 6 },
+  "COP/2": { currency: "COP", decimals: 2 },
+  "COPB/6": { currency: "COP", decimals: 6 },
+  "KSM/12": { currency: "KSM", decimals: 12 }
+};
+function toRaw(humanAmount, currency) {
+  const mapping = ASSET_MAP[currency.toUpperCase()];
+  if (!mapping) {
+    return { amount: humanAmount, asset: currency };
+  }
+  const parts = humanAmount.split(".");
+  const integerPart = parts[0] ?? "0";
+  const fractionalPart = (parts[1] ?? "").padEnd(mapping.decimals, "0").slice(0, mapping.decimals);
+  const raw = BigInt(integerPart) * BigInt(10 ** mapping.decimals) + BigInt(fractionalPart);
+  return { amount: raw.toString(), asset: mapping.asset };
+}
+function toHuman(rawAmount, asset) {
+  const mapping = REVERSE_ASSET_MAP[asset];
+  if (!mapping) {
+    return { amount: rawAmount, currency: asset };
+  }
+  const raw = BigInt(rawAmount);
+  const divisor = BigInt(10 ** mapping.decimals);
+  const integerPart = raw / divisor;
+  const fractionalPart = raw % divisor;
+  const fracStr = fractionalPart.toString().padStart(mapping.decimals, "0").replace(/0+$/, "");
+  const humanAmount = fracStr ? `${integerPart}.${fracStr}` : integerPart.toString();
+  return { amount: humanAmount, currency: mapping.currency };
+}
+function humanizeBalance(balance) {
+  return Object.entries(balance).map(([asset, values]) => {
+    const { currency } = toHuman("0", asset);
+    return {
+      currency,
+      current: toHuman(values.current, asset).amount,
+      pending: toHuman(values.pending, asset).amount,
+      ...values.in != null ? { in: toHuman(values.in, asset).amount } : {},
+      ...values.out != null ? { out: toHuman(values.out, asset).amount } : {}
+    };
+  });
+}
+function resolveAsset(currency) {
+  return ASSET_MAP[currency.toUpperCase()]?.asset ?? currency;
+}
+
+// src/mcp/tools/primitives/accounts.ts
+function registerAccountTools(server, clients) {
+  server.registerTool(
+    "list_accounts",
+    {
+      description: "List all financial accounts (cards, virtual pockets, polygon, US bank, Bancolombia) owned by the authenticated user. Optionally filter by account type. Use this to discover what accounts exist before operating on them. Returns URN, status, medium type, and balances for each account.",
+      inputSchema: {
+        medium: z.enum(["card", "virtual", "polygon", "us-account", "bancolombia"]).optional()
+      }
+    },
+    async ({ medium }) => {
+      const result = await clients.accounts.list({ medium });
+      const accounts = result.accounts.map((account) => ({
+        ...account,
+        balance: account.balance ? humanizeBalance(account.balance) : void 0
+      }));
+      return {
+        content: [{ type: "text", text: JSON.stringify(accounts, null, 2) }]
+      };
+    }
+  );
+  server.registerTool(
+    "get_account",
+    {
+      description: "Get full details of a specific account by its URN. Returns medium-specific fields (e.g. lastFour and detailsUrl for cards, address for polygon, routing/account numbers for US). Use when you already have a URN and need its current state.",
+      inputSchema: { urn: z.string() }
+    },
+    async ({ urn }) => {
+      const account = await clients.accounts.get(urn);
+      return {
+        content: [{ type: "text", text: JSON.stringify(account, null, 2) }]
+      };
+    }
+  );
+  server.registerTool(
+    "get_balance",
+    {
+      description: "Get the current balance of a single account by URN. Returns balances in human-readable amounts (USD, COP). Use this to check available funds before a transfer.",
+      inputSchema: { urn: z.string() }
+    },
+    async ({ urn }) => {
+      const raw = await clients.accounts.balance(urn);
+      const balances = humanizeBalance(raw);
+      return {
+        content: [{ type: "text", text: JSON.stringify(balances, null, 2) }]
+      };
+    }
+  );
+  server.registerTool(
+    "get_all_balances",
+    {
+      description: "Get aggregated balances across ALL accounts owned by the user, grouped by currency. Quick way to see total holdings."
+    },
+    async () => {
+      const raw = await clients.accounts.balances();
+      const balances = humanizeBalance(raw);
+      return {
+        content: [{ type: "text", text: JSON.stringify(balances, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/mcp/tools/primitives/virtual.ts
+import { z as z2 } from "zod/v4";
+function registerVirtualTools(server, clients) {
+  server.registerTool(
+    "create_virtual_account",
+    {
+      description: "Create a virtual account (also called a 'pocket' or 'ledger'). Virtual accounts hold balances and can be linked to cards and polygon accounts via ledgerId. For creating a card, prefer the 'create_card' workflow which handles the pocket automatically.",
+      inputSchema: {
+        name: z2.string().optional(),
+        ledgerId: z2.string().optional(),
+        metadata: z2.record(z2.string()).optional()
+      }
+    },
+    async ({ name, ledgerId, metadata }) => {
+      const account = await clients.accounts.virtual.create({
+        name,
+        ledgerId,
+        metadata
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(account, null, 2) }]
+      };
+    }
+  );
+  server.registerTool(
+    "list_virtual_accounts",
+    {
+      description: "List all virtual accounts (pockets) owned by the user. Shows name, URN, ledgerId, status, and balances."
+    },
+    async () => {
+      const result = await clients.accounts.virtual.list();
+      const accounts = result.accounts.map((account) => ({
+        ...account,
+        balance: account.balance ? humanizeBalance(account.balance) : void 0
+      }));
+      return {
+        content: [{ type: "text", text: JSON.stringify(accounts, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/mcp/tools/primitives/card.ts
+import { z as z3 } from "zod/v4";
+function registerCardTools(server, clients) {
+  server.registerTool(
+    "create_raw_card",
+    {
+      description: "Low-level: create a card linked to an existing ledgerId. Does NOT create the virtual account or polygon account. For most cases, use the high-level 'create_card' workflow instead.",
+      inputSchema: {
+        ledgerId: z3.string(),
+        name: z3.string().optional(),
+        metadata: z3.record(z3.unknown()).optional(),
+        webhookUrl: z3.string().optional()
+      }
+    },
+    async ({ ledgerId, name, metadata, webhookUrl }) => {
+      const card = await clients.accounts.card.create({
+        ledgerId,
+        name,
+        metadata,
+        webhookUrl
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(card, null, 2) }]
+      };
+    }
+  );
+  server.registerTool(
+    "list_cards",
+    {
+      description: "List all cards owned by the user. Returns card URN, last four digits, status, card type, detailsUrl, ledgerId, and balances."
+    },
+    async () => {
+      const result = await clients.accounts.card.list();
+      const cards = result.accounts.map((card) => ({
+        ...card,
+        balance: card.balance ? humanizeBalance(card.balance) : void 0
+      }));
+      return {
+        content: [{ type: "text", text: JSON.stringify(cards, null, 2) }]
+      };
+    }
+  );
+  server.registerTool(
+    "freeze_card",
+    {
+      description: "Temporarily freeze a card, blocking all transactions. The card can be reactivated later with activate_card.",
+      inputSchema: { urn: z3.string() }
+    },
+    async ({ urn }) => {
+      const card = await clients.accounts.card.freeze(urn);
+      return {
+        content: [{ type: "text", text: JSON.stringify(card, null, 2) }]
+      };
+    }
+  );
+  server.registerTool(
+    "activate_card",
+    {
+      description: "Activate a card. Use to unfreeze a previously frozen card, or to activate a newly created card.",
+      inputSchema: { urn: z3.string() }
+    },
+    async ({ urn }) => {
+      const card = await clients.accounts.card.activate(urn);
+      return {
+        content: [{ type: "text", text: JSON.stringify(card, null, 2) }]
+      };
+    }
+  );
+  server.registerTool(
+    "disable_card",
+    {
+      description: "Permanently disable a card. This is IRREVERSIBLE \u2014 the card cannot be reactivated.",
+      inputSchema: { urn: z3.string() }
+    },
+    async ({ urn }) => {
+      const card = await clients.accounts.card.disable(urn);
+      return {
+        content: [{ type: "text", text: JSON.stringify(card, null, 2) }]
+      };
+    }
+  );
+  server.registerTool(
+    "update_card_metadata",
+    {
+      description: "Update the metadata on a card. Metadata controls spending behavior (spending_control, mcc_whitelist, priority_mcc). For a friendlier interface, use 'configure_spending_rules' workflow.",
+      inputSchema: {
+        urn: z3.string(),
+        metadata: z3.record(z3.unknown())
+      }
+    },
+    async ({ urn, metadata }) => {
+      const card = await clients.accounts.card.updateMetadata({ urn, metadata });
+      return {
+        content: [{ type: "text", text: JSON.stringify(card, null, 2) }]
+      };
+    }
+  );
+  server.registerTool(
+    "rename_card",
+    {
+      description: "Change the display name of a card.",
+      inputSchema: {
+        urn: z3.string(),
+        name: z3.string()
+      }
+    },
+    async ({ urn, name }) => {
+      const card = await clients.accounts.card.updateName(urn, name);
+      return {
+        content: [{ type: "text", text: JSON.stringify(card, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/mcp/tools/primitives/polygon.ts
+import { z as z4 } from "zod/v4";
+function registerPolygonTools(server, clients) {
+  server.registerTool(
+    "create_polygon_account",
+    {
+      description: "Low-level: create a Polygon blockchain account. If ledgerId is provided, shares that ledger's balance. For most cases, use the 'create_card' workflow which creates it automatically.",
+      inputSchema: {
+        ledgerId: z4.string().optional(),
+        name: z4.string().optional(),
+        metadata: z4.record(z4.string()).optional()
+      }
+    },
+    async ({ ledgerId, name, metadata }) => {
+      const account = await clients.accounts.polygon.create({
+        ledgerId,
+        name,
+        metadata
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(account, null, 2) }]
+      };
+    }
+  );
+  server.registerTool(
+    "list_polygon_accounts",
+    {
+      description: "List all Polygon blockchain accounts. Shows wallet address, network, URN, ledgerId, and balances."
+    },
+    async () => {
+      const result = await clients.accounts.polygon.list();
+      const accounts = result.accounts.map((account) => ({
+        ...account,
+        balance: account.balance ? humanizeBalance(account.balance) : void 0
+      }));
+      return {
+        content: [{ type: "text", text: JSON.stringify(accounts, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/mcp/tools/primitives/us.ts
+import { z as z5 } from "zod/v4";
+function registerUsTools(server, clients) {
+  server.registerTool(
+    "get_us_tos_link",
+    {
+      description: "Get a Terms of Service acceptance URL that the user must visit before creating a US bank account.",
+      inputSchema: { redirectUri: z5.string() }
+    },
+    async ({ redirectUri }) => {
+      const result = await clients.accounts.us.getTosLink({ redirectUri });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.registerTool(
+    "create_us_account",
+    {
+      description: "Create a US bank account (routing + account number). Requires the user to have accepted TOS first. Returns account and routing numbers for ACH transfers.",
+      inputSchema: {
+        type: z5.enum(["individual", "business"]),
+        firstName: z5.string(),
+        lastName: z5.string(),
+        email: z5.string(),
+        phone: z5.string(),
+        address: z5.object({
+          streetLine1: z5.string(),
+          streetLine2: z5.string().optional(),
+          city: z5.string(),
+          state: z5.string(),
+          postalCode: z5.string(),
+          country: z5.string()
+        }),
+        birthDate: z5.string(),
+        taxIdentificationNumber: z5.string(),
+        govIdCountry: z5.string(),
+        govIdImageFront: z5.string(),
+        signedAgreementId: z5.string(),
+        name: z5.string().optional(),
+        ledgerId: z5.string().optional(),
+        metadata: z5.record(z5.unknown()).optional()
+      }
+    },
+    async (params) => {
+      const account = await clients.accounts.us.create(params);
+      return {
+        content: [{ type: "text", text: JSON.stringify(account, null, 2) }]
+      };
+    }
+  );
+  server.registerTool(
+    "list_us_accounts",
+    {
+      description: "List all US bank accounts. Shows account/routing numbers, status, and balances."
+    },
+    async () => {
+      const result = await clients.accounts.us.list();
+      const accounts = result.accounts.map((account) => ({
+        ...account,
+        balance: account.balance ? humanizeBalance(account.balance) : void 0
+      }));
+      return {
+        content: [{ type: "text", text: JSON.stringify(accounts, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/mcp/tools/primitives/transfers.ts
+import { z as z6 } from "zod/v4";
+function registerTransferTools(server, clients) {
+  server.registerTool(
+    "transfer",
+    {
+      description: "Transfer funds between two accounts. Specify source/destination URN, amount in human-readable format (e.g. '100' for $100), and currency ('USD' or 'COP'). The transfer is queued asynchronously. Returns a queueId to track.",
+      inputSchema: {
+        sourceUrn: z6.string(),
+        destinationUrn: z6.string(),
+        amount: z6.string(),
+        currency: z6.string().default("USD"),
+        metadata: z6.record(z6.unknown()).optional()
+      }
+    },
+    async ({ sourceUrn, destinationUrn, amount, currency, metadata }) => {
+      const { amount: rawAmount, asset } = toRaw(amount, currency);
+      const result = await clients.accounts.transfer({
+        sourceUrn,
+        destinationUrn,
+        amount: rawAmount,
+        asset,
+        metadata
+      });
+      const humanized = {
+        ...result,
+        amount: toHuman(rawAmount, asset).amount,
+        currency: toHuman(rawAmount, asset).currency
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(humanized, null, 2) }]
+      };
+    }
+  );
+  server.registerTool(
+    "batch_transfer",
+    {
+      description: "Execute multiple transfers in a single batch. Useful for payroll, distributions. Operations are auto-chunked into groups of 80.",
+      inputSchema: {
+        reference: z6.string(),
+        operations: z6.array(
+          z6.object({
+            fromUrn: z6.string(),
+            toUrn: z6.string(),
+            reference: z6.string(),
+            amount: z6.string(),
+            currency: z6.string().default("USD"),
+            metadata: z6.record(z6.unknown()).optional()
+          })
+        ),
+        metadata: z6.record(z6.unknown()).optional(),
+        webhookUrl: z6.string().optional()
+      }
+    },
+    async ({ reference, operations, metadata, webhookUrl }) => {
+      const mappedOps = operations.map((op) => {
+        const { amount, asset } = toRaw(op.amount, op.currency);
+        return {
+          fromUrn: op.fromUrn,
+          toUrn: op.toUrn,
+          reference: op.reference,
+          amount,
+          asset,
+          metadata: op.metadata
+        };
+      });
+      const result = await clients.accounts.batchTransfer({
+        reference,
+        operations: mappedOps,
+        metadata,
+        webhookUrl
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/mcp/tools/primitives/history.ts
+import { z as z7 } from "zod/v4";
+function registerHistoryTools(server, clients) {
+  server.registerTool(
+    "list_transactions",
+    {
+      description: "List transaction history across ALL accounts. Supports filtering by currency, date range, direction (in/out), and pagination. Use this for a global view of all money movement.",
+      inputSchema: {
+        currency: z7.string().optional(),
+        limit: z7.number().optional(),
+        before: z7.string().optional(),
+        after: z7.string().optional(),
+        direction: z7.enum(["in", "out"]).optional(),
+        next: z7.string().optional()
+      }
+    },
+    async ({ currency, limit, before, after, direction, next }) => {
+      const asset = currency ? resolveAsset(currency) : void 0;
+      const result = await clients.accounts.transactions({
+        asset,
+        limit,
+        before,
+        after,
+        direction,
+        next
+      });
+      const humanizedTxs = result.data.map((tx) => {
+        const { amount, currency: cur } = toHuman(tx.amount, tx.asset);
+        return { ...tx, amount, currency: cur };
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                data: humanizedTxs,
+                pageSize: result.pageSize,
+                hasMore: result.hasMore,
+                next: result.next
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+  );
+  server.registerTool(
+    "list_account_movements",
+    {
+      description: "List transaction history for a SPECIFIC account by URN. Shows deposits, withdrawals, and transfers with human-readable amounts.",
+      inputSchema: {
+        urn: z7.string(),
+        currency: z7.string().optional(),
+        limit: z7.number().optional(),
+        before: z7.string().optional(),
+        after: z7.string().optional(),
+        direction: z7.enum(["in", "out"]).optional(),
+        pocket: z7.enum(["main", "pending"]).optional(),
+        next: z7.string().optional()
+      }
+    },
+    async ({ urn, currency, limit, before, after, direction, pocket, next }) => {
+      const result = await clients.accounts.movements({
+        urn,
+        asset: currency ? resolveAsset(currency) : void 0,
+        limit,
+        before,
+        after,
+        direction,
+        pocket,
+        next
+      });
+      const humanizedMovements = result.data.map((mv) => {
+        const { amount, currency: cur } = toHuman(mv.amount, mv.asset);
+        return { ...mv, amount, currency: cur };
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                data: humanizedMovements,
+                pageSize: result.pageSize,
+                hasMore: result.hasMore,
+                next: result.next
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/mcp/tools/primitives/swap.ts
+import { z as z8 } from "zod/v4";
+function registerSwapTools(server, clients) {
+  server.registerTool(
+    "find_rates",
+    {
+      description: "Find exchange rates between two assets. Returns rates with fees, limits, and a rateSig needed to create swap orders. Use this before topup_via_pse or cashout_to_bank.",
+      inputSchema: {
+        fromAsset: z8.string(),
+        toAsset: z8.string(),
+        fromMediums: z8.array(z8.string()),
+        toMediums: z8.array(z8.string()),
+        amountSrc: z8.string().optional(),
+        amountDst: z8.string().optional()
+      }
+    },
+    async (params) => {
+      const result = await clients.swap.findRates(params);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.registerTool(
+    "list_pse_banks",
+    {
+      description: "List Colombian banks available for PSE payments. Returns bank code and name."
+    },
+    async () => {
+      const result = await clients.swap.pse.banks();
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.registerTool(
+    "create_pse_order",
+    {
+      description: "Low-level: create a PSE swap order to convert COP into DUSD. For a simpler flow, use 'topup_via_pse' workflow.",
+      inputSchema: {
+        rateSig: z8.string(),
+        toMedium: z8.string(),
+        amountSrc: z8.string().optional(),
+        amountDst: z8.string().optional(),
+        depositUrn: z8.string(),
+        bankCode: z8.string(),
+        userType: z8.union([z8.literal(0), z8.literal(1)]),
+        customerEmail: z8.string(),
+        userLegalIdType: z8.enum(["CC", "NIT", "CE"]),
+        userLegalId: z8.string(),
+        fullName: z8.string(),
+        phoneNumber: z8.string().optional(),
+        webhookUrl: z8.string().optional()
+      }
+    },
+    async ({
+      rateSig,
+      toMedium,
+      amountSrc,
+      amountDst,
+      depositUrn,
+      bankCode,
+      userType,
+      customerEmail,
+      userLegalIdType,
+      userLegalId,
+      fullName,
+      phoneNumber,
+      webhookUrl
+    }) => {
+      const result = await clients.swap.pse.create({
+        rateSig,
+        toMedium,
+        webhookUrl,
+        amountSrc,
+        amountDst,
+        depositInformation: { urn: depositUrn },
+        args: {
+          bankCode,
+          userType,
+          customerEmail,
+          userLegalIdType,
+          userLegalId,
+          customerData: { fullName, phoneNumber: phoneNumber ?? "" }
+        }
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.registerTool(
+    "create_bank_transfer_order",
+    {
+      description: "Low-level: create a bank transfer order to cash out DUSD to COP. For a simpler flow, use 'cashout_to_bank' workflow.",
+      inputSchema: {
+        rateSig: z8.string(),
+        toMedium: z8.string(),
+        amountSrc: z8.string().optional(),
+        amountDst: z8.string().optional(),
+        sourceAccountUrn: z8.string(),
+        bankAccountType: z8.enum(["savings", "checking"]),
+        bankAccountNumber: z8.string(),
+        bankAccountHolderName: z8.string(),
+        bankAccountHolderIdentificationType: z8.enum(["CC", "CE", "NIT", "PP"]),
+        bankAccountHolderIdentificationValue: z8.string(),
+        webhookUrl: z8.string().optional()
+      }
+    },
+    async ({
+      rateSig,
+      toMedium,
+      amountSrc,
+      amountDst,
+      sourceAccountUrn,
+      bankAccountType,
+      bankAccountNumber,
+      bankAccountHolderName,
+      bankAccountHolderIdentificationType,
+      bankAccountHolderIdentificationValue,
+      webhookUrl
+    }) => {
+      const result = await clients.swap.bankTransfer.create({
+        rateSig,
+        toMedium,
+        webhookUrl,
+        amountSrc,
+        amountDst,
+        depositInformation: {
+          bankAccountType,
+          bankAccountNumber,
+          bankAccountHolderName,
+          bankAccountHolderIdentificationType,
+          bankAccountHolderIdentificationValue
+        },
+        args: { sourceAccountUrn }
+      });
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/mcp/tools/workflows/identity.ts
+function registerIdentityWorkflows(server, clients) {
+  server.registerTool(
+    "get_profile",
+    {
+      description: "Get the authenticated user's identity profile and verification status. Returns name, email, phone, legal ID, address, and KYC status (approved/awaiting/rejected). Use this as the first call to understand who the user is, check if they can create cards (requires KYC approval), and to auto-fill forms like PSE top-ups. If KYC is not approved, tell the user to run verify_identity first."
+    },
+    async () => {
+      const me = await clients.identity.me();
+      let kyc = {};
+      try {
+        kyc = await clients.compliance.kyc.getVerification({ urn: me.urn });
+      } catch {
+        kyc = { status: "unknown" };
+      }
+      const profile = {
+        urn: me.urn,
+        firstName: me.profile.first_name,
+        lastName: me.profile.last_name,
+        email: me.profile.email,
+        phone: me.profile.phone,
+        legalIdType: me.profile.personal_id_type,
+        legalIdNumber: me.profile.personal_id_number,
+        address: {
+          line1: me.profile.address_line1,
+          line2: me.profile.address_line2,
+          city: me.profile.city,
+          state: me.profile.state,
+          postalCode: me.profile.postal_code,
+          country: me.profile.country_of_residence_code
+        },
+        birthdate: me.profile.birthdate,
+        kycStatus: kyc.status ?? "unknown",
+        canCreateCards: kyc.status === "approved"
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(profile, null, 2) }]
+      };
+    }
+  );
+  server.registerTool(
+    "verify_identity",
+    {
+      description: "Start or check identity verification (KYC). If the user has not started verification, initiates it and returns a URL to complete the process. The user MUST complete KYC before they can create cards. Call get_profile to check status afterward."
+    },
+    async () => {
+      const me = await clients.identity.me();
+      let kyc = {};
+      try {
+        kyc = await clients.compliance.kyc.getVerification({ urn: me.urn });
+      } catch {
+      }
+      if (kyc.status === "approved") {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({ status: "approved", completedAt: kyc.completedAt }, null, 2)
+            }
+          ]
+        };
+      }
+      let result = kyc;
+      try {
+        result = await clients.compliance.kyc.startVerification({ urn: me.urn });
+      } catch {
+      }
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              { status: result.status, verificationUrl: result.url, completedAt: result.completedAt },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/mcp/tools/workflows/account.ts
+import { z as z9 } from "zod/v4";
+function registerAccountWorkflows(server, clients) {
+  server.registerTool(
+    "create_account",
+    {
+      description: "Create a financial account \u2014 the place where money lives. Sets up a virtual pocket (holds the balance) and a Polygon blockchain address (for receiving USDC/crypto) sharing the same ledger. Use this when you need a shared balance that multiple cards will draw from. For a single-card setup, use create_card directly (it creates the account automatically).",
+      inputSchema: {
+        name: z9.string().optional().default("Account"),
+        fundFromUrn: z9.string().optional(),
+        fundAmount: z9.string().optional(),
+        currency: z9.string().optional().default("USD")
+      }
+    },
+    async ({ name, fundFromUrn, fundAmount, currency }) => {
+      const pocket = await clients.accounts.virtual.create({ name });
+      const polygon = await clients.accounts.polygon.create({ ledgerId: pocket.ledgerId, name });
+      let transferResult;
+      if (fundFromUrn && fundAmount) {
+        const { amount: rawAmount, asset } = toRaw(fundAmount, currency);
+        transferResult = await clients.accounts.transfer({
+          sourceUrn: fundFromUrn,
+          destinationUrn: pocket.urn,
+          amount: rawAmount,
+          asset
+        });
+      }
+      const result = {
+        account: { urn: pocket.urn, ledgerId: pocket.ledgerId },
+        polygon: { urn: polygon.urn, address: polygon.address, network: polygon.network },
+        funded: !!transferResult,
+        transferResult
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/mcp/tools/workflows/card.ts
+import { z as z10 } from "zod/v4";
+
+// src/mcp/categories.ts
+var CATEGORY_PRESETS = {
+  food: ["5411", "5412", "5441", "5451", "5462", "5499", "5812", "5813", "5814"],
+  transport: ["4111", "4121", "4131", "4784", "5541", "5542", "7512"],
+  entertainment: ["7832", "7841", "7911", "7922", "7929", "7932", "7933", "7941"],
+  health: ["5912", "8011", "8021", "8031", "8041", "8042", "8043", "8049", "8050", "8062"],
+  shopping: ["5311", "5331", "5399", "5611", "5621", "5631", "5641", "5651", "5661", "5691", "5699"],
+  ads: ["7311", "7312", "7372", "7375", "5734"],
+  travel: [
+    "3000",
+    "3001",
+    "3002",
+    "3003",
+    "3004",
+    "3005",
+    "3006",
+    "3007",
+    "3008",
+    "3009",
+    "3010",
+    "4411",
+    "4511",
+    "4722",
+    "7011",
+    "7012",
+    "7032",
+    "7033"
+  ],
+  subscriptions: ["5815", "5816", "5817", "5818", "4899"]
+};
+function resolveMccs(categories, rawMccs) {
+  const mccs = /* @__PURE__ */ new Set();
+  if (categories) {
+    for (const cat of categories) {
+      const preset = CATEGORY_PRESETS[cat.toLowerCase()];
+      if (preset) {
+        for (const code of preset) mccs.add(code);
+      }
+    }
+  }
+  if (rawMccs) {
+    for (const code of rawMccs) mccs.add(code);
+  }
+  return [...mccs];
+}
+
+// src/mcp/tools/workflows/card.ts
+function extractDomain(input3) {
+  const trimmed = input3.trim();
+  if (!trimmed) return null;
+  let hostname;
+  try {
+    const withProto = /^https?:\/\//i.test(trimmed) ? trimmed : `https://${trimmed}`;
+    hostname = new URL(withProto).hostname;
+  } catch {
+    hostname = trimmed.split("/")[0]?.split("?")[0]?.split("#")[0] ?? trimmed;
+  }
+  hostname = hostname.replace(/:\d+$/, "");
+  if (hostname.startsWith("www.")) hostname = hostname.slice(4);
+  return hostname.toLowerCase() || null;
+}
+function matchDomain(domain, allowedWebsites) {
+  if (!Array.isArray(allowedWebsites)) return false;
+  const normalized = domain.toLowerCase().replace(/^www\./, "");
+  return allowedWebsites.some((pattern) => {
+    if (typeof pattern !== "string") return false;
+    const p = pattern.toLowerCase().replace(/^www\./, "");
+    return normalized === p || normalized.endsWith(`.${p}`);
+  });
+}
+async function pollUntilActive(clients, urn, timeoutMs = 3e4, intervalMs = 2e3) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const account = await clients.accounts.get(urn);
+    if (account.status === "active") return account.status;
+    await new Promise((r) => setTimeout(r, intervalMs));
+  }
+  return "pending";
+}
+function registerCardWorkflows(server, clients) {
+  server.registerTool(
+    "create_card",
+    {
+      description: "Create a card for spending. If accountUrn is provided, the card is attached to that existing account (sharing its balance). If accountUrn is omitted, a new account (pocket + polygon) is created automatically. Optionally restrict to merchant categories using allowedCategories (e.g. 'food', 'transport', 'ads') or allowedMccs (raw MCC codes). Optionally fund the backing account on creation.",
+      inputSchema: {
+        name: z10.string().optional().default("Card"),
+        accountUrn: z10.string().optional(),
+        allowedCategories: z10.array(z10.string()).optional(),
+        allowedMccs: z10.array(z10.string()).optional(),
+        websites: z10.array(z10.string()).optional().describe('Domains this card should be used for (e.g. "amazon.com", "netflix.com")'),
+        fundFromUrn: z10.string().optional(),
+        fundAmount: z10.string().optional(),
+        currency: z10.string().optional().default("USD"),
+        webhookUrl: z10.string().optional()
+      }
+    },
+    async ({
+      name,
+      accountUrn,
+      allowedCategories,
+      allowedMccs,
+      websites,
+      fundFromUrn,
+      fundAmount,
+      currency,
+      webhookUrl
+    }) => {
+      const me = await clients.identity.me();
+      const kyc = await clients.compliance.kyc.getVerification({ urn: me.urn });
+      if (kyc.status !== "approved") {
+        return {
+          content: [{
+            type: "text",
+            text: "KYC verification is not approved. Please run verify_identity first to complete identity verification before creating cards."
+          }],
+          isError: true
+        };
+      }
+      let ledgerId;
+      let virtualAccount;
+      let polygon;
+      if (accountUrn) {
+        const existing = await clients.accounts.get(accountUrn);
+        ledgerId = existing.ledgerId;
+        virtualAccount = { urn: accountUrn, ledgerId };
+        const polygonList = await clients.accounts.list({ medium: "polygon" });
+        const match = polygonList.accounts.find((a) => a.ledgerId === ledgerId);
+        polygon = match ? { urn: match.urn, address: match.address, network: match.network } : { urn: "", address: "", network: "" };
+      } else {
+        const pocket = await clients.accounts.virtual.create({ name });
+        const poly = await clients.accounts.polygon.create({ ledgerId: pocket.ledgerId, name });
+        ledgerId = pocket.ledgerId;
+        virtualAccount = { urn: pocket.urn, ledgerId: pocket.ledgerId };
+        polygon = { urn: poly.urn, address: poly.address, network: poly.network };
+      }
+      const card = await clients.accounts.card.create(
+        { ledgerId, name, webhookUrl },
+        { waitLedger: true }
+      );
+      await pollUntilActive(clients, card.urn);
+      const mccs = resolveMccs(allowedCategories, allowedMccs);
+      const normalizedWebsites = (websites ?? []).map((w) => extractDomain(w)).filter((d) => d !== null);
+      if (mccs.length > 0 || normalizedWebsites.length > 0) {
+        const metadata = {};
+        if (mccs.length > 0) {
+          metadata.spending_control = "default";
+          metadata.mcc_whitelist = mccs;
+          metadata.preferred_asset = "DUSD/6";
+          metadata.default_asset = "DUSD/6";
+        }
+        if (normalizedWebsites.length > 0) {
+          metadata.allowed_websites = normalizedWebsites;
+        }
+        await clients.accounts.card.updateMetadata({
+          urn: card.urn,
+          metadata
+        });
+      }
+      let transferResult;
+      if (fundFromUrn && fundAmount) {
+        const { amount: rawAmount, asset } = toRaw(fundAmount, currency);
+        transferResult = await clients.accounts.transfer({
+          sourceUrn: fundFromUrn,
+          destinationUrn: virtualAccount.urn,
+          amount: rawAmount,
+          asset
+        });
+      }
+      const result = {
+        card: {
+          urn: card.urn,
+          lastFour: card.lastFour,
+          status: card.status,
+          detailsUrl: card.detailsUrl,
+          ledgerId: card.ledgerId
+        },
+        account: { urn: virtualAccount.urn, ledgerId },
+        polygon,
+        funded: !!transferResult,
+        transferResult
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.registerTool(
+    "create_disposable_card",
+    {
+      description: "Create a one-time disposable card with an exact funded amount. Creates an isolated account + card, funds it with the exact amount, so the card can never be charged more. Perfect for untrusted online purchases. Call disable_card after use.",
+      inputSchema: {
+        name: z10.string().optional().default("Disposable Card"),
+        sourceUrn: z10.string(),
+        amount: z10.string(),
+        currency: z10.string().optional().default("USD"),
+        allowedCategories: z10.array(z10.string()).optional(),
+        allowedMccs: z10.array(z10.string()).optional(),
+        websites: z10.array(z10.string()).optional().describe('Domains this card should be used for (e.g. "amazon.com")'),
+        webhookUrl: z10.string().optional()
+      }
+    },
+    async ({
+      name,
+      sourceUrn,
+      amount,
+      currency,
+      allowedCategories,
+      allowedMccs,
+      websites,
+      webhookUrl
+    }) => {
+      const me = await clients.identity.me();
+      const kyc = await clients.compliance.kyc.getVerification({ urn: me.urn });
+      if (kyc.status !== "approved") {
+        return {
+          content: [{
+            type: "text",
+            text: "KYC verification is not approved. Please run verify_identity first to complete identity verification before creating cards."
+          }],
+          isError: true
+        };
+      }
+      const pocket = await clients.accounts.virtual.create({ name });
+      const polygon = await clients.accounts.polygon.create({
+        ledgerId: pocket.ledgerId,
+        name
+      });
+      const card = await clients.accounts.card.create(
+        { ledgerId: pocket.ledgerId, name, webhookUrl },
+        { waitLedger: true }
+      );
+      await pollUntilActive(clients, card.urn);
+      const { amount: rawAmount, asset } = toRaw(amount, currency);
+      const transferResult = await clients.accounts.transfer({
+        sourceUrn,
+        destinationUrn: pocket.urn,
+        amount: rawAmount,
+        asset
+      });
+      const mccs = resolveMccs(allowedCategories, allowedMccs);
+      const normalizedWebsites = (websites ?? []).map((w) => extractDomain(w)).filter((d) => d !== null);
+      if (mccs.length > 0 || normalizedWebsites.length > 0) {
+        const metadata = {};
+        if (mccs.length > 0) {
+          metadata.spending_control = "default";
+          metadata.mcc_whitelist = mccs;
+          metadata.preferred_asset = "DUSD/6";
+          metadata.default_asset = "DUSD/6";
+        }
+        if (normalizedWebsites.length > 0) {
+          metadata.allowed_websites = normalizedWebsites;
+        }
+        await clients.accounts.card.updateMetadata({
+          urn: card.urn,
+          metadata
+        });
+      }
+      const result = {
+        card: {
+          urn: card.urn,
+          lastFour: card.lastFour,
+          status: card.status,
+          detailsUrl: card.detailsUrl,
+          ledgerId: card.ledgerId
+        },
+        account: { urn: pocket.urn, ledgerId: pocket.ledgerId },
+        polygon: { urn: polygon.urn, address: polygon.address, network: polygon.network },
+        funded: true,
+        transferResult
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.registerTool(
+    "resolve_card_for_website",
+    {
+      description: "Find which card(s) to use for a given website. Searches allowed_websites in card metadata. Returns all active matching cards with balances. If no card matches, returns all active cards so you can pick or assign one.",
+      inputSchema: {
+        url: z10.string().describe('URL or domain name to match (e.g. "https://amazon.com/dp/123" or "amazon.com")')
+      }
+    },
+    async ({ url }) => {
+      const domain = extractDomain(url);
+      if (!domain) {
+        return {
+          content: [{ type: "text", text: "A URL or domain name is required." }],
+          isError: true
+        };
+      }
+      const result = await clients.accounts.card.list();
+      const activeCards = result.accounts.filter(
+        (c) => c.status === "active"
+      );
+      const matches = activeCards.filter(
+        (c) => matchDomain(domain, c.metadata?.allowed_websites)
+      );
+      const formatCard = (card) => ({
+        urn: card.urn,
+        name: card.metadata?.name,
+        lastFour: card.lastFour,
+        status: card.status,
+        websites: Array.isArray(card.metadata?.allowed_websites) ? card.metadata.allowed_websites : [],
+        balance: card.balance ? humanizeBalance(card.balance) : void 0,
+        ledgerId: card.ledgerId
+      });
+      if (matches.length > 0) {
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              searchedDomain: domain,
+              matched: true,
+              cards: matches.map(formatCard)
+            }, null, 2)
+          }]
+        };
+      }
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            searchedDomain: domain,
+            matched: false,
+            message: `No card is assigned to "${domain}". Here are all active cards \u2014 you can assign one using assign_card_to_website.`,
+            cards: activeCards.map(formatCard)
+          }, null, 2)
+        }]
+      };
+    }
+  );
+  server.registerTool(
+    "assign_card_to_website",
+    {
+      description: "Associate a card with one or more websites. The agent will then be able to resolve which card to use for a given website via resolve_card_for_website. By default, websites are merged with any existing website assignments. Set merge=false to replace the list entirely.",
+      inputSchema: {
+        cardUrn: z10.string(),
+        websites: z10.array(z10.string()).describe('Domains to assign (e.g. ["amazon.com", "aws.amazon.com"])'),
+        merge: z10.boolean().optional().default(true).describe("Merge with existing websites (true) or replace them (false)")
+      }
+    },
+    async ({ cardUrn, websites, merge }) => {
+      const normalizedNew = websites.map((w) => extractDomain(w)).filter((d) => d !== null);
+      if (normalizedNew.length === 0) {
+        return {
+          content: [{ type: "text", text: "At least one valid domain is required." }],
+          isError: true
+        };
+      }
+      const card = await clients.accounts.get(cardUrn);
+      const existing = card.metadata ?? {};
+      let mergedWebsites;
+      if (merge && Array.isArray(existing.allowed_websites)) {
+        const validExisting = existing.allowed_websites.filter(
+          (w) => typeof w === "string"
+        );
+        mergedWebsites = [.../* @__PURE__ */ new Set([...validExisting, ...normalizedNew])];
+      } else {
+        mergedWebsites = [...new Set(normalizedNew)];
+      }
+      const updatedCard = await clients.accounts.card.updateMetadata({
+        urn: cardUrn,
+        metadata: {
+          ...existing,
+          allowed_websites: mergedWebsites
+        }
+      });
+      return {
+        content: [{
+          type: "text",
+          text: JSON.stringify({
+            card: {
+              urn: updatedCard.urn,
+              lastFour: updatedCard.lastFour,
+              status: updatedCard.status
+            },
+            allowedWebsites: mergedWebsites
+          }, null, 2)
+        }]
+      };
+    }
+  );
+}
+
+// src/mcp/tools/workflows/fund-card.ts
+import { z as z11 } from "zod/v4";
+function registerFundCardWorkflows(server, clients) {
+  server.registerTool(
+    "fund_card",
+    {
+      description: "Add funds to a card (tops up its backing account). Provide the card URN and a source \u2014 the tool resolves the card's backing account automatically. If multiple cards share the same account, all see the updated balance.",
+      inputSchema: {
+        cardUrn: z11.string(),
+        sourceUrn: z11.string(),
+        amount: z11.string(),
+        currency: z11.string().optional().default("USD")
+      }
+    },
+    async ({ cardUrn, sourceUrn, amount, currency }) => {
+      const cardAccount = await clients.accounts.get(cardUrn);
+      const { ledgerId } = cardAccount;
+      const { accounts: virtualAccounts } = await clients.accounts.list({ medium: "virtual" });
+      const pocket = virtualAccounts.find((a) => a.ledgerId === ledgerId);
+      if (!pocket) {
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify(
+              { error: `No virtual pocket found with ledgerId ${ledgerId} for card ${cardUrn}` },
+              null,
+              2
+            )
+          }]
+        };
+      }
+      const { amount: rawAmount, asset } = toRaw(amount, currency);
+      const transferResult = await clients.accounts.transfer({
+        sourceUrn,
+        destinationUrn: pocket.urn,
+        amount: rawAmount,
+        asset
+      });
+      const balance = await clients.accounts.balance(pocket.urn);
+      const result = {
+        transferResult,
+        accountBalance: humanizeBalance(balance)
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/mcp/tools/workflows/topup.ts
+import { z as z12 } from "zod/v4";
+function registerTopupWorkflows(server, clients) {
+  server.registerTool(
+    "topup_via_pse",
+    {
+      description: "Top up an account with Colombian pesos (COP) via PSE bank transfer. Finds the best exchange rate, creates the PSE order, and returns a checkout URL for the user to complete payment at their bank.",
+      inputSchema: {
+        accountUrn: z12.string(),
+        amount: z12.string(),
+        bankCode: z12.string(),
+        userType: z12.union([z12.literal(0), z12.literal(1)]),
+        customerEmail: z12.string(),
+        userLegalIdType: z12.enum(["CC", "NIT", "CE"]),
+        userLegalId: z12.string(),
+        fullName: z12.string(),
+        phoneNumber: z12.string().optional(),
+        webhookUrl: z12.string().optional()
+      }
+    },
+    async ({
+      accountUrn,
+      amount,
+      bankCode,
+      userType,
+      customerEmail,
+      userLegalIdType,
+      userLegalId,
+      fullName,
+      phoneNumber,
+      webhookUrl
+    }) => {
+      const { amount: rawAmount } = toRaw(amount, "COP");
+      const ratesResult = await clients.swap.findRates({
+        fromAsset: "COP/2",
+        toAsset: "DUSD/6",
+        fromMediums: ["pse"],
+        toMediums: ["kusama"],
+        amountSrc: rawAmount
+      });
+      const rate = ratesResult.rates[0];
+      if (!rate) {
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({ error: "No exchange rates available for COP \u2192 USD via PSE" }, null, 2)
+          }]
+        };
+      }
+      const orderResult = await clients.swap.pse.create({
+        rateSig: rate.sig,
+        toMedium: "kusama",
+        amountSrc: rawAmount,
+        webhookUrl,
+        depositInformation: { urn: accountUrn },
+        args: {
+          bankCode,
+          userType,
+          customerEmail,
+          userLegalIdType,
+          userLegalId,
+          customerData: { fullName, phoneNumber: phoneNumber ?? "" }
+        }
+      });
+      const checkoutUrl = orderResult.execution?.result?.how?.url;
+      const result = {
+        order: {
+          id: orderResult.order.id,
+          fromAmount: orderResult.order.fromAmount,
+          toAmount: orderResult.order.toAmount,
+          status: orderResult.order.status
+        },
+        checkoutUrl,
+        rate: { ratio: rate.ratio, fee: rate.fee }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.registerTool(
+    "cashout_to_bank",
+    {
+      description: "Cash out USD to Colombian pesos via bank transfer. Converts from a Bloque account and deposits COP into any Colombian bank account. Handles rate lookup and order creation.",
+      inputSchema: {
+        sourceAccountUrn: z12.string(),
+        amount: z12.string(),
+        currency: z12.string().optional().default("USD"),
+        bankName: z12.string(),
+        bankAccountType: z12.enum(["savings", "checking"]),
+        bankAccountNumber: z12.string(),
+        bankAccountHolderName: z12.string(),
+        idType: z12.enum(["CC", "CE", "NIT", "PP"]),
+        idNumber: z12.string(),
+        webhookUrl: z12.string().optional()
+      }
+    },
+    async ({
+      sourceAccountUrn,
+      amount,
+      currency,
+      bankName,
+      bankAccountType,
+      bankAccountNumber,
+      bankAccountHolderName,
+      idType,
+      idNumber,
+      webhookUrl
+    }) => {
+      const { amount: rawAmount } = toRaw(amount, currency);
+      const ratesResult = await clients.swap.findRates({
+        fromAsset: "DUSD/6",
+        toAsset: "COP/2",
+        fromMediums: ["kusama"],
+        toMediums: [bankName],
+        amountSrc: rawAmount
+      });
+      const rate = ratesResult.rates[0];
+      if (!rate) {
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify(
+              { error: `No exchange rates available for USD \u2192 COP via ${bankName}` },
+              null,
+              2
+            )
+          }]
+        };
+      }
+      const orderResult = await clients.swap.bankTransfer.create({
+        rateSig: rate.sig,
+        toMedium: bankName,
+        amountSrc: rawAmount,
+        webhookUrl,
+        depositInformation: {
+          bankAccountType,
+          bankAccountNumber,
+          bankAccountHolderName,
+          bankAccountHolderIdentificationType: idType,
+          bankAccountHolderIdentificationValue: idNumber
+        },
+        args: { sourceAccountUrn }
+      });
+      const result = {
+        order: {
+          id: orderResult.order.id,
+          fromAmount: orderResult.order.fromAmount,
+          toAmount: orderResult.order.toAmount,
+          status: orderResult.order.status
+        },
+        rate: { ratio: rate.ratio, fee: rate.fee }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/mcp/tools/workflows/spending-rules.ts
+import { z as z13 } from "zod/v4";
+function registerSpendingRulesWorkflows(server, clients) {
+  server.registerTool(
+    "configure_spending_rules",
+    {
+      description: "Advanced: configure smart spending rules that route a card's transactions across MULTIPLE accounts based on merchant category. Each route maps categories/MCCs to an account. Purchases are checked in route order; first match is debited. Routes without categories act as catch-all. Use create_card with allowedCategories for simple restrictions; use this only when one card needs to draw from multiple balance pools.",
+      inputSchema: {
+        cardUrn: z13.string(),
+        routes: z13.array(
+          z13.object({
+            accountUrn: z13.string(),
+            categories: z13.array(z13.string()).optional(),
+            mccs: z13.array(z13.string()).optional()
+          })
+        )
+      }
+    },
+    async ({ cardUrn, routes }) => {
+      const allMccs = [];
+      const priorityMcc = {};
+      let defaultAccountUrn;
+      for (const route of routes) {
+        const resolved = resolveMccs(route.categories, route.mccs);
+        if (resolved.length === 0) {
+          defaultAccountUrn = route.accountUrn;
+          continue;
+        }
+        for (const mcc of resolved) {
+          allMccs.push(mcc);
+          priorityMcc[mcc] = { asset: "DUSD/6", account_urn: route.accountUrn };
+        }
+      }
+      const metadata = {
+        spending_control: "smart",
+        preferred_asset: "DUSD/6",
+        default_asset: "DUSD/6",
+        mcc_whitelist: [...new Set(allMccs)],
+        priority_mcc: priorityMcc
+      };
+      if (defaultAccountUrn) {
+        metadata.default_account_urn = defaultAccountUrn;
+      }
+      const updatedCard = await clients.accounts.card.updateMetadata({
+        urn: cardUrn,
+        metadata
+      });
+      const summary = routes.map((route) => {
+        const resolved = resolveMccs(route.categories, route.mccs);
+        return {
+          accountUrn: route.accountUrn,
+          categories: route.categories ?? [],
+          mccs: resolved,
+          isCatchAll: resolved.length === 0
+        };
+      });
+      const result = { updatedCard, configuredRoutes: summary };
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.registerTool(
+    "add_spending_category",
+    {
+      description: "Add a new spending category to a card's smart routing. Creates a new account for the category and wires it into the routing rules. If the card doesn't have smart routing yet, it is automatically enabled.",
+      inputSchema: {
+        cardUrn: z13.string(),
+        categoryName: z13.string(),
+        categories: z13.array(z13.string()).optional(),
+        mccs: z13.array(z13.string()).optional(),
+        fundFromUrn: z13.string().optional(),
+        fundAmount: z13.string().optional(),
+        currency: z13.string().optional().default("USD")
+      }
+    },
+    async ({ cardUrn, categoryName, categories, mccs, fundFromUrn, fundAmount, currency }) => {
+      const pocket = await clients.accounts.virtual.create({ name: categoryName });
+      const polygon = await clients.accounts.polygon.create({
+        ledgerId: pocket.ledgerId,
+        name: categoryName
+      });
+      const card = await clients.accounts.get(cardUrn);
+      const existing = card.metadata ?? {};
+      const newMccs = resolveMccs(categories, mccs);
+      const existingWhitelist = existing.mcc_whitelist ?? [];
+      const existingPriority = existing.priority_mcc ?? {};
+      const mergedWhitelist = [.../* @__PURE__ */ new Set([...existingWhitelist, ...newMccs])];
+      const mergedPriority = { ...existingPriority };
+      for (const mcc of newMccs) {
+        mergedPriority[mcc] = { asset: "DUSD/6", account_urn: pocket.urn };
+      }
+      const mergedMetadata = {
+        ...existing,
+        spending_control: "smart",
+        preferred_asset: "DUSD/6",
+        default_asset: "DUSD/6",
+        mcc_whitelist: mergedWhitelist,
+        priority_mcc: mergedPriority
+      };
+      const updatedCard = await clients.accounts.card.updateMetadata({
+        urn: cardUrn,
+        metadata: mergedMetadata
+      });
+      let transferResult;
+      if (fundFromUrn && fundAmount) {
+        const { amount: rawAmount, asset } = toRaw(fundAmount, currency);
+        transferResult = await clients.accounts.transfer({
+          sourceUrn: fundFromUrn,
+          destinationUrn: pocket.urn,
+          amount: rawAmount,
+          asset
+        });
+      }
+      const result = {
+        account: { urn: pocket.urn, ledgerId: pocket.ledgerId },
+        polygon: { urn: polygon.urn, address: polygon.address },
+        updatedCard,
+        funded: !!transferResult,
+        transferResult
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/mcp/tools/workflows/overview.ts
+import { z as z14 } from "zod/v4";
+function registerOverviewWorkflows(server, clients) {
+  server.registerTool(
+    "wallet_overview",
+    {
+      description: "Get a complete financial overview in a single call. Returns all accounts grouped by type, with polygon addresses and attached cards, aggregated balances, and recent transactions. Use as the starting point when the user asks 'what do I have?'."
+    },
+    async () => {
+      const { accounts } = await clients.accounts.list();
+      const rawBalances = await clients.accounts.balances();
+      const txs = await clients.accounts.transactions({ limit: 10 });
+      const grouped = {
+        cards: [],
+        virtual: [],
+        polygon: [],
+        us: [],
+        bancolombia: []
+      };
+      for (const account of accounts) {
+        const humanized = {
+          ...account,
+          balance: account.balance ? humanizeBalance(account.balance) : void 0
+        };
+        switch (account.medium) {
+          case "card":
+            grouped.cards.push(humanized);
+            break;
+          case "virtual":
+            grouped.virtual.push(humanized);
+            break;
+          case "polygon":
+            grouped.polygon.push(humanized);
+            break;
+          case "us-account":
+            grouped.us.push(humanized);
+            break;
+          case "bancolombia":
+            grouped.bancolombia.push(humanized);
+            break;
+          default:
+            if (!grouped[account.medium]) grouped[account.medium] = [];
+            grouped[account.medium].push(humanized);
+        }
+      }
+      const humanizedTxs = txs.data.map((tx) => {
+        const { amount, currency } = toHuman(tx.amount, tx.asset);
+        return { ...tx, amount, currency };
+      });
+      const result = {
+        accounts: grouped,
+        totalBalances: humanizeBalance(rawBalances),
+        recentTransactions: humanizedTxs
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+  server.registerTool(
+    "card_summary",
+    {
+      description: "Get everything about a specific card: details (lastFour, status, detailsUrl), backing account, polygon address, balance, MCC restrictions, smart routing config, and recent movements. The detailsUrl is a PCI-compliant link for the USER to open to view full card number/CVV/expiry \u2014 the agent cannot read these.",
+      inputSchema: {
+        cardUrn: z14.string(),
+        movementsLimit: z14.number().optional().default(10)
+      }
+    },
+    async ({ cardUrn, movementsLimit }) => {
+      const card = await clients.accounts.get(cardUrn);
+      const rawBalance = await clients.accounts.balance(cardUrn);
+      let polygonAccount = null;
+      try {
+        const { accounts: polygonAccounts } = await clients.accounts.list({ medium: "polygon" });
+        const match = polygonAccounts.find((a) => a.ledgerId === card.ledgerId);
+        if (match) {
+          polygonAccount = {
+            urn: match.urn,
+            address: match.details?.address ?? match.address,
+            network: match.details?.network ?? match.network
+          };
+        }
+      } catch {
+      }
+      let movements = [];
+      let movementsMeta = {};
+      try {
+        const mvResult = await clients.accounts.movements({ urn: cardUrn, limit: movementsLimit });
+        movements = mvResult.data;
+        movementsMeta = {
+          pageSize: mvResult.pageSize,
+          hasMore: mvResult.hasMore,
+          next: mvResult.next
+        };
+      } catch {
+      }
+      const details = card.details ?? card;
+      const metadata = card.metadata ?? {};
+      const humanizedMovements = movements.map((mv) => {
+        const { amount, currency } = toHuman(mv.amount, mv.asset);
+        return { ...mv, amount, currency };
+      });
+      const result = {
+        card: {
+          urn: card.urn,
+          lastFour: details.lastFour ?? details.last_four,
+          status: details.status ?? card.status,
+          detailsUrl: details.detailsUrl ?? details.details_url,
+          cardType: details.cardType ?? details.card_type,
+          ledgerId: card.ledgerId
+        },
+        account: null,
+        polygonAddress: polygonAccount?.address ?? null,
+        balance: humanizeBalance(rawBalance),
+        restrictions: {
+          mccWhitelist: metadata.mcc_whitelist ?? null,
+          spendingControl: metadata.spending_control ?? null
+        },
+        smartRouting: metadata.priority_mcc ?? null,
+        recentMovements: {
+          data: humanizedMovements,
+          ...movementsMeta
+        }
+      };
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+      };
+    }
+  );
+}
+
+// src/mcp/server.ts
+function createBloqueServer(clients) {
+  const server = new McpServer({ name: "bloque", version: "0.0.1" });
+  registerAccountTools(server, clients);
+  registerVirtualTools(server, clients);
+  registerCardTools(server, clients);
+  registerPolygonTools(server, clients);
+  registerUsTools(server, clients);
+  registerTransferTools(server, clients);
+  registerHistoryTools(server, clients);
+  registerSwapTools(server, clients);
+  registerIdentityWorkflows(server, clients);
+  registerAccountWorkflows(server, clients);
+  registerCardWorkflows(server, clients);
+  registerFundCardWorkflows(server, clients);
+  registerTopupWorkflows(server, clients);
+  registerSpendingRulesWorkflows(server, clients);
+  registerOverviewWorkflows(server, clients);
+  return server;
+}
+async function startServer(server, mode = "stdio", options) {
+  if (mode === "stdio") {
+    const transport2 = new StdioServerTransport();
+    await server.connect(transport2);
+    return;
+  }
+  const port = options?.port ?? 3100;
+  const transport = new StreamableHTTPServerTransport({
+    sessionIdGenerator: () => randomUUID(),
+    enableJsonResponse: true
+  });
+  await server.connect(transport);
+  const httpServer = createServer((req, res) => {
+    if (req.url === "/mcp") {
+      transport.handleRequest(req, res);
+    } else {
+      res.writeHead(404).end("Not Found");
+    }
+  });
+  httpServer.listen(port, () => {
+    console.error(`Bloque MCP server listening on http://localhost:${port}/mcp`);
+  });
+}
+
+// src/commands/mcp.ts
+var store4 = new SessionStore();
+var mcpCommand = new Command4("mcp").description("Start the MCP server exposing Bloque SDK tools").option("--http", "Use HTTP/SSE transport instead of stdio").option("--port <port>", "HTTP port (only with --http)", "3100").action(async (opts) => {
+  const session = store4.load();
+  if (!session) {
+    console.error("Not logged in. Run `bloque login` first.");
+    process.exit(1);
+  }
+  const sdkConfig = session.authType === "apiKey" && session.apiKey ? {
+    auth: { type: "apiKey", apiKey: session.apiKey },
+    mode: session.mode,
+    origin: session.origin
+  } : {
+    auth: { type: "jwt" },
+    mode: session.mode,
+    origin: session.origin,
+    tokenStorage: {
+      get: () => session.accessToken,
+      set: () => {
+      },
+      clear: () => {
+      }
+    }
+  };
+  const sdk = new SDK2(sdkConfig);
+  let clients;
+  if (session.authType === "apiKey" && session.alias) {
+    clients = await sdk.connect(session.alias);
+  } else {
+    clients = await sdk.authenticate();
+  }
+  const server = createBloqueServer(clients);
+  if (opts.http) {
+    await startServer(server, "http", { port: Number(opts.port) });
+  } else {
+    await startServer(server, "stdio");
+  }
+});
+
+// src/commands/setup.ts
+import fs2 from "fs";
+import os2 from "os";
+import path2 from "path";
+import { execSync } from "child_process";
+import { Command as Command5 } from "commander";
+import { SDK as SDK3 } from "@bloque/sdk";
+import { checkbox, confirm, input as input2, password as password2, select as select2 } from "@inquirer/prompts";
+var store5 = new SessionStore();
+var OTP_CHANNELS2 = [
+  {
+    name: "WhatsApp",
+    value: "bloque-whatsapp",
+    prompt: "Phone number (e.g. +573001234567):",
+    sentMessage: "OTP sent via WhatsApp \u2014 check your phone."
+  },
+  {
+    name: "Email",
+    value: "bloque-email",
+    prompt: "Email address:",
+    sentMessage: "OTP sent \u2014 check your inbox."
+  }
+];
+var PLATFORM = process.platform;
+var HOME = os2.homedir();
+var APPDATA = process.env.APPDATA || path2.join(HOME, "AppData", "Roaming");
+var LOCAL_APPDATA = process.env.LOCALAPPDATA || path2.join(HOME, "AppData", "Local");
+function hasCommand(bin) {
+  try {
+    const cmd = PLATFORM === "win32" ? `where ${bin} 2>nul` : `which ${bin} 2>/dev/null`;
+    execSync(cmd, { stdio: "pipe" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasMacApp(bundleId) {
+  if (PLATFORM !== "darwin") return false;
+  try {
+    const result = execSync(
+      `mdfind "kMDItemCFBundleIdentifier == '${bundleId}'" 2>/dev/null`,
+      { stdio: "pipe", encoding: "utf-8" }
+    );
+    return result.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+function hasWindowsApp(...relativePaths) {
+  if (PLATFORM !== "win32") return false;
+  return relativePaths.some((p) => fs2.existsSync(path2.join(LOCAL_APPDATA, p)));
+}
+function hasLinuxDesktop(desktopName) {
+  if (PLATFORM !== "linux") return false;
+  const dirs = [
+    "/usr/share/applications",
+    path2.join(HOME, ".local", "share", "applications"),
+    "/var/lib/snapd/desktop/applications"
+  ];
+  return dirs.some((d) => fs2.existsSync(path2.join(d, desktopName)));
+}
+function claudeDesktopConfigPath() {
+  if (PLATFORM === "win32")
+    return path2.join(APPDATA, "Claude", "claude_desktop_config.json");
+  if (PLATFORM === "linux")
+    return path2.join(HOME, ".config", "Claude", "claude_desktop_config.json");
+  return path2.join(HOME, "Library", "Application Support", "Claude", "claude_desktop_config.json");
+}
+var AGENTS = [
+  {
+    id: "cursor",
+    name: "Cursor",
+    configPath: path2.join(HOME, ".cursor", "mcp.json"),
+    skillAgent: "cursor",
+    detect: () => hasMacApp("com.todesktop.230313mzl4w4u92") || hasWindowsApp("Programs\\cursor\\Cursor.exe") || hasLinuxDesktop("cursor.desktop") || hasCommand("cursor") || fs2.existsSync(path2.join(HOME, ".cursor"))
+  },
+  {
+    id: "claude-desktop",
+    name: "Claude Desktop",
+    configPath: claudeDesktopConfigPath(),
+    detect: () => hasMacApp("com.anthropic.claudefordesktop") || hasWindowsApp("AnthropicClaude\\Claude.exe", "Programs\\Claude\\Claude.exe") || hasLinuxDesktop("claude-desktop.desktop") || hasCommand("claude-desktop")
+  },
+  {
+    id: "claude-code",
+    name: "Claude Code",
+    configPath: path2.join(HOME, ".claude.json"),
+    skillAgent: "claude-code",
+    detect: () => hasCommand("claude")
+  },
+  {
+    id: "antigravity",
+    name: "Antigravity (Google)",
+    configPath: path2.join(HOME, ".gemini", "antigravity", "mcp_config.json"),
+    skillAgent: "gemini-cli",
+    detect: () => hasCommand("gemini")
+  }
+];
+var MCP_ENTRY = {
+  command: "npx",
+  args: ["-y", "@bloque/cli", "mcp"]
+};
+function detectInstalled() {
+  return AGENTS.filter((agent) => {
+    try {
+      return agent.detect();
+    } catch {
+      return false;
+    }
+  });
+}
+function readJsonFile(filePath) {
+  try {
+    const raw = fs2.readFileSync(filePath, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return {};
+  }
+}
+function writeJsonFile(filePath, data) {
+  fs2.mkdirSync(path2.dirname(filePath), { recursive: true });
+  fs2.writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n");
+}
+function injectMcpConfig(agent) {
+  const config = readJsonFile(agent.configPath);
+  if (!config.mcpServers) {
+    config.mcpServers = {};
+  }
+  if (config.mcpServers.bloque) {
+    return { action: "exists" };
+  }
+  config.mcpServers.bloque = MCP_ENTRY;
+  writeJsonFile(agent.configPath, config);
+  return { action: "added" };
+}
+function installSkills(agents) {
+  const skillAgents = agents.filter((a) => a.skillAgent).map((a) => a.skillAgent);
+  if (skillAgents.length === 0) return false;
+  const agentFlags = skillAgents.map((a) => `-a ${a}`).join(" ");
+  try {
+    execSync(
+      `npx -y skills add bloque-app/skills --skill bloque-sdk-ts -g ${agentFlags} -y`,
+      { stdio: "pipe", timeout: 12e4 }
+    );
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function runOtpLogin(mode) {
+  const channel = await select2({
+    message: "How would you like to receive your OTP?",
+    choices: OTP_CHANNELS2.map((c) => ({ name: c.name, value: c.value }))
+  });
+  const selectedChannel = OTP_CHANNELS2.find((c) => c.value === channel);
+  const userAlias = await input2({ message: selectedChannel.prompt });
+  let _token = null;
+  const sdk = new SDK3({
+    auth: { type: "jwt" },
+    mode,
+    origin: channel,
+    tokenStorage: {
+      get: () => _token,
+      set: (t) => {
+        _token = t;
+      },
+      clear: () => {
+        _token = null;
+      }
+    }
+  });
+  await sdk.assert(channel, userAlias);
+  console.log(selectedChannel.sentMessage);
+  const code = await password2({ message: "Enter OTP code:", mask: "*" });
+  const clients = await sdk.connect(channel, userAlias, code);
+  store5.save({
+    accessToken: clients.accessToken,
+    urn: clients.urn ?? "",
+    origin: channel,
+    mode,
+    authType: "jwt",
+    alias: userAlias,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  await portalAnimation(`Connected as ${clients.urn ?? userAlias}`);
+}
+var setupCommand = new Command5("setup").description("Set up Bloque MCP in your AI code agents").option("--jwt <token>", "JWT token for authentication (skips OTP)").option("--sandbox", "Use sandbox environment instead of production").action(async (opts) => {
+  const { jwt, sandbox } = opts;
+  const mode = sandbox ? "sandbox" : "production";
+  console.log("\n  Bloque Setup Wizard\n");
+  if (jwt) {
+    store5.save({
+      accessToken: jwt,
+      urn: "",
+      origin: "cli",
+      mode,
+      authType: "jwt",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    console.log("  Session saved from JWT token.\n");
+  } else if (store5.exists()) {
+    const session = store5.load();
+    console.log(`  Already logged in (${session.alias || session.urn || "session found"}).`);
+    const reuse = await confirm({ message: "Use existing session?", default: true });
+    if (!reuse) {
+      await runOtpLogin(mode);
+    } else {
+      console.log();
+    }
+  } else {
+    console.log("  No session found. Let's log in first.\n");
+    await runOtpLogin(mode);
+  }
+  const detected = detectInstalled();
+  const detectedIds = new Set(detected.map((a) => a.id));
+  if (AGENTS.length === 0) {
+    console.log("  No supported AI agents found on this system.");
+    return;
+  }
+  const choices = AGENTS.map((agent) => ({
+    name: detectedIds.has(agent.id) ? `${agent.name} (detected)` : `${agent.name}`,
+    value: agent.id,
+    checked: detectedIds.has(agent.id)
+  }));
+  const selectedIds = await checkbox({
+    message: "Which agents should Bloque be installed in?",
+    choices
+  });
+  if (selectedIds.length === 0) {
+    console.log("\n  No agents selected. Setup complete.\n");
+    return;
+  }
+  const selectedAgents = AGENTS.filter((a) => selectedIds.includes(a.id));
+  console.log("\n  Installing MCP server config...\n");
+  const mcpResults = [];
+  for (const agent of selectedAgents) {
+    const { action } = injectMcpConfig(agent);
+    if (action === "exists") {
+      const overwrite = await confirm({
+        message: `  ${agent.name}: bloque MCP already configured. Overwrite?`,
+        default: false
+      });
+      if (overwrite) {
+        const config = readJsonFile(agent.configPath);
+        config.mcpServers.bloque = MCP_ENTRY;
+        writeJsonFile(agent.configPath, config);
+        mcpResults.push({ agent: agent.name, result: "overwritten" });
+      } else {
+        mcpResults.push({ agent: agent.name, result: "skipped (already configured)" });
+      }
+    } else {
+      mcpResults.push({ agent: agent.name, result: "added" });
+    }
+  }
+  for (const r of mcpResults) {
+    console.log(`    ${r.agent}: ${r.result}`);
+  }
+  const agentsWithSkill = selectedAgents.filter((a) => a.skillAgent);
+  if (agentsWithSkill.length > 0) {
+    const names = agentsWithSkill.map((a) => a.name).join(", ");
+    process.stdout.write(`
+  Installing Bloque SDK skill globally for ${names}...`);
+    const ok = installSkills(agentsWithSkill);
+    console.log(ok ? " done\n" : " failed (you can install manually later)\n");
+  }
+  await portalAnimation("Setup complete");
+  console.log("  What was configured:\n");
+  for (const r of mcpResults) {
+    console.log(`    \x1B[38;5;75m\u25B8\x1B[0m ${r.agent}: MCP server ${r.result}`);
+  }
+  if (agentsWithSkill.length > 0) {
+    console.log(`    \x1B[38;5;75m\u25B8\x1B[0m Bloque SDK skill: ${agentsWithSkill.map((a) => a.name).join(", ")}`);
+  }
+  console.log("\n  Next steps:\n");
+  console.log("    1. Restart your AI agent(s) for changes to take effect");
+  console.log("    2. Ask your agent to use the Bloque tools");
+  console.log("    3. Run `bloque mcp --http` if you need HTTP transport\n");
+});
+
+// src/bin.ts
+var program = new Command6();
+program.name("bloque").description("Bloque CLI \u2014 manage accounts and cards via MCP").version("0.0.1");
+program.addCommand(setupCommand);
+program.addCommand(loginCommand);
+program.addCommand(logoutCommand);
+program.addCommand(whoamiCommand);
+program.addCommand(mcpCommand);
+program.parse();