@getrouter/getrouter-cli 0.1.0

package/src/index.ts

@@ -0,0 +1 @@
+export {};

package/tests/auth/device.test.ts

@@ -0,0 +1,75 @@
+import { describe, expect, it, vi } from "vitest";
+import { generateAuthCode, pollAuthorize } from "../../src/core/auth/device";
+
+const makeErr = (status: number) => Object.assign(new Error("err"), { status });
+
+describe("device auth", () => {
+  it("polls until authorize succeeds", async () => {
+    const authorize = vi
+      .fn()
+      .mockRejectedValueOnce(makeErr(404))
+      .mockResolvedValue({
+        accessToken: "a",
+        refreshToken: "b",
+        expiresAt: "2026-01-03T00:00:00Z",
+      });
+    let now = 0;
+    const res = await pollAuthorize({
+      authorize,
+      code: "abc",
+      now: () => now,
+      sleep: async (ms) => {
+        now += ms;
+      },
+      initialDelayMs: 1,
+      maxDelayMs: 2,
+      timeoutMs: 100,
+    });
+    expect(res.accessToken).toBe("a");
+    expect(authorize).toHaveBeenCalledTimes(2);
+  });
+
+  it("fails on 400/403", async () => {
+    await expect(
+      pollAuthorize({
+        authorize: vi.fn().mockRejectedValue(makeErr(400)),
+        code: "abc",
+        sleep: async () => {},
+        now: () => 0,
+        timeoutMs: 10,
+      }),
+    ).rejects.toThrow("Auth code already used");
+    await expect(
+      pollAuthorize({
+        authorize: vi.fn().mockRejectedValue(makeErr(403)),
+        code: "abc",
+        sleep: async () => {},
+        now: () => 0,
+        timeoutMs: 10,
+      }),
+    ).rejects.toThrow("Auth code expired");
+  });
+
+  it("times out after deadline", async () => {
+    const authorize = vi.fn().mockRejectedValue(makeErr(404));
+    let now = 0;
+    await expect(
+      pollAuthorize({
+        authorize,
+        code: "abc",
+        now: () => now,
+        sleep: async (ms) => {
+          now += ms;
+        },
+        initialDelayMs: 5,
+        maxDelayMs: 5,
+        timeoutMs: 6,
+      }),
+    ).rejects.toThrow("Login timed out");
+  });
+
+  it("generates 13-char base32 auth code", () => {
+    const id = generateAuthCode();
+    expect(id).toMatch(/^[a-z2-7]{13}$/);
+  });
+});

package/tests/auth/status.test.ts

@@ -0,0 +1,64 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { describe, expect, it, vi } from "vitest";
+import { clearAuth, getAuthStatus } from "../../src/core/auth";
+import { readAuth, writeAuth } from "../../src/core/config";
+
+const makeDir = () => fs.mkdtempSync(path.join(os.tmpdir(), "getrouter-"));
+
+describe("auth status", () => {
+  it("returns logged_out when missing", () => {
+    const dir = makeDir();
+    process.env.GETROUTER_CONFIG_DIR = dir;
+    const status = getAuthStatus();
+    expect(status.status).toBe("logged_out");
+  });
+
+  it("returns logged_out when expired", () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2026-01-02T00:00:00Z"));
+    const dir = makeDir();
+    process.env.GETROUTER_CONFIG_DIR = dir;
+    writeAuth({
+      accessToken: "a",
+      refreshToken: "b",
+      expiresAt: "2026-01-01T00:00:00Z",
+      tokenType: "Bearer",
+    });
+    const status = getAuthStatus();
+    expect(status.status).toBe("logged_out");
+    vi.useRealTimers();
+  });
+
+  it("returns logged_in when valid", () => {
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date("2026-01-02T00:00:00Z"));
+    const dir = makeDir();
+    process.env.GETROUTER_CONFIG_DIR = dir;
+    writeAuth({
+      accessToken: "tokenvalue",
+      refreshToken: "refreshvalue",
+      expiresAt: "2026-01-03T00:00:00Z",
+      tokenType: "Bearer",
+    });
+    const status = getAuthStatus();
+    expect(status.status).toBe("logged_in");
+    expect(status.note).toBeUndefined();
+    vi.useRealTimers();
+  });
+
+  it("clears auth state", () => {
+    const dir = makeDir();
+    process.env.GETROUTER_CONFIG_DIR = dir;
+    writeAuth({
+      accessToken: "a",
+      refreshToken: "b",
+      expiresAt: "c",
+      tokenType: "Bearer",
+    });
+    clearAuth();
+    const auth = readAuth();
+    expect(auth.accessToken).toBe("");
+  });
+});

