@getrouter/getrouter-cli 0.1.0

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@getrouter/getrouter-cli",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "CLI for getrouter.dev",
+  "bin": {
+    "getrouter": "dist/bin.mjs"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsx src/bin.ts --help",
+    "format": "biome check --write .",
+    "lint": "biome check .",
+    "test": "vitest run",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "packageManager": "bun@1.3.5",
+  "dependencies": {
+    "commander": "^12.1.0",
+    "prompts": "^2.4.2"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^2.3.10",
+    "@types/node": "^20.12.12",
+    "@types/prompts": "^2.4.9",
+    "tsdown": "^0.19.0-beta.2",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.3",
+    "vitest": "^2.1.8"
+  }
+}

package/src/bin.ts

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import { createProgram } from "./cli";
+
+createProgram().parse(process.argv);

package/src/cli.ts

@@ -0,0 +1,12 @@
+import { Command } from "commander";
+import { registerCommands } from "./cmd";
+
+export const createProgram = () => {
+  const program = new Command();
+  program
+    .name("getrouter")
+    .description("CLI for getrouter.dev")
+    .version("0.1.0");
+  registerCommands(program);
+  return program;
+};

package/src/cmd/auth.ts

@@ -0,0 +1,44 @@
+import type { Command } from "commander";
+import { createApiClients } from "../core/api/client";
+import { clearAuth } from "../core/auth";
+import {
+  buildLoginUrl,
+  generateAuthCode,
+  openLoginUrl,
+  pollAuthorize,
+} from "../core/auth/device";
+import { writeAuth } from "../core/config";
+
+export const registerAuthCommands = (program: Command) => {
+  program
+    .command("login")
+    .description("Login with device flow")
+    .action(async () => {
+      const { authService } = createApiClients({});
+      const authCode = generateAuthCode();
+      const url = buildLoginUrl(authCode);
+      console.log("🔐 To authenticate, visit:");
+      console.log(url);
+      console.log("⏳ Waiting for confirmation...");
+      void openLoginUrl(url);
+      const token = await pollAuthorize({
+        authorize: authService.Authorize.bind(authService),
+        code: authCode,
+      });
+      writeAuth({
+        accessToken: token.accessToken ?? "",
+        refreshToken: token.refreshToken ?? "",
+        expiresAt: token.expiresAt ?? "",
+        tokenType: "Bearer",
+      });
+      console.log("✅ Login successful.");
+    });
+
+  program
+    .command("logout")
+    .description("Clear local auth state")
+    .action(() => {
+      clearAuth();
+      console.log("Cleared local auth data.");
+    });
+};

package/src/cmd/claude.ts

@@ -0,0 +1,10 @@
+import type { Command } from "commander";
+import { buildAnthropicEnv, registerEnvCommand } from "./env";
+
+export const registerClaudeCommand = (program: Command) => {
+  registerEnvCommand(program, {
+    name: "claude",
+    description: "Configure Claude environment",
+    vars: buildAnthropicEnv,
+  });
+};

package/src/cmd/codex.ts

