routstrd 0.1.0

package/package.json

@@ -0,0 +1,34 @@
+{
+  "name": "routstrd",
+  "version": "0.1.0",
+  "module": "src/index.ts",
+  "type": "module",
+  "private": false,
+  "bin": {
+    "routstrd": "./dist/index.js"
+  },
+  "scripts": {
+    "start": "bun src/index.ts start",
+    "monitor": "bun src/index.ts monitor",
+    "lint": "tsc --noEmit",
+    "test": "bun test",
+    "build": "bun build src/index.ts --target=bun --outfile=dist/index.js",
+    "prepublishOnly": "bun run build"
+  },
+  "devDependencies": {
+    "@routstr/sdk": "../routstr-chat/sdk",
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5"
+  },
+  "dependencies": {
+    "@cashu/cashu-ts": "^3.1.1",
+    "@routstr/sdk": "^0.2.5",
+    "applesauce-core": "^5.1.0",
+    "applesauce-relay": "^5.1.0",
+    "commander": "^14.0.2",
+    "rxjs": "^7.8.1",
+    "zustand": "^5.0.5"
+  }
+}

package/routstr-cost-logging.md

@@ -0,0 +1,71 @@
+# routstr Proxy Cost Logging Issue
+
+## Problem
+
+The routstr proxy at `localhost:8009` returns usage data that differs slightly from what the pi-ai `openai-completions` provider expects.
+
+## What routstr Returns
+
+**Streaming response (last chunk):**
+```json
+{
+  "usage": {
+    "prompt_tokens": 9,
+    "completion_tokens": 9,
+    "total_tokens": 18,
+    "cost": 0.000018,
+    "prompt_tokens_details": {
+      "cached_tokens": 0,
+      "cache_write_tokens": 0
+    },
+    "completion_tokens_details": {
+      "reasoning_tokens": 0
+    }
+  },
+  "cost": {
+    "total_usd": 0.000018
+  }
+}
+```
+
+## What pi-ai Expects
+
+The `openai-completions` provider in pi-ai expects the standard OpenAI format:
+
+```json
+{
+  "usage": {
+    "prompt_tokens": 9,
+    "completion_tokens": 9,
+    "prompt_tokens_details": {
+      "cached_tokens": 0
+    },
+    "completion_tokens_details": {
+      "reasoning_tokens": 0
+    }
+  }
+}
+```
+
+## Current Handling
+
+The pi-ai provider already handles the standard format correctly via `parseChunkUsage()`:
+- `input` ← `prompt_tokens - cached_tokens`
+- `output` ← `completion_tokens + reasoning_tokens`
+- `cacheRead` ← `prompt_tokens_details.cached_tokens`
+- `cacheWrite` ← **NOT CURRENTLY PARSED** (hardcoded to 0)
+
+The provider then calculates cost using `calculateCost()` based on the model's configured cost per million tokens, ignoring any `cost` field from the response.
+
+## Gap
+
+The `parseChunkUsage()` function in `packages/ai/src/providers/openai-completions.ts` does not currently extract:
+1. `cache_write_tokens` from `prompt_tokens_details` (routstr-specific field)
+
+Currently `cacheWrite` is hardcoded to 0.
+
+## Resolution
+
+The existing pi-ai `openai-completions` provider should work with routstr as-is since routstr returns the standard OpenAI format fields. The usage should be logged correctly if:
+1. `stream_options: { include_usage: true }` is passed
+2. The model has a `cost` configuration in the registry

package/src/TUI refactor.md

