moltspay 0.8.10 → 0.8.13

package/README.md

@@ -330,9 +330,67 @@ Client Agent                    Server                     Facilitator (Coinbase
 - ❌ NO ETH/gas needed
 - ❌ NO API credentials needed
 
+## Server Setup (Selling Services)
+
+To run a MoltsPay server that accepts x402 payments:
+
+### 1. Configure CDP Credentials (Required for Mainnet)
+
+```bash
+# Copy the example config
+cp .env.example ~/.moltspay/.env
+
+# Edit with your CDP credentials (get from https://portal.cdp.coinbase.com/)
+nano ~/.moltspay/.env
+```
+
+```env
+# ~/.moltspay/.env
+USE_MAINNET=true
+CDP_API_KEY_ID=your-key-id
+CDP_API_KEY_SECRET=your-secret
+```
+
+**Important:** Server does NOT need a private key! The x402 facilitator handles all on-chain settlement.
+
+### 2. Create Services Manifest
+
+```json
+{
+  "provider": {
+    "name": "My AI Service",
+    "wallet": "0xYOUR_WALLET_ADDRESS",
+    "chain": "base"
+  },
+  "services": [
+    {
+      "id": "my-service",
+      "name": "My Service",
+      "price": 0.99,
+      "currency": "USDC",
+      "command": "./handlers/my-service.sh",
+      "input": { "prompt": { "type": "string", "required": true } },
+      "output": { "result": { "type": "string" } }
+    }
+  ]
+}
+```
+
+### 3. Start Server
+
+```bash
+npx moltspay start ./moltspay.services.json --port 3000
+```
+
+The server will:
+- Return 402 with payment requirements for unpaid requests
+- Verify signatures with CDP facilitator
+- Execute service only after payment verification
+- Settle payment on-chain (facilitator pays gas)
+
 ## CDP Wallet Support (Optional, Advanced)
 
-CDP wallet is an **optional alternative** for cases where you want Coinbase to host the wallet. Most users should use the simple local wallet above.
+CDP wallet is an **optional alternative** for **client agents** who want Coinbase to host their wallet. Most users should use the simple local wallet above.
 
 ```bash
 # Only if you have CDP credentials and want hosted wallet
@@ -445,8 +503,33 @@ const result = await permit.executePermitAndTransfer(
 # Install globally
 npm install -g moltspay
 
-# Get balance
-moltspay balance --chain base
+# === Client Commands ===
+
+# Initialize wallet (first time setup)
+npx moltspay init --chain base
+
+# Check wallet status and balance
+npx moltspay status
+
+# Update spending limits
+npx moltspay config                              # Interactive
+npx moltspay config --max-per-tx 50 --max-per-day 500  # Direct
+
+# Pay for a service
+npx moltspay pay http://server:3000 service-id --prompt "your prompt"
+
+# List services from a provider
+npx moltspay services http://server:3000
+
+# === Server Commands ===
+
+# Start server from services manifest
+npx moltspay start ./moltspay.services.json --port 3000
+
+# Stop running server
+npx moltspay stop
+
+# === Legacy Commands ===
 
 # Generate invoice
 moltspay invoice --order order_123 --amount 2.0 --service video

package/dist/cli/index.js

@@ -116,6 +116,7 @@ var MoltsPayClient = class {
     this.configDir = options.configDir || (0, import_path.join)((0, import_os.homedir)(), ".moltspay");
     this.config = this.loadConfig();
     this.walletData = this.loadWallet();
+    this.loadSpending();
     if (this.walletData) {
       this.wallet = new import_ethers.Wallet(this.walletData.privateKey);
     }
@@ -300,6 +301,7 @@ var MoltsPayClient = class {
     if (today > this.lastSpendingReset) {
       this.todaySpending = 0;
       this.lastSpendingReset = today;
+      this.saveSpending();
     }
     if (this.todaySpending + amount > this.config.limits.maxPerDay) {
       throw new Error(
@@ -308,10 +310,11 @@ var MoltsPayClient = class {
     }
   }
   /**
-   * Record spending
+   * Record spending and persist to disk
    */
   recordSpending(amount) {
     this.todaySpending += amount;
+    this.saveSpending();
   }
   // --- Config & Wallet Management ---
   loadConfig() {
@@ -327,9 +330,54 @@ var MoltsPayClient = class {
     const configPath = (0, import_path.join)(this.configDir, "config.json");
     (0, import_fs.writeFileSync)(configPath, JSON.stringify(this.config, null, 2));
   }
+  /**
+   * Load spending data from disk
+   */
+  loadSpending() {
+    const spendingPath = (0, import_path.join)(this.configDir, "spending.json");
+    if ((0, import_fs.existsSync)(spendingPath)) {
+      try {
+        const data = JSON.parse((0, import_fs.readFileSync)(spendingPath, "utf-8"));
+        const today = (/* @__PURE__ */ new Date()).setHours(0, 0, 0, 0);
+        if (data.date && data.date === today) {
+          this.todaySpending = data.amount || 0;
+          this.lastSpendingReset = data.date;
+        } else {
+          this.todaySpending = 0;
+          this.lastSpendingReset = today;
+        }
+      } catch {
+        this.todaySpending = 0;
+        this.lastSpendingReset = (/* @__PURE__ */ new Date()).setHours(0, 0, 0, 0);
+      }
+    }
+  }
+  /**
+   * Save spending data to disk
+   */
+  saveSpending() {
+    (0, import_fs.mkdirSync)(this.configDir, { recursive: true });
+    const spendingPath = (0, import_path.join)(this.configDir, "spending.json");
+    const data = {
+      date: this.lastSpendingReset || (/* @__PURE__ */ new Date()).setHours(0, 0, 0, 0),
+      amount: this.todaySpending,
+      updatedAt: Date.now()
+    };
+    (0, import_fs.writeFileSync)(spendingPath, JSON.stringify(data, null, 2));
+  }
   loadWallet() {
     const walletPath = (0, import_path.join)(this.configDir, "wallet.json");
     if ((0, import_fs.existsSync)(walletPath)) {
+      try {
+        const stats = (0, import_fs.statSync)(walletPath);
+        const mode = stats.mode & 511;
+        if (mode !== 384) {
+          console.warn(`[MoltsPay] WARNING: wallet.json has insecure permissions (${mode.toString(8)})`);
+          console.warn(`[MoltsPay] Fixing permissions to 0600...`);
+          (0, import_fs.chmodSync)(walletPath, 384);
+        }
+      } catch (err) {
+      }
       const content = (0, import_fs.readFileSync)(walletPath, "utf-8");
       return JSON.parse(content);
     }
@@ -347,7 +395,7 @@ var MoltsPayClient = class {
       createdAt: Date.now()
     };
     const walletPath = (0, import_path.join)(configDir, "wallet.json");
-    (0, import_fs.writeFileSync)(walletPath, JSON.stringify(walletData, null, 2));
+    (0, import_fs.writeFileSync)(walletPath, JSON.stringify(walletData, null, 2), { mode: 384 });
     const config = {
       chain: options.chain,
       limits: {
@@ -659,10 +707,14 @@ var MoltsPayServer = class {
    */
   sendPaymentRequired(config, res) {
     const requirements = this.buildPaymentRequirements(config);
-    requirements.description = `${config.name} - $${config.price} ${config.currency}`;
     const paymentRequired = {
       x402Version: X402_VERSION2,
-      accepts: [requirements]
+      accepts: [requirements],
+      resource: {
+        url: `/execute?service=${config.id}`,
+        description: `${config.name} - $${config.price} ${config.currency}`,
+        mimeType: "application/json"
+      }
     };
     const encoded = Buffer.from(JSON.stringify(paymentRequired)).toString("base64");
     res.writeHead(402, {
@@ -701,9 +753,8 @@ var MoltsPayServer = class {
     return {
       scheme: "exact",
       network: this.networkId,
-      maxAmountRequired: amountInUnits,
-      amount: amountInUnits,
       asset: usdcAddress,
+      amount: amountInUnits,
       payTo: this.manifest.provider.wallet,
       maxTimeoutSeconds: 300,
       extra: USDC_DOMAIN
@@ -960,75 +1011,141 @@ program.command("services <url>").description("List services from a provider").o
     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").option("--facilitator <url>", "x402 facilitator URL (default: https://x402.org/facilitator)").action(async (manifest, options) => {
-  const manifestPath = (0, import_path2.resolve)(manifest);
-  if (!(0, import_fs3.existsSync)(manifestPath)) {
-    console.error(`\u274C Manifest not found: ${manifestPath}`);
-    process.exit(1);
-  }
+program.command("start <paths...>").description("Start MoltsPay server from skill directories or manifest files").option("-p, --port <port>", "Port to listen on", "3000").option("--host <host>", "Host to bind", "0.0.0.0").option("--facilitator <url>", "x402 facilitator URL (default: https://x402.org/facilitator)").action(async (paths, options) => {
   const port = parseInt(options.port, 10);
   const host = options.host;
   const facilitatorUrl = options.facilitator;
+  const allPaths = paths.flatMap((p) => p.split(",").map((s) => s.trim())).filter(Boolean);
   console.log(`
 \u{1F680} Starting MoltsPay Server (x402 protocol)
 `);
-  console.log(`   Manifest: ${manifestPath}`);
-  console.log(`   Port: ${port}`);
-  console.log("");
-  try {
-    const server = new MoltsPayServer(manifestPath, { port, host, facilitatorUrl });
-    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 = (0, import_path2.dirname)(manifestPath);
-        server.skill(service.id, async (params) => {
-          return new Promise((resolve2, reject) => {
-            const proc = (0, import_child_process.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 allServices = [];
+  const handlers = /* @__PURE__ */ new Map();
+  let provider = null;
+  for (const inputPath of allPaths) {
+    const resolvedPath = (0, import_path2.resolve)(inputPath);
+    let manifestPath;
+    let skillDir;
+    let isSkillDir = false;
+    if ((0, import_fs3.existsSync)((0, import_path2.join)(resolvedPath, "moltspay.services.json"))) {
+      manifestPath = (0, import_path2.join)(resolvedPath, "moltspay.services.json");
+      skillDir = resolvedPath;
+      isSkillDir = true;
+    } else if ((0, import_fs3.existsSync)(resolvedPath) && resolvedPath.endsWith(".json")) {
+      manifestPath = resolvedPath;
+      skillDir = (0, import_path2.dirname)(resolvedPath);
+    } else if ((0, import_fs3.existsSync)(resolvedPath)) {
+      console.error(`\u274C No moltspay.services.json found in: ${resolvedPath}`);
+      continue;
+    } else {
+      console.error(`\u274C Path not found: ${resolvedPath}`);
+      continue;
+    }
+    console.log(`\u{1F4E6} Loading: ${manifestPath}`);
+    try {
+      const manifestContent = JSON.parse((0, import_fs3.readFileSync)(manifestPath, "utf-8"));
+      if (!provider) {
+        provider = manifestContent.provider;
+      }
+      let skillModule = null;
+      if (isSkillDir) {
+        const indexPath = (0, import_path2.join)(skillDir, "index.js");
+        if ((0, import_fs3.existsSync)(indexPath)) {
+          try {
+            skillModule = await import(indexPath);
+            console.log(`   \u2705 Loaded module: ${indexPath}`);
+          } catch (err) {
+            console.error(`   \u26A0\uFE0F  Failed to load module: ${err.message}`);
+          }
+        }
+      }
+      for (const service of manifestContent.services) {
+        allServices.push(service);
+        if (service.function && skillModule) {
+          const fn = skillModule[service.function] || skillModule.default?.[service.function];
+          if (fn && typeof fn === "function") {
+            handlers.set(service.id, fn);
+            console.log(`   \u2705 ${service.id} \u2192 ${service.function}()`);
+          } else {
+            console.error(`   \u274C Function '${service.function}' not found in index.js`);
+          }
+        } else if (service.command) {
+          const workdir = skillDir;
+          handlers.set(service.id, async (params) => {
+            return new Promise((resolvePromise, reject) => {
+              const proc = (0, import_child_process.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 {
+                  resolvePromise(JSON.parse(stdout.trim()));
+                } catch {
+                  resolvePromise({ output: stdout.trim() });
+                }
+              });
+              proc.on("error", (err) => {
+                reject(new Error(`Failed to spawn command: ${err.message}`));
+              });
             });
           });
-        });
+          console.log(`   \u2705 ${service.id} \u2192 command`);
+        } else {
+          console.warn(`   \u26A0\uFE0F  ${service.id}: no function or command defined`);
+        }
       }
+    } catch (err) {
+      console.error(`\u274C Failed to load ${manifestPath}: ${err.message}`);
+      continue;
     }
-    const pidData = { pid: process.pid, port, manifest: manifestPath };
+  }
+  if (allServices.length === 0) {
+    console.error("\n\u274C No services loaded. Exiting.");
+    process.exit(1);
+  }
+  if (!provider) {
+    console.error("\n\u274C No provider config found. Exiting.");
+    process.exit(1);
+  }
+  const combinedManifest = {
+    provider,
+    services: allServices
+  };
+  const tempManifestPath = (0, import_path2.join)(DEFAULT_CONFIG_DIR, "combined-manifest.json");
+  (0, import_fs3.writeFileSync)(tempManifestPath, JSON.stringify(combinedManifest, null, 2));
+  console.log(`
+\u{1F4CB} Combined manifest: ${allServices.length} services`);
+  console.log(`   Provider: ${provider.name}`);
+  console.log(`   Wallet: ${provider.wallet}`);
+  console.log(`   Port: ${port}`);
+  console.log("");
+  try {
+    const server = new MoltsPayServer(tempManifestPath, { port, host, facilitatorUrl });
+    for (const [serviceId, handler] of handlers) {
+      server.skill(serviceId, handler);
+    }
+    const pidData = { pid: process.pid, port, paths: allPaths };
     (0, import_fs3.writeFileSync)(PID_FILE, JSON.stringify(pidData, null, 2));
-    console.log(`   PID file: ${PID_FILE}`);
-    console.log("");
     server.listen(port);
     const cleanup = () => {
       try {
-        if ((0, import_fs3.existsSync)(PID_FILE)) {
-          (0, import_fs3.unlinkSync)(PID_FILE);
-        }
+        if ((0, import_fs3.existsSync)(PID_FILE)) (0, import_fs3.unlinkSync)(PID_FILE);
+        if ((0, import_fs3.existsSync)(tempManifestPath)) (0, import_fs3.unlinkSync)(tempManifestPath);
       } catch {
       }
     };