routstrd 0.4.5 → 0.4.7

package/src/daemon/wallet/index.ts

@@ -0,0 +1,360 @@
+import { getTokenMetadata } from "@cashu/cashu-ts";
+import { InsufficientBalanceError } from "@routstr/sdk";
+import { WalletConnect } from "applesauce-wallet-connect";
+import { RelayPool } from "applesauce-relay";
+import { logger } from "../../utils/logger";
+import { createCocodClient, type CocodClient } from "./cocod-client";
+import { startAutoRefillLoop, type AutoRefillConfig } from "./auto-refill";
+
+export function decodeCashuTokenAmount(token: string): {
+  amount: number;
+  unit: "sat" | "msat";
+} {
+  // TokenV4 may contain an 8-byte short keyset ID. Fully decoding its
+  // proofs requires the mint's full keyset IDs, but amount and unit do not.
+  // getTokenMetadata intentionally extracts those fields without trying to
+  // map short IDs, unlike getDecodedToken(token, []).
+  const metadata = getTokenMetadata(token);
+  const amount = metadata.amount.toNumber();
+  const unit = metadata.unit === "msat" ? "msat" : "sat";
+  return { amount, unit };
+}
+
+export async function receiveCashuToken(
+  client: Pick<CocodClient, "receiveCashu">,
+  token: string,
+): Promise<{ message: string; amount: number; unit: "sat" | "msat" }> {
+  // Validate the token before handing it to a state-changing wallet call. This
+  // prevents a successful receive from being reported as a failure if local
+  // metadata parsing ever rejects a future token format.
+  const { amount, unit } = decodeCashuTokenAmount(token);
+  const message = await client.receiveCashu(token);
+  return { message, amount, unit };
+}
+
+export interface WalletAdapterOptions {
+  cocodPath?: string | null;
+  walletClient?: CocodClient;
+  /** NWC connection string for Lightning funding (uses applesauce-wallet-connect) */
+  nwcConnectionString?: string;
+  /** Auto-refill configuration (static, for startup only) */
+  autoRefill?: AutoRefillConfig;
+  /**
+   * Config getter called on every check cycle to allow live updates.
+   * Return undefined to disable auto-refill, or a config to use.
+   * When provided, this replaces the static `autoRefill` option.
+   */
+  getAutoRefillConfig?: () => AutoRefillConfig | undefined;
+}
+
+export async function createWalletAdapter(
+  options: WalletAdapterOptions = {},
+) {
+  const client =
+    options.walletClient || createCocodClient({ cocodPath: options.cocodPath });
+  let activeMintUrl: string | null = null;
+  let mintUnits: Record<string, "sat" | "msat"> = {};
+
+  async function syncMintState(
+    balances?: Record<string, number>,
+  ): Promise<Record<string, number>> {
+    const nextBalances = balances || (await client.getBalances());
+
+    mintUnits = Object.fromEntries(
+      Object.keys(nextBalances).map((mintUrl) => [mintUrl, "sat"]),
+    );
+
+    try {
+      // Use default mint as active mint, fall back to first mint in list
+      const defaultMint = await client.getDefaultMint();
+      activeMintUrl = defaultMint || Object.keys(nextBalances)[0] || null;
+    } catch (error) {
+      logger.error("Failed to get default mint:", error);
+      if (!activeMintUrl) {
+        activeMintUrl = Object.keys(nextBalances)[0] || null;
+      }
+    }
+
+    return nextBalances;
+  }
+
+  // ── NWC connection (applesauce approach) ──────────────────────
+
+  let wallet: WalletConnect | undefined;
+  let pool: RelayPool | undefined;
+
+  // Getter for the current wallet instance (used by auto-refill loop)
+  const getWallet = (): WalletConnect | undefined => wallet;
+
+  if (options.nwcConnectionString) {
+    pool = new RelayPool();
+    wallet = WalletConnect.fromConnectURI(options.nwcConnectionString, { pool });
+
+    // Connect in background (non-blocking)
+    wallet.waitForService()
+      .then(() => {
+        logger.log(
+          `[nwc] NWC wallet connected. Relay: ${wallet!.relays[0]}, Service: ${wallet!.service}`,
+        );
+      })
+      .catch((err) => {
+        logger.error(`[nwc] NWC connection failed: ${err.message}`);
+      });
+  }
+
+  const walletAdapter = {
+    async reconnect(connectionString?: string): Promise<void> {
+      logger.log(
+        `[nwc] Reconnecting NWC wallet... ${connectionString ? "new connection string provided" : "disconnecting"}`,
+      );
+
+      // 1. Close existing relay pool connections
+      if (pool) {
+        for (const [url] of pool.relays) {
+          pool.remove(url, true);
+        }
+      }
+
+      // 2. Update wallet reference
+      wallet = undefined;
+      pool = undefined;
+
+      // 3. Create new wallet if connection string provided
+      if (connectionString) {
+        pool = new RelayPool();
+        wallet = WalletConnect.fromConnectURI(connectionString, { pool });
+
+        // Connect in background (non-blocking)
+        wallet.waitForService()
+          .then(() => {
+            logger.log(
+              `[nwc] NWC wallet reconnected. Relay: ${wallet!.relays[0]}, Service: ${wallet!.service}`,
+            );
+          })
+          .catch((err) => {
+            logger.error(`[nwc] NWC reconnection failed: ${err.message}`);
+          });
+      } else {
+        logger.log("[nwc] NWC wallet disconnected.");
+      }
+    },
+
+    async getBalances(): Promise<Record<string, number>> {
+      return syncMintState();
+    },
+    getMintUnits(): Record<string, "sat" | "msat"> {
+      return mintUnits;
+    },
+    getActiveMintUrl(): string | null {
+      return activeMintUrl;
+    },
+
+    // ── NWC funding methods ────────────────────────────────────
+
+    /** Fund the Cashu wallet from NWC by creating & paying a BOLT-11 invoice */
+    async fundFromNWC(amount: number): Promise<{
+      success: boolean;
+      invoice: string;
+      preimage?: string;
+      error?: string;
+    }> {
+      logger.log("=".repeat(50));
+      logger.log(`[nwc] Fund Cashu wallet from NWC — amount: ${amount} sats`);
+      logger.log("=".repeat(50));
+
+      if (!wallet || !wallet.service) {
+        logger.error("[nwc] NWC not connected");
+        return { success: false, invoice: "", error: "NWC not connected" };
+      }
+
+      // Use default mint for NWC funding
+      const defaultMint = await client.getDefaultMint();
+      const mintUrl = defaultMint;
+      if (!mintUrl) {
+        logger.error("[nwc] No default mint configured");
+        return { success: false, invoice: "", error: "No default mint configured" };
+      }
+
+      try {
+        // Step 1: Check initial balance
+        logger.log(`[nwc] Checking initial cocod balance on mint ${mintUrl}...`);
+        let initialBalance: number | null = null;
+        try {
+          const balances = await client.getBalances();
+          initialBalance = balances[mintUrl] ?? 0;
+          logger.log(`[nwc]   Initial balance: ${initialBalance} sats`);
+        } catch {
+          logger.log("[nwc]   Could not retrieve initial balance");
+        }
+
+        // Step 2: Create a BOLT-11 invoice via cocod
+        logger.log(`[nwc] Creating ${amount}-sat Lightning invoice via cocod...`);
+        const invoice = await client.receiveBolt11(amount, mintUrl);
+        logger.log(`[nwc]   Invoice: ${invoice}`);
+
+        // Step 3: Pay it via NWC
+        logger.log("[nwc] Paying invoice via NWC...");
+        const { preimage, fees_paid } = await wallet.payInvoice(invoice);
+        logger.log(`[nwc]   ✅ Payment successful!`);
+        logger.log(`[nwc]   Preimage: ${preimage}`);
+        if (fees_paid !== undefined) {
+          logger.log(`[nwc]   Fees paid: ${fees_paid} msats`);
+        }
+
+        // Step 4: Check final balance
+        logger.log("[nwc] Checking final cocod balance...");
+        try {
+          const balances = await client.getBalances();
+          const finalBalance = balances[mintUrl] ?? 0;
+          logger.log(`[nwc]   Final balance: ${finalBalance} sats`);
+          if (initialBalance !== null) {
+            const diff = finalBalance - initialBalance;
+            logger.log(`[nwc]   Balance change: ${diff > 0 ? "+" : ""}${diff} sats`);
+          }
+        } catch {
+          logger.log("[nwc]   Could not retrieve final balance");
+        }
+
+        logger.log("=".repeat(50));
+        return { success: true, invoice, preimage };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.error(`[nwc]   ❌ Fund from NWC failed: ${message}`);
+        logger.log("=".repeat(50));
+        return { success: false, invoice: "", error: message };
+      }
+    },
+
+    /** Get NWC connection status and wallet info */
+    async getNwcStatus(): Promise<{
+      connected: boolean;
+      alias?: string;
+      pubkey?: string;
+      network?: string;
+      methods?: string[];
+      balance?: number;
+      error?: string;
+    }> {
+      if (!wallet) {
+        return { connected: false, error: "NWC not configured" };
+      }
+
+      if (!wallet.service) {
+        return { connected: false, error: "NWC not connected" };
+      }
+
+      try {
+        const info = await wallet.getInfo();
+        let balance: number | undefined;
+        try {
+          const bal = await wallet.getBalance();
+          balance = Math.floor(bal.balance / 1000); // msats → sats
+        } catch {
+          // Balance might not be available
+        }
+        return {
+          connected: true,
+          alias: info.alias,
+          pubkey: info.pubkey,
+          network: info.network,
+          methods: info.methods,
+          balance,
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { connected: false, error: message };
+      }
+    },
+
+    /** Get the current auto-refill config, re-reading from the getter if available */
+    getAutoRefillConfig(): AutoRefillConfig | undefined {
+      return options.getAutoRefillConfig?.() ?? options.autoRefill;
+    },
+    async sendToken(mintUrl: string, amount: number): Promise<string> {
+      const maxRetries = 3;
+      const retryDelayMs = 5000;
+      const retryErrorPattern = "Proof already reserved by operation";
+
+      for (let attempt = 0; attempt <= maxRetries; attempt++) {
+        try {
+          return await client.sendCashu(amount, mintUrl);
+        } catch (error) {
+          const errorMessage =
+            error instanceof Error ? error.message : String(error);
+
+          const shouldRetry =
+            attempt < maxRetries && errorMessage.includes(retryErrorPattern);
+
+          if (shouldRetry) {
+            logger.log(
+              `sendToken attempt ${attempt + 1} failed with reserved proof error, retrying in ${retryDelayMs / 1000}s...`,
+            );
+            await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+            continue;
+          }
+
+          if (errorMessage.includes("Not enough proofs")) {
+            throw new InsufficientBalanceError(amount, 0);
+          }
+
+          logger.error("Error in walletAdapter sendToken:", error);
+          throw error;
+        }
+      }
+
+      throw new Error("sendToken failed after max retries");
+    },
+    async receiveToken(token: string): Promise<{
+      success: boolean;
+      amount: number;
+      unit: "sat" | "msat";
+      message?: string;
+    }> {
+      try {
+        const { amount, unit, message } = await receiveCashuToken(client, token);
+        return { success: true, amount, unit, message };
+      } catch (error) {
+        const errorMessage =
+          error instanceof Error ? error.message : String(error);
+        logger.error("Error in walletAdapter receiveToken:", errorMessage);
+        return { success: false, amount: 0, unit: "sat", message: errorMessage };
+      }
+    },
+  };
+
+  // ── Auto-refill setup ────────────────────────────────────────
+
+  let stopAutoRefill: (() => void) | undefined;
+
+  const autoRefillConfig = options.getAutoRefillConfig
+    ? options.getAutoRefillConfig()
+    : options.autoRefill;
+
+  if (autoRefillConfig && wallet) {
+    const getConfig = options.getAutoRefillConfig ?? (() => options.autoRefill);
+    stopAutoRefill = startAutoRefillLoop(client, getWallet, getConfig);
+    logger.log(
+      `[wallet] Auto-refill enabled: threshold=${autoRefillConfig.threshold} sats, amount=${autoRefillConfig.amount} sats, cooldown=${autoRefillConfig.cooldownMs / 60000} minutes`,
+    );
+  } else if (wallet && options.getAutoRefillConfig) {
+    // Wallet exists but auto-refill is not currently enabled.
+    // Start the loop anyway so it can pick up changes without a restart.
+    stopAutoRefill = startAutoRefillLoop(client, getWallet, options.getAutoRefillConfig);
+    logger.log("[wallet] Auto-refill loop started (currently disabled — enable via CLI to activate)");
+  }
+
+  try {
+    const [balances, defaultMint] = await Promise.all([
+      client.getBalances(),
+      client.getDefaultMint().catch(() => null),
+    ]);
+    mintUnits = Object.fromEntries(
+      Object.keys(balances).map((mintUrl) => [mintUrl, "sat"]),
+    );
+    activeMintUrl = defaultMint || Object.keys(balances)[0] || null;
+  } catch (error) {
+    logger.error("Failed to initialize wallet adapter state:", error);
+  }
+
+  return walletAdapter;
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env bun
+import { cli } from "./cli";
+
+cli(process.argv);

package/src/integrations/index.ts

@@ -0,0 +1,159 @@
+import type { RoutstrdConfig } from "../utils/config";
+import { logger } from "../utils/logger";
+import {
+  addDaemonClient,
+  type DaemonClient,
+} from "../utils/clients";
+import { getClientsList } from "../utils/clients";
+import { installOpencodeIntegration } from "./opencode";
+import { installOpenClawIntegration } from "./openclaw";
+import { installPiIntegration } from "./pi";
+import { installClaudeCodeIntegration } from "./claudecode";
+import { installHermesIntegration } from "./hermes";
+import type { IntegrationConfig } from "./registry";
+import { CLIENT_CONFIGS, runIntegrationsForClients } from "./registry";
+export { CLIENT_INTEGRATIONS, CLIENT_CONFIGS, runIntegrationsForClients } from "./registry";
+
+/**
+ * Refresh routstr21 models and then run integrations for all registered clients.
+ * Used both on initial daemon startup and in the recurring scheduled job.
+ */
+export async function refreshModelsAndIntegrations(
+  getRoutstr21Models: (force?: boolean) => Promise<any[]>,
+  config: RoutstrdConfig,
+  label: string = "Scheduled",
+): Promise<void> {
+  await getRoutstr21Models(true);
+  logger.log(`${label} model refresh completed successfully.`);
+
+  const clientIds = await getClientsList();
+  if (clientIds.length > 0) {
+    logger.log(`Refreshing ${clientIds.length} client integration(s)...`);
+    await runIntegrationsForClients(clientIds, config);
+    logger.log("Client integrations refreshed.");
+  }
+}
+
+function ask(question: string): Promise<string> {
+  process.stdout.write(question);
+
+  if (!process.stdin.isTTY) {
+    return Promise.resolve("1");
+  }
+
+  return new Promise((resolve) => {
+    process.stdin.resume();
+    process.stdin.setEncoding("utf8");
+    process.stdin.once("data", (data) => {
+      process.stdin.pause();
+      resolve(data.toString().trim());
+    });
+  });
+}
+
+function parseChoice(input: string): number {
+  if (input === "") {
+    return 1;
+  }
+
+  const parsed = Number.parseInt(input, 10);
+  if (!Number.isNaN(parsed) && parsed >= 1 && parsed <= 6) {
+    return parsed;
+  }
+
+  return 1;
+}
+
+/**
+ * Either a client integration key (as used in CLIENT_CONFIGS) or "skip".
+ */
+export type IntegrationKey = keyof typeof CLIENT_CONFIGS | "skip";
+
+/**
+ * Create/find the API key for a client and run its install integration.
+ * Shared by the interactive menu in setupIntegration and direct onboarding
+ * via `routstrd onboard --<client>` flags.
+ */
+async function installIntegrationByKey(
+  config: RoutstrdConfig,
+  key: keyof typeof CLIENT_CONFIGS,
+): Promise<void> {
+  const integrationConfig = CLIENT_CONFIGS[key];
+  if (!integrationConfig) {
+    console.log(`Unknown integration: ${key}`);
+    return;
+  }
+
+  const { client, created } = await addDaemonClient(
+    integrationConfig.name,
+  );
+
+  if (created) {
+    console.log(`Created new API key for ${integrationConfig.name}`);
+  } else {
+    console.log(`Using existing API key for ${integrationConfig.name}`);
+  }
+
+  switch (key) {
+    case "opencode":
+      await installOpencodeIntegration(config, client.apiKey, integrationConfig);
+      return;
+    case "openclaw":
+      await installOpenClawIntegration(config, client.apiKey, integrationConfig);
+      return;
+    case "pi-agent":
+      await installPiIntegration(config, client.apiKey, integrationConfig);
+      return;
+    case "claude-code":
+      await installClaudeCodeIntegration(config, client.apiKey, integrationConfig);
+      return;
+    case "hermes":
+      await installHermesIntegration(config, client.apiKey, integrationConfig);
+      return;
+    default:
+      console.log(`Unknown integration: ${key}`);
+  }
+}
+
+export async function setupIntegration(
+  config: RoutstrdConfig,
+  integrationKey?: IntegrationKey,
+): Promise<void> {
+  // Non-interactive selection (e.g. `routstrd onboard --pi-agent`).
+  if (integrationKey === "skip") {
+    console.log("Skipping integration setup.");
+    return;
+  }
+
+  if (integrationKey !== undefined) {
+    await installIntegrationByKey(config, integrationKey);
+    return;
+  }
+
+  console.log("\nChoose an integration to set up:");
+  console.log("1. OpenCode (default)");
+  console.log("2. OpenClaw");
+  console.log("3. Pi");
+  console.log("4. Claude Code");
+  console.log("5. Hermes");
+  console.log("6. Skip for now");
+
+  const answer = await ask("Select integration [1]: ");
+  const choice = parseChoice(answer);
+
+  const integrationByChoice: Record<number, keyof typeof CLIENT_CONFIGS> = {
+    1: "opencode",
+    2: "openclaw",
+    3: "pi-agent",
+    4: "claude-code",
+    5: "hermes",
+  };
+
+  const key = integrationByChoice[choice];
+  if (!key) {
+    console.log("Skipping integration setup.");
+    return;
+  }
+
+  await installIntegrationByKey(config, key);
+}

package/src/tui/usage/index.ts

@@ -0,0 +1 @@
+export { runUsageTui } from "./app.ts";

package/.claude/settings.local.json

@@ -1,10 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(bun build:*)",
-      "Bash(/Users/r/projects/routstr_main/routstrd/log_balance_table.sh)",
-      "Bash(bunx tsc *)",
-      "Bash(python3 *)"
-    ]
-  }
-}

package/.dockerignore

@@ -1,12 +0,0 @@
-node_modules/
-dist/
-.git/
-.worktrees/
-.pi/
-logs/
-tmp/
-temp/
-*.log
-.env
-.env.*
-.DS_Store