@getrouter/getrouter-cli 0.1.1 → 0.1.2

package/tests/core/api/pagination.test.ts

@@ -0,0 +1,87 @@
+import { describe, expect, it, vi } from "vitest";
+import { fetchAllPages } from "../../../src/core/api/pagination";
+
+type PageResponse = {
+  items: number[];
+  nextPageToken: string | undefined;
+};
+
+describe("fetchAllPages", () => {
+  it("fetches single page when no next token", async () => {
+    const fetchPage = vi.fn().mockResolvedValue({
+      items: [1, 2, 3],
+      nextPageToken: undefined,
+    });
+
+    const result = await fetchAllPages<PageResponse, number>(
+      fetchPage,
+      (res) => res.items,
+      (res) => res.nextPageToken,
+    );
+
+    expect(result).toEqual([1, 2, 3]);
+    expect(fetchPage).toHaveBeenCalledTimes(1);
+    expect(fetchPage).toHaveBeenCalledWith(undefined);
+  });
+
+  it("fetches multiple pages", async () => {
+    const fetchPage = vi
+      .fn()
+      .mockResolvedValueOnce({
+        items: [1, 2],
+        nextPageToken: "page2",
+      })
+      .mockResolvedValueOnce({
+        items: [3, 4],
+        nextPageToken: "page3",
+      })
+      .mockResolvedValueOnce({
+        items: [5],
+        nextPageToken: undefined,
+      });
+
+    const result = await fetchAllPages<PageResponse, number>(
+      fetchPage,
+      (res) => res.items,
+      (res) => res.nextPageToken,
+    );
+
+    expect(result).toEqual([1, 2, 3, 4, 5]);
+    expect(fetchPage).toHaveBeenCalledTimes(3);
+    expect(fetchPage).toHaveBeenNthCalledWith(1, undefined);
+    expect(fetchPage).toHaveBeenNthCalledWith(2, "page2");
+    expect(fetchPage).toHaveBeenNthCalledWith(3, "page3");
+  });
+
+  it("returns empty array when first page is empty", async () => {
+    const fetchPage = vi.fn().mockResolvedValue({
+      items: [],
+      nextPageToken: undefined,
+    });
+
+    const result = await fetchAllPages<PageResponse, number>(
+      fetchPage,
+      (res) => res.items,
+      (res) => res.nextPageToken,
+    );
+
+    expect(result).toEqual([]);
+    expect(fetchPage).toHaveBeenCalledTimes(1);
+  });
+
+  it("stops when nextPageToken is empty string", async () => {
+    const fetchPage = vi.fn().mockResolvedValueOnce({
+      items: [1],
+      nextPageToken: "",
+    });
+
+    const result = await fetchAllPages<PageResponse, number>(
+      fetchPage,
+      (res) => res.items,
+      (res) => res.nextPageToken || undefined,
+    );
+
+    expect(result).toEqual([1]);
+    expect(fetchPage).toHaveBeenCalledTimes(1);
+  });
+});

package/tests/http/request.test.ts

@@ -79,4 +79,161 @@ describe("requestJson", () => {
     const headers = (init?.headers ?? {}) as Record<string, string>;
     expect(headers.Cookie).toBe("router_auth=t2");
   });
