routstrd 0.4.8 → 0.4.10

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;

package/src/cli.test.ts

@@ -1,192 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import { mkdtempSync, mkdirSync, readFileSync, rmSync, statSync, writeFileSync } from "fs";
-import { tmpdir } from "os";
-import { join } from "path";
-import {
-  collectRecentRequestsFromLines,
-  initializeWallet,
-  parseStructuredLogLine,
-} from "./cli";
-
-const tempDirs: string[] = [];
-
-function makeTempDir(): string {
-  const dir = mkdtempSync(join(tmpdir(), "routstrd-wallet-test-"));
-  tempDirs.push(dir);
-  return dir;
-}
-
-function permissions(path: string): number {
-  return statSync(path).mode & 0o777;
-}
-
-afterEach(() => {
-  for (const dir of tempDirs.splice(0)) {
-    rmSync(dir, { recursive: true, force: true });
-  }
-});
-
-describe("parseStructuredLogLine", () => {
-  test("extracts timestamp, level, request id, model, and routing flag", () => {
-    const line =
-      "[2026-08-27T13:00:00.000Z] [INFO] [req:a1b2c3d4] [model:gpt-5] Routing request with path: /v1/chat/completions";
-
-    expect(parseStructuredLogLine(line)).toEqual({
-      timestamp: "2026-08-27T13:00:00.000Z",
-      level: "INFO",
-      requestId: "a1b2c3d4",
-      modelId: "gpt-5",
-      isRouting: true,
-    });
-  });
-
-  test("parses SDK child lines without marking them as routing lines", () => {
-    const line =
-      "[2026-08-27T13:00:01.000Z] [DEBUG] [req:a1b2c3d4] [model:gpt-5] [BalanceManager] token stuff";
-
-    expect(parseStructuredLogLine(line)).toEqual({
-      timestamp: "2026-08-27T13:00:01.000Z",
-      level: "DEBUG",
-      requestId: "a1b2c3d4",
-      modelId: "gpt-5",
-      isRouting: false,
-    });
-  });
-
-  test("handles legacy lines that have a request id but no model tag", () => {
-    const line =
-      "[2026-08-27T13:00:02.000Z] [INFO] [req:deadbeef] Routing request with path: /v1/responses";
-
-    expect(parseStructuredLogLine(line)).toEqual({
-      timestamp: "2026-08-27T13:00:02.000Z",
-      level: "INFO",
-      requestId: "deadbeef",
-      modelId: undefined,
-      isRouting: true,
-    });
-  });
-
-  test("extracts the bare request id from colon-joined legacy child tags", () => {
-    const line =
-      "[2026-08-27T13:00:04.000Z] [INFO] [req:deadbeef:RoutstrClient] [RoutstrClient] generic request pricing input {\"modelId\":\"deepseek-v4-flash-0731\"}";
-
-    const parsed = parseStructuredLogLine(line);
-    expect(parsed.requestId).toBe("deadbeef");
-    expect(parsed.modelId).toBe("deepseek-v4-flash-0731");
-    expect(parsed.isRouting).toBe(false);
-  });
-
-  test("falls back to the JSON modelId when no model tag is present", () => {
-    const line =
-      "[2026-08-27T13:00:05.000Z] [INFO] [req:deadbeef:RoutstrClient] [RoutstrClient] generic request pricing input {\"modelId\":\"deepseek-v4-pro-0813\",\"messageCount\":121}";
-
-    expect(parseStructuredLogLine(line).modelId).toBe("deepseek-v4-pro-0813");
-  });
-
-  test("returns an empty record for plain non-request lines", () => {
-    const line = "[2026-08-27T13:00:03.000Z] [WARN] Some startup message";
-
-    expect(parseStructuredLogLine(line)).toEqual({
-      timestamp: "2026-08-27T13:00:03.000Z",
-      level: "WARN",
-      requestId: undefined,
-      modelId: undefined,
-      isRouting: false,
-    });
-  });
-});
-
-describe("collectRecentRequestsFromLines", () => {
-  const lines = [
-    "[2026-08-27T13:00:00.000Z] [INFO] [req:11111111] [model:gpt-5] Routing request with path: /a",
-    "[2026-08-27T13:00:01.000Z] [DEBUG] [req:11111111] [model:gpt-5] [BalanceManager] token",
-    "[2026-08-27T13:00:02.000Z] [INFO] [req:22222222] [model:claude-sonnet-4.5] Routing request with path: /b",
-    "[2026-08-27T13:00:03.000Z] [DEBUG] [req:22222222] [model:claude-sonnet-4.5] [ModelManager] refresh",
-  ];
-
-  test("returns one record per request, newest first", () => {
-    expect(collectRecentRequestsFromLines(lines, 10)).toEqual([
-      {
-        requestId: "22222222",
-        modelId: "claude-sonnet-4.5",
-        timestamp: "2026-08-27T13:00:02.000Z",
-      },
-      {
-        requestId: "11111111",
-        modelId: "gpt-5",
-        timestamp: "2026-08-27T13:00:00.000Z",
-      },
-    ]);
-  });
-
-  test("respects the limit", () => {
-    expect(collectRecentRequestsFromLines(lines, 1)).toEqual([
-      {
-        requestId: "22222222",
-        modelId: "claude-sonnet-4.5",
-        timestamp: "2026-08-27T13:00:02.000Z",
-      },
-    ]);
-  });
-
-  test("defaults the model to unknown for legacy routing lines", () => {
-    const legacy = [
-      "[2026-08-27T13:00:00.000Z] [INFO] [req:deadbeef] Routing request with path: /a",
-    ];
-
-    expect(collectRecentRequestsFromLines(legacy, 10)).toEqual([
-      {
-        requestId: "deadbeef",
-        modelId: "unknown",
-        timestamp: "2026-08-27T13:00:00.000Z",
-      },
-    ]);
-  });
-
-  test("enriches the model from a sibling pricing line in legacy logs", () => {
-    const legacy = [
-      "[2026-08-27T13:00:00.000Z] [INFO] [req:deadbeef] Routing request with path: /a",
-      "[2026-08-27T13:00:01.000Z] [INFO] [req:deadbeef:RoutstrClient] [RoutstrClient] generic request pricing input {\"modelId\":\"deepseek-v4-flash-0731\"}",
-    ];
-
-    expect(collectRecentRequestsFromLines(legacy, 10)).toEqual([
-      {
-        requestId: "deadbeef",
-        modelId: "deepseek-v4-flash-0731",
-        timestamp: "2026-08-27T13:00:00.000Z",
-      },
-    ]);
-  });
-});
-
-describe("initializeWallet", () => {
-  test("creates the wallet directory and config with restrictive permissions", () => {
-    const walletDir = join(makeTempDir(), "wallet");
-
-    initializeWallet(walletDir);
-
-    const walletConfig = join(walletDir, "config.json");
-    expect(permissions(walletDir)).toBe(0o700);
-    expect(permissions(walletConfig)).toBe(0o600);
-
-    const config = JSON.parse(readFileSync(walletConfig, "utf8"));
-    expect(config.encrypted).toBe(false);
-    expect(typeof config.mnemonic).toBe("string");
-    expect(config.mnemonic.length).toBeGreaterThan(0);
-  });
-
-  test("repairs permissions without replacing an existing wallet", () => {
-    const walletDir = join(makeTempDir(), "wallet");
-    const walletConfig = join(walletDir, "config.json");
-    const existingConfig = JSON.stringify({ mnemonic: "existing seed" });
-
-    mkdirSync(walletDir, { mode: 0o755 });
-    writeFileSync(walletConfig, existingConfig, { mode: 0o644 });
-
-    initializeWallet(walletDir);
-
-    expect(readFileSync(walletConfig, "utf8")).toBe(existingConfig);
-    expect(permissions(walletDir)).toBe(0o700);
-    expect(permissions(walletConfig)).toBe(0o600);
-  });
-});

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

@@ -1,104 +0,0 @@
-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");
-  });
-});