@getrouter/getrouter-cli 0.1.13 → 0.1.14

package/src/core/setup/codex.ts

@@ -39,23 +39,105 @@ const PROVIDER_KEYS = [
   "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*=/);
-
-const parseTomlRhsValue = (rhs: string) => {
+function splitLines(content: string): string[] {
+  if (content.length === 0) return [];
+  return content.split(/\r?\n/);
+}
+
+function isLegacyTomlRootMarker(key: string): boolean {
+  return (LEGACY_TOML_ROOT_MARKERS as readonly string[]).includes(key);
+}
+
+function rootValues(
+  input: CodexConfigInput,
+): Record<(typeof ROOT_KEYS)[number], string> {
+  return {
+    model: `"${input.model}"`,
+    model_reasoning_effort: `"${input.reasoning}"`,
+    model_provider: `"${CODEX_PROVIDER}"`,
+  };
+}
+
+function providerValues(): Record<(typeof PROVIDER_KEYS)[number], string> {
+  return {
+    name: `"${CODEX_PROVIDER}"`,
+    base_url: `"${CODEX_BASE_URL}"`,
+    wire_api: `"responses"`,
+    requires_openai_auth: "true",
+  };
+}
+
+const HEADER_RE = /^\s*\[([^\]]+)\]\s*$/;
+const KEY_RE = /^\s*([A-Za-z0-9_.-]+)\s*=/;
+
+function matchHeader(line: string): RegExpMatchArray | null {
+  return line.match(HEADER_RE);
+}
+
+function matchKey(line: string): RegExpMatchArray | null {
+  return line.match(KEY_RE);
+}
+
+function readKeyFromLine(line: string): string | undefined {
+  const match = matchKey(line);
+  return match?.[1];
+}
+
+function readStringValue(
+  data: Record<string, unknown>,
+  key: string,
+): string | undefined {
+  const value = data[key];
+  return typeof value === "string" ? value : undefined;
+}
+
+function findSectionEnd(lines: string[], startIndex: number): number {
+  for (let i = startIndex; i < lines.length; i += 1) {
+    const line = lines[i];
+    if (line !== undefined && matchHeader(line)) {
+      return i;
+    }
+  }
+  return lines.length;
+}
+
+function upsertKeyLines<K extends string>(
+  lines: string[],
+  startIndex: number,
+  endIndex: number,
+  keys: readonly K[],
+  valueMap: Record<K, string>,
+): Set<K> {
+  const found = new Set<K>();
+
+  for (let i = startIndex; i < endIndex; i += 1) {
+    const line = lines[i];
+    if (line === undefined) continue;
+
+    const keyMatch = matchKey(line);
+    if (!keyMatch) continue;
+
+    const key = keyMatch[1] as K;
+    if (!keys.includes(key)) continue;
+
+    lines[i] = `${key} = ${valueMap[key]}`;
+    found.add(key);
+  }
+
+  return found;
+}
+
+function missingKeyLines<K extends string>(
+  keys: readonly K[],
+  found: ReadonlySet<K>,
+  valueMap: Record<K, string>,
+): string[] {
+  return keys
+    .filter((key) => !found.has(key))
+    .map((key) => `${key} = ${valueMap[key]}`);
+}
+
+function parseTomlRhsValue(rhs: string): string {
   const trimmed = rhs.trim();
   if (!trimmed) return "";
   const first = trimmed[0];
@@ -65,33 +147,31 @@ const parseTomlRhsValue = (rhs: string) => {
   }
   const hashIndex = trimmed.indexOf("#");
   return (hashIndex === -1 ? trimmed : trimmed.slice(0, hashIndex)).trim();
-};
+}
 
