routstrd 0.2.21 → 0.3.0

package/src/cli.ts

@@ -231,7 +231,8 @@ program
     "Mint URL to refund to (defaults to first mint in wallet)",
   )
   .option("-y, --yes", "Skip confirmation prompt", false)
-  .action(async (options: { mintUrl?: string; yes: boolean }) => {
+  .option("--xcashu", "Refund xcashu tokens only (uses refundXcashuTokens)", false)
+  .action(async (options: { mintUrl?: string; yes: boolean; xcashu: boolean }) => {
     await ensureDaemonRunning();
 
     let mintUrl = options.mintUrl;
@@ -257,6 +258,36 @@ program
     }
 
     try {
+      if (options.xcashu) {
+        // xcashu path: only refund xcashu tokens
+        const result = await callDaemon("/refund/xcashu", {
+          method: "POST",
+          body: { mintUrl },
+        });
+
+        if (result.error) {
+          console.log(result.error);
+          process.exit(1);
+        }
+
+        const output = result.output as
+          | {
+              message: string;
+              results: Array<{ baseUrl: string; token: string; success: boolean; error?: string }>;
+            }
+          | undefined;
+
+        if (output) {
+          console.log(output.message);
+          console.log("\nResults:");
+          for (const r of output.results) {
+            const status = r.success ? "success" : `failed: ${r.error || "unknown"}`;
+            console.log(`  - ${r.baseUrl}: ${status}`);
+          }
+        }
+        return;
+      }
+
       const result = await callDaemon("/refund", {
         method: "POST",
         body: { mintUrl },
@@ -1253,6 +1284,114 @@ walletMintsCmd
     });
   });
 
+// ── NWC (Nostr Wallet Connect) commands ─────────────────────────
+
+const nwcCmd = program
+  .command("nwc")
+  .description("Manage NWC (Nostr Wallet Connect) integration");
+
+nwcCmd
+  .command("connect")
+  .description("Connect to a Lightning wallet via NWC")
+  .argument("[connection-string]", "NWC connection string (nostr+walletconnect://...)")
+  .action(async (connectionString?: string) => {
+    if (!connectionString) {
+      // Interactive mode: prompt for connection string
+      const rl = require("readline").createInterface({
+        input: process.stdin,
+        output: process.stdout,
+      });
+      connectionString = await new Promise<string>((resolve) => {
+        rl.question("Paste your NWC connection string: ", (answer: string) => {
+          rl.close();
+          resolve(answer.trim());
+        });
+      });
+    }
+
+    // Quick validation: must be nostr+walletconnect:// with a 64-char hex pubkey
+    if (!/^nostr\+walletconnect:\/\/[0-9a-fA-F]{64}\?relay=/.test(connectionString)) {
+      console.error("Invalid NWC connection string: expected nostr+walletconnect://<64-char-hex>?relay=...");
+      process.exit(1);
+    }
+
+    await handleDaemonCommand("/nwc/connect", {
+      method: "POST",
+      body: { connectionString },
+    });
+  });
+
+nwcCmd
+  .command("disconnect")
+  .description("Disconnect from NWC wallet")
+  .action(async () => {
+    await handleDaemonCommand("/nwc/disconnect", {
+      method: "POST",
+    });
+  });
+
+nwcCmd
+  .command("status")
+  .description("Show NWC connection status and wallet info")
+  .action(async () => {
+    await handleDaemonCommand("/nwc/status");
+  });
+
+nwcCmd
+  .command("fund <amount>")
+  .description("Manually fund the Cashu wallet from the connected NWC wallet")
+  .action(async (amount: string) => {
+    const parsedAmount = parsePositiveIntOrExit(amount, "amount");
+    await handleDaemonCommand("/nwc/fund", {
+      method: "POST",
+      body: { amount: parsedAmount },
+    });
+  });
+
+const autoRefillCmd = nwcCmd
+  .command("auto-refill")
+  .description("Manage automatic wallet refill from NWC");
+
+autoRefillCmd
+  .command("on")
+  .description("Enable auto-refill")
+  .option(
+    "--threshold <sats>",
+    "Refill when Cashu balance drops below this many sats",
+    "500",
+  )
+  .option("--amount <sats>", "Refill this many sats at a time", "1000")
+  .option(
+    "--cooldown <seconds>",
+    "Minimum time between refills in seconds",
+    "300",
+  )
+  .action(async (options: { threshold: string; amount: string; cooldown: string }) => {
+    const threshold = parsePositiveIntOrExit(options.threshold, "threshold");
+    const amount = parsePositiveIntOrExit(options.amount, "amount");
+    const cooldownSec = parsePositiveIntOrExit(options.cooldown, "cooldown");
+
+    await handleDaemonCommand("/nwc/auto-refill", {
+      method: "POST",
+      body: {
+        enabled: true,
+        threshold,
+        amount,
+        cooldownMs: cooldownSec * 1000,
+      },
+    });
+  });
+
+autoRefillCmd
+  .command("off")
+  .description("Disable auto-refill")
+  .action(async () => {
+    await handleDaemonCommand("/nwc/auto-refill", {
+      method: "POST",
+      body: { enabled: false },
+    });
+  });
+
 // Stop
 program
   .command("stop")

package/src/daemon/config-store.ts

@@ -1,5 +1,5 @@
 import { mkdir } from "fs/promises";
-import { existsSync } from "fs";
+import { existsSync, readFileSync } from "fs";
 import {
   CONFIG_DIR,
   CONFIG_FILE,
@@ -31,6 +31,18 @@ export async function loadDaemonConfig(): Promise<RoutstrdConfig> {
   return DEFAULT_CONFIG;
 }
 
+export function loadDaemonConfigSync(): RoutstrdConfig {
+  try {
+    if (existsSync(CONFIG_FILE)) {
+      const content = readFileSync(CONFIG_FILE, "utf-8");
+      return { ...DEFAULT_CONFIG, ...JSON.parse(content) };
+    }
+  } catch (error) {
+    logger.error("Failed to load config:", error);
+  }
+  return DEFAULT_CONFIG;
+}
+
 export function saveDaemonConfig(config: RoutstrdConfig): void {
   Bun.write(CONFIG_FILE, JSON.stringify(config, null, 2));
 }

package/src/daemon/wallet/auto-refill.ts

@@ -0,0 +1,192 @@
+// Auto-refill loop for routstrd
+// Monitors Cocod Cashu balance and triggers NWC funding when below threshold.
+// This runs server-side, so refills happen regardless of whether a frontend is open.
+//
+// Uses applesauce-wallet-connect (same approach as nwc_integration/pay_invoice.mts).
+
+import type { CocodClient } from "./cocod-client";
+import type { WalletConnect } from "applesauce-wallet-connect";
+import { logger } from "../../utils/logger";
+
+export interface AutoRefillConfig {
+  /** Minimum sats balance before triggering a refill */
+  threshold: number;
+  /** Amount of sats to refill each time */
+  amount: number;
+  /** Minimum time between refills (milliseconds) */
+  cooldownMs: number;
+  /** Maximum consecutive failures before stopping (0 = never stop on failures) */
+  maxConsecutiveFailures?: number;
+}
+
+// Errors that cannot be resolved by retrying — the user must intervene.
+const FATAL_ERROR_PATTERNS = [
+  /insufficient (?:balance|funds)/i,
+  /invalid (?:credentials|auth)/i,
+  /forbidden/i,
+  /unauthorized/i,
+  /invoice.*expired/i,
+];
+
+function isFatalError(message: string): boolean {
+  return FATAL_ERROR_PATTERNS.some((pattern) => pattern.test(message));
+}
+
+export function startAutoRefillLoop(
+  cocod: CocodClient,
+  getWallet: () => WalletConnect | undefined,
+  getConfig: () => AutoRefillConfig | undefined,
+  intervalMs: number = 5000,
+): () => void {
+  let lastRefillAt = 0;
+  let lastAttemptAt = 0; // tracks last attempt (success or failure) for backoff
+  let running = true;
+  let timeout: ReturnType<typeof setInterval> | null = null;
+  let checkInProgress = false;
+  let consecutiveFailures = 0;
+
+  async function checkAndRefill(): Promise<void> {
+    if (!running) return;
+    if (checkInProgress) return;
+    const wallet = getWallet();
+    if (!wallet?.service) {
+      // NWC not connected — nothing to do
+      return;
+    }
+
+    // Read config fresh each cycle so changes apply without restart
+    const config = getConfig();
+    if (!config) {
+      // Auto-refill disabled
+      return;
+    }
+
+    const now = Date.now();
+    if (now - lastRefillAt < config.cooldownMs) {
+      return;
+    }
+
+    checkInProgress = true;
+
+    // If we've been failing too much, back off rather than retrying at full speed.
+    // This prevents tight loops on transient errors.
+    const backoffInterval = Math.min(
+      intervalMs * Math.pow(2, consecutiveFailures),
+      5 * 60 * 1000, // cap at 5 minutes
+    );
+    if (now - lastAttemptAt < backoffInterval) {
+      return;
+    }
+
+    try {
+      const balances = await cocod.getBalances();
+      const totalBalance = Object.values(balances).reduce<number>(
+        (sum, b) => sum + (typeof b === "number" ? b : 0),
+        0,
+      );
+
+      if (totalBalance >= config.threshold) {
+        // Balance is sufficient
+        return;
+      }
+
+      logger.log(
+        `[auto-refill] Balance ${totalBalance} sats < threshold ${config.threshold}. Refilling ${config.amount} sats...`,
+      );
+
+      // Get active mint
+      const mints = await cocod.listMints();
+      const mintUrl = mints[0];
+      if (!mintUrl) {
+        logger.error("[auto-refill] No active mint configured");
+        return;
+      }
+
+      // Step 1: Create a BOLT-11 invoice via cocod to fund the Cashu wallet
+      logger.log(
+        `[auto-refill] Creating BOLT-11 invoice for ${config.amount} sats via ${mintUrl}...`,
+      );
+      const invoice = await cocod.receiveBolt11(config.amount, mintUrl);
+
+      // Step 2: Pay the invoice via NWC (applesauce)
+      logger.log(`[auto-refill] Paying invoice via NWC...`);
+      const currentWallet = getWallet();
+      if (!currentWallet?.service) {
+        logger.log("[auto-refill] Wallet disconnected during refill check");
+        return;
+      }
+      const payment = await currentWallet.payInvoice(invoice);
+
+      // Step 3: The Cashu mint should automatically detect the paid invoice
+      // and issue tokens. We don't need to explicitly mint here; cocod
+      // handles this on its end when the mint sees the payment.
+      const preimage = payment.preimage;
+      if (preimage) {
+        logger.log(
+          `[auto-refill] Successfully refilled ${config.amount} sats. Preimage: ${preimage.slice(0, 16)}...`,
+        );
+      } else {
+        logger.log(
+          `[auto-refill] Successfully refilled ${config.amount} sats (no preimage returned).`,
+        );
+      }
+      if (payment.fees_paid !== undefined) {
+        logger.log(`[auto-refill] Fees paid: ${payment.fees_paid} msats`);
+      }
+      lastRefillAt = now;
+      lastAttemptAt = now;
+      consecutiveFailures = 0; // reset on success
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      lastAttemptAt = now; // track for backoff regardless of success/failure
+      consecutiveFailures++;
+
+      if (isFatalError(message)) {
+        // Cooldown for 10 minutes — the user likely needs to fund their NWC wallet.
+        // We don't stop permanently so it auto-recovers without a restart.
+        // Set lastRefillAt into the future so all time-gate checks block.
+        const FATAL_COOLDOWN_MS = 10 * 60 * 1000;
+        logger.error(
+          `[auto-refill] FATAL: ${message}. The funding wallet (NWC) cannot pay. ` +
+            `Cooling down for ${FATAL_COOLDOWN_MS / 60000} minutes. ` +
+            `Fund your NWC wallet and auto-refill will retry automatically.`,
+        );
+        lastRefillAt = now + FATAL_COOLDOWN_MS;
+        consecutiveFailures = 0; // reset — no point counting these as transient backoffs
+        checkInProgress = false;
+        return;
+      }
+
+      const maxFailures = config.maxConsecutiveFailures ?? 0;
+      if (maxFailures > 0 && consecutiveFailures >= maxFailures) {
+        logger.error(
+          `[auto-refill] Stopping after ${consecutiveFailures} consecutive failures (maxConsecutiveFailures=${maxFailures}). ` +
+            `Last error: ${message}`,
+        );
+        running = false;
+        return;
+      }
+
+      logger.error(
+        `[auto-refill] Error (attempt ${consecutiveFailures}, next in ${Math.round(backoffInterval / 1000)}s): ${message}`,
+      );
+    } finally {
+      checkInProgress = false;
+    }
+  }
+
+  // Check immediately on start
+  checkAndRefill();
+
+  // Then poll on interval
+  timeout = setInterval(checkAndRefill, intervalMs);
+
+  return () => {
+    running = false;
+    if (timeout) {
+      clearInterval(timeout);
+      timeout = null;
+    }
+    logger.log("[auto-refill] Stopped");
+  };
+}

package/src/start-daemon.ts

@@ -28,7 +28,7 @@ async function startDaemonUnlocked(
   const startupTimeoutMs = 10 * 60 * 1000;
 
   if (await isDaemonHealthy(port)) {
-    logger.log(`Routstr daemon already running on http://localhost:${port}/v1`);
+    console.log(`Routstr daemon already running on http://localhost:${port}/v1`);
     return;
   }
 
@@ -43,8 +43,8 @@ async function startDaemonUnlocked(
   const shellCmd = `bun run "${daemonScript}" ${args.map((a) => `'${a}'`).join(" ")}`;
 
   const proc = Bun.spawn(["sh", "-c", shellCmd], {
-    stdout: "inherit",
-    stderr: "inherit",
+    stdout: "ignore",
+    stderr: "ignore",
     stdin: "ignore",
     detached: true,
   });
@@ -67,7 +67,7 @@ async function startDaemonUnlocked(
     }
 
     if (await isDaemonHealthy(port)) {
-      logger.log(`Routstr daemon started (PID: ${proc.pid}).`);
+      console.log(`Routstr daemon started (PID: ${proc.pid}).`);
       return;
     }
   }
@@ -84,7 +84,7 @@ export async function startDaemon(
   const startupTimeoutMs = 10 * 60 * 1000;
 
   if (await isDaemonHealthy(port)) {
-    logger.log(`Routstr daemon already running on http://localhost:${port}/v1`);
+    console.log(`Routstr daemon already running on http://localhost:${port}/v1`);
     return;
   }
 

package/src/utils/config.ts

@@ -7,6 +7,28 @@ export const DB_PATH = `${CONFIG_DIR}/routstr.db`;
 export const CONFIG_FILE = `${CONFIG_DIR}/config.json`;
 export const LOGS_DIR = `${CONFIG_DIR}/logs`;
 
+/** NWC auto-refill configuration */
+export interface NwcAutoRefillConfig {
+  /** Whether auto-refill is enabled */
+  enabled: boolean;
+  /** Refill when Cashu balance drops below this many sats */
+  threshold: number;
+  /** Refill this many sats at a time */
+  amount: number;
+  /** Minimum time between refills in milliseconds */
+  cooldownMs: number;
+}
+
+/** NWC configuration section */
+export interface NwcConfig {
+  /** NWC mode: "funding_source" = NWC funds the cocod Cashu wallet */
+  mode: "funding_source" | "standalone";
+  /** NWC connection string (nostr+walletconnect://...) */
+  connectionString?: string;
+  /** Auto-refill settings */
+  autoRefill?: NwcAutoRefillConfig;
+}
+
 export interface RoutstrdConfig {
   port: number;
   provider: string | null;
@@ -16,6 +38,8 @@ export interface RoutstrdConfig {
   nsec?: string;
   /** Nostr hex pubkey for routstr review/model events (kind 38425/38423). */
   routstrPubkey?: string;
+  /** NWC integration configuration */
+  nwc?: NwcConfig;
 }
 
 export const DEFAULT_CONFIG: RoutstrdConfig = {

package/src/utils/logger.ts

@@ -48,18 +48,18 @@ async function writeLog(level: string, ...args: unknown[]) {
 
 export const logger = {
   log: (...args: unknown[]) => {
-    console.log(...args);
     writeLog("INFO", ...args);
   },
   debug: (...args: unknown[]) => {
     writeLog("DEBUG", ...args);
   },
+  warn: (...args: unknown[]) => {
+    writeLog("WARN", ...args);
+  },
   error: (...args: unknown[]) => {
-    console.error(...args);
     writeLog("ERROR", ...args);
   },
   info: (...args: unknown[]) => {
-    console.log(...args);
     writeLog("INFO", ...args);
   },
 };