@getrouter/getrouter-cli 0.1.1 → 0.1.3

package/src/core/setup/codex.ts

@@ -45,6 +45,7 @@ export const mergeCodexToml = (content: string, input: CodexConfigInput) => {
   let firstHeaderIndex: number | null = null;
   const rootFound = new Set<string>();
 
+  // Update root keys that appear before any section headers.
   for (let i = 0; i < updated.length; i += 1) {
     const headerMatch = matchHeader(updated[i] ?? "");
     if (headerMatch) {
@@ -66,6 +67,7 @@ export const mergeCodexToml = (content: string, input: CodexConfigInput) => {
     }
   }
 
+  // Insert missing root keys before the first section header (or at EOF).
   const insertIndex = firstHeaderIndex ?? updated.length;
   const missingRoot = ROOT_KEYS.filter((key) => !rootFound.has(key)).map(
     (key) => `${key} = ${rootValueMap[key]}`,
@@ -76,6 +78,7 @@ export const mergeCodexToml = (content: string, input: CodexConfigInput) => {
     updated.splice(insertIndex, 0, ...missingRoot, ...(needsBlank ? [""] : []));
   }
 
+  // Ensure the provider section exists and keep its keys in sync.
   const providerHeader = `[${PROVIDER_SECTION}]`;
   const providerHeaderIndex = updated.findIndex(
     (line) => line.trim() === providerHeader,
@@ -91,6 +94,7 @@ export const mergeCodexToml = (content: string, input: CodexConfigInput) => {
     return updated.join("\n");
   }
 
+  // Find the provider section bounds for in-place updates.
   let providerEnd = updated.length;
   for (let i = providerHeaderIndex + 1; i < updated.length; i += 1) {
     if (matchHeader(updated[i] ?? "")) {

package/src/core/setup/env.ts

@@ -1,6 +1,5 @@
 import { execSync } from "node:child_process";
 import fs from "node:fs";
-import os from "node:os";
 import path from "node:path";
 
 export type EnvVars = {
@@ -14,11 +13,21 @@ export type EnvShell = "sh" | "ps1";
 
 export type RcShell = "zsh" | "bash" | "fish" | "pwsh";
 
+const quoteEnvValue = (shell: EnvShell, value: string) => {
+  if (shell === "ps1") {
+    // PowerShell: single quotes are literal; escape by doubling.
+    return `'${value.replaceAll("'", "''")}'`;
+  }
+
+  // POSIX shell: use single quotes; escape embedded single quotes with: '\''.
+  return `'${value.replaceAll("'", "'\\''")}'`;
+};
+
 const renderLine = (shell: EnvShell, key: string, value: string) => {
   if (shell === "ps1") {
-    return `$env:${key}="${value}"`;
+    return `$env:${key}=${quoteEnvValue(shell, value)}`;
   }
-  return `export ${key}=${value}`;
+  return `export ${key}=${quoteEnvValue(shell, value)}`;
 };
 
 export const renderEnv = (shell: EnvShell, vars: EnvVars) => {
@@ -39,6 +48,7 @@ export const renderEnv = (shell: EnvShell, vars: EnvVars) => {
   return lines.join("\n");
 };
 
+// Wrap getrouter to source env after successful codex/claude runs.
 export const renderHook = (shell: RcShell) => {
   if (shell === "pwsh") {
     return [
@@ -126,6 +136,7 @@ export const writeEnvFile = (filePath: string, content: string) => {
   fs.mkdirSync(path.dirname(filePath), { recursive: true });
   fs.writeFileSync(filePath, content, "utf8");
   if (process.platform !== "win32") {
+    // Limit env file readability since it can contain API keys.
     fs.chmodSync(filePath, 0o600);
   }
 };
@@ -215,6 +226,3 @@ export const appendRcIfMissing = (rcPath: string, line: string) => {
   fs.writeFileSync(rcPath, `${content}${prefix}${line}\n`, "utf8");
   return true;
 };
-
-export const resolveConfigDir = () =>
-  process.env.GETROUTER_CONFIG_DIR || path.join(os.homedir(), ".getrouter");

package/tests/auth/refresh.test.ts

@@ -0,0 +1,149 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  ensureValidToken,
+  isTokenExpiringSoon,
+  refreshAccessToken,
+} from "../../src/core/auth/refresh";
+import { readAuth, writeAuth } from "../../src/core/config";
+
+const makeDir = () => fs.mkdtempSync(path.join(os.tmpdir(), "getrouter-"));
+
+describe("isTokenExpiringSoon", () => {
+  it("returns true for empty string", () => {
+    expect(isTokenExpiringSoon("")).toBe(true);
+  });
+
+  it("returns true for invalid date", () => {
+    expect(isTokenExpiringSoon("not-a-date")).toBe(true);
+  });
+
+  it("returns true for expired token", () => {
+    const past = new Date(Date.now() - 10000).toISOString();
+    expect(isTokenExpiringSoon(past)).toBe(true);
+  });
+
+  it("returns true for token expiring within buffer", () => {
+    const soon = new Date(Date.now() + 30000).toISOString(); // 30 seconds
+    expect(isTokenExpiringSoon(soon)).toBe(true);
+  });
+
+  it("returns false for token with plenty of time", () => {
+    const future = new Date(Date.now() + 5 * 60 * 1000).toISOString(); // 5 minutes
+    expect(isTokenExpiringSoon(future)).toBe(false);
+  });
+});
+
+describe("refreshAccessToken", () => {
+  beforeEach(() => {
+    process.env.GETROUTER_CONFIG_DIR = makeDir();
+  });
+
+  it("returns null when no refresh token", async () => {
+    writeAuth({
+      accessToken: "",
+      refreshToken: "",
+      expiresAt: "",
+      tokenType: "",
+    });
+    const result = await refreshAccessToken({});
+    expect(result).toBeNull();
+  });
+
+  it("returns null when refresh fails", async () => {
+    writeAuth({
+      accessToken: "old",
+      refreshToken: "refresh",
+      expiresAt: "",
+      tokenType: "Bearer",
+    });
+    const mockFetch = vi.fn().mockResolvedValue({
+      ok: false,
+      status: 401,
+    });
+    const result = await refreshAccessToken({
+      fetchImpl: mockFetch as unknown as typeof fetch,
+    });
+    expect(result).toBeNull();
+  });
+
+  it("refreshes and updates auth on success", async () => {
+    writeAuth({
+      accessToken: "old",
+      refreshToken: "refresh",
+      expiresAt: "",
+      tokenType: "Bearer",
+    });
+    const newToken = {
+      accessToken: "new-access",
+      refreshToken: "new-refresh",
+      expiresAt: "2026-12-01T00:00:00Z",
+    };
+    const mockFetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => newToken,
+    });
+    const result = await refreshAccessToken({
+      fetchImpl: mockFetch as unknown as typeof fetch,
+    });
+    expect(result).toEqual(newToken);
+    const saved = readAuth();
+    expect(saved.accessToken).toBe("new-access");
+    expect(saved.refreshToken).toBe("new-refresh");
+  });
+});
+
+describe("ensureValidToken", () => {
+  beforeEach(() => {
+    process.env.GETROUTER_CONFIG_DIR = makeDir();
+  });
+
+  it("returns false when no tokens", async () => {
+    writeAuth({
+      accessToken: "",
+      refreshToken: "",
+      expiresAt: "",
+      tokenType: "",
+    });
+    const result = await ensureValidToken({});
+    expect(result).toBe(false);
+  });
+
+  it("returns true when token is still valid", async () => {
+    const future = new Date(Date.now() + 10 * 60 * 1000).toISOString();
+    writeAuth({
+      accessToken: "valid",
+      refreshToken: "refresh",
+      expiresAt: future,
+      tokenType: "Bearer",
+    });
+    const result = await ensureValidToken({});
+    expect(result).toBe(true);
+  });
+
+  it("refreshes when token is expiring soon", async () => {
+    const soon = new Date(Date.now() + 10000).toISOString(); // 10 seconds
+    writeAuth({
+      accessToken: "expiring",
+      refreshToken: "refresh",
+      expiresAt: soon,
+      tokenType: "Bearer",
+    });
+    const newToken = {
+      accessToken: "new-access",
+      refreshToken: "new-refresh",
+      expiresAt: new Date(Date.now() + 3600000).toISOString(),
+    };
+    const mockFetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => newToken,
+    });
+    const result = await ensureValidToken({
+      fetchImpl: mockFetch as unknown as typeof fetch,
+    });
+    expect(result).toBe(true);
+    expect(mockFetch).toHaveBeenCalled();
+  });
+});

package/tests/cmd/codex.test.ts

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import prompts from "prompts";
-import { afterEach, describe, expect, it, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { createProgram } from "../../src/cli";
 import { createApiClients } from "../../src/core/api/client";
 import type { ConsumerService } from "../../src/generated/router/dashboard/v1";
@@ -32,6 +32,7 @@ const originalEnv = Object.fromEntries(
 );
 
 afterEach(() => {
+  vi.unstubAllGlobals();
   setStdinTTY(originalIsTTY);
   prompts.inject([]);
   for (const key of ENV_KEYS) {
@@ -44,6 +45,57 @@ afterEach(() => {
 });
 
 describe("codex command", () => {
+  beforeEach(() => {
+    vi.stubGlobal(
+      "fetch",
+      vi.fn().mockResolvedValue({
+        ok: true,
+        status: 200,
+        json: vi.fn().mockResolvedValue({ models: [] }),
+      }),
+    );
+  });
+
+  it("fetches codex models from remote endpoint", async () => {
+    setStdinTTY(true);
+    const dir = makeDir();
+    process.env.HOME = dir;
+
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: true,
+      status: 200,
+      json: vi.fn().mockResolvedValue({
+        models: ["gpt-5.2-codex"],
+      }),
+    });
+    vi.stubGlobal("fetch", fetchMock);
+
+    prompts.inject(["gpt-5.2-codex", "extra_high", mockConsumer, true]);
+    (createApiClients as unknown as ReturnType<typeof vi.fn>).mockReturnValue({
+      consumerService: {
+        ListConsumers: vi.fn().mockResolvedValue({
+          consumers: [
+            {
+              id: "c1",
+              name: "dev",
+              enabled: true,
+              createdAt: "2026-01-01T00:00:00Z",
+            },
+          ],
+        }),
+        GetConsumer: vi.fn().mockResolvedValue(mockConsumer),
+      } as unknown as ConsumerService,
+    });
+
+    const program = createProgram();
+    await program.parseAsync(["node", "getrouter", "codex"]);
+
+    expect(fetchMock).toHaveBeenCalled();
+    expect(String(fetchMock.mock.calls[0]?.[0] ?? "")).toContain(
+      "/v1/dashboard/providers/models?tag=codex",
+    );
+  });
+
   it("writes codex config and auth after interactive flow", async () => {
     setStdinTTY(true);
     const dir = makeDir();
@@ -144,4 +196,38 @@ describe("codex command", () => {
     expect(auth.OPENAI_API_KEY).toBe("key-123");
     expect(auth.OTHER).toBe("keep");
   });
+
+  it("supports -m to set a custom model", async () => {
+    setStdinTTY(true);
+    const dir = makeDir();
+    process.env.HOME = dir;
+    prompts.inject(["extra_high", mockConsumer, true]);
+    (createApiClients as unknown as ReturnType<typeof vi.fn>).mockReturnValue({
+      consumerService: {
+        ListConsumers: vi.fn().mockResolvedValue({
+          consumers: [
+            {
+              id: "c1",
+              name: "dev",
+              enabled: true,
+              createdAt: "2026-01-01T00:00:00Z",
+            },
+          ],
+        }),
+        GetConsumer: vi.fn().mockResolvedValue(mockConsumer),
+      } as unknown as ConsumerService,
+    });
+
+    const program = createProgram();
+    await program.parseAsync([
+      "node",
+      "getrouter",
+      "codex",
+      "-m",
+      "legacy-model",
+    ]);
+
+    const config = fs.readFileSync(codexConfigPath(dir), "utf8");
+    expect(config).toContain('model = "legacy-model"');
+  });
 });

package/tests/cmd/keys.test.ts

@@ -38,7 +38,7 @@ afterEach(() => {
 });
 
 describe("keys command", () => {
-  it("lists keys and redacts apiKey", async () => {
+  it("lists keys with redacted apiKey by default", async () => {
     setStdinTTY(false);
     (createApiClients as unknown as ReturnType<typeof vi.fn>).mockReturnValue({
       consumerService: {
@@ -55,6 +55,24 @@ describe("keys command", () => {
     expect(output).toContain("NAME");
     expect(output).not.toContain("ID");
     expect(output).toContain("abcd...WXYZ");
+    expect(output).not.toContain("abcd1234WXYZ");
+    log.mockRestore();
+  });
+
+  it("lists keys with full apiKey when --show is provided", async () => {
+    setStdinTTY(false);
+    (createApiClients as unknown as ReturnType<typeof vi.fn>).mockReturnValue({
+      consumerService: {
+        ListConsumers: vi.fn().mockResolvedValue({ consumers: [mockConsumer] }),
+      } as unknown as ConsumerService,
+      subscriptionService: emptySubscriptionService,
+      authService: emptyAuthService,
+    });
+    const log = vi.spyOn(console, "log").mockImplementation(() => {});
+    const program = createProgram();
+    await program.parseAsync(["node", "getrouter", "keys", "list", "--show"]);
+    const output = log.mock.calls.map((c) => c[0]).join("\n");
+    expect(output).toContain("abcd1234WXYZ");
     log.mockRestore();
   });
 
@@ -74,6 +92,24 @@ describe("keys command", () => {
     expect(output).toContain("NAME");
     expect(output).not.toContain("ID");
     expect(output).toContain("abcd...WXYZ");
+    expect(output).not.toContain("abcd1234WXYZ");
+    log.mockRestore();
+  });
+
+  it("lists keys when no subcommand and --show is provided", async () => {
+    setStdinTTY(true);
+    (createApiClients as unknown as ReturnType<typeof vi.fn>).mockReturnValue({
+      consumerService: {
+        ListConsumers: vi.fn().mockResolvedValue({ consumers: [mockConsumer] }),
+      } as unknown as ConsumerService,
+      subscriptionService: emptySubscriptionService,
+      authService: emptyAuthService,
+    });
+    const log = vi.spyOn(console, "log").mockImplementation(() => {});
+    const program = createProgram();
+    await program.parseAsync(["node", "getrouter", "keys", "--show"]);
+    const output = log.mock.calls.map((c) => c[0]).join("\n");
+    expect(output).toContain("abcd1234WXYZ");
     log.mockRestore();
   });
 
@@ -81,20 +117,18 @@ describe("keys command", () => {
     setStdinTTY(false);
     const program = createProgram();
     program.exitOverride();
-    const writeErr = vi
-      .spyOn(process.stderr, "write")
-      .mockImplementation(() => true);
-    program.configureOutput({
+    const silentOutput = {
       writeErr: () => {},
-    });
-    try {
-      await expect(
-        program.parseAsync(["node", "getrouter", "keys", "get", "c1"]),
-      ).rejects.toBeTruthy();
-      expect(writeErr).not.toHaveBeenCalled();
-    } finally {
-      writeErr.mockRestore();
-    }
+      writeOut: () => {},
+      outputError: () => {},
+    };
+    program.configureOutput(silentOutput);
+    program.commands
+      .find((command) => command.name() === "keys")
+      ?.configureOutput(silentOutput);
+    await expect(
+      program.parseAsync(["node", "getrouter", "keys", "get", "c1"]),
+    ).rejects.toBeTruthy();
   });
 
   it("creates a key and prints reminder", async () => {

package/tests/cmd/models.test.ts

@@ -39,8 +39,10 @@ describe("models command", () => {
     const program = createProgram();
     await program.parseAsync(["node", "getrouter", "models", "list"]);
     const output = log.mock.calls.map((call) => call[0]).join("\n");
+    expect(output).toContain("ID");
     expect(output).toContain("NAME");
-    expect(output).not.toContain("ID");
+    expect(output).toContain("gpt-5");
+    expect(output).toContain("GPT-5");
     log.mockRestore();
   });
 
@@ -55,8 +57,9 @@ describe("models command", () => {
     const program = createProgram();
     await program.parseAsync(["node", "getrouter", "models"]);
     const output = log.mock.calls.map((call) => call[0]).join("\n");
+    expect(output).toContain("ID");
     expect(output).toContain("NAME");
-    expect(output).not.toContain("ID");
+    expect(output).toContain("gpt-5");
     expect(output).toContain("GPT-5");
     log.mockRestore();
   });

package/tests/cmd/usages.test.ts

@@ -7,7 +7,7 @@ vi.mock("../../src/core/api/client", () => ({
 }));
 
 describe("usages command", () => {
-  it("prints chart and table", async () => {
+  it("prints chart with total tokens only", async () => {
     const listUsage = vi.fn().mockResolvedValue({
       usages: [
         {
@@ -32,11 +32,11 @@ describe("usages command", () => {
     expect(log).toHaveBeenCalledTimes(1);
     const output = String(log.mock.calls[0][0] ?? "");
     expect(output).toContain("📊 Usage (last 7 days)");
-    expect(output).toContain("I:1K");
-    expect(output).toContain("O:1K");
-    expect(output).toContain("Legend:");
+    expect(output).toContain("2K");
+    expect(output).not.toContain("I:");
+    expect(output).not.toContain("O:");
+    expect(output).not.toContain("Legend");
     expect(output).not.toContain("DAY");
-    expect(output).not.toContain("O:0179");
     log.mockRestore();
   });
 });

package/tests/config/fs.test.ts

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, vi } from "vitest";
 import { readJsonFile, writeJsonFile } from "../../src/core/config/fs";
 
 describe("config fs", () => {
@@ -11,4 +11,25 @@ describe("config fs", () => {
     writeJsonFile(file, { hello: "world" });
     expect(readJsonFile(file)).toEqual({ hello: "world" });
   });
+
+  it("tolerates invalid JSON by returning null and backing up the file", () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "getrouter-"));
+    const file = path.join(dir, "config.json");
+    fs.writeFileSync(file, "{", "utf8");
+
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+    try {
+      expect(readJsonFile(file)).toBeNull();
+    } finally {
+      warnSpy.mockRestore();
+    }
+
+    expect(fs.existsSync(file)).toBe(false);
+    const backups = fs
+      .readdirSync(dir)
+      .filter(
+        (name) => name.startsWith("config.corrupt-") && name.endsWith(".json"),
+      );
+    expect(backups.length).toBe(1);
+  });
 });

package/tests/config/index.test.ts

@@ -1,7 +1,7 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
-import { describe, expect, it } from "vitest";
+import { describe, expect, it, vi } from "vitest";
 import {
   readAuth,
   readConfig,
@@ -34,6 +34,21 @@ describe("config read/write", () => {
     expect(auth.expiresAt).toBe("c");
   });
 
+  it("falls back to defaults when config.json is invalid JSON", () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "getrouter-"));
+    process.env.GETROUTER_CONFIG_DIR = dir;
+    fs.writeFileSync(path.join(dir, "config.json"), "{", "utf8");
+
+    const warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+    try {
+      const cfg = readConfig();
+      expect(cfg.apiBase).toBe("https://getrouter.dev");
+      expect(cfg.json).toBe(false);
+    } finally {
+      warnSpy.mockRestore();
+    }
+  });
+
   it("defaults tokenType to Bearer", () => {
     const dir = fs.mkdtempSync(path.join(os.tmpdir(), "getrouter-"));
     process.env.GETROUTER_CONFIG_DIR = dir;

package/tests/config/paths.test.ts

@@ -1,10 +1,33 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
 import { describe, expect, it } from "vitest";
 import { getAuthPath, getConfigPath } from "../../src/core/config/paths";
 
 describe("config paths", () => {
+  const originalConfigDir = process.env.GETROUTER_CONFIG_DIR;
+
+  const restore = () => {
+    if (originalConfigDir === undefined) {
+      delete process.env.GETROUTER_CONFIG_DIR;
+      return;
+    }
+    process.env.GETROUTER_CONFIG_DIR = originalConfigDir;
+  };
+
   it("returns ~/.getrouter paths", () => {
+    delete process.env.GETROUTER_CONFIG_DIR;
     expect(getConfigPath()).toContain(".getrouter");
     expect(getConfigPath()).toContain("config.json");
     expect(getAuthPath()).toContain("auth.json");
+    restore();
+  });
+
+  it("uses GETROUTER_CONFIG_DIR when set", () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "getrouter-"));
+    process.env.GETROUTER_CONFIG_DIR = dir;
+    expect(getConfigPath()).toBe(path.join(dir, "config.json"));
+    expect(getAuthPath()).toBe(path.join(dir, "auth.json"));
+    restore();
   });
 });

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);
+  });
+});