@getrouter/getrouter-cli 0.1.13 → 0.1.14

package/src/core/api/client.ts

@@ -43,25 +43,23 @@ export type ApiClients = {
   usageService: UsageService;
 };
 
-export const createApiClients = ({
+const defaultFactories: ClientFactories = {
+  createConsumerServiceClient,
+  createAuthServiceClient,
+  createSubscriptionServiceClient,
+  createUsageServiceClient,
+  createModelServiceClient,
+};
+
+export function createApiClients({
   fetchImpl,
-  clients,
+  clients: factories = defaultFactories,
   includeAuth = true,
 }: {
   fetchImpl?: typeof fetch;
   clients?: ClientFactories;
   includeAuth?: boolean;
-}): ApiClients => {
-  const factories =
-    clients ??
-    ({
-      createConsumerServiceClient,
-      createAuthServiceClient,
-      createSubscriptionServiceClient,
-      createUsageServiceClient,
-      createModelServiceClient,
-    } satisfies ClientFactories);
-
+} = {}): ApiClients {
   const handler: RequestHandler = async ({ path, method, body }) => {
     return requestJson({
       path,
@@ -79,4 +77,4 @@ export const createApiClients = ({
     subscriptionService: factories.createSubscriptionServiceClient(handler),
     usageService: factories.createUsageServiceClient(handler),
   };
-};
+}

package/src/core/api/pagination.ts

@@ -6,11 +6,11 @@
  * @param getNextToken - Function that extracts the next page token from the response
  * @returns Array of all items across all pages
  */
-export const fetchAllPages = async <TResponse, TItem>(
+export async function fetchAllPages<TResponse, TItem>(
   fetchPage: (pageToken?: string) => Promise<TResponse>,
   getItems: (response: TResponse) => TItem[],
   getNextToken: (response: TResponse) => string | undefined,
-): Promise<TItem[]> => {
+): Promise<TItem[]> {
   const allItems: TItem[] = [];
   let pageToken: string | undefined;
 
@@ -22,4 +22,4 @@ export const fetchAllPages = async <TResponse, TItem>(
   } while (pageToken);
 
   return allItems;
-};
+}

package/src/core/api/providerModels.ts

@@ -1,32 +1,33 @@
 import { requestJson } from "../http/request";
 
-const asTrimmedString = (value: unknown): string | null => {
+type ListProviderModelsOptions = {
+  tag?: string;
+  fetchImpl?: typeof fetch;
+};
+
+function asTrimmedString(value: unknown): string | null {
   if (typeof value !== "string") return null;
   const trimmed = value.trim();
   return trimmed.length > 0 ? trimmed : null;
-};
+}
 
-const buildProviderModelsPath = (tag?: string) => {
+function buildProviderModelsPath(tag?: string): string {
   const query = new URLSearchParams();
   if (tag) query.set("tag", tag);
   const qs = query.toString();
   return `v1/dashboard/providers/models${qs ? `?${qs}` : ""}`;
-};
+}
 
-export const listProviderModels = async ({
-  tag,
-  fetchImpl,
-}: {
-  tag?: string;
-  fetchImpl?: typeof fetch;
-}): Promise<string[]> => {
+export async function listProviderModels(
+  options: ListProviderModelsOptions,
+): Promise<string[]> {
   const res = await requestJson<{ models?: unknown }>({
-    path: buildProviderModelsPath(tag),
+    path: buildProviderModelsPath(options.tag),
     method: "GET",
-    fetchImpl,
+    fetchImpl: options.fetchImpl,
     maxRetries: 0,
   });
   const raw = res?.models;
   const models = Array.isArray(raw) ? raw : [];
   return models.map(asTrimmedString).filter(Boolean) as string[];
-};
+}

package/src/core/auth/device.ts

@@ -33,6 +33,12 @@ export const generateAuthCode = () => {
 export const buildLoginUrl = (authCode: string) =>
   `https://getrouter.dev/auth/${authCode}`;
 
+const getErrorCode = (err: unknown) => {
+  if (typeof err !== "object" || err === null) return undefined;
+  if (!("code" in err)) return undefined;
+  return (err as { code?: unknown }).code;
+};
+
 const spawnBrowser = (command: string, args: string[]) => {
   try {
     const child = spawn(command, args, {
@@ -40,16 +46,13 @@ const spawnBrowser = (command: string, args: string[]) => {
       detached: true,
     });
     child.on("error", (err) => {
-      const code =
-        typeof err === "object" && err !== null && "code" in err
-          ? (err as { code?: string }).code
-          : undefined;
-      const reason =
-        code === "ENOENT"
-          ? ` (${command} not found)`
-          : code
-            ? ` (${code})`
-            : "";
+      const code = getErrorCode(err);
+      let reason = "";
+      if (code === "ENOENT") {
+        reason = ` (${command} not found)`;
+      } else if (typeof code === "string") {
+        reason = ` (${code})`;
+      }
       console.log(
         `⚠️ Unable to open browser${reason}. Please open the URL manually.`,
       );
@@ -62,15 +65,20 @@ const spawnBrowser = (command: string, args: string[]) => {
 
 export const openLoginUrl = async (url: string) => {
   try {
-    if (process.platform === "darwin") {
-      spawnBrowser("open", [url]);
-      return;
-    }
-    if (process.platform === "win32") {
-      spawnBrowser("cmd", ["/c", "start", "", url]);
-      return;
-    }
-    spawnBrowser("xdg-open", [url]);
+    const platformCommands: Record<
+      string,
+      { command: string; args: string[] }
+    > = {
+      darwin: { command: "open", args: [url] },
+      win32: { command: "cmd", args: ["/c", "start", "", url] },
+    };
+
+    const entry = platformCommands[process.platform] ?? {
+      command: "xdg-open",
+      args: [url],
+    };
+
+    spawnBrowser(entry.command, entry.args);
   } catch {
     // best effort
   }
@@ -89,14 +97,19 @@ export const pollAuthorize = async ({
   const start = now();
   let delay = initialDelayMs;
   let attempt = 0;
+
+  const getErrorStatus = (err: unknown) => {
+    if (typeof err !== "object" || err === null) return undefined;
+    if (!("status" in err)) return undefined;
+    const status = (err as { status?: unknown }).status;
+    return typeof status === "number" ? status : undefined;
+  };
+
   while (true) {
     try {
       return await authorize({ code });
     } catch (err: unknown) {
-      const status =
-        typeof err === "object" && err !== null && "status" in err
-          ? (err as { status?: number }).status
-          : undefined;
+      const status = getErrorStatus(err);
       if (status === 404) {
         // keep polling
       } else if (status === 400) {
@@ -107,11 +120,13 @@ export const pollAuthorize = async ({
         throw err;
       }
     }
+
     if (now() - start >= timeoutMs) {
       throw new Error(
         "Login timed out. Please run getrouter auth login again.",
       );
     }
+
     attempt += 1;
     onRetry?.(attempt, delay);
     await sleep(delay);

package/src/core/auth/index.ts

@@ -10,19 +10,27 @@ type AuthStatus = {
   tokenType?: string;
 };
 
-const isExpired = (expiresAt: string) => {
-  if (!expiresAt) return true;
-  const t = Date.parse(expiresAt);
-  if (Number.isNaN(t)) return true;
-  return t <= Date.now();
-};
+export function isTokenExpired(expiresAt: string, bufferMs = 0): boolean {
+  if (!expiresAt) {
+    return true;
+  }
+
+  const timestampMs = Date.parse(expiresAt);
+  if (Number.isNaN(timestampMs)) {
+    return true;
+  }
+
+  return timestampMs <= Date.now() + bufferMs;
+}
 
-export const getAuthStatus = (): AuthStatus => {
+export function getAuthStatus(): AuthStatus {
   const auth = readAuth();
   const hasTokens = Boolean(auth.accessToken && auth.refreshToken);
-  if (!hasTokens || isExpired(auth.expiresAt)) {
+
+  if (!hasTokens || isTokenExpired(auth.expiresAt)) {
     return { status: "logged_out" };
   }
+
   return {
     status: "logged_in",
     expiresAt: auth.expiresAt,
@@ -30,8 +38,8 @@ export const getAuthStatus = (): AuthStatus => {
     refreshToken: auth.refreshToken,
     tokenType: auth.tokenType,
   };
-};
+}
 
-export const clearAuth = () => {
+export function clearAuth(): void {
   writeAuth(defaultAuthState());
-};
+}

package/src/core/auth/refresh.ts

@@ -1,5 +1,6 @@
 import { readAuth, writeAuth } from "../config";
 import { buildApiUrl } from "../http/url";
+import { isTokenExpired } from "./index";
 
 type AuthToken = {
   accessToken: string | undefined;
@@ -9,19 +10,20 @@ type AuthToken = {
 
 const EXPIRY_BUFFER_MS = 60 * 1000; // Refresh 1 minute before expiry
 
-export const isTokenExpiringSoon = (expiresAt: string): boolean => {
-  if (!expiresAt) return true;
-  const t = Date.parse(expiresAt);
-  if (Number.isNaN(t)) return true;
-  return t <= Date.now() + EXPIRY_BUFFER_MS;
+type RefreshOptions = {
+  fetchImpl?: typeof fetch;
 };
 
-export const refreshAccessToken = async ({
-  fetchImpl,
-}: {
-  fetchImpl?: typeof fetch;
-}): Promise<AuthToken | null> => {
+export function isTokenExpiringSoon(expiresAt: string): boolean {
+  return isTokenExpired(expiresAt, EXPIRY_BUFFER_MS);
+}
+
+export async function refreshAccessToken(
+  options: RefreshOptions,
+): Promise<AuthToken | null> {
+  const { fetchImpl } = options;
   const auth = readAuth();
+
   if (!auth.refreshToken) {
     return null;
   }
@@ -48,21 +50,24 @@ export const refreshAccessToken = async ({
       tokenType: "Bearer",
     });
   }
+
   return token;
-};
+}
 
-export const ensureValidToken = async ({
-  fetchImpl,
-}: {
-  fetchImpl?: typeof fetch;
-}): Promise<boolean> => {
+export async function ensureValidToken(
+  options: RefreshOptions,
+): Promise<boolean> {
+  const { fetchImpl } = options;
   const auth = readAuth();
+
   if (!auth.accessToken || !auth.refreshToken) {
     return false;
   }
+
   if (!isTokenExpiringSoon(auth.expiresAt)) {
     return true;
   }
+
   const refreshed = await refreshAccessToken({ fetchImpl });
   return refreshed !== null && Boolean(refreshed.accessToken);
-};
+}

package/src/core/config/fs.ts

@@ -1,16 +1,16 @@
 import fs from "node:fs";
 import path from "node:path";
 
-const getCorruptBackupPath = (filePath: string) => {
+function getCorruptBackupPath(filePath: string): string {
   const dir = path.dirname(filePath);
   const ext = path.extname(filePath);
   const base = path.basename(filePath, ext);
   const stamp = new Date().toISOString().replace(/[:.]/g, "-");
   const rand = Math.random().toString(16).slice(2, 8);
   return path.join(dir, `${base}.corrupt-${stamp}-${rand}${ext}`);
-};
+}
 
-export const readJsonFile = <T = unknown>(filePath: string): T | null => {
+export function readJsonFile<T = unknown>(filePath: string): T | null {
   if (!fs.existsSync(filePath)) return null;
   let raw: string;
   try {
@@ -36,9 +36,9 @@ export const readJsonFile = <T = unknown>(filePath: string): T | null => {
     }
     return null;
   }
-};
+}
 
-export const writeJsonFile = (filePath: string, value: unknown) => {
+export function writeJsonFile(filePath: string, value: unknown): void {
   fs.mkdirSync(path.dirname(filePath), { recursive: true });
   fs.writeFileSync(filePath, JSON.stringify(value, null, 2), "utf8");
-};
+}

package/src/core/config/index.ts

@@ -8,24 +8,29 @@ import {
   defaultConfig,
 } from "./types";
 
-export const readConfig = (): ConfigFile => ({
-  ...defaultConfig(),
-  ...(readJsonFile<ConfigFile>(getConfigPath()) ?? {}),
-});
+export function readConfig(): ConfigFile {
+  return {
+    ...defaultConfig(),
+    ...(readJsonFile<ConfigFile>(getConfigPath()) ?? {}),
+  };
+}
 
-export const writeConfig = (cfg: ConfigFile) =>
+export function writeConfig(cfg: ConfigFile): void {
   writeJsonFile(getConfigPath(), cfg);
+}
 
-export const readAuth = (): AuthState => ({
-  ...defaultAuthState(),
-  ...(readJsonFile<AuthState>(getAuthPath()) ?? {}),
-});
+export function readAuth(): AuthState {
+  return {
+    ...defaultAuthState(),
+    ...(readJsonFile<AuthState>(getAuthPath()) ?? {}),
+  };
+}
 
-export const writeAuth = (auth: AuthState) => {
+export function writeAuth(auth: AuthState): void {
   const authPath = getAuthPath();
   writeJsonFile(authPath, auth);
   if (process.platform !== "win32") {
     // Restrict token file permissions on Unix-like systems.
     fs.chmodSync(authPath, 0o600);
   }
-};
+}

package/src/core/config/paths.ts

@@ -1,8 +1,16 @@
 import os from "node:os";
 import path from "node:path";
 
-export const resolveConfigDir = () =>
-  process.env.GETROUTER_CONFIG_DIR || path.join(os.homedir(), ".getrouter");
+export function resolveConfigDir(): string {
+  return (
+    process.env.GETROUTER_CONFIG_DIR || path.join(os.homedir(), ".getrouter")
+  );
+}
 
-export const getConfigPath = () => path.join(resolveConfigDir(), "config.json");
-export const getAuthPath = () => path.join(resolveConfigDir(), "auth.json");
+export function getConfigPath(): string {
+  return path.join(resolveConfigDir(), "config.json");
+}
+
+export function getAuthPath(): string {
+  return path.join(resolveConfigDir(), "auth.json");
+}

package/src/core/config/redact.ts

@@ -1,12 +1,12 @@
 const SECRET_KEYS = new Set(["accessToken", "refreshToken", "apiKey"]);
 
-const mask = (value: string) => {
+function mask(value: string): string {
   if (!value) return "";
   if (value.length <= 8) return "****";
   return `${value.slice(0, 4)}...${value.slice(-4)}`;
-};
+}
 
-export const redactSecrets = <T extends Record<string, unknown>>(obj: T): T => {
+export function redactSecrets<T extends Record<string, unknown>>(obj: T): T {
   const out: Record<string, unknown> = { ...obj };
   for (const key of Object.keys(out)) {
     const value = out[key];
@@ -15,4 +15,4 @@ export const redactSecrets = <T extends Record<string, unknown>>(obj: T): T => {
     }
   }
   return out as T;
-};
+}

package/src/core/config/types.ts

@@ -10,14 +10,18 @@ export type AuthState = {
   tokenType: string;
 };
 
-export const defaultConfig = (): ConfigFile => ({
-  apiBase: "https://getrouter.dev",
-  json: false,
-});
+export function defaultConfig(): ConfigFile {
+  return {
+    apiBase: "https://getrouter.dev",
+    json: false,
+  };
+}
 
-export const defaultAuthState = (): AuthState => ({
-  accessToken: "",
-  refreshToken: "",
-  expiresAt: "",
-  tokenType: "Bearer",
-});
+export function defaultAuthState(): AuthState {
+  return {
+    accessToken: "",
+    refreshToken: "",
+    expiresAt: "",
+    tokenType: "Bearer",
+  };
+}

package/src/core/http/errors.ts

@@ -1,32 +1,40 @@
-export type ApiError = {
+export interface ApiError {
   code?: string;
   message: string;
   details?: unknown;
   status?: number;
-};
+}
 
-export const createApiError = (
+export function createApiError(
   payload: unknown,
   fallbackMessage: string,
   status?: number,
-) => {
+): Error & ApiError {
   const payloadObject =
     payload && typeof payload === "object"
       ? (payload as Record<string, unknown>)
       : undefined;
+
   const message =
-    payloadObject && typeof payloadObject.message === "string"
+    typeof payloadObject?.message === "string"
       ? payloadObject.message
       : fallbackMessage;
+
   const err = new Error(message) as Error & ApiError;
-  if (payloadObject && typeof payloadObject.code === "string") {
-    err.code = payloadObject.code;
+
+  const code = payloadObject?.code;
+  if (typeof code === "string") {
+    err.code = code;
   }
-  if (payloadObject && payloadObject.details != null) {
-    err.details = payloadObject.details;
+
+  const details = payloadObject?.details;
+  if (details != null) {
+    err.details = details;
   }
+
   if (typeof status === "number") {
     err.status = status;
   }
+
   return err;
-};
+}

package/src/core/http/request.ts

@@ -1,7 +1,7 @@
 import { refreshAccessToken } from "../auth/refresh";
 import { readAuth } from "../config";
 import { createApiError } from "./errors";
-import { isServerError, withRetry } from "./retry";
+import { isRetryableError, withRetry } from "./retry";
 import { buildApiUrl } from "./url";
 
 type RequestInput = {
@@ -15,50 +15,48 @@ type RequestInput = {
   _retrySleep?: (ms: number) => Promise<void>;
 };
 
-const getAuthCookieName = () =>
-  process.env.GETROUTER_AUTH_COOKIE ||
-  process.env.KRATOS_AUTH_COOKIE ||
-  "access_token";
+function getAuthCookieName(): string {
+  const routerCookieName = process.env.GETROUTER_AUTH_COOKIE;
+  if (routerCookieName) {
+    return routerCookieName;
+  }
+
+  const kratosCookieName = process.env.KRATOS_AUTH_COOKIE;
+  if (kratosCookieName) {
+    return kratosCookieName;
+  }
+
+  return "access_token";
+}
 
-const buildHeaders = (accessToken?: string): Record<string, string> => {
+function buildHeaders(accessToken?: string): Record<string, string> {
   const headers: Record<string, string> = {
     "Content-Type": "application/json",
   };
+
   if (accessToken) {
     headers.Authorization = `Bearer ${accessToken}`;
     headers.Cookie = `${getAuthCookieName()}=${accessToken}`;
   }
+
   return headers;
-};
+}
 
-const doFetch = async (
+async function doFetch(
   url: string,
   method: string,
   headers: Record<string, string>,
   body: unknown,
   fetchImpl?: typeof fetch,
-): Promise<Response> => {
+): Promise<Response> {
   return (fetchImpl ?? fetch)(url, {
     method,
     headers,
     body: body == null ? undefined : JSON.stringify(body),
   });
-};
-
-const shouldRetryResponse = (error: unknown): boolean => {
-  if (
-    typeof error === "object" &&
-    error !== null &&
-    "status" in error &&
-    typeof (error as { status: unknown }).status === "number"
-  ) {
-    return isServerError((error as { status: number }).status);
-  }
-  // Retry on network errors (TypeError from fetch)
-  return error instanceof TypeError;
-};
+}
 
-export const requestJson = async <T = unknown>({
+export async function requestJson<T = unknown>({
   path,
   method,
   body,
@@ -66,21 +64,17 @@ export const requestJson = async <T = unknown>({
   maxRetries = 3,
   includeAuth = true,
   _retrySleep,
-}: RequestInput): Promise<T> => {
+}: RequestInput): Promise<T> {
   return withRetry(
     async () => {
-      const auth = includeAuth
-        ? readAuth()
-        : { accessToken: undefined, refreshToken: undefined };
       const url = buildApiUrl(path);
-      const headers = includeAuth
-        ? buildHeaders(auth.accessToken)
-        : buildHeaders();
+      const auth = includeAuth ? readAuth() : undefined;
+      const headers = buildHeaders(auth?.accessToken);
 
       let res = await doFetch(url, method, headers, body, fetchImpl);
 
       // On 401, attempt token refresh and retry once
-      if (includeAuth && res.status === 401 && auth.refreshToken) {
+      if (includeAuth && res.status === 401 && auth?.refreshToken) {
         const refreshed = await refreshAccessToken({ fetchImpl });
         if (refreshed?.accessToken) {
           const newHeaders = buildHeaders(refreshed.accessToken);
@@ -92,12 +86,13 @@ export const requestJson = async <T = unknown>({
         const payload = await res.json().catch(() => null);
         throw createApiError(payload, res.statusText, res.status);
       }
+
       return (await res.json()) as T;
     },
     {
       maxRetries,
-      shouldRetry: shouldRetryResponse,
+      shouldRetry: isRetryableError,
       sleep: _retrySleep,
     },
   );
-};
+}