+
+  it("retries with refreshed token on 401", async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "getrouter-"));
+    process.env.GETROUTER_CONFIG_DIR = dir;
+    fs.writeFileSync(
+      path.join(dir, "auth.json"),
+      JSON.stringify({
+        accessToken: "expired",
+        refreshToken: "refresh-token",
+        expiresAt: new Date(Date.now() + 3600000).toISOString(),
+        tokenType: "Bearer",
+      }),
+    );
+
+    let callCount = 0;
+    const fetchSpy = vi.fn(
+      async (input: RequestInfo | URL, _init?: RequestInit) => {
+        callCount++;
+        const url = typeof input === "string" ? input : input.toString();
+
+        // Refresh token endpoint
+        if (url.includes("auth/token")) {
+          return {
+            ok: true,
+            json: async () => ({
+              accessToken: "new-access",
+              refreshToken: "new-refresh",
+              expiresAt: new Date(Date.now() + 3600000).toISOString(),
+            }),
+          } as Response;
+        }
+
+        // First call returns 401, second succeeds
+        if (callCount === 1) {
+          return {
+            ok: false,
+            status: 401,
+            statusText: "Unauthorized",
+            json: async () => ({ message: "Token expired" }),
+          } as Response;
+        }
+
+        return {
+          ok: true,
+          json: async () => ({ ok: true }),
+        } as Response;
+      },
+    );
+
+    const res = await requestJson<{ ok: boolean }>({
+      path: "/v1/test",
+      method: "GET",
+      fetchImpl: fetchSpy as unknown as typeof fetch,
+    });
+
+    expect(res.ok).toBe(true);
+    expect(fetchSpy).toHaveBeenCalledTimes(3); // initial + refresh + retry
+  });
+
+  it("does not retry when no refresh token", async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "getrouter-"));
+    process.env.GETROUTER_CONFIG_DIR = dir;
+    fs.writeFileSync(
+      path.join(dir, "auth.json"),
+      JSON.stringify({ accessToken: "expired", refreshToken: "" }),
+    );
+
+    const fetchSpy = vi.fn(
+      async (_input: RequestInfo | URL, _init?: RequestInit) =>
+        ({
+          ok: false,
+          status: 401,
+          statusText: "Unauthorized",
+          json: async () => ({ message: "Token expired" }),
+        }) as Response,
+    );
+
+    await expect(
+      requestJson({
+        path: "/v1/test",
+        method: "GET",
+        fetchImpl: fetchSpy as unknown as typeof fetch,
+      }),
+    ).rejects.toThrow();
+
+    expect(fetchSpy).toHaveBeenCalledTimes(1); // no retry
+  });
+
+  it("retries on 5xx server errors", async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "getrouter-"));
+    process.env.GETROUTER_CONFIG_DIR = dir;
+    fs.writeFileSync(
+      path.join(dir, "auth.json"),
+      JSON.stringify({ accessToken: "token", refreshToken: "" }),
+    );
+
+    let callCount = 0;
+    const fetchSpy = vi.fn(
+      async (_input: RequestInfo | URL, _init?: RequestInit) => {
+        callCount++;
+        if (callCount === 1) {
+          return {
+            ok: false,
+            status: 503,
+            statusText: "Service Unavailable",
+            json: async () => ({ message: "Server overloaded" }),
+          } as Response;
+        }
+        return {
+          ok: true,
+          json: async () => ({ ok: true }),
+        } as Response;
+      },
+    );
+
+    const noopSleep = async () => {};
+    const res = await requestJson<{ ok: boolean }>({
+      path: "/v1/test",
+      method: "GET",
+      fetchImpl: fetchSpy as unknown as typeof fetch,
+      maxRetries: 2,
+      _retrySleep: noopSleep,
+    });
+
+    expect(res.ok).toBe(true);
+    expect(fetchSpy).toHaveBeenCalledTimes(2);
+  });
+
+  it("does not retry on 4xx client errors", async () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "getrouter-"));
+    process.env.GETROUTER_CONFIG_DIR = dir;
+    fs.writeFileSync(
+      path.join(dir, "auth.json"),
+      JSON.stringify({ accessToken: "token", refreshToken: "" }),
+    );
+
+    const fetchSpy = vi.fn(
+      async (_input: RequestInfo | URL, _init?: RequestInit) =>
+        ({
+          ok: false,
+          status: 404,
+          statusText: "Not Found",
+          json: async () => ({ message: "Not found" }),
+        }) as Response,
+    );
+
+    await expect(
+      requestJson({
+        path: "/v1/test",
+        method: "GET",
+        fetchImpl: fetchSpy as unknown as typeof fetch,
+        maxRetries: 2,
+      }),
+    ).rejects.toThrow();
+
+    expect(fetchSpy).toHaveBeenCalledTimes(1); // no retry on 404
+  });
 });

