routstrd 0.1.0

package/src/tui/usage/app.ts

@@ -0,0 +1,247 @@
+import { TABS } from "./constants.ts";
+import { fetchBalance, fetchStatus, fetchUsage, type BalanceInfo, type StatusInfo } from "./data.ts";
+import {
+  applyScrollToContent,
+  exitSearchMode,
+  nextSearchResult,
+  pageDown,
+  pageUp,
+  performSearch,
+  prevSearchResult,
+  scrollDown,
+  scrollToBottom,
+  scrollToTop,
+  scrollUp,
+  startSearch,
+  vimState,
+} from "./state.ts";
+import {
+  enterAlternateScreen,
+  eraseDown,
+  getHeight,
+  getWidth,
+  hideCursor,
+  leaveAlternateScreen,
+  moveCursor,
+  showCursor,
+} from "./terminal.ts";
+import { COLORS } from "./constants.ts";
+import { renderHeader, renderSearchBar, renderSeparator, renderTabContent, renderTabs } from "./render.ts";
+import type { TabId, UsageStats } from "./types.ts";
+import { isDaemonRunning } from "../../cli-shared.ts";
+
+export async function runUsageTui(): Promise<void> {
+  const running = await isDaemonRunning();
+  if (!running) {
+    console.log(`${COLORS.red}Error: routstrd daemon is not running.${COLORS.reset}`);
+    console.log(`Run ${COLORS.green}routstrd start${COLORS.reset} first.`);
+    process.exit(1);
+  }
+
+  const stdin = process.stdin;
+  const stdout = process.stdout;
+  const isInteractive = Boolean(stdout.isTTY && stdin.isTTY);
+
+  let currentTab: TabId = "overview";
+  let stats: UsageStats | null = null;
+  let balance: BalanceInfo | null = null;
+  let status: StatusInfo | null = null;
+  let refreshInterval: ReturnType<typeof setInterval> | null = null;
+  let shouldUpdate = true;
+  let autoRefresh = true;
+  let cleanedUp = false;
+  let rendering = false;
+
+  if (isInteractive) {
+    stdout.write(enterAlternateScreen() + hideCursor());
+    stdin.setRawMode?.(true);
+    stdin.resume();
+    stdin.setEncoding("utf-8");
+  }
+
+  function cleanup(exitCode = 0) {
+    if (cleanedUp) return;
+    cleanedUp = true;
+    if (refreshInterval) clearInterval(refreshInterval);
+
+    if (isInteractive) {
+      stdin.setRawMode?.(false);
+      stdin.pause();
+      stdout.write(showCursor() + leaveAlternateScreen());
+    } else {
+      stdout.write(showCursor());
+    }
+
+    process.exit(exitCode);
+  }
+
+  process.on("SIGINT", () => cleanup(0));
+  process.on("SIGTERM", () => cleanup(0));
+
+  async function render(forceFetch = false) {
+    if (rendering) return;
+    rendering = true;
+
+    try {
+      const width = getWidth();
+      const height = getHeight();
+
+      if (forceFetch || shouldUpdate) {
+        stats = await fetchUsage(1000);
+        balance = await fetchBalance();
+        status = await fetchStatus();
+        shouldUpdate = false;
+      }
+
+      if (!stats) {
+        stdout.write(
+          moveCursor(1, 1) +
+          eraseDown() +
+          `${COLORS.red}Error: Could not fetch usage data.${COLORS.reset}\n` +
+          `Make sure routstrd is running.\n` +
+          `\nPress Q to quit.`
+        );
+        return;
+      }
+
+      const content = renderTabContent(currentTab, stats, balance, status, width);
+      const footer = `${COLORS.dim}Press [Q] to quit, [R] to refresh, [A] to toggle auto-refresh${autoRefresh ? " (on)" : " (off)"}  scroll:${vimState.scrollPos}${COLORS.reset}${vimState.mode === "normal" ? `  ${COLORS.yellow}vim: hjkl/arrows, / search, g top, gg bottom${COLORS.reset}` : ""}`;
+      const chrome = renderHeader(currentTab, width) + renderTabs(currentTab) + renderSeparator(width) + renderSearchBar();
+      const chromeLines = chrome.split("\n").length - 1;
+      const footerSeparator = renderSeparator(width);
+      const footerLines = footerSeparator.split("\n").length - 1;
+      const contentViewportHeight = Math.max(1, height - chromeLines - footerLines - 1);
+      const visibleContent = applyScrollToContent(content, contentViewportHeight);
+      const footerBlock = (visibleContent ? "\n" : "") + footerSeparator + footer;
+
+      stdout.write(moveCursor(1, 1) + eraseDown() + chrome + visibleContent + footerBlock);
+    } finally {
+      rendering = false;
+    }
+  }
+
+  const handleKey = (key: string) => {
+    if (vimState.isSearching) {
+      if (key === "\x1b" || key === "\x1b[3~") {
+        exitSearchMode();
+        void render(false);
+        return;
+      }
+      if (key === "\r" || key === "\n") {
+        if (stats?.entries) performSearch(vimState.searchQuery, stats.entries);
+        exitSearchMode();
+        void render(false);
+        return;
+      }
+      if (key === "\x7f" || key === "\x08") {
+        vimState.searchQuery = vimState.searchQuery.slice(0, -1);
+        if (stats?.entries) performSearch(vimState.searchQuery, stats.entries);
+        void render(false);
+        return;
+      }
+      if (key === "\x03") {
+        exitSearchMode();
+        void render(false);
+        return;
+      }
+      if (key.length === 1 && key.charCodeAt(0) >= 32 && key.charCodeAt(0) < 127) {
+        vimState.searchQuery += key;
+        if (stats?.entries) performSearch(vimState.searchQuery, stats.entries);
+        void render(false);
+      }
+      return;
+    }
+
+    if (key === "q" || key === "Q" || key === "\u0003") return cleanup(0);
+    if (key === "r" || key === "R") {
+      shouldUpdate = true;
+      void render(true);
+      return;
+    }
+    if (key === "a" || key === "A") {
+      autoRefresh = !autoRefresh;
+      shouldUpdate = true;
+      void render(false);
+      return;
+    }
+
+    if (key === "j" || key === "\x1b[B" || key === "\x1bOB") {
+      scrollDown();
+      void render(false);
+      return;
+    }
+    if (key === "k" || key === "\x1b[A" || key === "\x1bOA") {
+      scrollUp();
+      void render(false);
+      return;
+    }
+    if (key === "l" || key === "\x1b[C" || key === "\x1bOC") {
+      const currentIdx = TABS.findIndex((t) => t.id === currentTab);
+      currentTab = TABS[(currentIdx + 1) % TABS.length]!.id;
+      vimState.scrollPos = 0;
+      void render(false);
+      return;
+    }
+    if (key === "h" || key === "\x1b[D" || key === "\x1bOD") {
+      const currentIdx = TABS.findIndex((t) => t.id === currentTab);
+      currentTab = TABS[(currentIdx - 1 + TABS.length) % TABS.length]!.id;
+      vimState.scrollPos = 0;
+      void render(false);
+      return;
+    }
+
+    if (key === "g") {
+      if (vimState.lastKey === "g" && Date.now() - vimState.lastKeyTime < 300) {
+        scrollToBottom();
+        vimState.lastKey = "";
+        void render(false);
+        return;
+      }
+      vimState.lastKey = "g";
+      vimState.lastKeyTime = Date.now();
+      scrollToTop();
+      void render(false);
+      return;
+    }
+
+    if (key === "\x02") { pageUp(); void render(false); return; }
+    if (key === "\x06") { pageDown(); void render(false); return; }
+    if (key === "\x15") { scrollUp(10); void render(false); return; }
+    if (key === "\x04") { scrollDown(10); void render(false); return; }
+    if (key === "\x1b[H" || key === "\x1b[1~" || key === "\x1bOH") { scrollToTop(); void render(false); return; }
+    if (key === "\x1b[F" || key === "\x1b[4~" || key === "\x1bOF") { scrollToBottom(); void render(false); return; }
+    if (key === "/") { startSearch(false); void render(false); return; }
+    if (key === "?") { startSearch(true); void render(false); return; }
+    if (key === "n") {
+      if (vimState.searchReverse) prevSearchResult(stats?.entries.length || 0);
+      else nextSearchResult(stats?.entries.length || 0);
+      void render(false);
+      return;
+    }
+    if (key === "N") {
+      if (vimState.searchReverse) nextSearchResult(stats?.entries.length || 0);
+      else prevSearchResult(stats?.entries.length || 0);
+      void render(false);
+      return;
+    }
+    if (key === "\x1b") { scrollToTop(); void render(false); return; }
+
+    const tab = TABS.find((t) => t.key === key);
+    if (tab) {
+      currentTab = tab.id;
+      vimState.scrollPos = 0;
+      void render(false);
+    }
+  };
+
+  if (isInteractive) stdin.on("data", handleKey);
+
+  await render(true);
+
+  refreshInterval = setInterval(() => {
+    if (autoRefresh) {
+      shouldUpdate = true;
+      void render(true);
+    }
+  }, 2000);
+}

