@getrouter/getrouter-cli 0.1.13 → 0.1.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getrouter/getrouter-cli",
-  "version": "0.1.13",
+  "version": "0.1.14",
   "type": "module",
   "description": "CLI for getrouter.dev",
   "bin": {

package/src/cli.ts

@@ -2,12 +2,14 @@ import { Command } from "commander";
 import { version } from "../package.json";
 import { registerCommands } from "./cmd";
 
-export const createProgram = () => {
+export function createProgram(): Command {
   const program = new Command();
   program
     .name("getrouter")
     .description("CLI for getrouter.dev")
     .version(version);
+
   registerCommands(program);
+
   return program;
-};
+}

package/src/cmd/auth.ts

@@ -9,7 +9,7 @@ import {
 } from "../core/auth/device";
 import { writeAuth } from "../core/config";
 
-export const registerAuthCommands = (program: Command) => {
+export function registerAuthCommands(program: Command): void {
   program
     .command("login")
     .description("Login with device flow")
@@ -41,4 +41,4 @@ export const registerAuthCommands = (program: Command) => {
       clearAuth();
       console.log("Cleared local auth data.");
     });
-};
+}

package/src/cmd/claude.ts

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

package/src/cmd/codex.ts

@@ -107,7 +107,7 @@ type CodexCommandOptions = {
   model?: string;
 };
 
