@getrouter/getrouter-cli 0.1.0

package/src/core/interactive/fuzzy.ts

@@ -0,0 +1,64 @@
+import prompts from "prompts";
+
+export type FuzzyChoice<T> = {
+  title: string;
+  value: T;
+  keywords?: string[];
+  description?: string;
+};
+
+const normalize = (value: string) => value.toLowerCase();
+
+const fuzzyScore = (query: string, target: string): number | null => {
+  if (!query) return 0;
+  let score = 0;
+  let lastIndex = -1;
+  for (const ch of query) {
+    const index = target.indexOf(ch, lastIndex + 1);
+    if (index === -1) return null;
+    score += index;
+    lastIndex = index;
+  }
+  return score;
+};
+
+const toSearchText = <T>(choice: FuzzyChoice<T>) =>
+  normalize([choice.title, ...(choice.keywords ?? [])].join(" ").trim());
+
+export const rankFuzzyChoices = <T>(
+  choices: FuzzyChoice<T>[],
+  input: string,
+  limit = 50,
+) => {
+  const query = normalize(input.trim());
+  if (!query) return choices.slice(0, limit);
+  const ranked = choices
+    .map((choice) => {
+      const score = fuzzyScore(query, toSearchText(choice));
+      return score == null ? null : { choice, score };
+    })
+    .filter(Boolean) as { choice: FuzzyChoice<T>; score: number }[];
+  ranked.sort(
+    (a, b) => a.score - b.score || a.choice.title.localeCompare(b.choice.title),
+  );
+  return ranked.slice(0, limit).map((entry) => entry.choice);
+};
+
+export const fuzzySelect = async <T>({
+  message,
+  choices,
+}: {
+  message: string;
+  choices: FuzzyChoice<T>[];
+}): Promise<T | null> => {
+  const response = await prompts({
+    type: "autocomplete",
+    name: "value",
+    message,
+    choices,
+    suggest: async (input, items) =>
+      rankFuzzyChoices(items as FuzzyChoice<T>[], String(input)),
+  });
+  if (response.value == null || response.value === "") return null;
+  return response.value as T;
+};

package/src/core/interactive/keys.ts