package/src/tui/usage/constants.ts

@@ -0,0 +1,42 @@
+import type { Tab } from "./types.ts";
+
+export const TABS: Tab[] = [
+  { id: "overview", name: "Overview", key: "1" },
+  { id: "today", name: "Today", key: "2" },
+  { id: "models", name: "Models", key: "3" },
+  { id: "providers", name: "Providers", key: "4" },
+  { id: "tokens", name: "Tokens", key: "5" },
+  { id: "clients", name: "Clients", key: "6" },
+  { id: "recent", name: "Recent", key: "7" },
+];
+
+export const COLORS = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  red: "\x1b[31m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  blue: "\x1b[34m",
+  magenta: "\x1b[35m",
+  cyan: "\x1b[36m",
+  white: "\x1b[37m",
+  bgBlue: "\x1b[44m",
+  bgGreen: "\x1b[42m",
+  bgYellow: "\x1b[43m",
+  bright: "\x1b[1m",
+};
+
+export const MODEL_COLORS: Record<string, string> = {
+  "gpt-5.4": COLORS.magenta,
+  "minimax-m2.7": COLORS.cyan,
+  default: COLORS.white,
+};
+
+export const CLIENT_COLORS: Record<string, string> = {
+  opencode: COLORS.blue,
+  openclaw: COLORS.green,
+  "pi-agent": COLORS.yellow,
+  unknown: COLORS.dim,
+  default: COLORS.white,
+};