package/tests/cli.test.ts

@@ -0,0 +1,31 @@
+import { readdirSync } from "node:fs";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import { createProgram } from "../src/cli";
+
+describe("getrouter cli", () => {
+  it("exposes name and help", () => {
+    const program = createProgram();
+    expect(program.name()).toBe("getrouter");
+    expect(program.helpInformation()).toContain("getrouter");
+  });
+
+  it("only ships registered command entrypoints", () => {
+    const cmdDir = path.join(process.cwd(), "src", "cmd");
+    const files = readdirSync(cmdDir).filter((file) => file.endsWith(".ts"));
+    const expected = [
+      "auth.ts",
+      "claude.ts",
+      "codex.ts",
+      "config-helpers.ts",
+      "config.ts",
+      "env.ts",
+      "index.ts",
+      "keys.ts",
+      "models.ts",
+      "status.ts",
+      "usages.ts",
+    ];
+    expect(files.sort()).toEqual(expected.sort());
+  });
+});

package/tests/cmd/auth.test.ts

@@ -0,0 +1,90 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { describe, expect, it, vi } from "vitest";
+import { createProgram } from "../../src/cli";
+import { createApiClients } from "../../src/core/api/client";
+import {
+  buildLoginUrl,
+  generateAuthCode,
+  openLoginUrl,
+  pollAuthorize,
+} from "../../src/core/auth/device";
+import { writeAuth } from "../../src/core/config";
+import type {
+  AuthService,
+  ConsumerService,
+  SubscriptionService,
+} from "../../src/generated/router/dashboard/v1";
+
+vi.mock("../../src/core/api/client", () => ({
+  createApiClients: vi.fn(),
+}));
+
+vi.mock("../../src/core/auth/device", async () => {
+  const actual = await vi.importActual<
+    typeof import("../../src/core/auth/device")
+  >("../../src/core/auth/device");
+  return {
+    ...actual,
+    generateAuthCode: vi.fn(() => "abcde234567fg"),
+    openLoginUrl: vi.fn(async () => {}),
+    pollAuthorize: vi.fn(),
+  };
+});
+
+const makeDir = () => fs.mkdtempSync(path.join(os.tmpdir(), "getrouter-"));
+
+describe("auth commands", () => {
+  it("login polls authorize and writes auth.json", async () => {
+    const dir = makeDir();
+    process.env.GETROUTER_CONFIG_DIR = dir;
+    const authService = {
+      Authorize: vi.fn(),
+      CreateAuth: vi.fn(),
+      RefreshToken: vi.fn(),
+    } as AuthService;
+    (createApiClients as unknown as ReturnType<typeof vi.fn>).mockReturnValue({
+      authService,
+      consumerService: {} as unknown as ConsumerService,
+      subscriptionService: {} as SubscriptionService,
+    });
+    (pollAuthorize as unknown as ReturnType<typeof vi.fn>).mockResolvedValue({
+      accessToken: "access",
+      refreshToken: "refresh",
+      expiresAt: "2026-01-03T00:00:00Z",
+    });
+    const log = vi.spyOn(console, "log").mockImplementation(() => {});
+    const program = createProgram();
+    await program.parseAsync(["node", "getrouter", "login"]);
+    const saved = JSON.parse(
+      fs.readFileSync(path.join(dir, "auth.json"), "utf-8"),
+    );
+    expect(saved.accessToken).toBe("access");
+    expect(saved.refreshToken).toBe("refresh");
+    expect(saved.tokenType).toBe("Bearer");
+    expect(openLoginUrl).toHaveBeenCalledWith(
+      buildLoginUrl(
+        (generateAuthCode as unknown as ReturnType<typeof vi.fn>).mock
+          .results[0].value,
+      ),
+    );
+    log.mockRestore();
+  });
+
+  it("logout clears local auth", async () => {
+    const dir = makeDir();
+    process.env.GETROUTER_CONFIG_DIR = dir;
+    writeAuth({
+      accessToken: "a",
+      refreshToken: "b",
+      expiresAt: "c",
+      tokenType: "Bearer",
+    });
+    const log = vi.spyOn(console, "log").mockImplementation(() => {});
+    const program = createProgram();
+    await program.parseAsync(["node", "getrouter", "logout"]);
+    expect(log.mock.calls[0][0]).toContain("Cleared local auth data");
+    log.mockRestore();
+  });
+});