@@ -0,0 +1,113 @@
+# TUI refactor plan
+
+## Goals
+- Move the usage TUI implementation out of `src/cli/usage-tui.ts` into a dedicated `src/tui/` folder.
+- Reduce the size and responsibility of the current monolithic file.
+- Keep the existing CLI entrypoint stable so current usage does not break.
+- Preserve behavior while making future TUI work easier.
+
+## Current state
+`src/cli/usage-tui.ts` currently mixes several concerns in one file:
+- TUI-specific types and constants
+- ANSI/terminal helpers
+- scroll/search/vim navigation state
+- data fetching from the daemon
+- usage aggregation/stat helpers
+- rendering for all tabs
+- app lifecycle and keyboard event handling
+
+This makes the file hard to extend safely.
+
+## Refactor strategy
+Do this incrementally and keep a thin compatibility wrapper in `src/cli/usage-tui.ts`.
+
+### Target structure
+- `src/tui/usage/index.ts`
+  - public entrypoint: `runUsageTui()`
+- `src/tui/usage/types.ts`
+  - `UsageStats`, tab ids, tab metadata, derived stat types
+- `src/tui/usage/constants.ts`
+  - tabs, colors, model/client color maps
+- `src/tui/usage/terminal.ts`
+  - ANSI helpers, width/height helpers, `stripAnsi`
+- `src/tui/usage/state.ts`
+  - vim/search/scroll state and state mutation helpers
+- `src/tui/usage/data.ts`
+  - `fetchUsage()` and usage aggregation helpers
+- `src/tui/usage/render.ts`
+  - shared render helpers and tab renderers
+- `src/tui/usage/app.ts`
+  - main loop, render orchestration, input handling, cleanup
+- `src/cli/usage-tui.ts`
+  - compatibility wrapper that re-exports or calls `runUsageTui()` from `src/tui/usage`
+
+## Design choices
+### 1. Keep CLI path compatibility
+Do not delete the CLI file outright. Turn it into a tiny wrapper:
+- minimal import from `../tui/usage/index.ts`
+- export `runUsageTui()`
+
+This avoids breaking any existing imports or scripts.
+
+### 2. Separate pure logic from side effects
+Keep these pure where possible:
+- aggregation helpers
+- formatting helpers
+- render helpers that return strings
+- scroll clamping logic
+
+Keep side effects isolated in the app layer:
+- reading terminal size
+- writing to stdout
+- raw mode setup
+- signal handling
+- interval scheduling
+
+### 3. Avoid over-engineering
+This should be a pragmatic refactor, not a framework:
+- no unnecessary classes
+- keep function-based design
+- only extract modules around clear responsibility boundaries
+
+### 4. Preserve behavior first
+No UX changes unless needed to support the extraction.
+That means:
+- same tabs
+- same keybindings
+- same output format
+- same fetch cadence
+- same search/scroll behavior
+
+## Implementation steps
+1. Create `src/tui/usage/`.
+2. Extract types/constants first.
+3. Extract terminal helpers.
+4. Extract data fetching + aggregation helpers.
+5. Extract state/search/scroll logic.
+6. Extract rendering helpers + tab renderers.
+7. Build `app.ts` using the extracted modules.
+8. Replace `src/cli/usage-tui.ts` with a thin wrapper.
+9. Run a TypeScript/bun check and fix imports.
+10. Smoke-test keyboard handling and rendering behavior.
+
+## Risks
+- circular imports between render/state/constants
+- broken relative import paths during extraction
+- subtle behavior regressions in scroll/search state
+- terminal escape handling differences if helpers are split carelessly
+
+## Validation checklist
+- `src/cli/usage-tui.ts` still exposes `runUsageTui()`
+- TUI starts from the same CLI path
+- scroll still works for long content
+- vim keys still work
+- arrow keys still work
+- tab switching still resets scroll
+- search mode still works
+- cleanup still restores cursor and alternate screen
+
+## Non-goals
+- redesigning the UI
+- changing tab contents
+- introducing tests unless needed for safety
+- adding new features unrelated to the refactor

package/src/cli-shared.ts