package/src/tui/usage/data.ts

@@ -0,0 +1,228 @@
+import type { UsageTrackingEntry } from "../../daemon/types.ts";
+import { callDaemon, isDaemonRunning } from "../../cli-shared.ts";
+import type { ClientStats, DayStats, ModelStats, ProviderStats, UsageStats } from "./types.ts";
+
+export interface BalanceKey {
+  id: string;
+  name: string;
+  balance: number;
+}
+
+export interface BalanceInfo {
+  keys: BalanceKey[];
+  total: number;
+  unit: "sat";
+  apikeysCalled: number;
+}
+
+export interface StatusInfo {
+  daemon: string;
+  wallet: string;
+  mode: "xcashu" | "apikeys";
+  error?: string;
+}
+
+export async function fetchStatus(): Promise<StatusInfo | null> {
+  try {
+    const running = await isDaemonRunning();
+    if (!running) return null;
+
+    const result = await callDaemon("/status");
+    if (result.error) return null;
+
+    const output = result.output as {
+      daemon?: string;
+      wallet?: string;
+      mode?: "xcashu" | "apikeys";
+      error?: string;
+    };
+
+    return {
+      daemon: output?.daemon || "unknown",
+      wallet: output?.wallet || "unknown",
+      mode: output?.mode || "apikeys",
+      error: output?.error,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export async function fetchBalance(): Promise<BalanceInfo | null> {
+  try {
+    const running = await isDaemonRunning();
+    if (!running) return null;
+
+    const result = await callDaemon("/keys/balance");
+    if (result.error) return null;
+
+    const output = result.output as {
+      keys?: BalanceKey[];
+      total?: number;
+      unit?: string;
+      apikeysCalled?: number;
+    };
+
+    return {
+      keys: output?.keys || [],
+      total: output?.total || 0,
+      unit: (output?.unit as "sat") || "sat",
+      apikeysCalled: output?.apikeysCalled || 0,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export async function fetchUsage(limit = 1000): Promise<UsageStats | null> {
+  try {
+    const running = await isDaemonRunning();
+    if (!running) return null;
+
+    const result = await callDaemon(`/usage?limit=${limit}`);
+    if (result.error) return null;
+
+    const output = result.output as {
+      entries?: UsageTrackingEntry[];
+      totalEntries?: number;
+      totalSatsCost?: number;
+      recentSatsCost?: number;
+      limit?: number;
+    };
+
+    return {
+      entries: output?.entries || [],
+      totalEntries: output?.totalEntries || 0,
+      totalSatsCost: output?.totalSatsCost || 0,
+      recentSatsCost: output?.recentSatsCost || 0,
+      limit: output?.limit || limit,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export function getTodayStart(): number {
+  const now = new Date();
+  return new Date(now.getFullYear(), now.getMonth(), now.getDate()).getTime();
+}
+
+export function formatDate(timestamp: number): string {
+  return new Date(timestamp).toISOString().split("T")[0] ?? "";
+}
+
+export function formatTime(timestamp: number): string {
+  return new Date(timestamp).toISOString().split("T")[1]?.slice(0, 8) ?? "";
+}
+
+export function formatNumber(n: number): string {
+  if (n >= 1_000_000) return (n / 1_000_000).toFixed(1) + "M";
+  if (n >= 1_000) return (n / 1_000).toFixed(1) + "K";
+  return n.toString();
+}
+
+export function getDayStats(entries: UsageTrackingEntry[]): Map<string, DayStats> {
+  const days = new Map<string, DayStats>();
+  for (const entry of entries) {
+    const date = formatDate(entry.timestamp);
+    const existing = days.get(date) || { date, requests: 0, satsCost: 0, promptTokens: 0, completionTokens: 0, totalTokens: 0 };
+    days.set(date, {
+      ...existing,
+      requests: existing.requests + 1,
+      satsCost: existing.satsCost + entry.satsCost,
+      promptTokens: existing.promptTokens + entry.promptTokens,
+      completionTokens: existing.completionTokens + entry.completionTokens,
+      totalTokens: existing.totalTokens + entry.totalTokens,
+    });
+  }
+  return days;
+}
+
+export function getHourlyToday(entries: UsageTrackingEntry[]): Map<number, DayStats> {
+  const todayStart = getTodayStart();
+  const hours = new Map<number, DayStats>();
+  for (const entry of entries) {
+    if (entry.timestamp < todayStart) continue;
+    const hour = new Date(entry.timestamp).getHours();
+    const existing = hours.get(hour) || {
+      date: formatDate(entry.timestamp), requests: 0, satsCost: 0, promptTokens: 0, completionTokens: 0, totalTokens: 0,
+    };
+    hours.set(hour, {
+      ...existing,
+      requests: existing.requests + 1,
+      satsCost: existing.satsCost + entry.satsCost,
+      promptTokens: existing.promptTokens + entry.promptTokens,
+      completionTokens: existing.completionTokens + entry.completionTokens,
+      totalTokens: existing.totalTokens + entry.totalTokens,
+    });
+  }
+  return hours;
+}
+
+export function getModelStats(entries: UsageTrackingEntry[]): ModelStats[] {
+  const models = new Map<string, ModelStats>();
+  for (const entry of entries) {
+    const existing = models.get(entry.modelId) || {
+      modelId: entry.modelId, requests: 0, satsCost: 0, promptTokens: 0, completionTokens: 0, totalTokens: 0,
+    };
+    models.set(entry.modelId, {
+      ...existing,
+      requests: existing.requests + 1,
+      satsCost: existing.satsCost + entry.satsCost,
+      promptTokens: existing.promptTokens + entry.promptTokens,
+      completionTokens: existing.completionTokens + entry.completionTokens,
+      totalTokens: existing.totalTokens + entry.totalTokens,
+    });
+  }
+  return Array.from(models.values()).sort((a, b) => b.satsCost - a.satsCost);
+}
+
+export function getProviderStats(entries: UsageTrackingEntry[]): ProviderStats[] {
+  const providers = new Map<string, ProviderStats>();
+  for (const entry of entries) {
+    const url = entry.baseUrl || "unknown";
+    const existing = providers.get(url) || {
+      baseUrl: url, requests: 0, satsCost: 0, promptTokens: 0, completionTokens: 0, totalTokens: 0,
+    };
+    providers.set(url, {
+      ...existing,
+      requests: existing.requests + 1,
+      satsCost: existing.satsCost + entry.satsCost,
+      promptTokens: existing.promptTokens + entry.promptTokens,
+      completionTokens: existing.completionTokens + entry.completionTokens,
+      totalTokens: existing.totalTokens + entry.totalTokens,
+    });
+  }
+  return Array.from(providers.values()).sort((a, b) => b.satsCost - a.satsCost);
+}
+
+export function getClientStats(entries: UsageTrackingEntry[]): ClientStats[] {
+  const clients = new Map<string, ClientStats>();
+  for (const entry of entries) {
+    const client = entry.client || "unknown";
+    const existing = clients.get(client) || {
+      client, requests: 0, satsCost: 0, promptTokens: 0, completionTokens: 0, totalTokens: 0,
+    };
+    clients.set(client, {
+      ...existing,
+      requests: existing.requests + 1,
+      satsCost: existing.satsCost + entry.satsCost,
+      promptTokens: existing.promptTokens + entry.promptTokens,
+      completionTokens: existing.completionTokens + entry.completionTokens,
+      totalTokens: existing.totalTokens + entry.totalTokens,
+    });
+  }
+  return Array.from(clients.values()).sort((a, b) => b.satsCost - a.satsCost);
+}
+
+export function getTotals(entries: UsageTrackingEntry[]) {
+  return entries.reduce(
+    (acc, entry) => ({
+      promptTokens: acc.promptTokens + entry.promptTokens,
+      completionTokens: acc.completionTokens + entry.completionTokens,
+      totalTokens: acc.totalTokens + entry.totalTokens,
+      satsCost: acc.satsCost + entry.satsCost,
+    }),
+    { promptTokens: 0, completionTokens: 0, totalTokens: 0, satsCost: 0 }
+  );
+}

package/src/tui/usage/index.ts

@@ -0,0 +1 @@
+export { runUsageTui } from "./app.ts";