routstrd 0.4.7 → 0.4.9

package/src/utils/clients.ts

@@ -6,7 +6,11 @@ import {
   ensureDaemonRunning,
 } from "./daemon-client";
 import { logger } from "./logger";
-import { CLIENT_INTEGRATIONS, CLIENT_CONFIGS } from "../integrations/registry";
+import {
+  CLIENT_INTEGRATIONS,
+  CLIENT_CONFIGS,
+  runIntegrationsForClients,
+} from "../integrations/registry";
 
 export interface ClientEntry {
   clientId: string;
@@ -125,6 +129,75 @@ export async function addDaemonClient(
   return { message: output.message, client: output.client, created: true };
 }
 
+/**
+ * Refresh routstr21 models from Nostr, then re-run every registered client
+ * integration so local client configs pick up new models and API keys.
+ *
+ * Shared by `routstrd refresh` and `routstrd clients --manual-refresh` — the
+ * same work the daemon performs on its scheduled refresh.
+ */
+export async function refreshModelsAndClientsAction(): Promise<void> {
+  const config = await loadConfig();
+
+  console.log("Refreshing routstr21 models...");
+  const result = await callDaemon("/v1/models?refresh=true");
+  if (result.error) {
+    console.log(`Model refresh failed: ${result.error}`);
+    process.exit(1);
+  }
+  console.log("Models refreshed.");
+
+  const clients = await getClientsList();
+  if (clients.length === 0) {
+    console.log("No clients to refresh.");
+    return;
+  }
+
+  console.log(`Refreshing ${clients.length} client integration(s)...`);
+  await runIntegrationsForClients(clients, config);
+  console.log("Client integrations refreshed.");
+}
+
+/**
+ * Toggle the daemon's scheduled refresh job. Routed through the daemon so it
+ * also works against a remote daemon, where the config lives on the host.
+ */
+export async function setAutomaticRefreshAction(
+  enabled: boolean,
+): Promise<void> {
+  await ensureDaemonRunning();
+
+  const result = await callDaemon("/settings/auto-refresh", {
+    method: "POST",
+    body: { enabled },
+  });
+
+  if (result.error) {
+    console.log(result.error);
+    process.exit(1);
+  }
+
+  const output = result.output as { message?: string } | undefined;
+  console.log(
+    output?.message ?? `Automatic refresh ${enabled ? "enabled" : "disabled"}.`,
+  );
+
+  if (enabled) {
+    console.log(
+      "The daemon will keep refreshing models and client integrations on a schedule.",
+    );
+    return;
+  }
+
+  console.log(
+    "The daemon will stop the scheduled refresh of models and client integrations.",
+  );
+  console.log("Run 'routstrd clients --manual-refresh' to refresh on demand.");
+  console.log(
+    "Run 'routstrd clients --enable-automatic-refresh' to turn it back on.",
+  );
+}
+
 export async function listClientsAction(): Promise<void> {
   await ensureDaemonRunning();
 

package/src/utils/config.ts

@@ -20,6 +20,18 @@ export interface NwcAutoRefillConfig {
   cooldownMs: number;
 }
 
+/**
+ * Scheduled background refresh job (Nostr events, routstr21 models, and client
+ * integrations). Missing values mean "enabled" with the default interval, so
+ * older config files keep working unchanged.
+ */
+export interface AutoRefreshConfig {
+  /** Run the recurring refresh job. Defaults to true. */
+  enabled?: boolean;
+  /** Milliseconds between refreshes. Defaults to 21 minutes. */
+  intervalMs?: number;
+}
+
 /** NWC configuration section */
 export interface NwcConfig {
   /** NWC mode: "funding_source" = NWC funds the cocod Cashu wallet */
@@ -57,6 +69,8 @@ export interface RoutstrdConfig {
   relays?: string[];
   /** NWC integration configuration */
   nwc?: NwcConfig;
+  /** Scheduled refresh job settings (see AutoRefreshConfig). */
+  autoRefresh?: AutoRefreshConfig;
   /**
    * Default max_tokens (chat/completions) and max_output_tokens (responses)
    * injected into proxied requests when the client does not supply one.

package/src/utils/daemon-stop.ts

@@ -0,0 +1,125 @@
+import { existsSync, readFileSync } from "fs";
+import { isDaemonRunning } from "./daemon-client";
+import { defaultIsProcessRunning } from "../daemon/wallet/coco-client";
+import { walletPidPath } from "../daemon/wallet/paths";
+import { formatElapsed } from "../start-daemon";
+
+/**
+ * Wait for a daemon that was asked to stop (POST /stop) to fully exit.
+ *
+ * The daemon shuts down gracefully: it stops accepting new connections
+ * right away, but keeps serving ongoing requests until they finish; only
+ * then does it dispose of the wallet, release the wallet PID lock, and
+ * exit. Spawning a replacement before the lock is released makes it abort
+ * with "Cannot claim the routstrd wallet lock", so restarts must wait for
+ * the old process to fully exit — telling the user why it is taking a
+ * while ("Finishing all ongoing requests...") and how to force it
+ * ("run 'kill -9 <PID>' to force stop") instead of racing ahead.
+ */
+export interface WaitForDaemonToExitOptions {
+  /** Wallet PID lock file held by the running daemon. */
+  pidFilePath?: string;
+  /** Returns true while the daemon still answers /health. */
+  isHealthy?: () => Promise<boolean>;
+  /** Returns the live PID recorded in the wallet lock file, or null when the
+   * file is gone or unreadable. */
+  readLockPid?: (pidFilePath: string) => number | null;
+  /** Returns true when a PID is alive (zombies count as dead). */
+  isProcessRunning?: (pid: number) => boolean;
+  sleep?: (ms: number) => Promise<void>;
+  log?: (message: string) => void;
+  /** How long to wait for the health check to stop responding after /stop. */
+  healthTimeoutMs?: number;
+  /** Silent window before reporting that ongoing requests are finishing. */
+  drainGraceMs?: number;
+  /** How long to wait for the old daemon to exit and release the lock. */
+  drainTimeoutMs?: number;
+  /** How often to re-report that ongoing requests are still finishing. */
+  drainHeartbeatMs?: number;
+  /** Interval between health and lock polls. */
+  pollIntervalMs?: number;
+}
+
+/** How often to re-report that the daemon is still finishing requests. */
+const DRAIN_HEARTBEAT_MS = 10_000;
+
+function defaultReadLockPid(pidFilePath: string): number | null {
+  if (!existsSync(pidFilePath)) return null;
+  try {
+    const pid = Number.parseInt(readFileSync(pidFilePath, "utf8").trim(), 10);
+    return Number.isInteger(pid) && pid > 0 ? pid : null;
+  } catch {
+    return null;
+  }
+}
+
+export async function waitForDaemonToExit(
+  options: WaitForDaemonToExitOptions = {},
+): Promise<void> {
+  const {
+    pidFilePath = walletPidPath(),
+    isHealthy = isDaemonRunning,
+    readLockPid = defaultReadLockPid,
+    isProcessRunning = defaultIsProcessRunning,
+    sleep = (ms: number) =>
+      new Promise<void>((resolve) => setTimeout(resolve, ms)),
+    log = (message: string) => console.log(message),
+    healthTimeoutMs = 10_000,
+    drainGraceMs = 1_000,
+    drainTimeoutMs = 10 * 60_000,
+    drainHeartbeatMs = DRAIN_HEARTBEAT_MS,
+    pollIntervalMs = 100,
+  } = options;
+
+  // Phase 1: the daemon stops accepting new connections promptly after
+  // /stop, so its health check should stop responding within seconds.
+  const healthDeadline = Date.now() + healthTimeoutMs;
+  while (await isHealthy()) {
+    if (Date.now() >= healthDeadline) {
+      throw new Error(
+        `routstrd did not stop within ${Math.round(healthTimeoutMs / 1000)} seconds`,
+      );
+    }
+    await sleep(pollIntervalMs);
+  }
+
+  // Phase 2: the process stays alive while it finishes ongoing requests and
+  // disposes of the wallet. The wallet PID lock is released only right before
+  // the process exits, so wait for it (or for the recorded PID to die). Both
+  // progress messages offer 'kill -9 <PID>': only SIGKILL interrupts a stuck
+  // drain — a plain SIGTERM just re-runs the same graceful shutdown.
+  const drainStartedAt = Date.now();
+  const drainDeadline = drainStartedAt + drainTimeoutMs;
+  let drainAnnounced = false;
+  let nextHeartbeatAt = 0;
+
+  for (;;) {
+    const lockPid = readLockPid(pidFilePath);
+    if (lockPid === null || !isProcessRunning(lockPid)) return;
+
+    const now = Date.now();
+    if (now >= drainDeadline) {
+      throw new Error(
+        `the previous daemon (PID ${lockPid}) did not finish its ongoing requests within ` +
+          `${formatElapsed(drainTimeoutMs)} and still holds the wallet lock at ${pidFilePath}. ` +
+          `Wait for it to exit and try again, or run 'kill -9 ${lockPid}' to force it.`,
+      );
+    }
+
+    if (!drainAnnounced && now - drainStartedAt >= drainGraceMs) {
+      drainAnnounced = true;
+      log(
+        `  Finishing all ongoing requests... (run 'kill -9 ${lockPid}' to force stop)`,
+      );
+      nextHeartbeatAt = now + drainHeartbeatMs;
+    } else if (drainAnnounced && now >= nextHeartbeatAt) {
+      log(
+        `  Still finishing ongoing requests (${formatElapsed(now - drainStartedAt)} elapsed)... ` +
+          `(run 'kill -9 ${lockPid}' to force stop)`,
+      );
+      nextHeartbeatAt += drainHeartbeatMs;
+    }
+
+    await sleep(pollIntervalMs);
+  }
+}

package/src/utils/standalone-update.ts

@@ -0,0 +1,214 @@
+import { createHash, randomBytes } from "crypto";
+import {
+  chmodSync,
+  constants,
+  copyFileSync,
+  mkdtempSync,
+  renameSync,
+  rmSync,
+  statSync,
+  writeFileSync,
+} from "fs";
+import { tmpdir } from "os";
+import { basename, join } from "path";
+
+const RELEASES_API = "https://api.github.com/repos/Routstr/routstrd/releases/latest";
+const FETCH_TIMEOUT_MS = 30_000;
+const PROCESS_TIMEOUT_MS = 30_000;
+const MAX_ARCHIVE_BYTES = 250 * 1024 * 1024;
+const MAX_CHECKSUM_BYTES = 1024 * 1024;
+
+type ReleaseAsset = {
+  name: string;
+  browser_download_url: string;
+};
+
+type GithubRelease = {
+  tag_name: string;
+  assets: ReleaseAsset[];
+};
+
+export type StandaloneRelease = {
+  version: string;
+  archive: ReleaseAsset;
+  checksums: ReleaseAsset;
+};
+
+function normalizeVersion(version: string): string {
+  return version.replace(/^v/, "");
+}
+
+export function releaseArchiveName(
+  version: string,
+  platform: NodeJS.Platform,
+  arch: string,
+): string {
+  if (platform !== "linux" && platform !== "darwin") {
+    throw new Error(`Standalone updates are not supported on ${platform}.`);
+  }
+  if (arch !== "x64" && arch !== "arm64") {
+    throw new Error(`Standalone updates are not supported on ${platform}-${arch}.`);
+  }
+  return `routstrd-v${normalizeVersion(version)}-${platform}-${arch}.tar.gz`;
+}
+
+async function fetchOrThrow(
+  url: string,
+  fetchImpl: typeof fetch,
+  maxBytes = MAX_CHECKSUM_BYTES,
+): Promise<Response> {
+  const response = await fetchImpl(url, {
+    headers: {
+      Accept: "application/vnd.github+json",
+      "User-Agent": "routstrd",
+    },
+    redirect: "follow",
+    signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
+  });
+  if (!response.ok) {
+    throw new Error(`Download failed (${response.status}) for ${url}`);
+  }
+  const contentLength = Number(response.headers.get("content-length"));
+  if (Number.isFinite(contentLength) && contentLength > maxBytes) {
+    throw new Error(`Download is too large (${contentLength} bytes) for ${url}`);
+  }
+  return response;
+}
+
+async function waitForExit(
+  proc: { exited: Promise<number>; kill(): void },
+  label: string,
+): Promise<number> {
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  try {
+    return await Promise.race([
+      proc.exited,
+      new Promise<never>((_, reject) => {
+        timeout = setTimeout(() => {
+          proc.kill();
+          reject(new Error(`${label} timed out.`));
+        }, PROCESS_TIMEOUT_MS);
+      }),
+    ]);
+  } finally {
+    if (timeout) clearTimeout(timeout);
+  }
+}
+
+export async function getLatestStandaloneRelease(
+  platform: NodeJS.Platform = process.platform,
+  arch: string = process.arch,
+  fetchImpl: typeof fetch = fetch,
+): Promise<StandaloneRelease> {
+  const response = await fetchOrThrow(RELEASES_API, fetchImpl);
+  const release = (await response.json()) as GithubRelease;
+  const version = normalizeVersion(release.tag_name || "");
+  if (!/^\d+\.\d+\.\d+/.test(version)) {
+    throw new Error("The latest GitHub Release has an invalid version tag.");
+  }
+
+  const archiveName = releaseArchiveName(version, platform, arch);
+  const archive = release.assets.find((asset) => asset.name === archiveName);
+  const checksums = release.assets.find((asset) => asset.name === "SHA256SUMS");
+  if (!archive || !checksums) {
+    throw new Error(`GitHub Release v${version} is missing ${archiveName} or SHA256SUMS.`);
+  }
+  return { version, archive, checksums };
+}
+
+export function expectedChecksum(contents: string, filename: string): string {
+  for (const line of contents.split("\n")) {
+    const match = line.trim().match(/^([a-fA-F0-9]{64})\s+\*?(.+)$/);
+    if (match?.[2] === filename) return match[1]!.toLowerCase();
+  }
+  throw new Error(`SHA256SUMS does not contain ${filename}.`);
+}
+
+export function sha256(bytes: ArrayBuffer | Uint8Array): string {
+  return createHash("sha256").update(new Uint8Array(bytes)).digest("hex");
+}
+
+async function verifyCandidate(path: string, version: string): Promise<void> {
+  const proc = Bun.spawn([path, "--version"], {
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const [code, outputText, errorText] = await Promise.all([
+    waitForExit(proc, "Downloaded binary validation"),
+    new Response(proc.stdout).text(),
+    new Response(proc.stderr).text(),
+  ]);
+  const output = outputText.trim();
+  const error = errorText.trim();
+  if (code !== 0 || normalizeVersion(output) !== normalizeVersion(version)) {
+    throw new Error(
+      `Downloaded binary failed version validation.${error ? ` ${error}` : ""}`,
+    );
+  }
+}
+
+export async function installStandaloneRelease(
+  release: StandaloneRelease,
+  executablePath: string = process.execPath,
+  fetchImpl: typeof fetch = fetch,
+): Promise<void> {
+  const tempDir = mkdtempSync(join(tmpdir(), "routstrd-update-"));
+  const archivePath = join(tempDir, release.archive.name);
+  const stagedPath = `${executablePath}.update-${randomBytes(12).toString("hex")}`;
+
+  try {
+    const [archiveResponse, checksumsResponse] = await Promise.all([
+      fetchOrThrow(
+        release.archive.browser_download_url,
+        fetchImpl,
+        MAX_ARCHIVE_BYTES,
+      ),
+      fetchOrThrow(release.checksums.browser_download_url, fetchImpl),
+    ]);
+    const archiveBytes = await archiveResponse.arrayBuffer();
+    if (archiveBytes.byteLength > MAX_ARCHIVE_BYTES) {
+      throw new Error(`Download is too large (${archiveBytes.byteLength} bytes).`);
+    }
+    const checksums = await checksumsResponse.text();
+    if (Buffer.byteLength(checksums) > MAX_CHECKSUM_BYTES) {
+      throw new Error("SHA256SUMS is too large.");
+    }
+    const expected = expectedChecksum(checksums, release.archive.name);
+    const actual = sha256(archiveBytes);
+    if (actual !== expected) {
+      throw new Error(
+        `Checksum mismatch for ${release.archive.name}: expected ${expected}, got ${actual}.`,
+      );
+    }
+    writeFileSync(archivePath, new Uint8Array(archiveBytes));
+
+    const extract = Bun.spawn(["tar", "-xzf", archivePath, "-C", tempDir], {
+      stdout: "ignore",
+      stderr: "pipe",
+    });
+    const [extractCode, extractErrorText] = await Promise.all([
+      waitForExit(extract, "Archive extraction"),
+      new Response(extract.stderr).text(),
+    ]);
+    const extractError = extractErrorText.trim();
+    if (extractCode !== 0) {
+      throw new Error(`Could not extract ${release.archive.name}. ${extractError}`.trim());
+    }
+
+    const extractedPath = join(tempDir, "routstrd");
+    const mode = statSync(executablePath).mode & 0o777;
+    copyFileSync(extractedPath, stagedPath, constants.COPYFILE_EXCL);
+    chmodSync(stagedPath, mode || 0o755);
+    await verifyCandidate(stagedPath, release.version);
+    renameSync(stagedPath, executablePath);
+  } catch (error) {
+    const detail = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Could not update ${basename(executablePath)} in place. ${detail}`,
+      { cause: error },
+    );
+  } finally {
+    rmSync(stagedPath, { force: true });
+    rmSync(tempDir, { recursive: true, force: true });
+  }
+}

package/src/utils/update-checker.ts

@@ -1,3 +1,7 @@
+import { isStandaloneExecutable } from "../runtime";
+import { VERSION } from "../version";
+import { getLatestStandaloneRelease } from "./standalone-update";
+
 const NPM_REGISTRY = "https://registry.npmjs.org";
 
 /** Packages that `routstrd update` manages. */
@@ -53,30 +57,65 @@ export async function getGlobalPackageVersion(
   }
 }
 
+type ParsedVersion = {
+  core: [number, number, number];
+  prerelease: string[] | null;
+};
+
+function parseVersion(version: string): ParsedVersion | null {
+  const match = version.match(
+    /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/,
+  );
+  if (!match?.[1] || !match[2] || !match[3]) return null;
+  return {
+    core: [
+      Number.parseInt(match[1], 10),
+      Number.parseInt(match[2], 10),
+      Number.parseInt(match[3], 10),
+    ],
+    prerelease: match[4]?.split(".") ?? null,
+  };
+}
+
+function comparePrerelease(a: string[] | null, b: string[] | null): number {
+  if (!a && !b) return 0;
+  if (!a) return 1;
+  if (!b) return -1;
+
+  for (let index = 0; index < Math.max(a.length, b.length); index++) {
+    const left = a[index];
+    const right = b[index];
+    if (left === undefined) return -1;
+    if (right === undefined) return 1;
+    if (left === right) continue;
+
+    const leftNumeric = /^\d+$/.test(left);
+    const rightNumeric = /^\d+$/.test(right);
+    if (leftNumeric && rightNumeric) {
+      return Number.parseInt(left, 10) - Number.parseInt(right, 10);
+    }
+    if (leftNumeric) return -1;
+    if (rightNumeric) return 1;
+    return left < right ? -1 : 1;
+  }
+  return 0;
+}
+
 /**
  * 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;
+  const left = parseVersion(a);
+  const right = parseVersion(b);
+  if (!left || !right) return null;
+
+  for (let index = 0; index < left.core.length; index++) {
+    const difference = left.core[index]! - right.core[index]!;
+    if (difference !== 0) return difference;
+  }
+  return comparePrerelease(left.prerelease, right.prerelease);
 }
 
 export interface PackageUpdate {
@@ -97,6 +136,30 @@ export interface UpdateCheckResult {
  * Returns a result with per-package details and an overall `hasUpdate` flag.
  */
 export async function checkForUpdates(): Promise<UpdateCheckResult> {
+  if (isStandaloneExecutable()) {
+    let latest: string | null = null;
+    try {
+      latest = (await getLatestStandaloneRelease()).version;
+    } catch {
+      // Update checks are best-effort and must not disrupt the TUI.
+    }
+    const hasUpdate = !!(
+      latest && (compareVersions(VERSION, latest) ?? -1) < 0
+    );
+    return {
+      hasUpdate,
+      packages: [
+        {
+          name: "routstrd",
+          label: "routstrd",
+          current: VERSION,
+          latest,
+          hasUpdate,
+        },
+      ],
+    };
+  }
+
   const packages = await Promise.all(
     UPDATE_PACKAGES.map(async ({ name, label }) => {
       const [current, latest] = await Promise.all([

package/src/version.ts

@@ -0,0 +1,3 @@
+import packageJson from "../package.json" with { type: "json" };
+
+export const VERSION = packageJson.version;