routstrd 0.3.10 → 0.4.0

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/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/coco-client.npc.test.ts

@@ -0,0 +1,252 @@
+import { afterEach, describe, expect, it, mock } from "bun:test";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { join } from "path";
+
+// The real NPCPlugin opens a websocket to npubx.cash once the wallet is ready.
+// Mock the module before importing coco-client so tests never touch the network.
+const npcState = {
+  info: { name: "alice" as string | null, pubkey: "ab".repeat(32) },
+  usernameResult: { success: true } as
+    | { success: true }
+    | { success: false; pr: { amount: number; mints: string[] } },
+  setUsernameCalls: [] as Array<{ username: string; attemptPayment?: boolean }>,
+  syncCalls: 0,
+};
+
+class MockNPCPlugin {
+  readonly name = "npc";
+  readonly required = [] as const;
+  private readonly api = {
+    getInfo: async () => npcState.info,
+    setUsername: async (username: string, attemptPayment?: boolean) => {
+      npcState.setUsernameCalls.push({ username, attemptPayment });
+      return npcState.usernameResult;
+    },
+    sync: async () => {
+      npcState.syncCalls += 1;
+    },
+  };
+
+  onInit(ctx: { registerExtension: (key: string, api: unknown) => void }) {
+    ctx.registerExtension("npc", this.api);
+    return () => {};
+  }
+}
+
+mock.module("coco-cashu-plugin-npc", () => ({
+  NPCPlugin: MockNPCPlugin,
+}));
+
+const { createCocoClient } = await import("./coco-client");
+const { createCocodClient, CocodHttpError } = await import("./cocod-client");
+
+const TEST_MNEMONIC =
+  "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about";
+
+const tempDirs: string[] = [];
+
+function makeWalletDir(): string {
+  const dir = mkdtempSync(join(tmpdir(), "routstrd-coco-npc-test-"));
+  tempDirs.push(dir);
+  const walletDir = join(dir, "wallet");
+  mkdirSync(walletDir, { recursive: true });
+  writeFileSync(
+    join(walletDir, "config.json"),
+    JSON.stringify({ version: 1, mnemonic: TEST_MNEMONIC, encrypted: false }),
+  );
+  return walletDir;
+}
+
+function testClientOptions(walletDir = makeWalletDir()) {
+  return {
+    walletDir,
+    legacySocketPath: join(walletDir, "legacy-cocod.sock"),
+    legacyPidPath: join(walletDir, "legacy-cocod.pid"),
+  };
+}
+
+function resetNpcState(): void {
+  npcState.info = { name: "alice", pubkey: "ab".repeat(32) };
+  npcState.usernameResult = { success: true };
+  npcState.setUsernameCalls = [];
+  npcState.syncCalls = 0;
+}
+
+afterEach(() => {
+  resetNpcState();
+  for (const dir of tempDirs.splice(0)) {
+    rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+describe("in-process coco client NPC integration", () => {
+  it("registers the plugin and exposes the wallet's NPC lightning address", async () => {
+    const client = await createCocoClient(testClientOptions());
+    try {
+      const info = await client.getNpcAddress();
+      expect(info).toEqual({
+        address: "alice@npubx.cash",
+        name: "alice",
+        pubkey: "ab".repeat(32),
+      });
+    } finally {
+      await client.dispose?.();
+    }
+  });
+
+  it("falls back to the npub address when no username is set", async () => {
+    npcState.info = { name: null, pubkey: "ab".repeat(32) };
+    const client = await createCocoClient(testClientOptions());
+    try {
+      const info = await client.getNpcAddress();
+      expect(info.address).toStartWith("npub1");
+      expect(info.address).toEndWith("@npubx.cash");
+      expect(info.name).toBeUndefined();
+      expect(info.pubkey).toBe("ab".repeat(32));
+    } finally {
+      await client.dispose?.();
+    }
+  });
+
+  it("maps payment-required username claims without paying", async () => {
+    npcState.usernameResult = {
+      success: false,
+      pr: { amount: 21, mints: ["https://mint.example.com"] },
+    };
+    const client = await createCocoClient(testClientOptions());
+    try {
+      const result = await client.setNpcUsername("bob");
+      expect(result).toEqual({
+        success: false,
+        paymentRequest: { amount: 21, mints: ["https://mint.example.com"] },
+      });
+      expect(npcState.setUsernameCalls).toEqual([
+        { username: "bob", attemptPayment: false },
+      ]);
+    } finally {
+      await client.dispose?.();
+    }
+  });
+
+  it("confirms the claim fee payment when requested", async () => {
+    const client = await createCocoClient(testClientOptions());
+    try {
+      const result = await client.setNpcUsername("bob", true);
+      expect(result).toEqual({ success: true });
+      expect(npcState.setUsernameCalls).toEqual([
+        { username: "bob", attemptPayment: true },
+      ]);
+    } finally {
+      await client.dispose?.();
+    }
+  });
+
+  it("triggers a manual quote sync", async () => {
+    const client = await createCocoClient(testClientOptions());
+    try {
+      await client.syncNpc();
+      expect(npcState.syncCalls).toBe(1);
+    } finally {
+      await client.dispose?.();
+    }
+  });
+
+  it("rejects NPC calls with a clear error when the plugin is disabled", async () => {
+    const client = await createCocoClient({
+      ...testClientOptions(),
+      enableNpc: false,
+    });
+    try {
+      await expect(client.getNpcAddress()).rejects.toThrow(
+        "NPC plugin is not enabled",
+      );
+      await expect(client.syncNpc()).rejects.toThrow(
+        "NPC plugin is not enabled",
+      );
+    } finally {
+      await client.dispose?.();
+    }
+  });
+});
+
+describe("legacy cocod client NPC passthroughs", () => {
+  type FetchImpl = (
+    input: string | URL | Request,
+    init?: RequestInit & { unix: string },
+  ) => Promise<Response>;
+
+  function legacyClient(handler: (path: string, body?: unknown) => Response) {
+    const requests: Array<{ path: string; body?: unknown }> = [];
+    const fetchImpl: FetchImpl = async (input, init) => {
+      const path = String(input).replace("http://localhost", "");
+      const body =
+        typeof init?.body === "string" ? JSON.parse(init.body) : undefined;
+      if (path !== "/ping") requests.push({ path, body });
+      if (path === "/ping") {
+        return new Response(JSON.stringify({ output: "pong" }));
+      }
+      return handler(path, body);
+    };
+    const client = createCocodClient({
+      socketPath: "/tmp/routstrd-test-legacy-npc/cocod.sock",
+      fetchImpl,
+    });
+    return { client, requests };
+  }
+
+  it("fetches and parses a username NPC address", async () => {
+    const { client, requests } = legacyClient(
+      () => new Response(JSON.stringify({ output: "alice@npubx.cash" })),
+    );
+    const info = await client.getNpcAddress();
+    expect(info).toEqual({ address: "alice@npubx.cash", name: "alice" });
+    expect(requests[0]?.path).toBe("/npc/address");
+  });
+
+  it("omits the name for npub fallback addresses", async () => {
+    const { client } = legacyClient(
+      () =>
+        new Response(JSON.stringify({ output: "npub1abc123@npubx.cash" })),
+    );
+    const info = await client.getNpcAddress();
+    expect(info).toEqual({ address: "npub1abc123@npubx.cash" });
+  });
+
+  it("posts username claims with the confirm flag", async () => {
+    const { client, requests } = legacyClient(
+      () => new Response(JSON.stringify({ output: { success: true } })),
+    );
+    const result = await client.setNpcUsername("bob", true);
+    expect(result).toEqual({ success: true });
+    expect(requests[0]).toEqual({
+      path: "/npc/username",
+      body: { username: "bob", confirm: true },
+    });
+  });
+
+  it("preserves the 402 payment-required error from cocod", async () => {
+    const { client } = legacyClient(
+      () =>
+        new Response(
+          JSON.stringify({ error: "Payment required to set username" }),
+          { status: 402 },
+        ),
+    );
+    try {
+      await client.setNpcUsername("bob");
+      expect.unreachable("should have thrown");
+    } catch (error) {
+      expect(error).toBeInstanceOf(CocodHttpError);
+      expect((error as InstanceType<typeof CocodHttpError>).status).toBe(402);
+      expect((error as Error).message).toContain("Payment required");
+    }
+  });
+
+  it("reports manual sync as unsupported", async () => {
+    const { client } = legacyClient(
+      () => new Response(JSON.stringify({ output: {} })),
+    );
+    await expect(client.syncNpc()).rejects.toThrow("not supported");
+  });
+});