routstrd 0.4.11 → 0.4.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "routstrd",
-  "version": "0.4.11",
+  "version": "0.4.12",
   "module": "src/index.ts",
   "type": "module",
   "private": false,
@@ -39,7 +39,7 @@
     "@cashu/cashu-ts": "^4.3.0",
     "@cashu/coco-core": "^1.0.1",
     "@cashu/coco-sqlite-bun": "^1.0.1",
-    "@routstr/sdk": "^0.4.6",
+    "@routstr/sdk": "^0.4.8",
     "@scure/bip39": "^2.2.0",
     "applesauce-core": "^5.1.0",
     "applesauce-relay": "^5.1.0",

package/src/cli.ts

@@ -10,7 +10,12 @@ import {
   loadConfig,
   getDaemonBaseUrl,
   getUserNpub,
+  type CommandResponse,
 } from "./utils/daemon-client";
+import {
+  formatCooldowns,
+  type CooldownsOutput,
+} from "./utils/cooldowns";
 import { waitForDaemonToExit } from "./utils/daemon-stop";
 import {
   listClientsAction,
@@ -53,6 +58,10 @@ import {
 } from "./daemon/wallet/paths";
 import * as QRCode from "qrcode";
 import { normalizeNostrPubkey, npubFromPubkey, npubFromSecretKey } from "./utils/nip98";
+import {
+  HISTORY_ENTRY_TYPES,
+  isHistoryEntryType,
+} from "./utils/history";
 import { generateSecretKey, nip19 } from "nostr-tools";
 import { generateMnemonic } from "@scure/bip39";
 import { wordlist } from "@scure/bip39/wordlists/english.js";
@@ -146,6 +155,36 @@ async function waitForMintQuote(operationId: string): Promise<void> {
   }
 }
 
+/**
+ * Warn that value-moving wallet operations will block until startup recovery
+ * finishes. Reads stay available, but the daemon gates send/receive behind the
+ * recovery gate, so without this notice the CLI would appear to hang silently
+ * after a restart.
+ */
+async function warnIfWalletRecovering(): Promise<void> {
+  try {
+    await ensureDaemonRunning();
+    const result = await callDaemon("/wallet/status");
+    const output = result.output as
+      | { state?: string; recovery?: { phase?: string } }
+      | undefined;
+    if (output?.state !== "RECOVERING") return;
+
+    const phase = output.recovery?.phase;
+    console.error(
+      "Wallet is recovering from a previous run (this only happens after a restart).",
+    );
+    if (phase && phase !== "done") {
+      console.error(`Recovery phase: ${phase}.`);
+    }
+    console.error(
+      "Please wait — send and receive resume as soon as recovery completes.",
+    );
+  } catch {
+    // Status is best-effort; never block the real command on it.
+  }
+}
+
 export function initializeWallet(walletDir = defaultWalletDir()): void {
   const walletConfig = join(walletDir, "config.json");
 
@@ -296,10 +335,7 @@ async function initDaemon(integrationKey?: IntegrationKey): Promise<void> {
 
   // Create initial config (0600, atomic write)
   if (!existsSync(CONFIG_FILE)) {
-    const config: RoutstrdConfig = {
-      ...DEFAULT_CONFIG,
-      cocodPath: null,
-    };
+    const config: RoutstrdConfig = { ...DEFAULT_CONFIG };
     saveDaemonConfig(config);
     console.log(`Created config file: ${CONFIG_FILE}`);
   }
@@ -1132,6 +1168,24 @@ const providersCmd = program
   .command("providers")
   .description("List and manage providers");
 
+// Strict index parsing: parseInt accepts garbage like "3abc" (-> 3) or
+// "0x5" (-> 0), which would silently act on the wrong provider.
+const parseProviderIndices = (raw: string[]): number[] => {
+  const valid: number[] = [];
+  const invalid: string[] = [];
+  for (const s of raw) {
+    if (/^\d+$/.test(s)) {
+      valid.push(parseInt(s, 10));
+    } else {
+      invalid.push(s);
+    }
+  }
+  if (invalid.length > 0) {
+    console.log(`Ignoring invalid index argument(s): ${invalid.join(", ")}`);
+  }
+  return valid;
+};
+
 providersCmd
   .command("list")
   .description("List all providers with their enabled/disabled status")
@@ -1152,6 +1206,8 @@ providersCmd
             index: number;
             baseUrl: string;
             disabled: boolean;
+            manuallyDisabled?: boolean;
+            manuallyEnabled?: boolean;
           }>;
           disabledCount: number;
           totalCount: number;
@@ -1167,7 +1223,13 @@ providersCmd
       `Providers (${output.totalCount} total, ${output.disabledCount} disabled):\n`,
     );
     for (const provider of output.providers) {
-      const status = provider.disabled ? "DISABLED" : "enabled ";
+      const status = provider.manuallyDisabled
+        ? "DISABLED (manual)         "
+        : provider.disabled
+          ? "DISABLED (nostr review)   "
+          : provider.manuallyEnabled
+            ? "enabled  (manual override)"
+            : "enabled                   ";
       console.log(`  [${provider.index}] ${status}  ${provider.baseUrl}`);
     }
   });
