@getrouter/getrouter-cli 0.1.13 → 0.1.14

package/dist/bin.mjs

@@ -8,7 +8,7 @@ import { randomInt } from "node:crypto";
 import prompts from "prompts";
 
 //#region package.json
-var version = "0.1.12";
+var version = "0.1.13";
 
 //#endregion
 //#region src/generated/router/dashboard/v1/index.ts
@@ -204,15 +204,15 @@ function createAuthServiceClient(handler) {
 
 //#endregion
 //#region src/core/config/fs.ts
-const getCorruptBackupPath = (filePath) => {
+function getCorruptBackupPath(filePath) {
 	const dir = path.dirname(filePath);
 	const ext = path.extname(filePath);
 	const base = path.basename(filePath, ext);
 	const stamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
 	const rand = Math.random().toString(16).slice(2, 8);
 	return path.join(dir, `${base}.corrupt-${stamp}-${rand}${ext}`);
-};
-const readJsonFile = (filePath) => {
+}
+function readJsonFile(filePath) {
 	if (!fs.existsSync(filePath)) return null;
 	let raw;
 	try {
@@ -233,62 +233,101 @@ const readJsonFile = (filePath) => {
 		}
 		return null;
 	}
-};
-const writeJsonFile = (filePath, value) => {
+}
+function writeJsonFile(filePath, value) {
 	fs.mkdirSync(path.dirname(filePath), { recursive: true });
 	fs.writeFileSync(filePath, JSON.stringify(value, null, 2), "utf8");
-};
+}
 
 //#endregion
 //#region src/core/config/paths.ts
-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");
+function resolveConfigDir() {
+	return process.env.GETROUTER_CONFIG_DIR || path.join(os.homedir(), ".getrouter");
+}
+function getConfigPath() {
+	return path.join(resolveConfigDir(), "config.json");
+}
+function getAuthPath() {
+	return path.join(resolveConfigDir(), "auth.json");
+}
 
 //#endregion
 //#region src/core/config/types.ts
-const defaultConfig = () => ({
-	apiBase: "https://getrouter.dev",
-	json: false
-});
-const defaultAuthState = () => ({
-	accessToken: "",
-	refreshToken: "",
-	expiresAt: "",
-	tokenType: "Bearer"
-});
+function defaultConfig() {
+	return {
+		apiBase: "https://getrouter.dev",
+		json: false
+	};
+}
+function defaultAuthState() {
+	return {
+		accessToken: "",
+		refreshToken: "",
+		expiresAt: "",
+		tokenType: "Bearer"
+	};
+}
 
 //#endregion
 //#region src/core/config/index.ts
-const readConfig = () => ({
-	...defaultConfig(),
-	...readJsonFile(getConfigPath()) ?? {}
-});
-const readAuth = () => ({
-	...defaultAuthState(),
-	...readJsonFile(getAuthPath()) ?? {}
-});
-const writeAuth = (auth) => {
+function readConfig() {
+	return {
+		...defaultConfig(),
+		...readJsonFile(getConfigPath()) ?? {}
+	};
+}
+function readAuth() {
+	return {
+		...defaultAuthState(),
+		...readJsonFile(getAuthPath()) ?? {}
+	};
+}
+function writeAuth(auth) {
 	const authPath = getAuthPath();
 	writeJsonFile(authPath, auth);
 	if (process.platform !== "win32") fs.chmodSync(authPath, 384);
-};
+}
 
 //#endregion
 //#region src/core/http/url.ts
-const getApiBase = () => {
+function getApiBase() {
 	return (readConfig().apiBase || "").replace(/\/+$/, "");
-};
-const buildApiUrl = (path$1) => {
+}
+function buildApiUrl(path$1) {
 	const base = getApiBase();
-	const normalized = path$1.replace(/^\/+/, "");
-	return base ? `${base}/${normalized}` : `/${normalized}`;
-};
+	const normalizedPath = path$1.replace(/^\/+/, "");
+	if (base) return `${base}/${normalizedPath}`;
+	return `/${normalizedPath}`;
+}
+
+//#endregion
+//#region src/core/auth/index.ts
+function isTokenExpired(expiresAt, bufferMs = 0) {
+	if (!expiresAt) return true;
+	const timestampMs = Date.parse(expiresAt);
+	if (Number.isNaN(timestampMs)) return true;
+	return timestampMs <= Date.now() + bufferMs;
+}
+function getAuthStatus() {
+	const auth = readAuth();
+	if (!Boolean(auth.accessToken && auth.refreshToken) || isTokenExpired(auth.expiresAt)) return { status: "logged_out" };
+	return {
+		status: "logged_in",
+		expiresAt: auth.expiresAt,
+		accessToken: auth.accessToken,
+		refreshToken: auth.refreshToken,
+		tokenType: auth.tokenType
+	};
+}
+function clearAuth() {
+	writeAuth(defaultAuthState());
+}
 
 //#endregion
 //#region src/core/auth/refresh.ts
 const EXPIRY_BUFFER_MS = 60 * 1e3;
-const refreshAccessToken = async ({ fetchImpl }) => {
+async function refreshAccessToken(options) {
+	const { fetchImpl } = options;
 	const auth = readAuth();
 	if (!auth.refreshToken) return null;
 	const res = await (fetchImpl ?? fetch)(buildApiUrl("v1/dashboard/auth/token"), {
@@ -305,32 +344,44 @@ const refreshAccessToken = async ({ fetchImpl }) => {
 		tokenType: "Bearer"
 	});
 	return token;
-};
+}
 
 //#endregion
 //#region src/core/http/errors.ts
-const createApiError = (payload, fallbackMessage, status) => {
+function createApiError(payload, fallbackMessage, status) {
 	const payloadObject = payload && typeof payload === "object" ? payload : void 0;
-	const message = payloadObject && typeof payloadObject.message === "string" ? payloadObject.message : fallbackMessage;
+	const message = 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;
+	const code = payloadObject?.code;
+	if (typeof code === "string") err.code = code;
+	const details = payloadObject?.details;
+	if (details != null) err.details = details;
 	if (typeof status === "number") err.status = status;
 	return err;
-};
+}
 
 //#endregion
 //#region src/core/http/retry.ts
-const defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-const isRetryableError = (error) => {
+function defaultSleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isServerError(status) {
+	return status >= 500 || status === 408 || status === 429;
+}
+function getErrorStatus(error) {
+	if (typeof error !== "object" || error === null) return;
+	if (!("status" in error)) return;
+	const status = error.status;
+	if (typeof status !== "number") return;
+	return status;
+}
+function isRetryableError(error, _attempt) {
 	if (error instanceof TypeError) return true;
-	if (typeof error === "object" && error !== null && "status" in error && typeof error.status === "number") {
-		const status = error.status;
-		return status >= 500 || status === 408 || status === 429;
-	}
-	return false;
-};
-const withRetry = async (fn, options = {}) => {
+	const status = getErrorStatus(error);
+	if (status === void 0) return false;
+	return isServerError(status);
+}
+async function withRetry(fn, options = {}) {
 	const { maxRetries = 3, initialDelayMs = 1e3, maxDelayMs = 1e4, shouldRetry = isRetryableError, onRetry, sleep = defaultSleep } = options;
 	let lastError;
 	let delay = initialDelayMs;
@@ -344,40 +395,38 @@ const withRetry = async (fn, options = {}) => {
 		delay = Math.min(delay * 2, maxDelayMs);
 	}
 	throw lastError;
-};
-const isServerError = (status) => status >= 500 || status === 408 || status === 429;
+}
 
 //#endregion
 //#region src/core/http/request.ts
-const getAuthCookieName = () => process.env.GETROUTER_AUTH_COOKIE || process.env.KRATOS_AUTH_COOKIE || "access_token";
-const buildHeaders = (accessToken) => {
+function getAuthCookieName() {
+	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";
+}
+function buildHeaders(accessToken) {
 	const headers = { "Content-Type": "application/json" };
 	if (accessToken) {
 		headers.Authorization = `Bearer ${accessToken}`;
 		headers.Cookie = `${getAuthCookieName()}=${accessToken}`;
 	}
 	return headers;
-};
-const doFetch = async (url, method, headers, body, fetchImpl) => {
+}
+async function doFetch(url, method, headers, body, fetchImpl) {
 	return (fetchImpl ?? fetch)(url, {
 		method,
 		headers,
 		body: body == null ? void 0 : JSON.stringify(body)
 	});
-};
-const shouldRetryResponse = (error) => {
-	if (typeof error === "object" && error !== null && "status" in error && typeof error.status === "number") return isServerError(error.status);
-	return error instanceof TypeError;
-};
-const requestJson = async ({ path: path$1, method, body, fetchImpl, maxRetries = 3, includeAuth = true, _retrySleep }) => {
+}
+async function requestJson({ path: path$1, method, body, fetchImpl, maxRetries = 3, includeAuth = true, _retrySleep }) {
 	return withRetry(async () => {
-		const auth = includeAuth ? readAuth() : {
-			accessToken: void 0,
-			refreshToken: void 0
-		};
 		const url = buildApiUrl(path$1);
-		let res = await doFetch(url, method, includeAuth ? buildHeaders(auth.accessToken) : buildHeaders(), body, fetchImpl);
-		if (includeAuth && res.status === 401 && auth.refreshToken) {
+		const auth = includeAuth ? readAuth() : void 0;
+		let res = await doFetch(url, method, buildHeaders(auth?.accessToken), body, fetchImpl);
+		if (includeAuth && res.status === 401 && auth?.refreshToken) {
 			const refreshed = await refreshAccessToken({ fetchImpl });
 			if (refreshed?.accessToken) res = await doFetch(url, method, buildHeaders(refreshed.accessToken), body, fetchImpl);
 		}
@@ -385,21 +434,21 @@ const requestJson = async ({ path: path$1, method, body, fetchImpl, maxRetries =
 		return await res.json();
 	}, {
 		maxRetries,
-		shouldRetry: shouldRetryResponse,
+		shouldRetry: isRetryableError,
 		sleep: _retrySleep
 	});
-};
+}
 
 //#endregion
 //#region src/core/api/client.ts
-const createApiClients = ({ fetchImpl, clients, includeAuth = true }) => {
-	const factories = clients ?? {
-		createConsumerServiceClient,
-		createAuthServiceClient,
-		createSubscriptionServiceClient,
-		createUsageServiceClient,
-		createModelServiceClient
-	};
+const defaultFactories = {
+	createConsumerServiceClient,
+	createAuthServiceClient,
+	createSubscriptionServiceClient,
+	createUsageServiceClient,
+	createModelServiceClient
+};
+function createApiClients({ fetchImpl, clients: factories = defaultFactories, includeAuth = true } = {}) {
 	const handler = async ({ path: path$1, method, body }) => {
 		return requestJson({
 			path: path$1,
@@ -416,30 +465,7 @@ const createApiClients = ({ fetchImpl, clients, includeAuth = true }) => {
 		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
@@ -450,6 +476,11 @@ const generateAuthCode = () => {
 	return out;
 };
 const buildLoginUrl = (authCode) => `https://getrouter.dev/auth/${authCode}`;
+const getErrorCode = (err) => {
+	if (typeof err !== "object" || err === null) return void 0;
+	if (!("code" in err)) return void 0;
+	return err.code;
+};
 const spawnBrowser = (command, args) => {
 	try {
 		const child = spawn(command, args, {
@@ -457,8 +488,10 @@ const spawnBrowser = (command, args) => {
 			detached: true
 		});
 		child.on("error", (err) => {
-			const code = typeof err === "object" && err !== null && "code" in err ? err.code : void 0;
-			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.`);
 		});
 		child.unref();
@@ -468,31 +501,42 @@ const spawnBrowser = (command, args) => {
 };
 const openLoginUrl = async (url) => {
 	try {
-		if (process.platform === "darwin") {
-			spawnBrowser("open", [url]);
-			return;
-		}
-		if (process.platform === "win32") {
-			spawnBrowser("cmd", [
-				"/c",
-				"start",
-				"",
-				url
-			]);
-			return;
-		}
-		spawnBrowser("xdg-open", [url]);
+		const entry = {
+			darwin: {
+				command: "open",
+				args: [url]
+			},
+			win32: {
+				command: "cmd",
+				args: [
+					"/c",
+					"start",
+					"",
+					url
+				]
+			}
+		}[process.platform] ?? {
+			command: "xdg-open",
+			args: [url]
+		};
+		spawnBrowser(entry.command, entry.args);
 	} 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;
+	const getErrorStatus$1 = (err) => {
+		if (typeof err !== "object" || err === null) return void 0;
+		if (!("status" in err)) return void 0;
+		const status = err.status;
+		return typeof status === "number" ? status : void 0;
+	};
 	while (true) {
 		try {
 			return await authorize({ code });
 		} catch (err) {
-			const status = typeof err === "object" && err !== null && "status" in err ? err.status : void 0;
+			const status = getErrorStatus$1(err);
 			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;
@@ -507,7 +551,7 @@ const pollAuthorize = async ({ authorize, code, timeoutMs = 300 * 1e3, initialDe
 
 //#endregion
 //#region src/cmd/auth.ts
-const registerAuthCommands = (program) => {
+function registerAuthCommands(program) {
 	program.command("login").description("Login with device flow").action(async () => {
 		const { authService } = createApiClients({ includeAuth: false });
 		const authCode = generateAuthCode();
@@ -532,7 +576,7 @@ const registerAuthCommands = (program) => {
 		clearAuth();
 		console.log("Cleared local auth data.");
 	});
-};
+}
 
 //#endregion
 //#region src/core/api/pagination.ts
@@ -544,7 +588,7 @@ const registerAuthCommands = (program) => {
 * @param getNextToken - Function that extracts the next page token from the response
 * @returns Array of all items across all pages
 */
-const fetchAllPages = async (fetchPage, getItems, getNextToken) => {
+async function fetchAllPages(fetchPage, getItems, getNextToken) {
 	const allItems = [];
 	let pageToken;
 	do {
@@ -554,7 +598,7 @@ const fetchAllPages = async (fetchPage, getItems, getNextToken) => {
 		pageToken = getNextToken(response);
 	} while (pageToken);
 	return allItems;
-};
+}
 
 //#endregion
 //#region src/core/interactive/fuzzy.ts
@@ -657,21 +701,28 @@ const promptKeyEnabled = async (initial) => {
 		enabled: typeof response.enabled === "boolean" ? response.enabled : initial
 	};
 };
-const selectConsumer = async (consumerService) => {
-	const consumers = await fetchAllPages((pageToken) => consumerService.ListConsumers({
-		pageSize: void 0,
-		pageToken
-	}), (res) => res?.consumers ?? [], (res) => res?.nextPageToken || void 0);
+const fetchConsumers = async (consumerService) => fetchAllPages((pageToken) => consumerService.ListConsumers({
+	pageSize: void 0,
+	pageToken
+}), (res) => res?.consumers ?? [], (res) => res?.nextPageToken || void 0);
+const ensureConsumers = (consumers) => {
 	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);
+	return {
+		sorted,
+		nameCounts: buildNameCounts(sorted)
+	};
+};
+const selectConsumer = async (consumerService) => {
+	const prepared = ensureConsumers(await fetchConsumers(consumerService));
+	if (!prepared) return null;
 	return 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),
@@ -682,22 +733,14 @@ const selectConsumer = async (consumerService) => {
 	}) ?? null;
 };
 const selectConsumerList = async (consumerService, message) => {
-	const consumers = await fetchAllPages((pageToken) => consumerService.ListConsumers({
-		pageSize: void 0,
-		pageToken
-	}), (res) => res?.consumers ?? [], (res) => res?.nextPageToken || void 0);
-	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 prepared = ensureConsumers(await fetchConsumers(consumerService));
+	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
 		}))
 	});
@@ -716,24 +759,30 @@ const confirmDelete = async (consumer) => {
 
 //#endregion
 //#region src/core/setup/env.ts
-const quoteEnvValue = (shell, value) => {
+function quoteEnvValue(shell, value) {
 	if (shell === "ps1") return `'${value.replaceAll("'", "''")}'`;
 	return `'${value.replaceAll("'", "'\\''")}'`;
-};
-const renderLine = (shell, key, value) => {
+}
+function renderLine(shell, key, value) {
 	if (shell === "ps1") return `$env:${key}=${quoteEnvValue(shell, value)}`;
 	return `export ${key}=${quoteEnvValue(shell, value)}`;
-};
-const renderEnv = (shell, vars) => {
+}
+function renderEnv(shell, vars) {
+	const entries = [
+		["openaiBaseUrl", "OPENAI_BASE_URL"],
+		["openaiApiKey", "OPENAI_API_KEY"],
+		["anthropicBaseUrl", "ANTHROPIC_BASE_URL"],
+		["anthropicApiKey", "ANTHROPIC_API_KEY"]
+	];
 	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));
+	for (const [varKey, envKey] of entries) {
+		const value = vars[varKey];
+		if (value) lines.push(renderLine(shell, envKey, value));
+	}
 	lines.push("");
 	return lines.join("\n");
-};
-const renderHook = (shell) => {
+}
+function renderHook(shell) {
 	if (shell === "pwsh") return [
 		"function getrouter {",
 		"  $cmd = Get-Command getrouter -CommandType Application,ExternalScript -ErrorAction SilentlyContinue | Select-Object -First 1",
@@ -799,19 +848,21 @@ const renderHook = (shell) => {
 		"}",
 		""
 	].join("\n");
-};
-const getEnvFilePath = (shell, configDir) => path.join(configDir, shell === "ps1" ? "env.ps1" : "env.sh");
-const getHookFilePath = (shell, configDir) => {
+}
+function getEnvFilePath(shell, configDir) {
+	return path.join(configDir, shell === "ps1" ? "env.ps1" : "env.sh");
+}
+function 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) => {
+}
+function 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) => {
+}
+function 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");
@@ -820,9 +871,11 @@ const resolveShellRcPath = (shell, homeDir) => {
 		return path.join(homeDir, ".config/powershell/Microsoft.PowerShell_profile.ps1");
 	}
 	return null;
-};
-const resolveEnvShell = (shell) => shell === "pwsh" ? "ps1" : "sh";
-const detectShell = () => {
+}
+function resolveEnvShell(shell) {
+	return shell === "pwsh" ? "ps1" : "sh";
+}
+function detectShell() {
 	const shellPath = process.env.SHELL;
 	if (shellPath) {
 		const name = shellPath.split("/").pop()?.toLowerCase();
@@ -830,39 +883,41 @@ const detectShell = () => {
 	}
 	if (process.platform === "win32") return "pwsh";
 	return "bash";
-};
-const applyEnvVars = (vars) => {
+}
+function 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) => {
+}
+function formatSourceLine(shell, envPath) {
+	return shell === "ps1" ? `. ${envPath}` : `source ${envPath}`;
+}
+function 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" });
+		execSync(`${shell} -c "source '${envPath}'"`, { stdio: "ignore" });
 	} catch {}
-};
-const appendRcIfMissing = (rcPath, line) => {
+}
+function appendRcIfMissing(rcPath, line$1) {
 	let content = "";
 	if (fs.existsSync(rcPath)) {
 		content = fs.readFileSync(rcPath, "utf8");
-		if (content.includes(line)) return false;
+		if (content.includes(line$1)) return false;
 	}
 	const prefix = content && !content.endsWith("\n") ? "\n" : "";
 	fs.mkdirSync(path.dirname(rcPath), { recursive: true });
-	fs.writeFileSync(rcPath, `${content}${prefix}${line}\n`, "utf8");
+	fs.writeFileSync(rcPath, `${content}${prefix}${line$1}\n`, "utf8");
 	return true;
-};
+}
 
 //#endregion
 //#region src/cmd/env.ts
 const CLAUDE_BASE_URL = "https://api.getrouter.dev/claude";
-const registerEnvCommand = (program, config) => {
+function 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();
@@ -901,44 +956,46 @@ const registerEnvCommand = (program, config) => {
 			console.log(sourceLine);
 		}
 	});
-};
-const buildAnthropicEnv = (apiKey) => ({
-	anthropicBaseUrl: CLAUDE_BASE_URL,
-	anthropicApiKey: apiKey
-});
+}
+function buildAnthropicEnv(apiKey) {
+	return {
+		anthropicBaseUrl: CLAUDE_BASE_URL,
+		anthropicApiKey: apiKey
+	};
+}
 
 //#endregion
 //#region src/cmd/claude.ts
-const registerClaudeCommand = (program) => {
+function registerClaudeCommand(program) {
 	registerEnvCommand(program, {
 		name: "claude",
 		description: "Configure Claude environment",
 		vars: buildAnthropicEnv
 	});
-};
+}
 
 //#endregion
 //#region src/core/api/providerModels.ts
-const asTrimmedString = (value) => {
+function asTrimmedString(value) {
 	if (typeof value !== "string") return null;
 	const trimmed = value.trim();
 	return trimmed.length > 0 ? trimmed : null;
-};
-const buildProviderModelsPath = (tag) => {
+}
+function buildProviderModelsPath(tag) {
 	const query = new URLSearchParams();
 	if (tag) query.set("tag", tag);
 	const qs = query.toString();
 	return `v1/dashboard/providers/models${qs ? `?${qs}` : ""}`;
-};
-const listProviderModels = async ({ tag, fetchImpl }) => {
+}
+async function listProviderModels(options) {
 	const raw = (await requestJson({
-		path: buildProviderModelsPath(tag),
+		path: buildProviderModelsPath(options.tag),
 		method: "GET",
-		fetchImpl,
+		fetchImpl: options.fetchImpl,
 		maxRetries: 0
 	}))?.models;
 	return (Array.isArray(raw) ? raw : []).map(asTrimmedString).filter(Boolean);
-};
+}
 
 //#endregion
 //#region src/core/interactive/codex.ts
@@ -1038,20 +1095,68 @@ const PROVIDER_KEYS = [
 	"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 parseTomlRhsValue = (rhs) => {
+function splitLines(content) {
+	if (content.length === 0) return [];
+	return content.split(/\r?\n/);
+}
+function isLegacyTomlRootMarker(key) {
+	return LEGACY_TOML_ROOT_MARKERS.includes(key);
+}
+function rootValues(input) {
+	return {
+		model: `"${input.model}"`,
+		model_reasoning_effort: `"${input.reasoning}"`,
+		model_provider: `"${CODEX_PROVIDER}"`
+	};
+}
+function providerValues() {
+	return {
+		name: `"${CODEX_PROVIDER}"`,
+		base_url: `"${CODEX_BASE_URL}"`,
+		wire_api: `"responses"`,
+		requires_openai_auth: "true"
+	};
+}
+const HEADER_RE = /^\s*\[([^\]]+)\]\s*$/;
+const KEY_RE = /^\s*([A-Za-z0-9_.-]+)\s*=/;
+function matchHeader(line$1) {
+	return line$1.match(HEADER_RE);
+}
+function matchKey(line$1) {
+	return line$1.match(KEY_RE);
+}
+function readKeyFromLine(line$1) {
+	return matchKey(line$1)?.[1];
+}
+function readStringValue(data, key) {
+	const value = data[key];
+	return typeof value === "string" ? value : void 0;
+}
+function findSectionEnd(lines, startIndex) {
+	for (let i = startIndex; i < lines.length; i += 1) {
+		const line$1 = lines[i];
+		if (line$1 !== void 0 && matchHeader(line$1)) return i;
+	}
+	return lines.length;
+}
+function upsertKeyLines(lines, startIndex, endIndex, keys, valueMap) {
+	const found = /* @__PURE__ */ new Set();
+	for (let i = startIndex; i < endIndex; i += 1) {
+		const line$1 = lines[i];
+		if (line$1 === void 0) continue;
+		const keyMatch = matchKey(line$1);
+		if (!keyMatch) continue;
+		const key = keyMatch[1];
+		if (!keys.includes(key)) continue;
+		lines[i] = `${key} = ${valueMap[key]}`;
+		found.add(key);
+	}
+	return found;
+}
+function missingKeyLines(keys, found, valueMap) {
+	return keys.filter((key) => !found.has(key)).map((key) => `${key} = ${valueMap[key]}`);
+}
+function parseTomlRhsValue(rhs) {
 	const trimmed = rhs.trim();
 	if (!trimmed) return "";
 	const first = trimmed[0];
@@ -1061,150 +1166,119 @@ const parseTomlRhsValue = (rhs) => {
 	}
 	const hashIndex = trimmed.indexOf("#");
 	return (hashIndex === -1 ? trimmed : trimmed.slice(0, hashIndex)).trim();
-};
-const readRootValue = (lines, key) => {
-	for (const line of lines) {
-		if (matchHeader(line)) break;
-		if (matchKey(line)?.[1] === key) {
-			const parts = line.split("=");
-			parts.shift();
-			return parseTomlRhsValue(parts.join("="));
-		}
+}
+function readRootValue(lines, key) {
+	for (const line$1 of lines) {
+		if (matchHeader(line$1)) break;
+		if (readKeyFromLine(line$1) === key) return parseTomlRhsValue(line$1.slice(line$1.indexOf("=") + 1));
 	}
-};
-const readCodexTomlRootValues = (content) => {
-	const lines = content.length ? content.split(/\r?\n/) : [];
+}
+function readCodexTomlRootValues(content) {
+	const lines = splitLines(content);
 	return {
 		model: readRootValue(lines, "model"),
 		reasoning: readRootValue(lines, "model_reasoning_effort"),
 		provider: readRootValue(lines, "model_provider")
 	};
-};
-const normalizeTomlString = (value) => {
+}
+function normalizeTomlString(value) {
 	if (!value) return "";
 	const trimmed = value.trim();
 	if (trimmed.startsWith("\"") && trimmed.endsWith("\"") || trimmed.startsWith("'") && trimmed.endsWith("'")) return trimmed.slice(1, -1).trim().toLowerCase();
 	return trimmed.replace(/['"]/g, "").trim().toLowerCase();
-};
-const stripLegacyRootMarkers = (lines) => {
+}
+function stripLegacyRootMarkers(lines) {
 	const updated = [];
 	let inRoot = true;
-	for (const line of lines) {
-		if (matchHeader(line)) inRoot = false;
+	for (const line$1 of lines) {
+		if (matchHeader(line$1)) inRoot = false;
 		if (inRoot) {
-			const key = matchKey(line)?.[1];
-			if (key && LEGACY_TOML_ROOT_MARKERS.includes(key)) continue;
+			const key = readKeyFromLine(line$1);
+			if (key !== void 0 && isLegacyTomlRootMarker(key)) continue;
 		}
-		updated.push(line);
+		updated.push(line$1);
 	}
 	return updated;
-};
-const mergeCodexToml = (content, input) => {
-	const updated = [...stripLegacyRootMarkers(content.length ? content.split(/\r?\n/) : [])];
+}
+function mergeCodexToml(content, input) {
+	const updated = stripLegacyRootMarkers(splitLines(content));
 	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]}`);
+	const firstHeaderIndex = updated.findIndex((line$1) => matchHeader(line$1) !== null);
+	const rootEnd = firstHeaderIndex === -1 ? updated.length : firstHeaderIndex;
+	const missingRoot = missingKeyLines(ROOT_KEYS, upsertKeyLines(updated, 0, rootEnd, ROOT_KEYS, rootValueMap), rootValueMap);
 	if (missingRoot.length > 0) {
+		const insertIndex = rootEnd;
 		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);
+	const providerHeaderIndex = updated.findIndex((line$1) => line$1.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]}`);
+		updated.push(providerHeader, ...PROVIDER_KEYS.map((key) => `${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]}`);
+	const providerStart = providerHeaderIndex + 1;
+	const providerEnd = findSectionEnd(updated, providerStart);
+	const missingProvider = missingKeyLines(PROVIDER_KEYS, upsertKeyLines(updated, providerStart, providerEnd, PROVIDER_KEYS, providerValueMap), providerValueMap);
 	if (missingProvider.length > 0) updated.splice(providerEnd, 0, ...missingProvider);
 	return updated.join("\n");
-};
-const mergeAuthJson = (data, apiKey) => {
+}
+function mergeAuthJson(data, apiKey) {
 	const next = { ...data };
 	for (const key of LEGACY_AUTH_MARKERS) if (key in next) delete next[key];
 	next.OPENAI_API_KEY = apiKey;
 	return next;
-};
-const stripGetrouterProviderSection = (lines) => {
+}
+function stripGetrouterProviderSection(lines) {
 	const updated = [];
 	let skipSection = false;
-	for (const line of lines) {
-		const headerMatch = matchHeader(line);
+	for (const line$1 of lines) {
+		const headerMatch = matchHeader(line$1);
 		if (headerMatch) {
-			if ((headerMatch[1]?.trim() ?? "") === PROVIDER_SECTION) {
+			if (headerMatch[1]?.trim() === PROVIDER_SECTION) {
 				skipSection = true;
 				continue;
 			}
 			skipSection = false;
 		}
 		if (skipSection) continue;
-		updated.push(line);
+		updated.push(line$1);
 	}
 	return updated;
-};
-const stripLegacyMarkersFromRoot = (rootLines) => rootLines.filter((line) => {
-	const key = matchKey(line)?.[1];
-	return !(key && LEGACY_TOML_ROOT_MARKERS.includes(key));
-});
-const setOrDeleteRootKey = (rootLines, key, value) => {
-	const idx = rootLines.findIndex((line) => matchKey(line)?.[1] === key);
+}
+function stripLegacyMarkersFromRoot(rootLines) {
+	return rootLines.filter((line$1) => {
+		const key = readKeyFromLine(line$1);
+		return !(key !== void 0 && isLegacyTomlRootMarker(key));
+	});
+}
+function setOrDeleteRootKey(rootLines, key, value) {
+	const idx = rootLines.findIndex((line$1) => readKeyFromLine(line$1) === key);
 	if (value === void 0) {
 		if (idx !== -1) rootLines.splice(idx, 1);
 		return;
 	}
 	if (idx !== -1) rootLines[idx] = `${key} = ${value}`;
 	else rootLines.push(`${key} = ${value}`);
-};
-const deleteRootKey = (rootLines, key) => {
+}
+function deleteRootKey(rootLines, key) {
 	setOrDeleteRootKey(rootLines, key, void 0);
-};
-const hasLegacyRootMarkers = (lines) => lines.some((line) => {
-	const key = matchKey(line)?.[1];
-	return !!(key && LEGACY_TOML_ROOT_MARKERS.includes(key));
-});
-const removeCodexConfig = (content, options) => {
+}
+function hasLegacyRootMarkers(lines) {
+	return lines.some((line$1) => {
+		const key = readKeyFromLine(line$1);
+		return key !== void 0 && isLegacyTomlRootMarker(key);
+	});
+}
+function removeCodexConfig(content, options) {
 	const { restoreRoot, allowRootRemoval = true } = options ?? {};
-	const lines = content.length ? content.split(/\r?\n/) : [];
+	const lines = splitLines(content);
 	const providerIsGetrouter = normalizeTomlString(readRootValue(lines, "model_provider")) === CODEX_PROVIDER;
 	const canRemoveRoot = allowRootRemoval || hasLegacyRootMarkers(lines);
 	const stripped = stripGetrouterProviderSection(lines);
-	const firstHeaderIndex = stripped.findIndex((line) => matchHeader(line));
+	const firstHeaderIndex = stripped.findIndex((line$1) => matchHeader(line$1));
 	const rootEnd = firstHeaderIndex === -1 ? stripped.length : firstHeaderIndex;
 	const rootLines = stripLegacyMarkersFromRoot(stripped.slice(0, rootEnd));
 	const restLines = stripped.slice(rootEnd);
@@ -1225,21 +1299,21 @@ const removeCodexConfig = (content, options) => {
 		content: nextContent,
 		changed: nextContent !== content
 	};
-};
-const removeAuthJson = (data, options) => {
+}
+function removeAuthJson(data, options) {
 	const { installed, restore } = options ?? {};
 	const next = { ...data };
 	let changed = false;
-	const legacyInstalled = typeof next._getrouter_codex_installed_openai_api_key === "string" ? next._getrouter_codex_installed_openai_api_key : void 0;
-	const legacyRestore = typeof next._getrouter_codex_backup_openai_api_key === "string" ? next._getrouter_codex_backup_openai_api_key : void 0;
+	const legacyInstalled = readStringValue(next, "_getrouter_codex_installed_openai_api_key");
+	const legacyRestore = readStringValue(next, "_getrouter_codex_backup_openai_api_key");
 	const effectiveInstalled = installed ?? legacyInstalled;
 	const effectiveRestore = restore ?? legacyRestore;
 	for (const key of LEGACY_AUTH_MARKERS) if (key in next) {
 		delete next[key];
 		changed = true;
 	}
-	const current = typeof next.OPENAI_API_KEY === "string" ? next.OPENAI_API_KEY : void 0;
-	const restoreValue = typeof effectiveRestore === "string" && effectiveRestore.trim().length > 0 ? effectiveRestore : void 0;
+	const current = readStringValue(next, "OPENAI_API_KEY");
+	const restoreValue = effectiveRestore?.trim() ? effectiveRestore : void 0;
 	if (effectiveInstalled && current && current === effectiveInstalled) {
 		if (restoreValue) next.OPENAI_API_KEY = restoreValue;
 		else delete next.OPENAI_API_KEY;
@@ -1253,7 +1327,7 @@ const removeAuthJson = (data, options) => {
 		data: next,
 		changed
 	};
-};
+}
 
 //#endregion
 //#region src/cmd/codex.ts
@@ -1300,7 +1374,7 @@ const promptReasoning = async (model) => await fuzzySelect({
 	choices: REASONING_FUZZY_CHOICES
 });
 const formatReasoningLabel = (id) => REASONING_CHOICES.find((choice) => choice.id === id)?.label ?? id;
-const registerCodexCommand = (program) => {
+function registerCodexCommand(program) {
 	const codex = program.command("codex").description("Configure Codex");
 	codex.option("-m, --model <model>", "Set codex model (skips model selection)").action(async (options) => {
 		requireInteractive$1();
@@ -1340,13 +1414,15 @@ const registerCodexCommand = (program) => {
 		backup.updatedAt = now;
 		backup.config ??= {};
 		backup.config.previous ??= {};
-		if (backup.config.previous.model === void 0 && existingRoot.model && existingRoot.model !== installedRoot.model) backup.config.previous.model = existingRoot.model;
-		if (backup.config.previous.reasoning === void 0 && existingRoot.reasoning && existingRoot.reasoning !== installedRoot.reasoning) backup.config.previous.reasoning = existingRoot.reasoning;
-		if (backup.config.previous.provider === void 0 && existingRoot.provider && existingRoot.provider !== installedRoot.provider) backup.config.previous.provider = existingRoot.provider;
+		const previousConfig = backup.config.previous;
+		if (previousConfig.model === void 0 && existingRoot.model && existingRoot.model !== installedRoot.model) previousConfig.model = existingRoot.model;
+		if (previousConfig.reasoning === void 0 && existingRoot.reasoning && existingRoot.reasoning !== installedRoot.reasoning) previousConfig.reasoning = existingRoot.reasoning;
+		if (previousConfig.provider === void 0 && existingRoot.provider && existingRoot.provider !== installedRoot.provider) previousConfig.provider = existingRoot.provider;
 		backup.config.installed = installedRoot;
 		backup.auth ??= {};
-		if (backup.auth.previousOpenaiKey === void 0 && existingOpenaiKey && existingOpenaiKey !== apiKey) backup.auth.previousOpenaiKey = existingOpenaiKey;
-		backup.auth.installedOpenaiKey = apiKey;
+		const authBackup = backup.auth;
+		if (authBackup.previousOpenaiKey === void 0 && existingOpenaiKey && existingOpenaiKey !== apiKey) authBackup.previousOpenaiKey = existingOpenaiKey;
+		authBackup.installedOpenaiKey = apiKey;
 		writeCodexBackup(backup);
 		const mergedConfig = mergeCodexToml(existingConfig, {
 			model,
@@ -1376,7 +1452,9 @@ const registerCodexCommand = (program) => {
 			allowRootRemoval: hasBackup
 		}) : null;
 		const authContent = authExists ? fs.readFileSync(authPath, "utf8").trim() : "";
-		const authData = authExists ? authContent ? JSON.parse(authContent) : {} : null;
+		let authData = null;
+		if (authExists) if (authContent) authData = JSON.parse(authContent);
+		else authData = {};
 		const authResult = authData ? removeAuthJson(authData, {
 			installed: installedOpenaiKey,
 			restore: restoreOpenaiKey
@@ -1394,7 +1472,7 @@ const registerCodexCommand = (program) => {
 		const backupPath = resolveCodexBackupPath();
 		if (fs.existsSync(backupPath)) fs.unlinkSync(backupPath);
 	});
-};
+}
 
 //#endregion
 //#region src/core/config/redact.ts
@@ -1403,28 +1481,28 @@ const SECRET_KEYS = new Set([
 	"refreshToken",
 	"apiKey"
 ]);
-const mask = (value) => {
+function mask(value) {
 	if (!value) return "";
 	if (value.length <= 8) return "****";
 	return `${value.slice(0, 4)}...${value.slice(-4)}`;
-};
-const redactSecrets = (obj) => {
+}
+function 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) => {
+function 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 = {}) => {
+}
+function 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) => {
@@ -1436,7 +1514,7 @@ const renderTable = (headers, rows, options = {}) => {
 		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
@@ -1469,8 +1547,22 @@ const requireInteractive = (message) => {
 };
 const requireInteractiveForSelection = () => requireInteractive("Interactive mode required when key id is omitted.");
 const requireInteractiveForAction = (action) => requireInteractive(`Interactive mode required for keys ${action}.`);
+const promptKeyDetails = async (initialName, initialEnabled) => {
+	const nameResult = await promptKeyName(initialName);
+	if (nameResult.cancelled) return { cancelled: true };
+	const enabledResult = await promptKeyEnabled(initialEnabled);
+	if (enabledResult.cancelled) return { cancelled: true };
+	return {
+		cancelled: false,
+		name: nameResult.name,
+		enabled: enabledResult.enabled
+	};
+};
 const updateConsumer = async (consumerService, consumer, name, enabled) => {
-	const updateMask = [name !== void 0 && name !== consumer.name ? "name" : null, enabled !== void 0 && enabled !== consumer.enabled ? "enabled" : null].filter(Boolean).join(",");
+	const updateMaskParts = [];
+	if (name !== void 0 && name !== consumer.name) updateMaskParts.push("name");
+	if (enabled !== void 0 && enabled !== consumer.enabled) updateMaskParts.push("enabled");
+	const updateMask = updateMaskParts.join(",");
 	if (!updateMask) return consumer;
 	return consumerService.UpdateConsumer({
 		consumer: {
@@ -1487,46 +1579,37 @@ const listConsumers = async (consumerService, showApiKey) => {
 		pageToken
 	}), (res) => res?.consumers ?? [], (res) => res?.nextPageToken || void 0)), showApiKey);
 };
-const resolveConsumerForUpdate = async (consumerService, id) => {
+const resolveConsumer = async (consumerService, message, 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");
+	return await selectConsumerList(consumerService, message);
 };
 const createConsumer = async (consumerService) => {
 	requireInteractiveForAction("create");
-	const nameResult = await promptKeyName();
-	if (nameResult.cancelled) return;
-	const enabledResult = await promptKeyEnabled(true);
-	if (enabledResult.cancelled) return;
+	const details = await promptKeyDetails(void 0, true);
+	if (details.cancelled) return;
 	let consumer = await consumerService.CreateConsumer({});
-	consumer = await updateConsumer(consumerService, consumer, nameResult.name, enabledResult.enabled);
+	consumer = await updateConsumer(consumerService, consumer, details.name, details.enabled);
 	outputConsumerTable(consumer, true);
 	console.log("Please store this API key securely.");
 };
 const updateConsumerById = async (consumerService, id) => {
 	requireInteractiveForAction("update");
-	const selected = await resolveConsumerForUpdate(consumerService, id);
+	const selected = await resolveConsumer(consumerService, "Select key to update", id);
 	if (!selected?.id) return;
-	const nameResult = await promptKeyName(selected.name);
-	if (nameResult.cancelled) return;
-	const enabledResult = await promptKeyEnabled(selected.enabled ?? true);
-	if (enabledResult.cancelled) return;
-	outputConsumerTable(await updateConsumer(consumerService, selected, nameResult.name, enabledResult.enabled), false);
+	const details = await promptKeyDetails(selected.name, selected.enabled ?? true);
+	if (details.cancelled) return;
+	outputConsumerTable(await updateConsumer(consumerService, selected, details.name, details.enabled), false);
 };
 const deleteConsumerById = async (consumerService, id) => {
 	requireInteractiveForAction("delete");
-	const selected = await resolveConsumerForDelete(consumerService, id);
+	const selected = await resolveConsumer(consumerService, "Select key to delete", id);
 	if (!selected?.id) return;
 	if (!await confirmDelete(selected)) return;
 	await consumerService.DeleteConsumer({ id: selected.id });
 	outputConsumerTable(selected, false);
 };
-const registerKeysCommands = (program) => {
+function registerKeysCommands(program) {
 	const keys = program.command("keys").description("Manage API keys");
 	keys.option("--show", "Show full API keys");
 	keys.allowExcessArguments(false);
@@ -1551,7 +1634,7 @@ const registerKeysCommands = (program) => {
 		const { consumerService } = createApiClients({});
 		await deleteConsumerById(consumerService, id);
 	});
-};
+}
 
 //#endregion
 //#region src/cmd/models.ts
@@ -1562,18 +1645,20 @@ const modelHeaders = [
 	"ENABLED",
 	"UPDATED_AT"
 ];
-const modelRow = (model) => [
-	String(model.id ?? ""),
-	String(model.name ?? ""),
-	String(model.author ?? ""),
-	String(model.enabled ?? ""),
-	String(model.updatedAt ?? "")
-];
-const outputModels = (models) => {
+function formatModelRow(model) {
+	return [
+		String(model.id ?? ""),
+		String(model.name ?? ""),
+		String(model.author ?? ""),
+		String(model.enabled ?? ""),
+		String(model.updatedAt ?? "")
+	];
+}
+function outputModels(models) {
 	console.log("🧠 Models");
-	console.log(renderTable(modelHeaders, models.map(modelRow)));
-};
-const listModels = async () => {
+	console.log(renderTable(modelHeaders, models.map(formatModelRow)));
+}
+async function listModels() {
 	const { modelService } = createApiClients({});
 	const models = (await modelService.ListModels({
 		pageSize: void 0,
@@ -1585,66 +1670,75 @@ const listModels = async () => {
 		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();
-	});
-};
+}
+function registerModelsCommands(program) {
+	program.command("models").description("List models").action(listModels).command("list").description("List models").action(listModels);
+}
 
 //#endregion
 //#region src/cmd/status.ts
 const LABEL_WIDTH = 10;
-const formatLine = (label, value) => {
+function line(label, value) {
+	return [label, value];
+}
+function 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;
+}
+function renderSection(title, items) {
+	const lines = [];
+	for (const item of items) {
+		if (!item) continue;
+		const rendered = formatLine(item[0], item[1]);
+		if (rendered) lines.push(rendered);
+	}
+	return [title, ...lines].join("\n");
+}
+function formatAuthStatus(status) {
+	if (status === "logged_in") return "✅ Logged in";
+	return "❌ Logged out";
+}
+function formatToken(token) {
+	if (!token) return;
 	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;
+}
+function formatWindow(startAt, endAt) {
+	if (!startAt && !endAt) return;
 	if (startAt && endAt) return `${startAt} → ${endAt}`;
 	if (startAt) return `${startAt} →`;
 	return `→ ${endAt}`;
-};
-const formatLimits = (requestPerMinute, tokenPerMinute) => {
+}
+function 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;
+	if (parts.length === 0) return;
 	return parts.join(" · ");
-};
-const renderAuthSection = () => {
+}
+function 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 isLoggedIn = status.status === "logged_in";
+	return renderSection("🔐 Auth", [
+		line("Status", formatAuthStatus(status.status)),
+		isLoggedIn && line("Expires", status.expiresAt),
+		isLoggedIn && line("TokenType", status.tokenType),
+		isLoggedIn && line("Access", formatToken(status.accessToken)),
+		isLoggedIn && line("Refresh", formatToken(status.refreshToken))
+	]);
+}
+function renderSubscriptionSection(subscription) {
+	if (!subscription) return renderSection("📦 Subscription", [line("Status", "No active subscription")]);
 	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) => {
+	return renderSection("📦 Subscription", [
+		line("Plan", subscription.plan?.name),
+		line("Status", subscription.status),
+		line("Window", formatWindow(subscription.startAt, subscription.endAt)),
+		line("Limits", limits)
+	]);
+}
+function registerStatusCommand(program) {
 	program.command("status").description("Show login and subscription status").action(async () => {
 		const { subscriptionService } = createApiClients({});
 		const subscription = await subscriptionService.CurrentSubscription({});
@@ -1652,62 +1746,49 @@ const registerStatusCommand = (program) => {
 		console.log("");
 		console.log(renderSubscriptionSection(subscription));
 	});
-};
+}
 
 //#endregion
 //#region src/core/output/usages.ts
 const TOTAL_BLOCK = "█";
 const DEFAULT_WIDTH = 24;
-const formatTokens = (value) => {
+function 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}`;
+	let threshold = 1e3;
+	let suffix = "K";
+	if (abs >= 1e9) {
+		threshold = 1e9;
+		suffix = "B";
+	} else if (abs >= 1e6) {
+		threshold = 1e6;
+		suffix = "M";
 	}
-	return Math.round(value).toString();
-};
-const renderUsageChart = (rows, width = DEFAULT_WIDTH) => {
+	const scaled = value / threshold;
+	const decimals = Math.abs(scaled) < 10 ? 1 : 0;
+	return `${scaled.toFixed(decimals).replace(/\.0$/, "")}${suffix}`;
+}
+function 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 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 maxTotal = Math.max(0, ...data.map((d) => d.total));
 	return [
 		header,
 		"",
-		...normalized.map((row) => {
-			if (maxTotal === 0 || row.total === 0) return `${row.day} ${"".padEnd(width, " ")} 0`;
-			const scaled = Math.max(1, Math.round(row.total / maxTotal * width));
-			const bar = TOTAL_BLOCK.repeat(scaled);
-			const totalLabel = formatTokens(row.total);
-			return `${row.day} ${bar.padEnd(width, " ")} ${totalLabel}`;
+		...data.map(({ day, total }) => {
+			if (maxTotal === 0 || total === 0) return `${day} ${" ".repeat(width)} 0`;
+			const scaled = Math.max(1, Math.round(total / maxTotal * width));
+			return `${day} ${TOTAL_BLOCK.repeat(scaled).padEnd(width, " ")} ${formatTokens(total)}`;
 		})
 	].join("\n");
-};
+}
 
 //#endregion
 //#region src/core/usages/aggregate.ts
@@ -1722,7 +1803,7 @@ const toNumber = (value) => {
 	}
 	return 0;
 };
-const aggregateUsages = (usages, maxDays = 7) => {
+function aggregateUsages(usages, maxDays = 7) {
 	const totals = /* @__PURE__ */ new Map();
 	for (const usage of usages) {
 		if (!usage.createdAt) continue;
@@ -1747,27 +1828,27 @@ const aggregateUsages = (usages, maxDays = 7) => {
 		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 () => {
+async function collectUsages() {
 	const { usageService } = createApiClients({});
 	return aggregateUsages((await usageService.ListUsage({
 		pageSize: 7,
 		pageToken: void 0
 	}))?.usages ?? [], 7);
-};
-const registerUsagesCommand = (program) => {
+}
+function 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) => {
+function registerCommands(program) {
 	registerAuthCommands(program);
 	registerCodexCommand(program);
 	registerClaudeCommand(program);
@@ -1775,16 +1856,16 @@ const registerCommands = (program) => {
 	registerModelsCommands(program);
 	registerStatusCommand(program);
 	registerUsagesCommand(program);
-};
+}
 
 //#endregion
 //#region src/cli.ts
-const createProgram = () => {
+function createProgram() {
 	const program = new Command();
 	program.name("getrouter").description("CLI for getrouter.dev").version(version);
 	registerCommands(program);
 	return program;
-};
+}
 
 //#endregion
 //#region src/bin.ts