routstrd 0.3.10 → 0.4.0

package/src/integrations/registry.ts

@@ -6,6 +6,8 @@ import { installOpenClawIntegration } from "./openclaw";
 import { installClaudeCodeIntegration } from "./claudecode";
 import { installHermesIntegration } from "./hermes";
 
+const HOME = process.env.HOME || process.env.USERPROFILE || "";
+
 export interface IntegrationConfig {
   clientId: string;
   name: string;
@@ -28,27 +30,27 @@ export const CLIENT_CONFIGS: Record<string, IntegrationConfig> = {
   opencode: {
     clientId: "opencode",
     name: "OpenCode",
-    configPath: join(process.env.HOME || "", ".config/opencode/opencode.json"),
+    configPath: join(HOME, ".config/opencode/opencode.json"),
   },
   "pi-agent": {
     clientId: "pi-agent",
     name: "Pi Agent",
-    configPath: join(process.env.HOME || "", ".pi/agent/models.json"),
+    configPath: join(HOME, ".pi/agent/models.json"),
   },
   openclaw: {
     clientId: "openclaw",
     name: "OpenClaw",
-    configPath: join(process.env.HOME || "", ".openclaw/openclaw.json"),
+    configPath: join(HOME, ".openclaw/openclaw.json"),
   },
   "claude-code": {
     clientId: "claude-code",
     name: "Claude Code",
-    configPath: join(process.env.HOME || "", ".claude/settings.json"),
+    configPath: join(HOME, ".claude/settings.json"),
   },
   hermes: {
     clientId: "hermes",
     name: "Hermes",
-    configPath: join(process.env.HOME || "", ".hermes/config.yaml"),
+    configPath: join(HOME, ".hermes/config.yaml"),
   },
 };
 

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",
@@ -60,18 +175,47 @@ async function startDaemonUnlocked(
     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)) {
+      printStartupProgress(progressLogOffset);
+      console.log(
+        `Routstr daemon started (PID: ${proc.pid}, ${formatElapsed(Date.now() - startedAt)}).`,
+      );
       return;
     }
   }
@@ -82,13 +226,15 @@ async function startDaemonUnlocked(
 }
 
 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/tui/usage/app.ts

@@ -28,7 +28,8 @@ import {
 } from "./terminal.ts";
 import { COLORS } from "./constants.ts";
 import { renderHeader, renderSearchBar, renderSeparator, renderTabContent, renderTabs } from "./render.ts";
