@uniwebpay/cli 0.1.0

package/dist/index.js

@@ -0,0 +1,1310 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/config.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var CONFIG_DIR = join(homedir(), ".uniweb");
+var CONFIG_FILE = join(CONFIG_DIR, "config.json");
+function getConfig() {
+  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 });
+  writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+function getSecret() {
+  return process.env.UNIWEB_SECRET || getConfig().secret;
+}
+function setSecret(secret, options) {
+  const config = getConfig();
+  config.secret = secret;
+  config.apiUrl = options?.apiUrl ?? config.apiUrl ?? getApiUrl();
+  config.payUrl = options?.payUrl ?? config.payUrl ?? getPayUrl();
+  saveConfig(config);
+}
+function getApiUrl() {
+  return process.env.UNIWEB_API_URL || getConfig().apiUrl || "https://apiskill.uniwebpay.com";
+}
+function getPayUrl() {
+  return process.env.UNIWEB_PAY_URL || getConfig().payUrl || "https://skill.uniwebpay.com";
+}
+var _overrideFormat;
+function setOutputFormat(format) {
+  _overrideFormat = format;
+}
+function getOutputFormat() {
+  if (_overrideFormat) return _overrideFormat;
+  const env = process.env.UNIWEB_OUTPUT;
+  if (env === "json" || env === "human") return env;
+  return getConfig().outputFormat || "human";
+}
+
+// src/api-client.ts
+async function apiRequest(method, path, body) {
+  const secret = getSecret();
+  if (!secret) {
+    console.error("No API key found. Set UNIWEB_SECRET or run `uniweb 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}`);
+  }
+  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 isJsonOutput() {
+  return getOutputFormat() === "json";
+}
+function output(data, humanFormatter) {
+  if (isJsonOutput()) {
+    console.log(JSON.stringify(data, null, 2));
+  } else if (humanFormatter) {
+    console.log(humanFormatter(data));
+  } else {
+    console.log(JSON.stringify(data, null, 2));
+  }
+}
+function success(message) {
+  if (!isJsonOutput()) {
+    console.log(`\u2713 ${message}`);
+  }
+}
+function info(message) {
+  if (!isJsonOutput()) {
+    console.log(message);
+  }
+}
+function writeInfo(message) {
+  if (isJsonOutput()) {
+    process.stderr.write(message);
+  } else {
+    process.stdout.write(message);
+  }
+}
+function jsonOnly(data) {
+  if (isJsonOutput()) {
+    output(data);
+  }
+}
+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 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 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 registerWalletCommands(program2) {
+  const wallet = program2.command("wallet").description("Manage your wallet");
+  wallet.command("create").description("Create a new wallet").action(async () => {
+    try {
+      const data = await apiRequestNoAuth("POST", "/wallets");
+      if (data.secret) {
+        setSecret(data.secret, {
+          apiUrl: data.apiUrl || getApiUrl(),
+          payUrl: data.payUrl
+        });
+        success("Wallet created! API key saved to ~/.uniweb/config.json");
+      }
+      output(data, (d) => {
+        const w = d.wallet || d;
+        return [
+          `Wallet ID:  ${w.id}`,
+          `Status:     ${w.status || "active"}`,
+          `Currency:   ${w.currency || "SGD"}`
+        ].join("\n");
+      });
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  wallet.command("info").description("Get current wallet info").action(async () => {
+    try {
+      const data = await apiRequest("GET", "/wallets/current");
+      output(data, (d) => {
+        return [
+          `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) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  wallet.command("claim").description("Generate a claim link for your wallet").action(async () => {
+    try {
+      const data = await apiRequest("POST", "/wallets/current/claim_link");
+      output(data, (d) => {
+        return [
+          `Claim URL:   ${d.claimUrl || "N/A"}`,
+          `Claim Token: ${d.claimToken || "N/A"}`,
+          `Expires At:  ${d.expiresAt ? fmtDate(d.expiresAt) : "N/A"}`
+        ].join("\n");
+      });
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/product.ts
+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").option("-w, --webhook-url <url>", "Webhook URL for this product").action(async (name, opts) => {
+    try {
+      const body = { name };
+      if (opts.description) body.description = opts.description;
+      if (opts.webhookUrl) body.webhookUrl = opts.webhookUrl;
+      const data = await apiRequest("POST", "/products", body);
+      success("Product created");
+      output(data, (d) => `Product ID: ${d.id}
+Name:       ${d.name}${d.webhookUrl ? "\nWebhook:    " + d.webhookUrl : ""}`);
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  product.command("list").description("List all products").action(async () => {
+    try {
+      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", "Active", "Created"],
+          items.map((p) => [p.id, p.name, p.active ? "yes" : "no", fmtDate(p.createdAt)])
+        );
+        return "";
+      });
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  product.command("get <id>").description("Get a product by ID").action(async (id) => {
+    try {
+      const data = await apiRequest("GET", `/products/${id}`);
+      output(data, (d) => [
+        `Product ID:  ${d.id}`,
+        `Name:        ${d.name}`,
+        `Description: ${d.description || "N/A"}`,
+        `Active:      ${d.active ? "yes" : "no"}`,
+        `Webhook:     ${d.webhookUrl || "N/A (using wallet default)"}`,
+        `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").option("-w, --webhook-url <url>", "Webhook URL for this product").action(async (id, opts) => {
+    try {
+      const body = {};
+      if (opts.name) body.name = opts.name;
+      if (opts.description) body.description = opts.description;
+      if (opts.webhookUrl) body.webhookUrl = opts.webhookUrl;
+      const data = await apiRequest("PATCH", `/products/${id}`, body);
+      success("Product updated");
+      jsonOnly(data ?? { ok: true, id });
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  product.command("delete <id>").description("Archive a product").action(async (id) => {
+    try {
+      const data = await apiRequest("DELETE", `/products/${id}`);
+      success(`Product ${id} archived`);
+      jsonOnly(data ?? { ok: true, id });
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/price.ts
+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) => {
+        const payUrl = getPayUrl();
+        return [
+          `Price ID:    ${d.id}`,
+          `Amount:      ${fmtAmount(d.unitAmount ?? d.amount, d.currency)}${d.interval ? "/" + d.interval : ""}`,
+          `Type:        ${d.type}`,
+          `Payment URL: ${payUrl}/buy/${d.id}`
+        ].join("\n");
+      });
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  price.command("list").description("List all prices").action(async () => {
+    try {
+      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,
+            fmtAmount(p.unitAmount ?? p.amount, p.currency),
+            p.type,
+            p.interval || "-"
+          ])
+        );
+        return "";
+      });
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/checkout.ts
+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").option("--customer-id <id>", "Customer ID (optional, auto-created from email at payment time)").option("--trial-days <days>", "Trial period in days (subscription mode)").action(async (opts) => {
+    try {
+      const body = {
+        mode: opts.mode,
+        lineItems: [{ priceId: opts.priceId, quantity: parseInt(opts.quantity, 10) }],
+        successUrl: opts.successUrl,
+        cancelUrl: opts.cancelUrl
+      };
+      if (opts.mode === "subscription") {
+        body.paymentMethodTypes = ["card"];
+      } else {
+        body.paymentMethodTypes = opts.methods.split(",").map((m) => m.trim());
+      }
+      if (opts.customerId) body.customerId = opts.customerId;
+      if (opts.trialDays) body.trialPeriodDays = parseInt(opts.trialDays, 10);
+      const data = await apiRequest("POST", "/checkout/sessions", body);
+      success("Checkout session created");
+      output(data, (d) => {
+        const lines = [
+          `Session ID:   ${d.id}`,
+          `Mode:         ${d.mode}`,
+          `Checkout URL: ${d.url || d.checkoutUrl || "N/A"}`
+        ];
+        if (d.mode === "subscription") lines.push(`(Subscription \u2014 customer will be created from email at checkout)`);
+        return lines.join("\n");
+      });
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  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;
+      info(`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();
+        writeInfo(`\r[${ts}] Status: ${status}  `);
+        if (status !== "open") {
+          info("\n");
+          output(data, formatSession);
+          break;
+        }
+        await new Promise((r) => setTimeout(r, intervalMs));
+      }
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/subscription.ts
+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) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  subscription.command("get <id>").description("Get a subscription by ID").action(async (id) => {
+    try {
+      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) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  subscription.command("cancel <id>").description("Cancel a subscription immediately").action(async (id) => {
+    try {
+      const data = await apiRequest("DELETE", `/subscriptions/${id}`);
+      success(`Subscription ${id} cancelled`);
+      jsonOnly(data ?? { ok: true, id });
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  subscription.command("pause <id>").description("Set subscription to cancel at end of current period").action(async (id) => {
+    try {
+      const data = await apiRequest("PATCH", `/subscriptions/${id}`, { cancelAtPeriodEnd: true });
+      success(`Subscription ${id} will cancel at period end`);
+      jsonOnly(data ?? { ok: true, id });
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  subscription.command("resume <id>").description("Resume a subscription set to cancel at period end").action(async (id) => {
+    try {
+      const data = await apiRequest("PATCH", `/subscriptions/${id}`, { cancelAtPeriodEnd: false });
+      success(`Subscription ${id} resumed`);
+      jsonOnly(data ?? { ok: true, id });
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/customer.ts
+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) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  customer.command("list").description("List all customers").action(async () => {
+    try {
+      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) {
+      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("delete <id>").description("Delete a customer").action(async (id) => {
+    try {
+      const data = await apiRequest("DELETE", `/customers/${id}`);
+      success(`Customer ${id} deleted`);
+      jsonOnly(data ?? { ok: true, id });
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  customer.command("update <id>").description("Update a customer").option("-e, --email <email>", "New email").option("-n, --name <name>", "New name").action(async (id, opts) => {
+    try {
+      const body = {};
+      if (opts.email) body.email = opts.email;
+      if (opts.name) body.name = opts.name;
+      if (Object.keys(body).length === 0) {
+        console.error("Provide at least --email or --name to update.");
+        process.exit(1);
+      }
+      const data = await apiRequest("PATCH", `/customers/${id}`, body);
+      success("Customer updated");
+      output(data, (d) => [
+        `Customer ID: ${d.id}`,
+        `Email:       ${d.email}`,
+        `Name:        ${d.name || "N/A"}`
+      ].join("\n"));
+    } 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)").option("-w, --webhook-url <url>", "Webhook URL for this payment link").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());
+      if (opts.webhookUrl) body.webhookUrl = opts.webhookUrl;
+      const data = await apiRequest("POST", "/payment_links", body);
+      success("Payment link created");
+      output(data, (d) => {
+        return [
+          `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) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  link.command("list").description("List all payment links").action(async () => {
+    try {
+      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 [
+          `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"}`,
+          `Webhook:  ${d.webhookUrl || "N/A (using wallet default)"}`,
+          `Created:  ${fmtDate(d.createdAt)}`
+        ].join("\n");
+      });
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  link.command("update <id>").description("Update a payment link").option("-n, --name <name>", "New link name").option("-d, --description <description>", "New description").option("--success-url <url>", "Success redirect URL").option("--cancel-url <url>", "Cancel redirect URL").option("-w, --webhook-url <url>", "Webhook URL").action(async (id, opts) => {
+    try {
+      const body = {};
+      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.webhookUrl) body.webhookUrl = opts.webhookUrl;
+      const data = await apiRequest("PATCH", `/payment_links/${id}`, body);
+      success("Payment link updated");
+      jsonOnly(data ?? { ok: true, id });
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  link.command("deactivate <id>").description("Deactivate a payment link").action(async (id) => {
+    try {
+      const data = await apiRequest("PATCH", `/payment_links/${id}`, { active: false });
+      success(`Payment link ${id} deactivated`);
+      jsonOnly(data ?? { ok: true, id });
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  link.command("activate <id>").description("Activate a payment link").action(async (id) => {
+    try {
+      const data = await apiRequest("PATCH", `/payment_links/${id}`, { active: true });
+      success(`Payment link ${id} activated`);
+      jsonOnly(data ?? { ok: true, id });
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/create.ts
+import { createInterface } from "readline";
+function prompt(question) {
+  const rl = createInterface({ input: process.stdin, output: isJsonOutput() ? process.stderr : 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 unitAmount = parseInt(amountStr, 10);
+      if (isNaN(unitAmount) || unitAmount <= 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);
+        }
+      }
+      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";
+      info("\nCreating product...");
+      const product = await apiRequest("POST", "/products", { name: productName });
+      success(`Product created: ${product.id}`);
+      info("Creating price...");
+      const priceBody = {
+        productId: product.id,
+        unitAmount,
+        type,
+        currency
+      };
+      if (interval) priceBody.interval = interval;
+      const price = await apiRequest("POST", "/prices", priceBody);
+      success(`Price created: ${price.id}`);
+      info("Creating checkout session...");
+      const mode = type === "recurring" ? "subscription" : "payment";
+      const session = await apiRequest("POST", "/checkout/sessions", {
+        mode,
+        lineItems: [{ priceId: price.id, quantity: 1 }],
+        successUrl,
+        cancelUrl
+      });
+      success(`Checkout session created: ${session.id}`);
+      const checkoutUrl = session.url || session.checkoutUrl;
+      if (checkoutUrl) {
+        info(`
+Checkout URL: ${checkoutUrl}`);
+      }
+      output({
+        product: { id: product.id, name: productName },
+        price: { id: price.id, unitAmount, currency, type, interval },
+        checkout: { id: session.id, url: checkoutUrl }
+      });
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+}
+
+// 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);
+    }
+  });
+  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 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 {
+      const data = await apiRequest("POST", `/payouts/${id}/cancel`);
+      success(`Payout ${id} cancelled`);
+      jsonOnly(data ?? { ok: true, id });
+    } 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: isJsonOutput() ? process.stderr : 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 "";
+      });
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  bank.command("add").description("Add a new bank account").action(async () => {
+    try {
+      const accountName = await prompt2("Account holder name: ");
+      const bankName = await prompt2("Bank name: ");
+      const bankCode = await prompt2("Bank code / routing number (press Enter to skip): ");
+      const accountNumber = await prompt2("Account number: ");
+      const currency = await prompt2("Currency (default: SGD): ") || "SGD";
+      const body = {
+        accountName,
+        bankName,
+        accountNumber,
+        currency
+      };
+      if (bankCode) body.bankCode = bankCode;
+      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 {
+      const data = await apiRequest("DELETE", `/bank_accounts/${id}`);
+      success(`Bank account ${id} removed`);
+      jsonOnly(data ?? { ok: true, id });
+    } 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 {
+      const data = await apiRequest("PATCH", `/bank_accounts/${id}`, { isDefault: true });
+      success(`Bank account ${id} set as default`);
+      jsonOnly(data ?? { ok: true, id });
+    } 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: isJsonOutput() ? process.stderr : 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 nationality = await prompt3("Nationality (2-letter code, e.g. SG): ");
+      const documentType = await prompt3("Document type (passport / national_id / drivers_license): ");
+      const documentNumber = await prompt3("Document number: ");
+      const documentFrontUrl = await prompt3("Document front image URL: ");
+      const documentBackUrl = await prompt3("Document back image URL (press Enter to skip): ");
+      const body = {
+        fullName,
+        dateOfBirth,
+        nationality,
+        documentType,
+        documentNumber,
+        documentFrontUrl
+      };
+      if (documentBackUrl) body.documentBackUrl = documentBackUrl;
+      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) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  kyc.command("status").description("Check KYC verification status").action(async () => {
+    try {
+      const data = await apiRequest("GET", "/kyc/status");
+      output(data, (d) => {
+        return [
+          `Account ID: ${d.accountId || "N/A"}`,
+          `KYC Status: ${d.kycStatus || "N/A"}`
+        ].join("\n");
+      });
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/webhook.ts
+var EVENT_DESCRIPTIONS = {
+  "payment.succeeded": "Customer payment completed successfully",
+  "payment.failed": "Customer payment failed",
+  "refund.succeeded": "Refund completed at the gateway",
+  "refund.failed": "Refund attempt rejected by the gateway",
+  "checkout.session.completed": "Checkout session marked complete (paymentId set)",
+  "checkout.session.expired": "Checkout session expired before payment",
+  "subscription.created": "New subscription created (or trial started)",
+  "subscription.renewed": "Subscription auto-renewed",
+  "subscription.past_due": "Subscription payment overdue; retries in progress",
+  "subscription.unpaid": "Subscription marked unpaid; retries exhausted",
+  "subscription.canceled": "Subscription cancelled (immediate or end-of-period)",
+  "subscription.trial_ending": "Trial period ending soon",
+  "payout.requested": "Payout request submitted by merchant",
+  "payout.approved": "Payout approved by admin review",
+  "payout.settled": "Payout settled to bank account",
+  "payout.rejected": "Payout rejected (KYC, AML, balance, etc.)",
+  "payout.failed": "Payout failed at bank rail after settlement attempt",
+  "account.kyc.approved": "Merchant account KYC approved",
+  "account.kyc.rejected": "Merchant account KYC rejected"
+};
+var EVENT_GROUPS = [
+  { title: "Payment Events", prefix: "payment." },
+  { title: "Refund Events", prefix: "refund." },
+  { title: "Checkout Events", prefix: "checkout." },
+  { title: "Subscription Events", prefix: "subscription." },
+  { title: "Payout Events", prefix: "payout." },
+  { title: "Account / KYC Events", prefix: "account." }
+];
+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 {
+      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");
+      output(data, (d) => [
+        `  URL:    ${d.webhookUrl}`,
+        d.webhookSecret ? `  Secret: ${d.webhookSecret}` : null,
+        d.webhookSecret ? "\nSave the secret \u2014 it will not be shown again." : null,
+        d.webhookSecret ? "Use client.webhooks.constructEvent(body, signature, secret) in your server." : null
+      ].filter(Boolean).join("\n"));
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  webhook.command("info").description("Show current webhook configuration").action(async () => {
+    try {
+      const data = await apiRequest("GET", "/wallets/current");
+      output(data, (d) => d.webhookUrl ? `Webhook URL: ${d.webhookUrl}
+Status: configured` : "No webhook configured.\nRun: uniweb webhook set <url>");
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  webhook.command("remove").description("Remove webhook configuration").action(async () => {
+    try {
+      const data = await apiRequest("PATCH", "/wallets/current", {
+        webhookUrl: null
+      });
+      success("Webhook removed");
+      jsonOnly(data ?? { ok: true, webhookUrl: null });
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  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: uniweb webhook set <url>");
+        process.exit(1);
+      }
+      const data = await apiRequest("PATCH", "/wallets/current", {
+        webhookUrl: wallet.webhookUrl
+      });
+      success("New secret generated");
+      output(data, (d) => [
+        `  URL:    ${d.webhookUrl}`,
+        d.webhookSecret ? `  Secret: ${d.webhookSecret}` : null,
+        d.webhookSecret ? "\nSave the new secret \u2014 it will not be shown again." : null,
+        d.webhookSecret ? "The old secret is now invalid." : null
+      ].filter(Boolean).join("\n"));
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  webhook.command("events").description("Webhook event types reference").action(() => {
+    const events = Object.keys(EVENT_DESCRIPTIONS);
+    const grouped = EVENT_GROUPS.map((g) => ({
+      title: g.title,
+      events: events.filter((e) => e.startsWith(g.prefix))
+    })).filter((g) => g.events.length > 0);
+    const reference = {
+      events: grouped.reduce((acc, g) => {
+        acc[g.title] = Object.fromEntries(g.events.map((e) => [e, EVENT_DESCRIPTIONS[e]]));
+        return acc;
+      }, {}),
+      payload: {
+        id: "evt_xxx",
+        type: "payment.succeeded",
+        created: 171e7,
+        data: { object: "{ ...full resource... }" }
+      },
+      signatureHeader: "uniweb-Signature: t={timestamp},v1={hmac-sha256-hex}"
+    };
+    const padTo = Math.max(...events.map((e) => e.length));
+    output(reference, () => {
+      const lines = ["uniweb Webhook Event Types", ""];
+      for (const group of grouped) {
+        lines.push(`${group.title}:`);
+        for (const event of group.events) {
+          lines.push(`  ${event.padEnd(padTo)}  \u2014 ${EVENT_DESCRIPTIONS[event]}`);
+        }
+        lines.push("");
+      }
+      lines.push(
+        "Payload Format:",
+        "  {",
+        '    "id": "evt_xxx",',
+        '    "type": "payment.succeeded",',
+        '    "created": 1710000000,',
+        '    "data": { "object": { ...full resource... } }',
+        "  }",
+        "",
+        "Signature Header:",
+        "  uniweb-Signature: t={timestamp},v1={hmac-sha256-hex}"
+      );
+      return lines.join("\n");
+    });
+  });
+}
+
+// src/commands/key.ts
+function registerKeyCommands(program2) {
+  const key = program2.command("key").description("Manage API keys");
+  key.command("create").description("Create a new API key").requiredOption("-t, --type <type>", "Key type: full or server").option("-n, --name <name>", 'Key name (e.g. "Production Backend")').option("-s, --scopes <scopes>", "Comma-separated scopes for server key (e.g. products.read,products.write,checkout.create)").action(async (opts) => {
+    try {
+      if (opts.type !== "full" && opts.type !== "server") {
+        console.error('Error: type must be "full" or "server"');
+        process.exit(1);
+      }
+      const body = { type: opts.type };
+      if (opts.name) body.name = opts.name;
+      if (opts.scopes && opts.type === "server") {
+        body.scopes = opts.scopes.split(",").map((s) => s.trim());
+      }
+      const data = await apiRequest("POST", "/keys", body);
+      success(`${opts.type === "server" ? "Server" : "Full"} key created`);
+      output(data, (d) => [
+        `Key ID:  ${d.id}`,
+        `Secret:  ${d.secret}`,
+        `Type:    ${d.type}`,
+        d.name ? `Name:    ${d.name}` : null,
+        `Scopes:  ${Array.isArray(d.scopes) ? d.scopes.join(", ") : d.scopes}`,
+        "",
+        "Save this secret \u2014 it will not be shown again."
+      ].filter(Boolean).join("\n"));
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  key.command("list").description("List all API keys").action(async () => {
+    try {
+      const data = await apiRequest("GET", "/keys");
+      output(data, (d) => {
+        const items = d.data || [];
+        if (!Array.isArray(items) || items.length === 0) return "No API keys found.";
+        table(
+          ["ID", "Type", "Name", "Last Used", "Active"],
+          items.map((k) => [
+            k.id,
+            k.type,
+            k.name || "-",
+            k.lastUsedAt ? fmtDate(k.lastUsedAt) : "Never",
+            k.active ? "yes" : "no"
+          ])
+        );
+        return "";
+      });
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  key.command("revoke <id>").description("Revoke an API key").action(async (id) => {
+    try {
+      const data = await apiRequest("DELETE", `/keys/${id}`);
+      success(`Key ${id} revoked`);
+      jsonOnly(data ?? { ok: true, id });
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  key.command("roll <id>").description("Rotate an API key (new secret, old one stops working)").action(async (id) => {
+    try {
+      const data = await apiRequest("POST", `/keys/${id}/roll`);
+      success("Key rotated");
+      output(data, (d) => [
+        `Key ID:     ${d.id}`,
+        `New Secret: ${d.secret}`,
+        "",
+        "Save this secret \u2014 it will not be shown again.",
+        "The old secret has been invalidated."
+      ].join("\n"));
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/payment.ts
+function registerPaymentCommands(program2) {
+  const payment = program2.command("payment").description("Manage payments");
+  payment.command("list").description("List payments").option("-s, --status <status>", "Filter by status (pending, authorized, succeeded, failed, refunded, partially_refunded, abandoned)").option("-c, --customer-id <id>", "Filter by customer ID").action(async (opts) => {
+    try {
+      const params = new URLSearchParams();
+      if (opts.status) params.set("status", opts.status);
+      if (opts.customerId) params.set("customer_id", opts.customerId);
+      const qs = params.toString();
+      const data = await apiRequest("GET", `/payments${qs ? "?" + qs : ""}`);
+      output(data, (d) => {
+        const items = d.data || [];
+        if (!Array.isArray(items) || items.length === 0) return "No payments found.";
+        table(
+          ["ID", "Amount", "Status", "Gateway", "Created"],
+          items.map((p) => [
+            p.id,
+            fmtAmount(p.amount, p.currency),
+            p.status,
+            p.gateway,
+            fmtDate(p.createdAt)
+          ])
+        );
+        return "";
+      });
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  payment.command("get <id>").description("Get payment details").option("--gateway", "Query gateway enquiry details").action(async (id, opts) => {
+    try {
+      const data = await apiRequest("GET", `/payments/${id}${opts.gateway ? "?gateway=true" : ""}`);
+      output(data, (d) => [
+        `Payment ID: ${d.id}`,
+        `Amount:     ${fmtAmount(d.amount, d.currency)}`,
+        `Status:     ${d.status}`,
+        `Gateway:    ${d.gateway}`,
+        d.gatewayStatus ? `Gateway Status:      ${d.gatewayStatus}` : null,
+        d.gatewayStatusCode ? `Gateway Status Code: ${d.gatewayStatusCode}` : null,
+        d.gatewayStatusMessage ? `Gateway Message:     ${d.gatewayStatusMessage}` : null,
+        `Customer:   ${d.customerId || "N/A"}`,
+        `Created:    ${fmtDate(d.createdAt)}`
+      ].filter(Boolean).join("\n"));
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  payment.command("void <id>").description("Void a payment (same-day, before settlement)").action(async (id) => {
+    try {
+      const data = await apiRequest("POST", `/payments/${id}/void`);
+      success(`Payment ${id} voided`);
+      jsonOnly(data ?? { ok: true, id });
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+  payment.command("refund <id>").description("Refund a payment").option("-a, --amount <amount>", "Refund amount in cents (defaults to full refundable amount)").option("--offline", "Process as offline refund").option("-r, --reason <reason>", "Refund reason").action(async (id, opts) => {
+    try {
+      const body = { paymentId: id };
+      if (opts.amount) body.amount = parseInt(opts.amount, 10);
+      if (opts.offline) body.offlineRefundFlag = true;
+      if (opts.reason) body.reason = opts.reason;
+      const data = await apiRequest("POST", "/refunds", body);
+      success("Refund created");
+      output(data, (d) => [
+        `Refund ID: ${d.id}`,
+        `Amount:    ${fmtAmount(d.amount, d.currency)}`,
+        `Status:    ${d.status}`
+      ].join("\n"));
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/commands/refund.ts
+function registerRefundCommands(program2) {
+  const refund = program2.command("refund").description("Manage refunds");
+  refund.command("get <id>").description("Get refund status").option("--gateway", "Query gateway enquiry details").action(async (id, opts) => {
+    try {
+      const data = await apiRequest("GET", `/refunds/${id}${opts.gateway ? "?gateway=true" : ""}`);
+      output(data, (d) => [
+        `Refund ID:              ${d.id}`,
+        `Payment ID:             ${d.paymentId}`,
+        `Amount:                 ${fmtAmount(d.amount, d.currency)}`,
+        `Status:                 ${d.status}`,
+        `Gateway:                ${d.gateway}`,
+        d.gatewayStatus ? `Gateway Status:         ${d.gatewayStatus}` : null,
+        d.gatewayStatusCode ? `Gateway Status Code:    ${d.gatewayStatusCode}` : null,
+        d.gatewayStatusMessage ? `Gateway Message:        ${d.gatewayStatusMessage}` : null,
+        d.gatewayRequestNo ? `Gateway Request No:     ${d.gatewayRequestNo}` : null,
+        d.gatewayTransactionId ? `Gateway Transaction ID: ${d.gatewayTransactionId}` : null,
+        `Created:                ${fmtDate(d.createdAt)}`
+      ].filter(Boolean).join("\n"));
+    } catch (err) {
+      console.error(`Error: ${err.message}`);
+      process.exit(1);
+    }
+  });
+}
+
+// src/index.ts
+var program = new Command();
+program.name("uniweb").description("uniweb CLI - manage payments from the command line").version("0.1.0").option("--json", "Output in JSON format").hook("preAction", (thisCommand) => {
+  const opts = thisCommand.opts();
+  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);
+registerKeyCommands(program);
+registerPaymentCommands(program);
+registerRefundCommands(program);
+program.parse();

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@uniwebpay/cli",
+  "version": "0.1.0",
+  "description": "uniweb CLI - Payment infrastructure for the AI era. Accept cards, e-wallets, and QR payments in Southeast Asia.",
+  "type": "module",
+  "bin": {
+    "uniweb": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsx src/index.ts"
+  },
+  "keywords": [
+    "payment",
+    "cli",
+    "checkout",
+    "subscription",
+    "billing",
+    "uniweb",
+    "ai-native",
+    "southeast-asia",
+    "singapore",
+    "wechat-pay",
+    "alipay",
+    "paynow"
+  ],
+  "author": "Glitter Protocol / uniweb contributors",
+  "license": "MIT",
+  "homepage": "https://vibecash.dev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/glitternetwork/uniweb.git",
+    "directory": "packages/cli"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "commander": "^12.0.0"
+  },
+  "devDependencies": {
+    "@uniweb/shared": "workspace:*",
+    "tsup": "^8.0.0",
+    "tsx": "^4.7.0",
+    "typescript": "^5.5.0"
+  }
+}
+