routstrd 0.3.10 → 0.4.0

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

package/src/utils/update-checker.ts

@@ -0,0 +1,114 @@
+const NPM_REGISTRY = "https://registry.npmjs.org";
+
+/** Packages that `routstrd update` manages. */
+export const UPDATE_PACKAGES = [
+  { name: "routstrd", label: "routstrd" },
+  { name: "@routstr/cocod", label: "cocod" },
+] as const;
+
+/**
+ * Fetch the latest published version of a package from the npm registry.
+ * Returns null if the version cannot be determined (e.g. offline, not found).
+ */
+export async function getLatestNpmVersion(
+  packageName: string,
+): Promise<string | null> {
+  try {
+    const response = await fetch(
+      `${NPM_REGISTRY}/${encodeURIComponent(packageName)}/latest`,
+    );
+    if (!response.ok) return null;
+    const data = (await response.json()) as { version?: string };
+    return data.version ?? null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get the version of a globally-installed bun package.
+ * Returns null when the package is not installed globally or the version
+ * cannot be parsed as semver (e.g. installed from a git URL).
+ */
+export async function getGlobalPackageVersion(
+  packageName: string,
+): Promise<string | null> {
+  try {
+    const proc = Bun.spawn(["bun", "pm", "ls", "-g"], {
+      stdout: "pipe",
+      stderr: "ignore",
+    });
+    const output = await new Response(proc.stdout).text();
+    await proc.exited;
+    // Lines look like:  ├── routstrd@0.3.10   or   └── @routstr/cocod@0.0.24
+    const escaped = packageName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const match = output.match(new RegExp(`${escaped}@([^\\s]+)`));
+    if (!match) return null;
+    const version = match[1];
+    // Reject non-semver versions (e.g. github:routstr/cocod#3f6ac14)
+    if (!version || !/^\d+\.\d+\.\d+/.test(version)) return null;
+    return version;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Compare two semver version strings.
+ * Returns a positive number if `a` is newer, negative if `b` is newer,
+ * 0 if equal, or null if either value is not parseable semver.
+ */
+export function compareVersions(a: string, b: string): number | null {
+  const parse = (v: string): [number, number, number] | null => {
+    const match = v.replace(/^v/, "").match(/^(\d+)\.(\d+)\.(\d+)/);
+    if (!match?.[1] || !match[2] || !match[3]) return null;
+    return [
+      parseInt(match[1], 10),
+      parseInt(match[2], 10),
+      parseInt(match[3], 10),
+    ];
+  };
+  const va = parse(a);
+  const vb = parse(b);
+  if (!va || !vb) return null;
+  const [a1, a2, a3] = va;
+  const [b1, b2, b3] = vb;
+  if (a1 !== b1) return a1 - b1;
+  if (a2 !== b2) return a2 - b2;
+  if (a3 !== b3) return a3 - b3;
+  return 0;
+}
+
+export interface PackageUpdate {
+  name: string;
+  label: string;
+  current: string | null;
+  latest: string | null;
+  hasUpdate: boolean;
+}
+
+export interface UpdateCheckResult {
+  hasUpdate: boolean;
+  packages: PackageUpdate[];
+}
+
+/**
+ * Check both routstrd and cocod for available updates.
+ * Returns a result with per-package details and an overall `hasUpdate` flag.
+ */
+export async function checkForUpdates(): Promise<UpdateCheckResult> {
+  const packages = await Promise.all(
+    UPDATE_PACKAGES.map(async ({ name, label }) => {
+      const [current, latest] = await Promise.all([
+        getGlobalPackageVersion(name),
+        getLatestNpmVersion(name),
+      ]);
+      const hasUpdate = !!(current && latest && (compareVersions(current, latest) ?? -1) < 0);
+      return { name, label, current, latest, hasUpdate } satisfies PackageUpdate;
+    }),
+  );
+  return {
+    hasUpdate: packages.some((p) => p.hasUpdate),
+    packages,
+  };
+}

package/tests/utils/daemon-client.test.ts

@@ -0,0 +1,61 @@
+import { describe, expect, test } from "bun:test";
+import {
+  getDaemonBaseUrl,
+  urlHost,
+  urlHosts,
+} from "../../src/utils/daemon-client";
+import type { RoutstrdConfig } from "../../src/utils/config";
+
+function config(host: string): RoutstrdConfig {
+  return {
+    port: 8008,
+    host,
+    provider: null,
+    cocodPath: null,
+  };
+}
+
+describe("daemon URL host formatting", () => {
+  test("prefers IPv4 loopback for an IPv4 wildcard", () => {
+    expect(urlHosts("0.0.0.0")).toEqual(["127.0.0.1", "[::1]"]);
+    expect(getDaemonBaseUrl(config("0.0.0.0"))).toBe("http://127.0.0.1:8008");
+  });
+
+  test("prefers IPv6 loopback for an IPv6 wildcard", () => {
+    expect(urlHosts("::")).toEqual(["[::1]", "127.0.0.1"]);
+    expect(getDaemonBaseUrl(config("::"))).toBe("http://[::1]:8008");
+  });
+
+  test("brackets IPv6 literals", () => {
+    expect(urlHost("2001:db8::1")).toBe("[2001:db8::1]");
+    expect(getDaemonBaseUrl(config("2001:db8::1"))).toBe(
+      "http://[2001:db8::1]:8008",
+    );
+  });
+
+  test("does not bracket an already-bracketed IPv6 literal twice", () => {
+    expect(urlHost("[::1]")).toBe("[::1]");
+  });
+
+  test("escapes an IPv6 zone identifier for use in a URL", () => {
+    expect(urlHost("fe80::1%en0")).toBe("[fe80::1%25en0]");
+  });
+
+  test("leaves IPv4 addresses and hostnames unchanged", () => {
+    expect(urlHost("127.0.0.1")).toBe("127.0.0.1");
+    expect(urlHost("localhost")).toBe("localhost");
+  });
+
+  test("uses the default loopback when the host is absent", () => {
+    expect(urlHost()).toBe("127.0.0.1");
+  });
+
+  test("preserves an explicitly configured daemon URL", () => {
+    expect(
+      getDaemonBaseUrl({
+        ...config("::"),
+        daemonUrl: "https://daemon.example/",
+      }),
+    ).toBe("https://daemon.example");
+  });
+});

package/tests/wallet/short-keyset-token.test.ts

@@ -0,0 +1,106 @@
+import { describe, expect, it, mock } from "bun:test";
+import {
+  Amount,
+  getDecodedToken,
+  getEncodedToken,
+} from "@cashu/cashu-ts";
+import {
+  createWalletAdapter,
+  decodeCashuTokenAmount,
+} from "../../src/daemon/wallet";
+import type { CocodClient } from "../../src/daemon/wallet/cocod-client";
+
+// A full modern keyset ID with the same format as Minibits' post-migration
+// active keyset. getEncodedToken stores only its first eight bytes in TokenV4.
+const FULL_KEYSET_ID =
+  "01fc0ec0e59cd6fa01b7a88f8cd77fce81fd1e64bca67d752e984992b7a3c3a821";
+const LEGACY_KEYSET_ID = "00107937db0cc865";
+
+function makeToken({
+  amounts = [5],
+  keysetId = FULL_KEYSET_ID,
+  unit = "sat",
+}: {
+  amounts?: number[];
+  keysetId?: string;
+  unit?: string;
+} = {}): string {
+  return getEncodedToken({
+    mint: "https://mint.minibits.cash/Bitcoin",
+    unit,
+    proofs: amounts.map((amount, index) => ({
+      id: keysetId,
+      amount: Amount.from(amount),
+      secret: `short-keyset-regression-fixture-${index}`,
+      C: `02${(index + 1).toString(16).padStart(2, "0").repeat(32)}`,
+    })),
+  });
+}
+
+function makeWalletClient(
+  receiveCashu: CocodClient["receiveCashu"],
+): CocodClient {
+  // createWalletAdapter is intentionally lazy; this receive-path test only
+  // needs the one capability exercised by receiveToken.
+  return { receiveCashu } as CocodClient;
+}
+
+describe("short keyset TokenV4 compatibility", () => {
+  it("reads amount metadata without resolving the shortened proof keyset ID", () => {
+    const token = makeToken({ amounts: [1, 4] });
+
+    // Guard the fixture itself: a full proof decode with no mint keysets must
+    // exercise the same short-ID failure that triggered this regression.
+    expect(() => getDecodedToken(token, [])).toThrow(/short keyset ID/i);
+    expect(decodeCashuTokenAmount(token)).toEqual({
+      amount: 5,
+      unit: "sat",
+    });
+  });
+
+  for (const tokenCase of [
+    {
+      name: "modern keyset with msat unit",
+      input: { amounts: [500, 1000], unit: "msat" },
+      expected: { amount: 1500, unit: "msat" as const },
+    },
+    {
+      name: "legacy v0 keyset",
+      input: { amounts: [2, 8], keysetId: LEGACY_KEYSET_ID },
+      expected: { amount: 10, unit: "sat" as const },
+    },
+  ]) {
+    it(`reads ${tokenCase.name} metadata`, () => {
+      expect(decodeCashuTokenAmount(makeToken(tokenCase.input))).toEqual(
+        tokenCase.expected,
+      );
+    });
+  }
+
+  it("reports success after cocod receives a short-keyset token", async () => {
+    const receiveCashu = mock(async () => "Received 5");
+    const walletClient = makeWalletClient(receiveCashu);
+    const adapter = await createWalletAdapter({ walletClient });
+
+    const result = await adapter.receiveToken(makeToken());
+
+    expect(receiveCashu).toHaveBeenCalledTimes(1);
+    expect(result).toEqual({
+      success: true,
+      amount: 5,
+      unit: "sat",
+      message: "Received 5",
+    });
+  });
+
+  it("does not call the wallet when token metadata is invalid", async () => {
+    const receiveCashu = mock(async () => "should not be called");
+    const walletClient = makeWalletClient(receiveCashu);
+    const adapter = await createWalletAdapter({ walletClient });
+
+    const result = await adapter.receiveToken("cashuBnot-a-valid-token");
+
+    expect(receiveCashu).not.toHaveBeenCalled();
+    expect(result.success).toBe(false);
+  });
+});