@getrouter/getrouter-cli 0.1.0

package/dist/bin.mjs

@@ -0,0 +1,1422 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { execSync, spawn } from "node:child_process";
+import { randomInt } from "node:crypto";
+import prompts from "prompts";
+
+//#region src/generated/router/dashboard/v1/index.ts
+function createSubscriptionServiceClient(handler) {
+	return { CurrentSubscription(request) {
+		const path$1 = `v1/dashboard/subscriptions/current`;
+		const body = null;
+		const queryParams = [];
+		let uri = path$1;
+		if (queryParams.length > 0) uri += `?${queryParams.join("&")}`;
+		return handler({
+			path: uri,
+			method: "GET",
+			body
+		}, {
+			service: "SubscriptionService",
+			method: "CurrentSubscription"
+		});
+	} };
+}
+function createConsumerServiceClient(handler) {
+	return {
+		CreateConsumer(request) {
+			const path$1 = `v1/dashboard/consumers/create`;
+			const body = JSON.stringify(request);
+			const queryParams = [];
+			let uri = path$1;
+			if (queryParams.length > 0) uri += `?${queryParams.join("&")}`;
+			return handler({
+				path: uri,
+				method: "POST",
+				body
+			}, {
+				service: "ConsumerService",
+				method: "CreateConsumer"
+			});
+		},
+		UpdateConsumer(request) {
+			const path$1 = `v1/dashboard/consumers/update`;
+			const body = JSON.stringify(request?.consumer ?? {});
+			const queryParams = [];
+			if (request.updateMask) queryParams.push(`updateMask=${encodeURIComponent(request.updateMask.toString())}`);
+			let uri = path$1;
+			if (queryParams.length > 0) uri += `?${queryParams.join("&")}`;
+			return handler({
+				path: uri,
+				method: "PUT",
+				body
+			}, {
+				service: "ConsumerService",
+				method: "UpdateConsumer"
+			});
+		},
+		DeleteConsumer(request) {
+			if (!request.id) throw new Error("missing required field request.id");
+			const path$1 = `v1/dashboard/consumers/${request.id}`;
+			const body = null;
+			const queryParams = [];
+			let uri = path$1;
+			if (queryParams.length > 0) uri += `?${queryParams.join("&")}`;
+			return handler({
+				path: uri,
+				method: "DELETE",
+				body
+			}, {
+				service: "ConsumerService",
+				method: "DeleteConsumer"
+			});
+		},
+		ListConsumers(request) {
+			const path$1 = `v1/dashboard/consumers`;
+			const body = null;
+			const queryParams = [];
+			if (request.pageSize) queryParams.push(`pageSize=${encodeURIComponent(request.pageSize.toString())}`);
+			if (request.pageToken) queryParams.push(`pageToken=${encodeURIComponent(request.pageToken.toString())}`);
+			let uri = path$1;
+			if (queryParams.length > 0) uri += `?${queryParams.join("&")}`;
+			return handler({
+				path: uri,
+				method: "GET",
+				body
+			}, {
+				service: "ConsumerService",
+				method: "ListConsumers"
+			});
+		},
+		GetConsumer(request) {
+			if (!request.id) throw new Error("missing required field request.id");
+			const path$1 = `v1/dashboard/consumers/${request.id}`;
+			const body = null;
+			const queryParams = [];
+			let uri = path$1;
+			if (queryParams.length > 0) uri += `?${queryParams.join("&")}`;
+			return handler({
+				path: uri,
+				method: "GET",
+				body
+			}, {
+				service: "ConsumerService",
+				method: "GetConsumer"
+			});
+		}
+	};
+}
+function createAuthServiceClient(handler) {
+	return {
+		Authorize(request) {
+			const path$1 = `v1/dashboard/auth/authorize`;
+			const body = JSON.stringify(request);
+			const queryParams = [];
+			let uri = path$1;
+			if (queryParams.length > 0) uri += `?${queryParams.join("&")}`;
+			return handler({
+				path: uri,
+				method: "POST",
+				body
+			}, {
+				service: "AuthService",
+				method: "Authorize"
+			});
+		},
+		CreateAuth(request) {
+			const path$1 = `v1/dashboard/auth/create`;
+			const body = JSON.stringify(request);
+			const queryParams = [];
+			let uri = path$1;
+			if (queryParams.length > 0) uri += `?${queryParams.join("&")}`;
+			return handler({
+				path: uri,
+				method: "POST",
+				body
+			}, {
+				service: "AuthService",
+				method: "CreateAuth"
+			});
+		},
+		RefreshToken(request) {
+			const path$1 = `v1/dashboard/auth/token`;
+			const body = JSON.stringify(request);
+			const queryParams = [];
+			let uri = path$1;
+			if (queryParams.length > 0) uri += `?${queryParams.join("&")}`;
+			return handler({
+				path: uri,
+				method: "POST",
+				body
+			}, {
+				service: "AuthService",
+				method: "RefreshToken"
+			});
+		}
+	};
+}
+function createModelServiceClient(handler) {
+	return { ListModels(request) {
+		const path$1 = `v1/dashboard/models`;
+		const body = null;
+		const queryParams = [];
+		if (request.pageSize) queryParams.push(`pageSize=${encodeURIComponent(request.pageSize.toString())}`);
+		if (request.pageToken) queryParams.push(`pageToken=${encodeURIComponent(request.pageToken.toString())}`);
+		if (request.filter) queryParams.push(`filter=${encodeURIComponent(request.filter.toString())}`);
+		let uri = path$1;
+		if (queryParams.length > 0) uri += `?${queryParams.join("&")}`;
+		return handler({
+			path: uri,
+			method: "GET",
+			body
+		}, {
+			service: "ModelService",
+			method: "ListModels"
+		});
+	} };
+}
+function createUsageServiceClient(handler) {
+	return { ListUsage(request) {
+		const path$1 = `v1/dashboard/usages`;
+		const body = null;
+		const queryParams = [];
+		if (request.pageSize) queryParams.push(`pageSize=${encodeURIComponent(request.pageSize.toString())}`);
+		if (request.pageToken) queryParams.push(`pageToken=${encodeURIComponent(request.pageToken.toString())}`);
+		let uri = path$1;
+		if (queryParams.length > 0) uri += `?${queryParams.join("&")}`;
+		return handler({
+			path: uri,
+			method: "GET",
+			body
+		}, {
+			service: "UsageService",
+			method: "ListUsage"
+		});
+	} };
+}
+
+//#endregion
+//#region src/core/config/fs.ts
+const readJsonFile = (filePath) => {
+	if (!fs.existsSync(filePath)) return null;
+	const raw = fs.readFileSync(filePath, "utf8");
+	return JSON.parse(raw);
+};
+const writeJsonFile = (filePath, value) => {
+	fs.mkdirSync(path.dirname(filePath), { recursive: true });
+	fs.writeFileSync(filePath, JSON.stringify(value, null, 2), "utf8");
+};
+
+//#endregion
+//#region src/core/config/types.ts
+const defaultConfig = () => ({
+	apiBase: "https://getrouter.dev",
+	json: false
+});
+const defaultAuthState = () => ({
+	accessToken: "",
+	refreshToken: "",
+	expiresAt: "",
+	tokenType: "Bearer"
+});
+
+//#endregion
+//#region src/core/config/index.ts
+const resolveConfigDir$1 = () => process.env.GETROUTER_CONFIG_DIR || path.join(os.homedir(), ".getrouter");
+const getConfigPath = () => path.join(resolveConfigDir$1(), "config.json");
+const getAuthPath = () => path.join(resolveConfigDir$1(), "auth.json");
+const readConfig = () => ({
+	...defaultConfig(),
+	...readJsonFile(getConfigPath()) ?? {}
+});
+const writeConfig = (cfg) => writeJsonFile(getConfigPath(), cfg);
+const readAuth = () => ({
+	...defaultAuthState(),
+	...readJsonFile(getAuthPath()) ?? {}
+});
+const writeAuth = (auth) => {
+	const authPath = getAuthPath();
+	writeJsonFile(authPath, auth);
+	if (process.platform !== "win32") fs.chmodSync(authPath, 384);
+};
+
+//#endregion
+//#region src/core/http/errors.ts
+const createApiError = (payload, fallbackMessage, status) => {
+	const payloadObject = payload && typeof payload === "object" ? payload : void 0;
+	const message = payloadObject && typeof payloadObject.message === "string" ? payloadObject.message : fallbackMessage;
+	const err = new Error(message);
+	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;
+};
+
+//#endregion
+//#region src/core/http/url.ts
+const getApiBase = () => {
+	return (readConfig().apiBase || "").replace(/\/+$/, "");
+};
+const buildApiUrl = (path$1) => {
+	const base = getApiBase();
+	const normalized = path$1.replace(/^\/+/, "");
+	return base ? `${base}/${normalized}` : `/${normalized}`;
+};
+
+//#endregion
+//#region src/core/http/request.ts
+const getAuthCookieName = () => process.env.GETROUTER_AUTH_COOKIE || process.env.KRATOS_AUTH_COOKIE || "access_token";
+const requestJson = async ({ path: path$1, method, body, fetchImpl }) => {
+	const headers = { "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$1), {
+		method,
+		headers,
+		body: body == null ? void 0 : JSON.stringify(body)
+	});
+	if (!res.ok) throw createApiError(await res.json().catch(() => null), res.statusText, res.status);
+	return await res.json();
+};
+
+//#endregion
+//#region src/core/api/client.ts
+const createApiClients = ({ fetchImpl, clients }) => {
+	const factories = clients ?? {
+		createConsumerServiceClient,
+		createAuthServiceClient,
+		createSubscriptionServiceClient,
+		createUsageServiceClient,
+		createModelServiceClient
+	};
+	const handler = async ({ path: path$1, method, body }) => {
+		return requestJson({
+			path: path$1,
+			method,
+			body: body ? JSON.parse(body) : void 0,
+			fetchImpl
+		});
+	};
+	return {
+		authService: factories.createAuthServiceClient(handler),
+		consumerService: factories.createConsumerServiceClient(handler),
+		modelService: factories.createModelServiceClient(handler),
+		subscriptionService: factories.createSubscriptionServiceClient(handler),
+		usageService: factories.createUsageServiceClient(handler)
+	};
+};
+
+//#endregion
+//#region src/core/auth/index.ts
+const isExpired = (expiresAt) => {
+	if (!expiresAt) return true;
+	const t = Date.parse(expiresAt);
+	if (Number.isNaN(t)) return true;
+	return t <= Date.now();
+};
+const getAuthStatus = () => {
+	const auth = readAuth();
+	if (!Boolean(auth.accessToken && auth.refreshToken) || isExpired(auth.expiresAt)) return { status: "logged_out" };
+	return {
+		status: "logged_in",
+		expiresAt: auth.expiresAt,
+		accessToken: auth.accessToken,
+		refreshToken: auth.refreshToken,
+		tokenType: auth.tokenType
+	};
+};
+const clearAuth = () => {
+	writeAuth(defaultAuthState());
+};
+
+//#endregion
+//#region src/core/auth/device.ts
+const alphabet = "abcdefghijklmnopqrstuvwxyz234567";
+const generateAuthCode = () => {
+	let out = "";
+	for (let i = 0; i < 13; i += 1) out += alphabet[randomInt(32)];
+	return out;
+};
+const buildLoginUrl = (authCode) => `https://getrouter.dev/#/a/${authCode}`;
+const openLoginUrl = async (url) => {
+	try {
+		if (process.platform === "darwin") {
+			spawn("open", [url], {
+				stdio: "ignore",
+				detached: true
+			}).unref();
+			return;
+		}
+		if (process.platform === "win32") {
+			spawn("cmd", [
+				"/c",
+				"start",
+				"",
+				url
+			], {
+				stdio: "ignore",
+				detached: true
+			}).unref();
+			return;
+		}
+		spawn("xdg-open", [url], {
+			stdio: "ignore",
+			detached: true
+		}).unref();
+	} catch {}
+};
+const pollAuthorize = async ({ authorize, code, timeoutMs = 300 * 1e3, initialDelayMs = 1e3, maxDelayMs = 1e4, sleep = (ms) => new Promise((r) => setTimeout(r, ms)), now = () => Date.now(), onRetry }) => {
+	const start = now();
+	let delay = initialDelayMs;
+	let attempt = 0;
+	while (true) {
+		try {
+			return await authorize({ code });
+		} catch (err) {
+			const status = typeof err === "object" && err !== null && "status" in err ? err.status : void 0;
+			if (status === 404) {} 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);
+	}
+};
+
+//#endregion
+//#region src/cmd/auth.ts
+const registerAuthCommands = (program) => {
+	program.command("login").description("Login with device flow").action(async () => {
+		const { authService } = createApiClients({});
+		const authCode = generateAuthCode();
+		const url = buildLoginUrl(authCode);
+		console.log("🔐 To authenticate, visit:");
+		console.log(url);
+		console.log("⏳ Waiting for confirmation...");
+		openLoginUrl(url);
+		const token = await pollAuthorize({
+			authorize: authService.Authorize.bind(authService),
+			code: authCode
+		});
+		writeAuth({
+			accessToken: token.accessToken ?? "",
+			refreshToken: token.refreshToken ?? "",
+			expiresAt: token.expiresAt ?? "",
+			tokenType: "Bearer"
+		});
+		console.log("✅ Login successful.");
+	});
+	program.command("logout").description("Clear local auth state").action(() => {
+		clearAuth();
+		console.log("Cleared local auth data.");
+	});
+};
+
+//#endregion
+//#region src/core/interactive/fuzzy.ts
+const normalize = (value) => value.toLowerCase();
+const fuzzyScore = (query, target) => {
+	if (!query) return 0;
+	let score = 0;
+	let lastIndex = -1;
+	for (const ch of query) {
+		const index = target.indexOf(ch, lastIndex + 1);
+		if (index === -1) return null;
+		score += index;
+		lastIndex = index;
+	}
+	return score;
+};
+const toSearchText = (choice) => normalize([choice.title, ...choice.keywords ?? []].join(" ").trim());
+const rankFuzzyChoices = (choices, input, limit = 50) => {
+	const query = normalize(input.trim());
+	if (!query) return choices.slice(0, limit);
+	const ranked = choices.map((choice) => {
+		const score = fuzzyScore(query, toSearchText(choice));
+		return score == null ? null : {
+			choice,
+			score
+		};
+	}).filter(Boolean);
+	ranked.sort((a, b) => a.score - b.score || a.choice.title.localeCompare(b.choice.title));
+	return ranked.slice(0, limit).map((entry) => entry.choice);
+};
+const fuzzySelect = async ({ message, choices }) => {
+	const response = await prompts({
+		type: "autocomplete",
+		name: "value",
+		message,
+		choices,
+		suggest: async (input, items) => rankFuzzyChoices(items, String(input))
+	});
+	if (response.value == null || response.value === "") return null;
+	return response.value;
+};
+
+//#endregion
+//#region src/core/interactive/keys.ts
+const sortByCreatedAtDesc = (consumers) => consumers.slice().sort((a, b) => {
+	const aTime = Date.parse(a.createdAt ?? "") || 0;
+	return (Date.parse(b.createdAt ?? "") || 0) - aTime;
+});
+const normalizeName = (consumer) => {
+	const name = consumer.name?.trim();
+	return name && name.length > 0 ? name : "(unnamed)";
+};
+const buildNameCounts = (consumers) => {
+	const counts = /* @__PURE__ */ new Map();
+	for (const consumer of consumers) {
+		const name = normalizeName(consumer);
+		counts.set(name, (counts.get(name) ?? 0) + 1);
+	}
+	return counts;
+};
+const formatChoice = (consumer, nameCounts) => {
+	const name = normalizeName(consumer);
+	const createdAt = consumer.createdAt ?? "-";
+	return (nameCounts.get(name) ?? 0) > 1 || name === "(unnamed)" ? `${name} (${createdAt})` : name;
+};
+const promptKeyName = async (initial) => {
+	const response = await prompts({
+		type: "text",
+		name: "name",
+		message: "Key name",
+		initial: initial ?? ""
+	});
+	const value = typeof response.name === "string" ? response.name.trim() : "";
+	return value.length > 0 ? value : void 0;
+};
+const promptKeyEnabled = async (initial) => {
+	const response = await prompts({
+		type: "confirm",
+		name: "enabled",
+		message: "Enable this key?",
+		initial
+	});
+	return typeof response.enabled === "boolean" ? response.enabled : initial;
+};
+const selectConsumer = async (consumerService) => {
+	const consumers = (await consumerService.ListConsumers({
+		pageSize: void 0,
+		pageToken: void 0
+	}))?.consumers ?? [];
+	if (consumers.length === 0) throw new Error("No available API keys");
+	const sorted = sortByCreatedAtDesc(consumers);
+	const nameCounts = buildNameCounts(sorted);
+	return await fuzzySelect({
+		message: "🔎 Search keys",
+		choices: sorted.map((consumer) => ({
+			title: formatChoice(consumer, nameCounts),
+			value: consumer,
+			keywords: [normalizeName(consumer), consumer.createdAt ?? ""].filter(Boolean)
+		}))
+	}) ?? null;
+};
+const selectConsumerList = async (consumerService, message) => {
+	const consumers = (await consumerService.ListConsumers({
+		pageSize: void 0,
+		pageToken: void 0
+	}))?.consumers ?? [];
+	if (consumers.length === 0) throw new Error("No available API keys");
+	const sorted = sortByCreatedAtDesc(consumers);
+	const nameCounts = buildNameCounts(sorted);
+	const response = await prompts({
+		type: "select",
+		name: "value",
+		message,
+		choices: sorted.map((consumer) => ({
+			title: formatChoice(consumer, nameCounts),
+			value: consumer
+		}))
+	});
+	if (response.value == null || response.value === "") return null;
+	return response.value;
+};
+const confirmDelete = async (consumer) => {
+	const response = await prompts({
+		type: "confirm",
+		name: "confirm",
+		message: `⚠️ Confirm delete ${consumer.name ?? "-"} (${consumer.id ?? "-"})?`,
+		initial: false
+	});
+	return Boolean(response.confirm);
+};
+
+//#endregion
+//#region src/core/setup/env.ts
+const renderLine = (shell, key, value) => {
+	if (shell === "ps1") return `$env:${key}="${value}"`;
+	return `export ${key}=${value}`;
+};
+const renderEnv = (shell, vars) => {
+	const lines = [];
+	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));
+	lines.push("");
+	return lines.join("\n");
+};
+const renderHook = (shell) => {
+	if (shell === "pwsh") return [
+		"function getrouter {",
+		"  $cmd = Get-Command getrouter -CommandType Application,ExternalScript -ErrorAction SilentlyContinue | Select-Object -First 1",
+		"  if ($null -ne $cmd) {",
+		"    & $cmd.Source @args",
+		"  }",
+		"  $exitCode = $LASTEXITCODE",
+		"  if ($exitCode -ne 0) {",
+		"    return $exitCode",
+		"  }",
+		"  if ($args.Count -gt 0 -and ($args[0] -eq \"codex\" -or $args[0] -eq \"claude\")) {",
+		"    $configDir = if ($env:GETROUTER_CONFIG_DIR) { $env:GETROUTER_CONFIG_DIR } else { Join-Path $HOME \".getrouter\" }",
+		"    $envPath = Join-Path $configDir \"env.ps1\"",
+		"    if (Test-Path $envPath) {",
+		"      . $envPath",
+		"    }",
+		"  }",
+		"  return $exitCode",
+		"}",
+		""
+	].join("\n");
+	if (shell === "fish") return [
+		"function getrouter",
+		"  command getrouter $argv",
+		"  set -l exit_code $status",
+		"  if test $exit_code -ne 0",
+		"    return $exit_code",
+		"  end",
+		"  if test (count $argv) -gt 0",
+		"    switch $argv[1]",
+		"      case codex claude",
+		"        set -l config_dir $GETROUTER_CONFIG_DIR",
+		"        if test -z \"$config_dir\"",
+		"          set config_dir \"$HOME/.getrouter\"",
+		"        end",
+		"        set -l env_path \"$config_dir/env.sh\"",
+		"        if test -f \"$env_path\"",
+		"          source \"$env_path\"",
+		"        end",
+		"    end",
+		"  end",
+		"  return $exit_code",
+		"end",
+		""
+	].join("\n");
+	return [
+		"getrouter() {",
+		"  command getrouter \"$@\"",
+		"  local exit_code=$?",
+		"  if [ $exit_code -ne 0 ]; then",
+		"    return $exit_code",
+		"  fi",
+		"  case \"$1\" in",
+		"    codex|claude)",
+		`      local config_dir="\${GETROUTER_CONFIG_DIR:-$HOME/.getrouter}"`,
+		"      local env_path=\"$config_dir/env.sh\"",
+		"      if [ -f \"$env_path\" ]; then",
+		"        source \"$env_path\"",
+		"      fi",
+		"      ;;",
+		"  esac",
+		"  return $exit_code",
+		"}",
+		""
+	].join("\n");
+};
+const getEnvFilePath = (shell, configDir) => path.join(configDir, shell === "ps1" ? "env.ps1" : "env.sh");
+const getHookFilePath = (shell, configDir) => {
+	if (shell === "pwsh") return path.join(configDir, "hook.ps1");
+	if (shell === "fish") return path.join(configDir, "hook.fish");
+	return path.join(configDir, "hook.sh");
+};
+const writeEnvFile = (filePath, content) => {
+	fs.mkdirSync(path.dirname(filePath), { recursive: true });
+	fs.writeFileSync(filePath, content, "utf8");
+	if (process.platform !== "win32") fs.chmodSync(filePath, 384);
+};
+const resolveShellRcPath = (shell, homeDir) => {
+	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");
+	if (shell === "pwsh") {
+		if (process.platform === "win32") return path.join(homeDir, "Documents/PowerShell/Microsoft.PowerShell_profile.ps1");
+		return path.join(homeDir, ".config/powershell/Microsoft.PowerShell_profile.ps1");
+	}
+	return null;
+};
+const resolveEnvShell = (shell) => shell === "pwsh" ? "ps1" : "sh";
+const detectShell = () => {
+	const shellPath = process.env.SHELL;
+	if (shellPath) {
+		const name = shellPath.split("/").pop()?.toLowerCase();
+		if (name === "zsh" || name === "bash" || name === "fish" || name === "pwsh") return name;
+	}
+	if (process.platform === "win32") return "pwsh";
+	return "bash";
+};
+const applyEnvVars = (vars) => {
+	if (vars.openaiBaseUrl) process.env.OPENAI_BASE_URL = vars.openaiBaseUrl;
+	if (vars.openaiApiKey) process.env.OPENAI_API_KEY = vars.openaiApiKey;
+	if (vars.anthropicBaseUrl) process.env.ANTHROPIC_BASE_URL = vars.anthropicBaseUrl;
+	if (vars.anthropicApiKey) process.env.ANTHROPIC_API_KEY = vars.anthropicApiKey;
+};
+const formatSourceLine = (shell, envPath) => shell === "ps1" ? `. ${envPath}` : `source ${envPath}`;
+const trySourceEnv = (shell, envShell, envPath) => {
+	try {
+		if (envShell === "ps1") {
+			execSync(`pwsh -NoProfile -Command ". '${envPath}'"`, { stdio: "ignore" });
+			return;
+		}
+		execSync(`${shell} -c "${shell === "fish" ? "source" : "source"} '${envPath}'"`, { stdio: "ignore" });
+	} catch {}
+};
+const appendRcIfMissing = (rcPath, line) => {
+	let content = "";
+	if (fs.existsSync(rcPath)) {
+		content = fs.readFileSync(rcPath, "utf8");
+		if (content.includes(line)) return false;
+	}
+	const prefix = content && !content.endsWith("\n") ? "\n" : "";
+	fs.mkdirSync(path.dirname(rcPath), { recursive: true });
+	fs.writeFileSync(rcPath, `${content}${prefix}${line}\n`, "utf8");
+	return true;
+};
+const resolveConfigDir = () => process.env.GETROUTER_CONFIG_DIR || path.join(os.homedir(), ".getrouter");
+
+//#endregion
+//#region src/cmd/env.ts
+const CLAUDE_BASE_URL = "https://api.getrouter.dev/claude";
+const registerEnvCommand = (program, config) => {
+	program.command(config.name).description(config.description).option("--install", "Install into shell rc").action(async (options) => {
+		if (!process.stdin.isTTY) throw new Error("Interactive mode required for key selection.");
+		const shell = detectShell();
+		const envShell = resolveEnvShell(shell);
+		const configDir = resolveConfigDir();
+		const { consumerService } = createApiClients({});
+		const selected = await selectConsumer(consumerService);
+		if (!selected?.id) return;
+		const consumer = await consumerService.GetConsumer({ id: selected.id });
+		if (!consumer?.apiKey) throw new Error("API key not found. Please create one or choose another.");
+		const vars = config.vars(consumer.apiKey);
+		const envPath = getEnvFilePath(envShell, configDir);
+		writeEnvFile(envPath, renderEnv(envShell, vars));
+		let installed = false;
+		let rcPath = null;
+		if (options.install) {
+			const hookPath = getHookFilePath(shell, configDir);
+			writeEnvFile(hookPath, renderHook(shell));
+			rcPath = resolveShellRcPath(shell, os.homedir());
+			if (rcPath) {
+				const envLine = formatSourceLine(envShell, envPath);
+				const hookLine = formatSourceLine(envShell, hookPath);
+				const envAdded = appendRcIfMissing(rcPath, envLine);
+				const hookAdded = appendRcIfMissing(rcPath, hookLine);
+				installed = envAdded || hookAdded;
+			}
+			applyEnvVars(vars);
+			trySourceEnv(shell, envShell, envPath);
+		}
+		const sourceLine = formatSourceLine(envShell, envPath);
+		if (options.install) {
+			if (installed && rcPath) console.log(`✅ Added to ${rcPath}`);
+			else if (rcPath) console.log(`ℹ️ Already configured in ${rcPath}`);
+		} else {
+			console.log("To load the environment in your shell, run:");
+			console.log(sourceLine);
+		}
+	});
+};
+const buildAnthropicEnv = (apiKey) => ({
+	anthropicBaseUrl: CLAUDE_BASE_URL,
+	anthropicApiKey: apiKey
+});
+
+//#endregion
+//#region src/cmd/claude.ts
+const registerClaudeCommand = (program) => {
+	registerEnvCommand(program, {
+		name: "claude",
+		description: "Configure Claude environment",
+		vars: buildAnthropicEnv
+	});
+};
+
+//#endregion
+//#region src/core/interactive/codex.ts
+const MODEL_CHOICES = [
+	{
+		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"]
+	}
+];
+const REASONING_CHOICES = [
+	{
+		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."
+	}
+];
+const REASONING_FUZZY_CHOICES = REASONING_CHOICES.map((choice) => ({
+	title: choice.label,
+	value: choice.id,
+	description: choice.description,
+	keywords: [choice.id, choice.value]
+}));
+const mapReasoningValue = (id) => REASONING_CHOICES.find((choice) => choice.id === id)?.value ?? "medium";
+
+//#endregion
+//#region src/core/setup/codex.ts
+const CODEX_PROVIDER = "getrouter";
+const CODEX_BASE_URL = "https://api.getrouter.dev/codex";
+const ROOT_KEYS = [
+	"model",
+	"model_reasoning_effort",
+	"model_provider"
+];
+const PROVIDER_SECTION = `model_providers.${CODEX_PROVIDER}`;
+const PROVIDER_KEYS = [
+	"name",
+	"base_url",
+	"wire_api",
+	"requires_openai_auth"
+];
+const rootValues = (input) => ({
+	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) => line.match(/^\s*\[([^\]]+)\]\s*$/);
+const matchKey = (line) => line.match(/^\s*([A-Za-z0-9_.-]+)\s*=/);
+const mergeCodexToml = (content, input) => {
+	const updated = [...content.length ? content.split(/\r?\n/) : []];
+	const rootValueMap = rootValues(input);
+	const providerValueMap = providerValues();
+	let currentSection = null;
+	let firstHeaderIndex = null;
+	const rootFound = /* @__PURE__ */ new Set();
+	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];
+		if (ROOT_KEYS.includes(key)) {
+			updated[i] = `${key} = ${rootValueMap[key]}`;
+			rootFound.add(key);
+		}
+	}
+	const insertIndex = firstHeaderIndex ?? updated.length;
+	const missingRoot = ROOT_KEYS.filter((key) => !rootFound.has(key)).map((key) => `${key} = ${rootValueMap[key]}`);
+	if (missingRoot.length > 0) {
+		const needsBlank = insertIndex < updated.length && updated[insertIndex]?.trim() !== "";
+		updated.splice(insertIndex, 0, ...missingRoot, ...needsBlank ? [""] : []);
+	}
+	const providerHeader = `[${PROVIDER_SECTION}]`;
+	const providerHeaderIndex = updated.findIndex((line) => line.trim() === providerHeader);
+	if (providerHeaderIndex === -1) {
+		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]}`);
+		return updated.join("\n");
+	}
+	let providerEnd = updated.length;
+	for (let i = providerHeaderIndex + 1; i < updated.length; i += 1) if (matchHeader(updated[i] ?? "")) {
+		providerEnd = i;
+		break;
+	}
+	const providerFound = /* @__PURE__ */ new Set();
+	for (let i = providerHeaderIndex + 1; i < providerEnd; i += 1) {
+		const keyMatch = matchKey(updated[i] ?? "");
+		if (!keyMatch) continue;
+		const key = keyMatch[1];
+		if (PROVIDER_KEYS.includes(key)) {
+			updated[i] = `${key} = ${providerValueMap[key]}`;
+			providerFound.add(key);
+		}
+	}
+	const missingProvider = PROVIDER_KEYS.filter((key) => !providerFound.has(key)).map((key) => `${key} = ${providerValueMap[key]}`);
+	if (missingProvider.length > 0) updated.splice(providerEnd, 0, ...missingProvider);
+	return updated.join("\n");
+};
+const mergeAuthJson = (data, apiKey) => ({
+	...data,
+	OPENAI_API_KEY: apiKey
+});
+
+//#endregion
+//#region src/cmd/codex.ts
+const CODEX_DIR = ".codex";
+const readFileIfExists = (filePath) => fs.existsSync(filePath) ? fs.readFileSync(filePath, "utf8") : "";
+const readAuthJson = (filePath) => {
+	if (!fs.existsSync(filePath)) return {};
+	const raw = fs.readFileSync(filePath, "utf8").trim();
+	if (!raw) return {};
+	const parsed = JSON.parse(raw);
+	if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error("Invalid auth.json format.");
+	return parsed;
+};
+const ensureCodexDir = () => {
+	const dir = path.join(os.homedir(), CODEX_DIR);
+	fs.mkdirSync(dir, { recursive: true });
+	return dir;
+};
+const requireInteractive$1 = () => {
+	if (!process.stdin.isTTY) throw new Error("Interactive mode required for codex configuration.");
+};
+const promptModel = async () => await fuzzySelect({
+	message: "Select Model and Effort\nAccess legacy models by running codex -m <model_name> or in your config.toml",
+	choices: MODEL_CHOICES
+});
+const promptReasoning = async (model) => await fuzzySelect({
+	message: `Select Reasoning Level for ${model}`,
+	choices: REASONING_FUZZY_CHOICES
+});
+const formatReasoningLabel = (id) => REASONING_CHOICES.find((choice) => choice.id === id)?.label ?? id;
+const registerCodexCommand = (program) => {
+	program.command("codex").description("Configure Codex").action(async () => {
+		requireInteractive$1();
+		const model = await promptModel();
+		if (!model) return;
+		const reasoningId = await promptReasoning(model);
+		if (!reasoningId) return;
+		const { consumerService } = createApiClients({});
+		const selected = await selectConsumer(consumerService);
+		if (!selected?.id) return;
+		const apiKey = (await consumerService.GetConsumer({ id: selected.id }))?.apiKey ?? "";
+		if (!apiKey) throw new Error("API key not found. Please create one or choose another.");
+		const reasoningValue = mapReasoningValue(reasoningId);
+		const keyName = selected.name ?? "-";
+		const keyId = selected.id ?? "-";
+		if (!(await prompts({
+			type: "confirm",
+			name: "confirm",
+			message: [
+				"Apply Codex configuration?",
+				`Model: ${model}`,
+				`Reasoning: ${formatReasoningLabel(reasoningId)} (${reasoningValue})`,
+				"Provider: getrouter",
+				`Key: ${keyName} (${keyId})`
+			].join("\n"),
+			initial: true
+		})).confirm) return;
+		const codexDir = ensureCodexDir();
+		const configPath = path.join(codexDir, "config.toml");
+		const authPath = path.join(codexDir, "auth.json");
+		const mergedConfig = mergeCodexToml(readFileIfExists(configPath), {
+			model,
+			reasoning: reasoningValue
+		});
+		fs.writeFileSync(configPath, mergedConfig, "utf8");
+		const mergedAuth = mergeAuthJson(readAuthJson(authPath), apiKey);
+		fs.writeFileSync(authPath, JSON.stringify(mergedAuth, null, 2));
+		if (process.platform !== "win32") fs.chmodSync(authPath, 384);
+		console.log("✅ Updated ~/.codex/config.toml");
+		console.log("✅ Updated ~/.codex/auth.json");
+	});
+};
+
+//#endregion
+//#region src/cmd/config-helpers.ts
+const normalizeApiBase = (value) => value.trim().replace(/\/+$/, "");
+const parseConfigValue = (key, raw) => {
+	if (key === "apiBase") {
+		const normalized = normalizeApiBase(raw);
+		if (!/^https?:\/\//.test(normalized)) throw new Error("apiBase must start with http:// or https://");
+		return normalized;
+	}
+	const lowered = raw.toLowerCase();
+	if (["true", "1"].includes(lowered)) return true;
+	if (["false", "0"].includes(lowered)) return false;
+	throw new Error("json must be true/false or 1/0");
+};
+
+//#endregion
+//#region src/cmd/config.ts
+const VALID_KEYS = new Set(["apiBase", "json"]);
+const registerConfigCommands = (program) => {
+	program.command("config").description("Manage CLI config").argument("[key]").argument("[value]").action((key, value) => {
+		const cfg = readConfig();
+		if (!key) {
+			console.log(`apiBase=${cfg.apiBase}`);
+			console.log(`json=${cfg.json}`);
+			return;
+		}
+		if (!value) throw new Error("Missing config value");
+		if (!VALID_KEYS.has(key)) throw new Error("Unknown config key");
+		const parsed = parseConfigValue(key, value);
+		const next = {
+			...cfg,
+			[key]: parsed
+		};
+		writeConfig(next);
+		console.log(`${key}=${next[key]}`);
+	});
+};
+
+//#endregion
+//#region src/core/config/redact.ts
+const SECRET_KEYS = new Set([
+	"accessToken",
+	"refreshToken",
+	"apiKey"
+]);
+const mask = (value) => {
+	if (!value) return "";
+	if (value.length <= 8) return "****";
+	return `${value.slice(0, 4)}...${value.slice(-4)}`;
+};
+const redactSecrets = (obj) => {
+	const out = { ...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;
+};
+
+//#endregion
+//#region src/core/output/table.ts
+const truncate = (value, max) => {
+	if (value.length <= max) return value;
+	if (max <= 3) return value.slice(0, max);
+	return `${value.slice(0, max - 3)}...`;
+};
+const renderTable = (headers, rows, options = {}) => {
+	const maxColWidth = options.maxColWidth ?? 32;
+	const normalized = rows.map((row) => row.map((cell) => cell && cell.length > 0 ? cell : "-"));
+	const widths = headers.map((header, index) => {
+		const colValues = normalized.map((row) => row[index] ?? "-");
+		const maxLen = Math.max(header.length, ...colValues.map((v) => v.length));
+		return Math.min(maxLen, maxColWidth);
+	});
+	const renderRow = (cells) => cells.map((cell, index) => {
+		return truncate(cell ?? "-", widths[index]).padEnd(widths[index], " ");
+	}).join("  ");
+	return `${renderRow(headers)}\n${normalized.map((row) => renderRow(row)).join("\n")}`;
+};
+
+//#endregion
+//#region src/cmd/keys.ts
+const consumerHeaders = [
+	"NAME",
+	"ENABLED",
+	"LAST_ACCESS",
+	"CREATED_AT",
+	"API_KEY"
+];
+const consumerRow = (consumer) => [
+	String(consumer.name ?? ""),
+	String(consumer.enabled ?? ""),
+	String(consumer.lastAccess ?? ""),
+	String(consumer.createdAt ?? ""),
+	String(consumer.apiKey ?? "")
+];
+const outputConsumerTable = (consumer) => {
+	console.log(renderTable(consumerHeaders, [consumerRow(consumer)]));
+};
+const outputConsumers = (consumers) => {
+	const rows = consumers.map(consumerRow);
+	console.log(renderTable(consumerHeaders, rows));
+};
+const redactConsumer = (consumer) => redactSecrets(consumer);
+const requireInteractive = (message) => {
+	if (!process.stdin.isTTY) throw new Error(message);
+};
+const requireInteractiveForSelection = () => requireInteractive("Interactive mode required when key id is omitted.");
+const requireInteractiveForAction = (action) => requireInteractive(`Interactive mode required for keys ${action}.`);
+const updateConsumer = async (consumerService, consumer, name, enabled) => {
+	const updateMask = [name !== void 0 && name !== consumer.name ? "name" : null, enabled !== void 0 && enabled !== consumer.enabled ? "enabled" : null].filter(Boolean).join(",");
+	if (!updateMask) return consumer;
+	return consumerService.UpdateConsumer({
+		consumer: {
+			...consumer,
+			name: name ?? consumer.name,
+			enabled: enabled ?? consumer.enabled
+		},
+		updateMask
+	});
+};
+const listConsumers = async (consumerService) => {
+	outputConsumers(((await consumerService.ListConsumers({
+		pageSize: void 0,
+		pageToken: void 0
+	}))?.consumers ?? []).map(redactConsumer));
+};
+const resolveConsumerForUpdate = async (consumerService, id) => {
+	if (id) return consumerService.GetConsumer({ id });
+	requireInteractiveForSelection();
+	return await selectConsumerList(consumerService, "Select key to update");
+};
+const resolveConsumerForDelete = async (consumerService, id) => {
+	if (id) return consumerService.GetConsumer({ id });
+	requireInteractiveForSelection();
+	return await selectConsumerList(consumerService, "Select key to delete");
+};
+const createConsumer = async (consumerService) => {
+	requireInteractiveForAction("create");
+	const name = await promptKeyName();
+	const enabled = await promptKeyEnabled(true);
+	let consumer = await consumerService.CreateConsumer({});
+	consumer = await updateConsumer(consumerService, consumer, name, enabled);
+	outputConsumerTable(consumer);
+	console.log("Please store this API key securely.");
+};
+const updateConsumerById = async (consumerService, id) => {
+	requireInteractiveForAction("update");
+	const selected = await resolveConsumerForUpdate(consumerService, id);
+	if (!selected?.id) return;
+	outputConsumerTable(redactConsumer(await updateConsumer(consumerService, selected, await promptKeyName(selected.name), await promptKeyEnabled(selected.enabled ?? true))));
+};
+const deleteConsumerById = async (consumerService, id) => {
+	requireInteractiveForAction("delete");
+	const selected = await resolveConsumerForDelete(consumerService, id);
+	if (!selected?.id) return;
+	if (!await confirmDelete(selected)) return;
+	await consumerService.DeleteConsumer({ id: selected.id });
+	outputConsumerTable(redactConsumer(selected));
+};
+const registerKeysCommands = (program) => {
+	const keys = program.command("keys").description("Manage API keys");
+	keys.allowExcessArguments(false);
+	keys.action(async () => {
+		const { consumerService } = createApiClients({});
+		await listConsumers(consumerService);
+	});
+	keys.command("list").description("List API keys").action(async () => {
+		const { consumerService } = createApiClients({});
+		await listConsumers(consumerService);
+	});
+	keys.command("create").description("Create an API key").action(async () => {
+		const { consumerService } = createApiClients({});
+		await createConsumer(consumerService);
+	});
+	keys.command("update").description("Update an API key").argument("[id]", "Key id").action(async (id) => {
+		const { consumerService } = createApiClients({});
+		await updateConsumerById(consumerService, id);
+	});
+	keys.command("delete").description("Delete an API key").argument("[id]", "Key id").action(async (id) => {
+		const { consumerService } = createApiClients({});
+		await deleteConsumerById(consumerService, id);
+	});
+};
+
+//#endregion
+//#region src/cmd/models.ts
+const modelHeaders = [
+	"NAME",
+	"AUTHOR",
+	"ENABLED",
+	"UPDATED_AT"
+];
+const modelRow = (model) => [
+	String(model.name ?? ""),
+	String(model.author ?? ""),
+	String(model.enabled ?? ""),
+	String(model.updatedAt ?? "")
+];
+const outputModels = (models) => {
+	console.log("🧠 Models");
+	console.log(renderTable(modelHeaders, models.map(modelRow)));
+};
+const listModels = async () => {
+	const { modelService } = createApiClients({});
+	const models = (await modelService.ListModels({
+		pageSize: void 0,
+		pageToken: void 0,
+		filter: void 0
+	}))?.models ?? [];
+	if (models.length === 0) {
+		console.log("😕 No models found");
+		return;
+	}
+	outputModels(models);
+};
+const registerModelsCommands = (program) => {
+	const models = program.command("models").description("List models");
+	models.action(async () => {
+		await listModels();
+	});
+	models.command("list").description("List models").action(async () => {
+		await listModels();
+	});
+};
+
+//#endregion
+//#region src/cmd/status.ts
+const LABEL_WIDTH = 10;
+const formatLine = (label, value) => {
+	if (value == null || value === "") return null;
+	return `  ${label.padEnd(LABEL_WIDTH, " ")}: ${value}`;
+};
+const formatAuthStatus = (status) => status === "logged_in" ? "✅ Logged in" : "❌ Logged out";
+const formatToken = (token) => {
+	if (!token) return void 0;
+	const trimmed = token.trim();
+	if (trimmed.length <= 12) return trimmed;
+	return `${trimmed.slice(0, 4)}...${trimmed.slice(-4)}`;
+};
+const formatWindow = (startAt, endAt) => {
+	if (!startAt && !endAt) return void 0;
+	if (startAt && endAt) return `${startAt} → ${endAt}`;
+	if (startAt) return `${startAt} →`;
+	return `→ ${endAt}`;
+};
+const formatLimits = (requestPerMinute, tokenPerMinute) => {
+	const parts = [];
+	if (typeof requestPerMinute === "number") parts.push(`${requestPerMinute} req/min`);
+	if (tokenPerMinute) parts.push(`${tokenPerMinute} tok/min`);
+	if (parts.length === 0) return void 0;
+	return parts.join(" · ");
+};
+const renderAuthSection = () => {
+	const status = getAuthStatus();
+	return ["🔐 Auth", ...[
+		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)].join("\n");
+};
+const renderSubscriptionSection = (subscription) => {
+	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);
+	return ["📦 Subscription", ...[
+		formatLine("Plan", subscription.plan?.name),
+		formatLine("Status", subscription.status),
+		formatLine("Window", windowLabel),
+		formatLine("Limits", limits)
+	].filter(Boolean)].join("\n");
+};
+const registerStatusCommand = (program) => {
+	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));
+	});
+};
+
+//#endregion
+//#region src/core/output/usages.ts
+const INPUT_BLOCK = "█";
+const OUTPUT_BLOCK = "▒";
+const DEFAULT_WIDTH = 24;
+const formatTokens = (value) => {
+	const abs = Math.abs(value);
+	if (abs < 1e3) return Math.round(value).toString();
+	for (const unit of [
+		{
+			threshold: 1e9,
+			suffix: "B"
+		},
+		{
+			threshold: 1e6,
+			suffix: "M"
+		},
+		{
+			threshold: 1e3,
+			suffix: "K"
+		}
+	]) 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}`;
+	}
+	return Math.round(value).toString();
+};
+const renderUsageChart = (rows, width = DEFAULT_WIDTH) => {
+	const header = "📊 Usage (last 7 days) · Tokens";
+	if (rows.length === 0) return `${header}\n\nNo usage data available.`;
+	const normalized = rows.map((row) => {
+		const input = Number(row.inputTokens);
+		const output = Number(row.outputTokens);
+		const safeInput = Number.isFinite(input) ? input : 0;
+		const safeOutput = Number.isFinite(output) ? output : 0;
+		return {
+			day: row.day,
+			input: safeInput,
+			output: safeOutput,
+			total: safeInput + safeOutput
+		};
+	});
+	const totals = normalized.map((row) => row.total);
+	const maxTotal = Math.max(0, ...totals);
+	const lines = normalized.map((row) => {
+		const total = row.total;
+		if (maxTotal === 0 || total === 0) return `${row.day} ${"".padEnd(width, " ")} I:0 O:0`;
+		const scaled = Math.max(1, Math.round(total / maxTotal * width));
+		let inputBars = Math.round(row.input / total * scaled);
+		let outputBars = Math.max(0, scaled - inputBars);
+		if (row.input > 0 && row.output > 0) {
+			if (inputBars === 0) {
+				inputBars = 1;
+				outputBars = Math.max(0, scaled - 1);
+			} else if (outputBars === 0) {
+				outputBars = 1;
+				inputBars = Math.max(0, scaled - 1);
+			}
+		}
+		const bar = `${INPUT_BLOCK.repeat(inputBars)}${OUTPUT_BLOCK.repeat(outputBars)}`;
+		const inputLabel = formatTokens(row.input);
+		const outputLabel = formatTokens(row.output);
+		return `${row.day} ${bar.padEnd(width, " ")} I:${inputLabel} O:${outputLabel}`;
+	});
+	const legend = `Legend: ${INPUT_BLOCK} input    ${OUTPUT_BLOCK} output`;
+	return [
+		header,
+		"",
+		...lines,
+		"",
+		legend
+	].join("\n");
+};
+
+//#endregion
+//#region src/core/usages/aggregate.ts
+const formatDay = (value) => {
+	return `${value.getFullYear()}-${String(value.getMonth() + 1).padStart(2, "0")}-${String(value.getDate()).padStart(2, "0")}`;
+};
+const toNumber = (value) => {
+	if (typeof value === "number") return Number.isFinite(value) ? value : 0;
+	if (typeof value === "string") {
+		const parsed = Number(value);
+		return Number.isFinite(parsed) ? parsed : 0;
+	}
+	return 0;
+};
+const aggregateUsages = (usages, maxDays = 7) => {
+	const totals = /* @__PURE__ */ new Map();
+	for (const usage of usages) {
+		if (!usage.createdAt) continue;
+		const parsed = new Date(usage.createdAt);
+		if (Number.isNaN(parsed.getTime())) continue;
+		const day = formatDay(parsed);
+		const input = toNumber(usage.inputTokens);
+		const output = toNumber(usage.outputTokens);
+		const totalRaw = typeof usage.totalTokens === "string" || typeof usage.totalTokens === "number" ? Number(usage.totalTokens) : NaN;
+		const total = Number.isFinite(totalRaw) && totalRaw > 0 ? totalRaw : input + output;
+		const current = totals.get(day) ?? {
+			day,
+			inputTokens: 0,
+			outputTokens: 0,
+			totalTokens: 0,
+			requests: 0
+		};
+		current.inputTokens += input;
+		current.outputTokens += output;
+		current.totalTokens += total;
+		current.requests += 1;
+		totals.set(day, current);
+	}
+	return Array.from(totals.values()).sort((a, b) => b.day.localeCompare(a.day)).slice(0, maxDays);
+};
+
+//#endregion
+//#region src/cmd/usages.ts
+const collectUsages = async () => {
+	const { usageService } = createApiClients({});
+	return aggregateUsages((await usageService.ListUsage({
+		pageSize: 7,
+		pageToken: void 0
+	}))?.usages ?? [], 7);
+};
+const registerUsagesCommand = (program) => {
+	program.command("usages").description("Show recent usage").action(async () => {
+		const aggregated = await collectUsages();
+		console.log(renderUsageChart(aggregated));
+	});
+};
+
+//#endregion
+//#region src/cmd/index.ts
+const registerCommands = (program) => {
+	registerAuthCommands(program);
+	registerCodexCommand(program);
+	registerClaudeCommand(program);
+	registerConfigCommands(program);
+	registerKeysCommands(program);
+	registerModelsCommands(program);
+	registerStatusCommand(program);
+	registerUsagesCommand(program);
+};
+
+//#endregion
+//#region src/cli.ts
+const createProgram = () => {
+	const program = new Command();
+	program.name("getrouter").description("CLI for getrouter.dev").version("0.1.0");
+	registerCommands(program);
+	return program;
+};
+
+//#endregion
+//#region src/bin.ts
+createProgram().parse(process.argv);
+
+//#endregion
+export {  };