moltspay 0.5.4 → 0.7.1

package/dist/cli/index.mjs

@@ -0,0 +1,967 @@
+#!/usr/bin/env node
+
+// src/cli/index.ts
+import { Command } from "commander";
+import { homedir as homedir2 } from "os";
+import { join as join2, dirname, resolve } from "path";
+import { existsSync as existsSync2, writeFileSync as writeFileSync2, readFileSync as readFileSync3, unlinkSync, mkdirSync as mkdirSync2 } from "fs";
+import { spawn } from "child_process";
+
+// src/client/index.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import { Wallet } from "ethers";
+
+// src/chains/index.ts
+var CHAINS = {
+  // ============ Mainnet ============
+  base: {
+    name: "Base",
+    chainId: 8453,
+    rpc: "https://mainnet.base.org",
+    usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    explorer: "https://basescan.org/address/",
+    explorerTx: "https://basescan.org/tx/",
+    avgBlockTime: 2
+  },
+  polygon: {
+    name: "Polygon",
+    chainId: 137,
+    rpc: "https://polygon-rpc.com",
+    usdc: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
+    explorer: "https://polygonscan.com/address/",
+    explorerTx: "https://polygonscan.com/tx/",
+    avgBlockTime: 2
+  },
+  ethereum: {
+    name: "Ethereum",
+    chainId: 1,
+    rpc: "https://eth.llamarpc.com",
+    usdc: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    explorer: "https://etherscan.io/address/",
+    explorerTx: "https://etherscan.io/tx/",
+    avgBlockTime: 12
+  },
+  // ============ Testnet ============
+  base_sepolia: {
+    name: "Base Sepolia",
+    chainId: 84532,
+    rpc: "https://sepolia.base.org",
+    usdc: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+    explorer: "https://sepolia.basescan.org/address/",
+    explorerTx: "https://sepolia.basescan.org/tx/",
+    avgBlockTime: 2
+  },
+  sepolia: {
+    name: "Sepolia",
+    chainId: 11155111,
+    rpc: "https://rpc.sepolia.org",
+    usdc: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238",
+    explorer: "https://sepolia.etherscan.io/address/",
+    explorerTx: "https://sepolia.etherscan.io/tx/",
+    avgBlockTime: 12
+  }
+};
+function getChain(name) {
+  const config = CHAINS[name];
+  if (!config) {
+    throw new Error(`Unsupported chain: ${name}. Supported: ${Object.keys(CHAINS).join(", ")}`);
+  }
+  return config;
+}
+function getChainById(chainId) {
+  return Object.values(CHAINS).find((c) => c.chainId === chainId);
+}
+
+// src/client/index.ts
+var DEFAULT_CONFIG = {
+  chain: "base",
+  limits: {
+    maxPerTx: 100,
+    maxPerDay: 1e3
+  }
+};
+var MoltsPayClient = class {
+  configDir;
+  config;
+  walletData = null;
+  wallet = null;
+  todaySpending = 0;
+  lastSpendingReset = 0;
+  constructor(options = {}) {
+    this.configDir = options.configDir || join(homedir(), ".moltspay");
+    this.config = this.loadConfig();
+    this.walletData = this.loadWallet();
+    if (this.walletData) {
+      this.wallet = new Wallet(this.walletData.privateKey);
+    }
+  }
+  /**
+   * Check if client is initialized (has wallet)
+   */
+  get isInitialized() {
+    return this.wallet !== null;
+  }
+  /**
+   * Get wallet address
+   */
+  get address() {
+    return this.wallet?.address || null;
+  }
+  /**
+   * Get current config
+   */
+  getConfig() {
+    return { ...this.config };
+  }
+  /**
+   * Update config
+   */
+  updateConfig(updates) {
+    if (updates.maxPerTx !== void 0) {
+      this.config.limits.maxPerTx = updates.maxPerTx;
+    }
+    if (updates.maxPerDay !== void 0) {
+      this.config.limits.maxPerDay = updates.maxPerDay;
+    }
+    this.saveConfig();
+  }
+  /**
+   * Get services from a provider
+   */
+  async getServices(serverUrl) {
+    const res = await fetch(`${serverUrl}/services`);
+    if (!res.ok) {
+      throw new Error(`Failed to get services: ${res.statusText}`);
+    }
+    return res.json();
+  }
+  /**
+   * Pay for a service and get the result
+   */
+  async pay(serverUrl, service, params) {
+    if (!this.wallet) {
+      throw new Error("Client not initialized. Run: npx moltspay init");
+    }
+    const payRes = await fetch(`${serverUrl}/pay`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ service, params })
+    });
+    if (payRes.status !== 402) {
+      const err = await payRes.json();
+      throw new Error(err.error || "Unexpected response");
+    }
+    const paymentReq = await payRes.json();
+    const { payment } = paymentReq;
+    this.checkLimits(payment.amount);
+    console.log(`[MoltsPay] Paying $${payment.amount} ${payment.currency} to ${payment.wallet}`);
+    const txHash = await this.executePayment(payment);
+    console.log(`[MoltsPay] Payment tx: ${txHash}`);
+    const verifyRes = await fetch(`${serverUrl}/verify`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        chargeId: payment.chargeId,
+        txHash
+      })
+    });
+    if (!verifyRes.ok) {
+      const err = await verifyRes.json();
+      throw new Error(err.error || "Verification failed");
+    }
+    const result = await verifyRes.json();
+    this.recordSpending(payment.amount);
+    return result.result;
+  }
+  /**
+   * Check spending limits
+   */
+  checkLimits(amount) {
+    if (amount > this.config.limits.maxPerTx) {
+      throw new Error(
+        `Amount $${amount} exceeds max per transaction ($${this.config.limits.maxPerTx})`
+      );
+    }
+    const today = (/* @__PURE__ */ new Date()).setHours(0, 0, 0, 0);
+    if (today > this.lastSpendingReset) {
+      this.todaySpending = 0;
+      this.lastSpendingReset = today;
+    }
+    if (this.todaySpending + amount > this.config.limits.maxPerDay) {
+      throw new Error(
+        `Would exceed daily limit ($${this.todaySpending} + $${amount} > $${this.config.limits.maxPerDay})`
+      );
+    }
+  }
+  /**
+   * Record spending
+   */
+  recordSpending(amount) {
+    this.todaySpending += amount;
+  }
+  /**
+   * Execute payment on-chain
+   */
+  async executePayment(payment) {
+    let chain;
+    try {
+      chain = getChain(payment.chain);
+    } catch {
+      throw new Error(`Unknown chain: ${payment.chain}`);
+    }
+    const { ethers: ethers2 } = await import("ethers");
+    const provider = new ethers2.JsonRpcProvider(chain.rpc);
+    const signer = new ethers2.Wallet(this.walletData.privateKey, provider);
+    const usdcAddress = chain.usdc;
+    const usdcAbi = [
+      "function transfer(address to, uint256 amount) returns (bool)",
+      "function balanceOf(address account) view returns (uint256)"
+    ];
+    const usdc = new ethers2.Contract(usdcAddress, usdcAbi, signer);
+    const amountInUnits = ethers2.parseUnits(payment.amount.toString(), 6);
+    const balance = await usdc.balanceOf(this.wallet.address);
+    if (balance < amountInUnits) {
+      throw new Error(
+        `Insufficient USDC balance: ${ethers2.formatUnits(balance, 6)} < ${payment.amount}`
+      );
+    }
+    const tx = await usdc.transfer(payment.wallet, amountInUnits);
+    const receipt = await tx.wait();
+    return receipt.hash;
+  }
+  // --- Config & Wallet Management ---
+  loadConfig() {
+    const configPath = join(this.configDir, "config.json");
+    if (existsSync(configPath)) {
+      const content = readFileSync(configPath, "utf-8");
+      return { ...DEFAULT_CONFIG, ...JSON.parse(content) };
+    }
+    return { ...DEFAULT_CONFIG };
+  }
+  saveConfig() {
+    mkdirSync(this.configDir, { recursive: true });
+    const configPath = join(this.configDir, "config.json");
+    writeFileSync(configPath, JSON.stringify(this.config, null, 2));
+  }
+  loadWallet() {
+    const walletPath = join(this.configDir, "wallet.json");
+    if (existsSync(walletPath)) {
+      const content = readFileSync(walletPath, "utf-8");
+      return JSON.parse(content);
+    }
+    return null;
+  }
+  /**
+   * Initialize a new wallet (called by CLI)
+   */
+  static init(configDir, options) {
+    mkdirSync(configDir, { recursive: true });
+    const wallet = Wallet.createRandom();
+    const walletData = {
+      address: wallet.address,
+      privateKey: wallet.privateKey,
+      createdAt: Date.now()
+    };
+    const walletPath = join(configDir, "wallet.json");
+    writeFileSync(walletPath, JSON.stringify(walletData, null, 2));
+    const config = {
+      chain: options.chain,
+      limits: {
+        maxPerTx: options.maxPerTx,
+        maxPerDay: options.maxPerDay
+      }
+    };
+    const configPath = join(configDir, "config.json");
+    writeFileSync(configPath, JSON.stringify(config, null, 2));
+    return { address: wallet.address, configDir };
+  }
+  /**
+   * Get wallet balance
+   */
+  async getBalance() {
+    if (!this.wallet) {
+      throw new Error("Client not initialized");
+    }
+    let chain;
+    try {
+      chain = getChain(this.config.chain);
+    } catch {
+      throw new Error(`Unknown chain: ${this.config.chain}`);
+    }
+    const { ethers: ethers2 } = await import("ethers");
+    const provider = new ethers2.JsonRpcProvider(chain.rpc);
+    const nativeBalance = await provider.getBalance(this.wallet.address);
+    const usdcAbi = ["function balanceOf(address) view returns (uint256)"];
+    const usdc = new ethers2.Contract(chain.usdc, usdcAbi, provider);
+    const usdcBalance = await usdc.balanceOf(this.wallet.address);
+    return {
+      usdc: parseFloat(ethers2.formatUnits(usdcBalance, 6)),
+      native: parseFloat(ethers2.formatEther(nativeBalance))
+    };
+  }
+};
+
+// src/server/index.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { createServer } from "http";
+
+// src/verify/index.ts
+import { ethers } from "ethers";
+var TRANSFER_EVENT_TOPIC = ethers.id("Transfer(address,address,uint256)");
+async function verifyPayment(params) {
+  const { txHash, expectedAmount, expectedTo } = params;
+  let chain;
+  try {
+    if (typeof params.chain === "number") {
+      chain = getChainById(params.chain);
+    } else {
+      chain = getChain(params.chain || "base");
+    }
+    if (!chain) {
+      return { verified: false, error: `Unsupported chain: ${params.chain}` };
+    }
+  } catch (e) {
+    return { verified: false, error: `Unsupported chain: ${params.chain}` };
+  }
+  try {
+    const provider = new ethers.JsonRpcProvider(chain.rpc);
+    const receipt = await provider.getTransactionReceipt(txHash);
+    if (!receipt) {
+      return { verified: false, error: "Transaction not found or not confirmed" };
+    }
+    if (receipt.status !== 1) {
+      return { verified: false, error: "Transaction failed" };
+    }
+    const usdcAddress = chain.usdc?.toLowerCase();
+    if (!usdcAddress) {
+      return { verified: false, error: `Chain ${chain.name} USDC address not configured` };
+    }
+    for (const log of receipt.logs) {
+      if (log.address.toLowerCase() !== usdcAddress) {
+        continue;
+      }
+      if (log.topics.length < 3 || log.topics[0] !== TRANSFER_EVENT_TOPIC) {
+        continue;
+      }
+      const from = "0x" + log.topics[1].slice(-40);
+      const to = "0x" + log.topics[2].slice(-40);
+      const amountRaw = BigInt(log.data);
+      const amount = Number(amountRaw) / 1e6;
+      if (expectedTo && to.toLowerCase() !== expectedTo.toLowerCase()) {
+        continue;
+      }
+      if (amount < expectedAmount) {
+        return {
+          verified: false,
+          error: `Insufficient amount: received ${amount} USDC, expected ${expectedAmount} USDC`,
+          amount,
+          from,
+          to,
+          txHash,
+          blockNumber: receipt.blockNumber
+        };
+      }
+      return {
+        verified: true,
+        amount,
+        from,
+        to,
+        txHash,
+        blockNumber: receipt.blockNumber
+      };
+    }
+    return { verified: false, error: "No USDC transfer found" };
+  } catch (e) {
+    return { verified: false, error: e.message || String(e) };
+  }
+}
+
+// src/server/index.ts
+function generateChargeId() {
+  return "ch_" + Math.random().toString(36).substring(2, 15);
+}
+var MoltsPayServer = class {
+  manifest;
+  skills = /* @__PURE__ */ new Map();
+  charges = /* @__PURE__ */ new Map();
+  options;
+  constructor(servicesPath, options = {}) {
+    const content = readFileSync2(servicesPath, "utf-8");
+    this.manifest = JSON.parse(content);
+    this.options = {
+      port: options.port || 3e3,
+      host: options.host || "0.0.0.0",
+      chargeExpirySecs: options.chargeExpirySecs || 300
+      // 5 minutes
+    };
+    console.log(`[MoltsPay] Loaded ${this.manifest.services.length} services from ${servicesPath}`);
+    console.log(`[MoltsPay] Provider: ${this.manifest.provider.name}`);
+    console.log(`[MoltsPay] Wallet: ${this.manifest.provider.wallet}`);
+  }
+  /**
+   * Register a skill handler for a service
+   */
+  skill(serviceId, handler) {
+    const config = this.manifest.services.find((s) => s.id === serviceId);
+    if (!config) {
+      throw new Error(`Service '${serviceId}' not found in manifest`);
+    }
+    this.skills.set(serviceId, {
+      id: serviceId,
+      config,
+      handler
+    });
+    console.log(`[MoltsPay] Registered skill: ${serviceId} ($${config.price} ${config.currency})`);
+    return this;
+  }
+  /**
+   * Start the server
+   */
+  listen(port) {
+    const p = port || this.options.port;
+    const server = createServer((req, res) => this.handleRequest(req, res));
+    server.listen(p, this.options.host, () => {
+      console.log(`[MoltsPay] Server listening on http://${this.options.host}:${p}`);
+      console.log(`[MoltsPay] Endpoints:`);
+      console.log(`  GET  /services  - List available services`);
+      console.log(`  POST /pay       - Create payment & execute service`);
+      console.log(`  POST /verify    - Verify payment & get result`);
+      console.log(`  GET  /status/:id - Check charge status`);
+    });
+  }
+  async handleRequest(req, res) {
+    const url = new URL(req.url || "/", `http://${req.headers.host}`);
+    const path = url.pathname;
+    const method = req.method || "GET";
+    res.setHeader("Access-Control-Allow-Origin", "*");
+    res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+    if (method === "OPTIONS") {
+      res.writeHead(204);
+      res.end();
+      return;
+    }
+    try {
+      if (method === "GET" && path === "/services") {
+        return this.handleGetServices(res);
+      }
+      if (method === "POST" && path === "/pay") {
+        const body = await this.readBody(req);
+        return this.handlePay(body, res);
+      }
+      if (method === "POST" && path === "/verify") {
+        const body = await this.readBody(req);
+        return this.handleVerify(body, res);
+      }
+      if (method === "GET" && path.startsWith("/status/")) {
+        const chargeId = path.replace("/status/", "");
+        return this.handleStatus(chargeId, res);
+      }
+      this.sendJson(res, 404, { error: "Not found" });
+    } catch (err) {
+      console.error("[MoltsPay] Error:", err);
+      this.sendJson(res, 500, { error: err.message || "Internal error" });
+    }
+  }
+  /**
+   * GET /services - List available services
+   */
+  handleGetServices(res) {
+    const services = this.manifest.services.map((s) => ({
+      id: s.id,
+      name: s.name,
+      description: s.description,
+      price: s.price,
+      currency: s.currency,
+      input: s.input,
+      output: s.output,
+      available: this.skills.has(s.id)
+    }));
+    this.sendJson(res, 200, {
+      provider: this.manifest.provider,
+      services
+    });
+  }
+  /**
+   * POST /pay - Create payment request
+   * Body: { service: string, params: object }
+   */
+  handlePay(body, res) {
+    const { service, params } = body;
+    if (!service) {
+      return this.sendJson(res, 400, { error: "Missing service" });
+    }
+    const skill = this.skills.get(service);
+    if (!skill) {
+      return this.sendJson(res, 404, { error: `Service '${service}' not found or not registered` });
+    }
+    for (const [key, field] of Object.entries(skill.config.input)) {
+      if (field.required && (!params || params[key] === void 0)) {
+        return this.sendJson(res, 400, { error: `Missing required param: ${key}` });
+      }
+    }
+    const chargeId = generateChargeId();
+    const now = Date.now();
+    const charge = {
+      id: chargeId,
+      service,
+      params: params || {},
+      amount: skill.config.price,
+      currency: skill.config.currency,
+      status: "pending",
+      createdAt: now,
+      expiresAt: now + this.options.chargeExpirySecs * 1e3
+    };
+    this.charges.set(chargeId, charge);
+    const paymentRequest = {
+      chargeId,
+      service,
+      amount: charge.amount,
+      currency: charge.currency,
+      wallet: this.manifest.provider.wallet,
+      chain: this.manifest.provider.chain,
+      expiresAt: charge.expiresAt
+    };
+    this.sendJson(res, 402, {
+      message: "Payment required",
+      payment: paymentRequest
+    });
+  }
+  /**
+   * POST /verify - Verify payment and execute skill
+   * Body: { chargeId: string, txHash: string }
+   */
+  async handleVerify(body, res) {
+    const { chargeId, txHash } = body;
+    if (!chargeId || !txHash) {
+      return this.sendJson(res, 400, { error: "Missing chargeId or txHash" });
+    }
+    const charge = this.charges.get(chargeId);
+    if (!charge) {
+      return this.sendJson(res, 404, { error: "Charge not found" });
+    }
+    if (Date.now() > charge.expiresAt) {
+      charge.status = "expired";
+      return this.sendJson(res, 400, { error: "Charge expired" });
+    }
+    if (charge.status === "completed") {
+      return this.sendJson(res, 200, {
+        status: "completed",
+        result: charge.result
+      });
+    }
+    try {
+      const verification = await verifyPayment({
+        txHash,
+        expectedTo: this.manifest.provider.wallet,
+        expectedAmount: charge.amount,
+        chain: this.manifest.provider.chain
+      });
+      if (!verification.verified) {
+        charge.status = "failed";
+        return this.sendJson(res, 400, {
+          error: "Payment verification failed",
+          reason: verification.error
+        });
+      }
+      charge.status = "paid";
+      charge.txHash = txHash;
+      charge.paidAt = Date.now();
+      const skill = this.skills.get(charge.service);
+      console.log(`[MoltsPay] Executing skill: ${charge.service}`);
+      const result = await skill.handler(charge.params);
+      charge.status = "completed";
+      charge.result = result;
+      charge.completedAt = Date.now();
+      this.sendJson(res, 200, {
+        status: "completed",
+        chargeId,
+        txHash,
+        result
+      });
+    } catch (err) {
+      console.error("[MoltsPay] Skill execution error:", err);
+      charge.status = "failed";
+      this.sendJson(res, 500, {
+        error: "Skill execution failed",
+        message: err.message
+      });
+    }
+  }
+  /**
+   * GET /status/:chargeId - Check charge status
+   */
+  handleStatus(chargeId, res) {
+    const charge = this.charges.get(chargeId);
+    if (!charge) {
+      return this.sendJson(res, 404, { error: "Charge not found" });
+    }
+    this.sendJson(res, 200, {
+      chargeId: charge.id,
+      service: charge.service,
+      amount: charge.amount,
+      currency: charge.currency,
+      status: charge.status,
+      txHash: charge.txHash,
+      result: charge.status === "completed" ? charge.result : void 0,
+      createdAt: charge.createdAt,
+      expiresAt: charge.expiresAt
+    });
+  }
+  async readBody(req) {
+    return new Promise((resolve2, reject) => {
+      let body = "";
+      req.on("data", (chunk) => body += chunk);
+      req.on("end", () => {
+        try {
+          resolve2(body ? JSON.parse(body) : {});
+        } catch {
+          reject(new Error("Invalid JSON"));
+        }
+      });
+      req.on("error", reject);
+    });
+  }
+  sendJson(res, status, data) {
+    res.writeHead(status, { "Content-Type": "application/json" });
+    res.end(JSON.stringify(data, null, 2));
+  }
+};
+
+// src/cli/index.ts
+import * as readline from "readline";
+var program = new Command();
+var DEFAULT_CONFIG_DIR = join2(homedir2(), ".moltspay");
+var PID_FILE = join2(DEFAULT_CONFIG_DIR, "server.pid");
+if (!existsSync2(DEFAULT_CONFIG_DIR)) {
+  mkdirSync2(DEFAULT_CONFIG_DIR, { recursive: true });
+}
+function prompt(question) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  return new Promise((resolve2) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve2(answer.trim());
+    });
+  });
+}
+program.name("moltspay").description("MoltsPay - Payment infrastructure for AI Agents").version("1.0.0");
+program.command("init").description("Initialize MoltsPay client (create wallet, set limits)").option("--chain <chain>", "Blockchain to use", "base").option("--max-per-tx <amount>", "Max amount per transaction").option("--max-per-day <amount>", "Max amount per day").option("--config-dir <dir>", "Config directory", DEFAULT_CONFIG_DIR).action(async (options) => {
+  console.log("\n\u{1F510} MoltsPay Client Setup\n");
+  if (existsSync2(join2(options.configDir, "wallet.json"))) {
+    console.log('\u26A0\uFE0F  Already initialized. Use "moltspay config" to update settings.');
+    console.log(`   Config dir: ${options.configDir}`);
+    return;
+  }
+  let chain = options.chain;
+  let maxPerTx = options.maxPerTx ? parseFloat(options.maxPerTx) : null;
+  let maxPerDay = options.maxPerDay ? parseFloat(options.maxPerDay) : null;
+  if (!maxPerTx) {
+    const answer = await prompt("Max per transaction (USD) [100]: ");
+    maxPerTx = answer ? parseFloat(answer) : 100;
+  }
+  if (!maxPerDay) {
+    const answer = await prompt("Max per day (USD) [1000]: ");
+    maxPerDay = answer ? parseFloat(answer) : 1e3;
+  }
+  console.log("\nCreating wallet...");
+  const result = MoltsPayClient.init(options.configDir, {
+    chain,
+    maxPerTx,
+    maxPerDay
+  });
+  console.log(`
+\u2705 Wallet created: ${result.address}`);
+  console.log(`
+\u{1F4C1} Config saved to: ${result.configDir}`);
+  console.log(`
+\u26A0\uFE0F  IMPORTANT: Back up ${join2(result.configDir, "wallet.json")}`);
+  console.log(`   This file contains your private key!
+`);
+  console.log(`\u{1F4B0} Fund your wallet with USDC on ${chain} to start using services.
+`);
+});
+program.command("config").description("Update MoltsPay settings").option("--max-per-tx <amount>", "Max amount per transaction").option("--max-per-day <amount>", "Max amount per day").option("--config-dir <dir>", "Config directory", DEFAULT_CONFIG_DIR).action(async (options) => {
+  const client = new MoltsPayClient({ configDir: options.configDir });
+  if (!client.isInitialized) {
+    console.log("\u274C Not initialized. Run: npx moltspay init");
+    return;
+  }
+  const currentConfig = client.getConfig();
+  if (!options.maxPerTx && !options.maxPerDay) {
+    console.log("\n\u{1F4CB} Current Settings:\n");
+    console.log(`   Wallet: ${client.address}`);
+    console.log(`   Chain: ${currentConfig.chain}`);
+    console.log(`   Max per tx: $${currentConfig.limits.maxPerTx}`);
+    console.log(`   Max per day: $${currentConfig.limits.maxPerDay}`);
+    console.log("");
+    const maxPerTxAnswer = await prompt(`New max per tx (USD) [${currentConfig.limits.maxPerTx}]: `);
+    const maxPerDayAnswer = await prompt(`New max per day (USD) [${currentConfig.limits.maxPerDay}]: `);
+    if (maxPerTxAnswer) {
+      client.updateConfig({ maxPerTx: parseFloat(maxPerTxAnswer) });
+      console.log(`\u2705 Updated max per tx to $${maxPerTxAnswer}`);
+    }
+    if (maxPerDayAnswer) {
+      client.updateConfig({ maxPerDay: parseFloat(maxPerDayAnswer) });
+      console.log(`\u2705 Updated max per day to $${maxPerDayAnswer}`);
+    }
+  } else {
+    if (options.maxPerTx) {
+      client.updateConfig({ maxPerTx: parseFloat(options.maxPerTx) });
+      console.log(`\u2705 Updated max per tx to $${options.maxPerTx}`);
+    }
+    if (options.maxPerDay) {
+      client.updateConfig({ maxPerDay: parseFloat(options.maxPerDay) });
+      console.log(`\u2705 Updated max per day to $${options.maxPerDay}`);
+    }
+  }
+});
+program.command("status").description("Show wallet status and balance").option("--config-dir <dir>", "Config directory", DEFAULT_CONFIG_DIR).option("--json", "Output as JSON").action(async (options) => {
+  const client = new MoltsPayClient({ configDir: options.configDir });
+  if (!client.isInitialized) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: "Not initialized" }));
+    } else {
+      console.log("\u274C Not initialized. Run: npx moltspay init");
+    }
+    return;
+  }
+  const config = client.getConfig();
+  let balance = { usdc: 0, native: 0 };
+  try {
+    balance = await client.getBalance();
+  } catch (err) {
+    console.error("Warning: Could not fetch balance:", err.message);
+  }
+  if (options.json) {
+    console.log(JSON.stringify({
+      address: client.address,
+      chain: config.chain,
+      balance,
+      limits: config.limits
+    }, null, 2));
+  } else {
+    console.log("\n\u{1F4CA} MoltsPay Status\n");
+    console.log(`   Wallet: ${client.address}`);
+    console.log(`   Chain: ${config.chain}`);
+    console.log(`   Balance: ${balance.usdc.toFixed(2)} USDC`);
+    console.log(`   Native: ${balance.native.toFixed(6)} ETH`);
+    console.log("");
+    console.log("   Limits:");
+    console.log(`     Max per tx: $${config.limits.maxPerTx}`);
+    console.log(`     Max per day: $${config.limits.maxPerDay}`);
+    console.log("");
+  }
+});
+program.command("services <url>").description("List services from a provider").option("--json", "Output as JSON").action(async (url, options) => {
+  try {
+    const client = new MoltsPayClient();
+    const services = await client.getServices(url);
+    if (options.json) {
+      console.log(JSON.stringify(services, null, 2));
+    } else {
+      console.log(`
+\u{1F3EA} ${services.provider.name}
+`);
+      console.log(`   ${services.provider.description || ""}`);
+      console.log(`   Wallet: ${services.provider.wallet}`);
+      console.log(`   Chain: ${services.provider.chain}`);
+      console.log("\n\u{1F4E6} Services:\n");
+      for (const svc of services.services) {
+        const status = svc.available ? "\u2705" : "\u274C";
+        console.log(`   ${status} ${svc.id}`);
+        console.log(`      ${svc.name} - $${svc.price} ${svc.currency}`);
+        if (svc.description) {
+          console.log(`      ${svc.description}`);
+        }
+        console.log("");
+      }
+    }
+  } catch (err) {
+    console.error("\u274C Error:", err.message);
+  }
+});
+program.command("start <manifest>").description("Start MoltsPay server from services manifest").option("-p, --port <port>", "Port to listen on", "3000").option("--host <host>", "Host to bind", "0.0.0.0").action(async (manifest, options) => {
+  const manifestPath = resolve(manifest);
+  if (!existsSync2(manifestPath)) {
+    console.error(`\u274C Manifest not found: ${manifestPath}`);
+    process.exit(1);
+  }
+  const port = parseInt(options.port, 10);
+  const host = options.host;
+  console.log(`
+\u{1F680} Starting MoltsPay Server
+`);
+  console.log(`   Manifest: ${manifestPath}`);
+  console.log(`   Port: ${port}`);
+  console.log("");
+  try {
+    const server = new MoltsPayServer(manifestPath, { port, host });
+    const manifestContent = await import("fs").then(
+      (fs) => JSON.parse(fs.readFileSync(manifestPath, "utf-8"))
+    );
+    for (const service of manifestContent.services) {
+      if (service.command) {
+        const workdir = dirname(manifestPath);
+        server.skill(service.id, async (params) => {
+          return new Promise((resolve2, reject) => {
+            const proc = spawn("sh", ["-c", service.command], {
+              cwd: workdir,
+              stdio: ["pipe", "pipe", "pipe"]
+            });
+            let stdout = "";
+            let stderr = "";
+            proc.stdout.on("data", (data) => {
+              stdout += data.toString();
+            });
+            proc.stderr.on("data", (data) => {
+              stderr += data.toString();
+              process.stderr.write(data);
+            });
+            proc.stdin.write(JSON.stringify(params));
+            proc.stdin.end();
+            proc.on("close", (code) => {
+              if (code !== 0) {
+                reject(new Error(`Command failed (exit ${code}): ${stderr || "Unknown error"}`));
+                return;
+              }
+              try {
+                const result = JSON.parse(stdout.trim());
+                resolve2(result);
+              } catch {
+                resolve2({ output: stdout.trim() });
+              }
+            });
+            proc.on("error", (err) => {
+              reject(new Error(`Failed to spawn command: ${err.message}`));
+            });
+          });
+        });
+      }
+    }
+    const pidData = { pid: process.pid, port, manifest: manifestPath };
+    writeFileSync2(PID_FILE, JSON.stringify(pidData, null, 2));
+    console.log(`   PID file: ${PID_FILE}`);
+    console.log("");
+    server.listen(port);
+    const cleanup = () => {
+      try {
+        if (existsSync2(PID_FILE)) {
+          unlinkSync(PID_FILE);
+        }
+      } catch {
+      }
+    };
+    process.on("SIGINT", () => {
+      console.log("\n\n\u{1F44B} Shutting down...");
+      cleanup();
+      process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+      console.log("\n\n\u{1F44B} Shutting down...");
+      cleanup();
+      process.exit(0);
+    });
+    process.on("exit", cleanup);
+  } catch (err) {
+    console.error(`\u274C Failed to start server: ${err.message}`);
+    process.exit(1);
+  }
+});
+program.command("stop").description("Stop the running MoltsPay server").action(async () => {
+  if (!existsSync2(PID_FILE)) {
+    console.log("\u274C No running server found (no PID file)");
+    process.exit(1);
+  }
+  try {
+    const pidData = JSON.parse(readFileSync3(PID_FILE, "utf-8"));
+    const { pid, port, manifest } = pidData;
+    console.log(`
+\u{1F6D1} Stopping MoltsPay Server
+`);
+    console.log(`   PID: ${pid}`);
+    console.log(`   Port: ${port}`);
+    console.log(`   Manifest: ${manifest}`);
+    console.log("");
+    try {
+      process.kill(pid, 0);
+    } catch {
+      console.log("\u26A0\uFE0F  Process not running, cleaning up PID file...");
+      unlinkSync(PID_FILE);
+      process.exit(0);
+    }
+    process.kill(pid, "SIGTERM");
+    console.log("\u2705 Sent SIGTERM to server");
+    await new Promise((resolve2) => setTimeout(resolve2, 1e3));
+    try {
+      process.kill(pid, 0);
+      console.log("\u26A0\uFE0F  Server still running, sending SIGKILL...");
+      process.kill(pid, "SIGKILL");
+    } catch {
+    }
+    if (existsSync2(PID_FILE)) {
+      unlinkSync(PID_FILE);
+    }
+    console.log("\u2705 Server stopped\n");
+  } catch (err) {
+    console.error(`\u274C Failed to stop server: ${err.message}`);
+    process.exit(1);
+  }
+});
+program.command("pay <server> <service> [params]").description("Pay for a service and get the result").option("--prompt <text>", "Prompt for the service").option("--image <url>", "Image URL (for image-to-video)").option("--json", "Output raw JSON only").action(async (server, service, paramsJson, options) => {
+  const client = new MoltsPayClient();
+  if (!client.isInitialized) {
+    console.error("\u274C Wallet not initialized. Run: npx moltspay init");
+    process.exit(1);
+  }
+  let params = {};
+  if (paramsJson) {
+    try {
+      params = JSON.parse(paramsJson);
+    } catch {
+      console.error("\u274C Invalid JSON params");
+      process.exit(1);
+    }
+  }
+  if (options.prompt) params.prompt = options.prompt;
+  if (options.image) params.image_url = options.image;
+  if (!params.prompt) {
+    console.error("\u274C Missing prompt. Use --prompt or pass JSON params");
+    process.exit(1);
+  }
+  if (!options.json) {
+    console.log(`
+\u{1F4B3} MoltsPay - Paying for service
+`);
+    console.log(`   Server: ${server}`);
+    console.log(`   Service: ${service}`);
+    console.log(`   Prompt: ${params.prompt}`);
+    if (params.image_url) console.log(`   Image: ${params.image_url}`);
+    console.log(`   Wallet: ${client.address}`);
+    console.log("");
+  }
+  try {
+    const result = await client.pay(server, service, params);
+    if (options.json) {
+      console.log(JSON.stringify(result));
+    } else {
+      console.log("\u2705 Success!\n");
+      console.log(JSON.stringify(result, null, 2));
+      console.log("");
+    }
+  } catch (err) {
+    if (options.json) {
+      console.log(JSON.stringify({ error: err.message }));
+    } else {
+      console.error(`\u274C Error: ${err.message}`);
+    }
+    process.exit(1);
+  }
+});
+program.parse();
+//# sourceMappingURL=index.mjs.map