@@ -0,0 +1,204 @@
+import { program } from "commander";
+import { existsSync } from "fs";
+import {
+  CONFIG_FILE,
+  DEFAULT_CONFIG,
+  LOG_FILE,
+  type RoutstrdConfig,
+} from "./utils/config";
+
+export interface CommandResponse {
+  output?: unknown;
+  error?: string;
+}
+
+export async function loadConfig(): Promise<RoutstrdConfig> {
+  try {
+    if (existsSync(CONFIG_FILE)) {
+      const content = await Bun.file(CONFIG_FILE).text();
+      return { ...DEFAULT_CONFIG, ...JSON.parse(content) };
+    }
+  } catch (error) {
+    console.error("Failed to load config:", error);
+  }
+  return DEFAULT_CONFIG;
+}
+
+async function callDaemon(
+  path: string,
+  options: { method?: "GET" | "POST"; body?: object } = {},
+): Promise<CommandResponse> {
+  const { method = "GET", body } = options;
+  const config = await loadConfig();
+
+  const response = await fetch(`http://localhost:${config.port}${path}`, {
+    method,
+    headers: body ? { "Content-Type": "application/json" } : {},
+    body: body ? JSON.stringify(body) : undefined,
+  });
+
+  if (!response.ok) {
+    const errorData = (await response.json()) as { error?: string };
+    throw new Error(errorData.error || `HTTP ${response.status}`);
+  }
+
+  return response.json() as Promise<CommandResponse>;
+}
+
+export async function isDaemonRunning(): Promise<boolean> {
+  try {
+    const config = await loadConfig();
+    const response = await fetch(`http://localhost:${config.port}/health`);
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
+export async function startDaemonProcess(): Promise<void> {
+  const logFile = Bun.file(LOG_FILE);
+
+  const proc = Bun.spawn([
+    "bun", "run", `${import.meta.dir}/daemon/index.ts`
+  ], {
+    stdout: logFile,
+    stderr: logFile,
+    stdin: "ignore",
+    detached: true,
+  });
+  
+  proc.unref();
+
+  for (let i = 0; i < 50; i++) {
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    if (await isDaemonRunning()) {
+      return;
+    }
+  }
+
+  throw new Error("Daemon failed to start within 5 seconds");
+}
+
+export async function ensureDaemonRunning(): Promise<void> {
+  if (await isDaemonRunning()) {
+    return;
+  }
+
+  console.log("Starting daemon...");
+  await startDaemonProcess();
+}
+
+export async function handleDaemonCommand(
+  path: string,
+  options: { method?: "GET" | "POST"; body?: object } = {},
+): Promise<CommandResponse> {
+  try {
+    await ensureDaemonRunning();
+    const result = await callDaemon(path, options);
+
+    if (result.error) {
+      console.log(result.error);
+      process.exit(1);
+    }
+
+    if (result.output !== undefined) {
+      if (typeof result.output === "string") {
+        console.log(result.output);
+      } else {
+        try {
+          const formatted = JSON.stringify(result.output, null, 2);
+          console.log(formatted ?? String(result.output));
+        } catch {
+          console.log(String(result.output));
+        }
+      }
+    }
+
+    return result;
+  } catch (error) {
+    const message = (error as Error).message;
+    if (message?.includes("fetch failed") || message?.includes("Connection refused")) {
+      console.error("Daemon is not running and failed to auto-start");
+      process.exit(1);
+    }
+    console.error(message);
+    process.exit(1);
+  }
+}
+
+export { program, callDaemon };
+
+program
+  .command("refund")
+  .description("Refund pending tokens and API keys to a specified mint")
+  .option("-m, --mint-url <mintUrl>", "Mint URL to refund to (defaults to first mint in wallet)")
+  .option("-y, --yes", "Skip confirmation prompt", false)
+  .action(async (options: { mintUrl?: string; yes: boolean }) => {
+    const config = await loadConfig();
+
+    let mintUrl = options.mintUrl;
+    if (!mintUrl) {
+      const balanceResponse = await fetch(`http://localhost:${config.port}/balance`);
+      const balanceResult = (await balanceResponse.json()) as {
+        output?: { balances?: Record<string, number> };
+        error?: string;
+      };
+      if (balanceResult.error) {
+        console.log(balanceResult.error);
+        process.exit(1);
+      }
+      const balances = balanceResult.output?.balances;
+      if (!balances || Object.keys(balances).length === 0) {
+        console.log("No mint URLs found in wallet balance");
+        process.exit(1);
+      }
+      mintUrl = Object.keys(balances)[0];
+      console.log(`Using mint URL: ${mintUrl}`);
+    }
+
+    try {
+      const response = await fetch(`http://localhost:${config.port}/refund`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ mintUrl }),
+      });
+
+      if (!response.ok) {
+        const errorData = (await response.json()) as { error?: string };
+        throw new Error(errorData.error || `HTTP ${response.status}`);
+      }
+
+      const result = (await response.json()) as {
+        output?: {
+          message: string;
+          pendingTokens: number;
+          apiKeys: number;
+          results: Array<{ baseUrl: string; success: boolean }>;
+        };
+        error?: string;
+      };
+
+      if (result.error) {
+        console.log(result.error);
+        process.exit(1);
+      }
+
+      if (result.output) {
+        console.log(result.output.message);
+        console.log(`\nPending tokens: ${result.output.pendingTokens}`);
+        console.log(`API keys: ${result.output.apiKeys}`);
+        console.log("\nResults:");
+        for (const r of result.output.results) {
+          console.log(`  - ${r.baseUrl}: ${r.success ? "success" : "failed"}`);
+        }
+      }
+    } catch (error) {
+      const message = (error as Error).message;
+      if (message?.includes("fetch failed") || message?.includes("Connection refused")) {
+        console.error("Daemon is not running");
+        process.exit(1);
+      }
+      console.error(message);
+      process.exit(1);
+    }
+  });