routstrd 0.3.11 → 0.4.1

package/src/daemon/args.ts

@@ -1,8 +1,10 @@
 export function parseArgs(argv: string[]): {
   port: number;
+  host: string | null;
   provider: string | null;
 } {
   const portFlagIndex = argv.findIndex((arg) => arg === "--port");
+  const hostFlagIndex = argv.findIndex((arg) => arg === "--host");
   const providerFlagIndex = argv.findIndex(
     (arg) => arg === "--provider" || arg === "-p",
   );
@@ -11,9 +13,14 @@ export function parseArgs(argv: string[]): {
     portFlagIndex !== -1
       ? Number.parseInt(argv[portFlagIndex + 1] || "8008", 10)
       : 8008;
+
+  const hostValue =
+    hostFlagIndex !== -1 ? argv[hostFlagIndex + 1] : undefined;
+  const host = hostValue?.trim() || null;
+
   const providerValue =
     providerFlagIndex !== -1 ? argv[providerFlagIndex + 1] : undefined;
   const provider = providerValue ? providerValue.trim() : null;
 
-  return { port, provider };
+  return { port, host, provider };
 }

package/src/daemon/fatal-error.test.ts

@@ -0,0 +1,104 @@
+import { afterEach, describe, expect, test } from "bun:test";
+import { unlinkSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+import { exitOnUncaughtException } from "./fatal-error";
+
+const fatalErrorModule = JSON.stringify(join(import.meta.dir, "fatal-error.ts"));
+
+const fixturePaths: string[] = [];
+
+afterEach(() => {
+  while (fixturePaths.length > 0) {
+    try {
+      unlinkSync(fixturePaths.pop()!);
+    } catch {
+      // Best effort cleanup of temp fixtures.
+    }
+  }
+});
+
+/** Run a fixture script in a real subprocess so process.exit is for real. */
+async function runFixture(source: string): Promise<{
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+}> {
+  const scriptPath = join(
+    tmpdir(),
+    `routstrd-fatal-error-fixture-${crypto.randomUUID()}.ts`,
+  );
+  fixturePaths.push(scriptPath);
+  await Bun.write(scriptPath, source);
+  const proc = Bun.spawn(["bun", scriptPath], {
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const [stdout, stderr] = await Promise.all([
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+  ]);
+  const exitCode = await proc.exited;
+  return { exitCode, stdout, stderr };
+}
+
+describe("exitOnUncaughtException", () => {
+  test("reports the error and exits with code 1", () => {
+    let exitCode: number | undefined;
+    const stderrLines: string[] = [];
+    const originalConsoleError = console.error;
+    console.error = (...args: unknown[]) => {
+      stderrLines.push(args.map(String).join(" "));
+    };
+    try {
+      exitOnUncaughtException(new Error("boom"), (code) => {
+        exitCode = code;
+      });
+    } finally {
+      console.error = originalConsoleError;
+    }
+    expect(exitCode).toBe(1);
+    expect(stderrLines.join("\n")).toContain("boom");
+  });
+
+  test("handles non-Error thrown values", () => {
+    let exitCode: number | undefined;
+    const originalConsoleError = console.error;
+    console.error = () => {};
+    try {
+      exitOnUncaughtException("string failure", (code) => {
+        exitCode = code;
+      });
+    } finally {
+      console.error = originalConsoleError;
+    }
+    expect(exitCode).toBe(1);
+  });
+});
+
+describe("installGlobalErrorHandlers (subprocess)", () => {
+  test("an uncaught exception exits the process with code 1", async () => {
+    const { exitCode, stderr } = await runFixture(`
+      import { installGlobalErrorHandlers } from ${fatalErrorModule};
+      installGlobalErrorHandlers();
+      setTimeout(() => {
+        throw new Error("boom-uncaught");
+      }, 10);
+    `);
+    expect(exitCode).toBe(1);
+    expect(stderr).toContain("boom-uncaught");
+  });
+
+  test("an unhandled rejection is logged without exiting", async () => {
+    const { exitCode, stdout } = await runFixture(`
+      import { installGlobalErrorHandlers } from ${fatalErrorModule};
+      installGlobalErrorHandlers();
+      Promise.reject(new Error("boom-rejection"));
+      setTimeout(() => {
+        console.log("STILL-ALIVE");
+      }, 50);
+    `);
+    expect(exitCode).toBe(0);
+    expect(stdout).toContain("STILL-ALIVE");
+  });
+});

package/src/daemon/fatal-error.ts

@@ -0,0 +1,48 @@
+import { logger } from "../utils/logger";
+
+/**
+ * Report an unrecoverable error, then exit.
+ *
+ * The daemon runs detached under a supervisor (pm2 via `routstrd service
+ * install`, or the spawning CLI). An uncaught exception means the call stack
+ * unwound unexpectedly mid-operation and process state can no longer be
+ * trusted. Swallowing it once left a daemon alive with nothing listening
+ * while it held both wallet PID locks, so every later start failed on the
+ * lock and liveness-only supervisors never restarted it. Exiting lets the
+ * supervisor bring up a healthy process instead.
+ *
+ * The file logger writes synchronously, so the record survives the exit.
+ * The error is mirrored to stderr because the daemon's stdout/stderr are
+ * redirected to debug.log, which is what the CLI surfaces when the daemon
+ * exits early and what pm2 captures. process.exit() runs the synchronous
+ * PID-lock exit hooks registered by claimPidFile, releasing the wallet
+ * locks on the way out.
+ *
+ * `exit` is injectable for tests.
+ */
+export function exitOnUncaughtException(
+  error: unknown,
+  exit: (code: number) => void = (code) => process.exit(code),
+): void {
+  logger.error("UNCAUGHT EXCEPTION:", error);
+  // Full error object (not just .message): this path means a bug, so the
+  // stack is the most useful thing to have in debug.log.
+  console.error("UNCAUGHT EXCEPTION:", error);
+  exit(1);
+}
+
+/**
+ * Install the process-level error handlers. Called once at daemon module
+ * load, before main() runs.
+ *
+ * Only uncaught exceptions are fatal. An unhandled rejection means a
+ * promise's failure went unobserved; the stack was not unwound and the
+ * process is still in a consistent state, so it is logged and the daemon
+ * keeps serving.
+ */
+export function installGlobalErrorHandlers(): void {
+  process.on("uncaughtException", (error) => exitOnUncaughtException(error));
+  process.on("unhandledRejection", (reason) => {
+    logger.error("UNHANDLED REJECTION:", reason);
+  });
+}

package/src/daemon/models.ts

@@ -1,9 +1,10 @@
-import { ModelManager, type SdkStore } from "@routstr/sdk";
+import { ModelManager, ProviderManager, type SdkStore } from "@routstr/sdk";
 import type { ExposedModel } from "./types";
 import { logger } from "../utils/logger";
 
 export type ModelProviderInfo = {
   baseUrl: string;
+  disabled: boolean;
   pricing: {
     prompt: number;
     completion: number;
@@ -16,16 +17,75 @@ export type ModelWithProviders = ExposedModel & {
   providers: ModelProviderInfo[];
 };
 
-export function createModelService(modelManager: ModelManager, store: SdkStore) {
+export function createModelService(
+  modelManager: ModelManager,
+  providerManager: ProviderManager,
+  store: SdkStore,
+) {
   let providerBootstrapPromise: Promise<void> | null = null;
 
+  const normalizeBaseUrl = (url: string): string =>
+    url.endsWith("/") ? url : `${url}/`;
+
+  /**
+   * Build the same cheapest-per-model view as ModelManager.fetchModels, but
+   * exclusively from the persisted cache. Model-list reads must not wait for
+   * unavailable providers; explicit and scheduled refreshes own network I/O.
+   */
+  const getCachedModels = (): ExposedModel[] => {
+    type PricedModel = ExposedModel & {
+      sats_pricing?: { completion?: number };
+    };
+
+    const cachedByProvider = modelManager.getAllCachedModels();
+    const currentProviders = new Set(
+      modelManager.getBaseUrls().map(normalizeBaseUrl),
+    );
+    const s = store.getState();
+    const manuallyEnabled = new Set(
+      (s.manuallyEnabledProviders || []).map(normalizeBaseUrl),
+    );
+    const disabledProviders = new Set(
+      [
+        ...(s.disabledProviders || []),
+        ...(s.manuallyDisabledProviders || []),
+      ]
+        .map(normalizeBaseUrl)
+        .filter((url) => !manuallyEnabled.has(url)),
+    );
+    const bestById = new Map<string, PricedModel>();
+
+    for (const [baseUrl, models] of Object.entries(cachedByProvider)) {
+      const normalized = normalizeBaseUrl(baseUrl);
+      if (
+        disabledProviders.has(normalized) ||
+        (currentProviders.size > 0 && !currentProviders.has(normalized))
+      ) {
+        continue;
+      }
+
+      for (const model of models as PricedModel[]) {
+        if (!model.sats_pricing) continue;
+        const existing = bestById.get(model.id);
+        if (
+          !existing ||
+          (model.sats_pricing.completion ?? 0) <
+            (existing.sats_pricing?.completion ?? 0)
+        ) {
+          bestById.set(model.id, model);
+        }
+      }
+    }
+
+    return [...bestById.values()];
+  };
+
   const ensureProvidersBootstrapped = (): Promise<void> => {
     if (!providerBootstrapPromise) {
       providerBootstrapPromise = (async () => {
         logger.log("Bootstrapping providers...");
         const providers = await modelManager.bootstrapProviders(false);
         logger.log(`Bootstrapped ${providers.length} providers`);
-        await modelManager.fetchModels(providers);
 
         // Sync discovered providers into the store so `providers list` reflects
         // the same set that the model manager knows about.
@@ -44,6 +104,7 @@ export function createModelService(modelManager: ModelManager, store: SdkStore)
 
         logger.log("Provider bootstrap complete.");
       })().catch((error) => {
+        providerBootstrapPromise = null;
         logger.error("Provider bootstrap failed:", error);
         throw error;
       });
@@ -54,16 +115,27 @@ export function createModelService(modelManager: ModelManager, store: SdkStore)
   const getRoutstr21Models = async (
     forceRefresh = false,
   ): Promise<ExposedModel[]> => {
-    await ensureProvidersBootstrapped();
-
     const routstr21ModelIds = Array.from(
       new Set(await modelManager.fetchRoutstr21Models(forceRefresh)),
     ).slice(0, 21);
-    const baseUrls = modelManager.getBaseUrls();
-    const discoveredModels = await modelManager.fetchModels(
-      baseUrls,
-      forceRefresh,
-    );
+
+    let discoveredModels: ExposedModel[];
+    if (!forceRefresh) {
+      discoveredModels = getCachedModels();
+    } else {
+      discoveredModels = [];
+    }
+
+    // Warm reads are cache-only. A cold start and explicit refresh still
+    // populate models from the provider network.
+    if (forceRefresh || discoveredModels.length === 0) {
+      await ensureProvidersBootstrapped();
+      discoveredModels = await modelManager.fetchModels(
+        modelManager.getBaseUrls(),
+        forceRefresh,
+      );
+    }
+
     const modelsById = new Map(discoveredModels.map((model) => [model.id, model]));
 
     return routstr21ModelIds.map((modelId) => {
@@ -77,33 +149,42 @@ export function createModelService(modelManager: ModelManager, store: SdkStore)
   ): Promise<ModelWithProviders | null> => {
     await ensureProvidersBootstrapped();
 
-    const allModels = modelManager.getAllCachedModels();
-    const providers: ModelProviderInfo[] = [];
-
-    for (const [baseUrl, models] of Object.entries(allModels)) {
-      const model = models.find((m) => m.id === modelId);
-      if (model && model.sats_pricing) {
-        providers.push({
-          baseUrl,
-          pricing: {
-            prompt: model.sats_pricing.prompt,
-            completion: model.sats_pricing.completion,
-            request: model.sats_pricing.request,
-            max_cost: model.sats_pricing.max_cost,
-          },
-        });
-      }
-    }
+    const s = store.getState();
+    const manuallyEnabled = new Set<string>(
+      (s.manuallyEnabledProviders || []).map(normalizeBaseUrl),
+    );
+    const disabledSet = new Set<string>(
+      [
+        ...(s.disabledProviders || []),
+        ...(s.manuallyDisabledProviders || []),
+      ].filter((url) => !manuallyEnabled.has(normalizeBaseUrl(url))),
+    );
+
+    // Use the SDK ranking (sorted by prompt+completion per million tokens)
+    // so the display order matches real routing. includeDisabled keeps
+    // disabled providers visible so we can annotate them.
+    const ranking = providerManager.getProviderPriceRankingForModel(modelId, {
+      includeDisabled: true,
+    });
 
-    // Sort by max_cost (cheapest first)
-    providers.sort((a, b) => a.pricing.max_cost - b.pricing.max_cost);
+    const providers: ModelProviderInfo[] = ranking.map((entry: any) => ({
+      baseUrl: entry.baseUrl,
+      disabled: disabledSet.has(entry.baseUrl),
+      pricing: {
+        prompt: entry.promptPerMillion / 1_000_000,
+        completion: entry.completionPerMillion / 1_000_000,
+        request: entry.model.sats_pricing?.request ?? 0,
+        max_cost: entry.model.sats_pricing?.max_cost ?? 0,
+      },
+    }));
 
     if (providers.length === 0) {
       return null;
     }
 
-    // Get model metadata from first provider that has it
+    // Get model metadata from first (cheapest) provider
     const cheapest = providers[0]!;
+    const allModels = modelManager.getAllCachedModels();
     const firstProvider = allModels[cheapest.baseUrl];
     const modelInfo = firstProvider?.find((m: { id: string }) => m.id === modelId);
 
@@ -149,28 +230,27 @@ export function createModelService(modelManager: ModelManager, store: SdkStore)
       undefined,
       true,
     );
-    if (reviewedDisabled.length > 0) {
+    if (reviewedDisabled && reviewedDisabled.length > 0) {
       console.log(
         `Review sync disabled ${reviewedDisabled.length} provider(s): ${reviewedDisabled.join(", ")}`,
       );
     }
 
     // Sync discovered providers into the store
-    const { baseUrlsList, setBaseUrlsList, disabledProviders, setDisabledProviders } =
-      store.getState() as any;
+    const { setBaseUrlsList, setDisabledProviders } = store.getState() as any;
 
     // Replace baseUrlsList with the fresh provider list
     setBaseUrlsList(providers);
 
-    // Merge review-disabled providers into the store's disabled list
-    const existingDisabled = new Set(disabledProviders || []);
-    for (const url of reviewedDisabled) {
-      existingDisabled.add(url);
+    // Mirror the review-disabled set into the store's auto-disabled list.
+    // `null` means the review sync left the adapter unchanged (e.g. no lgtm
+    // reviews found), so we must not clobber the store list with an empty array.
+    if (reviewedDisabled !== null) {
+      setDisabledProviders(reviewedDisabled);
     }
-    setDisabledProviders([...existingDisabled]);
 
     console.log(
-      `Provider refresh complete: ${providers.length} total, ${existingDisabled.size} disabled`,
+      `Provider refresh complete: ${providers.length} total, ${reviewedDisabled?.length ?? store.getState().disabledProviders?.length ?? 0} review-disabled`,
     );
   };
 

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

@@ -66,8 +66,6 @@ export function startAutoRefillLoop(
       return;
     }
 
-    checkInProgress = true;
-
     // If we've been failing too much, back off rather than retrying at full speed.
     // This prevents tight loops on transient errors.
     const backoffInterval = Math.min(
@@ -78,6 +76,8 @@ export function startAutoRefillLoop(
       return;
     }
 
+    checkInProgress = true;
+
     try {
       const balances = await cocod.getBalances();
       const totalBalance = Object.values(balances).reduce<number>(
@@ -94,11 +94,9 @@ export function startAutoRefillLoop(
         `[auto-refill] Balance ${totalBalance} sats < threshold ${config.threshold}. Refilling ${config.amount} sats...`,
       );
 
-      // Get active mint
-      const mints = await cocod.listMints();
-      const mintUrl = mints[0];
+      const mintUrl = await cocod.getDefaultMint();
       if (!mintUrl) {
-        logger.error("[auto-refill] No active mint configured");
+        logger.error("[auto-refill] No default mint configured");
         return;
       }
 

package/src/daemon/wallet/cleanup.test.ts

@@ -0,0 +1,168 @@
+import { describe, expect, it } from "bun:test";
+import { selectCleanupOperations } from "./cleanup";
+
+const NOW_MS = 1_800_000_000_000;
+const DAY_MS = 24 * 60 * 60 * 1000;
+
+function mint(overrides: Record<string, unknown>) {
+  return {
+    id: "mint-1",
+    state: "pending",
+    expiry: NOW_MS / 1000 - 1000, // expired
+    updatedAt: NOW_MS - 2 * DAY_MS,
+    lastObservedRemoteState: undefined,
+    ...overrides,
+  };
+}
+
+function send(overrides: Record<string, unknown>) {
+  return {
+    id: "send-1",
+    state: "pending",
+    updatedAt: NOW_MS - 2 * DAY_MS,
+    ...overrides,
+  };
+}
+
+function melt(overrides: Record<string, unknown>) {
+  return {
+    id: "melt-1",
+    state: "prepared",
+    updatedAt: NOW_MS - 2 * DAY_MS,
+    ...overrides,
+  };
+}
+
+describe("selectCleanupOperations", () => {
+  it("selects expired pending mint quotes that are old enough", () => {
+    const result = selectCleanupOperations({
+      mints: [mint({ id: "a" })],
+      sends: [],
+      melts: [],
+      nowMs: NOW_MS,
+      minAgeMs: DAY_MS,
+    });
+
+    expect(result.mintsToFail.map((op) => op.id)).toEqual(["a"]);
+  });
+
+  it("ignores mint quotes that have not expired", () => {
+    const result = selectCleanupOperations({
+      mints: [mint({ id: "a", expiry: NOW_MS / 1000 + 1000 })],
+      sends: [],
+      melts: [],
+      nowMs: NOW_MS,
+      minAgeMs: DAY_MS,
+    });
+
+    expect(result.mintsToFail).toEqual([]);
+  });
+
+  it("ignores expired mint quotes already observed as PAID", () => {
+    const result = selectCleanupOperations({
+      mints: [mint({ id: "a", lastObservedRemoteState: "PAID" })],
+      sends: [],
+      melts: [],
+      nowMs: NOW_MS,
+      minAgeMs: DAY_MS,
+    });
+
+    expect(result.mintsToFail).toEqual([]);
+  });
+
+  it("ignores expired mint quotes already observed as ISSUED", () => {
+    const result = selectCleanupOperations({
+      mints: [mint({ id: "a", lastObservedRemoteState: "ISSUED" })],
+      sends: [],
+      melts: [],
+      nowMs: NOW_MS,
+      minAgeMs: DAY_MS,
+    });
+
+    expect(result.mintsToFail).toEqual([]);
+  });
+
+  it("ignores mint quotes without an expiry", () => {
+    const result = selectCleanupOperations({
+      mints: [mint({ id: "a", expiry: 0 })],
+      sends: [],
+      melts: [],
+      nowMs: NOW_MS,
+      minAgeMs: DAY_MS,
+    });
+
+    expect(result.mintsToFail).toEqual([]);
+  });
+
+  it("selects expired mint quotes even when the watcher recently touched them", () => {
+    const result = selectCleanupOperations({
+      mints: [mint({ id: "a", updatedAt: NOW_MS - 60_000 })],
+      sends: [],
+      melts: [],
+      nowMs: NOW_MS,
+      minAgeMs: DAY_MS,
+    });
+
+    expect(result.mintsToFail.map((op) => op.id)).toEqual(["a"]);
+  });
+
+  it("selects stale pending sends for reclaim", () => {
+    const result = selectCleanupOperations({
+      mints: [],
+      sends: [send({ id: "s" })],
+      melts: [],
+      nowMs: NOW_MS,
+      minAgeMs: DAY_MS,
+    });
+
+    expect(result.sendsToReclaim.map((op) => op.id)).toEqual(["s"]);
+  });
+
+  it("ignores recent pending sends", () => {
+    const result = selectCleanupOperations({
+      mints: [],
+      sends: [send({ id: "s", updatedAt: NOW_MS - 60_000 })],
+      melts: [],
+      nowMs: NOW_MS,
+      minAgeMs: DAY_MS,
+    });
+
+    expect(result.sendsToReclaim).toEqual([]);
+  });
+
+  it("ignores non-pending sends even when old", () => {
+    const result = selectCleanupOperations({
+      mints: [],
+      sends: [send({ id: "s", state: "executing" })],
+      melts: [],
+      nowMs: NOW_MS,
+      minAgeMs: DAY_MS,
+    });
+
+    expect(result.sendsToReclaim).toEqual([]);
+  });
+
+  it("selects stale prepared melts for cancellation", () => {
+    const result = selectCleanupOperations({
+      mints: [],
+      sends: [],
+      melts: [melt({ id: "m" })],
+      nowMs: NOW_MS,
+      minAgeMs: DAY_MS,
+    });
+
+    expect(result.meltsToCancel.map((op) => op.id)).toEqual(["m"]);
+  });
+
+  it("ignores non-prepared melts", () => {
+    const result = selectCleanupOperations({
+      mints: [],
+      sends: [],
+      melts: [melt({ id: "m", state: "pending" })],
+      nowMs: NOW_MS,
+      minAgeMs: DAY_MS,
+    });
+
+    expect(result.meltsToCancel).toEqual([]);
+  });
+});