-export const registerCodexCommand = (program: Command) => {
+export function registerCodexCommand(program: Command): void {
   const codex = program.command("codex").description("Configure Codex");
 
   codex
@@ -168,40 +168,43 @@ export const registerCodexCommand = (program: Command) => {
         updatedAt: now,
       };
       backup.updatedAt = now;
+
       backup.config ??= {};
       backup.config.previous ??= {};
+      const previousConfig = backup.config.previous;
       if (
-        backup.config.previous.model === undefined &&
+        previousConfig.model === undefined &&
         existingRoot.model &&
         existingRoot.model !== installedRoot.model
       ) {
-        backup.config.previous.model = existingRoot.model;
+        previousConfig.model = existingRoot.model;
       }
       if (
-        backup.config.previous.reasoning === undefined &&
+        previousConfig.reasoning === undefined &&
         existingRoot.reasoning &&
         existingRoot.reasoning !== installedRoot.reasoning
       ) {
-        backup.config.previous.reasoning = existingRoot.reasoning;
+        previousConfig.reasoning = existingRoot.reasoning;
       }
       if (
-        backup.config.previous.provider === undefined &&
+        previousConfig.provider === undefined &&
         existingRoot.provider &&
         existingRoot.provider !== installedRoot.provider
       ) {
-        backup.config.previous.provider = existingRoot.provider;
+        previousConfig.provider = existingRoot.provider;
       }
       backup.config.installed = installedRoot;
 
       backup.auth ??= {};
+      const authBackup = backup.auth;
       if (
-        backup.auth.previousOpenaiKey === undefined &&
+        authBackup.previousOpenaiKey === undefined &&
         existingOpenaiKey &&
         existingOpenaiKey !== apiKey
       ) {
-        backup.auth.previousOpenaiKey = existingOpenaiKey;
+        authBackup.previousOpenaiKey = existingOpenaiKey;
       }
-      backup.auth.installedOpenaiKey = apiKey;
+      authBackup.installedOpenaiKey = apiKey;
       writeCodexBackup(backup);
 
       const mergedConfig = mergeCodexToml(existingConfig, {
@@ -248,11 +251,16 @@ export const registerCodexCommand = (program: Command) => {
       const authContent = authExists
         ? fs.readFileSync(authPath, "utf8").trim()
         : "";
-      const authData = authExists
-        ? authContent
-          ? (JSON.parse(authContent) as Record<string, unknown>)
-          : {}
-        : null;
+
+      let authData: Record<string, unknown> | null = null;
+      if (authExists) {
+        if (authContent) {
+          authData = JSON.parse(authContent) as Record<string, unknown>;
+        } else {
+          authData = {};
+        }
+      }
+
       const authResult = authData
         ? removeAuthJson(authData, {
             installed: installedOpenaiKey,
@@ -283,4 +291,4 @@ export const registerCodexCommand = (program: Command) => {
         fs.unlinkSync(backupPath);
       }
     });
-};
+}

package/src/cmd/env.ts

@@ -32,10 +32,10 @@ type EnvCommandConfig = {
   vars: (apiKey: string) => EnvVars;
 };
 
-export const registerEnvCommand = (
+export function registerEnvCommand(
   program: Command,
   config: EnvCommandConfig,
-) => {
+): void {
   program
     .command(config.name)
     .description(config.description)
@@ -90,14 +90,18 @@ export const registerEnvCommand = (
         console.log(sourceLine);
       }
     });
-};
+}
 
-export const buildOpenAIEnv = (apiKey: string): EnvVars => ({
-  openaiBaseUrl: CODEX_BASE_URL,
-  openaiApiKey: apiKey,
-});
+export function buildOpenAIEnv(apiKey: string): EnvVars {
+  return {
+    openaiBaseUrl: CODEX_BASE_URL,
+    openaiApiKey: apiKey,
+  };
+}
 
-export const buildAnthropicEnv = (apiKey: string): EnvVars => ({
-  anthropicBaseUrl: CLAUDE_BASE_URL,
-  anthropicApiKey: apiKey,
-});
+export function buildAnthropicEnv(apiKey: string): EnvVars {
+  return {
+    anthropicBaseUrl: CLAUDE_BASE_URL,
+    anthropicApiKey: apiKey,
+  };
+}

package/src/cmd/index.ts

@@ -7,7 +7,7 @@ import { registerModelsCommands } from "./models";
 import { registerStatusCommand } from "./status";
 import { registerUsagesCommand } from "./usages";
 
-export const registerCommands = (program: Command) => {
+export function registerCommands(program: Command): void {
   registerAuthCommands(program);
   registerCodexCommand(program);
   registerClaudeCommand(program);
@@ -15,4 +15,4 @@ export const registerCommands = (program: Command) => {
   registerModelsCommands(program);
   registerStatusCommand(program);
   registerUsagesCommand(program);
-};
+}

package/src/cmd/keys.ts

@@ -66,18 +66,41 @@ const requireInteractiveForSelection = () =>
 const requireInteractiveForAction = (action: string) =>
   requireInteractive(`Interactive mode required for keys ${action}.`);
 
+type PromptKeyResult =
+  | { cancelled: true }
+  | { cancelled: false; name: string | undefined; enabled: boolean };
+
+const promptKeyDetails = async (
+  initialName: string | undefined,
+  initialEnabled: boolean,
+): Promise<PromptKeyResult> => {
+  const nameResult = await promptKeyName(initialName);
+  if (nameResult.cancelled) return { cancelled: true };
+
+  const enabledResult = await promptKeyEnabled(initialEnabled);
+  if (enabledResult.cancelled) return { cancelled: true };
+
+  return {
+    cancelled: false,
+    name: nameResult.name,
+    enabled: enabledResult.enabled,
+  };
+};
+
 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(",");
+  const updateMaskParts: string[] = [];
+  if (name !== undefined && name !== consumer.name) {
+    updateMaskParts.push("name");
+  }
+  if (enabled !== undefined && enabled !== consumer.enabled) {
+    updateMaskParts.push("enabled");
+  }
+  const updateMask = updateMaskParts.join(",");
   if (!updateMask) {
     return consumer;
   }
@@ -108,42 +131,32 @@ const listConsumers = async (
   outputConsumers(sorted, showApiKey);
 };
 
-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 (
+const resolveConsumer = async (
   consumerService: Pick<ConsumerService, "GetConsumer" | "ListConsumers">,
+  message: string,
   id?: string,
 ) => {
   if (id) {
     return consumerService.GetConsumer({ id });
   }
   requireInteractiveForSelection();
-  return await selectConsumerList(consumerService, "Select key to delete");
+  return await selectConsumerList(consumerService, message);
 };
 
 const createConsumer = async (
   consumerService: Pick<ConsumerService, "CreateConsumer" | "UpdateConsumer">,
 ) => {
   requireInteractiveForAction("create");
-  const nameResult = await promptKeyName();
-  if (nameResult.cancelled) return;
-  const enabledResult = await promptKeyEnabled(true);
-  if (enabledResult.cancelled) return;
+
+  const details = await promptKeyDetails(undefined, true);
+  if (details.cancelled) return;
+
   let consumer = await consumerService.CreateConsumer({});
   consumer = await updateConsumer(
     consumerService,
     consumer,
-    nameResult.name,
-    enabledResult.enabled,
+    details.name,
+    details.enabled,
   );
   outputConsumerTable(consumer, true);
   console.log("Please store this API key securely.");
@@ -157,17 +170,24 @@ const updateConsumerById = async (
   id?: string,
 ) => {
   requireInteractiveForAction("update");
-  const selected = await resolveConsumerForUpdate(consumerService, id);
+  const selected = await resolveConsumer(
+    consumerService,
+    "Select key to update",
+    id,
+  );
   if (!selected?.id) return;
-  const nameResult = await promptKeyName(selected.name);
-  if (nameResult.cancelled) return;
-  const enabledResult = await promptKeyEnabled(selected.enabled ?? true);
-  if (enabledResult.cancelled) return;
+
+  const details = await promptKeyDetails(
+    selected.name,
+    selected.enabled ?? true,
+  );
+  if (details.cancelled) return;
+
   const consumer = await updateConsumer(
     consumerService,
     selected,
-    nameResult.name,
-    enabledResult.enabled,
+    details.name,
+    details.enabled,
   );
   outputConsumerTable(consumer, false);
 };
@@ -180,7 +200,11 @@ const deleteConsumerById = async (
   id?: string,
 ) => {
   requireInteractiveForAction("delete");
-  const selected = await resolveConsumerForDelete(consumerService, id);
+  const selected = await resolveConsumer(
+    consumerService,
+    "Select key to delete",
+    id,
+  );
   if (!selected?.id) return;
   const confirmed = await confirmDelete(selected);
   if (!confirmed) return;
@@ -188,7 +212,7 @@ const deleteConsumerById = async (
   outputConsumerTable(selected, false);
 };
 
-export const registerKeysCommands = (program: Command) => {
+export function registerKeysCommands(program: Command): void {
   const keys = program.command("keys").description("Manage API keys");
   keys.option("--show", "Show full API keys");
   keys.allowExcessArguments(false);
@@ -233,4 +257,4 @@ export const registerKeysCommands = (program: Command) => {
       const { consumerService } = createApiClients({});
       await deleteConsumerById(consumerService, id);
     });
-};
+}

package/src/cmd/models.ts

@@ -5,20 +5,22 @@ import type { routercommonv1_Model } from "../generated/router/dashboard/v1";
 
 const modelHeaders = ["ID", "NAME", "AUTHOR", "ENABLED", "UPDATED_AT"];
 
-const modelRow = (model: routercommonv1_Model) => [
-  String(model.id ?? ""),
-  String(model.name ?? ""),
-  String(model.author ?? ""),
-  String(model.enabled ?? ""),
-  String(model.updatedAt ?? ""),
-];
-
-const outputModels = (models: routercommonv1_Model[]) => {
+function formatModelRow(model: routercommonv1_Model): string[] {
+  return [
+    String(model.id ?? ""),
+    String(model.name ?? ""),
+    String(model.author ?? ""),
+    String(model.enabled ?? ""),
+    String(model.updatedAt ?? ""),
+  ];
+}
+
+function outputModels(models: routercommonv1_Model[]): void {
   console.log("🧠 Models");
-  console.log(renderTable(modelHeaders, models.map(modelRow)));
-};
+  console.log(renderTable(modelHeaders, models.map(formatModelRow)));
+}
 
-const listModels = async () => {
+async function listModels(): Promise<void> {
   const { modelService } = createApiClients({});
   const res = await modelService.ListModels({
     pageSize: undefined,
@@ -26,24 +28,20 @@ const listModels = async () => {
     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();
-  });
+  outputModels(models);
+}
 
-  models
-    .command("list")
+export function registerModelsCommands(program: Command): void {
+  const models = program
+    .command("models")
     .description("List models")
-    .action(async () => {
-      await listModels();
-    });
-};
+    .action(listModels);
+
+  models.command("list").description("List models").action(listModels);
+}

package/src/cmd/status.ts

@@ -4,103 +4,154 @@ import { getAuthStatus } from "../core/auth";
 
 const LABEL_WIDTH = 10;
 
-const formatLine = (label: string, value: string | number | undefined) => {
-  if (value == null || value === "") return null;
-  return `  ${label.padEnd(LABEL_WIDTH, " ")}: ${value}`;
+type LineValue = string | number | undefined;
+
+type SectionLine = readonly [label: string, value: LineValue];
+type SectionItem = SectionLine | false | null | undefined;
+
+type AuthStatus = "logged_in" | "logged_out";
+
+type Subscription = {
+  plan?: {
+    name?: string;
+    requestPerMinute?: number;
+    tokenPerMinute?: string | number;
+  };
+  status?: string;
+  startAt?: string;
+  endAt?: string;
 };
 
-const formatAuthStatus = (status: "logged_in" | "logged_out") =>
-  status === "logged_in" ? "✅ Logged in" : "❌ Logged out";
+function line(label: string, value: LineValue): SectionLine {
+  return [label, value];
+}
+
+function formatLine(label: string, value: LineValue): string | null {
+  if (value == null || value === "") {
+    return null;
+  }
+
+  return `  ${label.padEnd(LABEL_WIDTH, " ")}: ${value}`;
+}
+
+function renderSection(title: string, items: SectionItem[]): string {
+  const lines: string[] = [];
+
+  for (const item of items) {
+    if (!item) {
+      continue;
+    }
+
+    const rendered = formatLine(item[0], item[1]);
+    if (rendered) {
+      lines.push(rendered);
+    }
+  }
+
+  return [title, ...lines].join("\n");
+}
+
+function formatAuthStatus(status: AuthStatus): string {
+  if (status === "logged_in") {
+    return "✅ Logged in";
+  }
+
+  return "❌ Logged out";
+}
+
+function formatToken(token?: string): string | undefined {
+  if (!token) {
+    return undefined;
+  }
 
-const formatToken = (token?: string) => {
-  if (!token) return undefined;
   const trimmed = token.trim();
-  if (trimmed.length <= 12) return trimmed;
+  if (trimmed.length <= 12) {
+    return trimmed;
+  }
+
   return `${trimmed.slice(0, 4)}...${trimmed.slice(-4)}`;
-};
+}
+
+function formatWindow(startAt?: string, endAt?: string): string | undefined {
+  if (!startAt && !endAt) {
+    return undefined;
+  }
+
+  if (startAt && endAt) {
+    return `${startAt} → ${endAt}`;
+  }
+
+  if (startAt) {
+    return `${startAt} →`;
+  }
 
-const formatWindow = (startAt?: string, endAt?: string) => {
-  if (!startAt && !endAt) return undefined;
-  if (startAt && endAt) return `${startAt} → ${endAt}`;
-  if (startAt) return `${startAt} →`;
   return `→ ${endAt}`;
-};
+}
 
-const formatLimits = (
+function formatLimits(
   requestPerMinute?: number,
   tokenPerMinute?: string | number,
-) => {
+): string | undefined {
   const parts: string[] = [];
+
   if (typeof requestPerMinute === "number") {
     parts.push(`${requestPerMinute} req/min`);
   }
+
   if (tokenPerMinute) {
     parts.push(`${tokenPerMinute} tok/min`);
   }
-  if (parts.length === 0) return undefined;
+
+  if (parts.length === 0) {
+    return undefined;
+  }
+
   return parts.join(" · ");
-};
+}
 
-const renderAuthSection = () => {
+function renderAuthSection(): string {
   const status = getAuthStatus();
-  const lines = [
-    formatLine("Status", formatAuthStatus(status.status)),
-    status.status === "logged_in"
-      ? formatLine("Expires", status.expiresAt)
-      : null,
-    status.status === "logged_in"
-      ? formatLine("TokenType", status.tokenType)
-      : null,
-    status.status === "logged_in"
-      ? formatLine("Access", formatToken(status.accessToken))
-      : null,
-    status.status === "logged_in"
-      ? formatLine("Refresh", formatToken(status.refreshToken))
-      : null,
-  ].filter(Boolean) as string[];
-  return ["🔐 Auth", ...lines].join("\n");
-};
+  const isLoggedIn = status.status === "logged_in";
+
+  return renderSection("🔐 Auth", [
+    line("Status", formatAuthStatus(status.status)),
+    isLoggedIn && line("Expires", status.expiresAt),
+    isLoggedIn && line("TokenType", status.tokenType),
+    isLoggedIn && line("Access", formatToken(status.accessToken)),
+    isLoggedIn && line("Refresh", formatToken(status.refreshToken)),
+  ]);
+}
 
-const renderSubscriptionSection = (
-  subscription: {
-    plan?: {
-      name?: string;
-      requestPerMinute?: number;
-      tokenPerMinute?: string | number;
-    };
-    status?: string;
-    startAt?: string;
-    endAt?: string;
-  } | null,
-) => {
+function renderSubscriptionSection(subscription: Subscription | null): string {
   if (!subscription) {
-    return ["📦 Subscription", formatLine("Status", "No active subscription")]
-      .filter(Boolean)
-      .join("\n");
+    return renderSection("📦 Subscription", [
+      line("Status", "No active subscription"),
+    ]);
   }
+
   const limits = formatLimits(
     subscription.plan?.requestPerMinute,
     subscription.plan?.tokenPerMinute,
   );
-  const windowLabel = formatWindow(subscription.startAt, subscription.endAt);
-  const lines = [
-    formatLine("Plan", subscription.plan?.name),
-    formatLine("Status", subscription.status),
-    formatLine("Window", windowLabel),
-    formatLine("Limits", limits),
-  ].filter(Boolean) as string[];
-  return ["📦 Subscription", ...lines].join("\n");
-};
 
-export const registerStatusCommand = (program: Command) => {
+  return renderSection("📦 Subscription", [
+    line("Plan", subscription.plan?.name),
+    line("Status", subscription.status),
+    line("Window", formatWindow(subscription.startAt, subscription.endAt)),
+    line("Limits", limits),
+  ]);
+}
+
+export function registerStatusCommand(program: Command): void {
   program
     .command("status")
     .description("Show login and subscription status")
     .action(async () => {
       const { subscriptionService } = createApiClients({});
       const subscription = await subscriptionService.CurrentSubscription({});
+
       console.log(renderAuthSection());
       console.log("");
       console.log(renderSubscriptionSection(subscription));
     });
-};
+}

package/src/cmd/usages.ts

@@ -8,7 +8,7 @@ type UsageListResponse = {
   nextPageToken?: string;
 };
 
-const collectUsages = async () => {
+async function collectUsages(): Promise<ReturnType<typeof aggregateUsages>> {
   const { usageService } = createApiClients({});
   const res = (await usageService.ListUsage({
     pageSize: 7,
@@ -16,9 +16,9 @@ const collectUsages = async () => {
   })) as UsageListResponse;
   const usages = res?.usages ?? [];
   return aggregateUsages(usages, 7);
-};
+}
 
-export const registerUsagesCommand = (program: Command) => {
+export function registerUsagesCommand(program: Command): void {
   program
     .command("usages")
     .description("Show recent usage")
@@ -26,4 +26,4 @@ export const registerUsagesCommand = (program: Command) => {
       const aggregated = await collectUsages();
       console.log(renderUsageChart(aggregated));
     });
-};
+}