@getrouter/getrouter-cli 0.1.13 → 0.1.14

package/src/core/http/retry.ts

@@ -1,38 +1,54 @@
-export type RetryOptions = {
+export interface RetryOptions {
   maxRetries?: number;
   initialDelayMs?: number;
   maxDelayMs?: number;
   shouldRetry?: (error: unknown, attempt: number) => boolean;
   onRetry?: (error: unknown, attempt: number, delayMs: number) => void;
   sleep?: (ms: number) => Promise<void>;
-};
+}
 
-const defaultSleep = (ms: number) =>
-  new Promise<void>((resolve) => setTimeout(resolve, ms));
+function defaultSleep(ms: number): Promise<void> {
+  return new Promise<void>((resolve) => setTimeout(resolve, ms));
+}
 
-const isRetryableError = (error: unknown): boolean => {
-  // Network errors (fetch failures)
+export function isServerError(status: number): boolean {
+  return status >= 500 || status === 408 || status === 429;
+}
+
+function getErrorStatus(error: unknown): number | undefined {
+  if (typeof error !== "object" || error === null) {
+    return undefined;
+  }
+
+  if (!("status" in error)) {
+    return undefined;
+  }
+
+  const status = (error as { status: unknown }).status;
+  if (typeof status !== "number") {
+    return undefined;
+  }
+
+  return status;
+}
+
+export function isRetryableError(error: unknown, _attempt?: number): boolean {
   if (error instanceof TypeError) {
     return true;
   }
-  // Errors with status codes
-  if (
-    typeof error === "object" &&
-    error !== null &&
-    "status" in error &&
-    typeof (error as { status: unknown }).status === "number"
-  ) {
-    const status = (error as { status: number }).status;
-    // Retry on 5xx server errors, 408 timeout, 429 rate limit
-    return status >= 500 || status === 408 || status === 429;
+
+  const status = getErrorStatus(error);
+  if (status === undefined) {
+    return false;
   }
-  return false;
-};
 
-export const withRetry = async <T>(
+  return isServerError(status);
+}
+
+export async function withRetry<T>(
   fn: () => Promise<T>,
   options: RetryOptions = {},
-): Promise<T> => {
+): Promise<T> {
   const {
     maxRetries = 3,
     initialDelayMs = 1000,
@@ -62,7 +78,4 @@ export const withRetry = async <T>(
   }
 
   throw lastError;
-};
-
-export const isServerError = (status: number): boolean =>
-  status >= 500 || status === 408 || status === 429;
+}

package/src/core/http/url.ts

@@ -1,12 +1,17 @@
 import { readConfig } from "../config";
 
-export const getApiBase = () => {
+export function getApiBase(): string {
   const raw = readConfig().apiBase || "";
   return raw.replace(/\/+$/, "");
-};
+}
 
-export const buildApiUrl = (path: string) => {
+export function buildApiUrl(path: string): string {
   const base = getApiBase();
-  const normalized = path.replace(/^\/+/, "");
-  return base ? `${base}/${normalized}` : `/${normalized}`;
-};
+  const normalizedPath = path.replace(/^\/+/, "");
+
+  if (base) {
+    return `${base}/${normalizedPath}`;
+  }
+
+  return `/${normalizedPath}`;
+}

package/src/core/interactive/clipboard.ts

@@ -19,23 +19,23 @@ type CopyOptions = {
   spawnFn?: SpawnLike;
 };
 
-export const getClipboardCommands = (
+export function getClipboardCommands(
   platform: NodeJS.Platform,
-): ClipboardCommand[] => {
+): ClipboardCommand[] {
   if (platform === "darwin") return [{ command: "pbcopy", args: [] }];
   if (platform === "win32") return [{ command: "clip", args: [] }];
   return [
     { command: "wl-copy", args: [] },
     { command: "xclip", args: ["-selection", "clipboard"] },
   ];
-};
+}
 
-const runClipboardCommand = (
+function runClipboardCommand(
   text: string,
   command: ClipboardCommand,
   spawnFn: SpawnLike,
-): Promise<boolean> =>
-  new Promise((resolve) => {
+): Promise<boolean> {
+  return new Promise((resolve) => {
     const child = spawnFn(command.command, command.args, {
       stdio: ["pipe", "ignore", "ignore"],
     });
@@ -44,11 +44,12 @@ const runClipboardCommand = (
     child.stdin.write(text);
     child.stdin.end();
   });
+}
 
-export const copyToClipboard = async (
+export async function copyToClipboard(
   text: string,
   options: CopyOptions = {},
-) => {
+): Promise<boolean> {
   if (!text) return false;
   const platform = options.platform ?? process.platform;
   const spawnFn = options.spawnFn ?? spawn;
@@ -58,4 +59,4 @@ export const copyToClipboard = async (
     if (ok) return true;
   }
   return false;
-};
+}

package/src/core/interactive/keys.ts

@@ -126,10 +126,8 @@ export const promptKeyEnabled = async (
   };
 };
 
-export const selectConsumer = async (
-  consumerService: ConsumerService,
-): Promise<routercommonv1_Consumer | null> => {
-  const consumers = await fetchAllPages(
+const fetchConsumers = async (consumerService: ConsumerService) =>
+  fetchAllPages(
     (pageToken) =>
       consumerService.ListConsumers({
         pageSize: undefined,
@@ -138,6 +136,8 @@ export const selectConsumer = async (
     (res) => res?.consumers ?? [],
     (res) => res?.nextPageToken || undefined,
   );
+
+const ensureConsumers = (consumers: Consumer[]) => {
   if (consumers.length === 0) {
     console.log(
       "No available API keys. Create one at https://getrouter.dev/dashboard/keys",
@@ -145,11 +145,20 @@ export const selectConsumer = async (
     return null;
   }
   const sorted = sortConsumersByUpdatedAtDesc(consumers);
-  const nameCounts = buildNameCounts(sorted);
+  return { sorted, nameCounts: buildNameCounts(sorted) };
+};
+
+export const selectConsumer = async (
+  consumerService: ConsumerService,
+): Promise<routercommonv1_Consumer | null> => {
+  const consumers = await fetchConsumers(consumerService);
+  const prepared = ensureConsumers(consumers);
+  if (!prepared) return null;
+
   const selected = await fuzzySelect({
     message: "🔎 Search keys",
-    choices: sorted.map((consumer) => ({
-      title: formatChoice(consumer, nameCounts),
+    choices: prepared.sorted.map((consumer) => ({
+      title: formatChoice(consumer, prepared.nameCounts),
       value: consumer,
       keywords: [
         normalizeName(consumer),
@@ -165,29 +174,16 @@ export const selectConsumerList = async (
   consumerService: ConsumerService,
   message: string,
 ): Promise<routercommonv1_Consumer | null> => {
-  const consumers = await fetchAllPages(
-    (pageToken) =>
-      consumerService.ListConsumers({
-        pageSize: undefined,
-        pageToken,
-      }),
-    (res) => res?.consumers ?? [],
-    (res) => res?.nextPageToken || undefined,
-  );
-  if (consumers.length === 0) {
-    console.log(
-      "No available API keys. Create one at https://getrouter.dev/dashboard/keys",
-    );
-    return null;
-  }
-  const sorted = sortConsumersByUpdatedAtDesc(consumers);
-  const nameCounts = buildNameCounts(sorted);
+  const consumers = await fetchConsumers(consumerService);
+  const prepared = ensureConsumers(consumers);
+  if (!prepared) return null;
+
   const response = await prompts({
     type: "select",
     name: "value",
     message,
-    choices: sorted.map((consumer) => ({
-      title: formatChoice(consumer, nameCounts),
+    choices: prepared.sorted.map((consumer) => ({
+      title: formatChoice(consumer, prepared.nameCounts),
       value: consumer,
     })),
   });

package/src/core/output/table.ts

@@ -1,16 +1,16 @@
 type TableOptions = { maxColWidth?: number };
 
-const truncate = (value: string, max: number) => {
+function truncate(value: string, max: number): string {
   if (value.length <= max) return value;
   if (max <= 3) return value.slice(0, max);
   return `${value.slice(0, max - 3)}...`;
-};
+}
 
-export const renderTable = (
+export function renderTable(
   headers: string[],
   rows: string[][],
   options: TableOptions = {},
-) => {
+): string {
   const maxColWidth = options.maxColWidth ?? 32;
   const normalized = rows.map((row) =>
     row.map((cell) => (cell && cell.length > 0 ? cell : "-")),
@@ -31,4 +31,4 @@ export const renderTable = (
   const headerRow = renderRow(headers);
   const body = normalized.map((row) => renderRow(row)).join("\n");
   return `${headerRow}\n${body}`;
-};
+}

package/src/core/output/usages.ts

@@ -3,54 +3,55 @@ import type { AggregatedUsage } from "../usages/aggregate";
 const TOTAL_BLOCK = "█";
 const DEFAULT_WIDTH = 24;
 
-const formatTokens = (value: number) => {
+function formatTokens(value: number): string {
   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}`;
-    }
+
+  let threshold = 1_000;
+  let suffix = "K";
+
+  if (abs >= 1_000_000_000) {
+    threshold = 1_000_000_000;
+    suffix = "B";
+  } else if (abs >= 1_000_000) {
+    threshold = 1_000_000;
+    suffix = "M";
   }
-  return Math.round(value).toString();
-};
 
-export const renderUsageChart = (
+  const scaled = value / threshold;
+  const decimals = Math.abs(scaled) < 10 ? 1 : 0;
+  const output = scaled.toFixed(decimals).replace(/\.0$/, "");
+  return `${output}${suffix}`;
+}
+
+export function renderUsageChart(
   rows: AggregatedUsage[],
   width = DEFAULT_WIDTH,
-) => {
+): string {
   const header = "📊 Usage (last 7 days) · Tokens";
   if (rows.length === 0) {
     return `${header}\n\nNo usage data available.`;
   }
-  const normalized = rows.map((row) => {
-    const total = Number(row.totalTokens);
-    const safeTotal = Number.isFinite(total) ? total : 0;
+
+  const data = rows.map((row) => {
+    const rawTotal = Number(row.totalTokens);
     return {
       day: row.day,
-      total: safeTotal,
+      total: Number.isFinite(rawTotal) ? rawTotal : 0,
     };
   });
-  const totals = normalized.map((row) => row.total);
-  const maxTotal = Math.max(0, ...totals);
-  const lines = normalized.map((row) => {
-    if (maxTotal === 0 || row.total === 0) {
-      return `${row.day} ${"".padEnd(width, " ")} 0`;
+
+  const maxTotal = Math.max(0, ...data.map((d) => d.total));
+
+  const lines = data.map(({ day, total }) => {
+    if (maxTotal === 0 || total === 0) {
+      return `${day} ${" ".repeat(width)} 0`;
     }
-    const scaled = Math.max(1, Math.round((row.total / maxTotal) * width));
+
+    const scaled = Math.max(1, Math.round((total / maxTotal) * width));
     const bar = TOTAL_BLOCK.repeat(scaled);
-    const totalLabel = formatTokens(row.total);
-    return `${row.day} ${bar.padEnd(width, " ")} ${totalLabel}`;
+    return `${day} ${bar.padEnd(width, " ")} ${formatTokens(total)}`;
   });
+
   return [header, "", ...lines].join("\n");
-};
+}