@getrouter/getrouter-cli 0.1.0

package/src/cmd/status.ts

@@ -0,0 +1,106 @@
+import type { Command } from "commander";
+import { createApiClients } from "../core/api/client";
+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}`;
+};
+
+const formatAuthStatus = (status: "logged_in" | "logged_out") =>
+  status === "logged_in" ? "✅ Logged in" : "❌ Logged out";
+
+const formatToken = (token?: string) => {
+  if (!token) return undefined;
+  const trimmed = token.trim();
+  if (trimmed.length <= 12) return trimmed;
+  return `${trimmed.slice(0, 4)}...${trimmed.slice(-4)}`;
+};
+
+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 = (
+  requestPerMinute?: number,
+  tokenPerMinute?: string | number,
+) => {
+  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;
+  return parts.join(" · ");
+};
+
+const renderAuthSection = () => {
+  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 renderSubscriptionSection = (
+  subscription: {
+    plan?: {
+      name?: string;
+      requestPerMinute?: number;
+      tokenPerMinute?: string | number;
+    };
+    status?: string;
+    startAt?: string;
+    endAt?: string;
+  } | null,
+) => {
+  if (!subscription) {
+    return ["📦 Subscription", formatLine("Status", "No active subscription")]
+      .filter(Boolean)
+      .join("\n");
+  }
+  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) => {
+  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

@@ -0,0 +1,29 @@
+import type { Command } from "commander";
+import { createApiClients } from "../core/api/client";
+import { renderUsageChart } from "../core/output/usages";
+import { aggregateUsages, type RawUsage } from "../core/usages/aggregate";
+
+type UsageListResponse = {
+  usages?: RawUsage[];
+  nextPageToken?: string;
+};
+
+const collectUsages = async () => {
+  const { usageService } = createApiClients({});
+  const res = (await usageService.ListUsage({
+    pageSize: 7,
+    pageToken: undefined,
+  })) as UsageListResponse;
+  const usages = res?.usages ?? [];
+  return aggregateUsages(usages, 7);
+};
+
+export const registerUsagesCommand = (program: Command) => {
+  program
+    .command("usages")
+    .description("Show recent usage")
+    .action(async () => {
+      const aggregated = await collectUsages();
+      console.log(renderUsageChart(aggregated));
+    });
+};

package/src/core/api/client.ts

@@ -0,0 +1,79 @@
+import type {
+  AuthService,
+  ConsumerService,
+  ModelService,
+  SubscriptionService,
+  UsageService,
+} from "../../generated/router/dashboard/v1";
+import {
+  createAuthServiceClient,
+  createConsumerServiceClient,
+  createModelServiceClient,
+  createSubscriptionServiceClient,
+  createUsageServiceClient,
+} from "../../generated/router/dashboard/v1";
+import { requestJson } from "../http/request";
+
+export type RequestType = {
+  path: string;
+  method: string;
+  body: string | null;
+};
+
+export type RequestHandler = (
+  request: RequestType,
+  meta: { service: string; method: string },
+) => Promise<unknown>;
+
+export type ClientFactories = {
+  createConsumerServiceClient: (handler: RequestHandler) => ConsumerService;
+  createAuthServiceClient: (handler: RequestHandler) => AuthService;
+  createSubscriptionServiceClient: (
+    handler: RequestHandler,
+  ) => SubscriptionService;
+  createUsageServiceClient: (handler: RequestHandler) => UsageService;
+  createModelServiceClient: (handler: RequestHandler) => ModelService;
+};
+
+export type ApiClients = {
+  authService: AuthService;
+  consumerService: ConsumerService;
+  modelService: ModelService;
+  subscriptionService: SubscriptionService;
+  usageService: UsageService;
+};
+
+export const createApiClients = ({
+  fetchImpl,
+  clients,
+}: {
+  fetchImpl?: typeof fetch;
+  clients?: ClientFactories;
+}): ApiClients => {
+  const factories =
+    clients ??
+    ({
+      createConsumerServiceClient,
+      createAuthServiceClient,
+      createSubscriptionServiceClient,
+      createUsageServiceClient,
+      createModelServiceClient,
+    } satisfies ClientFactories);
+
+  const handler: RequestHandler = async ({ path, method, body }) => {
+    return requestJson({
+      path,
+      method,
+      body: body ? JSON.parse(body) : undefined,
+      fetchImpl,
+    });
+  };
+
+  return {
+    authService: factories.createAuthServiceClient(handler),
+    consumerService: factories.createConsumerServiceClient(handler),
+    modelService: factories.createModelServiceClient(handler),
+    subscriptionService: factories.createSubscriptionServiceClient(handler),
+    usageService: factories.createUsageServiceClient(handler),
+  };
+};

package/src/core/auth/device.ts

@@ -0,0 +1,105 @@
+import { spawn } from "node:child_process";
+import { randomInt } from "node:crypto";
+
+type AuthToken = {
+  accessToken: string | undefined;
+  refreshToken: string | undefined;
+  expiresAt: string | undefined;
+};
+
+type AuthorizeFn = (req: { code: string }) => Promise<AuthToken>;
+
+type PollOptions = {
+  authorize: AuthorizeFn;
+  code: string;
+  timeoutMs?: number;
+  initialDelayMs?: number;
+  maxDelayMs?: number;
+  sleep?: (ms: number) => Promise<void>;
+  now?: () => number;
+  onRetry?: (attempt: number, delayMs: number) => void;
+};
+
+const alphabet = "abcdefghijklmnopqrstuvwxyz234567";
+
+export const generateAuthCode = () => {
+  let out = "";
+  for (let i = 0; i < 13; i += 1) {
+    out += alphabet[randomInt(32)];
+  }
+  return out;
+};
+
+export const buildLoginUrl = (authCode: string) =>
+  `https://getrouter.dev/#/a/${authCode}`;
+
+export const openLoginUrl = async (url: string) => {
+  try {
+    if (process.platform === "darwin") {
+      const child = spawn("open", [url], {
+        stdio: "ignore",
+        detached: true,
+      });
+      child.unref();
+      return;
+    }
+    if (process.platform === "win32") {
+      const child = spawn("cmd", ["/c", "start", "", url], {
+        stdio: "ignore",
+        detached: true,
+      });
+      child.unref();
+      return;
+    }
+    const child = spawn("xdg-open", [url], {
+      stdio: "ignore",
+      detached: true,
+    });
+    child.unref();
+  } catch {
+    // best effort
+  }
+};
+
+export const pollAuthorize = async ({
+  authorize,
+  code,
+  timeoutMs = 5 * 60 * 1000,
+  initialDelayMs = 1000,
+  maxDelayMs = 10000,
+  sleep = (ms: number) => new Promise((r) => setTimeout(r, ms)),
+  now = () => Date.now(),
+  onRetry,
+}: PollOptions) => {
+  const start = now();
+  let delay = initialDelayMs;
+  let attempt = 0;
+  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;
+      if (status === 404) {
+        // keep polling
+      } else if (status === 400) {
+        throw new Error("Auth code already used. Please log in again.");
+      } else if (status === 403) {
+        throw new Error("Auth code expired. Please log in again.");
+      } else {
+        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);
+    delay = Math.min(delay * 2, maxDelayMs);
+  }
+};