-const readRootValue = (lines: string[], key: string) => {
+function readRootValue(lines: string[], key: string): string | undefined {
   for (const line of lines) {
     if (matchHeader(line)) break;
-    const keyMatch = matchKey(line);
-    if (keyMatch?.[1] === key) {
-      const parts = line.split("=");
-      parts.shift();
-      return parseTomlRhsValue(parts.join("="));
+
+    const lineKey = readKeyFromLine(line);
+    if (lineKey === key) {
+      const rhs = line.slice(line.indexOf("=") + 1);
+      return parseTomlRhsValue(rhs);
     }
   }
   return undefined;
-};
+}
 
-export const readCodexTomlRootValues = (
-  content: string,
-): CodexTomlRootValues => {
-  const lines = content.length ? content.split(/\r?\n/) : [];
+export function readCodexTomlRootValues(content: string): CodexTomlRootValues {
+  const lines = splitLines(content);
   return {
     model: readRootValue(lines, "model"),
     reasoning: readRootValue(lines, "model_reasoning_effort"),
     provider: readRootValue(lines, "model_provider"),
   };
-};
+}
 
-const normalizeTomlString = (value?: string) => {
+function normalizeTomlString(value?: string): string {
   if (!value) return "";
   const trimmed = value.trim();
   if (
@@ -101,9 +181,9 @@ const normalizeTomlString = (value?: string) => {
     return trimmed.slice(1, -1).trim().toLowerCase();
   }
   return trimmed.replace(/['"]/g, "").trim().toLowerCase();
-};
+}
 
-const stripLegacyRootMarkers = (lines: string[]) => {
+function stripLegacyRootMarkers(lines: string[]): string[] {
   const updated: string[] = [];
   let inRoot = true;
 
@@ -112,60 +192,46 @@ const stripLegacyRootMarkers = (lines: string[]) => {
       inRoot = false;
     }
     if (inRoot) {
-      const keyMatch = matchKey(line);
-      const key = keyMatch?.[1];
-      if (key && LEGACY_TOML_ROOT_MARKERS.includes(key as never)) continue;
+      const key = readKeyFromLine(line);
+      if (key !== undefined && isLegacyTomlRootMarker(key)) continue;
     }
     updated.push(line);
   }
 
   return updated;
-};
+}
 
-export const mergeCodexToml = (content: string, input: CodexConfigInput) => {
-  const lines = content.length ? content.split(/\r?\n/) : [];
-  const updated = [...stripLegacyRootMarkers(lines)];
+export function mergeCodexToml(
+  content: string,
+  input: CodexConfigInput,
+): string {
+  const lines = splitLines(content);
+  const updated = stripLegacyRootMarkers(lines);
   const rootValueMap = rootValues(input);
   const providerValueMap = providerValues();
 
-  let currentSection: string | null = null;
-  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) {
-      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);
-    }
-  }
-
-  // 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]}`,
+  const firstHeaderIndex = updated.findIndex(
+    (line) => matchHeader(line) !== null,
+  );
+  const rootEnd = firstHeaderIndex === -1 ? updated.length : firstHeaderIndex;
+
+  const rootFound = upsertKeyLines(
+    updated,
+    0,
+    rootEnd,
+    ROOT_KEYS,
+    rootValueMap,
   );
+
+  const missingRoot = missingKeyLines(ROOT_KEYS, rootFound, rootValueMap);
   if (missingRoot.length > 0) {
+    const insertIndex = rootEnd;
     const needsBlank =
       insertIndex < updated.length && updated[insertIndex]?.trim() !== "";
+
     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,
@@ -174,47 +240,40 @@ export const mergeCodexToml = (content: string, input: CodexConfigInput) => {
     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]}`);
-    }
+    updated.push(
+      providerHeader,
+      ...PROVIDER_KEYS.map((key) => `${key} = ${providerValueMap[key]}`),
+    );
     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] ?? "")) {
-      providerEnd = i;
-      break;
-    }
-  }
+  const providerStart = providerHeaderIndex + 1;
+  const providerEnd = findSectionEnd(updated, providerStart);
 
-  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 providerFound = upsertKeyLines(
+    updated,
+    providerStart,
+    providerEnd,
+    PROVIDER_KEYS,
+    providerValueMap,
+  );
 
-  const missingProvider = PROVIDER_KEYS.filter(
-    (key) => !providerFound.has(key),
-  ).map((key) => `${key} = ${providerValueMap[key]}`);
+  const missingProvider = missingKeyLines(
+    PROVIDER_KEYS,
+    providerFound,
+    providerValueMap,
+  );
   if (missingProvider.length > 0) {
     updated.splice(providerEnd, 0, ...missingProvider);
   }
 
   return updated.join("\n");
-};
+}
 
-export const mergeAuthJson = (
+export function mergeAuthJson(
   data: Record<string, unknown>,
   apiKey: string,
-): Record<string, unknown> => {
+): Record<string, unknown> {
   const next: Record<string, unknown> = { ...data };
   for (const key of LEGACY_AUTH_MARKERS) {
     if (key in next) {
@@ -223,16 +282,16 @@ export const mergeAuthJson = (
   }
   next.OPENAI_API_KEY = apiKey;
   return next;
-};
+}
 
-const stripGetrouterProviderSection = (lines: string[]) => {
+function stripGetrouterProviderSection(lines: string[]): string[] {
   const updated: string[] = [];
   let skipSection = false;
 
   for (const line of lines) {
     const headerMatch = matchHeader(line);
     if (headerMatch) {
-      const section = headerMatch[1]?.trim() ?? "";
+      const section = headerMatch[1]?.trim();
       if (section === PROVIDER_SECTION) {
         skipSection = true;
         continue;
@@ -245,21 +304,21 @@ const stripGetrouterProviderSection = (lines: string[]) => {
   }
 
   return updated;
-};
+}
 
-const stripLegacyMarkersFromRoot = (rootLines: string[]) =>
-  rootLines.filter((line) => {
-    const keyMatch = matchKey(line);
-    const key = keyMatch?.[1];
-    return !(key && LEGACY_TOML_ROOT_MARKERS.includes(key as never));
+function stripLegacyMarkersFromRoot(rootLines: string[]): string[] {
+  return rootLines.filter((line) => {
+    const key = readKeyFromLine(line);
+    return !(key !== undefined && isLegacyTomlRootMarker(key));
   });
+}
 
-const setOrDeleteRootKey = (
+function setOrDeleteRootKey(
   rootLines: string[],
   key: string,
   value: string | undefined,
-) => {
-  const idx = rootLines.findIndex((line) => matchKey(line)?.[1] === key);
+): void {
+  const idx = rootLines.findIndex((line) => readKeyFromLine(line) === key);
   if (value === undefined) {
     if (idx !== -1) {
       rootLines.splice(idx, 1);
@@ -271,28 +330,28 @@ const setOrDeleteRootKey = (
   } else {
     rootLines.push(`${key} = ${value}`);
   }
-};
+}
 
-const deleteRootKey = (rootLines: string[], key: string) => {
+function deleteRootKey(rootLines: string[], key: string): void {
   setOrDeleteRootKey(rootLines, key, undefined);
-};
+}
 
-const hasLegacyRootMarkers = (lines: string[]) =>
-  lines.some((line) => {
-    const keyMatch = matchKey(line);
-    const key = keyMatch?.[1];
-    return !!(key && LEGACY_TOML_ROOT_MARKERS.includes(key as never));
+function hasLegacyRootMarkers(lines: string[]): boolean {
+  return lines.some((line) => {
+    const key = readKeyFromLine(line);
+    return key !== undefined && isLegacyTomlRootMarker(key);
   });
+}
 
-export const removeCodexConfig = (
+export function removeCodexConfig(
   content: string,
   options?: {
     restoreRoot?: CodexTomlRootValues;
     allowRootRemoval?: boolean;
   },
-) => {
+): { content: string; changed: boolean } {
   const { restoreRoot, allowRootRemoval = true } = options ?? {};
-  const lines = content.length ? content.split(/\r?\n/) : [];
+  const lines = splitLines(content);
   const providerIsGetrouter =
     normalizeTomlString(readRootValue(lines, "model_provider")) ===
     CODEX_PROVIDER;
@@ -332,27 +391,27 @@ export const removeCodexConfig = (
 
   const nextContent = recombined.join("\n");
   return { content: nextContent, changed: nextContent !== content };
-};
+}
 
-export const removeAuthJson = (
+export function removeAuthJson(
   data: Record<string, unknown>,
   options?: {
     installed?: string;
     restore?: string;
   },
-) => {
+): { data: Record<string, unknown>; changed: boolean } {
   const { installed, restore } = options ?? {};
   const next: Record<string, unknown> = { ...data };
   let changed = false;
 
-  const legacyInstalled =
-    typeof next._getrouter_codex_installed_openai_api_key === "string"
-      ? (next._getrouter_codex_installed_openai_api_key as string)
-      : undefined;
-  const legacyRestore =
-    typeof next._getrouter_codex_backup_openai_api_key === "string"
-      ? (next._getrouter_codex_backup_openai_api_key as string)
-      : undefined;
+  const legacyInstalled = readStringValue(
+    next,
+    "_getrouter_codex_installed_openai_api_key",
+  );
+  const legacyRestore = readStringValue(
+    next,
+    "_getrouter_codex_backup_openai_api_key",
+  );
 
   const effectiveInstalled = installed ?? legacyInstalled;
   const effectiveRestore = restore ?? legacyRestore;
@@ -364,14 +423,8 @@ export const removeAuthJson = (
     }
   }
 
-  const current =
-    typeof next.OPENAI_API_KEY === "string"
-      ? (next.OPENAI_API_KEY as string)
-      : undefined;
-  const restoreValue =
-    typeof effectiveRestore === "string" && effectiveRestore.trim().length > 0
-      ? effectiveRestore
-      : undefined;
+  const current = readStringValue(next, "OPENAI_API_KEY");
+  const restoreValue = effectiveRestore?.trim() ? effectiveRestore : undefined;
 
   if (effectiveInstalled && current && current === effectiveInstalled) {
     if (restoreValue) {
@@ -384,4 +437,4 @@ export const removeAuthJson = (
   }
 
   return { data: next, changed };
-};
+}

package/src/core/setup/env.ts

@@ -13,7 +13,7 @@ export type EnvShell = "sh" | "ps1";
 
 export type RcShell = "zsh" | "bash" | "fish" | "pwsh";
 
-const quoteEnvValue = (shell: EnvShell, value: string) => {
+function quoteEnvValue(shell: EnvShell, value: string): string {
   if (shell === "ps1") {
     // PowerShell: single quotes are literal; escape by doubling.
     return `'${value.replaceAll("'", "''")}'`;
@@ -21,35 +21,37 @@ const quoteEnvValue = (shell: EnvShell, value: string) => {
 
   // POSIX shell: use single quotes; escape embedded single quotes with: '\''.
   return `'${value.replaceAll("'", "'\\''")}'`;
-};
+}
 
-const renderLine = (shell: EnvShell, key: string, value: string) => {
+function renderLine(shell: EnvShell, key: string, value: string): string {
   if (shell === "ps1") {
     return `$env:${key}=${quoteEnvValue(shell, value)}`;
   }
   return `export ${key}=${quoteEnvValue(shell, value)}`;
-};
+}
+
+export function renderEnv(shell: EnvShell, vars: EnvVars): string {
+  const entries: Array<[keyof EnvVars, string]> = [
+    ["openaiBaseUrl", "OPENAI_BASE_URL"],
+    ["openaiApiKey", "OPENAI_API_KEY"],
+    ["anthropicBaseUrl", "ANTHROPIC_BASE_URL"],
+    ["anthropicApiKey", "ANTHROPIC_API_KEY"],
+  ];
 
-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));
+  for (const [varKey, envKey] of entries) {
+    const value = vars[varKey];
+    if (value) {
+      lines.push(renderLine(shell, envKey, value));
+    }
   }
