@moonpay/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,2030 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { createRequire } from "module";
+import { Command, Option } from "commander";
+
+// src/auth.ts
+import { spawn } from "child_process";
+import * as crypto from "crypto";
+import * as fs from "fs";
+import * as http from "http";
+import * as os from "os";
+import * as path from "path";
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function generateCodeVerifier() {
+  return crypto.randomBytes(32).toString("base64url");
+}
+function generateCodeChallenge(verifier) {
+  return crypto.createHash("sha256").update(verifier).digest("base64url");
+}
+var CONFIG_DIR = path.join(os.homedir(), ".config", "moon-iq");
+var CONFIG_PATH = path.join(CONFIG_DIR, "config.json");
+var CREDENTIALS_PATH = path.join(CONFIG_DIR, "credentials.json");
+var LOCK_PATH = path.join(CONFIG_DIR, ".credentials.lock");
+var CALLBACK_PORT = 3847;
+var CALLBACK_URL = `http://localhost:${CALLBACK_PORT}/callback`;
+var DEFAULT_CONFIG = {
+  baseUrl: "https://moon-iq.com",
+  clientId: "mooniq_zin3s5jz3olzkdfxpmbeaogv"
+};
+function ensureConfigDir() {
+  if (!fs.existsSync(CONFIG_DIR)) {
+    fs.mkdirSync(CONFIG_DIR, { recursive: true, mode: 448 });
+  }
+}
+function atomicWriteFileSync(filePath, data, mode) {
+  const tmp = filePath + `.tmp.${process.pid}`;
+  fs.writeFileSync(tmp, data, { encoding: "utf-8", mode });
+  fs.renameSync(tmp, filePath);
+}
+var LOCK_STALE_MS = 3e4;
+function acquireLock() {
+  ensureConfigDir();
+  try {
+    const fd = fs.openSync(LOCK_PATH, fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_WRONLY, 384);
+    fs.writeSync(fd, JSON.stringify({ pid: process.pid, ts: Date.now() }));
+    fs.closeSync(fd);
+  } catch (err) {
+    if (err.code !== "EEXIST") throw err;
+    try {
+      const lockData = JSON.parse(fs.readFileSync(LOCK_PATH, "utf-8"));
+      if (Date.now() - lockData.ts < LOCK_STALE_MS) {
+        return null;
+      }
+    } catch {
+    }
+    try {
+      fs.unlinkSync(LOCK_PATH);
+    } catch {
+    }
+    try {
+      const fd = fs.openSync(LOCK_PATH, fs.constants.O_CREAT | fs.constants.O_EXCL | fs.constants.O_WRONLY, 384);
+      fs.writeSync(fd, JSON.stringify({ pid: process.pid, ts: Date.now() }));
+      fs.closeSync(fd);
+    } catch {
+      return null;
+    }
+  }
+  return () => {
+    try {
+      fs.unlinkSync(LOCK_PATH);
+    } catch {
+    }
+  };
+}
+function getConfig() {
+  if (!fs.existsSync(CONFIG_PATH)) {
+    return null;
+  }
+  try {
+    const data = JSON.parse(fs.readFileSync(CONFIG_PATH, "utf-8"));
+    if (!data.baseUrl || !data.clientId) {
+      return null;
+    }
+    return data;
+  } catch {
+    return null;
+  }
+}
+function getConfigOrDefault() {
+  const fromFile = getConfig();
+  if (fromFile) return fromFile;
+  saveConfig(DEFAULT_CONFIG);
+  return DEFAULT_CONFIG;
+}
+function getCredentials() {
+  if (!fs.existsSync(CREDENTIALS_PATH)) {
+    return null;
+  }
+  try {
+    const data = JSON.parse(fs.readFileSync(CREDENTIALS_PATH, "utf-8"));
+    if (!data.accessToken || !data.baseUrl) {
+      return null;
+    }
+    return data;
+  } catch {
+    return null;
+  }
+}
+function saveCredentials(creds) {
+  ensureConfigDir();
+  atomicWriteFileSync(CREDENTIALS_PATH, JSON.stringify(creds, null, 2), 384);
+}
+function saveConfig(config) {
+  ensureConfigDir();
+  atomicWriteFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), 384);
+}
+function clearCredentials() {
+  if (fs.existsSync(CREDENTIALS_PATH)) {
+    fs.unlinkSync(CREDENTIALS_PATH);
+  }
+}
+function openBrowser(url) {
+  const platform = process.platform;
+  const cmd = platform === "darwin" ? "open" : platform === "win32" ? "cmd" : "xdg-open";
+  const args = platform === "win32" ? ["/c", "start", "", url] : [url];
+  spawn(cmd, args, { stdio: "ignore", detached: true }).unref();
+}
+async function login(config) {
+  const state = crypto.randomUUID();
+  const usePkce = !config.clientSecret;
+  let codeVerifier;
+  if (usePkce) {
+    codeVerifier = generateCodeVerifier();
+  }
+  let resolveCallback;
+  const codePromise = new Promise((resolve) => {
+    resolveCallback = resolve;
+  });
+  const sockets = /* @__PURE__ */ new Set();
+  const server = http.createServer((req, res) => {
+    const url = new URL(req.url ?? "/", `http://localhost:${CALLBACK_PORT}`);
+    if (url.pathname === "/callback") {
+      const code2 = url.searchParams.get("code");
+      const returnedState = url.searchParams.get("state");
+      const error = url.searchParams.get("error");
+      const errorDesc = url.searchParams.get("error_description");
+      if (returnedState !== state) {
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(
+          `<!DOCTYPE html><html><head><meta charset="utf-8"><title>OAuth Error</title></head><body style="font-family:system-ui,sans-serif;display:flex;flex-direction:column;align-items:center;justify-content:center;min-height:100vh;margin:0;padding:2rem;text-align:center;background:#fef2f2"><h1 style="color:#b91c1c;margin:0 0 1rem">OAuth Error</h1><p style="color:#991b1b;margin:0">State mismatch \u2014 possible CSRF attack. Please try logging in again.</p></body></html>`
+        );
+        resolveCallback("");
+        setTimeout(() => server.close(), 2e3);
+      } else if (error) {
+        const safeError = escapeHtml(error);
+        const safeDesc = escapeHtml(errorDesc ?? "Unknown error");
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(
+          `<!DOCTYPE html><html><head><meta charset="utf-8"><title>OAuth Error</title></head><body style="font-family:system-ui,sans-serif;display:flex;flex-direction:column;align-items:center;justify-content:center;min-height:100vh;margin:0;padding:2rem;text-align:center;background:#fef2f2"><h1 style="color:#b91c1c;margin:0 0 1rem">OAuth Error</h1><p style="color:#991b1b;margin:0">${safeError}: ${safeDesc}</p></body></html>`
+        );
+        resolveCallback("");
+        setTimeout(() => server.close(), 2e3);
+      } else if (code2) {
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(
+          `<!DOCTYPE html><html><head><meta charset="utf-8"><title>Success</title></head><body style="font-family:system-ui,sans-serif;display:flex;flex-direction:column;align-items:center;justify-content:center;min-height:100vh;margin:0;padding:2rem;text-align:center;background:#f0fdf4"><h1 style="color:#166534;margin:0 0 1rem;font-size:1.5rem">\u2713 Success!</h1><p style="color:#15803d;margin:0;font-size:1.1rem">You can close this page and return to the terminal.</p></body></html>`
+        );
+        resolveCallback(code2);
+      } else {
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(
+          `<!DOCTYPE html><html><head><meta charset="utf-8"><title>Error</title></head><body style="font-family:system-ui,sans-serif;display:flex;flex-direction:column;align-items:center;justify-content:center;min-height:100vh;margin:0;padding:2rem;text-align:center;background:#fef2f2"><h1 style="color:#b91c1c;margin:0 0 1rem">Error</h1><p style="color:#991b1b;margin:0">No authorization code received.</p></body></html>`
+        );
+        resolveCallback("");
+        setTimeout(() => server.close(), 2e3);
+      }
+    } else {
+      res.writeHead(204);
+      res.end();
+    }
+  });
+  await new Promise((resolve, reject) => {
+    server.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        reject(
+          new Error(
+            `Port ${CALLBACK_PORT} is in use. Close the other process or run: lsof -i :${CALLBACK_PORT}`
+          )
+        );
+      } else {
+        reject(err);
+      }
+    });
+    server.on("connection", (socket) => {
+      sockets.add(socket);
+      socket.on("close", () => sockets.delete(socket));
+    });
+    server.listen(CALLBACK_PORT, "127.0.0.1", () => resolve());
+  });
+  console.log(
+    `Waiting for callback at http://localhost:${CALLBACK_PORT}/callback`
+  );
+  const authorizeParams = new URLSearchParams({
+    client_id: config.clientId,
+    redirect_uri: CALLBACK_URL,
+    response_type: "code",
+    scope: "profile email",
+    state
+  });
+  if (usePkce && codeVerifier) {
+    authorizeParams.set("code_challenge", generateCodeChallenge(codeVerifier));
+    authorizeParams.set("code_challenge_method", "S256");
+  }
+  const authorizeUrl = `${config.baseUrl}/api/oauth/authorize?${authorizeParams.toString()}`;
+  console.log("Opening browser for authorization...");
+  console.log("(Make sure you're logged in to Moon IQ in your browser)\n");
+  openBrowser(authorizeUrl);
+  const code = await codePromise;
+  if (!code) {
+    throw new Error("No authorization code received");
+  }
+  const tokenParams = {
+    grant_type: "authorization_code",
+    code,
+    client_id: config.clientId,
+    redirect_uri: CALLBACK_URL
+  };
+  if (config.clientSecret) {
+    tokenParams.client_secret = config.clientSecret;
+  }
+  if (usePkce && codeVerifier) {
+    tokenParams.code_verifier = codeVerifier;
+  }
+  const tokenResponse = await fetch(`${config.baseUrl}/api/oauth/token`, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: new URLSearchParams(tokenParams)
+  });
+  if (!tokenResponse.ok) {
+    const err = await tokenResponse.json().catch(() => ({}));
+    const msg = err.error_description ?? err.error ?? tokenResponse.statusText;
+    throw new Error(`Token exchange failed: ${msg}`);
+  }
+  const tokens = await tokenResponse.json();
+  const expiresAt = Date.now() + (tokens.expires_in ?? 3600) * 1e3;
+  const creds = {
+    accessToken: tokens.access_token,
+    refreshToken: tokens.refresh_token ?? null,
+    expiresAt,
+    baseUrl: config.baseUrl
+  };
+  saveCredentials(creds);
+  await new Promise((resolve) => setTimeout(resolve, 1e3));
+  server.close();
+  for (const socket of sockets) {
+    if ("destroy" in socket && typeof socket.destroy === "function") {
+      socket.destroy();
+    }
+  }
+  sockets.clear();
+  return creds;
+}
+async function refreshCredentials(creds, config) {
+  if (!creds.refreshToken) {
+    throw new Error("No refresh token available");
+  }
+  const unlock = acquireLock();
+  if (!unlock) {
+    await new Promise((r) => setTimeout(r, 2e3));
+    const fresh = getCredentials();
+    if (fresh && fresh.expiresAt > Date.now()) {
+      return fresh;
+    }
+    throw new Error("Token refresh failed (concurrent refresh in progress)");
+  }
+  try {
+    const latest = getCredentials();
+    if (latest && latest.expiresAt > Date.now() + 6e4) {
+      return latest;
+    }
+    const refreshParams = {
+      grant_type: "refresh_token",
+      refresh_token: creds.refreshToken,
+      client_id: config.clientId
+    };
+    if (config.clientSecret) {
+      refreshParams.client_secret = config.clientSecret;
+    }
+    const tokenResponse = await fetch(`${config.baseUrl}/api/oauth/token`, {
+      method: "POST",
+      headers: { "Content-Type": "application/x-www-form-urlencoded" },
+      body: new URLSearchParams(refreshParams)
+    });
+    if (!tokenResponse.ok) {
+      throw new Error("Token refresh failed");
+    }
+    const tokens = await tokenResponse.json();
+    const expiresAt = Date.now() + (tokens.expires_in ?? 3600) * 1e3;
+    const newCreds = {
+      accessToken: tokens.access_token,
+      refreshToken: tokens.refresh_token ?? creds.refreshToken,
+      expiresAt,
+      baseUrl: config.baseUrl
+    };
+    saveCredentials(newCreds);
+    return newCreds;
+  } finally {
+    unlock();
+  }
+}
+var TOKEN_EXPIRY_BUFFER_MS = 5 * 60 * 1e3;
+async function getValidToken() {
+  const creds = getCredentials();
+  if (!creds) return null;
+  const config = getConfig();
+  if (!config || config.baseUrl !== creds.baseUrl) return null;
+  if (Date.now() >= creds.expiresAt - TOKEN_EXPIRY_BUFFER_MS) {
+    if (creds.refreshToken) {
+      try {
+        const newCreds = await refreshCredentials(creds, config);
+        return newCreds.accessToken;
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+  return creds.accessToken;
+}
+
+// src/generated/client.ts
+var TOOL_NAMES = [
+  "iron_account_create",
+  "iron_account_retrieve",
+  "iron_offramp_create",
+  "iron_offramp_delete",
+  "iron_offramp_initiate",
+  "iron_offramp_list",
+  "iron_offramp_retrieve",
+  "iron_onramp_create",
+  "iron_onramp_delete",
+  "iron_onramp_list",
+  "iron_onramp_payment_create",
+  "iron_onramp_payment_retrieve",
+  "iron_onramp_retrieve",
+  "lending_account_retrieve",
+  "lending_deposit",
+  "lending_rate_retrieve",
+  "lending_recommend",
+  "lending_withdraw",
+  "market_digest_retrieve",
+  "moonpay_buy",
+  "solana_buy",
+  "token_balance_check",
+  "token_balance_list",
+  "token_balance_retrieve",
+  "token_bridge",
+  "token_buy",
+  "token_digest_retrieve",
+  "token_holder_list",
+  "token_limit_buy",
+  "token_limit_buy_recommend",
+  "token_limit_order_list",
+  "token_limit_recommend",
+  "token_limit_sell",
+  "token_limit_sell_recommend",
+  "token_liquidity_lock_list",
+  "token_liquidity_retrieve",
+  "token_pair_list",
+  "token_recurring_buy",
+  "token_recurring_order_list",
+  "token_recurring_recommend",
+  "token_recurring_sell",
+  "token_retrieve",
+  "token_search",
+  "token_sell",
+  "token_swap",
+  "token_swap_recommend",
+  "token_top_trader_list",
+  "token_transfer",
+  "token_trending_list",
+  "user_retrieve",
+  "user_update",
+  "user_wallet_list",
+  "user_wallet_retrieve",
+  "wallet_digest_retrieve",
+  "x402_request"
+];
+var TOOL_DEFINITIONS = [
+  {
+    "name": "iron_account_create",
+    "description": "Create a new Iron account for the user.",
+    "options": []
+  },
+  {
+    "name": "iron_account_retrieve",
+    "description": "Get the user's Iron account information.",
+    "options": []
+  },
+  {
+    "name": "iron_offramp_create",
+    "description": "Create a new offramp for the user to convert crypto to fiat",
+    "options": [
+      {
+        "name": "name",
+        "type": "string",
+        "description": "The name of the offramp",
+        "required": true
+      },
+      {
+        "name": "fiat",
+        "type": "string",
+        "description": "The fiat currency to convert to",
+        "required": true,
+        "choices": [
+          "USD",
+          "EUR"
+        ]
+      },
+      {
+        "name": "stablecoin",
+        "type": "string",
+        "description": "The stablecoin token to convert from",
+        "required": true,
+        "choices": [
+          "USDC",
+          "USDT",
+          "EURC"
+        ]
+      }
+    ]
+  },
+  {
+    "name": "iron_offramp_delete",
+    "description": "Cancel an offramp",
+    "options": [
+      {
+        "name": "offrampId",
+        "type": "string",
+        "description": "The ID of the offramp to cancel",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "iron_offramp_initiate",
+    "description": "Initiate an offramp by sending stablecoin to the offramp's deposit account. The stablecoin will be converted to fiat and deposited into your registered bank account. This process is asynchronous and may take some time for funds to appear in your bank account.",
+    "options": [
+      {
+        "name": "simulation",
+        "type": "boolean",
+        "description": "If true, only simulate the transaction without executing it",
+        "required": true
+      },
+      {
+        "name": "offrampId",
+        "type": "string",
+        "description": "The ID of the offramp to initiate",
+        "required": true
+      },
+      {
+        "name": "amount",
+        "type": "number",
+        "description": "The amount of stablecoin to send (in human-readable units, e.g., 100.5)",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "iron_offramp_list",
+    "description": "Get all offramps for the user",
+    "options": []
+  },
+  {
+    "name": "iron_offramp_retrieve",
+    "description": "Get an offramp for the user",
+    "options": [
+      {
+        "name": "offrampId",
+        "type": "string",
+        "description": "The ID of the offramp to retrieve",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "iron_onramp_create",
+    "description": "Create an onramp to convert fiat currency to a stablecoin",
+    "options": [
+      {
+        "name": "name",
+        "type": "string",
+        "description": "The name of the onramp",
+        "required": true
+      },
+      {
+        "name": "fiat",
+        "type": "string",
+        "description": "The fiat currency to convert from",
+        "required": true,
+        "choices": [
+          "USD",
+          "EUR"
+        ]
+      },
+      {
+        "name": "stablecoin",
+        "type": "string",
+        "description": "The stablecoin token to convert to",
+        "required": true,
+        "choices": [
+          "USDC",
+          "USDT",
+          "EURC"
+        ]
+      }
+    ]
+  },
+  {
+    "name": "iron_onramp_delete",
+    "description": "Cancel an onramp",
+    "options": [
+      {
+        "name": "onrampId",
+        "type": "string",
+        "description": "The ID of the onramp to cancel",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "iron_onramp_list",
+    "description": "Get all onramps for the user",
+    "options": [
+      {
+        "name": "status",
+        "type": "string",
+        "description": "Status of the onramps to get",
+        "required": true,
+        "choices": [
+          "Created",
+          "Authorized",
+          "DepositAccountAdded",
+          "Approved",
+          "Rejected",
+          "Cancelled"
+        ]
+      }
+    ]
+  },
+  {
+    "name": "iron_onramp_payment_create",
+    "description": "Create an open banking payment link for an onramp",
+    "options": [
+      {
+        "name": "onrampId",
+        "type": "string",
+        "description": "The ID of the onramp",
+        "required": true
+      },
+      {
+        "name": "amount",
+        "type": "string",
+        "description": "The amount to pay",
+        "required": true
+      },
+      {
+        "name": "fiat",
+        "type": "string",
+        "description": "The fiat currency (USD or EUR)",
+        "required": true,
+        "choices": [
+          "USD",
+          "EUR"
+        ]
+      }
+    ]
+  },
+  {
+    "name": "iron_onramp_payment_retrieve",
+    "description": "Get the status of an open banking payment",
+    "options": [
+      {
+        "name": "onrampId",
+        "type": "string",
+        "description": "The ID of the onramp this payment belongs to",
+        "required": true
+      },
+      {
+        "name": "paymentId",
+        "type": "string",
+        "description": "The ID of the payment to retrieve",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "iron_onramp_retrieve",
+    "description": "Get an onramp for the user",
+    "options": [
+      {
+        "name": "onrampId",
+        "type": "string",
+        "description": "The ID of the onramp to retrieve",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "lending_account_retrieve",
+    "description": "Get account details for a lending account by wallet address, including balances, interest earned, and withdrawal limits",
+    "options": []
+  },
+  {
+    "name": "lending_deposit",
+    "description": "Deposit USDC into your lending account to earn interest.",
+    "options": [
+      {
+        "name": "simulation",
+        "type": "boolean",
+        "description": "If true, only simulate the transaction without executing it",
+        "required": true
+      },
+      {
+        "name": "amount",
+        "type": "number",
+        "description": "Amount of USDC to deposit",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "lending_rate_retrieve",
+    "description": "Get current and historical interest rates for lending USDC",
+    "options": []
+  },
+  {
+    "name": "lending_recommend",
+    "description": "Analyze user's lending account and wallet balances to recommend either a deposit or withdraw action with appropriate parameters. Understands queries like 'should I deposit more?', 'recommend a withdrawal', or 'what should I do with my lending account?'.",
+    "options": [
+      {
+        "name": "query",
+        "type": "string",
+        "description": "Natural language query about lending recommendations. Examples: 'should I deposit more?', 'recommend a withdrawal', 'what should I do with my lending account?'.",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "lending_withdraw",
+    "description": "Withdraw USDC from your lending account.",
+    "options": [
+      {
+        "name": "simulation",
+        "type": "boolean",
+        "description": "If true, only simulate the transaction without executing it",
+        "required": true
+      },
+      {
+        "name": "amount",
+        "type": "number",
+        "description": "Amount of USDC to withdraw",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "market_digest_retrieve",
+    "description": "Retrieve a market digest by chain.",
+    "options": [
+      {
+        "name": "chain",
+        "type": "string",
+        "description": "Blockchain network",
+        "required": true,
+        "choices": [
+          "solana",
+          "ethereum",
+          "base",
+          "polygon",
+          "arbitrum",
+          "optimism"
+        ]
+      }
+    ]
+  },
+  {
+    "name": "moonpay_buy",
+    "description": "Buy a token using Moonpay. Specify either from.amount (USD to spend) or to.amount (tokens to buy), not both.",
+    "options": [
+      {
+        "name": "from",
+        "type": "string",
+        "description": "Payment currency and amount to spend",
+        "required": true
+      },
+      {
+        "name": "to",
+        "type": "string",
+        "description": "Destination chain, currency, and token amount",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "solana_buy",
+    "description": "Buy SOL with USDC. Use this when the user needs SOL for gas or wants to convert USDC to SOL.",
+    "options": [
+      {
+        "name": "simulation",
+        "type": "boolean",
+        "description": "If true, only simulate the transaction without executing it",
+        "required": true
+      },
+      {
+        "name": "amount",
+        "type": "number",
+        "description": "Amount of USDC to spend to buy SOL",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "token_balance_check",
+    "description": "Check if a wallet has enough of a specific token. Returns success: true if the wallet has sufficient balance, false otherwise.",
+    "options": [
+      {
+        "name": "wallet",
+        "type": "string",
+        "description": "Wallet address to check the balance for",
+        "required": true
+      },
+      {
+        "name": "token",
+        "type": "string",
+        "description": "Token address to check the balance of",
+        "required": true
+      },
+      {
+        "name": "amount",
+        "type": "number",
+        "description": "Required amount of tokens to check against",
+        "required": true
+      },
+      {
+        "name": "chain",
+        "type": "string",
+        "description": "Blockchain where the token and wallet exist",
+        "required": true,
+        "choices": [
+          "solana",
+          "ethereum",
+          "base",
+          "polygon",
+          "arbitrum",
+          "optimism"
+        ]
+      }
+    ]
+  },
+  {
+    "name": "token_balance_list",
+    "description": "List all token balances held in a wallet, including amount owned, current value in USD, and token details. Shows the complete token portfolio.",
+    "options": [
+      {
+        "name": "wallet",
+        "type": "string",
+        "description": "Wallet address to check token balances for",
+        "required": true
+      },
+      {
+        "name": "chain",
+        "type": "string",
+        "description": "Blockchain to check balances on (e.g. 'solana', 'ethereum', 'base')",
+        "required": true,
+        "choices": [
+          "solana",
+          "ethereum",
+          "base",
+          "polygon",
+          "arbitrum",
+          "optimism"
+        ]
+      }
+    ]
+  },
+  {
+    "name": "token_balance_retrieve",
+    "description": "Get the balance of a specific token in a wallet, including the amount owned, current USD value, and token price. Returns zero balance if token is not held.",
+    "options": [
+      {
+        "name": "wallet",
+        "type": "string",
+        "description": "Wallet address to check the balance for",
+        "required": true
+      },
+      {
+        "name": "token",
+        "type": "string",
+        "description": "Token address to check the balance of",
+        "required": true
+      },
+      {
+        "name": "chain",
+        "type": "string",
+        "description": "Blockchain where the token and wallet exist",
+        "required": true,
+        "choices": [
+          "solana",
+          "ethereum",
+          "base",
+          "polygon",
+          "arbitrum",
+          "optimism"
+        ]
+      }
+    ]
+  },
+  {
+    "name": "token_bridge",
+    "description": "Bridge tokens from Solana to another chain (or vice versa) via swaps.xyz cross-chain routing.",
+    "options": [
+      {
+        "name": "simulation",
+        "type": "boolean",
+        "description": "If true, only simulate the transaction without executing it",
+        "required": true
+      },
+      {
+        "name": "token",
+        "type": "string",
+        "description": "The address of the source token to bridge",
+        "required": true
+      },
+      {
+        "name": "amount",
+        "type": "number",
+        "description": "The amount of the source token to bridge",
+        "required": true
+      },
+      {
+        "name": "to",
+        "type": "string",
+        "description": "Destination wallet, chain, and token",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "token_buy",
+    "description": "Swap the specified amount of USDC for a token.",
+    "options": [
+      {
+        "name": "simulation",
+        "type": "boolean",
+        "description": "If true, only simulate the transaction without executing it",
+        "required": true
+      },
+      {
+        "name": "token",
+        "type": "string",
+        "description": "The address of the token to buy",
+        "required": true
+      },
+      {
+        "name": "amount",
+        "type": "number",
+        "description": "Amount of USDC to spend to buy the token",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "token_digest_retrieve",
+    "description": "Retrieve a token digest by token and chain.",
+    "options": [
+      {
+        "name": "token",
+        "type": "string",
+        "description": "Token address",
+        "required": true
+      },
+      {
+        "name": "chain",
+        "type": "string",
+        "description": "Blockchain network where the token exists",
+        "required": true,
+        "choices": [
+          "solana",
+          "ethereum",
+          "base",
+          "polygon",
+          "arbitrum",
+          "optimism"
+        ]
+      }
+    ]
+  },
+  {
+    "name": "token_holder_list",
+    "description": "List holders of a token with their balances and USD values. Shows holder distribution, concentration risk, and whale detection.",
+    "options": [
+      {
+        "name": "token",
+        "type": "string",
+        "description": "Token address to list holders for",
+        "required": true
+      },
+      {
+        "name": "chain",
+        "type": "string",
+        "description": "Blockchain where the token exists",
+        "required": true,
+        "choices": [
+          "solana",
+          "ethereum",
+          "base",
+          "polygon",
+          "arbitrum",
+          "optimism"
+        ]
+      },
+      {
+        "name": "limit",
+        "type": "number",
+        "description": "Maximum number of holders to return (default 25, max 200)",
+        "required": true
+      },
+      {
+        "name": "cursor",
+        "type": "string",
+        "description": "Pagination cursor from a previous response",
+        "required": true
+      },
+      {
+        "name": "sort",
+        "type": "string",
+        "description": "Sort holders by balance (largest first) or date (newest first)",
+        "required": true
+      },
+      {
+        "name": "order",
+        "type": "string",
+        "description": "Sort direction: ascending or descending",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "token_limit_buy",
+    "description": "Create a limit buy order to swap USDC for a token at a specific price.",
+    "options": [
+      {
+        "name": "simulation",
+        "type": "boolean",
+        "description": "If true, only simulate the transaction without executing it",
+        "required": true
+      },
+      {
+        "name": "token",
+        "type": "string",
+        "description": "The address of the token to buy",
+        "required": true
+      },
+      {
+        "name": "amount",
+        "type": "number",
+        "description": "Amount of USDC to spend to buy the token",
+        "required": true
+      },
+      {
+        "name": "price",
+        "type": "number",
+        "description": "Price in dollars (USDC) to buy the token",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "token_limit_buy_recommend",
+    "description": "Parse natural language queries into structured limit buy parameters. Understands queries like 'buy BONK at $0.00001', 'limit buy 100 USDC worth of SOL when price reaches $150', or 'buy BONK at $0.00001 with 50 USDC'. Returns the recommended limit buy parameters ready to use with token_limit_buy.",
+    "options": [
+      {
+        "name": "query",
+        "type": "string",
+        "description": "Natural language description of the desired limit buy order. Examples: 'buy BONK at $0.00001', 'limit buy 100 USDC worth of SOL when price reaches $150', 'buy BONK at $0.00001 with 50 USDC'. The agent will parse token, amount, and price from this query.",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "token_limit_order_list",
+    "description": "Get limit orders for the authenticated user.",
+    "options": []
+  },
+  {
+    "name": "token_limit_recommend",
+    "description": "Parse natural language queries into structured limit order parameters (buy or sell). Understands queries like 'buy BONK at $0.00001', 'sell BONK at $0.00002', 'limit buy 100 USDC worth of SOL when price reaches $150', or 'sell all my BONK at $0.00002'. Automatically determines if the request is a buy or sell order and returns the appropriate parameters ready to use with token_limit_buy or token_limit_sell.",
+    "options": [
+      {
+        "name": "query",
+        "type": "string",
+        "description": "Natural language description of the desired limit order (buy or sell). Examples: 'buy BONK at $0.00001', 'sell BONK at $0.00002', 'limit buy 100 USDC worth of SOL when price reaches $150', 'sell all my BONK at $0.00002'. The agent will parse the order type (buy/sell), token, amount, and price from this query.",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "token_limit_sell",
+    "description": "Create a limit sell order to swap a token for USDC at a specific price.",
+    "options": [
+      {
+        "name": "simulation",
+        "type": "boolean",
+        "description": "If true, only simulate the transaction without executing it",
+        "required": true
+      },
+      {
+        "name": "token",
+        "type": "string",
+        "description": "The address of the token to sell",
+        "required": true
+      },
+      {
+        "name": "amount",
+        "type": "number",
+        "description": "Amount of the token to sell",
+        "required": true
+      },
+      {
+        "name": "price",
+        "type": "number",
+        "description": "Price in dollars (USDC) to sell the token",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "token_limit_sell_recommend",
+    "description": "Parse natural language queries into structured limit sell parameters. Understands queries like 'sell BONK at $0.00002', 'limit sell 100 SOL when price reaches $200', or 'sell all my BONK at $0.00002'. Returns the recommended limit sell parameters ready to use with token_limit_sell.",
+    "options": [
+      {
+        "name": "query",
+        "type": "string",
+        "description": "Natural language description of the desired limit sell order. Examples: 'sell BONK at $0.00002', 'limit sell 100 SOL when price reaches $200', 'sell all my BONK at $0.00002'. The agent will parse token, amount, and price from this query.",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "token_liquidity_lock_list",
+    "description": "List individual liquidity locks for a token. Shows lock details including protocol, unlock schedule, and amounts for detailed lock analysis.",
+    "options": [
+      {
+        "name": "token",
+        "type": "string",
+        "description": "Token address to list liquidity locks for",
+        "required": true
+      },
+      {
+        "name": "chain",
+        "type": "string",
+        "description": "Blockchain where the token exists",
+        "required": true,
+        "choices": [
+          "solana",
+          "ethereum",
+          "base",
+          "polygon",
+          "arbitrum",
+          "optimism"
+        ]
+      },
+      {
+        "name": "cursor",
+        "type": "string",
+        "description": "Pagination cursor from a previous response",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "token_liquidity_retrieve",
+    "description": "Get liquidity metadata for a token including total and locked liquidity amounts. Critical for assessing rug pull risk and token safety.",
+    "options": [
+      {
+        "name": "token",
+        "type": "string",
+        "description": "Token address to check liquidity for",
+        "required": true
+      },
+      {
+        "name": "chain",
+        "type": "string",
+        "description": "Blockchain where the token exists",
+        "required": true,
+        "choices": [
+          "solana",
+          "ethereum",
+          "base",
+          "polygon",
+          "arbitrum",
+          "optimism"
+        ]
+      }
+    ]
+  },
+  {
+    "name": "token_pair_list",
+    "description": "List trading pairs for a token with liquidity, volume, and exchange information. Find the best pairs to trade a token.",
+    "options": [
+      {
+        "name": "token",
+        "type": "string",
+        "description": "Token address to list pairs for",
+        "required": true
+      },
+      {
+        "name": "chain",
+        "type": "string",
+        "description": "Blockchain where the token exists",
+        "required": true,
+        "choices": [
+          "solana",
+          "ethereum",
+          "base",
+          "polygon",
+          "arbitrum",
+          "optimism"
+        ]
+      },
+      {
+        "name": "limit",
+        "type": "number",
+        "description": "Maximum number of pairs to return (default 25)",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "token_recurring_buy",
+    "description": "Create a recurring buy order (DCA) to swap USDC for a token at regular intervals.",
+    "options": [
+      {
+        "name": "simulation",
+        "type": "boolean",
+        "description": "If true, only simulate the transaction without executing it",
+        "required": true
+      },
+      {
+        "name": "token",
+        "type": "string",
+        "description": "The address of the token to buy",
+        "required": true
+      },
+      {
+        "name": "amount",
+        "type": "number",
+        "description": "Amount of USDC used to buy the token per order",
+        "required": true
+      },
+      {
+        "name": "interval",
+        "type": "string",
+        "description": "Time interval between orders",
+        "required": true,
+        "choices": [
+          "hour",
+          "day",
+          "week",
+          "month"
+        ]
+      },
+      {
+        "name": "numberOfOrders",
+        "type": "number",
+        "description": "Number of buy orders",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "token_recurring_order_list",
+    "description": "Get recurring orders.",
+    "options": []
+  },
+  {
+    "name": "token_recurring_recommend",
+    "description": "Parse natural language queries into structured recurring order (DCA) parameters (buy or sell). Understands queries like 'buy BONK daily with 50 USDC for 10 days', 'sell BONK daily, 100 tokens per order for 10 days', 'DCA 100 USDC into SOL weekly for a month', or 'recurring sell SOL every day, 0.5 SOL, 20 orders'. Automatically determines if the request is a buy or sell order and returns the appropriate parameters ready to use with token_recurring_buy or token_recurring_sell.",
+    "options": [
+      {
+        "name": "query",
+        "type": "string",
+        "description": "Natural language description of the desired recurring order (buy or sell). Examples: 'buy BONK daily with 50 USDC for 10 days', 'sell BONK daily, 100 tokens per order for 10 days', 'DCA 100 USDC into SOL weekly for a month', 'recurring sell SOL every day, 0.5 SOL, 20 orders'. The agent will parse the order type (buy/sell), token, amount, interval, and numberOfOrders from this query.",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "token_recurring_sell",
+    "description": "Create a recurring sell order (DCA) to swap a token for USDC at regular intervals.",
+    "options": [
+      {
+        "name": "simulation",
+        "type": "boolean",
+        "description": "If true, only simulate the transaction without executing it",
+        "required": true
+      },
+      {
+        "name": "token",
+        "type": "string",
+        "description": "The address of the token to sell",
+        "required": true
+      },
+      {
+        "name": "amount",
+        "type": "number",
+        "description": "Amount of the token to sell per order",
+        "required": true
+      },
+      {
+        "name": "interval",
+        "type": "string",
+        "description": "Time interval between orders",
+        "required": true,
+        "choices": [
+          "hour",
+          "day",
+          "week",
+          "month"
+        ]
+      },
+      {
+        "name": "numberOfOrders",
+        "type": "number",
+        "description": "Number of recurring orders to create",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "token_retrieve",
+    "description": "Get detailed token information including market data, price changes, volume, trades, and holder statistics by token address",
+    "options": [
+      {
+        "name": "token",
+        "type": "string",
+        "description": "Address of the token to retrieve",
+        "required": true
+      },
+      {
+        "name": "chain",
+        "type": "string",
+        "description": "Blockchain network where the token exists",
+        "required": true,
+        "choices": [
+          "solana",
+          "ethereum",
+          "base",
+          "polygon",
+          "arbitrum",
+          "optimism"
+        ]
+      }
+    ]
+  },
+  {
+    "name": "token_search",
+    "description": "Search for tokens by name, symbol, or address. Returns matching tokens with their market data including price, volume, and liquidity.",
+    "options": [
+      {
+        "name": "query",
+        "type": "string",
+        "description": "Search term - can be token name (e.g. 'Bitcoin'), symbol (e.g. 'BTC'), or partial match",
+        "required": true
+      },
+      {
+        "name": "chain",
+        "type": "string",
+        "description": "Blockchain to search on (e.g. 'solana', 'ethereum', 'base')",
+        "required": true,
+        "choices": [
+          "solana",
+          "ethereum",
+          "base",
+          "polygon",
+          "arbitrum",
+          "optimism"
+        ]
+      },
+      {
+        "name": "limit",
+        "type": "number",
+        "description": "Maximum number of results to return (optional, defaults to 5)",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "token_sell",
+    "description": "Swap the specified amount of tokens for USDC.",
+    "options": [
+      {
+        "name": "simulation",
+        "type": "boolean",
+        "description": "If true, only simulate the transaction without executing it",
+        "required": true
+      },
+      {
+        "name": "token",
+        "type": "string",
+        "description": "The address of the token to sell",
+        "required": true
+      },
+      {
+        "name": "amount",
+        "type": "number",
+        "description": "Amount of token to sell",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "token_swap",
+    "description": "Swap the specified amount of input token for output token.",
+    "options": [
+      {
+        "name": "simulation",
+        "type": "boolean",
+        "description": "If true, only simulate the transaction without executing it",
+        "required": true
+      },
+      {
+        "name": "input",
+        "type": "string",
+        "description": "The address of the input token to swap",
+        "required": true
+      },
+      {
+        "name": "output",
+        "type": "string",
+        "description": "The address of the output token to receive",
+        "required": true
+      },
+      {
+        "name": "amount",
+        "type": "number",
+        "description": "The amount of the input token to swap",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "token_swap_recommend",
+    "description": "Parse natural language queries into structured swap parameters for swapping tokens on Solana. Understands queries like 'swap 100 USDC for SOL', 'swap all my USDC for BONK', or '50 SOL to USDC'. Returns the recommended swap parameters ready to use with token_swap.",
+    "options": [
+      {
+        "name": "query",
+        "type": "string",
+        "description": "Natural language description of the desired swap on Solana. Examples: 'swap 100 USDC for SOL', 'swap all my USDC for BONK', '50 SOL to USDC', 'convert my SOL to USDC'. The agent will parse tokens and amounts from this query.",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "token_top_trader_list",
+    "description": "Get top traders for a token ranked by volume. Shows buy/sell activity, realized profit, and current balance for smart money analysis.",
+    "options": [
+      {
+        "name": "token",
+        "type": "string",
+        "description": "Token address to get top traders for",
+        "required": true
+      },
+      {
+        "name": "chain",
+        "type": "string",
+        "description": "Blockchain where the token exists",
+        "required": true,
+        "choices": [
+          "solana",
+          "ethereum",
+          "base",
+          "polygon",
+          "arbitrum",
+          "optimism"
+        ]
+      },
+      {
+        "name": "period",
+        "type": "string",
+        "description": "Trading period to analyze",
+        "required": true,
+        "choices": [
+          "day",
+          "week",
+          "month",
+          "year"
+        ]
+      },
+      {
+        "name": "limit",
+        "type": "number",
+        "description": "Maximum number of traders to return (default 25)",
+        "required": true
+      },
+      {
+        "name": "page",
+        "type": "number",
+        "description": "Page number for pagination (default 1)",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "token_transfer",
+    "description": "Transfer tokens from your wallet to another address. This tool will build the transaction, sign it using the authenticated user's wallet, and execute it. The recipient's token account will be automatically created if it doesn't exist.",
+    "options": [
+      {
+        "name": "simulation",
+        "type": "boolean",
+        "description": "If true, only simulate the transaction without executing it",
+        "required": true
+      },
+      {
+        "name": "token",
+        "type": "string",
+        "description": "The address of the token to transfer",
+        "required": true
+      },
+      {
+        "name": "to",
+        "type": "string",
+        "description": "The recipient's wallet address",
+        "required": true
+      },
+      {
+        "name": "amount",
+        "type": "number",
+        "description": "The amount of tokens to transfer (in human-readable units, e.g., 1.5)",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "token_trending_list",
+    "description": "Get currently trending tokens on a blockchain. Perfect for discovering what's hot right now.",
+    "options": [
+      {
+        "name": "chain",
+        "type": "string",
+        "description": "Blockchain to get trending tokens from (e.g. 'solana', 'ethereum', 'base')",
+        "required": true,
+        "choices": [
+          "solana",
+          "ethereum",
+          "base",
+          "polygon",
+          "arbitrum",
+          "optimism"
+        ]
+      },
+      {
+        "name": "limit",
+        "type": "number",
+        "description": "Number of results per page",
+        "required": true
+      },
+      {
+        "name": "page",
+        "type": "number",
+        "description": "The page number of results",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "user_retrieve",
+    "description": "Retrieve the currently authenticated user from the session context.",
+    "options": []
+  },
+  {
+    "name": "user_update",
+    "description": "Update user fields in the database. This is a PUT-style update requiring all updatable fields (developer, firstName, lastName, username) to be sent. You must first call user_retrieve to get the current user state, then update with all four fields.",
+    "options": [
+      {
+        "name": "developer",
+        "type": "boolean",
+        "description": "Whether the user is a developer",
+        "required": true
+      },
+      {
+        "name": "firstName",
+        "type": "string",
+        "description": "The user's first name, or null to clear it",
+        "required": true
+      },
+      {
+        "name": "lastName",
+        "type": "string",
+        "description": "The user's last name, or null to clear it",
+        "required": true
+      },
+      {
+        "name": "username",
+        "type": "string",
+        "description": "The user's username (3-20 lowercase letters, numbers, and underscores, must start with a letter), or null to clear it",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "user_wallet_list",
+    "description": "List all wallets for the authenticated user.",
+    "options": []
+  },
+  {
+    "name": "user_wallet_retrieve",
+    "description": "Retrieve a wallet by address for the authenticated user. Use user_wallet_list to see your wallets.",
+    "options": [
+      {
+        "name": "address",
+        "type": "string",
+        "description": "Wallet address to retrieve",
+        "required": true
+      }
+    ]
+  },
+  {
+    "name": "wallet_digest_retrieve",
+    "description": "Retrieve a wallet digest by wallet address and chain.",
+    "options": [
+      {
+        "name": "wallet",
+        "type": "string",
+        "description": "Wallet address",
+        "required": true
+      },
+      {
+        "name": "chain",
+        "type": "string",
+        "description": "Blockchain network",
+        "required": true,
+        "choices": [
+          "solana",
+          "ethereum",
+          "base",
+          "polygon",
+          "arbitrum",
+          "optimism"
+        ]
+      }
+    ]
+  },
+  {
+    "name": "x402_request",
+    "description": "Make an HTTP request to an x402-protected endpoint. Automatically handles payment transactions when a 402 Payment Required response is received.",
+    "options": [
+      {
+        "name": "method",
+        "type": "string",
+        "description": "HTTP method",
+        "required": true,
+        "choices": [
+          "GET",
+          "POST",
+          "PUT",
+          "PATCH",
+          "DELETE"
+        ]
+      },
+      {
+        "name": "url",
+        "type": "string",
+        "description": "Full URL of the x402-protected endpoint (e.g., 'https://moon-iq.com/api/x402/tools/market_digest_retrieve')",
+        "required": true
+      },
+      {
+        "name": "body",
+        "type": "string",
+        "description": "Request body (for POST, PUT, PATCH)",
+        "required": true
+      },
+      {
+        "name": "params",
+        "type": "string",
+        "description": "Query parameters",
+        "required": true
+      }
+    ]
+  }
+];
+
+// src/client.ts
+async function callToolWithToken(baseUrl, token, toolName, params) {
+  const res = await fetch(`${baseUrl}/api/tools/${toolName}`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`
+    },
+    body: JSON.stringify(params)
+  });
+  const data = await res.json();
+  return { data, status: res.status };
+}
+async function callToolWithAuth(baseUrl, toolName, params) {
+  let token = await getValidToken();
+  if (!token) {
+    throw new Error(
+      "Not logged in. Run `mooniq login` first and ensure ~/.config/moon-iq/config.json has baseUrl and clientId."
+    );
+  }
+  let result = await callToolWithToken(baseUrl, token, toolName, params);
+  if (result.status === 401) {
+    const creds = getCredentials();
+    const config = getConfig();
+    if (creds?.refreshToken && config && config.baseUrl === creds.baseUrl) {
+      try {
+        const newCreds = await refreshCredentials(creds, config);
+        result = await callToolWithToken(
+          baseUrl,
+          newCreds.accessToken,
+          toolName,
+          params
+        );
+      } catch {
+      }
+    }
+  }
+  if (result.status < 200 || result.status >= 300) {
+    const err = result.data;
+    throw new Error(err?.error ?? "Tool call failed");
+  }
+  return result.data;
+}
+
+// src/format.ts
+var useColor = !process.env.NO_COLOR && process.stdout.isTTY === true;
+function ansi(code) {
+  return (text) => useColor ? `${code}${text}\x1B[0m` : text;
+}
+var color = {
+  bold: ansi("\x1B[1m"),
+  dim: ansi("\x1B[2m"),
+  green: ansi("\x1B[32m"),
+  yellow: ansi("\x1B[33m"),
+  cyan: ansi("\x1B[36m"),
+  red: ansi("\x1B[31m")
+};
+var MAX_COL_WIDTH = 40;
+function truncate(str, max) {
+  return str.length > max ? str.slice(0, max - 1) + "\u2026" : str;
+}
+function renderArrayTable(rows) {
+  if (rows.length === 0) return "";
+  const keys = Object.keys(rows[0]);
+  const widths = keys.map((k) => k.length);
+  const stringRows = rows.map(
+    (row) => keys.map((k, i) => {
+      const val = truncate(String(row[k] ?? ""), MAX_COL_WIDTH);
+      widths[i] = Math.max(widths[i], val.length);
+      return val;
+    })
+  );
+  for (let i = 0; i < widths.length; i++) {
+    widths[i] = Math.min(widths[i], MAX_COL_WIDTH);
+  }
+  const header = keys.map((k, i) => color.bold(k.padEnd(widths[i]))).join("  ");
+  const separator = color.dim(widths.map((w) => "\u2500".repeat(w)).join("\u2500\u2500"));
+  const body = stringRows.map((row) => row.map((val, i) => val.padEnd(widths[i])).join("  ")).join("\n");
+  return `${header}
+${separator}
+${body}`;
+}
+function renderObjectTable(obj) {
+  const entries = Object.entries(obj);
+  const maxKey = Math.min(
+    MAX_COL_WIDTH,
+    Math.max(...entries.map(([k]) => k.length))
+  );
+  return entries.map(([k, v]) => `${color.bold(k.padEnd(maxKey))}  ${String(v ?? "")}`).join("\n");
+}
+function renderTable(data) {
+  if (Array.isArray(data)) {
+    if (data.length === 0) return color.dim("(empty)");
+    if (typeof data[0] === "object" && data[0] !== null) {
+      return renderArrayTable(data);
+    }
+    return data.map(String).join("\n");
+  }
+  if (typeof data === "object" && data !== null) {
+    return renderObjectTable(data);
+  }
+  return String(data);
+}
+function formatOutput(result, format) {
+  if (format === "compact") {
+    return JSON.stringify(result);
+  }
+  if (format === "table") {
+    const value = typeof result === "object" && result !== null && "data" in result ? result.data : result;
+    return renderTable(value);
+  }
+  return JSON.stringify(result, null, 2);
+}
+
+// src/version-check.ts
+import { readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+var CACHE_DIR = join2(homedir2(), ".config", "moon-iq");
+var CACHE_FILE = join2(CACHE_DIR, "update-check.json");
+var ONE_DAY_MS = 24 * 60 * 60 * 1e3;
+var FETCH_TIMEOUT_MS = 3e3;
+function readCache() {
+  try {
+    const raw = readFileSync2(CACHE_FILE, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function writeCache(data) {
+  try {
+    mkdirSync2(CACHE_DIR, { recursive: true });
+    writeFileSync2(CACHE_FILE, JSON.stringify(data));
+  } catch {
+  }
+}
+function isNewer(latest, current) {
+  const a = latest.split(".").map(Number);
+  const b = current.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    if ((a[i] ?? 0) > (b[i] ?? 0)) return true;
+    if ((a[i] ?? 0) < (b[i] ?? 0)) return false;
+  }
+  return false;
+}
+function formatNotice(current, latest) {
+  return [
+    "",
+    color.yellow(`Update available: ${current} \u2192 ${latest}`),
+    color.dim("Run `npm i -g @moonpay/cli` to update."),
+    ""
+  ].join("\n");
+}
+function startVersionCheck(currentVersion) {
+  let notice = null;
+  const cache = readCache();
+  if (cache && Date.now() - cache.checkedAt < ONE_DAY_MS) {
+    if (isNewer(cache.latest, currentVersion)) {
+      notice = formatNotice(currentVersion, cache.latest);
+    }
+    return () => notice;
+  }
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), FETCH_TIMEOUT_MS);
+  fetch("https://registry.npmjs.org/@moonpay%2fcli/latest", {
+    signal: controller.signal
+  }).then((res) => res.json()).then((data) => {
+    const latest = data.version;
+    if (latest) {
+      writeCache({ latest, checkedAt: Date.now() });
+      if (isNewer(latest, currentVersion)) {
+        notice = formatNotice(currentVersion, latest);
+      }
+    }
+  }).catch(() => {
+  }).finally(() => clearTimeout(timeout));
+  return () => notice;
+}
+
+// src/index.ts
+var require2 = createRequire(import.meta.url);
+var { version } = require2("../package.json");
+var getUpdateNotice = startVersionCheck(version);
+var DEFAULT_BASE_URL = "https://moon-iq.com";
+var program = new Command();
+program.name("mooniq").description("Moon IQ CLI").version(version).option("-f, --format <type>", "Output format: json, compact, or table", "json");
+function getFormat() {
+  const fmt = program.opts().format;
+  if (fmt === "json" || fmt === "compact" || fmt === "table") return fmt;
+  return "json";
+}
+function printResult(result) {
+  console.log(formatOutput(result, getFormat()));
+}
+function printUpdateNotice() {
+  const notice = getUpdateNotice();
+  if (notice) process.stderr.write(notice);
+}
+function resolveBaseUrl() {
+  const config = getConfig();
+  const creds = getCredentials();
+  return config?.baseUrl ?? creds?.baseUrl ?? DEFAULT_BASE_URL;
+}
+program.command("login").description("Log in to Moon IQ via OAuth").action(async () => {
+  const config = getConfigOrDefault();
+  try {
+    await login(config);
+    console.log("Logged in successfully.");
+  } catch (error) {
+    console.error("Login failed:", error.message);
+    process.exit(1);
+  }
+});
+program.command("logout").description("Log out and clear stored credentials").action(() => {
+  clearCredentials();
+  console.log("Logged out.");
+});
+program.command("whoami").description("Show current user info").action(async () => {
+  let token = await getValidToken();
+  if (!token) {
+    console.error("Not logged in. Run `mooniq login` first.");
+    process.exit(1);
+  }
+  const creds = getCredentials();
+  const config = getConfig();
+  const baseUrl = resolveBaseUrl();
+  let res = await fetch(`${baseUrl}/api/oauth/userinfo`, {
+    headers: { Authorization: `Bearer ${token}` }
+  });
+  if (res.status === 401 && creds?.refreshToken && config && config.baseUrl === creds.baseUrl) {
+    try {
+      const newCreds = await refreshCredentials(creds, config);
+      res = await fetch(`${baseUrl}/api/oauth/userinfo`, {
+        headers: { Authorization: `Bearer ${newCreds.accessToken}` }
+      });
+    } catch {
+    }
+  }
+  if (!res.ok) {
+    console.error("Failed to fetch user info:", res.status);
+    process.exit(1);
+  }
+  const userinfo = await res.json();
+  const { id, wallets, emails, phoneNumbers, developer, ironId, ...display } = userinfo;
+  printResult(display);
+  printUpdateNotice();
+});
+program.command("run <tool_name>").description("Run a tool by name. Use --input for JSON params.").option(
+  "-i, --input <json>",
+  "Input parameters as JSON (omit for empty params)"
+).addHelpText(
+  "after",
+  `
+Examples:
+  mooniq run user_retrieve                    # no params
+  mooniq run token_search --input '{"query":"SOL","chain":"solana"}'   # with params
+`
+).action(async (toolName, options) => {
+  const toolNames = TOOL_NAMES;
+  if (!toolNames.includes(toolName)) {
+    console.error(`Unknown tool: ${toolName}`);
+    console.error(`Available tools: ${toolNames.slice(0, 10).join(", ")}...`);
+    process.exit(1);
+  }
+  let params = {};
+  if (options.input) {
+    try {
+      params = JSON.parse(options.input);
+    } catch {
+      console.error("Invalid JSON in --input");
+      process.exit(1);
+    }
+  }
+  try {
+    const baseUrl = resolveBaseUrl();
+    const result = await callToolWithAuth(baseUrl, toolName, params);
+    printResult(result);
+    printUpdateNotice();
+  } catch (error) {
+    console.error("Tool call failed:", error.message);
+    process.exit(1);
+  }
+});
+program.command("tools").description("List available tools").option("-s, --search <query>", "Filter tools by name or description").option("-c, --category <category>", "Filter tools by category").action((options) => {
+  const groups = /* @__PURE__ */ new Map();
+  for (const tool of TOOL_DEFINITIONS) {
+    const category = tool.name.split("_")[0];
+    if (!groups.has(category)) groups.set(category, []);
+    groups.get(category).push(tool);
+  }
+  const categoryFilter = options.category?.toLowerCase();
+  const searchQuery = options.search?.toLowerCase();
+  let categories = [...groups.keys()].sort();
+  if (categoryFilter) {
+    if (!groups.has(categoryFilter)) {
+      console.error(
+        `Unknown category: ${categoryFilter}
+Available categories: ${[...groups.keys()].sort().join(", ")}`
+      );
+      process.exit(1);
+    }
+    categories = [categoryFilter];
+  }
+  let totalCount = 0;
+  const lines = [];
+  for (const cat of categories) {
+    const tools = groups.get(cat);
+    const filtered = searchQuery ? tools.filter(
+      (t) => t.name.toLowerCase().includes(searchQuery) || t.description.toLowerCase().includes(searchQuery)
+    ) : tools;
+    if (filtered.length === 0) continue;
+    const maxName = Math.max(...filtered.map((t) => t.name.length));
+    if (lines.length > 0) lines.push("");
+    lines.push(color.bold(color.cyan(cat.toUpperCase())));
+    for (const tool of filtered) {
+      lines.push(
+        `  ${color.green(tool.name.padEnd(maxName))}  ${color.dim(tool.description)}`
+      );
+      totalCount++;
+    }
+  }
+  if (totalCount === 0) {
+    const msg = searchQuery ? `No tools matching "${options.search}".` : `No tools found.`;
+    console.error(msg);
+    console.error(
+      `Available categories: ${[...groups.keys()].sort().join(", ")}`
+    );
+    process.exit(1);
+  }
+  lines.push("");
+  lines.push(color.dim(`${totalCount} tool${totalCount === 1 ? "" : "s"}`));
+  console.log(lines.join("\n"));
+  printUpdateNotice();
+});
+function buildToolCommands(program2) {
+  const root = { children: /* @__PURE__ */ new Map() };
+  for (const tool of TOOL_DEFINITIONS) {
+    const parts = tool.name.split("_");
+    let current = root;
+    for (let i = 0; i < parts.length; i++) {
+      const part = parts[i];
+      if (!current.children.has(part)) {
+        current.children.set(part, { children: /* @__PURE__ */ new Map() });
+      }
+      current = current.children.get(part);
+      if (i === parts.length - 1) {
+        current.tool = tool;
+      }
+    }
+  }
+  function createCommands(node, parent, path2) {
+    for (const [name, child] of node.children) {
+      const currentPath = [...path2, name];
+      if (child.tool) {
+        const cmd = parent.command(name).description(child.tool.description || `Run ${child.tool.name}`);
+        for (const opt of child.tool.options) {
+          const optionFlag = createOptionFlag(opt);
+          const option = new Option(optionFlag, opt.description);
+          if (opt.choices) {
+            option.choices(opt.choices);
+          }
+          if (opt.required) {
+            cmd.addOption(option);
+          } else {
+            cmd.addOption(option);
+          }
+        }
+        const toolName = child.tool.name;
+        cmd.action(async (options) => {
+          const params = buildParams(child.tool.options, options);
+          const baseUrl = resolveBaseUrl();
+          try {
+            const result = await callToolWithAuth(baseUrl, toolName, params);
+            printResult(result);
+            printUpdateNotice();
+          } catch (error) {
+            console.error("Tool call failed:", error.message);
+            process.exit(1);
+          }
+        });
+        if (child.children.size > 0) {
+          createCommands(child, cmd, currentPath);
+        }
+      } else if (child.children.size > 0) {
+        const cmd = parent.command(name).description(`${name} commands`);
+        createCommands(child, cmd, currentPath);
+      }
+    }
+  }
+  createCommands(root, program2, []);
+}
+function createOptionFlag(opt) {
+  const kebabName = opt.name.replace(/([A-Z])/g, "-$1").toLowerCase();
+  if (opt.type === "boolean") {
+    return `--${kebabName}`;
+  }
+  const valuePlaceholder = `<${opt.name}>`;
+  return `--${kebabName} ${valuePlaceholder}`;
+}
+function buildParams(toolOptions, cmdOptions) {
+  const params = {};
+  for (const opt of toolOptions) {
+    const kebabName = opt.name.replace(/([A-Z])/g, "-$1").toLowerCase();
+    const camelName = kebabName.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+    const value = cmdOptions[camelName] ?? cmdOptions[opt.name];
+    if (value !== void 0) {
+      if (opt.type === "number" && typeof value === "string") {
+        params[opt.name] = parseFloat(value);
+      } else if (opt.type === "boolean") {
+        params[opt.name] = value === true || value === "true";
+      } else if (typeof value === "string") {
+        try {
+          const parsed = JSON.parse(value);
+          if (typeof parsed === "object" && parsed !== null) {
+            params[opt.name] = parsed;
+          } else {
+            params[opt.name] = value;
+          }
+        } catch {
+          params[opt.name] = value;
+        }
+      } else {
+        params[opt.name] = value;
+      }
+    } else {
+      params[opt.name] = opt.type === "boolean" ? false : null;
+    }
+  }
+  return params;
+}
+buildToolCommands(program);
+program.parse();
+//# sourceMappingURL=index.js.map