routstrd 0.4.7 → 0.4.9

package/src/daemon/args.ts

@@ -1,5 +1,5 @@
 export function parseArgs(argv: string[]): {
-  port: number;
+  port: number | null;
   host: string | null;
   provider: string | null;
 } {
@@ -9,10 +9,9 @@ export function parseArgs(argv: string[]): {
     (arg) => arg === "--provider" || arg === "-p",
   );
 
-  const port =
-    portFlagIndex !== -1
-      ? Number.parseInt(argv[portFlagIndex + 1] || "8008", 10)
-      : 8008;
+  const portValue = portFlagIndex !== -1 ? argv[portFlagIndex + 1] : undefined;
+  const parsedPort = portValue ? Number.parseInt(portValue, 10) : Number.NaN;
+  const port = Number.isInteger(parsedPort) ? parsedPort : null;
 
   const hostValue =
     hostFlagIndex !== -1 ? argv[hostFlagIndex + 1] : undefined;

package/src/daemon/http/index.ts

@@ -488,8 +488,22 @@ export function createDaemonRequestHandler(deps: {
         const body = await readJsonBody(req);
         const amount = getRequiredPositiveNumberField(body, "amount");
         const mintUrl = optionalStringField(body, "mintUrl");
-        const invoice = await deps.walletClient.receiveBolt11(amount, mintUrl);
-        return { output: { invoice, amount, mintUrl } };
+        const { invoice, operationId } = await deps.walletClient.receiveBolt11(
+          amount,
+          mintUrl,
+        );
+        return { output: { invoice, operationId, amount, mintUrl } };
+      });
+      return;
+    }
+
+    const mintQuoteMatch = url.pathname.match(/^\/wallet\/receive\/bolt11\/([^/]+)$/);
+    if (req.method === "GET" && mintQuoteMatch?.[1]) {
+      const operationId = decodeURIComponent(mintQuoteMatch[1]);
+      await respond(res, async () => {
+        const quote = await deps.walletClient.getMintQuote?.(operationId);
+        if (!quote) throw new CocodHttpError(404, "Mint quote not found");
+        return { output: quote };
       });
       return;
     }
