@hasna/wallets 0.1.2 → 0.1.4

package/dist/index.js

@@ -0,0 +1,869 @@
+// @bun
+// src/db/database.ts
+import { Database } from "bun:sqlite";
+import { homedir } from "os";
+import { join } from "path";
+import { existsSync, mkdirSync } from "fs";
+var _db = null;
+var MIGRATIONS = [
+  {
+    id: 1,
+    sql: `
+      CREATE TABLE IF NOT EXISTS providers (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL UNIQUE,
+        type TEXT NOT NULL,
+        status TEXT NOT NULL DEFAULT 'active' CHECK(status IN ('active', 'inactive', 'error')),
+        config TEXT DEFAULT '{}',
+        metadata TEXT DEFAULT '{}',
+        created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+        updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS cards (
+        id TEXT PRIMARY KEY,
+        provider_id TEXT NOT NULL REFERENCES providers(id) ON DELETE CASCADE,
+        external_id TEXT NOT NULL,
+        name TEXT NOT NULL,
+        last_four TEXT NOT NULL DEFAULT '',
+        brand TEXT NOT NULL DEFAULT 'visa',
+        status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('active', 'frozen', 'closed', 'pending')),
+        currency TEXT NOT NULL DEFAULT 'USD',
+        balance REAL NOT NULL DEFAULT 0,
+        funded_amount REAL NOT NULL DEFAULT 0,
+        spending_limit REAL,
+        agent_id TEXT,
+        metadata TEXT DEFAULT '{}',
+        expires_at TEXT,
+        created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+        updated_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS transactions (
+        id TEXT PRIMARY KEY,
+        card_id TEXT NOT NULL REFERENCES cards(id) ON DELETE CASCADE,
+        provider_id TEXT NOT NULL REFERENCES providers(id) ON DELETE CASCADE,
+        external_id TEXT,
+        type TEXT NOT NULL CHECK(type IN ('purchase', 'refund', 'load', 'withdrawal', 'fee')),
+        status TEXT NOT NULL DEFAULT 'pending' CHECK(status IN ('pending', 'completed', 'failed', 'reversed')),
+        amount REAL NOT NULL,
+        currency TEXT NOT NULL DEFAULT 'USD',
+        merchant TEXT,
+        description TEXT,
+        metadata TEXT DEFAULT '{}',
+        created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+      );
+
+      CREATE TABLE IF NOT EXISTS agents (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL UNIQUE,
+        description TEXT,
+        created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now')),
+        last_seen_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_cards_provider ON cards(provider_id);
+      CREATE INDEX IF NOT EXISTS idx_cards_agent ON cards(agent_id);
+      CREATE INDEX IF NOT EXISTS idx_cards_status ON cards(status);
+      CREATE INDEX IF NOT EXISTS idx_transactions_card ON transactions(card_id);
+      CREATE INDEX IF NOT EXISTS idx_transactions_provider ON transactions(provider_id);
+      CREATE INDEX IF NOT EXISTS idx_transactions_type ON transactions(type);
+
+      CREATE TABLE IF NOT EXISTS _migrations (
+        id INTEGER PRIMARY KEY,
+        applied_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+      );
+    `
+  }
+];
+function runMigrations(db) {
+  db.run(`CREATE TABLE IF NOT EXISTS _migrations (
+    id INTEGER PRIMARY KEY,
+    applied_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ', 'now'))
+  )`);
+  for (const migration of MIGRATIONS) {
+    const applied = db.query("SELECT id FROM _migrations WHERE id = ?").get(migration.id);
+    if (!applied) {
+      db.run("BEGIN");
+      try {
+        db.run(migration.sql);
+        db.run("INSERT INTO _migrations (id) VALUES (?)", [migration.id]);
+        db.run("COMMIT");
+      } catch (e) {
+        db.run("ROLLBACK");
+        throw e;
+      }
+    }
+  }
+}
+function resolveDbPath() {
+  const envPath = process.env["WALLETS_DB_PATH"];
+  if (envPath)
+    return envPath;
+  const dir = join(homedir(), ".wallets");
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  return join(dir, "wallets.db");
+}
+function getDatabase(dbPath) {
+  if (_db)
+    return _db;
+  const path = dbPath || resolveDbPath();
+  _db = new Database(path);
+  _db.run("PRAGMA journal_mode = WAL");
+  _db.run("PRAGMA foreign_keys = ON");
+  _db.run("PRAGMA busy_timeout = 5000");
+  runMigrations(_db);
+  return _db;
+}
+function closeDatabase() {
+  if (_db) {
+    _db.close();
+    _db = null;
+  }
+}
+function resetDatabase() {
+  closeDatabase();
+  _db = null;
+}
+function now() {
+  return new Date().toISOString();
+}
+function uuid() {
+  return crypto.randomUUID();
+}
+function shortId() {
+  return crypto.randomUUID().slice(0, 8);
+}
+// src/db/providers.ts
+function rowToProvider(row) {
+  return {
+    ...row,
+    status: row.status,
+    config: JSON.parse(row.config || "{}"),
+    metadata: JSON.parse(row.metadata || "{}")
+  };
+}
+function createProvider(input, db) {
+  const d = db || getDatabase();
+  const id = shortId();
+  d.run(`INSERT INTO providers (id, name, type, config, metadata) VALUES (?, ?, ?, ?, ?)`, [
+    id,
+    input.name,
+    input.type,
+    JSON.stringify(input.config || {}),
+    JSON.stringify(input.metadata || {})
+  ]);
+  return getProvider(id, d);
+}
+function getProvider(id, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM providers WHERE id = ?").get(id);
+  return row ? rowToProvider(row) : null;
+}
+function getProviderByName(name, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM providers WHERE name = ?").get(name);
+  return row ? rowToProvider(row) : null;
+}
+function listProviders(db) {
+  const d = db || getDatabase();
+  const rows = d.query("SELECT * FROM providers ORDER BY created_at DESC").all();
+  return rows.map(rowToProvider);
+}
+function updateProvider(id, input, db) {
+  const d = db || getDatabase();
+  const provider = getProvider(id, d);
+  if (!provider)
+    throw new Error(`Provider not found: ${id}`);
+  const sets = [];
+  const params = [];
+  if (input.name !== undefined) {
+    sets.push("name = ?");
+    params.push(input.name);
+  }
+  if (input.config !== undefined) {
+    sets.push("config = ?");
+    params.push(JSON.stringify(input.config));
+  }
+  if (input.metadata !== undefined) {
+    sets.push("metadata = ?");
+    params.push(JSON.stringify(input.metadata));
+  }
+  if (input.status !== undefined) {
+    sets.push("status = ?");
+    params.push(input.status);
+  }
+  if (sets.length > 0) {
+    sets.push("updated_at = ?");
+    params.push(now());
+    params.push(id);
+    d.run(`UPDATE providers SET ${sets.join(", ")} WHERE id = ?`, params);
+  }
+  return getProvider(id, d);
+}
+function deleteProvider(id, db) {
+  const d = db || getDatabase();
+  return d.run("DELETE FROM providers WHERE id = ?", [id]).changes > 0;
+}
+function ensureProvider(name, type, config, db) {
+  const d = db || getDatabase();
+  const existing = getProviderByName(name, d);
+  if (existing) {
+    if (config) {
+      return updateProvider(existing.id, { config }, d);
+    }
+    d.run("UPDATE providers SET updated_at = ? WHERE id = ?", [now(), existing.id]);
+    return getProvider(existing.id, d);
+  }
+  return createProvider({ name, type, config }, d);
+}
+// src/db/cards.ts
+function rowToCard(row) {
+  return {
+    ...row,
+    status: row.status,
+    currency: row.currency,
+    metadata: JSON.parse(row.metadata || "{}")
+  };
+}
+function createCardRecord(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  d.run(`INSERT INTO cards (id, provider_id, external_id, name, last_four, brand, status, currency, balance, funded_amount, spending_limit, agent_id, metadata, expires_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+    id,
+    input.provider_id,
+    input.external_id,
+    input.name,
+    input.last_four || "",
+    input.brand || "visa",
+    input.status || "pending",
+    input.currency || "USD",
+    input.balance ?? 0,
+    input.funded_amount ?? 0,
+    input.spending_limit ?? null,
+    input.agent_id ?? null,
+    JSON.stringify(input.metadata || {}),
+    input.expires_at ?? null
+  ]);
+  return getCard(id, d);
+}
+function getCard(id, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM cards WHERE id = ?").get(id);
+  return row ? rowToCard(row) : null;
+}
+function getCardByExternalId(externalId, providerId, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM cards WHERE external_id = ? AND provider_id = ?").get(externalId, providerId);
+  return row ? rowToCard(row) : null;
+}
+function listCards(filter = {}, db) {
+  const d = db || getDatabase();
+  const conditions = [];
+  const params = [];
+  if (filter.provider_id) {
+    conditions.push("provider_id = ?");
+    params.push(filter.provider_id);
+  }
+  if (filter.status) {
+    conditions.push("status = ?");
+    params.push(filter.status);
+  }
+  if (filter.agent_id) {
+    conditions.push("agent_id = ?");
+    params.push(filter.agent_id);
+  }
+  if (filter.currency) {
+    conditions.push("currency = ?");
+    params.push(filter.currency);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const limit = filter.limit ? `LIMIT ${filter.limit}` : "";
+  const offset = filter.offset ? `OFFSET ${filter.offset}` : "";
+  const rows = d.query(`SELECT * FROM cards ${where} ORDER BY created_at DESC ${limit} ${offset}`).all(...params);
+  return rows.map(rowToCard);
+}
+function updateCard(id, input, db) {
+  const d = db || getDatabase();
+  const card = getCard(id, d);
+  if (!card)
+    throw new Error(`Card not found: ${id}`);
+  const sets = [];
+  const params = [];
+  if (input.name !== undefined) {
+    sets.push("name = ?");
+    params.push(input.name);
+  }
+  if (input.status !== undefined) {
+    sets.push("status = ?");
+    params.push(input.status);
+  }
+  if (input.spending_limit !== undefined) {
+    sets.push("spending_limit = ?");
+    params.push(input.spending_limit);
+  }
+  if (input.metadata !== undefined) {
+    sets.push("metadata = ?");
+    params.push(JSON.stringify(input.metadata));
+  }
+  if (sets.length > 0) {
+    sets.push("updated_at = ?");
+    params.push(now());
+    params.push(id);
+    d.run(`UPDATE cards SET ${sets.join(", ")} WHERE id = ?`, params);
+  }
+  return getCard(id, d);
+}
+function updateCardBalance(id, balance, db) {
+  const d = db || getDatabase();
+  d.run("UPDATE cards SET balance = ?, updated_at = ? WHERE id = ?", [balance, now(), id]);
+  return getCard(id, d);
+}
+function deleteCard(id, db) {
+  const d = db || getDatabase();
+  return d.run("DELETE FROM cards WHERE id = ?", [id]).changes > 0;
+}
+// src/db/transactions.ts
+function rowToTransaction(row) {
+  return {
+    ...row,
+    type: row.type,
+    status: row.status,
+    currency: row.currency,
+    metadata: JSON.parse(row.metadata || "{}")
+  };
+}
+function createTransaction(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  d.run(`INSERT INTO transactions (id, card_id, provider_id, external_id, type, status, amount, currency, merchant, description, metadata)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
+    id,
+    input.card_id,
+    input.provider_id,
+    input.external_id ?? null,
+    input.type,
+    input.status || "completed",
+    input.amount,
+    input.currency || "USD",
+    input.merchant ?? null,
+    input.description ?? null,
+    JSON.stringify(input.metadata || {})
+  ]);
+  return getTransaction(id, d);
+}
+function getTransaction(id, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM transactions WHERE id = ?").get(id);
+  return row ? rowToTransaction(row) : null;
+}
+function listTransactions(filter = {}, db) {
+  const d = db || getDatabase();
+  const conditions = [];
+  const params = [];
+  if (filter.card_id) {
+    conditions.push("card_id = ?");
+    params.push(filter.card_id);
+  }
+  if (filter.provider_id) {
+    conditions.push("provider_id = ?");
+    params.push(filter.provider_id);
+  }
+  if (filter.type) {
+    conditions.push("type = ?");
+    params.push(filter.type);
+  }
+  if (filter.status) {
+    conditions.push("status = ?");
+    params.push(filter.status);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const limit = filter.limit ? `LIMIT ${filter.limit}` : "";
+  const offset = filter.offset ? `OFFSET ${filter.offset}` : "";
+  const rows = d.query(`SELECT * FROM transactions ${where} ORDER BY created_at DESC ${limit} ${offset}`).all(...params);
+  return rows.map(rowToTransaction);
+}
+// src/db/agents.ts
+function rowToAgent(row) {
+  return { ...row };
+}
+function registerAgent(input, db) {
+  const d = db || getDatabase();
+  const normalizedName = input.name.trim().toLowerCase();
+  const existing = getAgentByName(normalizedName, d);
+  if (existing) {
+    d.run("UPDATE agents SET last_seen_at = ? WHERE id = ?", [now(), existing.id]);
+    return getAgent(existing.id, d);
+  }
+  const id = shortId();
+  d.run("INSERT INTO agents (id, name, description) VALUES (?, ?, ?)", [id, normalizedName, input.description ?? null]);
+  return getAgent(id, d);
+}
+function getAgent(id, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM agents WHERE id = ?").get(id);
+  return row ? rowToAgent(row) : null;
+}
+function getAgentByName(name, db) {
+  const d = db || getDatabase();
+  const normalizedName = name.trim().toLowerCase();
+  const row = d.query("SELECT * FROM agents WHERE name = ?").get(normalizedName);
+  return row ? rowToAgent(row) : null;
+}
+function listAgents(db) {
+  const d = db || getDatabase();
+  const rows = d.query("SELECT * FROM agents ORDER BY last_seen_at DESC").all();
+  return rows.map(rowToAgent);
+}
+function deleteAgent(id, db) {
+  const d = db || getDatabase();
+  return d.run("DELETE FROM agents WHERE id = ?", [id]).changes > 0;
+}
+// src/types/index.ts
+class WalletError extends Error {
+  static code = "WALLET_ERROR";
+  static suggestion = "Check the wallet configuration and try again.";
+  constructor(message) {
+    super(message);
+    this.name = "WalletError";
+  }
+}
+
+class ProviderNotFoundError extends Error {
+  static code = "PROVIDER_NOT_FOUND";
+  static suggestion = "Use 'wallets provider list' to see available providers, or 'wallets provider add' to register one.";
+  constructor(id) {
+    super(`Provider not found: ${id}`);
+    this.name = "ProviderNotFoundError";
+  }
+}
+
+class CardNotFoundError extends Error {
+  static code = "CARD_NOT_FOUND";
+  static suggestion = "Use 'wallets card list' to see available cards.";
+  constructor(id) {
+    super(`Card not found: ${id}`);
+    this.name = "CardNotFoundError";
+  }
+}
+
+class ProviderError extends Error {
+  static code = "PROVIDER_ERROR";
+  static suggestion = "Check the provider configuration and API credentials. Run 'wallets doctor' for diagnostics.";
+  constructor(provider, message) {
+    super(`Provider '${provider}' error: ${message}`);
+    this.name = "ProviderError";
+  }
+}
+
+class InsufficientFundsError extends Error {
+  static code = "INSUFFICIENT_FUNDS";
+  static suggestion = "Fund the card with more money before making this transaction.";
+  constructor(cardId, required, available) {
+    super(`Insufficient funds on card ${cardId}: need ${required}, have ${available}`);
+    this.name = "InsufficientFundsError";
+  }
+}
+
+class ConfigError extends Error {
+  static code = "CONFIG_ERROR";
+  static suggestion = "Check ~/.wallets/config.json and ensure all required fields are set.";
+  constructor(message) {
+    super(message);
+    this.name = "ConfigError";
+  }
+}
+
+class AgentNotFoundError extends Error {
+  static code = "AGENT_NOT_FOUND";
+  static suggestion = "Use 'wallets agent list' to see registered agents.";
+  constructor(id) {
+    super(`Agent not found: ${id}`);
+    this.name = "AgentNotFoundError";
+  }
+}
+
+// src/providers/agentcard.ts
+class AgentCardProvider {
+  name = "agentcard";
+  type = "agentcard";
+  jwt;
+  baseUrl;
+  constructor(config) {
+    this.jwt = config.jwt;
+    this.baseUrl = config.baseUrl || "https://api.agentcard.sh";
+  }
+  async request(path, options = {}) {
+    const url = `${this.baseUrl}${path}`;
+    const res = await fetch(url, {
+      ...options,
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${this.jwt}`,
+        ...options.headers || {}
+      }
+    });
+    if (!res.ok) {
+      const body = await res.text();
+      throw new ProviderError("agentcard", `HTTP ${res.status}: ${body}`);
+    }
+    return res.json();
+  }
+  async createCard(input) {
+    const data = await this.request("/cards", {
+      method: "POST",
+      body: JSON.stringify({ amount: input.amount })
+    });
+    return {
+      id: data.id,
+      provider_id: "",
+      external_id: data.id,
+      name: input.name || `AgentCard $${input.amount}`,
+      last_four: "",
+      brand: "visa",
+      status: data.status || "pending",
+      currency: input.currency || "USD",
+      balance: 0,
+      funded_amount: data.amount || input.amount,
+      spending_limit: input.spending_limit ?? null,
+      agent_id: input.agent_id ?? null,
+      metadata: input.metadata || {},
+      expires_at: null,
+      created_at: new Date().toISOString(),
+      updated_at: new Date().toISOString(),
+      funding_url: data.funding_url
+    };
+  }
+  async listCards() {
+    const data = await this.request("/cards");
+    return data.map((c) => ({
+      id: c.id,
+      provider_id: "",
+      external_id: c.id,
+      name: `AgentCard ${c.last_four ? `*${c.last_four}` : c.id.slice(0, 8)}`,
+      last_four: c.last_four || "",
+      brand: "visa",
+      status: c.status || "active",
+      currency: "USD",
+      balance: c.balance ?? 0,
+      funded_amount: c.amount ?? 0,
+      spending_limit: null,
+      agent_id: null,
+      metadata: {},
+      expires_at: null,
+      created_at: c.created_at || new Date().toISOString(),
+      updated_at: new Date().toISOString()
+    }));
+  }
+  async getCardDetails(externalId) {
+    const data = await this.request(`/cards/${externalId}/details`);
+    return {
+      id: data.id,
+      provider_id: "",
+      external_id: data.id,
+      name: `AgentCard *${data.last_four || data.pan.slice(-4)}`,
+      last_four: data.last_four || data.pan.slice(-4),
+      brand: "visa",
+      status: data.status || "active",
+      currency: "USD",
+      balance: data.balance ?? 0,
+      funded_amount: data.amount ?? 0,
+      spending_limit: null,
+      agent_id: null,
+      metadata: {},
+      expires_at: null,
+      created_at: new Date().toISOString(),
+      updated_at: new Date().toISOString(),
+      pan: data.pan,
+      cvv: data.cvv,
+      exp_month: data.exp_month,
+      exp_year: data.exp_year
+    };
+  }
+  async getBalance(externalId) {
+    const data = await this.request(`/cards/${externalId}/balance`);
+    return {
+      balance: data.balance,
+      currency: data.currency || "USD"
+    };
+  }
+  async closeCard(externalId) {
+    await this.request(`/cards/${externalId}/close`, { method: "POST" });
+  }
+}
+
+// src/providers/registry.ts
+var providers = new Map;
+function registerProviderFactory(type, factory) {
+  providers.set(type, factory);
+}
+function listProviderTypes() {
+  return Array.from(providers.keys());
+}
+function createProviderInstance(type) {
+  const factory = providers.get(type);
+  if (!factory) {
+    throw new Error(`Unknown provider type: ${type}. Available: ${listProviderTypes().join(", ")}`);
+  }
+  return factory();
+}
+
+// src/providers/index.ts
+registerProviderFactory("agentcard", () => {
+  throw new Error("AgentCard requires config. Use createAgentCardProvider() instead.");
+});
+function createAgentCardProvider(config) {
+  return new AgentCardProvider(config);
+}
+function getProviderInstance(type, config) {
+  switch (type) {
+    case "agentcard":
+      return new AgentCardProvider({ jwt: config["jwt"], baseUrl: config["baseUrl"] });
+    default:
+      return createProviderInstance(type);
+  }
+}
+// src/lib/config.ts
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+import { existsSync as existsSync2, readFileSync, writeFileSync, mkdirSync as mkdirSync2 } from "fs";
+function getConfigDir() {
+  return process.env["WALLETS_CONFIG_DIR"] || join2(homedir2(), ".wallets");
+}
+function getConfigPath() {
+  return join2(getConfigDir(), "config.json");
+}
+function loadConfig() {
+  const configPath = getConfigPath();
+  if (!existsSync2(configPath)) {
+    return {};
+  }
+  try {
+    return JSON.parse(readFileSync(configPath, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveConfig(config) {
+  const configDir = getConfigDir();
+  if (!existsSync2(configDir)) {
+    mkdirSync2(configDir, { recursive: true });
+  }
+  writeFileSync(join2(configDir, "config.json"), JSON.stringify(config, null, 2) + `
+`);
+}
+function getProviderConfig(providerName) {
+  const config = loadConfig();
+  return config.providers?.[providerName];
+}
+function setProviderConfig(providerName, providerConfig) {
+  const config = loadConfig();
+  if (!config.providers)
+    config.providers = {};
+  config.providers[providerName] = providerConfig;
+  saveConfig(config);
+}
+// src/lib/doctor.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+function runDoctor() {
+  const checks = [];
+  const configDir = getConfigDir();
+  checks.push({
+    name: "Config directory",
+    status: existsSync3(configDir) ? "ok" : "warn",
+    message: existsSync3(configDir) ? `Found at ${configDir}` : `Not found at ${configDir}. Run 'wallets provider add' to create it.`
+  });
+  const configPath = getConfigPath();
+  if (existsSync3(configPath)) {
+    try {
+      const config = loadConfig();
+      checks.push({
+        name: "Config file",
+        status: "ok",
+        message: `Valid config at ${configPath}`
+      });
+      if (config.default_provider) {
+        checks.push({
+          name: "Default provider",
+          status: "ok",
+          message: `Set to '${config.default_provider}'`
+        });
+      } else {
+        checks.push({
+          name: "Default provider",
+          status: "warn",
+          message: "No default provider set. Use 'wallets provider add' to register one."
+        });
+      }
+    } catch {
+      checks.push({
+        name: "Config file",
+        status: "error",
+        message: `Invalid JSON at ${configPath}`
+      });
+    }
+  } else {
+    checks.push({
+      name: "Config file",
+      status: "warn",
+      message: `Not found at ${configPath}. Run 'wallets provider add' to create it.`
+    });
+  }
+  try {
+    const db = getDatabase();
+    const providers2 = listProviders(db);
+    checks.push({
+      name: "Database",
+      status: "ok",
+      message: `Connected. ${providers2.length} provider(s) registered.`
+    });
+    for (const provider of providers2) {
+      const hasConfig = provider.config && Object.keys(provider.config).length > 0;
+      if (provider.type === "agentcard") {
+        const hasJwt = provider.config && "jwt" in provider.config;
+        checks.push({
+          name: `Provider: ${provider.name}`,
+          status: hasJwt ? "ok" : "error",
+          message: hasJwt ? `AgentCard configured (status: ${provider.status})` : "Missing JWT token. Run 'wallets provider add agentcard' to configure."
+        });
+      } else {
+        checks.push({
+          name: `Provider: ${provider.name}`,
+          status: hasConfig ? "ok" : "warn",
+          message: `Type: ${provider.type}, Status: ${provider.status}${hasConfig ? "" : " (no config)"}`
+        });
+      }
+    }
+    if (providers2.length === 0) {
+      checks.push({
+        name: "Providers",
+        status: "warn",
+        message: "No providers registered. Use 'wallets provider add' to add one."
+      });
+    }
+  } catch (e) {
+    checks.push({
+      name: "Database",
+      status: "error",
+      message: `Failed to connect: ${e instanceof Error ? e.message : String(e)}`
+    });
+  }
+  try {
+    const binPath = join3(import.meta.dir, "../../dist/mcp/index.js");
+    const srcPath = join3(import.meta.dir, "../mcp/index.ts");
+    const mcpAvailable = existsSync3(binPath) || existsSync3(srcPath);
+    checks.push({
+      name: "MCP server",
+      status: mcpAvailable ? "ok" : "warn",
+      message: mcpAvailable ? "MCP server binary available" : "MCP server not found. Run 'bun run build' to compile."
+    });
+  } catch {
+    checks.push({
+      name: "MCP server",
+      status: "warn",
+      message: "Could not check MCP server status."
+    });
+  }
+  return {
+    checks,
+    healthy: checks.every((c) => c.status !== "error")
+  };
+}
+// src/lib/format.ts
+function formatCard(card) {
+  const id = card.id.slice(0, 8);
+  const last4 = card.last_four ? `*${card.last_four}` : "----";
+  return `${id} ${card.status.padEnd(8)} ${last4.padEnd(6)} $${card.balance.toFixed(2).padStart(10)} ${card.name}`;
+}
+function formatProvider(provider) {
+  return `${provider.id.slice(0, 8)} ${provider.status.padEnd(8)} ${provider.type.padEnd(12)} ${provider.name}`;
+}
+function formatTransaction(tx) {
+  const id = tx.id.slice(0, 8);
+  const sign = tx.type === "refund" || tx.type === "load" ? "+" : "-";
+  return `${id} ${tx.type.padEnd(10)} ${tx.status.padEnd(10)} ${sign}$${tx.amount.toFixed(2).padStart(9)} ${tx.merchant || tx.description || ""}`;
+}
+function formatDoctorCheck(check) {
+  const icon = check.status === "ok" ? "[ok]" : check.status === "warn" ? "[!!]" : "[ERR]";
+  return `${icon} ${check.name}: ${check.message}`;
+}
+function formatError(error) {
+  if (error instanceof ProviderNotFoundError) {
+    return JSON.stringify({ code: ProviderNotFoundError.code, message: error.message, suggestion: ProviderNotFoundError.suggestion });
+  }
+  if (error instanceof CardNotFoundError) {
+    return JSON.stringify({ code: CardNotFoundError.code, message: error.message, suggestion: CardNotFoundError.suggestion });
+  }
+  if (error instanceof ProviderError) {
+    return JSON.stringify({ code: ProviderError.code, message: error.message, suggestion: ProviderError.suggestion });
+  }
+  if (error instanceof InsufficientFundsError) {
+    return JSON.stringify({ code: InsufficientFundsError.code, message: error.message, suggestion: InsufficientFundsError.suggestion });
+  }
+  if (error instanceof ConfigError) {
+    return JSON.stringify({ code: ConfigError.code, message: error.message, suggestion: ConfigError.suggestion });
+  }
+  if (error instanceof AgentNotFoundError) {
+    return JSON.stringify({ code: AgentNotFoundError.code, message: error.message, suggestion: AgentNotFoundError.suggestion });
+  }
+  if (error instanceof WalletError) {
+    return JSON.stringify({ code: WalletError.code, message: error.message, suggestion: WalletError.suggestion });
+  }
+  if (error instanceof Error) {
+    return JSON.stringify({ code: "UNKNOWN_ERROR", message: error.message });
+  }
+  return JSON.stringify({ code: "UNKNOWN_ERROR", message: String(error) });
+}
+export {
+  updateProvider,
+  updateCardBalance,
+  updateCard,
+  setProviderConfig,
+  saveConfig,
+  runDoctor,
+  resetDatabase,
+  registerProviderFactory,
+  registerAgent,
+  loadConfig,
+  listTransactions,
+  listProviders,
+  listProviderTypes,
+  listCards,
+  listAgents,
+  getTransaction,
+  getProviderInstance,
+  getProviderConfig,
+  getProviderByName,
+  getProvider,
+  getDatabase,
+  getCardByExternalId,
+  getCard,
+  getAgentByName,
+  getAgent,
+  formatTransaction,
+  formatProvider,
+  formatError,
+  formatDoctorCheck,
+  formatCard,
+  ensureProvider,
+  deleteProvider,
+  deleteCard,
+  deleteAgent,
+  createTransaction,
+  createProvider,
+  createCardRecord,
+  createAgentCardProvider,
+  closeDatabase,
+  WalletError,
+  ProviderNotFoundError,
+  ProviderError,
+  InsufficientFundsError,
+  ConfigError,
+  CardNotFoundError,
+  AgentNotFoundError,
+  AgentCardProvider
+};