@@ -0,0 +1,119 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import type { Command } from "commander";
+import prompts from "prompts";
+import { createApiClients } from "../core/api/client";
+import {
+  MODEL_CHOICES,
+  mapReasoningValue,
+  REASONING_CHOICES,
+  REASONING_FUZZY_CHOICES,
+} from "../core/interactive/codex";
+import { fuzzySelect } from "../core/interactive/fuzzy";
+import { selectConsumer } from "../core/interactive/keys";
+import { mergeAuthJson, mergeCodexToml } from "../core/setup/codex";
+
+const CODEX_DIR = ".codex";
+
+const readFileIfExists = (filePath: string) =>
+  fs.existsSync(filePath) ? fs.readFileSync(filePath, "utf8") : "";
+
+const readAuthJson = (filePath: string) => {
+  if (!fs.existsSync(filePath)) return {};
+  const raw = fs.readFileSync(filePath, "utf8").trim();
+  if (!raw) return {};
+  const parsed = JSON.parse(raw);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error("Invalid auth.json format.");
+  }
+  return parsed as Record<string, unknown>;
+};
+
+const ensureCodexDir = () => {
+  const dir = path.join(os.homedir(), CODEX_DIR);
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+};
+
+const requireInteractive = () => {
+  if (!process.stdin.isTTY) {
+    throw new Error("Interactive mode required for codex configuration.");
+  }
+};
+
+const promptModel = async () =>
+  await fuzzySelect({
+    message:
+      "Select Model and Effort\nAccess legacy models by running codex -m <model_name> or in your config.toml",
+    choices: MODEL_CHOICES,
+  });
+
+const promptReasoning = async (model: string) =>
+  await fuzzySelect({
+    message: `Select Reasoning Level for ${model}`,
+    choices: REASONING_FUZZY_CHOICES,
+  });
+
+const formatReasoningLabel = (id: string) =>
+  REASONING_CHOICES.find((choice) => choice.id === id)?.label ?? id;
+
+export const registerCodexCommand = (program: Command) => {
+  program
+    .command("codex")
+    .description("Configure Codex")
+    .action(async () => {
+      requireInteractive();
+      const model = await promptModel();
+      if (!model) return;
+      const reasoningId = await promptReasoning(model);
+      if (!reasoningId) return;
+      const { consumerService } = createApiClients({});
+      const selected = await selectConsumer(consumerService);
+      if (!selected?.id) return;
+      const consumer = await consumerService.GetConsumer({ id: selected.id });
+      const apiKey = consumer?.apiKey ?? "";
+      if (!apiKey) {
+        throw new Error(
+          "API key not found. Please create one or choose another.",
+        );
+      }
+
+      const reasoningValue = mapReasoningValue(reasoningId);
+      const keyName = selected.name?.trim() || "(unnamed)";
+      const confirm = await prompts({
+        type: "confirm",
+        name: "confirm",
+        message: [
+          "Apply Codex configuration?",
+          `Model: ${model}`,
+          `Reasoning: ${formatReasoningLabel(reasoningId)} (${reasoningValue})`,
+          "Provider: getrouter",
+          `Key: ${keyName}`,
+        ].join("\n"),
+        initial: true,
+      });
+      if (!confirm.confirm) return;
+
+      const codexDir = ensureCodexDir();
+      const configPath = path.join(codexDir, "config.toml");
+      const authPath = path.join(codexDir, "auth.json");
+
+      const existingConfig = readFileIfExists(configPath);
+      const mergedConfig = mergeCodexToml(existingConfig, {
+        model,
+        reasoning: reasoningValue,
+      });
+      fs.writeFileSync(configPath, mergedConfig, "utf8");
+
+      const existingAuth = readAuthJson(authPath);
+      const mergedAuth = mergeAuthJson(existingAuth, apiKey);
+      fs.writeFileSync(authPath, JSON.stringify(mergedAuth, null, 2));
+      if (process.platform !== "win32") {
+        fs.chmodSync(authPath, 0o600);
+      }
+
+      console.log("✅ Updated ~/.codex/config.toml");
+      console.log("✅ Updated ~/.codex/auth.json");
+    });
+};

package/src/cmd/config-helpers.ts

@@ -0,0 +1,16 @@
+export const normalizeApiBase = (value: string) =>
+  value.trim().replace(/\/+$/, "");
+
+export const parseConfigValue = (key: "apiBase" | "json", raw: string) => {
+  if (key === "apiBase") {
+    const normalized = normalizeApiBase(raw);
+    if (!/^https?:\/\//.test(normalized)) {
+      throw new Error("apiBase must start with http:// or https://");
+    }
+    return normalized;
+  }
+  const lowered = raw.toLowerCase();
+  if (["true", "1"].includes(lowered)) return true;
+  if (["false", "0"].includes(lowered)) return false;
+  throw new Error("json must be true/false or 1/0");
+};

package/src/cmd/config.ts

@@ -0,0 +1,31 @@
+import type { Command } from "commander";
+import { readConfig, writeConfig } from "../core/config";
+import { parseConfigValue } from "./config-helpers";
+
+const VALID_KEYS = new Set(["apiBase", "json"]);
+
+export const registerConfigCommands = (program: Command) => {
+  program
+    .command("config")
+    .description("Manage CLI config")
+    .argument("[key]")
+    .argument("[value]")
+    .action((key: string | undefined, value: string | undefined) => {
+      const cfg = readConfig();
+      if (!key) {
+        console.log(`apiBase=${cfg.apiBase}`);
+        console.log(`json=${cfg.json}`);
+        return;
+      }
+      if (!value) {
+        throw new Error("Missing config value");
+      }
+      if (!VALID_KEYS.has(key)) {
+        throw new Error("Unknown config key");
+      }
+      const parsed = parseConfigValue(key as "apiBase" | "json", value);
+      const next = { ...cfg, [key]: parsed };
+      writeConfig(next);
+      console.log(`${key}=${(next as Record<string, unknown>)[key]}`);
+    });
+};