package/tests/cmd/claude.test.ts

@@ -0,0 +1,132 @@
+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 { createProgram } from "../../src/cli";
+import { createApiClients } from "../../src/core/api/client";
+import {
+  getEnvFilePath,
+  getHookFilePath,
+  resolveShellRcPath,
+} from "../../src/core/setup/env";
+import type {
+  AuthService,
+  ConsumerService,
+  SubscriptionService,
+} from "../../src/generated/router/dashboard/v1";
+
+vi.mock("../../src/core/api/client", () => ({
+  createApiClients: vi.fn(),
+}));
+
+const makeDir = () => fs.mkdtempSync(path.join(os.tmpdir(), "getrouter-"));
+const mockConsumer = { id: "c1", apiKey: "key-123" };
+
+const originalIsTTY = process.stdin.isTTY;
+const setStdinTTY = (value: boolean) => {
+  Object.defineProperty(process.stdin, "isTTY", {
+    value,
+    configurable: true,
+  });
+};
+
+const ENV_KEYS = [
+  "GETROUTER_CONFIG_DIR",
+  "HOME",
+  "SHELL",
+  "OPENAI_BASE_URL",
+  "OPENAI_API_KEY",
+  "ANTHROPIC_BASE_URL",
+  "ANTHROPIC_API_KEY",
+];
+
+const originalEnv = Object.fromEntries(
+  ENV_KEYS.map((key) => [key, process.env[key]]),
+);
+
+afterEach(() => {
+  setStdinTTY(originalIsTTY);
+  prompts.inject([]);
+  for (const key of ENV_KEYS) {
+    if (originalEnv[key] === undefined) {
+      delete process.env[key];
+    } else {
+      process.env[key] = originalEnv[key];
+    }
+  }
+});
+
+describe("claude command", () => {
+  it("writes Anthropic-only env file", async () => {
+    setStdinTTY(true);
+    prompts.inject([mockConsumer]);
+    const dir = makeDir();
+    process.env.GETROUTER_CONFIG_DIR = dir;
+    process.env.HOME = dir;
+    process.env.SHELL = "/bin/bash";
+    (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,
+      subscriptionService: {} as SubscriptionService,
+      authService: {} as AuthService,
+    });
+    const program = createProgram();
+    await program.parseAsync(["node", "getrouter", "claude"]);
+    const content = fs.readFileSync(getEnvFilePath("sh", dir), "utf8");
+    expect(content).toContain("ANTHROPIC_BASE_URL");
+    expect(content).toContain("ANTHROPIC_API_KEY");
+    expect(content).not.toContain("OPENAI_BASE_URL");
+    expect(content).not.toContain("OPENAI_API_KEY");
+  });
+
+  it("installs into rc and updates process env", async () => {
+    setStdinTTY(true);
+    prompts.inject([mockConsumer]);
+    const dir = makeDir();
+    process.env.GETROUTER_CONFIG_DIR = dir;
+    process.env.HOME = dir;
+    process.env.SHELL = "/bin/bash";
+    (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,
+      subscriptionService: {} as SubscriptionService,
+      authService: {} as AuthService,
+    });
+    const program = createProgram();
+    await program.parseAsync(["node", "getrouter", "claude", "--install"]);
+    const envPath = getEnvFilePath("sh", dir);
+    const hookPath = getHookFilePath("bash", dir);
+    const rcPath = resolveShellRcPath("bash", dir);
+    const rcContent = fs.readFileSync(rcPath ?? "", "utf8");
+    expect(rcContent).toContain(`source ${envPath}`);
+    expect(rcContent).toContain(`source ${hookPath}`);
+    expect(fs.existsSync(hookPath)).toBe(true);
+    expect(process.env.ANTHROPIC_BASE_URL).toBe(
+      "https://api.getrouter.dev/claude",
+    );
+    expect(process.env.ANTHROPIC_API_KEY).toBe("key-123");
+  });
+});