@@ -0,0 +1,164 @@
+import prompts from "prompts";
+import type {
+  ConsumerService as DashboardConsumerService,
+  routercommonv1_Consumer,
+} from "../../generated/router/dashboard/v1";
+import { fuzzySelect } from "./fuzzy";
+
+type Consumer = routercommonv1_Consumer;
+type ConsumerService = Pick<DashboardConsumerService, "ListConsumers">;
+
+export type KeyMenuAction =
+  | "list"
+  | "view"
+  | "create"
+  | "update"
+  | "delete"
+  | "exit";
+
+const sortByCreatedAtDesc = (consumers: Consumer[]) =>
+  consumers.slice().sort((a, b) => {
+    const aTime = Date.parse(a.createdAt ?? "") || 0;
+    const bTime = Date.parse(b.createdAt ?? "") || 0;
+    return bTime - aTime;
+  });
+
+const normalizeName = (consumer: Consumer) => {
+  const name = consumer.name?.trim();
+  return name && name.length > 0 ? name : "(unnamed)";
+};
+
+const buildNameCounts = (consumers: Consumer[]) => {
+  const counts = new Map<string, number>();
+  for (const consumer of consumers) {
+    const name = normalizeName(consumer);
+    counts.set(name, (counts.get(name) ?? 0) + 1);
+  }
+  return counts;
+};
+
+const formatChoice = (consumer: Consumer, nameCounts: Map<string, number>) => {
+  const name = normalizeName(consumer);
+  const createdAt = consumer.createdAt ?? "-";
+  const needsDetail = (nameCounts.get(name) ?? 0) > 1 || name === "(unnamed)";
+  return needsDetail ? `${name} (${createdAt})` : name;
+};
+
+export const selectKeyAction = async (): Promise<KeyMenuAction> => {
+  const actions: KeyMenuAction[] = [
+    "list",
+    "view",
+    "create",
+    "update",
+    "delete",
+    "exit",
+  ];
+  const response = await prompts({
+    type: "select",
+    name: "action",
+    message: "🔑 Select an action",
+    choices: [
+      { title: "List keys", value: "list" },
+      { title: "View key", value: "view" },
+      { title: "Create key", value: "create" },
+      { title: "Update key", value: "update" },
+      { title: "Delete key", value: "delete" },
+      { title: "Exit", value: "exit" },
+    ],
+  });
+  if (typeof response.action === "number") {
+    return actions[response.action] ?? "exit";
+  }
+  if (typeof response.action === "string") {
+    return response.action as KeyMenuAction;
+  }
+  return "exit";
+};
+
+export const promptKeyName = async (
+  initial?: string,
+): Promise<string | undefined> => {
+  const response = await prompts({
+    type: "text",
+    name: "name",
+    message: "Key name",
+    initial: initial ?? "",
+  });
+  const value = typeof response.name === "string" ? response.name.trim() : "";
+  return value.length > 0 ? value : undefined;
+};
+
+export const promptKeyEnabled = async (initial: boolean): Promise<boolean> => {
+  const response = await prompts({
+    type: "confirm",
+    name: "enabled",
+    message: "Enable this key?",
+    initial,
+  });
+  return typeof response.enabled === "boolean" ? response.enabled : initial;
+};
+
+export const selectConsumer = async (
+  consumerService: ConsumerService,
+): Promise<routercommonv1_Consumer | null> => {
+  const res = await consumerService.ListConsumers({
+    pageSize: undefined,
+    pageToken: undefined,
+  });
+  const consumers = res?.consumers ?? [];
+  if (consumers.length === 0) {
+    throw new Error("No available API keys");
+  }
+  const sorted = sortByCreatedAtDesc(consumers);
+  const nameCounts = buildNameCounts(sorted);
+  const selected = await fuzzySelect({
+    message: "🔎 Search keys",
+    choices: sorted.map((consumer) => ({
+      title: formatChoice(consumer, nameCounts),
+      value: consumer,
+      keywords: [normalizeName(consumer), consumer.createdAt ?? ""].filter(
+        Boolean,
+      ),
+    })),
+  });
+  return selected ?? null;
+};
+
+export const selectConsumerList = async (
+  consumerService: ConsumerService,
+  message: string,
+): Promise<routercommonv1_Consumer | null> => {
+  const res = await consumerService.ListConsumers({
+    pageSize: undefined,
+    pageToken: undefined,
+  });
+  const consumers = res?.consumers ?? [];
+  if (consumers.length === 0) {
+    throw new Error("No available API keys");
+  }
+  const sorted = sortByCreatedAtDesc(consumers);
+  const nameCounts = buildNameCounts(sorted);
+  const response = await prompts({
+    type: "select",
+    name: "value",
+    message,
+    choices: sorted.map((consumer) => ({
+      title: formatChoice(consumer, nameCounts),
+      value: consumer,
+    })),
+  });
+  if (response.value == null || response.value === "") return null;
+  return response.value as routercommonv1_Consumer;
+};
+
+export const confirmDelete = async (consumer: Consumer) => {
+  const name = consumer.name ?? "-";
+  const id = consumer.id ?? "-";
+  const response = await prompts({
+    type: "confirm",
+    name: "confirm",
+    message: `⚠️ Confirm delete ${name} (${id})?`,
+    initial: false,
+  });
+  return Boolean(response.confirm);
+};

package/src/core/output/table.ts

@@ -0,0 +1,34 @@
+type TableOptions = { maxColWidth?: number };
+
+const truncate = (value: string, max: number) => {
+  if (value.length <= max) return value;
+  if (max <= 3) return value.slice(0, max);
+  return `${value.slice(0, max - 3)}...`;
+};
+
+export const renderTable = (
+  headers: string[],
+  rows: string[][],
+  options: TableOptions = {},
+) => {
+  const maxColWidth = options.maxColWidth ?? 32;
+  const normalized = rows.map((row) =>
+    row.map((cell) => (cell && cell.length > 0 ? cell : "-")),
+  );
+  const widths = headers.map((header, index) => {
+    const colValues = normalized.map((row) => row[index] ?? "-");
+    const maxLen = Math.max(header.length, ...colValues.map((v) => v.length));
+    return Math.min(maxLen, maxColWidth);
+  });
+  const renderRow = (cells: string[]) =>
+    cells
+      .map((cell, index) => {
+        const raw = cell ?? "-";
+        const clipped = truncate(raw, widths[index]);
+        return clipped.padEnd(widths[index], " ");
+      })
+      .join("  ");
+  const headerRow = renderRow(headers);
+  const body = normalized.map((row) => renderRow(row)).join("\n");
+  return `${headerRow}\n${body}`;
+};