package/tests/http/retry.test.ts

@@ -0,0 +1,152 @@
+import { describe, expect, it, vi } from "vitest";
+import { isServerError, withRetry } from "../../src/core/http/retry";
+
+describe("isServerError", () => {
+  it("returns true for 5xx errors", () => {
+    expect(isServerError(500)).toBe(true);
+    expect(isServerError(502)).toBe(true);
+    expect(isServerError(503)).toBe(true);
+    expect(isServerError(599)).toBe(true);
+  });
+
+  it("returns true for 408 and 429", () => {
+    expect(isServerError(408)).toBe(true);
+    expect(isServerError(429)).toBe(true);
+  });
+
+  it("returns false for 4xx client errors", () => {
+    expect(isServerError(400)).toBe(false);
+    expect(isServerError(401)).toBe(false);
+    expect(isServerError(403)).toBe(false);
+    expect(isServerError(404)).toBe(false);
+  });
+
+  it("returns false for 2xx success", () => {
+    expect(isServerError(200)).toBe(false);
+    expect(isServerError(201)).toBe(false);
+  });
+});
+
+describe("withRetry", () => {
+  it("returns result on first success", async () => {
+    const fn = vi.fn().mockResolvedValue("success");
+    const result = await withRetry(fn);
+    expect(result).toBe("success");
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+
+  it("retries on failure and succeeds", async () => {
+    const fn = vi
+      .fn()
+      .mockRejectedValueOnce(new TypeError("network error"))
+      .mockResolvedValueOnce("success");
+
+    const sleep = vi.fn().mockResolvedValue(undefined);
+    const result = await withRetry(fn, { sleep });
+
+    expect(result).toBe("success");
+    expect(fn).toHaveBeenCalledTimes(2);
+    expect(sleep).toHaveBeenCalledTimes(1);
+  });
+
+  it("respects maxRetries", async () => {
+    const fn = vi.fn().mockRejectedValue(new TypeError("network error"));
+    const sleep = vi.fn().mockResolvedValue(undefined);
+
+    await expect(withRetry(fn, { maxRetries: 2, sleep })).rejects.toThrow(
+      "network error",
+    );
+    expect(fn).toHaveBeenCalledTimes(3); // initial + 2 retries
+  });
+
+  it("calls onRetry callback", async () => {
+    const fn = vi
+      .fn()
+      .mockRejectedValueOnce(new TypeError("fail"))
+      .mockResolvedValueOnce("ok");
+
+    const onRetry = vi.fn();
+    const sleep = vi.fn().mockResolvedValue(undefined);
+
+    await withRetry(fn, { onRetry, sleep });
+
+    expect(onRetry).toHaveBeenCalledWith(expect.any(TypeError), 1, 1000);
+  });
+
+  it("uses exponential backoff", async () => {
+    const fn = vi
+      .fn()
+      .mockRejectedValueOnce(new TypeError("fail1"))
+      .mockRejectedValueOnce(new TypeError("fail2"))
+      .mockResolvedValueOnce("ok");
+
+    const onRetry = vi.fn();
+    const sleep = vi.fn().mockResolvedValue(undefined);
+
+    await withRetry(fn, {
+      onRetry,
+      sleep,
+      initialDelayMs: 100,
+      maxDelayMs: 500,
+    });
+
+    expect(onRetry).toHaveBeenCalledTimes(2);
+    expect(onRetry).toHaveBeenNthCalledWith(1, expect.any(TypeError), 1, 100);
+    expect(onRetry).toHaveBeenNthCalledWith(2, expect.any(TypeError), 2, 200);
+  });
+
+  it("respects maxDelayMs", async () => {
+    const fn = vi
+      .fn()
+      .mockRejectedValueOnce(new TypeError("1"))
+      .mockRejectedValueOnce(new TypeError("2"))
+      .mockRejectedValueOnce(new TypeError("3"))
+      .mockResolvedValueOnce("ok");
+
+    const onRetry = vi.fn();
+    const sleep = vi.fn().mockResolvedValue(undefined);
+
+    await withRetry(fn, {
+      onRetry,
+      sleep,
+      initialDelayMs: 100,
+      maxDelayMs: 150,
+      maxRetries: 5,
+    });
+
+    expect(onRetry).toHaveBeenNthCalledWith(3, expect.any(TypeError), 3, 150);
+  });
+
+  it("does not retry when shouldRetry returns false", async () => {
+    const error = new Error("non-retryable");
+    const fn = vi.fn().mockRejectedValue(error);
+    const shouldRetry = vi.fn().mockReturnValue(false);
+
+    await expect(withRetry(fn, { shouldRetry })).rejects.toThrow(
+      "non-retryable",
+    );
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+
+  it("retries on 500 status errors", async () => {
+    const error = { status: 500, message: "server error" };
+    const fn = vi.fn().mockRejectedValueOnce(error).mockResolvedValueOnce("ok");
+
+    const sleep = vi.fn().mockResolvedValue(undefined);
+    const result = await withRetry(fn, { sleep });
+
+    expect(result).toBe("ok");
+    expect(fn).toHaveBeenCalledTimes(2);
+  });
+
+  it("retries on 429 rate limit", async () => {
+    const error = { status: 429, message: "rate limited" };
+    const fn = vi.fn().mockRejectedValueOnce(error).mockResolvedValueOnce("ok");
+
+    const sleep = vi.fn().mockResolvedValue(undefined);
+    const result = await withRetry(fn, { sleep });
+
+    expect(result).toBe("ok");
+    expect(fn).toHaveBeenCalledTimes(2);
+  });
+});

package/tests/output/usages.test.ts

@@ -2,7 +2,7 @@ import { describe, expect, it } from "vitest";
 import { renderUsageChart } from "../../src/core/output/usages";
 
 describe("renderUsageChart", () => {
-  it("renders stacked bars", () => {
+  it("renders bars with total tokens", () => {
     const output = renderUsageChart([
       {
         day: "2026-01-03",
@@ -29,16 +29,14 @@ describe("renderUsageChart", () => {
     expect(output.startsWith("📊 Usage (last 7 days)")).toBe(true);
     expect(output).toContain("Tokens");
     expect(output).toContain("█");
-    expect(output).toContain("▒");
-    expect(output).toContain("I:1K");
-    expect(output).toContain("O:1K");
+    expect(output).toContain("2K");
     expect(output).toContain("📊 Usage (last 7 days) · Tokens\n\n2026-01-03");
-    expect(output).toContain("O:1K\n\nLegend: █ input    ▒ output");
-    expect(output).toContain("Legend: █ input    ▒ output");
-    expect(output).not.toContain("O:0179");
+    expect(output).not.toContain("Legend");
+    expect(output).not.toContain("I:");
+    expect(output).not.toContain("O:");
   });
 
-  it("prints input and output totals separately", () => {
+  it("prints total tokens only", () => {
     const output = renderUsageChart([
       {
         day: "2026-01-03",
@@ -48,9 +46,9 @@ describe("renderUsageChart", () => {
         requests: 2,
       },
     ]);
-    expect(output).toContain("I:1.2K");
-    expect(output).toContain("O:3.4K");
-    expect(output).not.toContain("4.6K");
+    expect(output).toContain("4.6K");
+    expect(output).not.toContain("I:");
+    expect(output).not.toContain("O:");
   });
 
   it("handles numeric strings without skewing bars", () => {
@@ -66,6 +64,7 @@ describe("renderUsageChart", () => {
       ],
       10,
     );
-    expect(output).toContain("█████▒▒▒▒▒");
+    expect(output).toContain("██████████");
+    expect(output).toContain("2K");
   });
 });

package/tsconfig.json

@@ -7,7 +7,8 @@
     "strict": true,
     "esModuleInterop": true,
     "moduleResolution": "node",
-    "skipLibCheck": true
+    "skipLibCheck": true,
+    "resolveJsonModule": true
   },
   "include": ["src", "tests"]
 }