@@ -1180,9 +1242,7 @@ providersCmd
   .action(async (indices: string[]) => {
     await ensureDaemonRunning();
 
-    const indexNums = indices
-      .map((s) => parseInt(s, 10))
-      .filter((n) => Number.isFinite(n));
+    const indexNums = parseProviderIndices(indices);
     if (indexNums.length === 0) {
       console.log("No valid indices provided.");
       process.exit(1);
@@ -1217,9 +1277,7 @@ providersCmd
   .action(async (indices: string[]) => {
     await ensureDaemonRunning();
 
-    const indexNums = indices
-      .map((s) => parseInt(s, 10))
-      .filter((n) => Number.isFinite(n));
+    const indexNums = parseProviderIndices(indices);
     if (indexNums.length === 0) {
       console.log("No valid indices provided.");
       process.exit(1);
@@ -1246,6 +1304,51 @@ providersCmd
     }
   });
 
+providersCmd
+  .command("nostr-sync <indices...>")
+  .description(
+    "Remove manual enable/disable overrides and return providers to their Nostr review-based state (e.g., routstrd providers nostr-sync 0 2 5)",
+  )
+  .action(async (indices: string[]) => {
+    await ensureDaemonRunning();
+
+    const indexNums = parseProviderIndices(indices);
+    if (indexNums.length === 0) {
+      console.log("No valid indices provided.");
+      process.exit(1);
+    }
+
+    const result = await callDaemon("/providers/nostr-sync", {
+      method: "POST",
+      body: { indices: indexNums },
+    });
+
+    if (result.error) {
+      console.log(result.error);
+      process.exit(1);
+    }
+
+    const output = result.output as
+      | {
+          message: string;
+          providers: Array<{ baseUrl: string; disabled: boolean }>;
+          skipped?: unknown[];
+        }
+      | undefined;
+    if (output) {
+      console.log(output.message);
+      for (const provider of output.providers) {
+        const status = provider.disabled
+          ? "DISABLED (nostr review)"
+          : "enabled";
+        console.log(`  - ${provider.baseUrl} -> ${status}`);
+      }
+      if (output.skipped && output.skipped.length > 0) {
+        console.log(`Skipped invalid indices: ${output.skipped.join(", ")}`);
+      }
+    }
+  });
+
 providersCmd
   .command("reviews")
   .description(
@@ -1334,6 +1437,52 @@ providersCmd
     }
   });
 
+// Cooldowns - providers/models the router is currently skipping
+program
+  .command("cooldowns")
+  .description(
+    "List providers and models currently on cooldown (temporarily skipped by the router)",
+  )
+  .option("--json", "Print the raw daemon response as JSON", false)
+  .action(async (options: { json: boolean }) => {
+    await ensureDaemonRunning();
+
+    let result: CommandResponse;
+    try {
+      result = await callDaemon("/cooldowns");
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      // A daemon built before this command existed has no /cooldowns route:
+      // it either 404s or falls through to the "POST only" catch-all.
+      if (message.includes("404") || message === "Only POST is supported.") {
+        console.error(
+          "The running daemon has no /cooldowns endpoint, so it cannot report cooldowns. " +
+            "Restart it on a newer build (routstrd service restart) and try again.",
+        );
+        process.exit(1);
+      }
+      throw error;
+    }
+
+    if (result.error) {
+      console.log(result.error);
+      process.exit(1);
+    }
+
+    const output = result.output as CooldownsOutput | undefined;
+    if (options.json) {
+      console.log(JSON.stringify(output ?? {}, null, 2));
+      return;
+    }
+
+    if (!output) {
+      console.log("No cooldown data returned by the daemon.");
+      return;
+    }
+
+    console.log(formatCooldowns(output));
+  });
+
 // Clients - list and manage clients
 const clientsCmd = program
   .command("clients")
@@ -1671,17 +1820,50 @@ program
   .description("Show wallet transaction history")
   .option("-n, --limit <number>", "Number of entries to show", "50")
   .option("--offset <number>", "Number of entries to skip", "0")
-  .option("-v, --verbose", "Show full details including encoded Cashu tokens")
+  .option(
+    "-t, --type <type...>",
+    "Filter by transaction type (send, receive, mint, melt). Repeatable or comma-separated",
+  )
+  .option("-i, --id <id>", "Show a single transaction by its ID")
+  .option("-v, --verbose", "Show full details instead of the summary line")
   .option("--json", "Output raw JSON with token objects (no encoding)")
-  .action(async (options: { limit: string; offset: string; verbose: boolean; json: boolean }) => {
+  .action(async (options: {
+    limit: string;
+    offset: string;
+    type?: string[];
+    id?: string;
+    verbose: boolean;
+    json: boolean;
+  }) => {
     await ensureDaemonRunning();
 
     const limit = Math.min(parseInt(options.limit, 10) || 50, 1000);
     const offset = parseInt(options.offset, 10) || 0;
 
-    const result = await callDaemon(
-      `/wallet/history?offset=${offset}&limit=${limit}`,
+    // Support both repeated flags (-t send -t mint) and comma-separated
+    // values (-t send,mint).
+    const requestedTypes = (options.type ?? [])
+      .flatMap((value) => value.split(","))
+      .map((value) => value.trim().toLowerCase())
+      .filter((value) => value.length > 0);
+    const unknownTypes = requestedTypes.filter(
+      (value) => !isHistoryEntryType(value),
     );
+    if (unknownTypes.length > 0) {
+      console.error(
+        `Unknown transaction type: ${unknownTypes.join(", ")}. Valid types: ${HISTORY_ENTRY_TYPES.join(", ")}.`,
+      );
+      process.exit(1);
+    }
+
+    const query = new URLSearchParams({
+      offset: String(offset),
+      limit: String(limit),
+    });
+    if (requestedTypes.length > 0) query.set("type", requestedTypes.join(","));
+    if (options.id) query.set("id", options.id);
+
+    const result = await callDaemon(`/wallet/history?${query.toString()}`);
 
     if (result.error) {
       console.log(result.error);
@@ -1694,7 +1876,15 @@ program
     const entries = data?.entries || [];
 
     if (entries.length === 0) {
-      console.log("No transaction history yet.");
+      if (options.id) {
+        console.log(`No transaction found with ID ${options.id}.`);
+      } else if (requestedTypes.length > 0) {
+        console.log(
+          `No ${requestedTypes.join(", ")} transactions found.`,
+        );
+      } else {
+        console.log("No transaction history yet.");
+      }
       return;
     }
 
@@ -1751,10 +1941,13 @@ program
     const pad = (s: string, w: number) => s.padEnd(w);
     const sep = Object.values(widths).map((w) => "-".repeat(w)).join(" | ");
 
-    console.log(
-      `${pad(idCol, widths.id)} | ${pad(timeCol, widths.time)} | ${pad(typeCol, widths.type)} | ${pad(mintCol, widths.mint)} | ${pad(amtCol, widths.amount)}`,
-    );
-    console.log(sep);
+    // A single transaction lookup prints just its summary line.
+    if (!options.id) {
+      console.log(
+        `${pad(idCol, widths.id)} | ${pad(timeCol, widths.time)} | ${pad(typeCol, widths.type)} | ${pad(mintCol, widths.mint)} | ${pad(amtCol, widths.amount)}`,
+      );
+      console.log(sep);
+    }
 
     for (const row of rows) {
       console.log(
@@ -1787,6 +1980,7 @@ program
   )
   .option("--mint-url <url>", "Mint URL to use")
   .action(async (target: string, options: { mintUrl?: string }) => {
+    await warnIfWalletRecovering();
     if (isPositiveIntegerString(target)) {
       await handleDaemonCommand("/wallet/send/cashu", {
         method: "POST",
@@ -1814,6 +2008,7 @@ program
   )
   .option("--mint-url <url>", "Mint URL to use for bolt11 receive")
   .action(async (value: string, options: { mintUrl?: string }) => {
+    await warnIfWalletRecovering();
     if (isPositiveIntegerString(value)) {
       try {
         await ensureDaemonRunning();
@@ -1896,16 +2091,22 @@ walletCmd
   .option("--mint-url <url>", "Only clean up operations for this mint URL")
   .option(
     "--min-age <hours>",
-    "Minimum age for reclaiming sends/cancelling melts, in hours (default: 168, one week; expired mint quotes are always failed)",
+    "Minimum age for reclaiming sends/cancelling melts, in hours (default: 168, one week; expired mint quotes are checked with their mint)",
     "168",
   )
   .option("--dry-run", "Report what would be cleaned without applying changes", false)
+  .option(
+    "--force",
+    "Fail expired mint quotes without confirming UNPAID with the mint (may strand paid quotes)",
+    false,
+  )
   .option("-y, --yes", "Skip confirmation prompt", false)
   .action(
     async (options: {
       mintUrl?: string;
       minAge: string;
       dryRun: boolean;
+      force: boolean;
       yes: boolean;
     }) => {
       const minAgeHours = Number.parseFloat(options.minAge);
@@ -1921,7 +2122,9 @@ walletCmd
         });
         const answer = await new Promise<string>((resolve) => {
           rl.question(
-            "This will fail expired mint quotes, reclaim old pending sends, and cancel prepared melts. Continue? [y/N] ",
+            options.force
+              ? "WARNING: --force fails expired mint quotes WITHOUT checking the mint and may strand paid sats. It also reclaims old pending sends and cancels prepared melts. Continue? [y/N] "
+              : "This will fail expired mint quotes confirmed unpaid, reclaim old pending sends, and cancel prepared melts. Continue? [y/N] ",
             (value: string) => {
               rl.close();
               resolve(value.trim().toLowerCase());
@@ -1943,6 +2146,7 @@ walletCmd
             mintUrl: options.mintUrl,
             minAgeMs: Math.round(minAgeHours * 60 * 60 * 1000),
             dryRun: options.dryRun === true,
+            force: options.force === true,
           },
         });
 
@@ -1955,6 +2159,8 @@ walletCmd
           | {
               dryRun?: boolean;
               failedMintQuotes?: number;
+              mintQuoteCandidates?: number;
+              leftForRecovery?: number;
               reclaimedSends?: number;
               cancelledMelts?: number;
               skipped?: number;
@@ -1965,8 +2171,15 @@ walletCmd
         if (output) {
           const prefix = output.dryRun ? "Would clean up:" : "Cleaned up:";
           console.log(prefix);
+          if (output.dryRun) {
+            console.log(
+              `  Expired mint quote candidates (not checked with mint): ${output.mintQuoteCandidates ?? 0}`,
+            );
+          } else {
+            console.log(`  Expired mint quotes failed: ${output.failedMintQuotes ?? 0}`);
+          }
           console.log(
-            `  Expired mint quotes failed: ${output.failedMintQuotes ?? 0}`,
+            `  Expired quotes kept for recovery (paid/issued/unverified): ${output.leftForRecovery ?? 0}`,
           );
           console.log(`  Pending sends reclaimed: ${output.reclaimedSends ?? 0}`);
           console.log(
@@ -1997,6 +2210,124 @@ walletCmd
     },
   );
 
+walletCmd
+  .command("recover")
+  .description(
+    "Retry mint quotes using their stored outputs (does not replace rejected outputs)",
+  )
+  .option(
+    "--op <id>",
+    "Recover this operation id (repeatable; find IDs with routstrd history --json)",
+    (value: string, previous: string[]) => [...previous, value],
+    [] as string[],
+  )
+  .option(
+    "--include-failed",
+    "Also re-open operations coco already gave up on (requires --op)",
+    false,
+  )
+  .option("-y, --yes", "Skip confirmation prompt", false)
+  .action(
+    async (options: {
+      op: string[];
+      includeFailed: boolean;
+      yes: boolean;
+    }) => {
+      const operationIds = options.op ?? [];
+      if (options.includeFailed && operationIds.length === 0) {
+        console.error(
+          "--include-failed can only target operations named with --op",
+        );
+        process.exit(1);
+      }
+
+      if (!options.yes) {
+        const rl = require("readline").createInterface({
+          input: process.stdin,
+          output: process.stdout,
+        });
+        const prompt =
+          operationIds.length > 0
+            ? `Recover ${operationIds.length} mint quote operation(s)? [y/N] `
+            : "Check every pending mint quote with its mint and claim any paid sats? [y/N] ";
+        const answer = await new Promise<string>((resolve) => {
+          rl.question(prompt, (value: string) => {
+            rl.close();
+            resolve(value.trim().toLowerCase());
+          });
+        });
+        if (answer !== "y" && answer !== "yes") {
+          console.log("Aborted.");
+          return;
+        }
+      }
+
+      try {
+        await ensureDaemonRunning();
+
+        const result = await callDaemon("/wallet/recover", {
+          method: "POST",
+          body: {
+            operationIds: operationIds.length > 0 ? operationIds : undefined,
+            includeFailed: options.includeFailed === true,
+          },
+        });
+
+        if (result.error) {
+          console.log(result.error);
+          process.exit(1);
+        }
+
+        const output = result.output as
+          | {
+              checked?: number;
+              recovered?: number;
+              waiting?: number;
+              terminal?: number;
+              reopened?: number;
+              retryable?: number;
+              busy?: number;
+              errors?: Array<{ operationId: string; error: string }>;
+            }
+          | undefined;
+
+        if (output) {
+          console.log("Mint quote recovery:");
+          console.log(`  Checked with mint: ${output.checked ?? 0}`);
+          console.log(
+            `  Recovered (paid sats claimed): ${output.recovered ?? 0}`,
+          );
+          console.log(`  Still unpaid: ${output.waiting ?? 0}`);
+          console.log(`  No longer issuable: ${output.terminal ?? 0}`);
+          console.log(
+            `  Re-opened failed operations: ${output.reopened ?? 0}`,
+          );
+          console.log(`  Left for a later run: ${output.retryable ?? 0}`);
+          console.log(
+            `  Skipped (recovery still running): ${output.busy ?? 0}`,
+          );
+          if (output.errors && output.errors.length > 0) {
+            console.log("\nErrors:");
+            for (const e of output.errors) {
+              console.log(`  - ${e.operationId}: ${e.error}`);
+            }
+          }
+        }
+      } catch (error) {
+        const message = (error as Error).message;
+        if (
+          message?.includes("fetch failed") ||
+          message?.includes("Connection refused")
+        ) {
+          console.error("Daemon is not running");
+          process.exit(1);
+        }
+        console.error(message);
+        process.exit(1);
+      }
+    },
+  );
+
 const walletReceiveCmd = walletCmd
   .command("receive")
   .description("Wallet receive operations");
@@ -2005,6 +2336,7 @@ walletReceiveCmd
   .command("cashu <token>")
   .description("Receive a Cashu token")
   .action(async (token: string) => {
+    await warnIfWalletRecovering();
     await handleDaemonCommand("/wallet/receive/cashu", {
       method: "POST",
       body: { token },
@@ -2016,6 +2348,7 @@ walletReceiveCmd
   .description("Create a Lightning invoice")
   .option("--mint-url <url>", "Mint URL to use")
   .action(async (amount: string, options: { mintUrl?: string }) => {
+    await warnIfWalletRecovering();
     try {
       await ensureDaemonRunning();
 
@@ -2054,6 +2387,7 @@ walletSendCmd
   .description("Create a Cashu token to send")
   .option("--mint-url <url>", "Mint URL to use")
   .action(async (amount: string, options: { mintUrl?: string }) => {
+    await warnIfWalletRecovering();
     await handleDaemonCommand("/wallet/send/cashu", {
       method: "POST",
       body: {
@@ -2068,6 +2402,7 @@ walletSendCmd
   .description("Pay a Lightning invoice")
   .option("--mint-url <url>", "Mint URL to use")
   .action(async (invoice: string, options: { mintUrl?: string }) => {
+    await warnIfWalletRecovering();
     await handleDaemonCommand("/wallet/send/bolt11", {
       method: "POST",
       body: {