vibecash 0.1.3 → 0.2.1

package/dist/index.js

@@ -1,1012 +1,968 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { Command as Command9 } from "commander";
-
-// src/commands/wallet.ts
 import { Command } from "commander";
 
 // src/config.ts
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
-
-// ../shared/src/constants.ts
-var PRODUCT_NAME = "vibecash";
-var DOMAINS = {
-  api: `api.${PRODUCT_NAME}.dev`,
-  app: `${PRODUCT_NAME}.dev`,
-  pay: `pay.${PRODUCT_NAME}.dev`,
-  js: `js.${PRODUCT_NAME}.dev`
-};
-var API_BASE_URL = `https://${DOMAINS.api}/v1`;
-var EXPIRATION = {
-  checkoutSession: 24 * 60 * 60 * 1e3,
-  // 24 hours
-  claimToken: 7 * 24 * 60 * 60 * 1e3,
-  // 7 days
-  portalSession: 60 * 60 * 1e3
-  // 1 hour
-};
-
-// ../shared/src/utils-browser.ts
-function formatAmount(amountCents, currency) {
-  const amount = amountCents / 100;
-  return new Intl.NumberFormat("en-US", {
-    style: "currency",
-    currency
-  }).format(amount);
-}
-function parseAmountToCents(amount) {
-  const parsed = typeof amount === "string" ? parseFloat(amount) : amount;
-  return Math.round(parsed * 100);
-}
-
-// ../shared/src/utils-node.ts
-import { createHash, randomBytes, timingSafeEqual } from "crypto";
-
-// src/config.ts
-var CONFIG_DIR = join(homedir(), `.${PRODUCT_NAME}`);
+var CONFIG_DIR = join(homedir(), ".vibecash");
 var CONFIG_FILE = join(CONFIG_DIR, "config.json");
 function getConfig() {
-  if (!existsSync(CONFIG_FILE)) {
-    return {};
-  }
-  try {
-    const content = readFileSync(CONFIG_FILE, "utf-8");
-    return JSON.parse(content);
-  } catch {
-    return {};
-  }
+  if (!existsSync(CONFIG_FILE)) return {};
+  return JSON.parse(readFileSync(CONFIG_FILE, "utf-8"));
 }
 function saveConfig(config) {
-  if (!existsSync(CONFIG_DIR)) {
-    mkdirSync(CONFIG_DIR, { recursive: true });
-  }
-  const existing = getConfig();
-  const merged = { ...existing, ...config };
-  writeFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2));
+  if (!existsSync(CONFIG_DIR)) mkdirSync(CONFIG_DIR, { recursive: true });
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
 }
 function getSecret() {
-  const envSecret = process.env.AIPAY_SECRET;
-  if (envSecret) {
-    return envSecret;
-  }
+  return process.env.VIBECASH_SECRET || getConfig().secret;
+}
+function setSecret(secret) {
   const config = getConfig();
-  return config.secret;
+  config.secret = secret;
+  saveConfig(config);
 }
 function getApiUrl() {
-  const envUrl = process.env.AIPAY_API_URL;
-  if (envUrl) {
-    return envUrl;
-  }
-  const config = getConfig();
-  return config.apiUrl || "https://api.vibecash.dev";
+  return process.env.VIBECASH_API_URL || getConfig().apiUrl || "https://api.vibecash.dev";
+}
+var _overrideFormat;
+function setOutputFormat(format) {
+  _overrideFormat = format;
 }
 function getOutputFormat() {
-  const envFormat = process.env.AIPAY_OUTPUT;
-  if (envFormat === "human" || envFormat === "json") {
-    return envFormat;
-  }
-  const config = getConfig();
-  return config.outputFormat || "json";
+  if (_overrideFormat) return _overrideFormat;
+  const env = process.env.VIBECASH_OUTPUT;
+  if (env === "json" || env === "human") return env;
+  return getConfig().outputFormat || "human";
 }
 
 // src/api-client.ts
