routstrd 0.1.0

package/src/tui/usage/types.ts

@@ -0,0 +1,65 @@
+import type { UsageTrackingEntry } from "../../daemon/types.ts";
+
+export interface UsageStats {
+  entries: UsageTrackingEntry[];
+  totalEntries: number;
+  totalSatsCost: number;
+  recentSatsCost: number;
+  limit: number;
+}
+
+export interface DayStats {
+  date: string;
+  requests: number;
+  satsCost: number;
+  promptTokens: number;
+  completionTokens: number;
+  totalTokens: number;
+}
+
+export interface ModelStats {
+  modelId: string;
+  requests: number;
+  satsCost: number;
+  promptTokens: number;
+  completionTokens: number;
+  totalTokens: number;
+}
+
+export interface ProviderStats {
+  baseUrl: string;
+  requests: number;
+  satsCost: number;
+  promptTokens: number;
+  completionTokens: number;
+  totalTokens: number;
+}
+
+export interface ClientStats {
+  client: string;
+  requests: number;
+  satsCost: number;
+  promptTokens: number;
+  completionTokens: number;
+  totalTokens: number;
+}
+
+export type TabId = "overview" | "today" | "models" | "providers" | "tokens" | "clients" | "recent";
+
+export interface Tab {
+  id: TabId;
+  name: string;
+  key: string;
+}
+
+export interface VimState {
+  scrollPos: number;
+  searchQuery: string;
+  searchResults: number[];
+  currentSearchIdx: number;
+  isSearching: boolean;
+  searchReverse: boolean;
+  mode: "normal" | "search";
+  lastKey: string;
+  lastKeyTime: number;
+}

package/src/utils/config.ts

@@ -0,0 +1,22 @@
+const HOME = process.env.HOME || process.env.USERPROFILE || "";
+
+export const CONFIG_DIR = process.env.ROUTSTRD_DIR || `${HOME}/.routstrd`;
+export const SOCKET_PATH = process.env.ROUTSTRD_SOCKET || `${CONFIG_DIR}/routstrd.sock`;
+export const PID_FILE = process.env.ROUTSTRD_PID || `${CONFIG_DIR}/routstrd.pid`;
+export const DB_PATH = `${CONFIG_DIR}/routstr.db`;
+export const CONFIG_FILE = `${CONFIG_DIR}/config.json`;
+export const LOG_FILE = `${CONFIG_DIR}/routstrd.log`;
+
+export interface RoutstrdConfig {
+  port: number;
+  provider: string | null;
+  cocodPath: string | null;
+  mode?: "xcashu" | "apikeys";
+}
+
+export const DEFAULT_CONFIG: RoutstrdConfig = {
+  port: 8008,
+  provider: null,
+  cocodPath: null,
+  mode: "apikeys",
+};

package/src/utils/logger.ts

@@ -0,0 +1,54 @@
+import { appendFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+
+const HOME = process.env.HOME || process.env.USERPROFILE || "";
+const LOG_DIR = process.env.ROUTSTRD_DIR || `${HOME}/.routstrd`;
+const LOG_FILE = join(LOG_DIR, "routstrd.log");
+
+async function ensureLogDir() {
+  if (!existsSync(LOG_DIR)) {
+    await mkdir(LOG_DIR, { recursive: true });
+  }
+}
+
+async function writeLog(level: string, ...args: unknown[]) {
+  await ensureLogDir();
+  const timestamp = new Date().toISOString();
+  const message = args
+    .map((a) => {
+      if (a instanceof Error) {
+        return `${a.message}${a.stack ? `\n${a.stack}` : ""}`;
+      }
+      if (typeof a === "object") {
+        try {
+          return JSON.stringify(a);
+        } catch {
+          return String(a);
+        }
+      }
+      return String(a);
+    })
+    .join(" ");
+  const line = `[${timestamp}] [${level}] ${message}\n`;
+  try {
+    await appendFile(LOG_FILE, line);
+  } catch (error) {
+    console.error("Failed to write log:", error);
+  }
+}
+
+export const logger = {
+  log: (...args: unknown[]) => {
+    console.log(...args);
+    writeLog("INFO", ...args);
+  },
+  error: (...args: unknown[]) => {
+    console.error(...args);
+    writeLog("ERROR", ...args);
+  },
+  info: (...args: unknown[]) => {
+    console.log(...args);
+    writeLog("INFO", ...args);
+  },
+};

package/test_box.ts

@@ -0,0 +1,15 @@
+import { renderBox } from "./src/tui/usage/render.ts";
+import { stripAnsi } from "./src/tui/usage/terminal.ts";
+
+const w = 40;
+const testBox = renderBox(["Hello World", "Line 2"], w, "Title");
+console.log(testBox);
+const lines = testBox.split("\n");
+lines.forEach((l, i) => console.log(`Line ${i} length: ${stripAnsi(l).length}`));
+
+console.log("---");
+
+const testBoxNoTitle = renderBox(["Hello World", "Line 2"], w);
+console.log(testBoxNoTitle);
+const lines2 = testBoxNoTitle.split("\n");
+lines2.forEach((l, i) => console.log(`Line ${i} length: ${stripAnsi(l).length}`));

package/test_curl.sh

@@ -0,0 +1,11 @@
+#!/bin/bash
+curl -X POST "http://localhost:8008/v1/chat/completions" \
+  -H "Authorization: Bearer YOUR_API_KEY" \
+  -H "Content-Type: application/json" \
+  -d '{
+    "model": "gemma-3n-e4b-it",
+    "messages": [
+      {"role":"system","content":"You are Routstr."},
+      {"role":"user","content":"Ping the node"}
+    ]
+  }'

