routstrd 0.2.22 → 0.3.1

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.1",
   "module": "src/index.ts",
   "type": "module",
   "private": false,
@@ -24,9 +24,10 @@
   },
   "dependencies": {
     "@cashu/cashu-ts": "^4.3.0",
-    "@routstr/sdk": "^0.3.8",
+    "@routstr/sdk": "^0.3.9",
     "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

@@ -3,6 +3,7 @@ import { startDaemon } from "./start-daemon";
 import {
   handleDaemonCommand,
   callDaemon,
+  callAuth,
   ensureDaemonRunning,
   isDaemonRunning,
   loadConfig,
@@ -81,7 +82,7 @@ async function printLightningInvoice(invoice: string): Promise<void> {
 }
 
 async function installCocodOrExit(): Promise<void> {
-  logger.log("cocod not found. Installing globally with bun...");
+  console.log("cocod not found. Installing globally with bun...");
 
   const installProc = Bun.spawn(
     ["bun", "install", "--global", "@routstr/cocod"],
@@ -93,13 +94,13 @@ async function installCocodOrExit(): Promise<void> {
 
   const installCode = await installProc.exited;
   if (installCode !== 0 || !(await isCocodInstalled())) {
-    logger.error(
+    console.error(
       "Failed to install cocod. Please run 'bun install --global @routstr/cocod' manually.",
     );
     throw new Error("cocod installation failed");
   }
 
-  logger.log("cocod installed successfully.");
+  console.log("cocod installed successfully.");
 }
 
 async function requireLocalDaemon(): Promise<void> {
@@ -113,12 +114,12 @@ async function requireLocalDaemon(): Promise<void> {
 }
 
 async function initDaemon(): Promise<void> {
-  logger.log("Initializing routstrd...");
+  console.log("Initializing routstrd...");
 
   // Create config directory
   if (!existsSync(CONFIG_DIR)) {
     mkdirSync(CONFIG_DIR, { recursive: true });
-    logger.log(`Created config directory: ${CONFIG_DIR}`);
+    console.log(`Created config directory: ${CONFIG_DIR}`);
   }
 
   // Create initial config
@@ -128,7 +129,7 @@ async function initDaemon(): Promise<void> {
       cocodPath: null,
     };
     await Bun.write(CONFIG_FILE, JSON.stringify(config, null, 2));
-    logger.log(`Created config file: ${CONFIG_FILE}`);
+    console.log(`Created config file: ${CONFIG_FILE}`);
   }
 
   const config = await loadConfig();
@@ -190,30 +191,30 @@ async function initDaemon(): Promise<void> {
   const alreadyInitialized = combinedOutput.includes("already initialized");
 
   if (initCode !== 0 && !alreadyInitialized) {
-    logger.error(
+    console.error(
       "Failed to initialize cocod. Please run 'cocod init' manually.",
     );
     return;
   }
 
   if (alreadyInitialized) {
-    logger.log("cocod is already initialized.");
+    console.log("cocod is already initialized.");
   } else {
-    logger.log("cocod initialized successfully.");
+    console.log("cocod initialized successfully.");
   }
 
   await startDaemon({ port: String(config.port || 8008) });
 
   await setupIntegration(config);
 
-  logger.log("\nInitialization complete!");
-  logger.log(
+  console.log("\nInitialization complete!");
+  console.log(
     "\n use 'routstrd receive <cashu-token>' or 'routstrd receive 2100' to top up your local wallet using Lightning!",
   );
-  logger.log(
+  console.log(
     "\n full wallet commands still work too, e.g. 'routstrd wallet receive cashu <token>' and 'routstrd wallet receive bolt11 2100'.",
   );
-  logger.log(
+  console.log(
     "\nTo ensure routstrd persists across system restarts, run: 'routstrd service install'",
   );
 }
@@ -231,7 +232,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 +259,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 },
@@ -303,7 +335,8 @@ program
 program
   .command("remote <url>")
   .description("Configure a remote daemon URL")
-  .action(async (url: string) => {
+  .option("--auth-url <authUrl>", "URL of the auth proxy for management commands (npubs, clients, usage)")
+  .action(async (url: string, options: { authUrl?: string }) => {
     try {
       new URL(url);
     } catch {
@@ -311,12 +344,24 @@ program
       process.exit(1);
     }
 
+    if (options.authUrl) {
+      try {
+        new URL(options.authUrl);
+      } catch {
+        console.error(`Invalid auth URL: ${options.authUrl}`);
+        process.exit(1);
+      }
+    }
+
     if (!existsSync(CONFIG_DIR)) {
       mkdirSync(CONFIG_DIR, { recursive: true });
     }
 
     const config = await loadConfig();
     const updates: Partial<RoutstrdConfig> = { daemonUrl: url };
+    if (options.authUrl) {
+      updates.authUrl = options.authUrl;
+    }
     let generatedNpub: string | undefined;
 
     if (!config.nsec) {
@@ -335,6 +380,9 @@ program
     await Bun.write(CONFIG_FILE, JSON.stringify(updatedConfig, null, 2));
 
     console.log(`Remote daemon URL set to: ${url}`);
+    if (options.authUrl) {
+      console.log(`Auth proxy URL set to: ${options.authUrl}`);
+    }
     if (generatedNpub) {
       console.log(
         `\nA new Nostr identity has been generated for remote authentication.`,
@@ -635,7 +683,7 @@ program
         ? Math.min(requested, 1000)
         : 10;
 
-    const result = await callDaemon(`/usage?limit=${limit}`);
+    const result = await callAuth(`/usage?limit=${limit}`);
     if (result.error) {
       console.log(result.error);
       process.exit(1);
@@ -851,7 +899,7 @@ npubsCmd
     await ensureDaemonRunning();
     const config = await loadConfig();
     const userNpub = getUserNpub(config);
-    const result = await callDaemon("/npubs");
+    const result = await callAuth("/npubs");
     if (result.error) {
       console.log(result.error);
       process.exit(1);
@@ -894,7 +942,7 @@ npubsCmd
       );
       process.exit(1);
     }
-    const result = await callDaemon("/npubs");
+    const result = await callAuth("/npubs");
     if (result.error) {
       console.log(result.error);
       process.exit(1);
@@ -912,7 +960,7 @@ npubsCmd
       console.error("Failed to normalize user npub.");
       process.exit(1);
     }
-    const addResult = await callDaemon("/npubs", {
+    const addResult = await callAuth("/npubs", {
       method: "POST",
       body: { npub: npubFromPubkey(normalized) },
     });
@@ -946,7 +994,7 @@ npubsCmd
       process.exit(1);
     }
     const body: Record<string, string> = { npub: npubFromPubkey(normalized), role: options.role };
-    const result = await callDaemon("/npubs", {
+    const result = await callAuth("/npubs", {
       method: "POST",
       body,
     });
@@ -979,7 +1027,7 @@ npubsCmd
       console.error("Invalid role. Expected 'admin' or 'user'.");
       process.exit(1);
     }
-    const result = await callDaemon("/npubs", {
+    const result = await callAuth("/npubs", {
       method: "PATCH",
       body: { npub: npubFromPubkey(normalized), role: options.role },
     });
@@ -1008,7 +1056,7 @@ npubsCmd
       console.error("Invalid npub value. Use npub1... or 64-char hex pubkey.");
       process.exit(1);
     }
-    const result = await callDaemon(
+    const result = await callAuth(
       `/npubs/${encodeURIComponent(npubFromPubkey(normalized))}`,
       {
         method: "DELETE",
@@ -1253,6 +1301,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");
+  };
+}