@getrouter/getrouter-cli 0.1.0

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

@@ -0,0 +1,38 @@
+import { describe, expect, it } from "vitest";
+import { mergeAuthJson, mergeCodexToml } from "../../../src/core/setup/codex";
+
+describe("codex setup helpers", () => {
+  it("merges codex toml at root and provider table", () => {
+    const input = [
+      'other = "keep"',
+      'model = "old-model"',
+      "",
+      "[model_providers.other]",
+      'name = "x"',
+      "",
+      "[model_providers.getrouter]",
+      'name = "old"',
+      'extra = "keep"',
+      "",
+    ].join("\n");
+    const output = mergeCodexToml(input, {
+      model: "gpt-5.2-codex",
+      reasoning: "xhigh",
+    });
+    expect(output).toContain('model = "gpt-5.2-codex"');
+    expect(output).toContain('model_reasoning_effort = "xhigh"');
+    expect(output).toContain('model_provider = "getrouter"');
+    expect(output).toContain("[model_providers.getrouter]");
+    expect(output).toContain('base_url = "https://api.getrouter.dev/codex"');
+    expect(output).toContain('wire_api = "responses"');
+    expect(output).toContain("requires_openai_auth = true");
+    expect(output).toContain('other = "keep"');
+    expect(output).toContain('extra = "keep"');
+  });
+
+  it("merges auth json", () => {
+    const output = mergeAuthJson({ existing: "keep" }, "key-123");
+    expect(output.OPENAI_API_KEY).toBe("key-123");
+    expect(output.existing).toBe("keep");
+  });
+});

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

@@ -0,0 +1,84 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import {
+  appendRcIfMissing,
+  getEnvFilePath,
+  getHookFilePath,
+  renderEnv,
+  renderHook,
+  resolveShellRcPath,
+  writeEnvFile,
+} from "../../../src/core/setup/env";
+
+const vars = {
+  openaiBaseUrl: "https://api.getrouter.dev/codex",
+  openaiApiKey: "key-123",
+  anthropicBaseUrl: "https://api.getrouter.dev/claude",
+  anthropicApiKey: "key-123",
+};
+
+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",
+    );
+    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"',
+    );
+    expect(output).toContain('$env:ANTHROPIC_API_KEY="key-123"');
+  });
+
+  it("writes env file", () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "getrouter-env-"));
+    const filePath = getEnvFilePath("sh", dir);
+    writeEnvFile(filePath, "hello");
+    expect(fs.readFileSync(filePath, "utf8")).toBe("hello");
+  });
+
+  it("renders sh hook", () => {
+    const output = renderHook("bash");
+    expect(output).toContain("getrouter() {");
+    expect(output).toContain("command getrouter");
+    expect(output).toContain("source");
+  });
+
+  it("renders pwsh hook", () => {
+    const output = renderHook("pwsh");
+    expect(output).toContain("function getrouter");
+    expect(output).toContain("$LASTEXITCODE");
+  });
+
+  it("resolves shell rc paths", () => {
+    expect(resolveShellRcPath("zsh", "/tmp")).toBe("/tmp/.zshrc");
+    expect(resolveShellRcPath("bash", "/tmp")).toBe("/tmp/.bashrc");
+    expect(resolveShellRcPath("fish", "/tmp")).toBe(
+      "/tmp/.config/fish/config.fish",
+    );
+  });
+
+  it("resolves hook file paths", () => {
+    expect(getHookFilePath("bash", "/tmp")).toBe("/tmp/hook.sh");
+    expect(getHookFilePath("zsh", "/tmp")).toBe("/tmp/hook.sh");
+    expect(getHookFilePath("fish", "/tmp")).toBe("/tmp/hook.fish");
+    expect(getHookFilePath("pwsh", "/tmp")).toBe("/tmp/hook.ps1");
+  });
+
+  it("appends rc line once", () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "getrouter-rc-"));
+    const rcPath = path.join(dir, "rc");
+    const line = "source ~/.getrouter/env.sh";
+    fs.writeFileSync(rcPath, `${line}\n`);
+    expect(appendRcIfMissing(rcPath, line)).toBe(false);
+    expect(appendRcIfMissing(rcPath, line)).toBe(false);
+    const content = fs.readFileSync(rcPath, "utf8");
+    expect(content.split(line).length - 1).toBe(1);
+  });
+});