package/src/cmd/env.ts

@@ -0,0 +1,103 @@
+import os from "node:os";
+import type { Command } from "commander";
+import { createApiClients } from "../core/api/client";
+import { selectConsumer } from "../core/interactive/keys";
+import {
+  appendRcIfMissing,
+  applyEnvVars,
+  detectShell,
+  type EnvVars,
+  formatSourceLine,
+  getEnvFilePath,
+  getHookFilePath,
+  renderEnv,
+  renderHook,
+  resolveConfigDir,
+  resolveEnvShell,
+  resolveShellRcPath,
+  trySourceEnv,
+  writeEnvFile,
+} from "../core/setup/env";
+
+const CODEX_BASE_URL = "https://api.getrouter.dev/codex";
+const CLAUDE_BASE_URL = "https://api.getrouter.dev/claude";
+
+type EnvCommandOptions = {
+  install?: boolean;
+};
+
+type EnvCommandConfig = {
+  name: string;
+  description: string;
+  vars: (apiKey: string) => EnvVars;
+};
+
+export const registerEnvCommand = (
+  program: Command,
+  config: EnvCommandConfig,
+) => {
+  program
+    .command(config.name)
+    .description(config.description)
+    .option("--install", "Install into shell rc")
+    .action(async (options: EnvCommandOptions) => {
+      if (!process.stdin.isTTY) {
+        throw new Error("Interactive mode required for key selection.");
+      }
+      const shell = detectShell();
+      const envShell = resolveEnvShell(shell);
+      const configDir = resolveConfigDir();
+      const { consumerService } = createApiClients({});
+      const selected = await selectConsumer(consumerService);
+      if (!selected?.id) return;
+      const consumer = await consumerService.GetConsumer({ id: selected.id });
+      if (!consumer?.apiKey) {
+        throw new Error(
+          "API key not found. Please create one or choose another.",
+        );
+      }
+
+      const vars = config.vars(consumer.apiKey);
+      const envPath = getEnvFilePath(envShell, configDir);
+      writeEnvFile(envPath, renderEnv(envShell, vars));
+
+      let installed = false;
+      let rcPath: string | null = null;
+      if (options.install) {
+        const hookPath = getHookFilePath(shell, configDir);
+        writeEnvFile(hookPath, renderHook(shell));
+        rcPath = resolveShellRcPath(shell, os.homedir());
+        if (rcPath) {
+          const envLine = formatSourceLine(envShell, envPath);
+          const hookLine = formatSourceLine(envShell, hookPath);
+          const envAdded = appendRcIfMissing(rcPath, envLine);
+          const hookAdded = appendRcIfMissing(rcPath, hookLine);
+          installed = envAdded || hookAdded;
+        }
+        applyEnvVars(vars);
+        trySourceEnv(shell, envShell, envPath);
+      }
+
+      const sourceLine = formatSourceLine(envShell, envPath);
+      if (options.install) {
+        if (installed && rcPath) {
+          console.log(`✅ Added to ${rcPath}`);
+        } else if (rcPath) {
+          console.log(`ℹ️ Already configured in ${rcPath}`);
+        }
+      } else {
+        console.log("To load the environment in your shell, run:");
+        console.log(sourceLine);
+      }
+    });
+};
+
+export const buildOpenAIEnv = (apiKey: string): EnvVars => ({
+  openaiBaseUrl: CODEX_BASE_URL,
+  openaiApiKey: apiKey,
+});
+
+export const buildAnthropicEnv = (apiKey: string): EnvVars => ({
+  anthropicBaseUrl: CLAUDE_BASE_URL,
+  anthropicApiKey: apiKey,
+});

package/src/cmd/index.ts

