routstrd 0.3.11 → 0.4.1

package/src/start-daemon.ts

@@ -1,52 +1,167 @@
-import { openSync } from "fs";
+import {
+  closeSync,
+  existsSync,
+  fstatSync,
+  openSync,
+  readSync,
+} from "fs";
 import { logger } from "./utils/logger";
 import { CONFIG_DIR, LOGS_DIR } from "./utils/config";
 import { withCrossProcessLock } from "./utils/process-lock";
+import { urlHosts } from "./utils/daemon-client";
+import { fileURLToPath } from "url";
 
 const DAEMON_STARTUP_LOCK_PATH = `${CONFIG_DIR}/routstrd-startup.lock`;
 const DEBUG_LOG_PATH = `${CONFIG_DIR}/debug.log`;
 
-async function isDaemonHealthy(port: string): Promise<boolean> {
-  const controller = new AbortController();
-  const timeoutId = setTimeout(() => controller.abort(), 2000);
+/**
+ * The spawned daemon's stdout/stderr is redirected to DEBUG_LOG_PATH, so when
+ * it exits early we can surface its actual error from there instead of just
+ * telling the user to go read logs.
+ */
+function readDaemonOutput(offset: number): string {
+  let fd: number | undefined;
   try {
-    const existing = await fetch(`http://localhost:${port}/health`, {
-      signal: controller.signal,
-    });
-    return existing.ok;
+    if (!existsSync(DEBUG_LOG_PATH)) return "";
+    fd = openSync(DEBUG_LOG_PATH, "r");
+    const size = fstatSync(fd).size;
+    if (size <= offset) return "";
+    const bytesToRead = Math.min(size - offset, 256 * 1024);
+    const buffer = Buffer.allocUnsafe(bytesToRead);
+    const bytesRead = readSync(fd, buffer, 0, bytesToRead, offset);
+    return buffer
+      .toString("utf8", 0, bytesRead)
+      .split("\n")
+      .map((line) => line.trim())
+      .filter(Boolean)
+      .slice(-30)
+      .join("\n");
   } catch {
-    return false;
+    return "";
   } finally {
-    clearTimeout(timeoutId);
+    if (fd !== undefined) closeSync(fd);
   }
 }
 
+const STARTUP_LOG_PREFIX = "[routstrd:start]";
+
+/**
+ * Print only explicitly tagged, user-safe progress emitted by the detached
+ * daemon. Return the next byte offset so each line is shown exactly once.
+ */
+function printStartupProgress(offset: number): {
+  offset: number;
+  lastMessage?: string;
+} {
+  let fd: number | undefined;
+  try {
+    if (!existsSync(DEBUG_LOG_PATH)) return { offset };
+    fd = openSync(DEBUG_LOG_PATH, "r");
+    const size = fstatSync(fd).size;
+    if (size <= offset) return { offset };
+
+    // Startup messages are short. Bound each read so a noisy daemon cannot
+    // make the waiting CLI repeatedly load a large debug log into memory.
+    const bytesToRead = Math.min(size - offset, 64 * 1024);
+    const buffer = Buffer.allocUnsafe(bytesToRead);
+    const bytesRead = readSync(fd, buffer, 0, bytesToRead, offset);
+    const lastNewlineIndex = buffer.subarray(0, bytesRead).lastIndexOf(0x0a);
+    const completeBytes = lastNewlineIndex + 1;
+    if (completeBytes === 0) return { offset };
+    const appended = buffer.toString("utf8", 0, completeBytes);
+
+    let lastMessage: string | undefined;
+    for (const line of appended.split("\n")) {
+      const markerIndex = line.indexOf(STARTUP_LOG_PREFIX);
+      if (markerIndex === -1) continue;
+      const message = line.slice(markerIndex + STARTUP_LOG_PREFIX.length).trim();
+      if (message) {
+        console.log(`  ${message}`);
+        lastMessage = message;
+      }
+    }
+    return { offset: offset + completeBytes, lastMessage };
+  } catch {
+    return { offset };
+  } finally {
+    if (fd !== undefined) closeSync(fd);
+  }
+}
+
+function formatElapsed(elapsedMs: number): string {
+  const seconds = Math.floor(elapsedMs / 1000);
+  if (seconds < 60) return `${seconds}s`;
+  return `${Math.floor(seconds / 60)}m ${seconds % 60}s`;
+}
+
+function fileSize(path: string): number {
+  let fd: number | undefined;
+  try {
+    fd = openSync(path, "r");
+    return fstatSync(fd).size;
+  } finally {
+    if (fd !== undefined) closeSync(fd);
+  }
+}
+
+async function healthyDaemonHost(
+  port: string,
+  host = "127.0.0.1",
+): Promise<string | null> {
+  // Return the responding candidate so status output shows a connectable URL.
+  for (const candidate of urlHosts(host)) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 2000);
+    try {
+      const existing = await fetch(`http://${candidate}:${port}/health`, {
+        signal: controller.signal,
+      });
+      if (existing.ok) return candidate;
+    } catch {
+      // Try the next candidate host.
+    } finally {
+      clearTimeout(timeoutId);
+    }
+  }
+  return null;
+}
+
 async function startDaemonUnlocked(
-  options: { port?: string; provider?: string },
+  options: { port?: string; host?: string; provider?: string },
 ): Promise<void> {
   const args: string[] = [];
   const port = options.port || "8008";
+  const host = options.host || "127.0.0.1";
   const pollIntervalMs = 250;
   const startupTimeoutMs = 10 * 60 * 1000;
 
-  if (await isDaemonHealthy(port)) {
-    console.log(`Routstr daemon already running on http://localhost:${port}/v1`);
+  const existingHost = await healthyDaemonHost(port, host);
+  if (existingHost) {
+    console.log(`Routstr daemon already running on http://${existingHost}:${port}/v1`);
     return;
   }
 
   if (options.port) {
     args.push("--port", options.port);
   }
+  if (options.host) {
+    args.push("--host", options.host);
+  }
   if (options.provider) {
     args.push("--provider", options.provider);
   }
 
-  const daemonScript = new URL("./daemon/index.js", import.meta.url).pathname;
-  const shellCmd = `bun run "${daemonScript}" ${args.map((a) => `'${a}'`).join(" ")}`;
+  let daemonScript = fileURLToPath(new URL("./daemon/index.js", import.meta.url));
+  if (!existsSync(daemonScript)) {
+    daemonScript = fileURLToPath(new URL("./daemon/index.ts", import.meta.url));
+  }
 
+  const debugLogOffset = existsSync(DEBUG_LOG_PATH)
+    ? fileSize(DEBUG_LOG_PATH)
+    : 0;
   const debugLogFd = openSync(DEBUG_LOG_PATH, "a");
 
-  const proc = Bun.spawn(["sh", "-c", shellCmd], {
+  const proc = Bun.spawn(["bun", daemonScript, ...args], {
     stdout: debugLogFd,
     stderr: debugLogFd,
     stdin: "ignore",
@@ -55,40 +170,91 @@ async function startDaemonUnlocked(
 
   proc.unref();
 
+  // The daemon must outlive a successful start, but a start we give up on must not
+  // leave a detached process holding the wallet locks. `detached` makes it a group leader.
+  const killSpawnedDaemon = (): void => {
+    try {
+      process.kill(-proc.pid, "SIGTERM");
+    } catch {
+      // Already exited.
+    }
+  };
+  const abandonOnSignal = (): void => {
+    killSpawnedDaemon();
+    process.exit(1);
+  };
+  process.once("SIGINT", abandonOnSignal);
+  process.once("SIGTERM", abandonOnSignal);
+
   let exitCode: number | null = null;
   proc.exited.then((code) => {
     exitCode = code;
   });
 
+  const startedAt = Date.now();
+  const heartbeatIntervalMs = 10_000;
+  let nextHeartbeatAt = heartbeatIntervalMs;
+  let progressLogOffset = debugLogOffset;
+  let currentPhase = "starting daemon";
+
   const maxPolls = Math.ceil(startupTimeoutMs / pollIntervalMs);
   for (let i = 0; i < maxPolls; i++) {
     await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
 
+    const progress = printStartupProgress(progressLogOffset);
+    progressLogOffset = progress.offset;
+    if (progress.lastMessage) {
+      currentPhase = progress.lastMessage
+        .replace(/\.$/, "")
+        .toLowerCase();
+    }
+
+    const elapsedMs = Date.now() - startedAt;
+    if (elapsedMs >= nextHeartbeatAt) {
+      console.log(
+        `  Still ${currentPhase} (${formatElapsed(elapsedMs)} elapsed)...`,
+      );
+      nextHeartbeatAt += heartbeatIntervalMs;
+    }
+
     if (exitCode !== null) {
+      const daemonOutput = readDaemonOutput(debugLogOffset);
       throw new Error(
-        `Daemon process exited early with code ${exitCode}. Check logs in ${LOGS_DIR}`,
+        `Daemon process exited early with code ${exitCode}.` +
+          (daemonOutput
+            ? `\n\nDaemon output:\n${daemonOutput}`
+            : ` Check logs in ${LOGS_DIR}`),
       );
     }
 
-    if (await isDaemonHealthy(port)) {
-      console.log(`Routstr daemon started (PID: ${proc.pid}).`);
+    if (await healthyDaemonHost(port, host)) {
+      process.off("SIGINT", abandonOnSignal);
+      process.off("SIGTERM", abandonOnSignal);
+      printStartupProgress(progressLogOffset);
+      console.log(
+        `Routstr daemon started (PID: ${proc.pid}, ${formatElapsed(Date.now() - startedAt)}).`,
+      );
       return;
     }
   }
 
+  killSpawnedDaemon();
   throw new Error(
-    `Daemon failed to start within ${Math.round(startupTimeoutMs / 1000)} seconds. Check logs in ${LOGS_DIR}`,
+    `Daemon did not become healthy within ${Math.round(startupTimeoutMs / 1000)} seconds; ` +
+      `the incomplete daemon (PID ${proc.pid}) was stopped. Check logs in ${LOGS_DIR}`,
   );
 }
 
 export async function startDaemon(
-  options: { port?: string; provider?: string } = {},
+  options: { port?: string; host?: string; provider?: string } = {},
 ): Promise<void> {
   const port = options.port || "8008";
+  const host = options.host || "127.0.0.1";
   const startupTimeoutMs = 10 * 60 * 1000;
 
-  if (await isDaemonHealthy(port)) {
-    console.log(`Routstr daemon already running on http://localhost:${port}/v1`);
+  const existingHost = await healthyDaemonHost(port, host);
+  if (existingHost) {
+    console.log(`Routstr daemon already running on http://${existingHost}:${port}/v1`);
     return;
   }
 

package/src/utils/clients.ts

@@ -2,6 +2,7 @@ import {
   callDaemon,
   loadConfig,
   getDaemonBaseUrl,
+  getUserNpub,
   ensureDaemonRunning,
 } from "./daemon-client";
 import { logger } from "./logger";
@@ -202,6 +203,7 @@ export async function addClientAction(options: AddClientOptions): Promise<void>
   if (options.hermes) integrationKeys.push("hermes");
 
   if (integrationKeys.length > 0) {
+    let hadFailure = false;
     for (const key of integrationKeys) {
       const integrationFn = CLIENT_INTEGRATIONS[key];
       const integrationConfig = CLIENT_CONFIGS[key];
@@ -222,15 +224,34 @@ export async function addClientAction(options: AddClientOptions): Promise<void>
         console.log(`    Client ID: ${client.id}`);
         console.log(`    API Key:   ${client.apiKey}`);
       } catch (error) {
+        const message = (error as Error)?.message ?? String(error);
         logger.error(
           `Failed to set up ${integrationConfig.name} integration:`,
           error,
         );
+        console.error(
+          `\n  Error: failed to set up ${integrationConfig.name} integration.`,
+        );
+        console.error(`  ${message}`);
+        if (/NIP-98|registered npub\/pubkey|registered/i.test(message)) {
+          const npub = getUserNpub(config);
+          console.error(
+            `  The daemon at ${getDaemonBaseUrl(config)} rejected this account.`,
+          );
+          if (npub) {
+            console.error(
+              `  Register/authorize this npub on the remote daemon first:`,
+            );
+            console.error(`    ${npub}`);
+          }
+        }
+        hadFailure = true;
         continue;
       }
     }
 
     console.log(`\n  Access Routstr at: ${getDaemonBaseUrl(config)}/v1`);
+    if (hadFailure) process.exit(1);
     return;
   }
 

package/src/utils/config.ts

@@ -32,6 +32,7 @@ export interface NwcConfig {
 
 export interface RoutstrdConfig {
   port: number;
+  host: string;
   provider: string | null;
   cocodPath: string | null;
   mode?: "xcashu" | "apikeys";
@@ -54,11 +55,21 @@ export interface RoutstrdConfig {
   relays?: string[];
   /** NWC integration configuration */
   nwc?: NwcConfig;
+  /**
+   * Default max_tokens (chat/completions) and max_output_tokens (responses)
+   * injected into proxied requests when the client does not supply one.
+   * Caps the completion budget the SDK prices against (completion × maxTokens)
+   * instead of the provider's worst-case max_completion_cost. Set to 0 to
+   * disable injection and always forward the client's value as-is.
+   */
+  maxTokens?: number;
 }
 
 export const DEFAULT_CONFIG: RoutstrdConfig = {
   port: 8008,
+  host: "127.0.0.1",
   provider: null,
   cocodPath: null,
   mode: "apikeys",
+  maxTokens: 64000,
 };

package/src/utils/daemon-client.ts

@@ -29,12 +29,40 @@ export async function loadConfig(): Promise<RoutstrdConfig> {
   return DEFAULT_CONFIG;
 }
 
-export function getDaemonBaseUrl(config: RoutstrdConfig): string {
-  return (
-    config.daemonUrl?.replace(/\/$/, "") || `http://localhost:${config.port}`
+/** Format a bind address for use as a URL host. */
+export function urlHost(host?: string): string {
+  return urlHosts(host)[0] ?? "127.0.0.1";
+}
+
+/** Return connectable URL hosts for a bind address, in preference order. */
+export function urlHosts(host?: string): string[] {
+  if (!host || host === "0.0.0.0") return ["127.0.0.1", "[::1]"];
+  if (host === "::") return ["[::1]", "127.0.0.1"];
+  if (host.startsWith("[") && host.endsWith("]")) return [host];
+  if (host.includes(":")) return [`[${host.replace(/%/g, "%25")}]`];
+  return [host];
+}
+
+function localDaemonBaseUrls(config: RoutstrdConfig): string[] {
+  return urlHosts(config.host).map(
+    (host) => `http://${host}:${config.port}`,
   );
 }
 
+class DaemonConnectionError extends Error {
+  constructor(cause: unknown) {
+    super("Failed to connect to daemon", { cause });
+    this.name = "DaemonConnectionError";
+  }
+}
+
+export function getDaemonBaseUrl(config: RoutstrdConfig): string {
+  if (config.daemonUrl) {
+    return config.daemonUrl.replace(/\/$/, "");
+  }
+  return `http://${urlHost(config.host)}:${config.port}`;
+}
+
 export function getAuthBaseUrl(config: RoutstrdConfig): string {
   if (config.authUrl) {
     return config.authUrl.replace(/\/$/, "");
@@ -67,14 +95,20 @@ async function _callUrl(
     );
   }
 
-  const response = await fetch(url, {
-    method,
-    headers: {
-      ...(authorization ? { Authorization: authorization } : {}),
-      ...(bodyString ? { "Content-Type": "application/json" } : {}),
-    },
-    body: bodyString,
-  });
+  const headers = new Headers();
+  if (authorization) headers.set("Authorization", authorization);
+  if (bodyString) headers.set("Content-Type", "application/json");
+
+  let response: Response;
+  try {
+    response = await fetch(url, {
+      method,
+      headers,
+      body: bodyString,
+    });
+  } catch (error) {
+    throw new DaemonConnectionError(error);
+  }
 
   if (!response.ok) {
     const errorData = (await response.json()) as { error?: string };
@@ -84,13 +118,33 @@ async function _callUrl(
   return response.json() as Promise<CommandResponse>;
 }
 
+async function callLocalDaemon(
+  path: string,
+  options: { method?: "GET" | "POST" | "PATCH" | "DELETE"; body?: object },
+  config: RoutstrdConfig,
+): Promise<CommandResponse> {
+  // Retry only connection failures; HTTP errors prove that a server answered.
+  let connectionError: DaemonConnectionError | undefined;
+  for (const baseUrl of localDaemonBaseUrls(config)) {
+    try {
+      return await _callUrl(baseUrl, path, options, config);
+    } catch (error) {
+      if (!(error instanceof DaemonConnectionError)) throw error;
+      connectionError = error;
+    }
+  }
+  throw connectionError ?? new Error("No daemon host candidates available");
+}
+
 export async function callDaemon(
   path: string,
   options: { method?: "GET" | "POST" | "PATCH" | "DELETE"; body?: object } = {},
 ): Promise<CommandResponse> {
   const config = await loadConfig();
-  const baseUrl = getDaemonBaseUrl(config);
-  return _callUrl(baseUrl, path, options, config);
+  if (config.daemonUrl) {
+    return _callUrl(getDaemonBaseUrl(config), path, options, config);
+  }
+  return callLocalDaemon(path, options, config);
 }
 
 /** Like callDaemon but sends requests to the auth proxy URL instead.
@@ -100,26 +154,50 @@ export async function callAuth(
   options: { method?: "GET" | "POST" | "PATCH" | "DELETE"; body?: object } = {},
 ): Promise<CommandResponse> {
   const config = await loadConfig();
-  const baseUrl = getAuthBaseUrl(config);
-  return _callUrl(baseUrl, path, options, config);
+  if (!config.authUrl && !config.daemonUrl) {
+    return callLocalDaemon(path, options, config);
+  }
+  return _callUrl(getAuthBaseUrl(config), path, options, config);
 }
 
 export async function isDaemonRunning(): Promise<boolean> {
   try {
     const config = await loadConfig();
-    const baseUrl = getDaemonBaseUrl(config);
-    const url = `${baseUrl}/health`;
 
-    let authorization: string | undefined;
-    if (config.daemonUrl && config.nsec) {
-      const secretKey = parseSecretKey(config.nsec);
-      authorization = await createNIP98Authorization(secretKey, url, "GET");
+    if (config.daemonUrl) {
+      const baseUrl = config.daemonUrl.replace(/\/$/, "");
+      const url = `${baseUrl}/health`;
+      let authorization: string | undefined;
+      if (config.nsec) {
+        const secretKey = parseSecretKey(config.nsec);
+        authorization = await createNIP98Authorization(secretKey, url, "GET");
+      }
+      try {
+        const response = await fetch(url, {
+          headers: authorization ? { Authorization: authorization } : {},
+        });
+        return response.ok;
+      } catch {
+        return false;
+      }
     }
 
-    const response = await fetch(url, {
-      headers: authorization ? { Authorization: authorization } : {},
-    });
-    return response.ok;
+    // A wildcard bind may be listening on either loopback family.
+    for (const baseUrl of localDaemonBaseUrls(config)) {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), 2000);
+      try {
+        const response = await fetch(`${baseUrl}/health`, {
+          signal: controller.signal,
+        });
+        if (response.ok) return true;
+      } catch {
+        // Try the next candidate host.
+      } finally {
+        clearTimeout(timeoutId);
+      }
+    }
+    return false;
   } catch {
     return false;
   }
@@ -145,6 +223,7 @@ export async function startDaemonProcess(): Promise<void> {
   const config = await loadConfig();
   await startDaemon({
     port: String(config.port || 8008),
+    host: config.host || undefined,
     provider: config.provider || undefined,
   });
 }

package/src/utils/logger.ts

@@ -1,26 +1,37 @@
-import { appendFile, mkdir } from "fs/promises";
-import { existsSync } from "fs";
+import { appendFileSync, existsSync, mkdirSync } from "fs";
 import { join } from "path";
 
 const HOME = process.env.HOME || process.env.USERPROFILE || "";
+
+// `bun test` sets NODE_ENV=test. Test runs import modules that pull in this
+// singleton, so without this guard their output would be written into the real
+// ~/.routstrd log files alongside production daemon output.
+const isTest = process.env.NODE_ENV === "test";
+
 const LOG_DIR = process.env.ROUTSTRD_DIR || `${HOME}/.routstrd`;
 const LOGS_DIR = join(LOG_DIR, "logs");
+/** Wallet-engine (coco-core / Cashu) diagnostics land in their own directory. */
+export const COCO_LOGS_DIR = join(LOG_DIR, "coco-logs");
 
-function getLogFileForDate(date: Date = new Date()): string {
+function getLogFileForDate(logsDir: string, date: Date = new Date()): string {
   const year = date.getFullYear();
   const month = String(date.getMonth() + 1).padStart(2, "0");
   const day = String(date.getDate()).padStart(2, "0");
-  return join(LOGS_DIR, `${year}-${month}-${day}.log`);
+  return join(logsDir, `${year}-${month}-${day}.log`);
 }
 
-async function ensureLogDir() {
-  if (!existsSync(LOGS_DIR)) {
-    await mkdir(LOGS_DIR, { recursive: true });
+function ensureDir(dir: string) {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
   }
 }
 
-async function writeLog(level: string, ...args: unknown[]) {
-  await ensureLogDir();
+// NOTE: writes are synchronous on purpose — the daemon calls process.exit()
+// right after logger.error(...) on fatal paths, and async writes were being
+// silently dropped, making startup failures invisible.
+function writeLog(logsDir: string, level: string, ...args: unknown[]) {
+  if (isTest) return;
+  ensureDir(logsDir);
   const timestamp = new Date().toISOString();
   const message = args
     .map((a) => {
@@ -38,28 +49,31 @@ async function writeLog(level: string, ...args: unknown[]) {
     })
     .join(" ");
   const line = `[${timestamp}] [${level}] ${message}\n`;
-  const logFile = getLogFileForDate(new Date(timestamp));
+  const logFile = getLogFileForDate(logsDir, new Date(timestamp));
   try {
-    await appendFile(logFile, line);
+    appendFileSync(logFile, line);
   } catch (error) {
     console.error("Failed to write log:", error);
   }
 }
 
-export const logger = {
-  log: (...args: unknown[]) => {
-    writeLog("INFO", ...args);
-  },
-  debug: (...args: unknown[]) => {
-    writeLog("DEBUG", ...args);
-  },
-  warn: (...args: unknown[]) => {
-    writeLog("WARN", ...args);
-  },
-  error: (...args: unknown[]) => {
-    writeLog("ERROR", ...args);
-  },
-  info: (...args: unknown[]) => {
-    writeLog("INFO", ...args);
-  },
-};
+export interface FileLogger {
+  log: (...args: unknown[]) => void;
+  debug: (...args: unknown[]) => void;
+  warn: (...args: unknown[]) => void;
+  error: (...args: unknown[]) => void;
+  info: (...args: unknown[]) => void;
+}
+
+function createLogger(logsDir: string): FileLogger {
+  return {
+    log: (...args) => writeLog(logsDir, "INFO", ...args),
+    debug: (...args) => writeLog(logsDir, "DEBUG", ...args),
+    warn: (...args) => writeLog(logsDir, "WARN", ...args),
+    error: (...args) => writeLog(logsDir, "ERROR", ...args),
+    info: (...args) => writeLog(logsDir, "INFO", ...args),
+  };
+}
+
+export const logger = createLogger(LOGS_DIR);
+export const cocoLogger = createLogger(COCO_LOGS_DIR);