+
   lines.push("");
   return lines.join("\n");
-};
+}
 
 // Wrap getrouter to source env after successful codex/claude runs.
-export const renderHook = (shell: RcShell) => {
+export function renderHook(shell: RcShell): string {
   if (shell === "pwsh") {
     return [
       "function getrouter {",
@@ -121,27 +123,31 @@ export const renderHook = (shell: RcShell) => {
     "}",
     "",
   ].join("\n");
-};
+}
 
-export const getEnvFilePath = (shell: EnvShell, configDir: string) =>
-  path.join(configDir, shell === "ps1" ? "env.ps1" : "env.sh");
+export function getEnvFilePath(shell: EnvShell, configDir: string): string {
+  return path.join(configDir, shell === "ps1" ? "env.ps1" : "env.sh");
+}
 
-export const getHookFilePath = (shell: RcShell, configDir: string) => {
+export function getHookFilePath(shell: RcShell, configDir: string): 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) => {
+export function writeEnvFile(filePath: string, content: string): void {
   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);
   }
-};
+}
 
-export const resolveShellRcPath = (shell: RcShell, homeDir: string) => {
+export function resolveShellRcPath(
+  shell: RcShell,
+  homeDir: string,
+): string | null {
   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");
@@ -158,12 +164,13 @@ export const resolveShellRcPath = (shell: RcShell, homeDir: string) => {
     );
   }
   return null;
-};
+}
 