package/test_split_box.ts

@@ -0,0 +1,17 @@
+import { renderBox } from "./src/tui/usage/render.ts";
+
+const width = 80;
+const halfWidth1 = Math.floor(width / 2);
+const halfWidth2 = width - halfWidth1;
+
+const leftBox = ["Total Spent: 12.78k sats", "Total Requests: 1.0k"];
+const rightBox = ["Total Tokens: 25.8M", "Avg Tokens/Req: 25.8K"];
+
+const leftBoxStr = renderBox(leftBox, halfWidth1, "Stats of Sats");
+const rightBoxStr = renderBox(rightBox, halfWidth2, "Token Stats");
+
+const leftLines = leftBoxStr.split("\n");
+const rightLines = rightBoxStr.split("\n");
+
+const combinedContent = leftLines.map((l, i) => l + (rightLines[i] || " ".repeat(halfWidth2))).join("\n");
+console.log(combinedContent);

package/test_split_box2.ts

@@ -0,0 +1,23 @@
+import { renderBox } from "./src/tui/usage/render.ts";
+
+const width = 80;
+const halfWidth1 = Math.floor(width / 2);
+const halfWidth2 = width - halfWidth1;
+
+const leftBox = ["Total Spent: 12.78k sats", "Total Requests: 1.0k"];
+const rightBox = ["Total Tokens: 25.8M", "Avg Tokens/Req: 25.8K"];
+
+const leftBoxStr = renderBox(leftBox, halfWidth1, "Stats of Sats");
+const rightBoxStr = renderBox(rightBox, halfWidth2, "Token Stats");
+
+const leftLines = leftBoxStr.split("\n");
+const rightLines = rightBoxStr.split("\n");
+
+const maxLines = Math.max(leftLines.length, rightLines.length);
+const combinedLines: string[] = [];
+for (let i = 0; i < maxLines; i++) {
+  const l = leftLines[i] || " ".repeat(Math.floor(width / 2));
+  const r = rightLines[i] || " ".repeat(Math.ceil(width / 2));
+  combinedLines.push(l + r);
+}
+console.log(combinedLines.join("\n"));

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "allowImportingTsExtensions": true,
+    "noEmit": true,
+    "types": ["bun-types"]
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules"]
+}

package/v1-messages-format-report.md