-import type { TabId, UsageStats } from "./types.ts";
+import type { TabId, UpdateInfo, UsageStats } from "./types.ts";
+import { checkForUpdates } from "../../utils/update-checker.ts";
 
 export async function runUsageTui(): Promise<void> {
   const running = await isDaemonRunning();
@@ -53,6 +54,39 @@ export async function runUsageTui(): Promise<void> {
   let cleanedUp = false;
   let fetching = false;
 
+  // Update-check state — re-checked at most every 210 minutes to avoid
+  // spamming the npm registry. The first check happens shortly after
+  // startup so the TUI doesn't block on a network call.
+  const UPDATE_CHECK_INTERVAL_MS = 210 * 60 * 1000;
+  const UPDATE_CHECK_DELAY_MS = 3000;
+  let updateInfo: UpdateInfo | null = null;
+  let lastUpdateCheck = 0;
+  let updateCheckInProgress = false;
+
+  async function maybeCheckForUpdates(): Promise<void> {
+    if (updateCheckInProgress) return;
+    const now = Date.now();
+    if (updateInfo && now - lastUpdateCheck < UPDATE_CHECK_INTERVAL_MS) return;
+
+    updateCheckInProgress = true;
+    lastUpdateCheck = now;
+    try {
+      const result = await checkForUpdates();
+      const outdated = result.packages.filter((p) => p.hasUpdate);
+      updateInfo = {
+        hasUpdate: result.hasUpdate,
+        text: outdated.length > 0
+          ? `Update available: ${outdated.map((p) => p.label).join(", ")} ${outdated.map((p) => p.latest).join(", ")}`
+          : "",
+      };
+      render();
+    } catch {
+      // Silently ignore — update checks are best-effort
+    } finally {
+      updateCheckInProgress = false;
+    }
+  }
+
   if (isInteractive) {
     stdout.write(enterAlternateScreen() + hideCursor());
     stdin.setRawMode?.(true);
@@ -138,7 +172,7 @@ export async function runUsageTui(): Promise<void> {
 
     const content = renderTabContent(currentTab, stats, balance, status, width, clients);
     const footer = `${COLORS.dim}Press [Q] to quit, [R] to refresh, [A] to toggle auto-refresh${autoRefresh ? " (on)" : " (off)"}  scroll:${vimState.scrollPos}${COLORS.reset}${vimState.mode === "normal" ? `  ${COLORS.yellow}vim: hjkl/arrows, / search, g top, gg bottom${COLORS.reset}` : ""}`;
-    const chrome = renderHeader(currentTab, width, visibleTabs) + renderTabs(currentTab, visibleTabs) + renderSeparator(width) + renderSearchBar();
+    const chrome = renderHeader(currentTab, width, visibleTabs, updateInfo ?? undefined) + renderTabs(currentTab, visibleTabs) + renderSeparator(width) + renderSearchBar();
     const chromeLines = chrome.split("\n").length - 1;
     const footerSeparator = renderSeparator(width);
     const footerLines = footerSeparator.split("\n").length - 1;
@@ -265,9 +299,14 @@ export async function runUsageTui(): Promise<void> {
 
   await fetchData();
 
+  // Kick off the first update check after a short delay so the initial
+  // data fetch isn't blocked by a network round-trip to npm.
+  setTimeout(() => void maybeCheckForUpdates(), UPDATE_CHECK_DELAY_MS);
+
   refreshInterval = setInterval(() => {
     if (autoRefresh) {
       void fetchData();
     }
+    void maybeCheckForUpdates();
   }, 2000);
 }

package/src/tui/usage/render.ts

@@ -8,7 +8,7 @@ import {
 import { vimState } from "./state.ts";
 import { stripAnsi } from "./terminal.ts";
 import type { BalanceInfo, StatusInfo } from "./data.ts";
-import type { TabId, UsageStats } from "./types.ts";
+import type { TabId, UpdateInfo, UsageStats } from "./types.ts";
 
 /** Format a cost value: 0.12, 1.23, 12.34, 123.45, 1.23k, 1.23m */
 function formatCost(value: number): string {
@@ -24,13 +24,20 @@ function formatReqs(value: number): string {
   return value.toString();
 }
 
-export function renderHeader(activeTab: TabId, width: number, visibleTabs: Tab[]): string {
+export function renderHeader(activeTab: TabId, width: number, visibleTabs: Tab[], updateInfo?: UpdateInfo): string {
   const title = `${COLORS.bold}${COLORS.cyan}ROUTSTRD USAGE MONITOR${COLORS.reset}`;
   const vimIndicator = `${COLORS.yellow}[vim]${COLORS.reset}`;
   const maxKey = visibleTabs.length;
   const help = `${COLORS.dim}[Q] Quit  [↑↓] Scroll  [←→] Tabs  [1-${maxKey}] Tabs  [R] Refresh${COLORS.reset}`;
   const fill = width - title.length - help.length - vimIndicator.length - 6;
-  return `${title}${vimIndicator}${" ".repeat(Math.max(1, fill))}${help}\n`;
+  const headerLine = `${title}${vimIndicator}${" ".repeat(Math.max(1, fill))}${help}`;
+
+  if (updateInfo?.hasUpdate) {
+    const banner = `${COLORS.bold}${COLORS.yellow}  ↻ UPDATE AVAILABLE — run ${COLORS.green}routstrd update${COLORS.yellow} to update${COLORS.reset}`;
+    return `${headerLine}\n${banner}\n`;
+  }
+
+  return `${headerLine}\n`;
 }
 
 export function renderSearchBar(): string {

package/src/tui/usage/types.ts

@@ -1,8 +1,14 @@
 import type { UsageTrackingEntry } from "../../daemon/types.ts";
 import type { UsageSummary } from "../../daemon/http/usage-summary.ts";
+import type { UpdateCheckResult } from "../../utils/update-checker.ts";
 
 export type { UsageSummary };
 
+export interface UpdateInfo {
+  hasUpdate: boolean;
+  text: string;
+}
+
 export interface UsageStats {
   entries: UsageTrackingEntry[];
   totalEntries: number;

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,
   });
 }