-export const resolveEnvShell = (shell: RcShell): EnvShell =>
-  shell === "pwsh" ? "ps1" : "sh";
+export function resolveEnvShell(shell: RcShell): EnvShell {
+  return shell === "pwsh" ? "ps1" : "sh";
+}
 
-export const detectShell = (): RcShell => {
+export function detectShell(): RcShell {
   const shellPath = process.env.SHELL;
   if (shellPath) {
     const name = shellPath.split("/").pop()?.toLowerCase();
@@ -178,9 +185,9 @@ export const detectShell = (): RcShell => {
   }
   if (process.platform === "win32") return "pwsh";
   return "bash";
-};
+}
 
-export const applyEnvVars = (vars: EnvVars) => {
+export function applyEnvVars(vars: EnvVars): void {
   if (vars.openaiBaseUrl) process.env.OPENAI_BASE_URL = vars.openaiBaseUrl;
   if (vars.openaiApiKey) process.env.OPENAI_API_KEY = vars.openaiApiKey;
   if (vars.anthropicBaseUrl) {
@@ -189,16 +196,17 @@ export const applyEnvVars = (vars: EnvVars) => {
   if (vars.anthropicApiKey) {
     process.env.ANTHROPIC_API_KEY = vars.anthropicApiKey;
   }
-};
+}
 
-export const formatSourceLine = (shell: EnvShell, envPath: string) =>
-  shell === "ps1" ? `. ${envPath}` : `source ${envPath}`;
+export function formatSourceLine(shell: EnvShell, envPath: string): string {
+  return shell === "ps1" ? `. ${envPath}` : `source ${envPath}`;
+}
 
-export const trySourceEnv = (
+export function trySourceEnv(
   shell: RcShell,
   envShell: EnvShell,
   envPath: string,
-) => {
+): void {
   try {
     if (envShell === "ps1") {
       execSync(`pwsh -NoProfile -Command ". '${envPath}'"`, {
@@ -206,16 +214,15 @@ export const trySourceEnv = (
       });
       return;
     }
-    const command = shell === "fish" ? "source" : "source";
-    execSync(`${shell} -c "${command} '${envPath}'"`, {
+    execSync(`${shell} -c "source '${envPath}'"`, {
       stdio: "ignore",
     });
   } catch {
     // Best-effort: ignore failures and let the caller print instructions.
   }
-};
+}
 
-export const appendRcIfMissing = (rcPath: string, line: string) => {
+export function appendRcIfMissing(rcPath: string, line: string): boolean {
   let content = "";
   if (fs.existsSync(rcPath)) {
     content = fs.readFileSync(rcPath, "utf8");
@@ -225,4 +232,4 @@ export const appendRcIfMissing = (rcPath: string, line: string) => {
   fs.mkdirSync(path.dirname(rcPath), { recursive: true });
   fs.writeFileSync(rcPath, `${content}${prefix}${line}\n`, "utf8");
   return true;
-};
+}

package/src/core/usages/aggregate.ts

@@ -29,10 +29,10 @@ const toNumber = (value: number | string | undefined) => {
   return 0;
 };
 
-export const aggregateUsages = (
+export function aggregateUsages(
   usages: RawUsage[],
   maxDays = 7,
-): AggregatedUsage[] => {
+): AggregatedUsage[] {
   const totals = new Map<string, AggregatedUsage>();
 
   for (const usage of usages) {
@@ -66,4 +66,4 @@ export const aggregateUsages = (
   return Array.from(totals.values())
     .sort((a, b) => b.day.localeCompare(a.day))
     .slice(0, maxDays);
-};
+}