@@ -785,6 +799,27 @@ export function createDaemonRequestHandler(deps: {
       return;
     }
 
+    // Scheduled refresh job (Nostr events, models, client integrations).
+    // The job re-reads this on every tick, so no daemon restart is needed.
+    if (req.method === "POST" && url.pathname === "/settings/auto-refresh") {
+      await respond(res, async () => {
+        const body = await readJsonBody(req);
+        const enabled = body.enabled === true || body.enabled === "true";
+
+        const config = await loadDaemonConfig();
+        config.autoRefresh = { ...config.autoRefresh, enabled };
+        saveDaemonConfig(config);
+
+        return {
+          output: {
+            message: `Automatic refresh ${enabled ? "enabled" : "disabled"}.`,
+            autoRefresh: config.autoRefresh,
+          },
+        };
+      });
+      return;
+    }
+
     if (req.method === "GET" && url.pathname === "/models") {
       try {
         const forceRefresh =

package/src/daemon/index.ts

@@ -74,9 +74,8 @@ import { installGlobalErrorHandlers } from "./fatal-error";
 // the process silently. Uncaught exceptions are fatal: the process state can
 // no longer be trusted, so the daemon logs and exits for its supervisor to
 // restart (see fatal-error.ts).
-installGlobalErrorHandlers();
-
-async function main(): Promise<void> {
+export async function runDaemon(argv: string[] = process.argv): Promise<void> {
+  installGlobalErrorHandlers();
   // Install signal handlers before migration and wallet startup. If a signal
   // arrives before the full shutdown path is wired, process.exit() still runs
   // the synchronous PID-lock exit hooks registered by claimPidFile.
@@ -89,10 +88,10 @@ async function main(): Promise<void> {
   process.once("SIGTERM", shutdownForSignal);
 
   startupProgress("Loading configuration...");
-  const args = parseArgs(process.argv);
+  const args = parseArgs(argv);
   const config = await loadDaemonConfig();
 
-  const port = args.port;
+  const port = args.port ?? config.port ?? 8008;
   const host = args.host || config.host || "127.0.0.1";
   const provider = args.provider || config.provider;
   const requestResponseLogDir =
@@ -235,39 +234,94 @@ async function main(): Promise<void> {
     // Ignore
   }
 
-  const REFRESH_INTERVAL_MS = 21 * 60 * 1000; // 21 mins
+  const DEFAULT_REFRESH_INTERVAL_MS = 21 * 60 * 1000; // 21 mins
+  // While the job is disabled we keep a light poll running so `clients
+  // --enable-automatic-refresh` takes effect without a daemon restart.
+  const DISABLED_REFRESH_POLL_MS = 60 * 1000;
+
+  /**
+   * Read autoRefresh from disk on every tick (like the NWC auto-refill
+   * getter) so CLI/config changes apply immediately without a restart.
+   */
+  const readAutoRefreshSettings = (): {
+    enabled: boolean;
+    intervalMs: number;
+  } => {
+    const autoRefresh = loadDaemonConfigSync().autoRefresh;
+    const intervalMs =
+      typeof autoRefresh?.intervalMs === "number" && autoRefresh.intervalMs > 0
+        ? autoRefresh.intervalMs
+        : DEFAULT_REFRESH_INTERVAL_MS;
+    return { enabled: autoRefresh?.enabled !== false, intervalMs };
+  };
 
   // Recurring job to refresh routstr21 models
-  let refreshInterval: ReturnType<typeof setInterval> | null = null;
+  let refreshTimer: ReturnType<typeof setTimeout> | null = null;
+  let refreshJobActive = false;
+  let disabledNoticeLogged = false;
+
+  const runScheduledRefresh = async (): Promise<void> => {
+    logger.log("Running scheduled Nostr event refresh...");
+    try {
+      await modelManager.refreshNostrEvents();
+    } catch (error) {
+      logger.error("Scheduled Nostr event refresh failed:", error);
+    }
+
+    logger.log("Running scheduled model refresh...");
+    try {
+      await refreshModelsAndIntegrations(getRoutstr21Models, updatedConfig, "Scheduled");
+    } catch (error) {
+      logger.error("Scheduled model refresh failed:", error);
+    }
+  };
+
+  const scheduleNextRefresh = (): void => {
+    if (!refreshJobActive) return;
+
+    const { enabled, intervalMs } = readAutoRefreshSettings();
+    if (!enabled) {
+      if (!disabledNoticeLogged) {
+        logger.log(
+          "Scheduled refresh job is disabled (autoRefresh.enabled=false). Polling for re-enable every 60s.",
+        );
+        disabledNoticeLogged = true;
+      }
+      refreshTimer = setTimeout(
+        scheduleNextRefresh,
+        Math.min(intervalMs, DISABLED_REFRESH_POLL_MS),
+      );
+      return;
+    }
+
+    if (disabledNoticeLogged) {
+      logger.log("Scheduled refresh job re-enabled.");
+      disabledNoticeLogged = false;
+    }
+
+    refreshTimer = setTimeout(() => {
+      void runScheduledRefresh()
+        .catch((error) => logger.error("Model refresh interval escaped:", error))
+        .finally(() => scheduleNextRefresh());
+    }, intervalMs);
+  };
 
   const startModelRefreshJob = () => {
+    refreshJobActive = true;
+    const { enabled, intervalMs } = readAutoRefreshSettings();
     logger.log(
-      `Starting recurring model refresh job (every ${REFRESH_INTERVAL_MS / 1000 / 60 / 60} hours)`,
+      enabled
+        ? `Starting recurring model refresh job (every ${Math.round(intervalMs / 60_000)} minutes)`
+        : "Recurring model refresh job is disabled (autoRefresh.enabled=false).",
     );
-
-    refreshInterval = setInterval(() => {
-      (async () => {
-        logger.log("Running scheduled Nostr event refresh...");
-        try {
-          await modelManager.refreshNostrEvents();
-        } catch (error) {
-          logger.error("Scheduled Nostr event refresh failed:", error);
-        }
-
-        logger.log("Running scheduled model refresh...");
-        try {
-          await refreshModelsAndIntegrations(getRoutstr21Models, updatedConfig, "Scheduled");
-        } catch (error) {
-          logger.error("Scheduled model refresh failed:", error);
-        }
-      })().catch((error) => logger.error("Model refresh interval escaped:", error));
-    }, REFRESH_INTERVAL_MS);
+    scheduleNextRefresh();
   };
 
   const stopModelRefreshJob = () => {
-    if (refreshInterval) {
-      clearInterval(refreshInterval);
-      refreshInterval = null;
+    refreshJobActive = false;
+    if (refreshTimer) {
+      clearTimeout(refreshTimer);
+      refreshTimer = null;
       logger.log("Stopped recurring model refresh job.");
     }
   };
@@ -381,9 +435,16 @@ async function main(): Promise<void> {
 
         startModelRefreshJob();
         startRefundJob();
-        // Run an immediate refresh to populate models right away
-        logger.log("Running initial model refresh...");
-        await refreshModelsAndIntegrations(getRoutstr21Models, updatedConfig, "Initial");
+        // Run an immediate refresh to populate models right away. Client
+        // integrations are skipped when the scheduled job is disabled, so a
+        // restart does not overwrite hand-edited client configs.
+        if (readAutoRefreshSettings().enabled) {
+          logger.log("Running initial model refresh...");
+          await refreshModelsAndIntegrations(getRoutstr21Models, updatedConfig, "Initial");
+        } else {
+          logger.log("Running initial model refresh (client integrations skipped)...");
+          await getRoutstr21Models(true);
+        }
       })
       .catch((error) => {
         logger.error("Initial model refresh failed:", error);
@@ -395,7 +456,7 @@ async function main(): Promise<void> {
 }
 
 if (import.meta.main) {
-  main().catch((error) => {
+  runDaemon().catch((error) => {
     logger.error("Failed to start Routstr daemon:", error);
     // Also write to stderr so the spawning CLI can surface the real error
     // (stdout/stderr are redirected to debug.log by start-daemon.ts).

package/src/daemon/wallet/auto-refill.ts

@@ -104,7 +104,7 @@ export function startAutoRefillLoop(
       logger.log(
         `[auto-refill] Creating BOLT-11 invoice for ${config.amount} sats via ${mintUrl}...`,
       );
-      const invoice = await cocod.receiveBolt11(config.amount, 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...`);

package/src/daemon/wallet/coco-client.ts

@@ -1,5 +1,6 @@
 import {
   Manager,
+  OperationInProgressError,
   getEncodedToken,
   normalizeMintUrl,
 } from "@cashu/coco-core";
@@ -146,6 +147,9 @@ const SAFE_COCO_LOG_FIELDS = new Set([
   "operationId",
   "quoteId",
   "state",
+  "code",
+  "detail",
+  "status",
   "count",
   "total",
   "filterCount",
@@ -260,7 +264,8 @@ export function isZombieProcess(
   }
 }
 
-function defaultIsProcessRunning(pid: number): boolean {
+/** Test whether a PID is alive; dead-but-unreaped zombies count as dead. */
+export function defaultIsProcessRunning(pid: number): boolean {
   try {
     process.kill(pid, 0);
   } catch (error) {
@@ -765,6 +770,181 @@ export async function settleExpiredMintQuotes(
   return settlement;
 }
 
+const PENDING_MINT_SWEEP_INTERVAL_MS = 15_000;
+/** Per-quote wait inside a sweep, so one stalled mint cannot starve the rest. */
+const PENDING_MINT_CHECK_TIMEOUT_MS = 10_000;
+const PENDING_MINT_SWEEP_DEADLINE_MS = 30_000;
+const PENDING_MINT_STOP_DRAIN_MS = 10_000;
+
+export interface PendingMintQuoteSource {
+  ops: { mint: Pick<Manager["ops"]["mint"], "listPending" | "refresh" | "get"> };
+  wallet: { balances: Pick<Manager["wallet"]["balances"], "byMint"> };
+  mintOperationService: Pick<MintOperationServiceCleanup, "failPendingOperation">;
+}
+
+export interface PendingMintSweepState {
+  /** Refreshes that outlived their wait; skipped until they settle. */
+  outstanding: Map<string, Promise<unknown>>;
+  /** Next sweep starts after this operation. */
+  after?: string;
+}
+
+export interface PendingMintSweepOptions {
+  deadlineMs?: number;
+  checkTimeoutMs?: number;
+  state?: PendingMintSweepState;
+}
+
+type PendingMintOutcome = "unreachable" | "other";
+type PendingMintOp = Awaited<ReturnType<PendingMintQuoteSource["ops"]["mint"]["listPending"]>>[number];
+
+/** Startup mint recovery, run while up: coco's live subscriptions can stop. */
+export async function settlePendingMintQuotes(
+  source: PendingMintQuoteSource,
+  nowMs: number,
+  options: PendingMintSweepOptions = {},
+): Promise<{ unreachable: number }> {
+  const deadlineMs = options.deadlineMs ?? PENDING_MINT_SWEEP_DEADLINE_MS;
+  const checkTimeoutMs = options.checkTimeoutMs ?? PENDING_MINT_CHECK_TIMEOUT_MS;
+  const state: PendingMintSweepState = options.state ?? { outstanding: new Map() };
+  let unreachable = 0;
+
+  const pending = await source.ops.mint.listPending();
+  const resumeAt = pending.findIndex((op) => op.id === state.after) + 1;
+  const ordered = [...pending.slice(resumeAt), ...pending.slice(0, resumeAt)];
+  const startedAt = Date.now();
+  for (const op of ordered) {
+    const remainingMs = deadlineMs - (Date.now() - startedAt);
+    if (state.outstanding.has(op.id) || remainingMs <= 0) {
+      unreachable++;
+      continue;
+    }
+    state.after = op.id;
+    // Report on the refresh itself so a late result is still logged.
+    const settled = source.ops.mint
+      .refresh(op.id)
+      .then(
+        (result) => reportPendingMintRefresh(source, op, result, nowMs),
+        (error) => reportPendingMintRefreshError(source, op, error),
+      )
+      .finally(() => state.outstanding.delete(op.id));
+    state.outstanding.set(op.id, settled);
+    try {
+      const outcome = await withTimeout(settled, Math.min(checkTimeoutMs, remainingMs));
+      if (outcome === "unreachable") unreachable++;
+    } catch {
+      unreachable++;
+    }
+  }
+  return { unreachable };
+}
+
+async function reportPendingMintRefresh(
+  source: PendingMintQuoteSource,
+  op: PendingMintOp,
+  result: Awaited<ReturnType<PendingMintQuoteSource["ops"]["mint"]["refresh"]>>,
+  nowMs: number,
+): Promise<PendingMintOutcome> {
+  const quote = `Mint quote ${op.quoteId} at ${op.mintUrl}`;
+  if (result.state === "finalized") {
+    if (result.error) {
+      // Already issued, proofs not restored: not a credit.
+      logger.warn(`${quote}: ${result.error}`);
+      return "other";
+    }
+    const balance = (await source.wallet.balances.byMint())[op.mintUrl]?.spendable;
+    logger.log(
+      `${quote}: paid, ${op.amount} sat minted` +
+        (balance === undefined ? "" : `, balance now ${balance} sat`),
+    );
+    return "other";
+  }
+  if (result.state === "failed") {
+    logger.warn(`${quote}: failed at the mint: ${result.error ?? "unknown reason"}`);
+    return "other";
+  }
+  // Paid-before-expiry is only known to the mint, so expired quotes are
+  // checked too; confirmed UNPAID after expiry is failed locally, as at startup.
+  const expired = op.expiry > 0 && op.expiry * 1000 <= nowMs;
+  if (expired && result.state === "pending" && result.lastObservedRemoteState === "UNPAID") {
+    await source.mintOperationService.failPendingOperation(
+      { id: op.id },
+      {
+        reason: "Expired mint quote confirmed unpaid by mint",
+        retryable: false,
+        observedAt: Date.now(),
+      },
+    );
+  }
+  return "other";
+}
+
+async function reportPendingMintRefreshError(
+  source: PendingMintQuoteSource,
+  op: PendingMintOp,
+  error: unknown,
+): Promise<PendingMintOutcome> {
+  // coco's own watcher is minting this quote right now; let it finish.
+  if (error instanceof OperationInProgressError) return "other";
+  // A failed mint attempt rejects after coco moved the operation back to pending.
+  const current = await source.ops.mint.get(op.id);
+  if (current?.state === "pending" && current.lastObservedRemoteState === "PAID") {
+    if (op.lastObservedRemoteState !== "PAID" || current.error !== op.error) {
+      logger.warn(
+        `Mint quote ${op.quoteId} at ${op.mintUrl}: paid (${op.amount} sat) but proofs not minted yet: ${current.error ?? String(error)}; will retry`,
+      );
+    }
+    return "other";
+  }
+  return "unreachable";
+}
+
+/**
+ * Stopping waits for the running sweep, then briefly for stragglers. Anything
+ * still running after that fails against the closed database and is picked
+ * up by startup recovery.
+ */
+function startPendingMintSweep(source: PendingMintQuoteSource): () => Promise<void> {
+  let stopped = false;
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  let inFlight: Promise<void> = Promise.resolve();
+  let unreachableBefore = 0;
+  const state: PendingMintSweepState = { outstanding: new Map() };
+
+  const tick = async () => {
+    if (stopped) return;
+    inFlight = settlePendingMintQuotes(source, Date.now(), { state }).then(
+      ({ unreachable }) => {
+        // Report a mint becoming unreachable, or reachable again, once.
+        if (unreachable > 0 && unreachableBefore === 0) {
+          logger.warn(`Could not check ${unreachable} pending mint quote(s); will keep retrying`);
+        } else if (unreachable === 0 && unreachableBefore > 0) {
+          logger.log("Pending mint quote checks are reaching the mint again");
+        }
+        unreachableBefore = unreachable;
+      },
+      (error: unknown) => {
+        logger.warn(
+          `Pending mint quote sweep failed: ${error instanceof Error ? error.message : String(error)}`,
+        );
+      },
+    );
+    await inFlight;
+    if (!stopped) timer = setTimeout(tick, PENDING_MINT_SWEEP_INTERVAL_MS);
+  };
+  timer = setTimeout(tick, PENDING_MINT_SWEEP_INTERVAL_MS);
+
+  return async () => {
+    stopped = true;
+    if (timer !== undefined) clearTimeout(timer);
+    await inFlight;
+    await withTimeout(
+      Promise.allSettled(state.outstanding.values()),
+      PENDING_MINT_STOP_DRAIN_MS,
+    ).catch(() => {});
+  };
+}
+
 interface ReceiveRecoveryInternals {
   receiveOperationService: {
     checkProofStatesWithMint(
@@ -972,6 +1152,7 @@ export async function createCocoClient(
     pendingMints: 0,
   };
   let recoveryResolve: (() => void) | undefined;
+  let stopPendingMintSweep: (() => Promise<void>) | undefined;
   const recoveryPromise = new Promise<void>((resolve) => {
     recoveryResolve = resolve;
   });
@@ -1166,6 +1347,13 @@ export async function createCocoClient(
         recoveryPhase = "done";
         recoveryResolve?.();
         startupProgress("Wallet recovery complete.");
+        stopPendingMintSweep = startPendingMintSweep({
+          ops: coco!.ops,
+          wallet: coco!.wallet,
+          mintOperationService: (
+            coco as unknown as { mintOperationService: MintOperationServiceCleanup }
+          ).mintOperationService,
+        });
       })
       .catch((error) => {
         recoveryDone = true;
@@ -1383,7 +1571,7 @@ export async function createCocoClient(
       }
     },
 
-    async receiveBolt11(amount: number, mintUrl?: string): Promise<string> {
+    async receiveBolt11(amount: number, mintUrl?: string) {
       await waitForRecovery();
       const targetMint = mintUrl
         ? normalizeMintUrl(mintUrl)
@@ -1399,7 +1587,20 @@ export async function createCocoClient(
       if (!("request" in op)) {
         throw new Error("mint prepare did not return a payment request");
       }
-      return op.request as string;
+      return { invoice: op.request as string, operationId: op.id };
+    },
+
+    async getMintQuote(operationId: string) {
+      const op = await coco.ops.mint.get(operationId);
+      if (!op || op.state === "init") return null;
+      return {
+        operationId: op.id,
+        state: op.state,
+        mintState: op.lastObservedRemoteState,
+        amount: op.amount,
+        mintUrl: op.mintUrl,
+        error: op.error,
+      };
     },
 
     async sendCashu(amount: number, mintUrl?: string): Promise<string> {
@@ -1475,6 +1676,7 @@ export async function createCocoClient(
         // Let any in-flight recovery settle before closing the database from
         // underneath it. The recovery promise resolves on success or failure.
         await recoveryPromise;
+        await stopPendingMintSweep?.();
         await coco.dispose();
       } finally {
         try {

package/src/daemon/wallet/cocod-client.ts

@@ -109,13 +109,29 @@ export class CocodHttpError extends Error {
   }
 }
 
+/** Progress of a Lightning top-up created with `receiveBolt11`. */
+export interface MintQuoteStatus {
+  operationId: string;
+  state: "pending" | "executing" | "finalized" | "failed";
+  /** Last quote state reported by the mint (UNPAID, PAID, ISSUED). */
+  mintState?: string;
+  amount: number;
+  mintUrl: string;
+  error?: string;
+}
+
 export interface CocodClient {
   ping(): Promise<boolean>;
   getStatus(): Promise<CocodState>;
   unlock(passphrase: string): Promise<string>;
   getBalances(): Promise<Record<string, number>>;
   receiveCashu(token: string): Promise<string>;
-  receiveBolt11(amount: number, mintUrl?: string): Promise<string>;
+  receiveBolt11(
+    amount: number,
+    mintUrl?: string,
+  ): Promise<{ invoice: string; operationId?: string }>;
+  /** Progress of a top-up, when the wallet tracks mint operations. */
+  getMintQuote?(operationId: string): Promise<MintQuoteStatus | null>;
   sendCashu(amount: number, mintUrl?: string): Promise<string>;
   sendBolt11(invoice: string, mintUrl?: string): Promise<string>;
   listMints(): Promise<string[]>;
@@ -421,8 +437,8 @@ export function createCocodClient(
       logger.debug(`[receiveCashu] Full response.output:`, message);
       return message;
     },
-    async receiveBolt11(amount: number, mintUrl?: string): Promise<string> {
-      return post<string>("/receive/bolt11", { amount, mintUrl });
+    async receiveBolt11(amount: number, mintUrl?: string) {
+      return { invoice: await post<string>("/receive/bolt11", { amount, mintUrl }) };
     },
     async sendCashu(amount: number, mintUrl?: string): Promise<string> {
       return post<string>("/send/cashu", { amount, mintUrl });

package/src/daemon/wallet/index.ts

@@ -189,7 +189,7 @@ export async function createWalletAdapter(
 
         // 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);
+        const { invoice } = await client.receiveBolt11(amount, mintUrl);
         logger.log(`[nwc]   Invoice: ${invoice}`);
 
         // Step 3: Pay it via NWC

package/src/index.ts

@@ -1,4 +1,12 @@
 #!/usr/bin/env bun
 import { cli } from "./cli";
 
-cli(process.argv);
+try {
+  await cli(process.argv);
+} catch (error) {
+  console.error(
+    "routstrd command failed:",
+    error instanceof Error ? error.message : error,
+  );
+  process.exit(1);
+}

package/src/runtime.ts

@@ -0,0 +1,55 @@
+export const DAEMON_COMMAND = "daemon";
+
+type BunRuntime = {
+  isStandaloneExecutable?: boolean;
+  main: string;
+};
+
+export function isStandaloneExecutable(
+  runtime: BunRuntime = Bun as unknown as BunRuntime,
+): boolean {
+  return (
+    runtime.isStandaloneExecutable === true ||
+    runtime.main.startsWith("/$bunfs/")
+  );
+}
+
+type RuntimeExecutable = {
+  standalone: boolean;
+  execPath: string;
+  main: string;
+};
+
+export function daemonSpawnCommand(
+  args: string[],
+  runtime: RuntimeExecutable = {
+    standalone: isStandaloneExecutable(),
+    execPath: process.execPath,
+    main: Bun.main,
+  },
+): string[] {
+  return runtime.standalone
+    ? [runtime.execPath, DAEMON_COMMAND, ...args]
+    : [runtime.execPath, runtime.main, DAEMON_COMMAND, ...args];
+}
+
+export function pm2DaemonArgs(
+  runtime: RuntimeExecutable = {
+    standalone: isStandaloneExecutable(),
+    execPath: process.execPath,
+    main: Bun.main,
+  },
+): string[] {
+  const entrypoint = runtime.standalone ? runtime.execPath : runtime.main;
+  const interpreter = runtime.standalone ? "none" : runtime.execPath;
+  return [
+    "start",
+    entrypoint,
+    "--name",
+    "routstrd",
+    "--interpreter",
+    interpreter,
+    "--",
+    DAEMON_COMMAND,
+  ];
+}

package/src/start-daemon.ts

@@ -9,7 +9,7 @@ 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";
+import { daemonSpawnCommand } from "./runtime";
 
 const DAEMON_STARTUP_LOCK_PATH = `${CONFIG_DIR}/routstrd-startup.lock`;
 const DEBUG_LOG_PATH = `${CONFIG_DIR}/debug.log`;
@@ -88,7 +88,8 @@ function printStartupProgress(offset: number): {
   }
 }
 
-function formatElapsed(elapsedMs: number): string {
+/** Format an elapsed duration as "45s" or "2m 5s". */
+export 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`;
@@ -151,17 +152,12 @@ async function startDaemonUnlocked(
     args.push("--provider", options.provider);
   }
 
-  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(["bun", daemonScript, ...args], {
+  const proc = Bun.spawn(daemonSpawnCommand(args), {
     stdout: debugLogFd,
     stderr: debugLogFd,
     stdin: "ignore",