package/tests/cmd/codex.test.ts

@@ -0,0 +1,147 @@
+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 { createProgram } from "../../src/cli";
+import { createApiClients } from "../../src/core/api/client";
+import type { ConsumerService } from "../../src/generated/router/dashboard/v1";
+
+vi.mock("../../src/core/api/client", () => ({
+  createApiClients: vi.fn(),
+}));
+
+const makeDir = () => fs.mkdtempSync(path.join(os.tmpdir(), "getrouter-"));
+const codexConfigPath = (dir: string) =>
+  path.join(dir, ".codex", "config.toml");
+const codexAuthPath = (dir: string) => path.join(dir, ".codex", "auth.json");
+
+const mockConsumer = { id: "c1", apiKey: "key-123" };
+
+const originalIsTTY = process.stdin.isTTY;
+const setStdinTTY = (value: boolean) => {
+  Object.defineProperty(process.stdin, "isTTY", {
+    value,
+    configurable: true,
+  });
+};
+
+const ENV_KEYS = ["GETROUTER_CONFIG_DIR", "HOME", "SHELL"];
+const originalEnv = Object.fromEntries(
+  ENV_KEYS.map((key) => [key, process.env[key]]),
+);
+
+afterEach(() => {
+  setStdinTTY(originalIsTTY);
+  prompts.inject([]);
+  for (const key of ENV_KEYS) {
+    if (originalEnv[key] === undefined) {
+      delete process.env[key];
+    } else {
+      process.env[key] = originalEnv[key];
+    }
+  }
+});
+
+describe("codex command", () => {
+  it("writes codex config and auth after interactive flow", async () => {
+    setStdinTTY(true);
+    const dir = makeDir();
+    process.env.HOME = dir;
+    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"]);
+
+    const config = fs.readFileSync(codexConfigPath(dir), "utf8");
+    expect(config).toContain('model = "gpt-5.2-codex"');
+    expect(config).toContain('model_reasoning_effort = "xhigh"');
+    expect(config).toContain('model_provider = "getrouter"');
+    expect(config).toContain("[model_providers.getrouter]");
+    expect(config).toContain('name = "getrouter"');
+    expect(config).toContain('base_url = "https://api.getrouter.dev/codex"');
+    expect(config).toContain('wire_api = "responses"');
+    expect(config).toContain("requires_openai_auth = true");
+
+    const auth = JSON.parse(fs.readFileSync(codexAuthPath(dir), "utf8"));
+    expect(auth.OPENAI_API_KEY).toBe("key-123");
+  });
+
+  it("merges existing codex config and auth", async () => {
+    setStdinTTY(true);
+    const dir = makeDir();
+    process.env.HOME = dir;
+    const codexDir = path.join(dir, ".codex");
+    fs.mkdirSync(codexDir, { recursive: true });
+    fs.writeFileSync(
+      codexConfigPath(dir),
+      [
+        'theme = "dark"',
+        'model = "old-model"',
+        'model_provider = "other"',
+        "",
+        "[model_providers.other]",
+        'name = "other"',
+        'base_url = "https://example.com"',
+        "",
+        "[model_providers.getrouter]",
+        'name = "old"',
+        'base_url = "https://old.example.com"',
+        'extra = "keep"',
+        "",
+      ].join("\n"),
+    );
+    fs.writeFileSync(
+      codexAuthPath(dir),
+      JSON.stringify({ OTHER: "keep", OPENAI_API_KEY: "old" }, null, 2),
+    );
+    prompts.inject(["gpt-5.2", "low", 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"]);
+
+    const config = fs.readFileSync(codexConfigPath(dir), "utf8");
+    expect(config).toContain('theme = "dark"');
+    expect(config).toContain("[model_providers.other]");
+    expect(config).toContain('base_url = "https://example.com"');
+    expect(config).toContain('extra = "keep"');
+    expect(config).toContain('model = "gpt-5.2"');
+    expect(config).toContain('model_reasoning_effort = "low"');
+    expect(config).toContain('model_provider = "getrouter"');
+    expect(config).toContain('base_url = "https://api.getrouter.dev/codex"');
+
+    const auth = JSON.parse(fs.readFileSync(codexAuthPath(dir), "utf8"));
+    expect(auth.OPENAI_API_KEY).toBe("key-123");
+    expect(auth.OTHER).toBe("keep");
+  });
+});

package/tests/cmd/config-helpers.test.ts

@@ -0,0 +1,18 @@
+import { describe, expect, it } from "vitest";
+import {
+  normalizeApiBase,
+  parseConfigValue,
+} from "../../src/cmd/config-helpers";
+
+describe("config helpers", () => {
+  it("normalizes apiBase", () => {
+    expect(normalizeApiBase("https://getrouter.dev/")).toBe(
+      "https://getrouter.dev",
+    );
+  });
+
+  it("parses json values", () => {
+    expect(parseConfigValue("json", "true")).toBe(true);
+    expect(parseConfigValue("json", "0")).toBe(false);
+  });
+});

package/tests/cmd/config.test.ts

@@ -0,0 +1,56 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { createProgram } from "../../src/cli";
+import { parseConfigValue } from "../../src/cmd/config-helpers";
+
+const makeDir = () => fs.mkdtempSync(path.join(os.tmpdir(), "getrouter-"));
+const originalConfigDir = process.env.GETROUTER_CONFIG_DIR;
+
+afterEach(() => {
+  if (originalConfigDir == null) {
+    delete process.env.GETROUTER_CONFIG_DIR;
+  } else {
+    process.env.GETROUTER_CONFIG_DIR = originalConfigDir;
+  }
+});
+
+describe("config command", () => {
+  it("prints full config when no args", async () => {
+    process.env.GETROUTER_CONFIG_DIR = makeDir();
+    const log = vi.spyOn(console, "log").mockImplementation(() => {});
+    const program = createProgram();
+    await program.parseAsync(["node", "getrouter", "config"]);
+    const output = log.mock.calls.map((c) => c[0]).join("\n");
+    expect(output).toContain("apiBase=");
+    expect(output).toContain("json=");
+    log.mockRestore();
+  });
+
+  it("sets config key and prints value", async () => {
+    process.env.GETROUTER_CONFIG_DIR = makeDir();
+    const log = vi.spyOn(console, "log").mockImplementation(() => {});
+    const program = createProgram();
+    await program.parseAsync([
+      "node",
+      "getrouter",
+      "config",
+      "apiBase",
+      "https://getrouter.dev",
+    ]);
+    const output = log.mock.calls.map((c) => c[0]).join("\n");
+    expect(output).toContain("apiBase=https://getrouter.dev");
+    log.mockRestore();
+  });
+});
+
+describe("config validation", () => {
+  it("rejects invalid json value", () => {
+    expect(() => parseConfigValue("json", "nope")).toThrow();
+  });
+
+  it("rejects invalid apiBase", () => {
+    expect(() => parseConfigValue("apiBase", "ftp://bad")).toThrow();
+  });
+});