vibecash 0.1.0

package/dist/index.js

@@ -0,0 +1,1012 @@
+#!/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_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 {};
+  }
+}
+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));
+}
+function getSecret() {
+  const envSecret = process.env.AIPAY_SECRET;
+  if (envSecret) {
+    return envSecret;
+  }
+  const config = getConfig();
+  return config.secret;
+}
+function getApiUrl() {
+  const envUrl = process.env.AIPAY_API_URL;
+  if (envUrl) {
+    return envUrl;
+  }
+  const config = getConfig();
+  return config.apiUrl || "https://api.vibecash.dev";
+}
+function getOutputFormat() {
+  const envFormat = process.env.AIPAY_OUTPUT;
+  if (envFormat === "human" || envFormat === "json") {
+    return envFormat;
+  }
+  const config = getConfig();
+  return config.outputFormat || "json";
+}
+
+// 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 updatePaymentLink(id, data) {
+    return this.request("PATCH", `/v1/payment_links/${id}`, 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) {
+    console.log(humanFormatter(data));
+  } else {
+    console.log(JSON.stringify(data, null, 2));
+  }
+}
+function formatDate(timestamp) {
+  return new Date(timestamp).toLocaleString();
+}
+function formatCurrency(amountCents, currency = "USD") {
+  return formatAmount(amountCents, currency);
+}
+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 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}`);
+}
+
+// src/commands/wallet.ts
+function createWalletCommand() {
+  const wallet = new Command("wallet").description("Manage wallets");
+  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;
+        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}`
+        ].join("\n");
+      });
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to create wallet");
+    }
+  });
+  wallet.command("status").description("Get current wallet status").action(async () => {
+    try {
+      const client = new ApiClient();
+      const result = await client.getWallet();
+      output(result, (data) => {
+        const d = data;
+        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)}`
+        ].join("\n");
+      });
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to get wallet status");
+    }
+  });
+  wallet.command("claim").description("Generate a claim link for this 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");
+      });
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to generate claim link");
+    }
+  });
+  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");
+      });
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to create product");
+    }
+  });
+  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);
+      });
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to list products");
+    }
+  });
+  product.command("get").description("Get product details").argument("<id>", "Product 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");
+      });
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to get product");
+    }
+  });
+  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");
+      }
+    }
+  );
+  price.command("list").description("List prices").option("-p, --product <id>", "Filter by product ID").action(async (options) => {
+    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) => [
+            p.id,
+            p.productId,
+            formatCurrency(p.amount, p.currency),
+            p.type,
+            p.interval || "-"
+          ])
+        ];
+        return formatTable(rows);
+      });
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to list prices");
+    }
+  });
+  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");
+      }
+    }
+  );
+  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));
+        }
+        error("Timeout waiting for checkout to complete");
+      } else {
+        const result = await client.getCheckoutSession(id);
+        output(result, formatCheckoutSession);
+      }
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to get checkout session");
+    }
+  });
+  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);
+      });
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to list subscriptions");
+    }
+  });
+  subscription.command("get").description("Get subscription details").argument("<id>", "Subscription 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");
+      });
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to get subscription");
+    }
+  });
+  subscription.command("cancel").description("Cancel a subscription").argument("<id>", "Subscription ID").option("--immediately", "Cancel immediately instead of at period end").action(async (id, options) => {
+    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");
+      });
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to cancel subscription");
+    }
+  });
+  subscription.command("resume").description("Resume a canceled subscription").argument("<id>", "Subscription ID").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");
+      });
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to resume subscription");
+    }
+  });
+  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");
+      });
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to create customer");
+    }
+  });
+  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);
+      });
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to list customers");
+    }
+  });
+  customer.command("get").description("Get customer details").argument("<id>", "Customer ID").action(async (id) => {
+    try {
+      const client = new ApiClient();
+      const result = await client.getCustomer(id);
+      output(result, (data) => {
+        const d = data;
+        return [
+          `Customer: ${d.id}`,
+          ``,
+          `  Email:   ${d.email}`,
+          d.name ? `  Name:    ${d.name}` : null,
+          `  Created: ${formatDate(d.createdAt)}`
+        ].filter(Boolean).join("\n");
+      });
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to get customer");
+    }
+  });
+  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) => {
+    try {
+      const client = new ApiClient();
+      const result = await client.createPortalSession(id, options.returnUrl);
+      output(result, (data) => {
+        const d = data;
+        return [
+          `Portal session created!`,
+          ``,
+          `  ID:      ${d.id}`,
+          `  URL:     ${d.url}`,
+          `  Expires: ${formatDate(d.expiresAt)}`
+        ].join("\n");
+      });
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to create portal session");
+    }
+  });
+  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");
+          });
+        }
+      } catch (err) {
+        error(err instanceof Error ? err.message : "Failed to create checkout");
+      }
+    }
+  );
+  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");
+      }
+    }
+  );
+  link.command("list").description("List all payment links").action(async () => {
+    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
+          ])
+        ];
+        return formatTable(rows);
+      });
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to list payment links");
+    }
+  });
+  link.command("get").description("Get payment link details").argument("<id>", "Payment Link ID").action(async (id) => {
+    try {
+      const client = new ApiClient();
+      const result = await client.getPaymentLink(id);
+      output(result, (data) => {
+        const d = data;
+        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");
+      });
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to get payment link");
+    }
+  });
+  link.command("deactivate").description("Deactivate a payment link").argument("<id>", "Payment Link ID").action(async (id) => {
+    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.`;
+      });
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to deactivate payment link");
+    }
+  });
+  link.command("activate").description("Activate a payment link").argument("<id>", "Payment Link ID").action(async (id) => {
+    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.`;
+      });
+    } catch (err) {
+      error(err instanceof Error ? err.message : "Failed to activate payment link");
+    }
+  });
+  return link;
+}
+
+// src/index.ts
+var program = new Command9();
+program.name("vibecash").description("AI Guardian CLI - Payment infrastructure for AI agents").version("0.1.0");
+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) => {
+  const opts = thisCommand.opts();
+  if (opts.human) {
+    process.env.AIPAY_OUTPUT = "human";
+  } else if (opts.json) {
+    process.env.AIPAY_OUTPUT = "json";
+  }
+});
+program.parse();