package/src/core/auth/index.ts

@@ -0,0 +1,37 @@
+import { readAuth, writeAuth } from "../config";
+import { defaultAuthState } from "../config/types";
+
+type AuthStatus = {
+  status: "logged_in" | "logged_out";
+  note?: string;
+  expiresAt?: string;
+  accessToken?: string;
+  refreshToken?: string;
+  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 const getAuthStatus = (): AuthStatus => {
+  const auth = readAuth();
+  const hasTokens = Boolean(auth.accessToken && auth.refreshToken);
+  if (!hasTokens || isExpired(auth.expiresAt)) {
+    return { status: "logged_out" };
+  }
+  return {
+    status: "logged_in",
+    expiresAt: auth.expiresAt,
+    accessToken: auth.accessToken,
+    refreshToken: auth.refreshToken,
+    tokenType: auth.tokenType,
+  };
+};
+
+export const clearAuth = () => {
+  writeAuth(defaultAuthState());
+};

package/src/core/config/fs.ts

@@ -0,0 +1,13 @@
+import fs from "node:fs";
+import path from "node:path";
+
+export const readJsonFile = <T = unknown>(filePath: string): T | null => {
+  if (!fs.existsSync(filePath)) return null;
+  const raw = fs.readFileSync(filePath, "utf8");
+  return JSON.parse(raw) as T;
+};
+
+export const writeJsonFile = (filePath: string, value: unknown) => {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(value, null, 2), "utf8");
+};

