routstrd 0.3.2 → 0.3.4

package/src/daemon/request-response-log-sink.ts

@@ -0,0 +1,269 @@
+import { createWriteStream, mkdirSync, type WriteStream } from "fs";
+import { writeFile } from "fs/promises";
+import { join } from "path";
+import type { SdkLogger } from "@routstr/sdk";
+
+export interface RequestResponseLogRequestInput {
+  method: string;
+  url: string;
+  path: string;
+  baseUrl: string;
+  headers: Record<string, string>;
+  body?: unknown;
+  rawBody?: string;
+}
+
+export interface RequestResponseLogSink {
+  logRequest?(input: RequestResponseLogRequestInput): string | undefined | Promise<string | undefined>;
+  logResponseStart?(id: string | undefined, response: Response): void | Promise<void>;
+  logResponseChunk?(id: string | undefined, sequence: number, text: string): void | Promise<void>;
+  logResponseEnd?(id: string | undefined): void | Promise<void>;
+  logResponseError?(id: string | undefined, error: unknown): void | Promise<void>;
+  logResponseBody?(id: string | undefined, response: Response): void | Promise<void>;
+}
+
+interface ActiveResponseLog {
+  stream: WriteStream;
+  pending: Promise<void>;
+}
+
+export interface FileRequestResponseLogSinkOptions {
+  dir: string;
+  logger?: SdkLogger;
+}
+
+const SENSITIVE_HEADER_NAMES = new Set([
+  "authorization",
+  "x-cashu",
+  "cookie",
+  "set-cookie",
+  "proxy-authorization",
+]);
+
+const SENSITIVE_BODY_FIELD_NAMES = new Set([
+  "authorization",
+  "api_key",
+  "apikey",
+  "apiKey",
+  "access_token",
+  "accessToken",
+  "bearer",
+  "cashu",
+  "cookie",
+  "key",
+  "password",
+  "secret",
+  "token",
+  "x-cashu",
+]);
+
+const REDACTED = "[REDACTED]";
+
+const sanitizeForFilename = (value: string): string =>
+  value.replace(/[^a-zA-Z0-9._-]+/g, "-").replace(/^-+|-+$/g, "");
+
+const makeId = (): string => {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const random = crypto.randomUUID().slice(0, 8);
+  return `${timestamp}-${random}`;
+};
+
+const headersToObject = (headers: Headers): Record<string, string> => {
+  const out: Record<string, string> = {};
+  headers.forEach((value, key) => {
+    out[key] = value;
+  });
+  return out;
+};
+
+const redactHeaders = (headers: Record<string, string>): Record<string, string> =>
+  Object.fromEntries(
+    Object.entries(headers).map(([key, value]) => [
+      key,
+      SENSITIVE_HEADER_NAMES.has(key.toLowerCase()) ? REDACTED : value,
+    ]),
+  );
+
+const redactBody = (value: unknown): unknown => {
+  if (!value || typeof value !== "object") return value;
+  if (Array.isArray(value)) return value.map(redactBody);
+
+  return Object.fromEntries(
+    Object.entries(value as Record<string, unknown>).map(([key, entry]) => [
+      key,
+      SENSITIVE_BODY_FIELD_NAMES.has(key) || SENSITIVE_BODY_FIELD_NAMES.has(key.toLowerCase())
+        ? REDACTED
+        : redactBody(entry),
+    ]),
+  );
+};
+
+const redactRawBody = (rawBody: string | undefined): string | undefined => {
+  if (!rawBody) return undefined;
+  try {
+    return JSON.stringify(redactBody(JSON.parse(rawBody)));
+  } catch {
+    return rawBody;
+  }
+};
+
+export class FileRequestResponseLogSink implements RequestResponseLogSink {
+  private requestsDir: string;
+  private responsesDir: string;
+  private activeResponses = new Map<string, ActiveResponseLog>();
+
+  constructor(private options: FileRequestResponseLogSinkOptions) {
+    this.requestsDir = join(options.dir, "requests");
+    this.responsesDir = join(options.dir, "responses");
+    mkdirSync(this.requestsDir, { recursive: true });
+    mkdirSync(this.responsesDir, { recursive: true });
+  }
+
+  async logRequest(input: RequestResponseLogRequestInput): Promise<string | undefined> {
+    try {
+      const id = makeId();
+      const filePath = join(this.requestsDir, `${sanitizeForFilename(id)}.json`);
+      await writeFile(
+        filePath,
+        JSON.stringify(
+          {
+            id,
+            timestamp: new Date().toISOString(),
+            method: input.method,
+            url: input.url,
+            path: input.path,
+            baseUrl: input.baseUrl,
+            headers: redactHeaders(input.headers),
+            body: redactBody(input.body),
+            rawBody: redactRawBody(input.rawBody),
+          },
+          null,
+          2,
+        ),
+      );
+      return id;
+    } catch (error) {
+      this.options.logger?.error?.("[request-response-log] failed to log request:", error);
+      return undefined;
+    }
+  }
+
+  async logResponseStart(id: string | undefined, response: Response): Promise<void> {
+    if (!id) return;
+    await this.append(id, {
+      type: "response_start",
+      status: response.status,
+      statusText: response.statusText,
+      headers: redactHeaders(headersToObject(response.headers)),
+    });
+  }
+
+  logResponseChunk(id: string | undefined, sequence: number, text: string): void {
+    if (!id) return;
+    void this.append(id, {
+      type: "chunk",
+      sequence,
+      text,
+    });
+  }
+
+  async logResponseEnd(id: string | undefined): Promise<void> {
+    if (!id) return;
+    await this.append(id, { type: "end" });
+    await this.close(id);
+  }
+
+  async logResponseError(id: string | undefined, error: unknown): Promise<void> {
+    if (!id) return;
+    await this.append(id, {
+      type: "error",
+      error: error instanceof Error ? { message: error.message, stack: error.stack } : String(error),
+    });
+    await this.close(id);
+  }
+
+  async logResponseBody(id: string | undefined, response: Response): Promise<void> {
+    if (!id) return;
+    try {
+      if (!response.body) {
+        await this.logResponseEnd(id);
+        return;
+      }
+
+      const reader = response.body.getReader();
+      const decoder = new TextDecoder("utf-8");
+      let sequence = 0;
+
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        if (value && value.byteLength > 0) {
+          await this.append(id, {
+            type: "chunk",
+            sequence: sequence++,
+            text: decoder.decode(value, { stream: true }),
+          });
+        }
+      }
+
+      const tail = decoder.decode();
+      if (tail) {
+        await this.append(id, {
+          type: "chunk",
+          sequence: sequence++,
+          text: tail,
+        });
+      }
+
+      await this.logResponseEnd(id);
+    } catch (error) {
+      await this.logResponseError(id, error);
+    }
+  }
+
+  private getOrCreate(id: string): ActiveResponseLog {
+    const existing = this.activeResponses.get(id);
+    if (existing) return existing;
+
+    const filePath = join(this.responsesDir, `${sanitizeForFilename(id)}.jsonl`);
+    const stream = createWriteStream(filePath, { flags: "a" });
+    const active: ActiveResponseLog = {
+      stream,
+      pending: Promise.resolve(),
+    };
+
+    stream.on("error", (error) => {
+      this.options.logger?.error?.("[request-response-log] response log stream error:", error);
+    });
+
+    this.activeResponses.set(id, active);
+    return active;
+  }
+
+  private async append(id: string, event: Record<string, unknown>): Promise<void> {
+    try {
+      const active = this.getOrCreate(id);
+      const line = JSON.stringify({ requestLogId: id, timestamp: new Date().toISOString(), ...event }) + "\n";
+      active.pending = active.pending.then(
+        () =>
+          new Promise<void>((resolve, reject) => {
+            active.stream.write(line, (error) => {
+              if (error) reject(error);
+              else resolve();
+            });
+          }),
+      );
+      await active.pending;
+    } catch (error) {
+      this.options.logger?.error?.("[request-response-log] failed to append response event:", error);
+    }
+  }
+
+  private async close(id: string): Promise<void> {
+    const active = this.activeResponses.get(id);
+    if (!active) return;
+    this.activeResponses.delete(id);
+    await active.pending;
+    await new Promise<void>((resolve) => active.stream.end(resolve));
+  }
+}