package/src/core/output/usages.ts

@@ -0,0 +1,75 @@
+import type { AggregatedUsage } from "../usages/aggregate";
+
+const INPUT_BLOCK = "█";
+const OUTPUT_BLOCK = "▒";
+const DEFAULT_WIDTH = 24;
+
+const formatTokens = (value: number) => {
+  const abs = Math.abs(value);
+  if (abs < 1000) return Math.round(value).toString();
+  const units = [
+    { threshold: 1_000_000_000, suffix: "B" },
+    { threshold: 1_000_000, suffix: "M" },
+    { threshold: 1_000, suffix: "K" },
+  ];
+  for (const unit of units) {
+    if (abs >= unit.threshold) {
+      const scaled = value / unit.threshold;
+      const decimals = Math.abs(scaled) < 10 ? 1 : 0;
+      let output = scaled.toFixed(decimals);
+      if (output.endsWith(".0")) {
+        output = output.slice(0, -2);
+      }
+      return `${output}${unit.suffix}`;
+    }
+  }
+  return Math.round(value).toString();
+};
+
+export const renderUsageChart = (
+  rows: AggregatedUsage[],
+  width = DEFAULT_WIDTH,
+) => {
+  const header = "📊 Usage (last 7 days) · Tokens";
+  if (rows.length === 0) {
+    return `${header}\n\nNo usage data available.`;
+  }
+  const normalized = rows.map((row) => {
+    const input = Number(row.inputTokens);
+    const output = Number(row.outputTokens);
+    const safeInput = Number.isFinite(input) ? input : 0;
+    const safeOutput = Number.isFinite(output) ? output : 0;
+    return {
+      day: row.day,
+      input: safeInput,
+      output: safeOutput,
+      total: safeInput + safeOutput,
+    };
+  });
+  const totals = normalized.map((row) => row.total);
+  const maxTotal = Math.max(0, ...totals);
+  const lines = normalized.map((row) => {
+    const total = row.total;
+    if (maxTotal === 0 || total === 0) {
+      return `${row.day} ${"".padEnd(width, " ")} I:0 O:0`;
+    }
+    const scaled = Math.max(1, Math.round((total / maxTotal) * width));
+    let inputBars = Math.round((row.input / total) * scaled);
+    let outputBars = Math.max(0, scaled - inputBars);
+    if (row.input > 0 && row.output > 0) {
+      if (inputBars === 0) {
+        inputBars = 1;
+        outputBars = Math.max(0, scaled - 1);
+      } else if (outputBars === 0) {
+        outputBars = 1;
+        inputBars = Math.max(0, scaled - 1);
+      }
+    }
+    const bar = `${INPUT_BLOCK.repeat(inputBars)}${OUTPUT_BLOCK.repeat(outputBars)}`;
+    const inputLabel = formatTokens(row.input);
+    const outputLabel = formatTokens(row.output);
+    return `${row.day} ${bar.padEnd(width, " ")} I:${inputLabel} O:${outputLabel}`;
+  });
+  const legend = `Legend: ${INPUT_BLOCK} input    ${OUTPUT_BLOCK} output`;
+  return [header, "", ...lines, "", legend].join("\n");
+};

package/src/core/paths.ts

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

package/src/core/setup/codex.ts

