moltspay 0.8.10 → 0.8.13

package/dist/cli/index.mjs

@@ -8,7 +8,7 @@ import { existsSync as existsSync3, writeFileSync as writeFileSync2, readFileSyn
 import { spawn } from "child_process";
 
 // src/client/index.ts
-import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { existsSync, readFileSync, writeFileSync, mkdirSync, statSync, chmodSync } from "fs";
 import { homedir } from "os";
 import { join } from "path";
 import { Wallet, ethers } from "ethers";
@@ -93,6 +93,7 @@ var MoltsPayClient = class {
     this.configDir = options.configDir || join(homedir(), ".moltspay");
     this.config = this.loadConfig();
     this.walletData = this.loadWallet();
+    this.loadSpending();
     if (this.walletData) {
       this.wallet = new Wallet(this.walletData.privateKey);
     }
@@ -277,6 +278,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(
@@ -285,10 +287,11 @@ var MoltsPayClient = class {
     }
   }
   /**
-   * Record spending
+   * Record spending and persist to disk
    */
   recordSpending(amount) {
     this.todaySpending += amount;
+    this.saveSpending();
   }
   // --- Config & Wallet Management ---
   loadConfig() {
@@ -304,9 +307,54 @@ var MoltsPayClient = class {
     const configPath = join(this.configDir, "config.json");
     writeFileSync(configPath, JSON.stringify(this.config, null, 2));
   }
+  /**
+   * Load spending data from disk
+   */
+  loadSpending() {
+    const spendingPath = join(this.configDir, "spending.json");
+    if (existsSync(spendingPath)) {
+      try {
+        const data = JSON.parse(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() {
+    mkdirSync(this.configDir, { recursive: true });
+    const spendingPath = join(this.configDir, "spending.json");
+    const data = {
+      date: this.lastSpendingReset || (/* @__PURE__ */ new Date()).setHours(0, 0, 0, 0),
+      amount: this.todaySpending,
+      updatedAt: Date.now()
+    };
+    writeFileSync(spendingPath, JSON.stringify(data, null, 2));
+  }
   loadWallet() {
     const walletPath = join(this.configDir, "wallet.json");
     if (existsSync(walletPath)) {
+      try {
+        const stats = 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...`);
+          chmodSync(walletPath, 384);
+        }
+      } catch (err) {
+      }
       const content = readFileSync(walletPath, "utf-8");
       return JSON.parse(content);
     }
@@ -324,7 +372,7 @@ var MoltsPayClient = class {
       createdAt: Date.now()
     };
     const walletPath = join(configDir, "wallet.json");
-    writeFileSync(walletPath, JSON.stringify(walletData, null, 2));
+    writeFileSync(walletPath, JSON.stringify(walletData, null, 2), { mode: 384 });
     const config = {
       chain: options.chain,
       limits: {
@@ -636,10 +684,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, {
@@ -678,9 +730,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
@@ -937,75 +988,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 = resolve(manifest);
-  if (!existsSync3(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 = 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 allServices = [];
+  const handlers = /* @__PURE__ */ new Map();
+  let provider = null;
+  for (const inputPath of allPaths) {
+    const resolvedPath = resolve(inputPath);
+    let manifestPath;
+    let skillDir;
+    let isSkillDir = false;
+    if (existsSync3(join3(resolvedPath, "moltspay.services.json"))) {
+      manifestPath = join3(resolvedPath, "moltspay.services.json");
+      skillDir = resolvedPath;
+      isSkillDir = true;
+    } else if (existsSync3(resolvedPath) && resolvedPath.endsWith(".json")) {
+      manifestPath = resolvedPath;
+      skillDir = dirname(resolvedPath);
+    } else if (existsSync3(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(readFileSync3(manifestPath, "utf-8"));
+      if (!provider) {
+        provider = manifestContent.provider;
+      }
+      let skillModule = null;
+      if (isSkillDir) {
+        const indexPath = join3(skillDir, "index.js");
+        if (existsSync3(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 = 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 = join3(DEFAULT_CONFIG_DIR, "combined-manifest.json");
+  writeFileSync2(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 };
     writeFileSync2(PID_FILE, JSON.stringify(pidData, null, 2));
-    console.log(`   PID file: ${PID_FILE}`);
-    console.log("");
     server.listen(port);
     const cleanup = () => {
       try {
-        if (existsSync3(PID_FILE)) {
-          unlinkSync(PID_FILE);
-        }
+        if (existsSync3(PID_FILE)) unlinkSync(PID_FILE);
+        if (existsSync3(tempManifestPath)) unlinkSync(tempManifestPath);
       } catch {
       }
     };