package/src/core/config/index.ts

@@ -0,0 +1,37 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { readJsonFile, writeJsonFile } from "./fs";
+import {
+  type AuthState,
+  type ConfigFile,
+  defaultAuthState,
+  defaultConfig,
+} from "./types";
+
+const resolveConfigDir = () =>
+  process.env.GETROUTER_CONFIG_DIR || path.join(os.homedir(), ".getrouter");
+
+const getConfigPath = () => path.join(resolveConfigDir(), "config.json");
+const getAuthPath = () => path.join(resolveConfigDir(), "auth.json");
+
+export const readConfig = (): ConfigFile => ({
+  ...defaultConfig(),
+  ...(readJsonFile<ConfigFile>(getConfigPath()) ?? {}),
+});
+
+export const writeConfig = (cfg: ConfigFile) =>
+  writeJsonFile(getConfigPath(), cfg);
+
+export const readAuth = (): AuthState => ({
+  ...defaultAuthState(),
+  ...(readJsonFile<AuthState>(getAuthPath()) ?? {}),
+});
+
+export const writeAuth = (auth: AuthState) => {
+  const authPath = getAuthPath();
+  writeJsonFile(authPath, auth);
+  if (process.platform !== "win32") {
+    fs.chmodSync(authPath, 0o600);
+  }
+};

package/src/core/config/paths.ts

@@ -0,0 +1,5 @@
+import path from "node:path";
+import { getConfigDir } from "../paths";
+
+export const getConfigPath = () => path.join(getConfigDir(), "config.json");
+export const getAuthPath = () => path.join(getConfigDir(), "auth.json");

package/src/core/config/redact.ts

@@ -0,0 +1,18 @@
+const SECRET_KEYS = new Set(["accessToken", "refreshToken", "apiKey"]);
+
+const mask = (value: 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 => {
+  const out: Record<string, unknown> = { ...obj };
+  for (const key of Object.keys(out)) {
+    const value = out[key];
+    if (SECRET_KEYS.has(key) && typeof value === "string") {
+      out[key] = mask(value);
+    }
+  }
+  return out as T;
+};

package/src/core/config/types.ts

@@ -0,0 +1,23 @@
+export type ConfigFile = {
+  apiBase: string;
+  json: boolean;
+};
+
+export type AuthState = {
+  accessToken: string;
+  refreshToken: string;
+  expiresAt: string;
+  tokenType: string;
+};
+
+export const defaultConfig = (): ConfigFile => ({
+  apiBase: "https://getrouter.dev",
+  json: false,
+});
+
+export const defaultAuthState = (): AuthState => ({
+  accessToken: "",
+  refreshToken: "",
+  expiresAt: "",
+  tokenType: "Bearer",
+});

package/src/core/http/errors.ts

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

package/src/core/http/request.ts

@@ -0,0 +1,41 @@
+import { readAuth } from "../config";
+import { createApiError } from "./errors";
+import { buildApiUrl } from "./url";
+
+type RequestInput = {
+  path: string;
+  method: string;
+  body?: unknown;
+  fetchImpl?: typeof fetch;
+};
+
+const getAuthCookieName = () =>
+  process.env.GETROUTER_AUTH_COOKIE ||
+  process.env.KRATOS_AUTH_COOKIE ||
+  "access_token";
+
+export const requestJson = async <T = unknown>({
+  path,
+  method,
+  body,
+  fetchImpl,
+}: RequestInput): Promise<T> => {
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+  };
+  const auth = readAuth();
+  if (auth.accessToken) {
+    headers.Authorization = `Bearer ${auth.accessToken}`;
+    headers.Cookie = `${getAuthCookieName()}=${auth.accessToken}`;
+  }
+  const res = await (fetchImpl ?? fetch)(buildApiUrl(path), {
+    method,
+    headers,
+    body: body == null ? undefined : JSON.stringify(body),
+  });
+  if (!res.ok) {
+    const payload = await res.json().catch(() => null);
+    throw createApiError(payload, res.statusText, res.status);
+  }
+  return (await res.json()) as T;
+};