@@ -0,0 +1,129 @@
+type CodexConfigInput = {
+  model: string;
+  reasoning: string;
+};
+
+const CODEX_PROVIDER = "getrouter";
+const CODEX_BASE_URL = "https://api.getrouter.dev/codex";
+
+const ROOT_KEYS = [
+  "model",
+  "model_reasoning_effort",
+  "model_provider",
+] as const;
+const PROVIDER_SECTION = `model_providers.${CODEX_PROVIDER}`;
+const PROVIDER_KEYS = [
+  "name",
+  "base_url",
+  "wire_api",
+  "requires_openai_auth",
+] as const;
+
+const rootValues = (input: CodexConfigInput) => ({
+  model: `"${input.model}"`,
+  model_reasoning_effort: `"${input.reasoning}"`,
+  model_provider: `"${CODEX_PROVIDER}"`,
+});
+
+const providerValues = () => ({
+  name: `"${CODEX_PROVIDER}"`,
+  base_url: `"${CODEX_BASE_URL}"`,
+  wire_api: `"responses"`,
+  requires_openai_auth: "true",
+});
+
+const matchHeader = (line: string) => line.match(/^\s*\[([^\]]+)\]\s*$/);
+const matchKey = (line: string) => line.match(/^\s*([A-Za-z0-9_.-]+)\s*=/);
+
+export const mergeCodexToml = (content: string, input: CodexConfigInput) => {
+  const lines = content.length ? content.split(/\r?\n/) : [];
+  const updated = [...lines];
+  const rootValueMap = rootValues(input);
+  const providerValueMap = providerValues();
+
+  let currentSection: string | null = null;
+  let firstHeaderIndex: number | null = null;
+  const rootFound = new Set<string>();
+
+  for (let i = 0; i < updated.length; i += 1) {
+    const headerMatch = matchHeader(updated[i] ?? "");
+    if (headerMatch) {
+      currentSection = headerMatch[1]?.trim() ?? null;
+      if (firstHeaderIndex === null) {
+        firstHeaderIndex = i;
+      }
+      continue;
+    }
+    if (currentSection !== null) {
+      continue;
+    }
+    const keyMatch = matchKey(updated[i] ?? "");
+    if (!keyMatch) continue;
+    const key = keyMatch[1] as keyof typeof rootValueMap;
+    if (ROOT_KEYS.includes(key)) {
+      updated[i] = `${key} = ${rootValueMap[key]}`;
+      rootFound.add(key);
+    }
+  }
+
+  const insertIndex = firstHeaderIndex ?? updated.length;
+  const missingRoot = ROOT_KEYS.filter((key) => !rootFound.has(key)).map(
+    (key) => `${key} = ${rootValueMap[key]}`,
+  );
+  if (missingRoot.length > 0) {
+    const needsBlank =
+      insertIndex < updated.length && updated[insertIndex]?.trim() !== "";
+    updated.splice(insertIndex, 0, ...missingRoot, ...(needsBlank ? [""] : []));
+  }
+
+  const providerHeader = `[${PROVIDER_SECTION}]`;
+  const providerHeaderIndex = updated.findIndex(
+    (line) => line.trim() === providerHeader,
+  );
+  if (providerHeaderIndex === -1) {
+    if (updated.length > 0 && updated[updated.length - 1]?.trim() !== "") {
+      updated.push("");
+    }
+    updated.push(providerHeader);
+    for (const key of PROVIDER_KEYS) {
+      updated.push(`${key} = ${providerValueMap[key]}`);
+    }
+    return updated.join("\n");
+  }
+
+  let providerEnd = updated.length;
+  for (let i = providerHeaderIndex + 1; i < updated.length; i += 1) {
+    if (matchHeader(updated[i] ?? "")) {
+      providerEnd = i;
+      break;
+    }
+  }
+
+  const providerFound = new Set<string>();
+  for (let i = providerHeaderIndex + 1; i < providerEnd; i += 1) {
+    const keyMatch = matchKey(updated[i] ?? "");
+    if (!keyMatch) continue;
+    const key = keyMatch[1] as keyof typeof providerValueMap;
+    if (PROVIDER_KEYS.includes(key)) {
+      updated[i] = `${key} = ${providerValueMap[key]}`;
+      providerFound.add(key);
+    }
+  }
+
+  const missingProvider = PROVIDER_KEYS.filter(
+    (key) => !providerFound.has(key),
+  ).map((key) => `${key} = ${providerValueMap[key]}`);
+  if (missingProvider.length > 0) {
+    updated.splice(providerEnd, 0, ...missingProvider);
+  }
+
+  return updated.join("\n");
+};
+
+export const mergeAuthJson = (
+  data: Record<string, unknown>,
+  apiKey: string,
+): Record<string, unknown> => ({
+  ...data,
+  OPENAI_API_KEY: apiKey,
+});