package/tests/core/usages/aggregate.test.ts

@@ -0,0 +1,55 @@
+import { describe, expect, it } from "vitest";
+import { aggregateUsages } from "../../../src/core/usages/aggregate";
+
+describe("aggregateUsages", () => {
+  it("groups by local day and totals tokens", () => {
+    const rows = [
+      {
+        createdAt: "2026-01-03T10:00:00",
+        inputTokens: 5,
+        outputTokens: 7,
+        totalTokens: 12,
+      },
+      {
+        createdAt: "2026-01-03T18:00:00",
+        inputTokens: 3,
+        outputTokens: 2,
+        totalTokens: 5,
+      },
+    ];
+    const result = aggregateUsages(rows, 7);
+    expect(result).toHaveLength(1);
+    expect(result[0].totalTokens).toBe(17);
+    expect(result[0].inputTokens).toBe(8);
+    expect(result[0].outputTokens).toBe(9);
+    expect(result[0].requests).toBe(2);
+  });
+
+  it("limits results to the most recent days", () => {
+    const rows = [
+      { createdAt: "2026-01-05T00:00:00Z", totalTokens: 1 },
+      { createdAt: "2026-01-04T00:00:00Z", totalTokens: 1 },
+      { createdAt: "2026-01-03T00:00:00Z", totalTokens: 1 },
+    ];
+    const result = aggregateUsages(rows, 2);
+    expect(result).toHaveLength(2);
+    expect(result[0].day).toBe("2026-01-05");
+    expect(result[1].day).toBe("2026-01-04");
+  });
+
+  it("coerces string token values to numbers", () => {
+    const rows = [
+      {
+        createdAt: "2026-01-03T10:00:00Z",
+        inputTokens: "0123",
+        outputTokens: "045",
+        totalTokens: "0168",
+      },
+    ];
+    const result = aggregateUsages(rows, 7);
+    expect(result).toHaveLength(1);
+    expect(result[0].inputTokens).toBe(123);
+    expect(result[0].outputTokens).toBe(45);
+    expect(result[0].totalTokens).toBe(168);
+  });
+});

package/tests/http/errors.test.ts

@@ -0,0 +1,15 @@
+import { describe, expect, it } from "vitest";
+import { createApiError } from "../../src/core/http/errors";
+
+describe("api errors", () => {
+  it("normalizes error payload", () => {
+    const err = createApiError(
+      { code: "BAD", message: "oops" },
+      "fallback",
+      400,
+    );
+    expect(err.message).toBe("oops");
+    expect(err.code).toBe("BAD");
+    expect(err.status).toBe(400);
+  });
+});

package/tests/http/request.test.ts

@@ -0,0 +1,82 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { requestJson } from "../../src/core/http/request";
+
+const originalCookieName = process.env.GETROUTER_AUTH_COOKIE;
+const originalKratosCookie = process.env.KRATOS_AUTH_COOKIE;
+
+afterEach(() => {
+  if (originalCookieName === undefined) {
+    delete process.env.GETROUTER_AUTH_COOKIE;
+  } else {
+    process.env.GETROUTER_AUTH_COOKIE = originalCookieName;
+  }
+  if (originalKratosCookie === undefined) {
+    delete process.env.KRATOS_AUTH_COOKIE;
+  } else {
+    process.env.KRATOS_AUTH_COOKIE = originalKratosCookie;
+  }
+});
+
+describe("requestJson", () => {
+  it("adds Authorization when token exists", 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: "t" }),
+    );
+
+    const fetchSpy = vi.fn(
+      async (_input: RequestInfo | URL, _init?: RequestInit) =>
+        ({
+          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);
+    const call = fetchSpy.mock.calls[0] as Parameters<typeof fetch> | undefined;
+    const init = call?.[1];
+    const headers = (init?.headers ?? {}) as Record<string, string>;
+    expect(headers.Authorization).toBe("Bearer t");
+    expect(headers.Cookie).toBe("access_token=t");
+  });
+
+  it("uses GETROUTER_AUTH_COOKIE when set", async () => {
+    process.env.GETROUTER_AUTH_COOKIE = "router_auth";
+    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: "t2" }),
+    );
+
+    const fetchSpy = vi.fn(
+      async (_input: RequestInfo | URL, _init?: RequestInit) =>
+        ({
+          ok: true,
+          json: async () => ({ ok: true }),
+        }) as Response,
+    );
+
+    await requestJson({
+      path: "/v1/test",
+      method: "GET",
+      fetchImpl: fetchSpy as unknown as typeof fetch,
+    });
+
+    const call = fetchSpy.mock.calls[0] as Parameters<typeof fetch> | undefined;
+    const init = call?.[1];
+    const headers = (init?.headers ?? {}) as Record<string, string>;
+    expect(headers.Cookie).toBe("router_auth=t2");
+  });
+});