@@ -0,0 +1,20 @@
+import type { Command } from "commander";
+import { registerAuthCommands } from "./auth";
+import { registerClaudeCommand } from "./claude";
+import { registerCodexCommand } from "./codex";
+import { registerConfigCommands } from "./config";
+import { registerKeysCommands } from "./keys";
+import { registerModelsCommands } from "./models";
+import { registerStatusCommand } from "./status";
+import { registerUsagesCommand } from "./usages";
+
+export const registerCommands = (program: Command) => {
+  registerAuthCommands(program);
+  registerCodexCommand(program);
+  registerClaudeCommand(program);
+  registerConfigCommands(program);
+  registerKeysCommands(program);
+  registerModelsCommands(program);
+  registerStatusCommand(program);
+  registerUsagesCommand(program);
+};

package/src/cmd/keys.ts

@@ -0,0 +1,207 @@
+import type { Command } from "commander";
+import { createApiClients } from "../core/api/client";
+import { redactSecrets } from "../core/config/redact";
+import {
+  confirmDelete,
+  promptKeyEnabled,
+  promptKeyName,
+  selectConsumerList,
+} from "../core/interactive/keys";
+import { renderTable } from "../core/output/table";
+import type {
+  ConsumerService,
+  routercommonv1_Consumer,
+} from "../generated/router/dashboard/v1";
+
+type ConsumerLike = Partial<routercommonv1_Consumer>;
+
+const consumerHeaders = [
+  "NAME",
+  "ENABLED",
+  "LAST_ACCESS",
+  "CREATED_AT",
+  "API_KEY",
+];
+
+const consumerRow = (consumer: ConsumerLike) => [
+  String(consumer.name ?? ""),
+  String(consumer.enabled ?? ""),
+  String(consumer.lastAccess ?? ""),
+  String(consumer.createdAt ?? ""),
+  String(consumer.apiKey ?? ""),
+];
+
+const outputConsumerTable = (consumer: ConsumerLike) => {
+  console.log(renderTable(consumerHeaders, [consumerRow(consumer)]));
+};
+
+const outputConsumers = (consumers: routercommonv1_Consumer[]) => {
+  const rows = consumers.map(consumerRow);
+  console.log(renderTable(consumerHeaders, rows));
+};
+
+const redactConsumer = (consumer: routercommonv1_Consumer) =>
+  redactSecrets(consumer);
+
+const requireInteractive = (message: string) => {
+  if (!process.stdin.isTTY) {
+    throw new Error(message);
+  }
+};
+
+const requireInteractiveForSelection = () =>
+  requireInteractive("Interactive mode required when key id is omitted.");
+
+const requireInteractiveForAction = (action: string) =>
+  requireInteractive(`Interactive mode required for keys ${action}.`);
+
+const updateConsumer = async (
+  consumerService: Pick<ConsumerService, "UpdateConsumer">,
+  consumer: routercommonv1_Consumer,
+  name: string | undefined,
+  enabled: boolean | undefined,
+) => {
+  const updateMask = [
+    name !== undefined && name !== consumer.name ? "name" : null,
+    enabled !== undefined && enabled !== consumer.enabled ? "enabled" : null,
+  ]
+    .filter(Boolean)
+    .join(",");
+  if (!updateMask) {
+    return consumer;
+  }
+  return consumerService.UpdateConsumer({
+    consumer: {
+      ...consumer,
+      name: name ?? consumer.name,
+      enabled: enabled ?? consumer.enabled,
+    },
+    updateMask,
+  });
+};
+
+const listConsumers = async (
+  consumerService: Pick<ConsumerService, "ListConsumers">,
+) => {
+  const res = await consumerService.ListConsumers({
+    pageSize: undefined,
+    pageToken: undefined,
+  });
+  const consumers = (res?.consumers ?? []).map(redactConsumer);
+  outputConsumers(consumers);
+};
+
+const resolveConsumerForUpdate = async (
+  consumerService: Pick<ConsumerService, "GetConsumer" | "ListConsumers">,
+  id?: string,
+) => {
+  if (id) {
+    return consumerService.GetConsumer({ id });
+  }
+  requireInteractiveForSelection();
+  return await selectConsumerList(consumerService, "Select key to update");
+};
+
+const resolveConsumerForDelete = async (
+  consumerService: Pick<ConsumerService, "GetConsumer" | "ListConsumers">,
+  id?: string,
+) => {
+  if (id) {
+    return consumerService.GetConsumer({ id });
+  }
+  requireInteractiveForSelection();
+  return await selectConsumerList(consumerService, "Select key to delete");
+};
+
+const createConsumer = async (
+  consumerService: Pick<ConsumerService, "CreateConsumer" | "UpdateConsumer">,
+) => {
+  requireInteractiveForAction("create");
+  const name = await promptKeyName();
+  const enabled = await promptKeyEnabled(true);
+  let consumer = await consumerService.CreateConsumer({});
+  consumer = await updateConsumer(consumerService, consumer, name, enabled);
+  outputConsumerTable(consumer);
+  console.log("Please store this API key securely.");
+};
+
+const updateConsumerById = async (
+  consumerService: Pick<
+    ConsumerService,
+    "GetConsumer" | "ListConsumers" | "UpdateConsumer"
+  >,
+  id?: string,
+) => {
+  requireInteractiveForAction("update");
+  const selected = await resolveConsumerForUpdate(consumerService, id);
+  if (!selected?.id) return;
+  const name = await promptKeyName(selected.name);
+  const enabled = await promptKeyEnabled(selected.enabled ?? true);
+  const consumer = await updateConsumer(
+    consumerService,
+    selected,
+    name,
+    enabled,
+  );
+  outputConsumerTable(redactConsumer(consumer));
+};
+
+const deleteConsumerById = async (
+  consumerService: Pick<
+    ConsumerService,
+    "GetConsumer" | "ListConsumers" | "DeleteConsumer"
+  >,
+  id?: string,
+) => {
+  requireInteractiveForAction("delete");
+  const selected = await resolveConsumerForDelete(consumerService, id);
+  if (!selected?.id) return;
+  const confirmed = await confirmDelete(selected);
+  if (!confirmed) return;
+  await consumerService.DeleteConsumer({ id: selected.id });
+  outputConsumerTable(redactConsumer(selected));
+};
+
+export const registerKeysCommands = (program: Command) => {
+  const keys = program.command("keys").description("Manage API keys");
+  keys.allowExcessArguments(false);
+
+  keys.action(async () => {
+    const { consumerService } = createApiClients({});
+    await listConsumers(consumerService);
+  });
+
+  keys
+    .command("list")
+    .description("List API keys")
+    .action(async () => {
+      const { consumerService } = createApiClients({});
+      await listConsumers(consumerService);
+    });
+
+  keys
+    .command("create")
+    .description("Create an API key")
+    .action(async () => {
+      const { consumerService } = createApiClients({});
+      await createConsumer(consumerService);
+    });
+
+  keys
+    .command("update")
+    .description("Update an API key")
+    .argument("[id]", "Key id")
+    .action(async (id?: string) => {
+      const { consumerService } = createApiClients({});
+      await updateConsumerById(consumerService, id);
+    });
+
+  keys
+    .command("delete")
+    .description("Delete an API key")
+    .argument("[id]", "Key id")
+    .action(async (id?: string) => {
+      const { consumerService } = createApiClients({});
+      await deleteConsumerById(consumerService, id);
+    });
+};