package/src/core/setup/env.ts

@@ -0,0 +1,220 @@
+import { execSync } from "node:child_process";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+export type EnvVars = {
+  openaiBaseUrl?: string;
+  openaiApiKey?: string;
+  anthropicBaseUrl?: string;
+  anthropicApiKey?: string;
+};
+
+export type EnvShell = "sh" | "ps1";
+
+export type RcShell = "zsh" | "bash" | "fish" | "pwsh";
+
+const renderLine = (shell: EnvShell, key: string, value: string) => {
+  if (shell === "ps1") {
+    return `$env:${key}="${value}"`;
+  }
+  return `export ${key}=${value}`;
+};
+
+export const renderEnv = (shell: EnvShell, vars: EnvVars) => {
+  const lines: string[] = [];
+  if (vars.openaiBaseUrl) {
+    lines.push(renderLine(shell, "OPENAI_BASE_URL", vars.openaiBaseUrl));
+  }
+  if (vars.openaiApiKey) {
+    lines.push(renderLine(shell, "OPENAI_API_KEY", vars.openaiApiKey));
+  }
+  if (vars.anthropicBaseUrl) {
+    lines.push(renderLine(shell, "ANTHROPIC_BASE_URL", vars.anthropicBaseUrl));
+  }
+  if (vars.anthropicApiKey) {
+    lines.push(renderLine(shell, "ANTHROPIC_API_KEY", vars.anthropicApiKey));
+  }
+  lines.push("");
+  return lines.join("\n");
+};
+
+export const renderHook = (shell: RcShell) => {
+  if (shell === "pwsh") {
+    return [
+      "function getrouter {",
+      "  $cmd = Get-Command getrouter -CommandType Application,ExternalScript -ErrorAction SilentlyContinue | Select-Object -First 1",
+      "  if ($null -ne $cmd) {",
+      "    & $cmd.Source @args",
+      "  }",
+      "  $exitCode = $LASTEXITCODE",
+      "  if ($exitCode -ne 0) {",
+      "    return $exitCode",
+      "  }",
+      '  if ($args.Count -gt 0 -and ($args[0] -eq "codex" -or $args[0] -eq "claude")) {',
+      '    $configDir = if ($env:GETROUTER_CONFIG_DIR) { $env:GETROUTER_CONFIG_DIR } else { Join-Path $HOME ".getrouter" }',
+      '    $envPath = Join-Path $configDir "env.ps1"',
+      "    if (Test-Path $envPath) {",
+      "      . $envPath",
+      "    }",
+      "  }",
+      "  return $exitCode",
+      "}",
+      "",
+    ].join("\n");
+  }
+
+  if (shell === "fish") {
+    return [
+      "function getrouter",
+      "  command getrouter $argv",
+      "  set -l exit_code $status",
+      "  if test $exit_code -ne 0",
+      "    return $exit_code",
+      "  end",
+      "  if test (count $argv) -gt 0",
+      "    switch $argv[1]",
+      "      case codex claude",
+      "        set -l config_dir $GETROUTER_CONFIG_DIR",
+      '        if test -z "$config_dir"',
+      '          set config_dir "$HOME/.getrouter"',
+      "        end",
+      '        set -l env_path "$config_dir/env.sh"',
+      '        if test -f "$env_path"',
+      '          source "$env_path"',
+      "        end",
+      "    end",
+      "  end",
+      "  return $exit_code",
+      "end",
+      "",
+    ].join("\n");
+  }
+
+  return [
+    "getrouter() {",
+    '  command getrouter "$@"',
+    "  local exit_code=$?",
+    "  if [ $exit_code -ne 0 ]; then",
+    "    return $exit_code",
+    "  fi",
+    '  case "$1" in',
+    "    codex|claude)",
+    `      local config_dir="\${GETROUTER_CONFIG_DIR:-$HOME/.getrouter}"`,
+    '      local env_path="$config_dir/env.sh"',
+    '      if [ -f "$env_path" ]; then',
+    '        source "$env_path"',
+    "      fi",
+    "      ;;",
+    "  esac",
+    "  return $exit_code",
+    "}",
+    "",
+  ].join("\n");
+};
+
+export const getEnvFilePath = (shell: EnvShell, configDir: string) =>
+  path.join(configDir, shell === "ps1" ? "env.ps1" : "env.sh");
+
+export const getHookFilePath = (shell: RcShell, configDir: string) => {
+  if (shell === "pwsh") return path.join(configDir, "hook.ps1");
+  if (shell === "fish") return path.join(configDir, "hook.fish");
+  return path.join(configDir, "hook.sh");
+};
+
+export const writeEnvFile = (filePath: string, content: string) => {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, content, "utf8");
+  if (process.platform !== "win32") {
+    fs.chmodSync(filePath, 0o600);
+  }
+};
+
+export const resolveShellRcPath = (shell: RcShell, homeDir: string) => {
+  if (shell === "zsh") return path.join(homeDir, ".zshrc");
+  if (shell === "bash") return path.join(homeDir, ".bashrc");
+  if (shell === "fish") return path.join(homeDir, ".config/fish/config.fish");
+  if (shell === "pwsh") {
+    if (process.platform === "win32") {
+      return path.join(
+        homeDir,
+        "Documents/PowerShell/Microsoft.PowerShell_profile.ps1",
+      );
+    }
+    return path.join(
+      homeDir,
+      ".config/powershell/Microsoft.PowerShell_profile.ps1",
+    );
+  }
+  return null;
+};
+
+export const resolveEnvShell = (shell: RcShell): EnvShell =>
+  shell === "pwsh" ? "ps1" : "sh";
+
+export const detectShell = (): RcShell => {
+  const shellPath = process.env.SHELL;
+  if (shellPath) {
+    const name = shellPath.split("/").pop()?.toLowerCase();
+    if (
+      name === "zsh" ||
+      name === "bash" ||
+      name === "fish" ||
+      name === "pwsh"
+    ) {
+      return name;
+    }
+  }
+  if (process.platform === "win32") return "pwsh";
+  return "bash";
+};
+
+export const applyEnvVars = (vars: EnvVars) => {
+  if (vars.openaiBaseUrl) process.env.OPENAI_BASE_URL = vars.openaiBaseUrl;
+  if (vars.openaiApiKey) process.env.OPENAI_API_KEY = vars.openaiApiKey;
+  if (vars.anthropicBaseUrl) {
+    process.env.ANTHROPIC_BASE_URL = vars.anthropicBaseUrl;
+  }
+  if (vars.anthropicApiKey) {
+    process.env.ANTHROPIC_API_KEY = vars.anthropicApiKey;
+  }
+};
+
+export const formatSourceLine = (shell: EnvShell, envPath: string) =>
+  shell === "ps1" ? `. ${envPath}` : `source ${envPath}`;
+
+export const trySourceEnv = (
+  shell: RcShell,
+  envShell: EnvShell,
+  envPath: string,
+) => {
+  try {
+    if (envShell === "ps1") {
+      execSync(`pwsh -NoProfile -Command ". '${envPath}'"`, {
+        stdio: "ignore",
+      });
+      return;
+    }
+    const command = shell === "fish" ? "source" : "source";
+    execSync(`${shell} -c "${command} '${envPath}'"`, {
+      stdio: "ignore",
+    });
+  } catch {
+    // Best-effort: ignore failures and let the caller print instructions.
+  }
+};
+
+export const appendRcIfMissing = (rcPath: string, line: string) => {
+  let content = "";
+  if (fs.existsSync(rcPath)) {
+    content = fs.readFileSync(rcPath, "utf8");
+    if (content.includes(line)) return false;
+  }
+  const prefix = content && !content.endsWith("\n") ? "\n" : "";
+  fs.mkdirSync(path.dirname(rcPath), { recursive: true });
+  fs.writeFileSync(rcPath, `${content}${prefix}${line}\n`, "utf8");
+  return true;
+};
+
+export const resolveConfigDir = () =>
+  process.env.GETROUTER_CONFIG_DIR || path.join(os.homedir(), ".getrouter");