@routstr/cocod 0.0.16

package/src/logs.test.ts

@@ -0,0 +1,54 @@
+import { mkdtemp, rename, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { describe, expect, test } from "bun:test";
+
+import { followLogFile, parseLogLineCount, tailLogLines } from "./logs";
+
+describe("logs helpers", () => {
+  test("tailLogLines returns the requested trailing lines", () => {
+    expect(tailLogLines("one\ntwo\nthree\n", 2)).toBe("two\nthree\n");
+    expect(tailLogLines("one\ntwo\nthree", 1)).toBe("three");
+  });
+
+  test("parseLogLineCount requires a positive integer", () => {
+    expect(parseLogLineCount("25")).toBe(25);
+    expect(() => parseLogLineCount("0")).toThrow("--lines must be a positive integer");
+    expect(() => parseLogLineCount("2x")).toThrow("--lines must be a positive integer");
+  });
+
+  test("followLogFile continues after log rotation", async () => {
+    const dir = await mkdtemp(join(tmpdir(), "cocod-logs-"));
+    const logFile = join(dir, "daemon.log");
+    await writeFile(logFile, "one\n", "utf8");
+
+    const controller = new AbortController();
+    const chunks: string[] = [];
+    const followPromise = followLogFile(
+      logFile,
+      (chunk) => {
+        chunks.push(chunk);
+        controller.abort();
+      },
+      {
+        startPosition: Buffer.byteLength("one\n"),
+        pollIntervalMs: 10,
+        signal: controller.signal,
+      },
+    );
+
+    await Bun.sleep(20);
+    await rename(logFile, `${logFile}.1`);
+    await writeFile(logFile, "two\n", "utf8");
+
+    await Promise.race([
+      followPromise,
+      Bun.sleep(500).then(() => {
+        throw new Error("Timed out waiting for followed log output");
+      }),
+    ]);
+
+    expect(chunks).toEqual(["two\n"]);
+  });
+});

package/src/logs.ts

@@ -0,0 +1,118 @@
+import { stat } from "node:fs/promises";
+
+export const DEFAULT_LOG_LINES = 50;
+const DEFAULT_POLL_INTERVAL_MS = 250;
+
+interface FollowLogOptions {
+  startPosition?: number;
+  pollIntervalMs?: number;
+  signal?: AbortSignal;
+}
+
+function isNotFoundError(error: unknown): boolean {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+
+export function parseLogLineCount(value: string): number {
+  if (!/^\d+$/.test(value)) {
+    throw new Error("--lines must be a positive integer");
+  }
+
+  const lineCount = Number.parseInt(value, 10);
+
+  if (!Number.isInteger(lineCount) || lineCount < 1) {
+    throw new Error("--lines must be a positive integer");
+  }
+
+  return lineCount;
+}
+
+export function tailLogLines(content: string, lineCount: number): string {
+  if (content.length === 0) {
+    return "";
+  }
+
+  const hasTrailingNewline = content.endsWith("\n");
+  const normalizedContent = hasTrailingNewline ? content.slice(0, -1) : content;
+
+  if (normalizedContent.length === 0) {
+    return content;
+  }
+
+  const lines = normalizedContent.split("\n");
+  const tailedContent = lines.slice(-lineCount).join("\n");
+
+  return hasTrailingNewline ? `${tailedContent}\n` : tailedContent;
+}
+
+export async function readRecentLogText(filePath: string, lineCount: number): Promise<string> {
+  const file = Bun.file(filePath);
+
+  if (!(await file.exists())) {
+    throw new Error(`Log file not found: ${filePath}`);
+  }
+
+  return tailLogLines(await file.text(), lineCount);
+}
+
+export async function getLogFileSize(filePath: string): Promise<number> {
+  try {
+    return (await stat(filePath)).size;
+  } catch (error) {
+    if (isNotFoundError(error)) {
+      return 0;
+    }
+
+    throw error;
+  }
+}
+
+export async function followLogFile(
+  filePath: string,
+  onChunk: (chunk: string) => void,
+  options: FollowLogOptions = {},
+): Promise<void> {
+  const { startPosition = 0, pollIntervalMs = DEFAULT_POLL_INTERVAL_MS, signal } = options;
+  let position = startPosition;
+  let inode: number | undefined;
+
+  while (!signal?.aborted) {
+    let currentSize = 0;
+
+    try {
+      const fileStat = await stat(filePath);
+      currentSize = fileStat.size;
+
+      if (inode !== undefined && fileStat.ino !== inode) {
+        position = 0;
+      }
+
+      inode = fileStat.ino;
+    } catch (error) {
+      if (isNotFoundError(error)) {
+        inode = undefined;
+        position = 0;
+        await Bun.sleep(pollIntervalMs);
+        continue;
+      }
+
+      throw error;
+    }
+
+    if (currentSize < position) {
+      position = 0;
+    }
+
+    if (currentSize > position) {
+      const chunk = await Bun.file(filePath).slice(position, currentSize).text();
+
+      if (chunk.length > 0) {
+        onChunk(chunk);
+      }
+
+      position = currentSize;
+    }
+
+    await Bun.sleep(pollIntervalMs);
+  }
+}

package/src/routes.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, test } from "bun:test";
+
+import { createRouteHandlers } from "./routes";
+import { DaemonStateManager } from "./utils/state";
+
+describe("routes", () => {
+  test("/init validates invalid mnemonic", async () => {
+    const stateManager = new DaemonStateManager();
+    const routes = createRouteHandlers(stateManager);
+
+    const response = await routes["/init"]!.POST!(
+      new Request("http://localhost/init", {
+        method: "POST",
+        body: JSON.stringify({ mnemonic: "invalid mnemonic" }),
+      }),
+      stateManager.getState(),
+    );
+
+    const body = (await response.json()) as { error?: string };
+    expect(response.status).toBe(400);
+    expect(body.error).toBe("Invalid mnemonic");
+  });
+
+  test("/unlock requires passphrase", async () => {
+    const stateManager = new DaemonStateManager();
+    stateManager.setLocked("encrypted", "https://mint.example.com");
+    const routes = createRouteHandlers(stateManager);
+
+    const response = await routes["/unlock"]!.POST!(
+      new Request("http://localhost/unlock", {
+        method: "POST",
+        body: JSON.stringify({}),
+      }),
+      stateManager.getState(),
+    );
+
+    const body = (await response.json()) as { error?: string };
+    expect(response.status).toBe(400);
+    expect(body.error).toBe("Passphrase required");
+  });
+
+  test("/x-cashu/parse requires request field", async () => {
+    const stateManager = new DaemonStateManager();
+    const fakeManager = {} as unknown as import("coco-cashu-core").Manager;
+    stateManager.setUnlocked(fakeManager, "https://mint.example.com", new Uint8Array([1, 2, 3]));
+    const routes = createRouteHandlers(stateManager);
+
+    const response = await routes["/x-cashu/parse"]!.POST!(
+      new Request("http://localhost/x-cashu/parse", {
+        method: "POST",
+        body: JSON.stringify({}),
+      }),
+      stateManager.getState(),
+    );
+
+    const body = (await response.json()) as { error?: string };
+    expect(response.status).toBe(400);
+    expect(body.error).toBe("Request is required");
+  });
+});