package/src/cmd/models.ts

@@ -0,0 +1,48 @@
+import type { Command } from "commander";
+import { createApiClients } from "../core/api/client";
+import { renderTable } from "../core/output/table";
+import type { routercommonv1_Model } from "../generated/router/dashboard/v1";
+
+const modelHeaders = ["NAME", "AUTHOR", "ENABLED", "UPDATED_AT"];
+
+const modelRow = (model: routercommonv1_Model) => [
+  String(model.name ?? ""),
+  String(model.author ?? ""),
+  String(model.enabled ?? ""),
+  String(model.updatedAt ?? ""),
+];
+
+const outputModels = (models: routercommonv1_Model[]) => {
+  console.log("🧠 Models");
+  console.log(renderTable(modelHeaders, models.map(modelRow)));
+};
+
+const listModels = async () => {
+  const { modelService } = createApiClients({});
+  const res = await modelService.ListModels({
+    pageSize: undefined,
+    pageToken: undefined,
+    filter: undefined,
+  });
+  const models = res?.models ?? [];
+  if (models.length === 0) {
+    console.log("😕 No models found");
+    return;
+  }
+  outputModels(models);
+};
+
+export const registerModelsCommands = (program: Command) => {
+  const models = program.command("models").description("List models");
+
+  models.action(async () => {
+    await listModels();
+  });
+
+  models
+    .command("list")
+    .description("List models")
+    .action(async () => {
+      await listModels();
+    });
+};