package/tests/http/url.test.ts

@@ -0,0 +1,17 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import { buildApiUrl } from "../../src/core/http/url";
+
+describe("buildApiUrl", () => {
+  it("joins base and path safely", () => {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "getrouter-"));
+    process.env.GETROUTER_CONFIG_DIR = dir;
+    fs.writeFileSync(
+      path.join(dir, "config.json"),
+      JSON.stringify({ apiBase: "https://getrouter.dev/" }),
+    );
+    expect(buildApiUrl("/v1/test")).toBe("https://getrouter.dev/v1/test");
+  });
+});

package/tests/output/table.test.ts

@@ -0,0 +1,29 @@
+import { describe, expect, it } from "vitest";
+import { renderTable } from "../../src/core/output/table";
+
+describe("table renderer", () => {
+  it("renders headers and rows with alignment", () => {
+    const out = renderTable(
+      ["ID", "NAME"],
+      [
+        ["1", "alpha"],
+        ["2", "beta"],
+      ],
+    );
+    expect(out).toContain("ID");
+    expect(out).toContain("NAME");
+    expect(out).toContain("alpha");
+  });
+
+  it("truncates long cells", () => {
+    const out = renderTable(["ID"], [["0123456789ABCDEFGHIJ"]], {
+      maxColWidth: 8,
+    });
+    expect(out).toContain("01234...");
+  });
+
+  it("fills empty with dash", () => {
+    const out = renderTable(["ID"], [[""]]);
+    expect(out).toContain("-");
+  });
+});

package/tests/output/usages.test.ts

@@ -0,0 +1,71 @@
+import { describe, expect, it } from "vitest";
+import { renderUsageChart } from "../../src/core/output/usages";
+
+describe("renderUsageChart", () => {
+  it("renders stacked bars", () => {
+    const output = renderUsageChart([
+      {
+        day: "2026-01-03",
+        inputTokens: 10,
+        outputTokens: 20,
+        totalTokens: 30,
+        requests: 2,
+      },
+    ]);
+    expect(output).toContain("2026-01-03");
+    expect(output).toMatch(/█/);
+  });
+
+  it("uses an emoji header and token-friendly numbers", () => {
+    const output = renderUsageChart([
+      {
+        day: "2026-01-03",
+        inputTokens: 1000,
+        outputTokens: 1000,
+        totalTokens: 2000,
+        requests: 2,
+      },
+    ]);
+    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("📊 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");
+  });
+
+  it("prints input and output totals separately", () => {
+    const output = renderUsageChart([
+      {
+        day: "2026-01-03",
+        inputTokens: 1200,
+        outputTokens: 3400,
+        totalTokens: 4600,
+        requests: 2,
+      },
+    ]);
+    expect(output).toContain("I:1.2K");
+    expect(output).toContain("O:3.4K");
+    expect(output).not.toContain("4.6K");
+  });
+
+  it("handles numeric strings without skewing bars", () => {
+    const output = renderUsageChart(
+      [
+        {
+          day: "2026-01-03",
+          inputTokens: "1000",
+          outputTokens: "1000",
+          totalTokens: "2000",
+          requests: 1,
+        } as unknown as Parameters<typeof renderUsageChart>[0][number],
+      ],
+      10,
+    );
+    expect(output).toContain("█████▒▒▒▒▒");
+  });
+});

package/tests/paths.test.ts

@@ -0,0 +1,9 @@
+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");
+  });
+});

package/tsconfig.json

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

package/tsdown.config.ts

@@ -0,0 +1,5 @@
+import { defineConfig } from "tsdown";
+
+export default defineConfig({
+  entry: ["src/bin.ts"],
+});

package/vitest.config.ts

@@ -0,0 +1,7 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    include: ["tests/**/*.test.ts"],
+  },
+});