package/src/core/http/url.ts

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

package/src/core/interactive/clipboard.ts

@@ -0,0 +1,61 @@
+import { spawn } from "node:child_process";
+
+type ClipboardCommand = {
+  command: string;
+  args: string[];
+};
+
+type SpawnLike = (
+  command: string,
+  args: string[],
+  options: { stdio: ["pipe", "ignore", "ignore"] },
+) => {
+  stdin: { write: (text: string) => void; end: () => void };
+  on: (event: string, cb: (code?: number) => void) => void;
+};
+
+type CopyOptions = {
+  platform?: NodeJS.Platform;
+  spawnFn?: SpawnLike;
+};
+
+export const getClipboardCommands = (
+  platform: NodeJS.Platform,
+): 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 = (
+  text: string,
+  command: ClipboardCommand,
+  spawnFn: SpawnLike,
+): Promise<boolean> =>
+  new Promise((resolve) => {
+    const child = spawnFn(command.command, command.args, {
+      stdio: ["pipe", "ignore", "ignore"],
+    });
+    child.on("error", () => resolve(false));
+    child.on("close", (code) => resolve(code === 0));
+    child.stdin.write(text);
+    child.stdin.end();
+  });
+
+export const copyToClipboard = async (
+  text: string,
+  options: CopyOptions = {},
+) => {
+  if (!text) return false;
+  const platform = options.platform ?? process.platform;
+  const spawnFn = options.spawnFn ?? spawn;
+  const commands = getClipboardCommands(platform);
+  for (const command of commands) {
+    const ok = await runClipboardCommand(text, command, spawnFn);
+    if (ok) return true;
+  }
+  return false;
+};

package/src/core/interactive/codex.ts

@@ -0,0 +1,75 @@
+import type { FuzzyChoice } from "./fuzzy";
+
+export type ReasoningChoice = {
+  id: string;
+  label: string;
+  value: string;
+  description: string;
+};
+
+export const MODEL_CHOICES: FuzzyChoice<string>[] = [
+  {
+    title: "gpt-5.2-codex",
+    value: "gpt-5.2-codex",
+    description: "Latest frontier agentic coding model.",
+    keywords: ["gpt-5.2-codex", "codex"],
+  },
+  {
+    title: "gpt-5.1-codex-max",
+    value: "gpt-5.1-codex-max",
+    description: "Codex-optimized flagship for deep and fast reasoning.",
+    keywords: ["gpt-5.1-codex-max", "codex"],
+  },
+  {
+    title: "gpt-5.1-codex-mini",
+    value: "gpt-5.1-codex-mini",
+    description: "Optimized for codex. Cheaper, faster, but less capable.",
+    keywords: ["gpt-5.1-codex-mini", "codex"],
+  },
+  {
+    title: "gpt-5.2",
+    value: "gpt-5.2",
+    description:
+      "Latest frontier model with improvements across knowledge, reasoning and coding.",
+    keywords: ["gpt-5.2"],
+  },
+];
+
+export const REASONING_CHOICES: ReasoningChoice[] = [
+  {
+    id: "low",
+    label: "Low",
+    value: "low",
+    description: "Fast responses with lighter reasoning",
+  },
+  {
+    id: "medium",
+    label: "Medium (default)",
+    value: "medium",
+    description: "Balances speed and reasoning depth for everyday tasks",
+  },
+  {
+    id: "high",
+    label: "High",
+    value: "high",
+    description: "Greater reasoning depth for complex problems",
+  },
+  {
+    id: "extra_high",
+    label: "Extra high",
+    value: "xhigh",
+    description:
+      "Extra high reasoning depth for complex problems. Warning: Extra high reasoning effort can quickly consume Plus plan rate limits.",
+  },
+];
+
+export const REASONING_FUZZY_CHOICES: FuzzyChoice<string>[] =
+  REASONING_CHOICES.map((choice) => ({
+    title: choice.label,
+    value: choice.id,
+    description: choice.description,
+    keywords: [choice.id, choice.value],
+  }));
+
+export const mapReasoningValue = (id: string) =>
+  REASONING_CHOICES.find((choice) => choice.id === id)?.value ?? "medium";