package/src/tui/usage/app.ts

@@ -1,6 +1,6 @@
 import { getVisibleTabs } from "./constants.ts";
 import type { Tab } from "./types.ts";
-import { fetchBalance, fetchClients, fetchStatus, fetchUsage, hasAnyNpubs, isDaemonRunning, type BalanceInfo, type ClientInfo, type StatusInfo } from "./data.ts";
+import { fetchBalance, fetchClients, fetchStatus, fetchUsageSummary, hasAnyNpubs, isDaemonRunning, type BalanceInfo, type ClientInfo, type StatusInfo } from "./data.ts";
 import {
   applyScrollToContent,
   exitSearchMode,
@@ -49,10 +49,9 @@ export async function runUsageTui(): Promise<void> {
   let clients: ClientInfo[] = [];
   let visibleTabs: Tab[] = getVisibleTabs(false);
   let refreshInterval: ReturnType<typeof setInterval> | null = null;
-  let shouldUpdate = true;
   let autoRefresh = true;
   let cleanedUp = false;
-  let rendering = false;
+  let fetching = false;
 
   if (isInteractive) {
     stdout.write(enterAlternateScreen() + hideCursor());
@@ -80,123 +79,141 @@ export async function runUsageTui(): Promise<void> {
   process.on("SIGINT", () => cleanup(0));
   process.on("SIGTERM", () => cleanup(0));
 
-  async function render(forceFetch = false) {
-    if (rendering) return;
-    rendering = true;
-
+  /**
+   * Background fetch — async, never blocks rendering. Updates the state
+   * variables only on success, then triggers a repaint. Overlapping calls
+   * are skipped via the `fetching` guard so we don't race stale results.
+   */
+  async function fetchData(): Promise<void> {
+    if (fetching) return;
+    fetching = true;
     try {
-      const width = getWidth();
-      const height = getHeight();
+      const running = await isDaemonRunning();
+      if (!running) {
+        stats = null;
+      } else {
+        // Fire all 4 fetches concurrently — cuts the blocked window significantly.
+        const [newStats, newBalance, newStatus, newClients] = await Promise.all([
+          fetchUsageSummary(),
+          fetchBalance(),
+          fetchStatus(),
+          fetchClients(),
+        ]);
+        if (newStats) stats = newStats;
+        if (newBalance) balance = newBalance;
+        if (newStatus) status = newStatus;
+        if (newClients && newClients.length > 0) clients = newClients;
 
-      if (forceFetch || shouldUpdate) {
-        stats = await fetchUsage(10000);
-        balance = await fetchBalance();
-        status = await fetchStatus();
-        clients = await fetchClients();
         const npubsVisible = hasAnyNpubs(clients);
         visibleTabs = getVisibleTabs(npubsVisible);
-        // If current tab is npubs but it's no longer visible, fall back to clients
         if (currentTab === "npubs" && !npubsVisible) {
           currentTab = "clients";
           vimState.scrollPos = 0;
         }
-        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;
       }
+      render();
+    } finally {
+      fetching = false;
+    }
+  }
 
-      const content = renderTabContent(currentTab, stats, balance, status, width, clients);
-      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, visibleTabs) + renderTabs(currentTab, visibleTabs) + 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;
+  /**
+   * Synchronous paint — never awaits I/O. Reads the current state variables
+   * and writes to stdout. Safe to call from key handlers without blocking.
+   */
+  function render(): void {
+    const width = getWidth();
+    const height = getHeight();
 
-      stdout.write(moveCursor(1, 1) + eraseDown() + chrome + visibleContent + footerBlock);
-    } finally {
-      rendering = 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, clients);
+    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, visibleTabs) + renderTabs(currentTab, visibleTabs) + 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);
   }
 
   const handleKey = (key: string) => {
     if (vimState.isSearching) {
       if (key === "\x1b" || key === "\x1b[3~") {
         exitSearchMode();
-        void render(false);
+        render();
         return;
       }
       if (key === "\r" || key === "\n") {
         if (stats?.entries) performSearch(vimState.searchQuery, stats.entries);
         exitSearchMode();
-        void render(false);
+        render();
         return;
       }
       if (key === "\x7f" || key === "\x08") {
         vimState.searchQuery = vimState.searchQuery.slice(0, -1);
         if (stats?.entries) performSearch(vimState.searchQuery, stats.entries);
-        void render(false);
+        render();
         return;
       }
       if (key === "\x03") {
         exitSearchMode();
-        void render(false);
+        render();
         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);
+        render();
       }
       return;
     }
 
     if (key === "q" || key === "Q" || key === "\u0003") return cleanup(0);
     if (key === "r" || key === "R") {
-      shouldUpdate = true;
-      void render(true);
+      void fetchData();
       return;
     }
     if (key === "a" || key === "A") {
       autoRefresh = !autoRefresh;
-      shouldUpdate = true;
-      void render(false);
+      render();
       return;
     }
 
     if (key === "j" || key === "\x1b[B" || key === "\x1bOB") {
       scrollDown();
-      void render(false);
+      render();
       return;
     }
     if (key === "k" || key === "\x1b[A" || key === "\x1bOA") {
       scrollUp();
-      void render(false);
+      render();
       return;
     }
     if (key === "l" || key === "\x1b[C" || key === "\x1bOC") {
       const currentIdx = visibleTabs.findIndex((t) => t.id === currentTab);
       currentTab = visibleTabs[(currentIdx + 1) % visibleTabs.length]!.id;
       vimState.scrollPos = 0;
-      void render(false);
+      render();
       return;
     }
     if (key === "h" || key === "\x1b[D" || key === "\x1bOD") {
       const currentIdx = visibleTabs.findIndex((t) => t.id === currentTab);
       currentTab = visibleTabs[(currentIdx - 1 + visibleTabs.length) % visibleTabs.length]!.id;
       vimState.scrollPos = 0;
-      void render(false);
+      render();
       return;
     }
 
@@ -204,54 +221,53 @@ export async function runUsageTui(): Promise<void> {
       if (vimState.lastKey === "g" && Date.now() - vimState.lastKeyTime < 300) {
         scrollToBottom();
         vimState.lastKey = "";
-        void render(false);
+        render();
         return;
       }
       vimState.lastKey = "g";
       vimState.lastKeyTime = Date.now();
       scrollToTop();
-      void render(false);
+      render();
       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 === "\x02") { pageUp(); render(); return; }
+    if (key === "\x06") { pageDown(); render(); return; }
+    if (key === "\x15") { scrollUp(10); render(); return; }
+    if (key === "\x04") { scrollDown(10); render(); return; }
+    if (key === "\x1b[H" || key === "\x1b[1~" || key === "\x1bOH") { scrollToTop(); render(); return; }
+    if (key === "\x1b[F" || key === "\x1b[4~" || key === "\x1bOF") { scrollToBottom(); render(); return; }
+    if (key === "/") { startSearch(false); render(); return; }
+    if (key === "?") { startSearch(true); render(); return; }
     if (key === "n") {
       if (vimState.searchReverse) prevSearchResult(stats?.entries.length || 0);
       else nextSearchResult(stats?.entries.length || 0);
-      void render(false);
+      render();
       return;
     }
     if (key === "N") {
       if (vimState.searchReverse) nextSearchResult(stats?.entries.length || 0);
       else prevSearchResult(stats?.entries.length || 0);
-      void render(false);
+      render();
       return;
     }
-    if (key === "\x1b") { scrollToTop(); void render(false); return; }
+    if (key === "\x1b") { scrollToTop(); render(); return; }
 
     const tab = visibleTabs.find((t) => t.key === key);
     if (tab) {
       currentTab = tab.id;
       vimState.scrollPos = 0;
-      void render(false);
+      render();
     }
   };
 
   if (isInteractive) stdin.on("data", handleKey);
 
-  await render(true);
+  await fetchData();
 
   refreshInterval = setInterval(() => {
     if (autoRefresh) {
-      shouldUpdate = true;
-      void render(true);
+      void fetchData();
     }
   }, 2000);
 }