routstrd 0.3.9 → 0.3.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "routstrd",
-  "version": "0.3.9",
+  "version": "0.3.11",
   "module": "src/index.ts",
   "type": "module",
   "private": false,
@@ -24,7 +24,7 @@
   },
   "dependencies": {
     "@cashu/cashu-ts": "^4.3.0",
-    "@routstr/sdk": "^0.3.16",
+    "@routstr/sdk": "^0.3.18",
     "applesauce-core": "^5.1.0",
     "applesauce-relay": "^5.1.0",
     "applesauce-wallet-connect": "^6.0.0",
@@ -32,6 +32,7 @@
     "nostr-tools": "^2.12.0",
     "qrcode": "^1.5.4",
     "rxjs": "^7.8.1",
+    "yaml": "^2.9.0",
     "zustand": "^5.0.5"
   }
 }

package/src/cli.ts

@@ -36,6 +36,11 @@ import {
   resolveCocodExecutable,
 } from "./daemon/wallet/cocod-client";
 import packageJson from "../package.json" with { type: "json" };
+import {
+  compareVersions,
+  getGlobalPackageVersion,
+  getLatestNpmVersion,
+} from "./utils/update-checker.ts";
 
 type RoutstrModel = {
   id: string;
@@ -363,34 +368,52 @@ program
   .command("update")
   .description("Update routstrd and cocod to the latest versions")
   .action(async () => {
-    console.log("Updating routstrd...");
-    const routstrdProc = Bun.spawn(["bun", "install", "-g", "routstrd"], {
-      stdout: "inherit",
-      stderr: "inherit",
-    });
-    const routstrdCode = await routstrdProc.exited;
-    if (routstrdCode !== 0) {
-      console.error("Failed to update routstrd.");
-      process.exit(1);
-    }
-    console.log("routstrd updated successfully.\n");
+    const packages = [
+      { name: "routstrd", label: "routstrd" },
+      { name: "@routstr/cocod", label: "cocod" },
+    ];
 
-    console.log("Updating cocod...");
-    const cocodProc = Bun.spawn(["bun", "install", "-g", "@routstr/cocod"], {
-      stdout: "inherit",
-      stderr: "inherit",
-    });
-    const cocodCode = await cocodProc.exited;
-    if (cocodCode !== 0) {
-      console.error("Failed to update cocod.");
-      process.exit(1);
-    }
-    console.log("cocod updated successfully.\n");
+    let updatedAny = false;
 
-    console.log("Both routstrd and cocod have been updated!");
+    for (const { name, label } of packages) {
+      const installed = await getGlobalPackageVersion(name);
+      const latest = await getLatestNpmVersion(name);
 
-    // Restart daemons so the new binaries take effect immediately.
-    await restartDaemonsAfterUpdate();
+      // Only skip when we're confident the installed version is current.
+      // If we can't determine either version we fall through to installing.
+      if (
+        installed &&
+        latest &&
+        (compareVersions(installed, latest) ?? -1) >= 0
+      ) {
+        console.log(`${label} is already up to date (v${installed}).`);
+        continue;
+      }
+
+      const fromPart = installed ? ` from v${installed}` : "";
+      const toPart = latest ? ` to v${latest}` : "";
+      console.log(`Updating ${label}${fromPart}${toPart}...`);
+
+      const proc = Bun.spawn(["bun", "install", "-g", name], {
+        stdout: "inherit",
+        stderr: "inherit",
+      });
+      const code = await proc.exited;
+      if (code !== 0) {
+        console.error(`Failed to update ${label}.`);
+        process.exit(1);
+      }
+      console.log(`${label} updated successfully.\n`);
+      updatedAny = true;
+    }
+
+    if (updatedAny) {
+      console.log("All requested updates have been applied!");
+      // Restart daemons so the new binaries take effect immediately.
+      await restartDaemonsAfterUpdate();
+    } else {
+      console.log("\nAll packages are already up to date — nothing to do.");
+    }
   });
 
 program

package/src/integrations/hermes.ts

@@ -1,10 +1,65 @@
 import { existsSync, mkdirSync } from "fs";
 import { readFile, writeFile } from "fs/promises";
 import { dirname } from "path";
+import { parseDocument } from "yaml";
 import type { RoutstrdConfig } from "../utils/config";
 import type { IntegrationConfig, RoutstrModel } from "./registry";
 import { callDaemon, getDaemonBaseUrl } from "../utils/daemon-client";
 
+interface HermesRoutstrConfig {
+  baseUrl: string;
+  apiKey: string;
+  defaultModel: string;
+}
+
+interface HermesCustomProvider {
+  name?: string;
+  [key: string]: unknown;
+}
+
+export function mergeHermesConfig(
+  content: string,
+  routstr: HermesRoutstrConfig,
+): string {
+  const document = parseDocument(content || "{}", { prettyErrors: true });
+  if (document.errors.length > 0) {
+    throw document.errors[0];
+  }
+
+  const urlDisplay = routstr.baseUrl
+    .replace(/\/v1$/, "")
+    .replace(/^https?:\/\//, "");
+  const provider = {
+    name: `Routstr (${urlDisplay})`,
+    base_url: routstr.baseUrl,
+    api_key: routstr.apiKey,
+    model: routstr.defaultModel,
+  };
+
+  const isNewConfig = content.trim() === "";
+  if (isNewConfig) {
+    document.set("model", {
+      default: routstr.defaultModel,
+      provider: "custom",
+      base_url: routstr.baseUrl,
+      api_key: routstr.apiKey,
+    });
+  }
+
+  const existingConfig = document.toJS() as {
+    custom_providers?: HermesCustomProvider[];
+  };
+  const existingProviders = existingConfig.custom_providers;
+  const providers = Array.isArray(existingProviders) ? existingProviders : [];
+  if (providers.some((item) => item.name?.startsWith("Routstr ("))) {
+    return content;
+  }
+  providers.push(provider);
+  document.set("custom_providers", providers);
+
+  return document.toString();
+}
+
 export async function installHermesIntegration(
   config: RoutstrdConfig,
   apiKey: string,
@@ -26,10 +81,10 @@ export async function installHermesIntegration(
 
     if (models.length >= 3) {
       defaultModel = models[2]!.id;
-      console.log(`Set default model to 3rd available model: ${defaultModel}`);
+      console.log(`Using 3rd available model for new Hermes configurations: ${defaultModel}`);
     } else if (models.length > 0) {
       defaultModel = models[0]!.id;
-      console.log(`Only ${models.length} models available, using ${defaultModel} as default.`);
+      console.log(`Only ${models.length} models available, using ${defaultModel} for new Hermes configurations.`);
     } else {
       console.log("No models available from routstr daemon, using fallback default.");
     }
@@ -47,36 +102,24 @@ export async function installHermesIntegration(
     console.error(`Error reading ${configPath}, creating new one.`);
   }
 
-  // Remove existing model block
-  content = content.replace(/^model:\n(?:  .*\n)*/gm, "");
-  // Remove existing custom_providers block
-  content = content.replace(/^custom_providers:\n(?:- .*\n(?:  .*\n)*)*/gm, "");
-  // Clean up extra blank lines
-  content = content.replace(/\n{3,}/g, "\n\n").trim();
-
-  const urlDisplay = baseUrl.replace(/^https?:\/\//, "");
-
-  const modelBlock = `model:
-  default: ${defaultModel}
-  provider: custom
-  base_url: ${baseUrlV1}
-  api_key: ${apiKey}`;
-
-  const providerBlock = `custom_providers:
-- name: Routstr (${urlDisplay})
-  base_url: ${baseUrlV1}
-  api_key: ${apiKey}
-  model: ${defaultModel}`;
-
-  const parts: string[] = [modelBlock];
-  if (content) {
-    parts.push(content);
+  let newContent: string;
+  try {
+    newContent = mergeHermesConfig(content, {
+      baseUrl: baseUrlV1,
+      apiKey,
+      defaultModel,
+    });
+  } catch (error) {
+    console.error(`Failed to parse ${configPath} as YAML; leaving it unchanged:`, error);
+    return;
   }
-  parts.push(providerBlock);
-
-  const newContent = parts.join("\n\n") + "\n";
 
   try {
+    if (newContent === content) {
+      console.log(`${configPath} already contains current routstr settings.`);
+      return;
+    }
+
     mkdirSync(dirname(configPath), { recursive: true });
     await writeFile(configPath, newContent);
     console.log(`Successfully updated ${configPath} with routstr settings.`);

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/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/integrations/hermes.test.ts

@@ -0,0 +1,97 @@
+import { describe, expect, it } from "bun:test";
+import { parse } from "yaml";
+import { mergeHermesConfig } from "../../src/integrations/hermes";
+
+const ROUTSTR = {
+  baseUrl: "http://localhost:8008/v1",
+  apiKey: "routstr-key",
+  defaultModel: "deepseek-v4-flash",
+};
+
+describe("mergeHermesConfig", () => {
+  it("preserves the user's model and unrelated custom providers", () => {
+    const existing = `model:
+  default: user-model
+  provider: custom
+  base_url: https://user.example/v1
+  api_key: user-key
+
+custom_providers:
+  - name: User Provider
+    base_url: https://user.example/v1
+    api_key: user-key
+    model: user-model
+
+other_setting: true
+`;
+
+    const merged = parse(mergeHermesConfig(existing, ROUTSTR));
+
+    expect(merged.model).toEqual({
+      default: "user-model",
+      provider: "custom",
+      base_url: "https://user.example/v1",
+      api_key: "user-key",
+    });
+    expect(merged.other_setting).toBe(true);
+    expect(merged.custom_providers).toContainEqual({
+      name: "User Provider",
+      base_url: "https://user.example/v1",
+      api_key: "user-key",
+      model: "user-model",
+    });
+    expect(merged.custom_providers).toContainEqual({
+      name: "Routstr (localhost:8008)",
+      base_url: ROUTSTR.baseUrl,
+      api_key: ROUTSTR.apiKey,
+      model: ROUTSTR.defaultModel,
+    });
+  });
+
+  it("does not add a model configuration to an existing Hermes file", () => {
+    const merged = parse(mergeHermesConfig("other_setting: true\n", ROUTSTR));
+
+    expect(merged.model).toBeUndefined();
+    expect(merged.other_setting).toBe(true);
+  });
+
+  it("creates a Routstr default when creating a new Hermes file", () => {
+    const merged = parse(mergeHermesConfig("", ROUTSTR));
+
+    expect(merged.model).toEqual({
+      default: ROUTSTR.defaultModel,
+      provider: "custom",
+      base_url: ROUTSTR.baseUrl,
+      api_key: ROUTSTR.apiKey,
+    });
+  });
+
+  it("keeps an existing Routstr provider unchanged without duplicating it", () => {
+    const existing = `custom_providers:
+  - name: Routstr (old-host:8008)
+    base_url: http://old-host:8008/v1
+    api_key: old-key
+    model: old-model
+`;
+
+    const once = mergeHermesConfig(existing, ROUTSTR);
+    const twice = mergeHermesConfig(once, ROUTSTR);
+    const merged = parse(twice);
+    const routstrProviders = merged.custom_providers.filter(
+      (provider: { name?: string }) => provider.name?.startsWith("Routstr ("),
+    );
+
+    expect(routstrProviders).toHaveLength(1);
+    expect(routstrProviders[0]).toEqual({
+      name: "Routstr (old-host:8008)",
+      base_url: "http://old-host:8008/v1",
+      api_key: "old-key",
+      model: "old-model",
+    });
+    expect(twice).toBe(once);
+  });
+
+  it("rejects malformed YAML instead of replacing it", () => {
+    expect(() => mergeHermesConfig("model: [unterminated", ROUTSTR)).toThrow();
+  });
+});