-var ApiClient = class {
-  baseUrl;
-  secret;
-  constructor(options) {
-    this.baseUrl = options?.baseUrl || getApiUrl();
-    this.secret = options?.secret || getSecret();
-  }
-  async request(method, path, body, requiresAuth = true) {
-    const url = `${this.baseUrl}${path}`;
-    const headers = {
-      "Content-Type": "application/json"
-    };
-    if (requiresAuth) {
-      if (!this.secret) {
-        throw new Error(
-          "No API secret found. Set AIPAY_SECRET environment variable or run `aipay wallet create`"
-        );
-      }
-      headers["Authorization"] = `Bearer ${this.secret}`;
-    }
-    const response = await fetch(url, {
-      method,
-      headers,
-      body: body ? JSON.stringify(body) : void 0
-    });
-    const json = await response.json();
-    if (!response.ok) {
-      const errorMessage = json.error?.message || `API error: ${response.status}`;
-      throw new Error(errorMessage);
-    }
-    return json;
-  }
-  // Wallets
-  async createWallet() {
-    return this.request("POST", "/v1/wallets", void 0, false);
-  }
-  async getWallet() {
-    return this.request("GET", "/v1/wallets/current");
-  }
-  async createClaimLink() {
-    return this.request("POST", "/v1/wallets/current/claim_link");
-  }
-  // Products
-  async createProduct(data) {
-    return this.request("POST", "/v1/products", data);
-  }
-  async listProducts() {
-    return this.request("GET", "/v1/products");
-  }
-  async getProduct(id) {
-    return this.request("GET", `/v1/products/${id}`);
-  }
-  // Prices
-  async createPrice(data) {
-    return this.request("POST", "/v1/prices", {
-      productId: data.productId,
-      amount: data.amount,
-      currency: data.currency,
-      type: data.type,
-      interval: data.interval,
-      intervalCount: data.intervalCount,
-      trialPeriodDays: data.trialPeriodDays
-    });
-  }
-  async listPrices(productId) {
-    const query = productId ? `?product_id=${productId}` : "";
-    return this.request("GET", `/v1/prices${query}`);
-  }
-  // Checkout
-  async createCheckoutSession(data) {
-    return this.request("POST", "/v1/checkout/sessions", data);
-  }
-  async getCheckoutSession(id) {
-    return this.request("GET", `/v1/checkout/sessions/${id}`, void 0, false);
-  }
-  // Subscriptions
-  async listSubscriptions(params) {
-    const query = new URLSearchParams();
-    if (params?.customerId) query.set("customer_id", params.customerId);
-    if (params?.status) query.set("status", params.status);
-    const queryStr = query.toString() ? `?${query.toString()}` : "";
-    return this.request("GET", `/v1/subscriptions${queryStr}`);
-  }
-  async getSubscription(id) {
-    return this.request("GET", `/v1/subscriptions/${id}`);
-  }
-  async cancelSubscription(id, immediately = false) {
-    return this.request("POST", `/v1/subscriptions/${id}/cancel`, {
-      cancel_at_period_end: !immediately
-    });
-  }
-  async resumeSubscription(id) {
-    return this.request("POST", `/v1/subscriptions/${id}/resume`);
-  }
-  // Customers
-  async createCustomer(data) {
-    return this.request("POST", "/v1/customers", data);
-  }
-  async listCustomers() {
-    return this.request("GET", "/v1/customers");
-  }
-  async getCustomer(id) {
-    return this.request("GET", `/v1/customers/${id}`);
-  }
-  async createPortalSession(customerId, returnUrl) {
-    return this.request("POST", `/v1/customers/${customerId}/portal_sessions`, {
-      return_url: returnUrl
-    });
-  }
-  // Payment Links
-  async createPaymentLink(data) {
-    return this.request("POST", "/v1/payment_links", data);
-  }
-  async listPaymentLinks() {
-    return this.request("GET", "/v1/payment_links");
-  }
-  async getPaymentLink(id) {
-    return this.request("GET", `/v1/payment_links/${id}`, void 0, false);
+async function apiRequest(method, path, body) {
+  const secret = getSecret();
+  if (!secret) {
+    console.error("No API key found. Set VIBECASH_SECRET or run `vibecash wallet create`");
+    process.exit(1);
+  }
+  const url = `${getApiUrl()}/v1${path}`;
+  const res = await fetch(url, {
+    method,
+    headers: {
+      "Content-Type": "application/json",
+      "Authorization": `Bearer ${secret}`
+    },
+    body: body ? JSON.stringify(body) : void 0
+  });
+  const data = await res.json();
+  if (!res.ok) {
+    const msg = data.error?.message || "Unknown error";
+    throw new Error(`API Error (${res.status}): ${msg}`);
   }
-  async updatePaymentLink(id, data) {
-    return this.request("PATCH", `/v1/payment_links/${id}`, data);
+  return data;
+}
+async function apiRequestNoAuth(method, path, body) {
+  const url = `${getApiUrl()}/v1${path}`;
+  const res = await fetch(url, {
+    method,
+    headers: { "Content-Type": "application/json" },
+    body: body ? JSON.stringify(body) : void 0
+  });
+  const data = await res.json();
+  if (!res.ok) {
+    const msg = data.error?.message || "Unknown error";
+    throw new Error(`API Error (${res.status}): ${msg}`);
   }
-};
+  return data;
+}
 
 // src/utils/output.ts
-function formatAmount2(amountCents, currency = "USD") {
-  return formatAmount(amountCents, currency);
-}
 function output(data, humanFormatter) {
   const format = getOutputFormat();
-  if (format === "human" && humanFormatter) {
+  if (format === "json") {
+    console.log(JSON.stringify(data, null, 2));
+  } else if (humanFormatter) {
     console.log(humanFormatter(data));
   } else {
     console.log(JSON.stringify(data, null, 2));
   }
 }
-function formatDate(timestamp) {
-  return new Date(timestamp).toLocaleString();
+function success(message) {
+  console.log(`\u2713 ${message}`);
 }
-function formatCurrency(amountCents, currency = "USD") {
-  return formatAmount(amountCents, currency);
+function table(headers, rows) {
+  const colWidths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => (r[i] || "").length)));
+  const top = "\u250C" + colWidths.map((w) => "\u2500".repeat(w + 2)).join("\u252C") + "\u2510";
+  const bot = "\u2514" + colWidths.map((w) => "\u2500".repeat(w + 2)).join("\u2534") + "\u2518";
+  const row = (cells) => "\u2502" + cells.map((c, i) => ` ${(c || "").padEnd(colWidths[i])} `).join("\u2502") + "\u2502";
+  console.log(top);
+  console.log(row(headers));
+  console.log("\u251C" + colWidths.map((w) => "\u2500".repeat(w + 2)).join("\u253C") + "\u2524");
+  rows.forEach((r) => console.log(row(r)));
+  console.log(bot);
 }
-function formatStatus(status) {
-  const colors = {
-    active: "\x1B[32m",
-    // green
-    trialing: "\x1B[33m",
-    // yellow
-    past_due: "\x1B[31m",
-    // red
-    canceled: "\x1B[90m",
-    // gray
-    succeeded: "\x1B[32m",
-    failed: "\x1B[31m",
-    pending: "\x1B[33m",
-    open: "\x1B[33m",
-    complete: "\x1B[32m",
-    expired: "\x1B[90m",
-    created: "\x1B[36m",
-    // cyan
-    claimed: "\x1B[32m",
-    verified: "\x1B[32m"
-  };
-  const reset = "\x1B[0m";
-  const color = colors[status] || "";
-  return `${color}${status}${reset}`;
+function fmtAmount(cents, currency) {
+  if (cents == null) return "N/A";
+  const n = typeof cents === "string" ? parseInt(cents, 10) : cents;
+  if (isNaN(n)) return String(cents);
+  const dec = (n / 100).toFixed(2);
+  return currency ? `${dec} ${currency}` : dec;
 }
-function formatTable(rows) {
-  if (rows.length === 0) return "";
-  const colWidths = [];
-  for (const row of rows) {
-    row.forEach((cell, i) => {
-      const cellLen = stripAnsi(cell).length;
-      colWidths[i] = Math.max(colWidths[i] || 0, cellLen);
-    });
-  }
-  return rows.map(
-    (row) => row.map((cell, i) => cell.padEnd(colWidths[i] + (cell.length - stripAnsi(cell).length))).join("  ")
-  ).join("\n");
-}
-function stripAnsi(str) {
-  return str.replace(/\x1b\[[0-9;]*m/g, "");
-}
-function error(message) {
-  console.error(`\x1B[31mError:\x1B[0m ${message}`);
-  process.exit(1);
-}
-function info(message) {
-  console.log(`\x1B[36m\u2139\x1B[0m ${message}`);
+function fmtDate(ts) {
+  if (ts == null || ts === "") return "N/A";
+  const n = typeof ts === "string" ? parseInt(ts, 10) : ts;
+  if (isNaN(n) || n === 0) return "N/A";
+  const d = new Date(n);
+  const pad = (v) => String(v).padStart(2, "0");
+  return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}`;
 }
 
 // src/commands/wallet.ts
-function createWalletCommand() {
-  const wallet = new Command("wallet").description("Manage wallets");
+function registerWalletCommands(program2) {
+  const wallet = program2.command("wallet").description("Manage your wallet");
   wallet.command("create").description("Create a new wallet").action(async () => {
     try {
-      const client = new ApiClient();
-      const result = await client.createWallet();
-      saveConfig({ secret: result.secret });
-      output(result, (data) => {
-        const d = data;
+      const data = await apiRequestNoAuth("POST", "/wallets");
+      if (data.secret) {
+        setSecret(data.secret);
+        success("Wallet created! API key saved to ~/.vibecash/config.json");
+      }
+      output(data, (d) => {
+        const w = d.wallet || d;
         return [
-          `Wallet created successfully!`,
-          ``,
-          `  ID:     ${d.id}`,
-          `  Secret: ${d.secret}`,
-          `  Status: ${formatStatus(d.status)}`,
-          ``,
-          `Your secret has been saved to ~/.aipay/config.json`,
-          `You can also set it as an environment variable:`,
-          `  export AIPAY_SECRET=${d.secret}`
+          `Wallet ID:  ${w.id}`,
+          `Status:     ${w.status || "active"}`,
+          `Currency:   ${w.currency || "SGD"}`
         ].join("\n");
       });
     } catch (err) {
-      error(err instanceof Error ? err.message : "Failed to create wallet");
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
     }
   });
-  wallet.command("status").description("Get current wallet status").action(async () => {
+  wallet.command("info").description("Get current wallet info").action(async () => {
     try {
-      const client = new ApiClient();
-      const result = await client.getWallet();
-      output(result, (data) => {
-        const d = data;
+      const data = await apiRequest("GET", "/wallets/current");
+      output(data, (d) => {
         return [
-          `Wallet: ${d.id}`,
-          ``,
-          `  Status:          ${formatStatus(d.status)}`,
-          `  Balance:         ${formatCurrency(d.balance, d.currency)}`,
-          `  Pending Balance: ${formatCurrency(d.pendingBalance, d.currency)}`,
-          `  Created:         ${formatDate(d.createdAt)}`
+          `Wallet ID:  ${d.id}`,
+          `Status:     ${d.status || "N/A"}`,
+          `Currency:   ${d.currency || "N/A"}`,
+          `Available:  ${fmtAmount(d.availableBalance, d.currency)}`,
+          `Pending:    ${fmtAmount(d.pendingBalance, d.currency)}`,
+          `Withdrawn:  ${fmtAmount(d.withdrawnBalance, d.currency)}`,
+          `Webhook:    ${d.webhookUrl || "not configured"}`,
+          `Created:    ${fmtDate(d.createdAt)}`
         ].join("\n");
       });
     } catch (err) {
-      error(err instanceof Error ? err.message : "Failed to get wallet status");
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
     }
   });
-  wallet.command("claim").description("Generate a claim link for this wallet").action(async () => {
+  wallet.command("claim").description("Generate a claim link for your wallet").action(async () => {
     try {
-      const client = new ApiClient();
-      const wallet2 = await client.getWallet();
-      if (wallet2.status === "claimed" || wallet2.status === "verified") {
-        error("This wallet has already been claimed and cannot be claimed again.");
-        return;
-      }
-      const result = await client.createClaimLink();
-      output(result, (data) => {
-        const d = data;
-        return [
-          `Claim link generated!`,
-          ``,
-          `  URL:     ${d.claimUrl}`,
-          `  Expires: ${formatDate(d.expiresAt)}`,
-          ``,
-          `Share this link to allow someone to claim ownership of this wallet.`
-        ].join("\n");
+      const data = await apiRequest("POST", "/wallets/current/claim_link");
+      output(data, (d) => {
+        return `Claim Link: ${d.url || d.claimLink || d.link || JSON.stringify(d)}`;
       });
     } catch (err) {
-      error(err instanceof Error ? err.message : "Failed to generate claim link");
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
     }
   });
-  return wallet;
 }
 
 // src/commands/product.ts
-import { Command as Command2 } from "commander";
-function createProductCommand() {
-  const product = new Command2("product").description("Manage products");
-  product.command("create").description("Create a new product").argument("<name>", "Product name").option("-d, --description <description>", "Product description").action(async (name, options) => {
-    try {
-      const client = new ApiClient();
-      const result = await client.createProduct({
-        name,
-        description: options.description
-      });
-      output(result, (data) => {
-        const d = data;
-        return [
-          `Product created!`,
-          ``,
-          `  ID:          ${d.id}`,
-          `  Name:        ${d.name}`,
-          d.description ? `  Description: ${d.description}` : null,
-          `  Active:      ${d.active}`,
-          `  Created:     ${formatDate(d.createdAt)}`
-        ].filter(Boolean).join("\n");
-      });
+function registerProductCommands(program2) {
+  const product = program2.command("product").description("Manage products");
+  product.command("create <name>").description("Create a new product").option("-d, --description <description>", "Product description").action(async (name, opts) => {
+    try {
+      const body = { name };
+      if (opts.description) body.description = opts.description;
+      const data = await apiRequest("POST", "/products", body);
+      success("Product created");
+      output(data, (d) => `Product ID: ${d.id}
+Name:       ${d.name}`);
     } catch (err) {
-      error(err instanceof Error ? err.message : "Failed to create product");
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
     }
   });
   product.command("list").description("List all products").action(async () => {
     try {
-      const client = new ApiClient();
-      const result = await client.listProducts();
-      output(result, (data) => {
-        const d = data;
-        if (d.data.length === 0) {
-          return "No products found.";
-        }
-        const rows = [
-          ["ID", "NAME", "ACTIVE", "CREATED"],
-          ...d.data.map((p) => [p.id, p.name, p.active ? "yes" : "no", formatDate(p.createdAt)])
-        ];
-        return formatTable(rows);
+      const data = await apiRequest("GET", "/products");
+      output(data, (d) => {
+        const items = d.data || d.products || d;
+        if (!Array.isArray(items) || items.length === 0) return "No products found.";
+        table(
+          ["ID", "Name", "Created"],
+          items.map((p) => [p.id, p.name, fmtDate(p.createdAt)])
+        );
+        return "";
       });
     } catch (err) {
-      error(err instanceof Error ? err.message : "Failed to list products");
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
     }
   });
-  product.command("get").description("Get product details").argument("<id>", "Product ID").action(async (id) => {
+  product.command("get <id>").description("Get a product by ID").action(async (id) => {
     try {
-      const client = new ApiClient();
-      const result = await client.getProduct(id);
-      output(result, (data) => {
-        const d = data;
-        return [
-          `Product: ${d.id}`,
-          ``,
-          `  Name:        ${d.name}`,
-          d.description ? `  Description: ${d.description}` : null,
-          `  Active:      ${d.active}`,
-          `  Created:     ${formatDate(d.createdAt)}`
-        ].filter(Boolean).join("\n");
-      });
+      const data = await apiRequest("GET", `/products/${id}`);
+      output(data, (d) => [
+        `Product ID:  ${d.id}`,
+        `Name:        ${d.name}`,
+        `Description: ${d.description || "N/A"}`,
+        `Created:     ${fmtDate(d.createdAt)}`
+      ].join("\n"));
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  product.command("update <id>").description("Update a product").option("-n, --name <name>", "New product name").option("-d, --description <description>", "New product description").action(async (id, opts) => {
+    try {
+      const body = {};
+      if (opts.name) body.name = opts.name;
+      if (opts.description) body.description = opts.description;
+      await apiRequest("PATCH", `/products/${id}`, body);
+      success("Product updated");
     } catch (err) {
-      error(err instanceof Error ? err.message : "Failed to get product");
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  product.command("delete <id>").description("Delete a product").action(async (id) => {
+    try {
+      await apiRequest("DELETE", `/products/${id}`);
+      success(`Product ${id} deleted`);
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
     }
   });
-  return product;
 }
 
 // src/commands/price.ts
-import { Command as Command3 } from "commander";
-function createPriceCommand() {
-  const price = new Command3("price").description("Manage prices");
-  price.command("create").description("Create a new price").argument("<product_id>", "Product ID").requiredOption("-a, --amount <amount>", "Price amount (e.g., 9.99)").requiredOption("-t, --type <type>", "Price type (one_time or recurring)").option("-c, --currency <currency>", "Currency code", "USD").option("-i, --interval <interval>", "Billing interval (day, week, month, year)").option("--interval-count <count>", "Number of intervals between billings", "1").option("--trial-days <days>", "Trial period in days").action(
-    async (productId, options) => {
-      try {
-        const type = options.type;
-        if (!["one_time", "recurring"].includes(type)) {
-          error("Type must be one_time or recurring");
-          return;
-        }
-        if (type === "recurring" && !options.interval) {
-          error("Interval is required for recurring prices");
-          return;
-        }
-        const client = new ApiClient();
-        const result = await client.createPrice({
-          productId,
-          amount: parseAmountToCents(options.amount),
-          currency: options.currency,
-          type,
-          interval: options.interval,
-          intervalCount: parseInt(options.intervalCount, 10),
-          trialPeriodDays: options.trialDays ? parseInt(options.trialDays, 10) : void 0
-        });
-        output(result, (data) => {
-          const d = data;
-          const interval = d.type === "recurring" && d.interval ? d.intervalCount === 1 ? `/${d.interval}` : `/${d.intervalCount} ${d.interval}s` : "";
-          return [
-            `Price created!`,
-            ``,
-            `  ID:       ${d.id}`,
-            `  Amount:   ${formatCurrency(d.amount, d.currency)}${interval}`,
-            `  Type:     ${d.type}`,
-            d.interval ? `  Interval: ${d.interval}` : null,
-            d.trialPeriodDays ? `  Trial:    ${d.trialPeriodDays} days` : null,
-            `  Created:  ${formatDate(d.createdAt)}`
-          ].filter(Boolean).join("\n");
-        });
-      } catch (err) {
-        error(err instanceof Error ? err.message : "Failed to create price");
-      }
+function registerPriceCommands(program2) {
+  const price = program2.command("price").description("Manage prices");
+  price.command("create <productId>").description("Create a new price for a product").requiredOption("-a, --amount <amount>", "Price amount in cents (e.g. 1000 = $10.00)").requiredOption("-t, --type <type>", "Price type (one_time or recurring)").option("-c, --currency <currency>", "Currency code", "SGD").option("-i, --interval <interval>", "Billing interval (month, year) \u2014 required for recurring").action(async (productId, opts) => {
+    try {
+      const body = {
+        productId,
+        unitAmount: parseInt(opts.amount, 10),
+        type: opts.type,
+        currency: opts.currency.toUpperCase()
+      };
+      if (opts.interval) body.interval = opts.interval;
+      const data = await apiRequest("POST", "/prices", body);
+      success("Price created");
+      output(data, (d) => [
+        `Price ID: ${d.id}`,
+        `Amount:   ${fmtAmount(d.unitAmount ?? d.amount, d.currency)}`,
+        `Type:     ${d.type}`,
+        d.interval ? `Interval: ${d.interval}` : null
+      ].filter(Boolean).join("\n"));
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
     }
-  );
-  price.command("list").description("List prices").option("-p, --product <id>", "Filter by product ID").action(async (options) => {
+  });
+  price.command("list").description("List all prices").action(async () => {
     try {
-      const client = new ApiClient();
-      const result = await client.listPrices(options.product);
-      output(result, (data) => {
-        const d = data;
-        if (d.data.length === 0) {
-          return "No prices found.";
-        }
-        const rows = [
-          ["ID", "PRODUCT", "AMOUNT", "TYPE", "INTERVAL"],
-          ...d.data.map((p) => [
+      const data = await apiRequest("GET", "/prices");
+      output(data, (d) => {
+        const items = d.data || d.prices || d;
+        if (!Array.isArray(items) || items.length === 0) return "No prices found.";
+        table(
+          ["ID", "Amount", "Type", "Interval"],
+          items.map((p) => [
             p.id,
-            p.productId,
-            formatCurrency(p.amount, p.currency),
+            fmtAmount(p.unitAmount ?? p.amount, p.currency),
             p.type,
             p.interval || "-"
           ])
-        ];
-        return formatTable(rows);
+        );
+        return "";
       });
     } catch (err) {
-      error(err instanceof Error ? err.message : "Failed to list prices");
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
     }
   });
-  return price;
 }
 
 // src/commands/checkout.ts
-import { Command as Command4 } from "commander";
-function createCheckoutCommand() {
-  const checkout = new Command4("checkout").description("Manage checkout sessions");
-  checkout.command("create").description("Create a checkout session").option("-p, --price <id>", "Price ID").option("-a, --amount <amount>", "Amount for inline price (e.g., 9.99)").option("-d, --description <desc>", "Description for inline price").option("-m, --mode <mode>", "Checkout mode (payment, subscription)", "payment").option("--success-url <url>", "Success redirect URL").option("--cancel-url <url>", "Cancel redirect URL").option("--email <email>", "Customer email").option("-c, --currency <currency>", "Currency code (default: USD)", "USD").option("--trial-days <days>", "Trial period days (for subscriptions)").action(
-    async (options) => {
-      try {
-        if (!options.price && !options.amount) {
-          error("Either --price or --amount is required");
-          return;
-        }
-        const mode = options.mode;
-        if (!["payment", "subscription", "setup"].includes(mode)) {
-          error("Mode must be payment, subscription, or setup");
-          return;
-        }
-        const client = new ApiClient();
-        const params = {
-          mode,
-          successUrl: options.successUrl,
-          cancelUrl: options.cancelUrl,
-          customerEmail: options.email,
-          trialPeriodDays: options.trialDays ? parseInt(options.trialDays, 10) : void 0
-        };
-        if (options.price) {
-          params.priceId = options.price;
-        } else if (options.amount) {
-          params.lineItems = [
-            {
-              description: options.description,
-              amount: parseAmountToCents(options.amount),
-              currency: options.currency.toUpperCase(),
-              quantity: 1
-            }
-          ];
-        }
-        const result = await client.createCheckoutSession(params);
-        output(result, (data) => {
-          const d = data;
-          return [
-            `Checkout session created!`,
-            ``,
-            `  ID:      ${d.id}`,
-            `  Mode:    ${d.mode}`,
-            `  Status:  ${formatStatus(d.status)}`,
-            d.amountTotal ? `  Amount:  ${formatCurrency(d.amountTotal, d.currency || "USD")}` : null,
-            `  URL:     ${d.url}`,
-            `  Expires: ${formatDate(d.expiresAt)}`
-          ].filter(Boolean).join("\n");
-        });
-      } catch (err) {
-        error(err instanceof Error ? err.message : "Failed to create checkout session");
-      }
+function registerCheckoutCommands(program2) {
+  const checkout = program2.command("checkout").description("Manage checkout sessions");
+  checkout.command("create").description("Create a new checkout session").requiredOption("-p, --price-id <priceId>", "Price ID to checkout").requiredOption("--success-url <url>", "URL to redirect on success").requiredOption("--cancel-url <url>", "URL to redirect on cancel").option("-m, --mode <mode>", "payment or subscription", "payment").option("-q, --quantity <quantity>", "Quantity", "1").option("--methods <methods>", "Payment methods (comma-separated: card,alipay,paynow,wechat)", "card,alipay,paynow,wechat").action(async (opts) => {
+    try {
+      const body = {
+        mode: opts.mode,
+        lineItems: [{ priceId: opts.priceId, quantity: parseInt(opts.quantity, 10) }],
+        successUrl: opts.successUrl,
+        cancelUrl: opts.cancelUrl,
+        paymentMethodTypes: opts.methods.split(",").map((m) => m.trim())
+      };
+      const data = await apiRequest("POST", "/checkout/sessions", body);
+      success("Checkout session created");
+      output(data, (d) => {
+        return [
+          `Session ID:   ${d.id}`,
+          `Checkout URL: ${d.url || d.checkoutUrl || "N/A"}`
+        ].join("\n");
+      });
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
     }
-  );
-  checkout.command("status").description("Get checkout session status").argument("<id>", "Checkout session ID").option("-w, --wait", "Wait for session to complete").option("--timeout <ms>", "Timeout in milliseconds when waiting", "300000").action(async (id, options) => {
-    try {
-      const client = new ApiClient();
-      if (options.wait) {
-        const timeout = parseInt(options.timeout, 10);
-        const startTime = Date.now();
-        info("Waiting for checkout to complete...");
-        while (Date.now() - startTime < timeout) {
-          const result = await client.getCheckoutSession(id);
-          if (result.session.status === "complete") {
-            output(result, formatCheckoutSession);
-            return;
-          }
-          if (result.session.status === "expired") {
-            error("Checkout session expired");
-            return;
-          }
-          await new Promise((resolve) => setTimeout(resolve, 2e3));
+  });
+  checkout.command("get <id>").description("Get a checkout session by ID").option("-w, --watch", 'Poll until status changes from "open" (every 5s)').option("-i, --interval <seconds>", "Poll interval in seconds", "5").action(async (id, opts) => {
+    try {
+      const formatSession = (d) => {
+        return [
+          `Session ID: ${d.id}`,
+          `Status:     ${d.status || "N/A"}`,
+          `Mode:       ${d.mode || "N/A"}`,
+          d.amountTotal != null ? `Amount:     ${fmtAmount(d.amountTotal, d.currency)}` : null,
+          d.paymentId ? `Payment ID: ${d.paymentId}` : null,
+          d.url ? `URL:        ${d.url}` : null,
+          d.successUrl ? `Success:    ${d.successUrl}` : null
+        ].filter(Boolean).join("\n");
+      };
+      if (!opts.watch) {
+        const data = await apiRequest("GET", `/checkout/sessions/${id}`);
+        output(data, formatSession);
+        return;
+      }
+      const intervalMs = parseInt(opts.interval || "5", 10) * 1e3;
+      console.log(`Watching session ${id} (every ${intervalMs / 1e3}s)...
+`);
+      while (true) {
+        const data = await apiRequest("GET", `/checkout/sessions/${id}`);
+        const status = data.status || "unknown";
+        const ts = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+        process.stdout.write(`\r[${ts}] Status: ${status}  `);
+        if (status !== "open") {
+          console.log("\n");
+          output(data, formatSession);
+          break;
         }
-        error("Timeout waiting for checkout to complete");
-      } else {
-        const result = await client.getCheckoutSession(id);
-        output(result, formatCheckoutSession);
+        await new Promise((r) => setTimeout(r, intervalMs));
       }
     } catch (err) {
-      error(err instanceof Error ? err.message : "Failed to get checkout session");
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
     }
   });
-  return checkout;
-}
-function formatCheckoutSession(data) {
-  const d = data;
-  const lines = [
-    `Checkout Session: ${d.session.id}`,
-    ``,
-    `  Status:  ${formatStatus(d.session.status)}`,
-    `  Mode:    ${d.session.mode}`
-  ];
-  if (d.product) {
-    lines.push(`  Product: ${d.product.name} (${d.product.id})`);
-  }
-  if (d.price) {
-    lines.push(`  Price:   ${formatCurrency(d.price.amount, d.price.currency)} (${d.price.id})`);
-  } else if (d.session.amountTotal) {
-    lines.push(`  Amount:  ${formatCurrency(d.session.amountTotal, d.session.currency || "USD")}`);
-  }
-  lines.push(`  URL:     ${d.session.url}`);
-  lines.push(`  Created: ${formatDate(d.session.createdAt)}`);
-  if (d.session.completedAt) {
-    lines.push(`  Completed: ${formatDate(d.session.completedAt)}`);
-  }
-  return lines.join("\n");
 }
 
 // src/commands/subscription.ts
-import { Command as Command5 } from "commander";
-function createSubscriptionCommand() {
-  const subscription = new Command5("subscription").description("Manage subscriptions");
-  subscription.command("list").description("List subscriptions").option("-c, --customer <id>", "Filter by customer ID").option("-s, --status <status>", "Filter by status").action(async (options) => {
-    try {
-      const client = new ApiClient();
-      const result = await client.listSubscriptions({
-        customerId: options.customer,
-        status: options.status
-      });
-      output(result, (data) => {
-        const d = data;
-        if (d.data.length === 0) {
-          return "No subscriptions found.";
-        }
-        const rows = [
-          ["ID", "CUSTOMER", "STATUS", "PERIOD END", "CANCEL"],
-          ...d.data.map((s) => [
-            s.id,
-            s.customerId,
-            formatStatus(s.status),
-            formatDate(s.currentPeriodEnd),
-            s.cancelAtPeriodEnd ? "yes" : "no"
-          ])
-        ];
-        return formatTable(rows);
+function registerSubscriptionCommands(program2) {
+  const subscription = program2.command("subscription").description("Manage subscriptions");
+  subscription.command("list").description("List all subscriptions").action(async () => {
+    try {
+      const data = await apiRequest("GET", "/subscriptions");
+      output(data, (d) => {
+        const items = d.data || d.subscriptions || d;
+        if (!Array.isArray(items) || items.length === 0) return "No subscriptions found.";
+        table(
+          ["ID", "Status", "Customer", "Price", "Created"],
+          items.map((s) => [s.id, s.status, s.customerId || "N/A", s.priceId || "N/A", fmtDate(s.createdAt)])
+        );
+        return "";
       });
     } catch (err) {
-      error(err instanceof Error ? err.message : "Failed to list subscriptions");
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
     }
   });
-  subscription.command("get").description("Get subscription details").argument("<id>", "Subscription ID").action(async (id) => {
+  subscription.command("get <id>").description("Get a subscription by ID").action(async (id) => {
     try {
-      const client = new ApiClient();
-      const result = await client.getSubscription(id);
-      output(result, (data) => {
-        const d = data;
-        return [
-          `Subscription: ${d.id}`,
-          ``,
-          `  Customer:     ${d.customerId}`,
-          `  Price:        ${d.priceId}`,
-          `  Status:       ${formatStatus(d.status)}`,
-          `  Period Start: ${formatDate(d.currentPeriodStart)}`,
-          `  Period End:   ${formatDate(d.currentPeriodEnd)}`,
-          d.trialEnd ? `  Trial End:    ${formatDate(d.trialEnd)}` : null,
-          `  Cancel:       ${d.cancelAtPeriodEnd ? "at period end" : "no"}`,
-          `  Created:      ${formatDate(d.createdAt)}`
-        ].filter(Boolean).join("\n");
-      });
+      const data = await apiRequest("GET", `/subscriptions/${id}`);
+      output(data, (d) => [
+        `Subscription ID:    ${d.id}`,
+        `Status:             ${d.status}`,
+        `Customer:           ${d.customerId || "N/A"}`,
+        `Price:              ${d.priceId || "N/A"}`,
+        `Current Period End: ${fmtDate(d.currentPeriodEnd)}`,
+        `Created:            ${fmtDate(d.createdAt)}`
+      ].join("\n"));
     } catch (err) {
-      error(err instanceof Error ? err.message : "Failed to get subscription");
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
     }
   });
-  subscription.command("cancel").description("Cancel a subscription").argument("<id>", "Subscription ID").option("--immediately", "Cancel immediately instead of at period end").action(async (id, options) => {
+  subscription.command("cancel <id>").description("Cancel a subscription").action(async (id) => {
     try {
-      const client = new ApiClient();
-      const result = await client.cancelSubscription(id, options.immediately);
-      output(result, (data) => {
-        const d = data;
-        const when = options.immediately ? "immediately" : "at period end";
-        return [
-          `Subscription ${d.id} will be canceled ${when}.`,
-          ``,
-          `  Status:       ${formatStatus(d.status)}`,
-          `  Cancel:       ${d.cancelAtPeriodEnd ? "at period end" : "immediately"}`,
-          d.canceledAt ? `  Canceled At:  ${formatDate(d.canceledAt)}` : null
-        ].filter(Boolean).join("\n");
-      });
+      await apiRequest("POST", `/subscriptions/${id}/cancel`);
+      success(`Subscription ${id} cancelled`);
     } catch (err) {
-      error(err instanceof Error ? err.message : "Failed to cancel subscription");
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
     }
   });
-  subscription.command("resume").description("Resume a canceled subscription").argument("<id>", "Subscription ID").action(async (id) => {
+  subscription.command("resume <id>").description("Resume a cancelled subscription").action(async (id) => {
     try {
-      const client = new ApiClient();
-      const result = await client.resumeSubscription(id);
-      output(result, (data) => {
-        const d = data;
-        return [
-          `Subscription ${d.id} has been resumed.`,
-          ``,
-          `  Status: ${formatStatus(d.status)}`,
-          `  Cancel: ${d.cancelAtPeriodEnd ? "at period end" : "no"}`
-        ].join("\n");
-      });
+      await apiRequest("POST", `/subscriptions/${id}/resume`);
+      success(`Subscription ${id} resumed`);
     } catch (err) {
-      error(err instanceof Error ? err.message : "Failed to resume subscription");
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
     }
   });
-  return subscription;
 }
 
 // src/commands/customer.ts
-import { Command as Command6 } from "commander";
-function createCustomerCommand() {
-  const customer = new Command6("customer").description("Manage customers");
-  customer.command("create").description("Create a new customer").requiredOption("-e, --email <email>", "Customer email").option("-n, --name <name>", "Customer name").action(async (options) => {
-    try {
-      const client = new ApiClient();
-      const result = await client.createCustomer({
-        email: options.email,
-        name: options.name
-      });
-      output(result, (data) => {
-        const d = data;
-        return [
-          `Customer created!`,
-          ``,
-          `  ID:      ${d.id}`,
-          `  Email:   ${d.email}`,
-          d.name ? `  Name:    ${d.name}` : null,
-          `  Created: ${formatDate(d.createdAt)}`
-        ].filter(Boolean).join("\n");
-      });
+function registerCustomerCommands(program2) {
+  const customer = program2.command("customer").description("Manage customers");
+  customer.command("create").description("Create a new customer").requiredOption("-e, --email <email>", "Customer email").option("-n, --name <name>", "Customer name").action(async (opts) => {
+    try {
+      const body = { email: opts.email };
+      if (opts.name) body.name = opts.name;
+      const data = await apiRequest("POST", "/customers", body);
+      success("Customer created");
+      output(data, (d) => [
+        `Customer ID: ${d.id}`,
+        `Email:       ${d.email}`,
+        `Name:        ${d.name || "N/A"}`
+      ].join("\n"));
     } catch (err) {
-      error(err instanceof Error ? err.message : "Failed to create customer");
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
     }
   });
   customer.command("list").description("List all customers").action(async () => {
     try {
-      const client = new ApiClient();
-      const result = await client.listCustomers();
-      output(result, (data) => {
-        const d = data;
-        if (d.data.length === 0) {
-          return "No customers found.";
-        }
-        const rows = [
-          ["ID", "EMAIL", "NAME", "CREATED"],
-          ...d.data.map((c) => [c.id, c.email, c.name || "-", formatDate(c.createdAt)])
-        ];
-        return formatTable(rows);
+      const data = await apiRequest("GET", "/customers");
+      output(data, (d) => {
+        const items = d.data || d.customers || d;
+        if (!Array.isArray(items) || items.length === 0) return "No customers found.";
+        table(
+          ["ID", "Email", "Name", "Created"],
+          items.map((c) => [c.id, c.email, c.name || "", fmtDate(c.createdAt)])
+        );
+        return "";
       });
     } catch (err) {
-      error(err instanceof Error ? err.message : "Failed to list customers");
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  customer.command("get <id>").description("Get a customer by ID").action(async (id) => {
+    try {
+      const data = await apiRequest("GET", `/customers/${id}`);
+      output(data, (d) => [
+        `Customer ID: ${d.id}`,
+        `Email:       ${d.email}`,
+        `Name:        ${d.name || "N/A"}`,
+        `Created:     ${fmtDate(d.createdAt)}`
+      ].join("\n"));
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
     }
   });
-  customer.command("get").description("Get customer details").argument("<id>", "Customer ID").action(async (id) => {
+  customer.command("portal <id>").description("Create a customer portal session").action(async (id) => {
     try {
-      const client = new ApiClient();
-      const result = await client.getCustomer(id);
-      output(result, (data) => {
-        const d = data;
+      const data = await apiRequest("POST", `/customers/${id}/portal-session`);
+      success("Portal session created");
+      output(data, (d) => `Portal URL: ${d.url || d.portalUrl || JSON.stringify(d)}`);
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/link.ts
+function registerLinkCommands(program2) {
+  const link = program2.command("link").description("Manage payment links");
+  link.command("create <amount>").description("Create a new payment link (amount in cents, e.g. 1000 = $10.00)").option("-c, --currency <currency>", "Currency code", "SGD").option("-n, --name <name>", "Link name").option("-d, --description <description>", "Link description").option("--success-url <url>", "URL to redirect after successful payment").option("--cancel-url <url>", "URL to redirect on cancel").option("--methods <methods>", "Payment methods (comma-separated: card,alipay,paynow,wechat)").action(async (amount, opts) => {
+    try {
+      const body = {
+        amount: parseInt(amount, 10),
+        currency: opts.currency
+      };
+      if (opts.name) body.name = opts.name;
+      if (opts.description) body.description = opts.description;
+      if (opts.successUrl) body.successUrl = opts.successUrl;
+      if (opts.cancelUrl) body.cancelUrl = opts.cancelUrl;
+      if (opts.methods) body.paymentMethodTypes = opts.methods.split(",").map((m) => m.trim());
+      const data = await apiRequest("POST", "/payment_links", body);
+      success("Payment link created");
+      output(data, (d) => {
         return [
-          `Customer: ${d.id}`,
-          ``,
-          `  Email:   ${d.email}`,
-          d.name ? `  Name:    ${d.name}` : null,
-          `  Created: ${formatDate(d.createdAt)}`
+          `Link ID:  ${d.id}`,
+          `URL:      ${d.url || "N/A"}`,
+          `Amount:   ${fmtAmount(d.amount, d.currency)}`,
+          d.description ? `Desc:     ${d.description}` : null
         ].filter(Boolean).join("\n");
       });
     } catch (err) {
-      error(err instanceof Error ? err.message : "Failed to get customer");
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
     }
   });
-  customer.command("portal").description("Create a customer portal session").argument("<id>", "Customer ID").option("-r, --return-url <url>", "Return URL after portal session").action(async (id, options) => {
+  link.command("list").description("List all payment links").action(async () => {
     try {
-      const client = new ApiClient();
-      const result = await client.createPortalSession(id, options.returnUrl);
-      output(result, (data) => {
-        const d = data;
+      const data = await apiRequest("GET", "/payment_links");
+      output(data, (d) => {
+        const items = d.data || d.paymentLinks || d;
+        if (!Array.isArray(items) || items.length === 0) return "No payment links found.";
+        table(
+          ["ID", "Amount", "Active", "Description", "Created"],
+          items.map((l) => [
+            l.id,
+            fmtAmount(l.amount, l.currency),
+            l.active ? "yes" : "no",
+            l.description || "",
+            fmtDate(l.createdAt)
+          ])
+        );
+        return "";
+      });
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  link.command("get <id>").description("Get a payment link by ID").action(async (id) => {
+    try {
+      const data = await apiRequest("GET", `/payment_links/${id}`);
+      output(data, (d) => {
         return [
-          `Portal session created!`,
-          ``,
-          `  ID:      ${d.id}`,
-          `  URL:     ${d.url}`,
-          `  Expires: ${formatDate(d.expiresAt)}`
+          `Link ID:  ${d.id}`,
+          `URL:      ${d.url || "N/A"}`,
+          `Amount:   ${fmtAmount(d.amount, d.currency)}`,
+          `Active:   ${d.active ? "yes" : "no"}`,
+          `Desc:     ${d.description || "N/A"}`,
+          `Created:  ${fmtDate(d.createdAt)}`
         ].join("\n");
       });
     } catch (err) {
-      error(err instanceof Error ? err.message : "Failed to create portal session");
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  link.command("deactivate <id>").description("Deactivate a payment link").action(async (id) => {
+    try {
+      await apiRequest("PATCH", `/payment_links/${id}`, { active: false });
+      success(`Payment link ${id} deactivated`);
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  link.command("activate <id>").description("Activate a payment link").action(async (id) => {
+    try {
+      await apiRequest("PATCH", `/payment_links/${id}`, { active: true });
+      success(`Payment link ${id} activated`);
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
     }
   });
-  return customer;
 }
 
 // src/commands/create.ts
-import { Command as Command7 } from "commander";
-function createQuickCreateCommand() {
-  const create = new Command7("create").description("Quick command to create a checkout session").argument("<amount>", "Amount to charge (e.g., 9.99)").option("-d, --description <desc>", "Product/payment description").option("--monthly", "Create a monthly subscription").option("--yearly", "Create a yearly subscription").option("--weekly", "Create a weekly subscription").option("--trial-days <days>", "Trial period in days (for subscriptions)").option("--success-url <url>", "Success redirect URL").option("--cancel-url <url>", "Cancel redirect URL").option("--email <email>", "Customer email").action(
-    async (amountStr, options) => {
-      try {
-        const client = new ApiClient();
-        const amount = parseAmountToCents(amountStr);
-        let mode = "payment";
-        let interval;
-        if (options.monthly || options.yearly || options.weekly) {
-          mode = "subscription";
-          if (options.monthly) interval = "month";
-          else if (options.yearly) interval = "year";
-          else if (options.weekly) interval = "week";
-        }
-        if (mode === "subscription") {
-          const product = await client.createProduct({
-            name: options.description || "Subscription"
-          });
-          const price = await client.createPrice({
-            productId: product.id,
-            amount,
-            currency: "USD",
-            type: "recurring",
-            interval,
-            trialPeriodDays: options.trialDays ? parseInt(options.trialDays, 10) : void 0
-          });
-          const session = await client.createCheckoutSession({
-            mode: "subscription",
-            priceId: price.id,
-            successUrl: options.successUrl,
-            cancelUrl: options.cancelUrl,
-            customerEmail: options.email
-          });
-          output(
-            {
-              product,
-              price,
-              session
-            },
-            (data) => {
-              const d = data;
-              return [
-                `Subscription checkout created!`,
-                ``,
-                `  Product:  ${d.product.name} (${d.product.id})`,
-                `  Price:    ${formatCurrency(d.price.amount, d.price.currency)}/${d.price.interval} (${d.price.id})`,
-                ``,
-                `  Session:  ${d.session.id}`,
-                `  Status:   ${formatStatus(d.session.status)}`,
-                `  URL:      ${d.session.url}`,
-                `  Expires:  ${formatDate(d.session.expiresAt)}`
-              ].join("\n");
-            }
-          );
-        } else {
-          const session = await client.createCheckoutSession({
-            mode: "payment",
-            lineItems: [
-              {
-                description: options.description,
-                amount,
-                currency: "USD",
-                quantity: 1
-              }
-            ],
-            successUrl: options.successUrl,
-            cancelUrl: options.cancelUrl,
-            customerEmail: options.email
-          });
-          output(session, (data) => {
-            const d = data;
-            return [
-              `Payment checkout created!`,
-              ``,
-              `  Session: ${d.id}`,
-              `  Amount:  ${formatCurrency(d.amountTotal || 0, d.currency || "USD")}`,
-              `  Status:  ${formatStatus(d.status)}`,
-              `  URL:     ${d.url}`,
-              `  Expires: ${formatDate(d.expiresAt)}`
-            ].join("\n");
-          });
+import { createInterface } from "readline";
+function prompt(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+function registerCreateCommand(program2) {
+  program2.command("create").description("Quick create: product + price + checkout session in one go").action(async () => {
+    try {
+      const productName = await prompt("Product name: ");
+      if (!productName) {
+        console.error("Product name is required.");
+        process.exit(1);
+      }
+      const amountStr = await prompt("Amount (in smallest currency unit, e.g. 1000 for $10.00): ");
+      const amount = parseInt(amountStr, 10);
+      if (isNaN(amount) || amount <= 0) {
+        console.error("Invalid amount.");
+        process.exit(1);
+      }
+      const currency = await prompt("Currency (default: SGD): ") || "SGD";
+      const type = await prompt("Type (one_time or recurring): ");
+      if (type !== "one_time" && type !== "recurring") {
+        console.error('Type must be "one_time" or "recurring".');
+        process.exit(1);
+      }
+      let interval;
+      if (type === "recurring") {
+        interval = await prompt("Billing interval (month or year): ");
+        if (interval !== "month" && interval !== "year") {
+          console.error('Interval must be "month" or "year".');
+          process.exit(1);
         }
-      } catch (err) {
-        error(err instanceof Error ? err.message : "Failed to create checkout");
       }
+      const successUrl = await prompt("Success URL (default: https://example.com/success): ") || "https://example.com/success";
+      const cancelUrl = await prompt("Cancel URL (default: https://example.com/cancel): ") || "https://example.com/cancel";
+      console.log("\nCreating product...");
+      const product = await apiRequest("POST", "/products", { name: productName });
+      success(`Product created: ${product.id}`);
+      console.log("Creating price...");
+      const priceBody = {
+        productId: product.id,
+        amount,
+        type,
+        currency
+      };
+      if (interval) priceBody.interval = interval;
+      const price = await apiRequest("POST", "/prices", priceBody);
+      success(`Price created: ${price.id}`);
+      console.log("Creating checkout session...");
+      const session = await apiRequest("POST", "/checkout/sessions", {
+        priceId: price.id,
+        successUrl,
+        cancelUrl
+      });
+      success(`Checkout session created: ${session.id}`);
+      const checkoutUrl = session.url || session.checkoutUrl;
+      if (checkoutUrl) {
+        console.log(`
+Checkout URL: ${checkoutUrl}`);
+      }
+      output({
+        product: { id: product.id, name: productName },
+        price: { id: price.id, amount, currency, type, interval },
+        checkout: { id: session.id, url: checkoutUrl }
+      });
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
     }
-  );
-  return create;
+  });
 }
 
-// src/commands/link.ts
-import { Command as Command8 } from "commander";
-function createLinkCommand() {
-  const link = new Command8("link").description("Manage payment links (reusable payment URLs)");
-  link.command("create").description("Create a new payment link").argument("<amount>", "Amount in dollars (e.g., 9.99)").option("-c, --currency <currency>", "Currency code (default: USD)", "USD").option("-n, --name <name>", "Product/payment name").option("-d, --description <description>", "Description").option("--success-url <url>", "Redirect URL after successful payment").option("--cancel-url <url>", "Redirect URL if customer cancels").action(
-    async (amountStr, options) => {
-      try {
-        const amount = parseAmountToCents(amountStr);
-        const client = new ApiClient();
-        const result = await client.createPaymentLink({
-          amount,
-          currency: options.currency,
-          name: options.name,
-          description: options.description,
-          successUrl: options.successUrl,
-          cancelUrl: options.cancelUrl
-        });
-        output(result, (data) => {
-          const d = data;
-          return [
-            `Payment Link created!`,
-            ``,
-            `  ID:          ${d.id}`,
-            d.name ? `  Name:        ${d.name}` : null,
-            d.description ? `  Description: ${d.description}` : null,
-            `  Amount:      ${formatAmount2(d.amount, d.currency)}`,
-            `  URL:         ${d.url}`,
-            `  Active:      ${d.active}`,
-            `  Created:     ${formatDate(d.createdAt)}`,
-            ``,
-            `Share this URL with customers - each visitor gets their own checkout session.`
-          ].filter(Boolean).join("\n");
-        });
-      } catch (err) {
-        error(err instanceof Error ? err.message : "Failed to create payment link");
-      }
+// src/commands/payout.ts
+function registerPayoutCommands(program2) {
+  const payout = program2.command("payout").description("Manage payouts");
+  payout.command("list").description("List all payouts").action(async () => {
+    try {
+      const data = await apiRequest("GET", "/payouts");
+      output(data, (d) => {
+        const items = d.data || d.payouts || d;
+        if (!Array.isArray(items) || items.length === 0) return "No payouts found.";
+        table(
+          ["ID", "Amount", "Status", "Created"],
+          items.map((p) => [p.id, fmtAmount(p.amount, p.currency), p.status, fmtDate(p.createdAt)])
+        );
+        return "";
+      });
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
     }
-  );
-  link.command("list").description("List all payment links").action(async () => {
+  });
+  payout.command("create").description("Create a new payout").requiredOption("-a, --amount <amount>", "Payout amount in cents (e.g. 1000 = $10.00)").requiredOption("-b, --bank-account-id <bankAccountId>", "Bank account ID").action(async (opts) => {
     try {
-      const client = new ApiClient();
-      const result = await client.listPaymentLinks();
-      output(result, (data) => {
-        const d = data;
-        if (d.data.length === 0) {
-          return "No payment links found.";
-        }
-        const rows = [
-          ["ID", "NAME", "AMOUNT", "ACTIVE", "URL"],
-          ...d.data.map((l) => [
-            l.id,
-            l.name || "-",
-            formatAmount2(l.amount, l.currency),
-            l.active ? "yes" : "no",
-            l.url
+      const body = {
+        amount: parseInt(opts.amount, 10),
+        bankAccountId: opts.bankAccountId
+      };
+      const data = await apiRequest("POST", "/payouts", body);
+      success("Payout created");
+      output(data, (d) => [
+        `Payout ID: ${d.id}`,
+        `Amount:    ${fmtAmount(d.amount, d.currency)}`,
+        `Status:    ${d.status}`
+      ].join("\n"));
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  payout.command("cancel <id>").description("Cancel a payout").action(async (id) => {
+    try {
+      await apiRequest("POST", `/payouts/${id}/cancel`);
+      success(`Payout ${id} cancelled`);
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  payout.command("status").description("Check payout eligibility").action(async () => {
+    try {
+      const data = await apiRequest("GET", "/payouts/eligibility");
+      output(data, (d) => [
+        `Eligible:          ${d.eligible ?? "N/A"}`,
+        `Available Balance: ${fmtAmount(d.availableBalance)}`,
+        `Minimum Payout:    ${fmtAmount(d.minimumPayout)}`
+      ].join("\n"));
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/bank.ts
+import { createInterface as createInterface2 } from "readline";
+function prompt2(question) {
+  const rl = createInterface2({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+function registerBankCommands(program2) {
+  const bank = program2.command("bank").description("Manage bank accounts");
+  bank.command("list").description("List all bank accounts").action(async () => {
+    try {
+      const data = await apiRequest("GET", "/bank-accounts");
+      output(data, (d) => {
+        const items = d.data || d.bankAccounts || d;
+        if (!Array.isArray(items) || items.length === 0) return "No bank accounts found.";
+        table(
+          ["ID", "Bank Name", "Last 4", "Default", "Created"],
+          items.map((b) => [
+            b.id,
+            b.bankName || "N/A",
+            b.last4 || "N/A",
+            b.isDefault ? "yes" : "no",
+            fmtDate(b.createdAt)
           ])
-        ];
-        return formatTable(rows);
+        );
+        return "";
+      });
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  bank.command("add").description("Add a new bank account").action(async () => {
+    try {
+      const accountHolderName = await prompt2("Account holder name: ");
+      const bankName = await prompt2("Bank name: ");
+      const routingNumber = await prompt2("Routing number: ");
+      const accountNumber = await prompt2("Account number: ");
+      const accountType = await prompt2("Account type (checking/savings, default: checking): ") || "checking";
+      const body = {
+        accountHolderName,
+        bankName,
+        routingNumber,
+        accountNumber,
+        accountType
+      };
+      const data = await apiRequest("POST", "/bank-accounts", body);
+      success("Bank account added");
+      output(data, (d) => [
+        `Bank Account ID: ${d.id}`,
+        `Bank:            ${d.bankName || bankName}`,
+        `Last 4:          ${d.last4 || "N/A"}`
+      ].join("\n"));
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  bank.command("remove <id>").description("Remove a bank account").action(async (id) => {
+    try {
+      await apiRequest("DELETE", `/bank-accounts/${id}`);
+      success(`Bank account ${id} removed`);
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  bank.command("set-default <id>").description("Set a bank account as default").action(async (id) => {
+    try {
+      await apiRequest("PATCH", `/bank-accounts/${id}`, { isDefault: true });
+      success(`Bank account ${id} set as default`);
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/kyc.ts
+import { createInterface as createInterface3 } from "readline";
+function prompt3(question) {
+  const rl = createInterface3({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve(answer.trim());
+    });
+  });
+}
+function registerKycCommands(program2) {
+  const kyc = program2.command("kyc").description("Manage KYC verification");
+  kyc.command("submit").description("Submit KYC verification details").action(async () => {
+    try {
+      const fullName = await prompt3("Full name: ");
+      const dateOfBirth = await prompt3("Date of birth (YYYY-MM-DD): ");
+      const address = await prompt3("Street address: ");
+      const city = await prompt3("City: ");
+      const state = await prompt3("State/Province: ");
+      const postalCode = await prompt3("Postal code: ");
+      const country = await prompt3("Country (2-letter code, e.g. SG): ");
+      const body = {
+        fullName,
+        dateOfBirth,
+        address: {
+          line1: address,
+          city,
+          state,
+          postalCode,
+          country
+        }
+      };
+      const data = await apiRequest("POST", "/kyc", body);
+      success("KYC submission received");
+      output(data, (d) => {
+        return [
+          `KYC ID: ${d.id || "N/A"}`,
+          `Status: ${d.status || "pending"}`
+        ].join("\n");
       });
     } catch (err) {
-      error(err instanceof Error ? err.message : "Failed to list payment links");
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
     }
   });
-  link.command("get").description("Get payment link details").argument("<id>", "Payment Link ID").action(async (id) => {
+  kyc.command("status").description("Check KYC verification status").action(async () => {
     try {
-      const client = new ApiClient();
-      const result = await client.getPaymentLink(id);
-      output(result, (data) => {
-        const d = data;
+      const data = await apiRequest("GET", "/kyc/status");
+      output(data, (d) => {
         return [
-          `Payment Link: ${d.id}`,
-          ``,
-          d.name ? `  Name:        ${d.name}` : null,
-          d.description ? `  Description: ${d.description}` : null,
-          `  Amount:      ${formatAmount2(d.amount, d.currency)}`,
-          `  URL:         ${d.url}`,
-          `  Active:      ${d.active}`,
-          d.successUrl ? `  Success URL: ${d.successUrl}` : null,
-          `  Created:     ${formatDate(d.createdAt)}`
-        ].filter(Boolean).join("\n");
+          `Status: ${d.status || "N/A"}`,
+          `Verified: ${d.verified ?? "N/A"}`,
+          `Requirements: ${d.requirements ? JSON.stringify(d.requirements) : "None"}`
+        ].join("\n");
       });
     } catch (err) {
-      error(err instanceof Error ? err.message : "Failed to get payment link");
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
     }
   });
-  link.command("deactivate").description("Deactivate a payment link").argument("<id>", "Payment Link ID").action(async (id) => {
+}
+
+// src/commands/webhook.ts
+function registerWebhookCommands(program2) {
+  const webhook = program2.command("webhook").description("Manage webhook configuration");
+  webhook.command("set <url>").description("Set webhook URL for your wallet (must be HTTPS)").action(async (url) => {
     try {
-      const client = new ApiClient();
-      const result = await client.updatePaymentLink(id, { active: false });
-      output(result, (data) => {
-        const d = data;
-        return `Payment link ${d.id} has been deactivated.`;
+      if (!url.startsWith("https://")) {
+        console.error("Error: webhook URL must start with https://");
+        process.exit(1);
+      }
+      const data = await apiRequest("PATCH", "/wallets/current", {
+        webhookUrl: url
       });
+      success("Webhook configured");
+      console.log(`  URL:    ${data.webhookUrl}`);
+      if (data.webhookSecret) {
+        console.log(`  Secret: ${data.webhookSecret}`);
+        console.log("\nSave the secret \u2014 it will not be shown again.");
+        console.log("Use client.webhooks.constructEvent(body, signature, secret) in your server.");
+      }
     } catch (err) {
-      error(err instanceof Error ? err.message : "Failed to deactivate payment link");
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
     }
   });
-  link.command("activate").description("Activate a payment link").argument("<id>", "Payment Link ID").action(async (id) => {
+  webhook.command("info").description("Show current webhook configuration").action(async () => {
     try {
-      const client = new ApiClient();
-      const result = await client.updatePaymentLink(id, { active: true });
-      output(result, (data) => {
-        const d = data;
-        return `Payment link ${d.id} has been activated.`;
+      const data = await apiRequest("GET", "/wallets/current");
+      if (data.webhookUrl) {
+        console.log(`Webhook URL: ${data.webhookUrl}`);
+        console.log("Status: configured");
+      } else {
+        console.log("No webhook configured.");
+        console.log("Run: vibecash webhook set <url>");
+      }
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  webhook.command("remove").description("Remove webhook configuration").action(async () => {
+    try {
+      await apiRequest("PATCH", "/wallets/current", {
+        webhookUrl: null
       });
+      success("Webhook removed");
     } catch (err) {
-      error(err instanceof Error ? err.message : "Failed to activate payment link");
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
     }
   });
-  return link;
+  webhook.command("roll-secret").description("Generate a new webhook signing secret (invalidates the old one)").action(async () => {
+    try {
+      const wallet = await apiRequest("GET", "/wallets/current");
+      if (!wallet.webhookUrl) {
+        console.error("No webhook configured. Run: vibecash webhook set <url>");
+        process.exit(1);
+      }
+      const data = await apiRequest("PATCH", "/wallets/current", {
+        webhookUrl: wallet.webhookUrl
+      });
+      success("New secret generated");
+      console.log(`  URL:    ${data.webhookUrl}`);
+      if (data.webhookSecret) {
+        console.log(`  Secret: ${data.webhookSecret}`);
+        console.log("\nSave the new secret \u2014 it will not be shown again.");
+        console.log("The old secret is now invalid.");
+      }
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  webhook.command("events").description("Webhook event types reference").action(() => {
+    console.log("VibeCash Webhook Event Types\n");
+    console.log("Payment Events:");
+    console.log("  payment.succeeded    \u2014 Customer payment completed successfully");
+    console.log("  payment.failed       \u2014 Customer payment failed\n");
+    console.log("Subscription Events:");
+    console.log("  subscription.renewed       \u2014 Subscription auto-renewed");
+    console.log("  subscription.past_due      \u2014 Subscription payment overdue");
+    console.log("  subscription.unpaid        \u2014 Subscription marked unpaid");
+    console.log("  subscription.trial_ending  \u2014 Trial period ending soon\n");
+    console.log("Checkout Events:");
+    console.log("  checkout.session.expired   \u2014 Checkout session expired\n");
+    console.log("Payload Format:");
+    console.log("  {");
+    console.log('    "id": "evt_xxx",');
+    console.log('    "type": "payment.succeeded",');
+    console.log('    "created": 1710000000,');
+    console.log('    "data": { "object": { ...full resource... } }');
+    console.log("  }\n");
+    console.log("Signature Header:");
+    console.log("  VibeCash-Signature: t={timestamp},v1={hmac-sha256-hex}");
+  });
 }
 
 // src/index.ts
-var program = new Command9();
-program.name("vibecash").description("VibeCash - Payment infrastructure for AI agents").version("0.1.3");
-program.addCommand(createWalletCommand());
-program.addCommand(createProductCommand());
-program.addCommand(createPriceCommand());
-program.addCommand(createCheckoutCommand());
-program.addCommand(createSubscriptionCommand());
-program.addCommand(createCustomerCommand());
-program.addCommand(createQuickCreateCommand());
-program.addCommand(createLinkCommand());
-program.option("--human", "Output in human-readable format");
-program.option("--json", "Output in JSON format (default)");
-program.hook("preAction", (thisCommand) => {
+var program = new Command();
+program.name("vibecash").description("VibeCash CLI - manage payments from the command line").version("0.2.1").option("--json", "Output in JSON format").hook("preAction", (thisCommand) => {
   const opts = thisCommand.opts();
-  if (opts.human) {
-    process.env.AIPAY_OUTPUT = "human";
-  } else if (opts.json) {
-    process.env.AIPAY_OUTPUT = "json";
-  }
+  if (opts.json) setOutputFormat("json");
 });
+registerWalletCommands(program);
+registerProductCommands(program);
+registerPriceCommands(program);
+registerCheckoutCommands(program);
+registerSubscriptionCommands(program);
+registerCustomerCommands(program);
+registerLinkCommands(program);
+registerCreateCommand(program);
+registerPayoutCommands(program);
+registerBankCommands(program);
+registerKycCommands(program);
+registerWebhookCommands(program);
 program.parse();