routstrd 0.2.22 → 0.3.0

package/docker-compose.yml

@@ -1,14 +1,15 @@
 services:
-  bun:
+  routstrd:
     build: .
-    container_name: routstrd-bun
-    working_dir: /app
-    volumes:
-      - .:/app
-      - bun_home:/root/.bun
+    container_name: routstrd
     stdin_open: true
     tty: true
+    volumes:
+      - routstrd_data:/data
+    ports:
+      - "8008:8008"
+    restart: unless-stopped
     command: /bin/bash
 
 volumes:
-  bun_home:
+  routstrd_data:

package/new-task.md

@@ -0,0 +1,60 @@
+# Hot-reload NWC connection (remove restart requirement)
+
+## Problem
+
+`nwc connect` and `nwc disconnect` require a daemon restart to take effect. The
+CLI writes the new connection string to disk, but the daemon never re-reads it.
+
+## Current flow
+
+1. **Startup** — `createWalletAdapter` reads `options.nwcConnectionString` and
+   creates a `WalletConnect` (relay pool + NWC wallet service) once:
+   ```ts
+   // src/daemon/wallet/index.ts:70-78
+   if (options.nwcConnectionString) {
+     wallet = WalletConnect.fromConnectURI(options.nwcConnectionString, { pool });
+   }
+   ```
+
+2. **CLI `nwc connect`** — HTTP handler at `POST /nwc/connect` only calls
+   `saveDaemonConfig(config)`. The running `WalletConnect` instance is untouched.
+
+3. **Result** — the old connection (or lack thereof) stays active until restart.
+
+## What needs to happen
+
+Provide a way for the daemon to tear down the old `WalletConnect` and create a
+new one from the updated connection string, triggered by the HTTP handler,
+**without restarting the process**.
+
+### Key pieces
+
+- **`src/daemon/wallet/index.ts`** — `createWalletAdapter` needs to expose a
+  `reconnect(connectionString: string)` method that:
+  - Closes the old relay pool / WalletConnect
+  - Creates a new `WalletConnect` from the new connection string
+  - Updates the adapter's internal `wallet` reference
+  - If connection string is empty/undefined, disconnects and sets `wallet` to
+    `undefined`
+  
+- **`src/daemon/http/index.ts`** — `POST /nwc/connect` and `POST /nwc/disconnect`
+  handlers should call `reconnect()` after saving config, and drop the "Restart
+  daemon" message.
+
+- **`src/daemon/index.ts`** — may need to store the `reconnect` function and pass
+  it through `DaemonDeps` to the HTTP handler.
+
+- **`src/cli.ts`** — remove `console.log("\nRun 'routstrd restart' to connect...")`
+  from the connect/disconnect commands.
+
+### Considerations
+
+- The `WalletConnect` instance is referenced in the auto-refill loop (passed to
+  `startAutoRefillLoop`). After a reconnect, the auto-refill loop's captured
+  `wallet` reference would be stale. The loop already reads config from disk
+  each cycle, so it should also reference the latest `wallet` instance.
+  - Could make the auto-refill loop accept a `getWallet: () => WalletConnect |
+    undefined` getter, same pattern as the config getter.
+- Relay pool cleanup — `applesauce-wallet-connect` / `applesauce-relay` may need
+  explicit `pool.close()` or `pool.destroy()` to free connections.
+- Edge case: a refill is in progress when reconnect is triggered.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "routstrd",
-  "version": "0.2.22",
+  "version": "0.3.0",
   "module": "src/index.ts",
   "type": "module",
   "private": false,
@@ -27,6 +27,7 @@
     "@routstr/sdk": "^0.3.8",
     "applesauce-core": "^5.1.0",
     "applesauce-relay": "^5.1.0",
+    "applesauce-wallet-connect": "^6.0.0",
     "commander": "^14.0.2",
     "nostr-tools": "^2.12.0",
     "qrcode": "^1.5.4",

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/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 = {