@getrouter/getrouter-cli 0.1.1 → 0.1.3

package/tests/core/interactive/codex.test.ts

@@ -1,11 +1,16 @@
-import { describe, expect, it } from "vitest";
+import { afterEach, describe, expect, it, vi } from "vitest";
 import {
+  getCodexModelChoices,
   MODEL_CHOICES,
   mapReasoningValue,
   REASONING_CHOICES,
 } from "../../../src/core/interactive/codex";
 
 describe("codex interactive helpers", () => {
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
   it("maps extra high to xhigh", () => {
     expect(mapReasoningValue("extra_high")).toBe("xhigh");
   });
@@ -14,4 +19,23 @@ describe("codex interactive helpers", () => {
     expect(MODEL_CHOICES.length).toBeGreaterThan(0);
     expect(REASONING_CHOICES.length).toBeGreaterThan(0);
   });
+
+  it("fetches codex models from ListProviderModels(tag=codex)", async () => {
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: vi.fn().mockResolvedValue({
+        models: ["new-codex-model-xyz"],
+      }),
+    });
+    vi.stubGlobal("fetch", fetchMock);
+
+    const choices = await getCodexModelChoices();
+    expect(
+      choices.some((choice) => choice.value === "new-codex-model-xyz"),
+    ).toBe(true);
+    expect(String(fetchMock.mock.calls[0]?.[0] ?? "")).toContain(
+      "/v1/dashboard/providers/models?tag=codex",
+    );
+  });
 });

package/tests/core/setup/env.test.ts

@@ -23,17 +23,31 @@ describe("setup env helpers", () => {
   it("renders sh env", () => {
     const output = renderEnv("sh", vars);
     expect(output).toContain(
-      "export OPENAI_BASE_URL=https://api.getrouter.dev/codex",
+      "export OPENAI_BASE_URL='https://api.getrouter.dev/codex'",
     );
-    expect(output).toContain("export ANTHROPIC_API_KEY=key-123");
+    expect(output).toContain("export ANTHROPIC_API_KEY='key-123'");
   });
 
   it("renders ps1 env", () => {
     const output = renderEnv("ps1", vars);
     expect(output).toContain(
-      '$env:OPENAI_BASE_URL="https://api.getrouter.dev/codex"',
+      "$env:OPENAI_BASE_URL='https://api.getrouter.dev/codex'",
     );
-    expect(output).toContain('$env:ANTHROPIC_API_KEY="key-123"');
+    expect(output).toContain("$env:ANTHROPIC_API_KEY='key-123'");
+  });
+
+  it("escapes values safely", () => {
+    expect(
+      renderEnv("sh", {
+        openaiApiKey: "a'b",
+      }),
+    ).toContain("export OPENAI_API_KEY='a'\\''b'");
+
+    expect(
+      renderEnv("ps1", {
+        openaiApiKey: "a'b",
+      }),
+    ).toContain("$env:OPENAI_API_KEY='a''b'");
   });
 
   it("writes env file", () => {

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

@@ -1,13 +1,14 @@
 {
   "compilerOptions": {
-    "target": "ES2020",
+    "target": "ES2021",
     "module": "CommonJS",
     "rootDir": ".",
     "outDir": "dist",
     "strict": true,
     "esModuleInterop": true,
     "moduleResolution": "node",
-    "skipLibCheck": true
+    "skipLibCheck": true,
+    "resolveJsonModule": true
   },
   "include": ["src", "tests"]
 }

package/src/core/paths.ts

@@ -1,4 +0,0 @@
-import os from "node:os";
-import path from "node:path";
-
-export const getConfigDir = () => path.join(os.homedir(), ".getrouter");

package/tests/paths.test.ts

@@ -1,9 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { getConfigDir } from "../src/core/paths";
-
-describe("paths", () => {
-  it("returns ~/.getrouter path", () => {
-    const dir = getConfigDir();
-    expect(dir).toContain(".getrouter");
-  });
-});