routstrd 0.4.0 → 0.4.2

package/src/integrations/pi.ts

@@ -8,6 +8,8 @@ import { callDaemon, getDaemonBaseUrl } from "../utils/daemon-client";
 type PiModelEntry = {
   id: string;
   contextWindow?: number;
+  // Preserve arbitrary manual fields (reasoning, thinkingLevelMap, compat, cost, maxTokens, etc.)
+  [key: string]: unknown;
 };
 
 type PiProviderConfig = {
@@ -61,15 +63,29 @@ export async function installPiIntegration(
       return;
     }
 
+    // Preserve any manually-added per-model fields (reasoning, thinkingLevelMap,
+    // compat, cost, maxTokens, etc.) across refreshes. Only `id` and `contextWindow`
+    // are managed by routstrd.
+    const existingModels = new Map<string, PiModelEntry>(
+      (piConfig.providers["routstr"]?.models ?? []).map((m) => [m.id, m]),
+    );
+
     const providerModels: PiModelEntry[] = models.map((model) => {
-      const entry: PiModelEntry = { id: model.id };
+      const previous = existingModels.get(model.id);
+      const entry: PiModelEntry = previous ? { ...previous } : { id: model.id };
+
+      entry.id = model.id;
       if (model.context_length !== undefined && model.context_length > 0) {
         entry.contextWindow = model.context_length;
       }
+
       return entry;
     });
 
+    // Preserve provider-level manual fields (compat, headers, name, etc.); only update
+    // the routstrd-managed fields below.
     piConfig.providers["routstr"] = {
+      ...(piConfig.providers["routstr"] ?? {}),
       baseUrl,
       api: "openai-completions",
       apiKey,

package/src/start-daemon.ts

@@ -170,6 +170,22 @@ async function startDaemonUnlocked(
 
   proc.unref();
 
+  // The daemon must outlive a successful start, but a start we give up on must not
+  // leave a detached process holding the wallet locks. `detached` makes it a group leader.
+  const killSpawnedDaemon = (): void => {
+    try {
+      process.kill(-proc.pid, "SIGTERM");
+    } catch {
+      // Already exited.
+    }
+  };
+  const abandonOnSignal = (): void => {
+    killSpawnedDaemon();
+    process.exit(1);
+  };
+  process.once("SIGINT", abandonOnSignal);
+  process.once("SIGTERM", abandonOnSignal);
+
   let exitCode: number | null = null;
   proc.exited.then((code) => {
     exitCode = code;
@@ -212,6 +228,8 @@ async function startDaemonUnlocked(
     }
 
     if (await healthyDaemonHost(port, host)) {
+      process.off("SIGINT", abandonOnSignal);
+      process.off("SIGTERM", abandonOnSignal);
       printStartupProgress(progressLogOffset);
       console.log(
         `Routstr daemon started (PID: ${proc.pid}, ${formatElapsed(Date.now() - startedAt)}).`,
@@ -220,8 +238,10 @@ async function startDaemonUnlocked(
     }
   }
 
+  killSpawnedDaemon();
   throw new Error(
-    `Daemon failed to start within ${Math.round(startupTimeoutMs / 1000)} seconds. Check logs in ${LOGS_DIR}`,
+    `Daemon did not become healthy within ${Math.round(startupTimeoutMs / 1000)} seconds; ` +
+      `the incomplete daemon (PID ${proc.pid}) was stopped. Check logs in ${LOGS_DIR}`,
   );
 }
 

package/src/tui/usage/data.ts

@@ -1,5 +1,10 @@
 import type { UsageTrackingEntry } from "../../daemon/types.ts";
-import { callDaemon, isDaemonRunning } from "../../utils/daemon-client.ts";
+import {
+  callDaemon,
+  getDaemonBaseUrl,
+  isDaemonRunning,
+  loadConfig,
+} from "../../utils/daemon-client.ts";
 import type { UsageStats, UsageSummary } from "./types.ts";
 
 export { isDaemonRunning };
@@ -21,12 +26,17 @@ export interface StatusInfo {
   daemon: string;
   wallet: string;
   mode: "xcashu" | "apikeys";
+  /** URL the TUI is connected through (local bind or remote daemonUrl). */
+  url?: string;
   error?: string;
 }
 
 export async function fetchStatus(): Promise<StatusInfo | null> {
   try {
-    const result = await callDaemon("/status");
+    const [result, config] = await Promise.all([
+      callDaemon("/status"),
+      loadConfig(),
+    ]);
     if (result.error) return null;
 
     const output = result.output as {
@@ -40,6 +50,7 @@ export async function fetchStatus(): Promise<StatusInfo | null> {
       daemon: output?.daemon || "unknown",
       wallet: output?.wallet || "unknown",
       mode: output?.mode || "apikeys",
+      url: getDaemonBaseUrl(config),
       error: output?.error,
     };
   } catch {

package/src/tui/usage/render.ts

@@ -162,6 +162,14 @@ export function renderOverview(stats: UsageStats, balance: BalanceInfo | null, s
     const walletColor = status.wallet === "connected" ? COLORS.green : COLORS.red;
     const modeColor = COLORS.cyan;
     statusLines.push(`${COLORS.bold}Daemon:${COLORS.reset} ${daemonColor}${status.daemon}${COLORS.reset}`);
+    if (status.url) {
+      const label = "Running on: ";
+      const maxUrlLen = Math.max(8, halfWidth2 - 4 - label.length);
+      const url = status.url.length > maxUrlLen
+        ? `${status.url.slice(0, Math.max(0, maxUrlLen - 1))}…`
+        : status.url;
+      statusLines.push(`${COLORS.bold}${label}${COLORS.reset} ${COLORS.cyan}${url}${COLORS.reset}`);
+    }
     statusLines.push(`${COLORS.bold}Wallet:${COLORS.reset} ${walletColor}${status.wallet}${COLORS.reset}`);
     statusLines.push(`${COLORS.bold}Mode:${COLORS.reset} ${modeColor}${status.mode}${COLORS.reset}`);
     if (status.error) {

package/src/utils/config.ts

@@ -48,8 +48,10 @@ export interface RoutstrdConfig {
    * Defaults to daemonUrl or localhost:{port} if not set. */
   authUrl?: string;
   nsec?: string;
-  /** Nostr hex pubkey for routstr review/model events (kind 38425/38423). */
+  /** Nostr hex pubkey for routstr review/audit events (kind 38425). */
   routstrPubkey?: string;
+  /** Nostr hex pubkey for the routstr-21 model list only (kind 38423). Falls back to routstrPubkey. */
+  routstrModelsPubkey?: string;
   /** Nostr relay URLs for provider/model discovery (kinds 38421/38423/38425).
    * When unset, each method uses its own built-in defaults. */
   relays?: string[];

package/tests/daemon/config-store.perms.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, test } from "bun:test";
+import { spawnSync } from "child_process";
+import { mkdtempSync, rmSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+// These scenarios mutate process.env.ROUTSTRD_DIR before the config-store
+// module is loaded, and other test files import the same module singleton
+// first — so each scenario runs in an isolated bun subprocess where the env
+// is guaranteed to be in place before module evaluation.
+
+const SCENARIO = join(import.meta.dir, "config-store.scenario.ts");
+
+function runScenario(name: string): { code: number; out: string } {
+  const dir = mkdtempSync(join(tmpdir(), `routstrd-cfg-${name}-`));
+  const res = spawnSync("bun", [SCENARIO, name], {
+    env: {
+      ...process.env,
+      NODE_ENV: "test",
+      ROUTSTRD_DIR: join(dir, "daemon"),
+    },
+    stdout: "pipe",
+    stderr: "pipe",
+  });
+  const out = `${res.stdout}${res.stderr}`;
+  rmSync(dir, { recursive: true, force: true });
+  // bun's spawnSync reports the exit code in `status` (exitCode is undefined).
+  return { code: res.status ?? res.exitCode ?? -1, out };
+}
+
+describe("daemon config store permissions", () => {
+  test("fresh install: config dir 0700, config file 0600, atomic write", () => {
+    const { code, out } = runScenario("fresh-install");
+    expect(out).toContain("SCENARIO-OK");
+    expect(code).toBe(0);
+  });
+
+  test("existing over-permissive install (0755/0644) is repaired", () => {
+    const { code, out } = runScenario("repair-perms");
+    expect(out).toContain("SCENARIO-OK");
+    expect(code).toBe(0);
+  });
+
+  test("write failure surfaces synchronously with no temp file left", () => {
+    const { code, out } = runScenario("write-failure");
+    expect(out).toContain("SCENARIO-OK");
+    expect(code).toBe(0);
+  });
+
+  test("corrupt JSON falls back to defaults", () => {
+    const { code, out } = runScenario("corrupt-json");
+    expect(out).toContain("SCENARIO-OK");
+    expect(code).toBe(0);
+  });
+});

package/tests/daemon/config-store.scenario.ts

@@ -0,0 +1,113 @@
+// Scenario runner for config-store.perms.test.ts — executed as a standalone
+// bun process with ROUTSTRD_DIR set before module evaluation. Not a test file.
+import {
+  chmodSync,
+  existsSync,
+  readdirSync,
+  statSync,
+  writeFileSync,
+} from "fs";
+
+const { CONFIG_DIR, CONFIG_FILE } = await import("../../src/utils/config");
+const {
+  ensureDirs,
+  ensureDirsSync,
+  loadDaemonConfig,
+  loadDaemonConfigSync,
+  saveDaemonConfig,
+  REQUESTS_DIR,
+} = await import("../../src/daemon/config-store");
+
+const modeOf = (p: string): number => statSync(p).mode & 0o777;
+
+const baseConfig = {
+  port: 8008,
+  host: "127.0.0.1",
+  provider: null,
+  cocodPath: null,
+};
+
+function assert(cond: unknown, msg: string): void {
+  if (!cond) {
+    console.error(`ASSERT-FAIL: ${msg}`);
+    process.exit(1);
+  }
+}
+
+const scenario = process.argv[2];
+
+switch (scenario) {
+  case "fresh-install": {
+    saveDaemonConfig({
+      ...baseConfig,
+      nsec: "nsec1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq",
+    });
+    assert(modeOf(CONFIG_DIR) === 0o700, `dir mode ${modeOf(CONFIG_DIR).toString(8)} != 700`);
+    assert(modeOf(CONFIG_FILE) === 0o600, `file mode ${modeOf(CONFIG_FILE).toString(8)} != 600`);
+    assert(
+      readdirSync(CONFIG_DIR).filter((f) => f.endsWith(".tmp")).length === 0,
+      "temp file left behind",
+    );
+    const loaded = await loadDaemonConfig();
+    assert(
+      loaded.nsec === "nsec1qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq",
+      "nsec round-trip failed",
+    );
+    assert(loaded.port === 8008, "port round-trip failed");
+
+    await ensureDirs();
+    assert(modeOf(CONFIG_DIR) === 0o700, "ensureDirs dir mode");
+    assert(modeOf(REQUESTS_DIR) === 0o700, "ensureDirs requests dir mode");
+    break;
+  }
+
+  case "repair-perms": {
+    // Simulate an install written by the vulnerable version.
+    ensureDirsSync();
+    writeFileSync(CONFIG_FILE, JSON.stringify(baseConfig), { mode: 0o644 });
+    chmodSync(CONFIG_DIR, 0o755);
+    chmodSync(CONFIG_FILE, 0o644);
+    assert(modeOf(CONFIG_FILE) === 0o644, "setup: file not 0644");
+
+    // Load repairs the file mode...
+    loadDaemonConfigSync();
+    assert(modeOf(CONFIG_FILE) === 0o600, "load did not repair file mode");
+
+    // ...and the next save repairs the directory mode too.
+    chmodSync(CONFIG_DIR, 0o755);
+    saveDaemonConfig({ ...baseConfig, port: 9009 });
+    assert(modeOf(CONFIG_DIR) === 0o700, "save did not repair dir mode");
+    assert(modeOf(CONFIG_FILE) === 0o600, "save did not keep file mode");
+    assert(loadDaemonConfigSync().port === 9009, "save did not persist port");
+    break;
+  }
+
+  case "write-failure": {
+    // Turn the config dir into a regular file: mkdir fails and no temp write
+    // can succeed, so saveDaemonConfig must surface the error synchronously.
+    writeFileSync(process.env.ROUTSTRD_DIR!, "blocked");
+    let threw = false;
+    try {
+      saveDaemonConfig(baseConfig);
+    } catch {
+      threw = true;
+    }
+    assert(threw, "saveDaemonConfig did not throw on unwritable target");
+    break;
+  }
+
+  case "corrupt-json": {
+    ensureDirsSync();
+    writeFileSync(CONFIG_FILE, "{ not json");
+    const loaded = await loadDaemonConfig();
+    assert(loaded.port === 8008, "did not fall back to defaults");
+    assert(existsSync(CONFIG_FILE), "config file vanished");
+    break;
+  }
+
+  default:
+    console.error(`unknown scenario: ${scenario}`);
+    process.exit(2);
+}
+
+console.log("SCENARIO-OK");

package/tests/integrations/hermes.test.ts

@@ -66,7 +66,7 @@ other_setting: true
     });
   });
 
-  it("keeps an existing Routstr provider unchanged without duplicating it", () => {
+  it("updates an existing Routstr provider in place without duplicating it", () => {
     const existing = `custom_providers:
   - name: Routstr (old-host:8008)
     base_url: http://old-host:8008/v1
@@ -83,14 +83,51 @@ other_setting: true
 
     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",
+      name: "Routstr (localhost:8008)",
+      base_url: ROUTSTR.baseUrl,
+      api_key: ROUTSTR.apiKey,
+      model: ROUTSTR.defaultModel,
     });
     expect(twice).toBe(once);
   });
 
+  it("repoints model.provider when the Routstr provider is renamed", () => {
+    const existing = `model:
+  default: old-model
+  provider: custom:routstr-(old-host:8008)
+
+custom_providers:
+  - name: Routstr (old-host:8008)
+    base_url: http://old-host:8008/v1
+    api_key: old-key
+    model: old-model
+`;
+
+    const merged = parse(mergeHermesConfig(existing, ROUTSTR));
+
+    expect(merged.model).toEqual({
+      default: "old-model",
+      provider: "custom:routstr-(localhost:8008)",
+    });
+  });
+
+  it("leaves model.provider alone when it does not reference the Routstr provider", () => {
+    const existing = `model:
+  default: user-model
+  provider: custom:user-provider
+
+custom_providers:
+  - name: Routstr (old-host:8008)
+    base_url: http://old-host:8008/v1
+    api_key: old-key
+    model: old-model
+`;
+
+    const merged = parse(mergeHermesConfig(existing, ROUTSTR));
+
+    expect(merged.model.provider).toBe("custom:user-provider");
+  });
+
   it("rejects malformed YAML instead of replacing it", () => {
     expect(() => mergeHermesConfig("model: [unterminated", ROUTSTR)).toThrow();
   });