@@ -0,0 +1,223 @@
+# Report: why `POST /v1/messages` on port 8008 returns chat-completions chunks while port 8009 preserves Messages API format
+
+Date: 2026-03-28
+
+## Summary
+
+I tested the same request against both local daemons using `scripts/test-direct-local.ts` semantics (`POST /v1/messages`, `stream: true`).
+
+- `localhost:8009` preserves the Anthropic/OpenAI Messages-style stream as expected:
+  - `message_start`
+  - `content_block_start`
+  - `content_block_delta`
+  - `message_delta`
+  - `message_stop`
+- `localhost:8008` returns OpenAI chat-completions streaming chunks instead:
+  - `object: "chat.completion.chunk"`
+  - `choices[].delta`
+
+This is **not** because the SDK itself is incapable of preserving `/v1/messages`.
+It happens because the two daemons call the SDK differently.
+
+---
+
+## What I tested
+
+### 8008 (`../routstrd/`)
+
+Listener:
+- `../routstrd/src/daemon/index.ts`
+- request handler in `../routstrd/src/daemon/http/index.ts`
+
+Observed result for `POST http://localhost:8008/v1/messages`:
+- response `content-type: text/event-stream`
+- SSE payload is OpenAI chat-completions chunks (`chat.completion.chunk`)
+
+### 8009 (`routstr-chat/scripts/routstr-daemon.ts`)
+
+Listener:
+- `scripts/routstr-daemon.ts`
+
+Observed result for `POST http://localhost:8009/v1/messages`:
+- response `content-type: text/event-stream`
+- SSE payload preserves Messages API events (`message_start`, `content_block_delta`, etc.)
+
+---
+
+## Direct cause
+
+### 8009 forwards the incoming path to the SDK
+
+In `routstr-chat/scripts/routstr-daemon.ts`, the request is routed with:
+
+```ts
+await routeRequestsToNodeResponse({
+  modelId,
+  requestBody,
+  path: url.pathname,
+  headers: forwardedHeaders,
+  ...
+});
+```
+
+Because it passes:
+
+```ts
+path: url.pathname
+```
+
+an incoming request to `/v1/messages` stays `/v1/messages` all the way through the SDK and upstream provider routing.
+
+### 8008 does **not** forward the incoming path
+
+In `../routstrd/src/daemon/http/index.ts`, the request is routed with:
+
+```ts
+const response = await routeRequests({
+  modelId,
+  requestBody,
+  forcedProvider,
+  headers: incomingHeaders,
+  walletAdapter: deps.walletAdapter,
+  storageAdapter: deps.storageAdapter,
+  providerRegistry: deps.providerRegistry,
+  discoveryAdapter: deps.discoveryAdapter,
+  modelManager: deps.modelManager,
+  debugLevel: "DEBUG",
+  mode: deps.mode,
+  usageTrackingDriver: deps.usageTrackingDriver,
+  sdkStore: deps.store,
+});
+```
+
+Notice: **no `path` is passed**.
+
+In the SDK, `routeRequests()` defaults the path to:
+
+```ts
+path = "/v1/chat/completions"
+```
+
+from:
+- `routstr-chat/sdk/routeRequests.ts`
+
+So even when the client calls:
+
+```http
+POST /v1/messages
+```
+
+on port 8008, the daemon internally re-routes it as:
+
+```http
+POST /v1/chat/completions
+```
+
+That is why the upstream/provider response is converted into chat-completions format.
+
+---
+
+## Why the behavior differs even though both are built on the same SDK
+
+Both daemons use the same SDK primitives, but:
+
+- **8009** uses `routeRequestsToNodeResponse(...)` and explicitly passes `path: url.pathname`
+- **8008** uses `routeRequests(...)` and relies on the SDK default path, which is `/v1/chat/completions`
+
+So the format difference is caused by **daemon integration code**, not by a provider-specific quirk and not by an unavoidable SDK conversion.
+
+---
+
+## Important implementation detail
+
+The SDK helper itself documents this default:
+
+- `routstr-chat/sdk/routeRequests.ts`
+
+```ts
+/** Optional: API path (defaults to /v1/chat/completions) */
+```
+
+and in `resolveRouteRequestContext(...)`:
+
+```ts
+path = "/v1/chat/completions"
+```
+
+Therefore any caller that omits `path` will get chat-completions semantics by default.
+
+---
+
+## Evidence from runtime tests
+
+### Port 8008
+
+Observed streamed chunks included:
+
+- `object: "chat.completion.chunk"`
+- `choices[0].delta.content`
+- final `[DONE]`
+
+### Port 8009
+
+Observed streamed events included:
+
+- `event: message_start`
+- `event: content_block_start`
+- `event: content_block_delta`
+- `event: message_delta`
+- `event: message_stop`
+- final `[DONE]`
+
+This matches the code-path difference above.
+
+---
+
+## Recommended fix
+
+In `../routstrd/src/daemon/http/index.ts`, pass the incoming path through to the SDK:
+
+```ts
+const response = await routeRequests({
+  modelId,
+  requestBody,
+  path: url.pathname,
+  forcedProvider,
+  headers: incomingHeaders,
+  walletAdapter: deps.walletAdapter,
+  storageAdapter: deps.storageAdapter,
+  providerRegistry: deps.providerRegistry,
+  discoveryAdapter: deps.discoveryAdapter,
+  modelManager: deps.modelManager,
+  debugLevel: "DEBUG",
+  mode: deps.mode,
+  usageTrackingDriver: deps.usageTrackingDriver,
+  sdkStore: deps.store,
+});
+```
+
+This should make `POST /v1/messages` on port 8008 preserve the Messages API format, matching port 8009.
+
+---
+
+## Secondary note
+
+Port 8008 currently uses `routeRequests(...)` and then manually streams the returned response body to `res`.
+Port 8009 uses `routeRequestsToNodeResponse(...)` directly.
+
+That difference is probably not the root cause here.
+The root cause is specifically that **8008 drops the incoming request path and falls back to the SDK default of `/v1/chat/completions`**.
+
+---
+
+## Conclusion
+
+The reason `localhost:8008/v1/messages` appears to "convert to chat completions" is:
+
+1. `../routstrd` receives `/v1/messages`
+2. its handler calls `routeRequests(...)` without `path`
+3. the SDK defaults `path` to `/v1/chat/completions`
+4. the upstream request is therefore made against chat completions
+5. the stream returned is chat-completions SSE, not Messages API SSE
+
+Port 8009 works because it explicitly forwards `url.pathname` into the SDK call.