github-router 0.3.7 → 0.3.9

package/dist/main.js

@@ -5,16 +5,15 @@ import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
 import { randomBytes, randomUUID } from "node:crypto";
-import clipboard from "clipboardy";
+import process$1 from "node:process";
 import { serve } from "srvx";
-import invariant from "tiny-invariant";
 import { getProxyForUrl } from "proxy-from-env";
 import { Agent, ProxyAgent, setGlobalDispatcher } from "undici";
-import process$1 from "node:process";
 import { Hono } from "hono";
 import { cors } from "hono/cors";
 import { streamSSE } from "hono/streaming";
 import { events } from "fetch-event-stream";
+import clipboard from "clipboardy";
 
 //#region src/lib/paths.ts
 const APP_DIR = path.join(os.homedir(), ".local", "share", "github-router");
@@ -103,7 +102,7 @@ var HTTPError = class extends Error {
 async function forwardError(c, error) {
 	consola.error("Error occurred:", error);
 	if (error instanceof HTTPError) {
-		const errorText = await error.response.text();
+		const errorText = await error.response.text().catch(() => "");
 		let errorJson;
 		try {
 			errorJson = JSON.parse(errorText);
@@ -414,78 +413,86 @@ const checkUsage = defineCommand({
 });
 
 //#endregion
-//#region src/debug.ts
-async function getPackageVersion() {
-	try {
-		const packageJsonPath = new URL("../package.json", import.meta.url).pathname;
-		return JSON.parse(await fs.readFile(packageJsonPath)).version;
-	} catch {
-		return "unknown";
-	}
+//#region src/lib/port.ts
+const DEFAULT_PORT = 8787;
+const DEFAULT_CODEX_MODEL = "gpt5.3-codex";
+const PORT_RANGE_MIN = 11e3;
+const PORT_RANGE_MAX = 65535;
+/** Generate a random port number in the range [11000, 65535]. */
+function generateRandomPort() {
+	return Math.floor(Math.random() * (PORT_RANGE_MAX - PORT_RANGE_MIN + 1)) + PORT_RANGE_MIN;
 }
-function getRuntimeInfo() {
-	const isBun = typeof Bun !== "undefined";
+
+//#endregion
+//#region src/lib/launch.ts
+function buildLaunchCommand(target) {
 	return {
-		name: isBun ? "bun" : "node",
-		version: isBun ? Bun.version : process.version.slice(1),
-		platform: os.platform(),
-		arch: os.arch()
+		cmd: target.kind === "claude-code" ? [
+			"claude",
+			"--dangerously-skip-permissions",
+			...target.extraArgs
+		] : [
+			"codex",
+			"-m",
+			target.model ?? DEFAULT_CODEX_MODEL,
+			...target.extraArgs
+		],
+		env: {
+			...process$1.env,
+			...target.envVars
+		}
 	};
 }
-async function checkTokenExists() {
+function launchChild(target, server$1) {
+	const { cmd, env } = buildLaunchCommand(target);
+	const executable = cmd[0];
+	if (!Bun.which(executable)) {
+		consola.error(`"${executable}" not found on PATH. Install it first, then try again.`);
+		process$1.exit(1);
+	}
+	let child;
 	try {
-		if (!(await fs.stat(PATHS.GITHUB_TOKEN_PATH)).isFile()) return false;
-		return (await fs.readFile(PATHS.GITHUB_TOKEN_PATH, "utf8")).trim().length > 0;
-	} catch {
-		return false;
+		child = Bun.spawn({
+			cmd,
+			env,
+			stdin: "inherit",
+			stdout: "inherit",
+			stderr: "inherit"
+		});
+	} catch (error) {
+		consola.error(`Failed to launch ${executable}:`, error instanceof Error ? error.message : String(error));
+		server$1.close(true).catch(() => {});
+		process$1.exit(1);
+	}
+	let cleaned = false;
+	let exiting = false;
+	async function cleanup() {
+		if (cleaned) return;
+		cleaned = true;
+		try {
+			child.kill();
+		} catch {}
+		const timeout = setTimeout(() => process$1.exit(1), 5e3);
+		try {
+			await server$1.close(true);
+		} catch {}
+		clearTimeout(timeout);
 	}
-}
-async function getDebugInfo() {
-	const [version, tokenExists] = await Promise.all([getPackageVersion(), checkTokenExists()]);
-	return {
-		version,
-		runtime: getRuntimeInfo(),
-		paths: {
-			APP_DIR: PATHS.APP_DIR,
-			GITHUB_TOKEN_PATH: PATHS.GITHUB_TOKEN_PATH
-		},
-		tokenExists
+	function exit(code) {
+		if (exiting) return;
+		exiting = true;
+		process$1.exit(code);
+	}
+	const onSignal = () => {
+		cleanup().then(() => exit(130)).catch(() => exit(1));
 	};
+	process$1.on("SIGINT", onSignal);
+	process$1.on("SIGTERM", onSignal);
+	child.exited.then(async (exitCode) => {
+		await cleanup();
+		exit(exitCode ?? 0);
+	}).catch(() => exit(1));
 }
-function printDebugInfoPlain(info) {
-	consola.info(`github-router debug
-
-Version: ${info.version}
-Runtime: ${info.runtime.name} ${info.runtime.version} (${info.runtime.platform} ${info.runtime.arch})
-
-Paths:
-- APP_DIR: ${info.paths.APP_DIR}
-- GITHUB_TOKEN_PATH: ${info.paths.GITHUB_TOKEN_PATH}
-
-Token exists: ${info.tokenExists ? "Yes" : "No"}`);
-}
-function printDebugInfoJson(info) {
-	console.log(JSON.stringify(info, null, 2));
-}
-async function runDebug(options) {
-	const debugInfo = await getDebugInfo();
-	if (options.json) printDebugInfoJson(debugInfo);
-	else printDebugInfoPlain(debugInfo);
-}
-const debug = defineCommand({
-	meta: {
-		name: "debug",
-		description: "Print debug information about the application"
-	},
-	args: { json: {
-		type: "boolean",
-		default: false,
-		description: "Output debug information as JSON"
-	} },
-	run({ args }) {
-		return runDebug({ json: args.json });
-	}
-});
 
 //#endregion
 //#region src/lib/proxy.ts
@@ -533,69 +540,6 @@ function initProxyFromEnv() {
 	}
 }
 
-//#endregion
-//#region src/lib/shell.ts
-function getShell() {
-	const { platform, env } = process$1;
-	if (platform === "win32") {
-		if (env.SHELL) {
-			if (env.SHELL.endsWith("zsh")) return "zsh";
-			if (env.SHELL.endsWith("fish")) return "fish";
-			if (env.SHELL.endsWith("bash")) return "bash";
-			return "sh";
-		}
-		if (env.POWERSHELL_DISTRIBUTION_CHANNEL) return "powershell";
-		if (env.PSModulePath) {
-			const lower = env.PSModulePath.toLowerCase();
-			if (lower.includes("documents\\powershell") || lower.includes("documents\\windowspowershell")) return "powershell";
-		}
-		return "cmd";
-	}
-	const shellPath = env.SHELL;
-	if (shellPath) {
-		if (shellPath.endsWith("zsh")) return "zsh";
-		if (shellPath.endsWith("fish")) return "fish";
-		if (shellPath.endsWith("bash")) return "bash";
-	}
-	return "sh";
-}
-function quotePosixValue(value) {
-	return `'${value.replace(/'/g, "'\\''")}'`;
-}
-function quotePowerShellValue(value) {
-	return `'${value.replace(/'/g, "''")}'`;
-}
-/**
-* Generates a copy-pasteable script to set multiple environment variables
-* and run a subsequent command.
-* @param {EnvVars} envVars - An object of environment variables to set.
-* @param {string} commandToRun - The command to run after setting the variables.
-* @returns {string} The formatted script string.
-*/
-function generateEnvScript(envVars, commandToRun = "") {
-	const shell = getShell();
-	const filteredEnvVars = Object.entries(envVars).filter(([, value]) => value !== void 0);
-	let commandBlock;
-	switch (shell) {
-		case "powershell":
-			commandBlock = filteredEnvVars.map(([key, value]) => `$env:${key} = ${quotePowerShellValue(value)}`).join("; ");
-			break;
-		case "cmd":
-			commandBlock = filteredEnvVars.map(([key, value]) => `set "${key}=${value}"`).join(" & ");
-			break;
-		case "fish":
-			commandBlock = filteredEnvVars.map(([key, value]) => `set -gx ${key} ${quotePosixValue(value)}`).join("; ");
-			break;
-		default: {
-			const assignments = filteredEnvVars.map(([key, value]) => `${key}=${quotePosixValue(value)}`).join(" ");
-			commandBlock = filteredEnvVars.length > 0 ? `export ${assignments}` : "";
-			break;
-		}
-	}
-	if (commandBlock && commandToRun) return `${commandBlock}${shell === "cmd" ? " & " : shell === "powershell" ? "; " : " && "}${commandToRun}`;
-	return commandBlock || commandToRun;
-}
-
 //#endregion
 //#region src/lib/approval.ts
 const awaitApproval = async () => {
@@ -671,7 +615,19 @@ function logRequest(info, model, startTime) {
 	const elapsed = Date.now() - startTime;
 	const duration = elapsed >= 1e3 ? `${(elapsed / 1e3).toFixed(1)}s` : `${elapsed}ms`;
 	parts.push(info.streaming ? `${duration} stream` : duration);
-	consola.info(parts.join("  "));
+	const line = parts.join("  ");
+	if (detectCapabilityMismatch(info, model)) consola.error(`[MISMATCH] ${line}`);
+	else consola.info(line);
+}
+/**
+* Detect when the API rejects a request for token/context reasons
+* that contradict what the /models endpoint reported.
+*/
+function detectCapabilityMismatch(info, model) {
+	if (!info.errorBody || !model) return false;
+	if (!info.status || info.status < 400) return false;
+	const err = info.errorBody.toLowerCase();
+	return err.includes("token") || err.includes("context") || err.includes("too long") || err.includes("max_tokens") || err.includes("prompt is too long");
 }
 
 //#endregion
@@ -872,13 +828,13 @@ const getTokenCount = async (payload, model) => {
 
 //#endregion
 //#region src/services/copilot/create-chat-completions.ts
-const createChatCompletions = async (payload) => {
+const createChatCompletions = async (payload, modelHeaders) => {
 	if (!state.copilotToken) throw new Error("Copilot token not found");
 	const enableVision = payload.messages.some((x) => typeof x.content !== "string" && x.content?.some((x$1) => x$1.type === "image_url"));
 	const isAgentCall = payload.messages.some((msg) => ["assistant", "tool"].includes(msg.role));
 	const headers = {
 		...copilotHeaders(state, enableVision),
-		"Openai-Organization": "github-copilot",
+		...modelHeaders,
 		"X-Initiator": isAgentCall ? "agent" : "user"
 	};
 	const response = await fetch(`${copilotBaseUrl(state)}/chat/completions`, {
@@ -997,7 +953,20 @@ async function handleCompletion$1(c) {
 		};
 		if (debugEnabled) consola.debug("Set max_tokens to:", JSON.stringify(payload.max_tokens));
 	}
-	const response = await createChatCompletions(payload);
+	const response = await createChatCompletions(payload, selectedModel?.requestHeaders).catch(async (error) => {
+		if (error instanceof HTTPError) {
+			const errorBody = await error.response.clone().text().catch(() => "");
+			logRequest({
+				method: "POST",
+				path: c.req.path,
+				model: originalModel,
+				resolvedModel,
+				status: error.response.status,
+				errorBody
+			}, selectedModel, startTime);
+		}
+		throw error;
+	});
 	const isStreaming = !isNonStreaming$1(response);
 	const outputTokens = !isStreaming ? response.usage?.completion_tokens : void 0;
 	logRequest({
@@ -1125,6 +1094,8 @@ function buildHeaders(extraHeaders) {
 	return {
 		...copilotHeaders(state),
 		accept: "application/json",
+		"openai-intent": "conversation-agent",
+		"x-interaction-type": "conversation-agent",
 		"X-Initiator": "agent",
 		"anthropic-version": "2023-06-01",
 		"X-Interaction-Id": randomUUID(),
@@ -1233,10 +1204,13 @@ async function handleCountTokens(c) {
 		const filtered = filterBetaHeader(anthropicBeta);
 		if (filtered) extraHeaders["anthropic-beta"] = filtered;
 	}
-	const response = await countTokens(finalBody, extraHeaders);
-	const responseBody = await response.json();
 	const modelId = resolvedModel ?? originalModel;
 	const selectedModel = state.models?.data.find((m) => m.id === modelId);
+	const response = await countTokens(finalBody, {
+		...selectedModel?.requestHeaders,
+		...extraHeaders
+	});
+	const responseBody = await response.json();
 	logRequest({
 		method: "POST",
 		path: c.req.path,
@@ -1387,7 +1361,27 @@ async function handleCompletion(c) {
 	const betaHeaders = extractBetaHeaders(c);
 	const { body: resolvedBody, originalModel, resolvedModel } = resolveModelInBody(await processWebSearch(rawBody));
 	const selectedModel = state.models?.data.find((m) => m.id === (resolvedModel ?? originalModel));
-	const response = await createMessages(resolvedBody, betaHeaders);
+	const effectiveBetas = applyDefaultBetas(betaHeaders, resolvedModel ?? originalModel);
+	let response;
+	try {
+		response = await createMessages(resolvedBody, {
+			...selectedModel?.requestHeaders,
+			...effectiveBetas
+		});
+	} catch (error) {
+		if (error instanceof HTTPError) {
+			const errorBody = await error.response.clone().text().catch(() => "");
+			logRequest({
+				method: "POST",
+				path: c.req.path,
+				model: originalModel,
+				resolvedModel,
+				status: error.response.status,
+				errorBody
+			}, selectedModel, startTime);
+		}
+		throw error;
+	}
 	if ((response.headers.get("content-type") ?? "").includes("text/event-stream")) {
 		logRequest({
 			method: "POST",
@@ -1449,6 +1443,19 @@ function resolveModelInBody(rawBody) {
 		resolvedModel: resolved
 	};
 }
+/**
+* Apply default anthropic-beta values for Claude models when the client
+* (e.g. curl) sends no beta headers. Claude CLI sends its own betas,
+* so this only fires as a safety net for bare clients.
+*/
+function applyDefaultBetas(betaHeaders, modelId) {
+	if (betaHeaders["anthropic-beta"]) return betaHeaders;
+	if (!modelId || !modelId.startsWith("claude-")) return betaHeaders;
+	return {
+		...betaHeaders,
+		"anthropic-beta": ["interleaved-thinking-2025-05-14", "token-counting-2024-11-01"].join(",")
+	};
+}
 
 //#endregion
 //#region src/routes/messages/route.ts
@@ -1495,12 +1502,13 @@ modelRoutes.get("/", async (c) => {
 
 //#endregion
 //#region src/services/copilot/create-responses.ts
-const createResponses = async (payload) => {
+const createResponses = async (payload, modelHeaders) => {
 	if (!state.copilotToken) throw new Error("Copilot token not found");
 	const enableVision = detectVision(payload.input);
 	const isAgentCall = detectAgentCall(payload.input);
 	const headers = {
 		...copilotHeaders(state, enableVision),
+		...modelHeaders,
 		"X-Initiator": isAgentCall ? "agent" : "user"
 	};
 	const filteredPayload = filterUnsupportedTools(payload);
@@ -1577,7 +1585,20 @@ async function handleResponses(c) {
 		payload.max_output_tokens = selectedModel?.capabilities.limits.max_output_tokens;
 		if (debugEnabled) consola.debug("Set max_output_tokens to:", JSON.stringify(payload.max_output_tokens));
 	}
-	const response = await createResponses(payload);
+	const response = await createResponses(payload, selectedModel?.requestHeaders).catch(async (error) => {
+		if (error instanceof HTTPError) {
+			const errorBody = await error.response.clone().text().catch(() => "");
+			logRequest({
+				method: "POST",
+				path: c.req.path,
+				model: originalModel,
+				resolvedModel,
+				status: error.response.status,
+				errorBody
+			}, selectedModel, startTime);
+		}
+		throw error;
+	});
 	const isStreaming = !isNonStreaming(response);
 	logRequest({
 		method: "POST",
@@ -1710,84 +1731,9 @@ server.route("/v1/search", searchRoutes);
 server.route("/v1/messages", messageRoutes);
 
 //#endregion
-//#region src/start.ts
-const allowedAccountTypes = new Set([
-	"individual",
-	"business",
-	"enterprise"
-]);
-function printAndCopyCommand(command, label) {
-	consola.box(`${label}\n\n${command}`);
-	try {
-		clipboard.writeSync(command);
-		consola.success(`Copied ${label} command to clipboard!`);
-	} catch {
-		consola.warn("Failed to copy to clipboard. Copy the command above manually.");
-	}
-}
-function filterModelsByEndpoint(models, endpoint) {
-	const filtered = models.filter((model) => {
-		const endpoints = model.supported_endpoints;
-		if (!endpoints || endpoints.length === 0) return true;
-		return endpoints.some((entry) => {
-			return entry.replace(/^\/?v1\//, "").replace(/^\//, "") === endpoint;
-		});
-	});
-	return filtered.length > 0 ? filtered : models;
-}
-async function generateClaudeCodeCommand(serverUrl) {
-	invariant(state.models, "Models should be loaded by now");
-	const claudeModels = state.models.data.filter((model) => model.id.toLowerCase().startsWith("claude"));
-	if (claudeModels.length === 0) {
-		consola.error("No Claude models available from Copilot API");
-		return;
-	}
-	const mainModel = claudeModels.find((m) => m.id.includes("opus")) ?? claudeModels.find((m) => m.id.includes("sonnet")) ?? claudeModels[0];
-	const smallModel = claudeModels.find((m) => m.id.includes("haiku")) ?? claudeModels.find((m) => m.id.includes("sonnet")) ?? claudeModels[0];
-	let selectedModel = mainModel.id;
-	let selectedSmallModel = smallModel.id;
-	if (claudeModels.length > 1) {
-		consola.info(`Using ${mainModel.id} as main model and ${smallModel.id} as small model`);
-		if (await consola.prompt("Override model selection?", {
-			type: "confirm",
-			initial: false
-		})) {
-			selectedModel = await consola.prompt("Select a main model for Claude Code", {
-				type: "select",
-				options: claudeModels.map((model) => model.id)
-			});
-			selectedSmallModel = await consola.prompt("Select a small/fast model for Claude Code", {
-				type: "select",
-				options: claudeModels.map((model) => model.id)
-			});
-		}
-	}
-	printAndCopyCommand(generateEnvScript({
-		ANTHROPIC_BASE_URL: serverUrl,
-		ANTHROPIC_AUTH_TOKEN: "dummy",
-		ANTHROPIC_MODEL: selectedModel,
-		ANTHROPIC_DEFAULT_SONNET_MODEL: selectedModel,
-		ANTHROPIC_SMALL_FAST_MODEL: selectedSmallModel,
-		ANTHROPIC_DEFAULT_HAIKU_MODEL: selectedSmallModel,
-		DISABLE_NON_ESSENTIAL_MODEL_CALLS: "1",
-		CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1"
-	}, "claude --dangerously-skip-permissions"), "Claude Code");
-}
-async function generateCodexCommand(serverUrl) {
-	invariant(state.models, "Models should be loaded by now");
-	const supportedModels = filterModelsByEndpoint(state.models.data, "responses");
-	const defaultCodexModel = supportedModels.find((model) => model.id === "gpt5.2-codex");
-	const selectedModel = defaultCodexModel ? defaultCodexModel.id : await consola.prompt("Select a model to use with Codex CLI", {
-		type: "select",
-		options: supportedModels.map((model) => model.id)
-	});
-	const quotedModel = JSON.stringify(selectedModel);
-	printAndCopyCommand(generateEnvScript({
-		OPENAI_BASE_URL: `${serverUrl}/v1`,
-		OPENAI_API_KEY: "dummy"
-	}, `codex -m ${quotedModel}`), "Codex CLI");
-}
-async function runServer(options) {
+//#region src/lib/server-setup.ts
+const MAX_PORT_RETRIES = 10;
+async function setupAndServe(options) {
 	if (options.proxyEnv) initProxyFromEnv();
 	if (options.verbose) {
 		consola.level = 5;
@@ -1808,115 +1754,443 @@ async function runServer(options) {
 	await setupCopilotToken();
 	await cacheModels();
 	consola.info(`Available models: \n${state.models?.data.map((model) => `- ${model.id}`).join("\n")}`);
-	const serverUrl = `http://localhost:${options.port}`;
-	if (options.claudeCode) await generateClaudeCodeCommand(serverUrl);
-	if (options.codex) await generateCodexCommand(serverUrl);
-	consola.box(`🌐 Usage Viewer: https://animeshkundu.github.io/github-router/dashboard.html?endpoint=${serverUrl}/usage`);
-	serve({
+	const serveOptions = {
 		fetch: server.fetch,
 		hostname: "127.0.0.1",
+		silent: options.silent
+	};
+	let srvxServer;
+	if (options.port !== void 0) srvxServer = serve({
+		...serveOptions,
 		port: options.port
 	});
+	else {
+		let lastError;
+		for (let attempt = 0; attempt < MAX_PORT_RETRIES; attempt++) {
+			const candidatePort = generateRandomPort();
+			try {
+				srvxServer = serve({
+					...serveOptions,
+					port: candidatePort
+				});
+				break;
+			} catch (error) {
+				lastError = error;
+				if (!(error instanceof Error && (error.message.includes("EADDRINUSE") || error.message.includes("address already in use") || "code" in error && error.code === "EADDRINUSE"))) throw error;
+				consola.debug(`Port ${candidatePort} in use, trying another...`);
+			}
+		}
+		if (srvxServer === void 0) throw new Error(`Failed to find an available port after ${MAX_PORT_RETRIES} attempts. Specify a port with --port or free some ports. Last error: ${lastError}`);
+	}
+	const url = srvxServer.url;
+	if (!url) throw new Error("Server started but URL is not available");
+	const serverUrl = url.replace(/\/$/, "");
+	return {
+		server: srvxServer,
+		serverUrl
+	};
 }
-const start = defineCommand({
+/** Shared CLI arg definitions for all server commands. */
+const sharedServerArgs = {
+	port: {
+		alias: "p",
+		type: "string",
+		description: "Port to listen on"
+	},
+	verbose: {
+		alias: "v",
+		type: "boolean",
+		default: false,
+		description: "Enable verbose logging"
+	},
+	"account-type": {
+		alias: "a",
+		type: "string",
+		default: "enterprise",
+		description: "Account type to use (individual, business, enterprise)"
+	},
+	manual: {
+		type: "boolean",
+		default: false,
+		description: "Enable manual request approval"
+	},
+	"rate-limit": {
+		alias: "r",
+		type: "string",
+		description: "Rate limit in seconds between requests"
+	},
+	wait: {
+		alias: "w",
+		type: "boolean",
+		default: false,
+		description: "Wait instead of error when rate limit is hit. Has no effect if rate limit is not set"
+	},
+	"github-token": {
+		alias: "g",
+		type: "string",
+		description: "Provide GitHub token directly (must be generated using the `auth` subcommand)"
+	},
+	"show-token": {
+		type: "boolean",
+		default: false,
+		description: "Show GitHub and Copilot tokens on fetch and refresh"
+	},
+	"proxy-env": {
+		type: "boolean",
+		default: false,
+		description: "Initialize proxy from environment variables"
+	}
+};
+const allowedAccountTypes = new Set([
+	"individual",
+	"business",
+	"enterprise"
+]);
+/** Parse shared server args into ServerSetupOptions fields. */
+function parseSharedArgs(args) {
+	const portRaw = args.port;
+	let port;
+	if (portRaw !== void 0) {
+		port = Number.parseInt(portRaw, 10);
+		if (Number.isNaN(port) || port <= 0 || port > 65535) throw new Error("Invalid port. Must be between 1 and 65535.");
+	}
+	const accountType = args["account-type"] ?? "enterprise";
+	if (!allowedAccountTypes.has(accountType)) throw new Error("Invalid account type. Must be individual, business, or enterprise.");
+	const rateLimitRaw = args["rate-limit"];
+	let rateLimit;
+	if (rateLimitRaw !== void 0) {
+		rateLimit = Number.parseInt(rateLimitRaw, 10);
+		if (Number.isNaN(rateLimit) || rateLimit <= 0) throw new Error("Invalid rate limit. Must be a positive integer.");
+	}
+	const rateLimitWait = args.wait && rateLimit !== void 0;
+	if (args.wait && rateLimit === void 0) consola.warn("Rate limit wait ignored because no rate limit was set.");
+	const githubToken = args["github-token"] ?? process.env.GH_TOKEN;
+	return {
+		port,
+		verbose: args.verbose,
+		accountType,
+		manual: args.manual,
+		rateLimit,
+		rateLimitWait,
+		githubToken,
+		showToken: args["show-token"],
+		proxyEnv: args["proxy-env"]
+	};
+}
+/** Build environment variables for Claude Code. */
+function getClaudeCodeEnvVars(serverUrl, model) {
+	const vars = {
+		ANTHROPIC_BASE_URL: serverUrl,
+		ANTHROPIC_AUTH_TOKEN: "dummy",
+		DISABLE_NON_ESSENTIAL_MODEL_CALLS: "1",
+		CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1"
+	};
+	if (model) vars.ANTHROPIC_MODEL = model;
+	return vars;
+}
+/** Build environment variables for Codex CLI. */
+function getCodexEnvVars(serverUrl) {
+	return {
+		OPENAI_BASE_URL: `${serverUrl}/v1`,
+		OPENAI_API_KEY: "dummy"
+	};
+}
+
+//#endregion
+//#region src/claude.ts
+const claude = defineCommand({
 	meta: {
-		name: "start",
-		description: "Start the github-router server"
+		name: "claude",
+		description: "Start the proxy server and launch Claude Code"
 	},
 	args: {
-		port: {
-			alias: "p",
-			type: "string",
-			default: "8787",
-			description: "Port to listen on"
-		},
-		verbose: {
-			alias: "v",
-			type: "boolean",
-			default: false,
-			description: "Enable verbose logging"
-		},
-		"account-type": {
-			alias: "a",
+		...sharedServerArgs,
+		model: {
+			alias: "m",
 			type: "string",
-			default: "enterprise",
-			description: "Account type to use (individual, business, enterprise)"
-		},
-		manual: {
-			type: "boolean",
-			default: false,
-			description: "Enable manual request approval"
-		},
-		"rate-limit": {
-			alias: "r",
-			type: "string",
-			description: "Rate limit in seconds between requests"
-		},
-		wait: {
-			alias: "w",
-			type: "boolean",
-			default: false,
-			description: "Wait instead of error when rate limit is hit. Has no effect if rate limit is not set"
-		},
-		"github-token": {
-			alias: "g",
+			description: "Override the default model for Claude Code"
+		}
+	},
+	async run({ args }) {
+		if (!process$1.stdout.isTTY) {
+			consola.error("The claude subcommand requires a TTY (interactive terminal).");
+			process$1.exit(1);
+		}
+		const parsed = parseSharedArgs(args);
+		let server$1;
+		let serverUrl;
+		try {
+			const result = await setupAndServe({
+				...parsed,
+				port: parsed.port,
+				silent: true
+			});
+			server$1 = result.server;
+			serverUrl = result.serverUrl;
+			await server$1.ready();
+		} catch (error) {
+			consola.error("Failed to start server:", error instanceof Error ? error.message : error);
+			process$1.exit(1);
+		}
+		consola.success(`Server ready on ${serverUrl}, launching Claude Code...`);
+		consola.level = 1;
+		launchChild({
+			kind: "claude-code",
+			envVars: getClaudeCodeEnvVars(serverUrl, args.model),
+			extraArgs: args._ ?? [],
+			model: args.model
+		}, server$1);
+	}
+});
+
+//#endregion
+//#region src/codex.ts
+const codex = defineCommand({
+	meta: {
+		name: "codex",
+		description: "Start the proxy server and launch Codex CLI"
+	},
+	args: {
+		...sharedServerArgs,
+		model: {
+			alias: "m",
 			type: "string",
-			description: "Provide GitHub token directly (must be generated using the `auth` subcommand)"
+			description: "Override the default model for Codex CLI"
+		}
+	},
+	async run({ args }) {
+		if (!process$1.stdout.isTTY) {
+			consola.error("The codex subcommand requires a TTY (interactive terminal).");
+			process$1.exit(1);
+		}
+		const parsed = parseSharedArgs(args);
+		let server$1;
+		let serverUrl;
+		try {
+			const result = await setupAndServe({
+				...parsed,
+				port: parsed.port,
+				silent: true
+			});
+			server$1 = result.server;
+			serverUrl = result.serverUrl;
+			await server$1.ready();
+		} catch (error) {
+			consola.error("Failed to start server:", error instanceof Error ? error.message : error);
+			process$1.exit(1);
+		}
+		const codexModel = args.model ?? DEFAULT_CODEX_MODEL;
+		consola.success(`Server ready on ${serverUrl}, launching Codex CLI (${codexModel})...`);
+		consola.level = 1;
+		launchChild({
+			kind: "codex",
+			envVars: getCodexEnvVars(serverUrl),
+			extraArgs: args._ ?? [],
+			model: args.model
+		}, server$1);
+	}
+});
+
+//#endregion
+//#region src/debug.ts
+async function getPackageVersion() {
+	try {
+		const packageJsonPath = new URL("../package.json", import.meta.url).pathname;
+		return JSON.parse(await fs.readFile(packageJsonPath)).version;
+	} catch {
+		return "unknown";
+	}
+}
+function getRuntimeInfo() {
+	const isBun = typeof Bun !== "undefined";
+	return {
+		name: isBun ? "bun" : "node",
+		version: isBun ? Bun.version : process.version.slice(1),
+		platform: os.platform(),
+		arch: os.arch()
+	};
+}
+async function checkTokenExists() {
+	try {
+		if (!(await fs.stat(PATHS.GITHUB_TOKEN_PATH)).isFile()) return false;
+		return (await fs.readFile(PATHS.GITHUB_TOKEN_PATH, "utf8")).trim().length > 0;
+	} catch {
+		return false;
+	}
+}
+async function getDebugInfo() {
+	const [version, tokenExists] = await Promise.all([getPackageVersion(), checkTokenExists()]);
+	return {
+		version,
+		runtime: getRuntimeInfo(),
+		paths: {
+			APP_DIR: PATHS.APP_DIR,
+			GITHUB_TOKEN_PATH: PATHS.GITHUB_TOKEN_PATH
 		},
-		"claude-code": {
-			alias: "c",
+		tokenExists
+	};
+}
+function printDebugInfoPlain(info) {
+	consola.info(`github-router debug
+
+Version: ${info.version}
+Runtime: ${info.runtime.name} ${info.runtime.version} (${info.runtime.platform} ${info.runtime.arch})
+
+Paths:
+- APP_DIR: ${info.paths.APP_DIR}
+- GITHUB_TOKEN_PATH: ${info.paths.GITHUB_TOKEN_PATH}
+
+Token exists: ${info.tokenExists ? "Yes" : "No"}`);
+}
+function printDebugInfoJson(info) {
+	console.log(JSON.stringify(info, null, 2));
+}
+async function runDebug(options) {
+	const debugInfo = await getDebugInfo();
+	if (options.json) printDebugInfoJson(debugInfo);
+	else printDebugInfoPlain(debugInfo);
+}
+const debug = defineCommand({
+	meta: {
+		name: "debug",
+		description: "Print debug information about the application"
+	},
+	args: { json: {
+		type: "boolean",
+		default: false,
+		description: "Output debug information as JSON"
+	} },
+	run({ args }) {
+		return runDebug({ json: args.json });
+	}
+});
+
+//#endregion
+//#region src/lib/shell.ts
+function getShell() {
+	const { platform, env } = process$1;
+	if (platform === "win32") {
+		if (env.SHELL) {
+			if (env.SHELL.endsWith("zsh")) return "zsh";
+			if (env.SHELL.endsWith("fish")) return "fish";
+			if (env.SHELL.endsWith("bash")) return "bash";
+			return "sh";
+		}
+		if (env.POWERSHELL_DISTRIBUTION_CHANNEL) return "powershell";
+		if (env.PSModulePath) {
+			const lower = env.PSModulePath.toLowerCase();
+			if (lower.includes("documents\\powershell") || lower.includes("documents\\windowspowershell")) return "powershell";
+		}
+		return "cmd";
+	}
+	const shellPath = env.SHELL;
+	if (shellPath) {
+		if (shellPath.endsWith("zsh")) return "zsh";
+		if (shellPath.endsWith("fish")) return "fish";
+		if (shellPath.endsWith("bash")) return "bash";
+	}
+	return "sh";
+}
+function quotePosixValue(value) {
+	return `'${value.replace(/'/g, "'\\''")}'`;
+}
+function quotePowerShellValue(value) {
+	return `'${value.replace(/'/g, "''")}'`;
+}
+/**
+* Generates a copy-pasteable script to set multiple environment variables
+* and run a subsequent command.
+* @param {EnvVars} envVars - An object of environment variables to set.
+* @param {string} commandToRun - The command to run after setting the variables.
+* @returns {string} The formatted script string.
+*/
+function generateEnvScript(envVars, commandToRun = "") {
+	const shell = getShell();
+	const filteredEnvVars = Object.entries(envVars).filter(([, value]) => value !== void 0);
+	let commandBlock;
+	switch (shell) {
+		case "powershell":
+			commandBlock = filteredEnvVars.map(([key, value]) => `$env:${key} = ${quotePowerShellValue(value)}`).join("; ");
+			break;
+		case "cmd":
+			commandBlock = filteredEnvVars.map(([key, value]) => `set "${key}=${value}"`).join(" & ");
+			break;
+		case "fish":
+			commandBlock = filteredEnvVars.map(([key, value]) => `set -gx ${key} ${quotePosixValue(value)}`).join("; ");
+			break;
+		default: {
+			const assignments = filteredEnvVars.map(([key, value]) => `${key}=${quotePosixValue(value)}`).join(" ");
+			commandBlock = filteredEnvVars.length > 0 ? `export ${assignments}` : "";
+			break;
+		}
+	}
+	if (commandBlock && commandToRun) return `${commandBlock}${shell === "cmd" ? " & " : shell === "powershell" ? "; " : " && "}${commandToRun}`;
+	return commandBlock || commandToRun;
+}
+
+//#endregion
+//#region src/start.ts
+function printAndCopyCommand(command, label) {
+	consola.box(`${label}\n\n${command}`);
+	try {
+		clipboard.writeSync(command);
+		consola.success(`Copied ${label} command to clipboard!`);
+	} catch {
+		consola.warn("Failed to copy to clipboard. Copy the command above manually.");
+	}
+}
+function generateClaudeCodeCommand(serverUrl, model) {
+	printAndCopyCommand(generateEnvScript(getClaudeCodeEnvVars(serverUrl, model), "claude --dangerously-skip-permissions"), "Claude Code");
+}
+function generateCodexCommand(serverUrl, model) {
+	const codexModel = model ?? DEFAULT_CODEX_MODEL;
+	printAndCopyCommand(generateEnvScript(getCodexEnvVars(serverUrl), `codex -m ${codexModel}`), "Codex CLI");
+}
+const start = defineCommand({
+	meta: {
+		name: "start",
+		description: "Start the github-router server"
+	},
+	args: {
+		...sharedServerArgs,
+		cc: {
 			type: "boolean",
 			default: false,
 			description: "Generate a command to launch Claude Code with Copilot API config"
 		},
-		codex: {
+		cx: {
 			type: "boolean",
 			default: false,
 			description: "Generate a command to launch Codex CLI with Copilot API config"
 		},
-		"show-token": {
-			type: "boolean",
-			default: false,
-			description: "Show GitHub and Copilot tokens on fetch and refresh"
-		},
-		"proxy-env": {
-			type: "boolean",
-			default: false,
-			description: "Initialize proxy from environment variables"
+		model: {
+			alias: "m",
+			type: "string",
+			description: "Override the default model (used with --cc or --cx)"
 		}
 	},
-	run({ args }) {
-		const rateLimitRaw = args["rate-limit"];
-		let rateLimit;
-		if (rateLimitRaw !== void 0) {
-			rateLimit = Number.parseInt(rateLimitRaw, 10);
-			if (Number.isNaN(rateLimit) || rateLimit <= 0) throw new Error("Invalid rate limit. Must be a positive integer.");
-		}
-		const port = Number.parseInt(args.port, 10);
-		if (Number.isNaN(port) || port <= 0 || port > 65535) throw new Error("Invalid port. Must be between 1 and 65535.");
-		const accountType = args["account-type"];
-		if (!allowedAccountTypes.has(accountType)) throw new Error("Invalid account type. Must be individual, business, or enterprise.");
-		const rateLimitWait = args.wait && rateLimit !== void 0;
-		if (args.wait && rateLimit === void 0) consola.warn("Rate limit wait ignored because no rate limit was set.");
-		const githubToken = args["github-token"] ?? process.env.GH_TOKEN;
-		return runServer({
-			port,
-			verbose: args.verbose,
-			accountType,
-			manual: args.manual,
-			rateLimit,
-			rateLimitWait,
-			githubToken,
-			claudeCode: args["claude-code"],
-			codex: args.codex,
-			showToken: args["show-token"],
-			proxyEnv: args["proxy-env"]
+	async run({ args }) {
+		const parsed = parseSharedArgs(args);
+		const { serverUrl } = await setupAndServe({
+			...parsed,
+			port: parsed.port ?? DEFAULT_PORT,
+			silent: false
 		});
+		if (args.cc) generateClaudeCodeCommand(serverUrl, args.model);
+		if (args.cx) generateCodexCommand(serverUrl, args.model);
+		consola.box(`🌐 Usage Viewer: https://animeshkundu.github.io/github-router/dashboard.html?endpoint=${serverUrl}/usage`);
 	}
 });
 
 //#endregion
 //#region src/main.ts
+process.on("unhandledRejection", (error) => {
+	consola.error("Unhandled rejection:", error);
+});
+process.on("uncaughtException", (error) => {
+	consola.error("Uncaught exception:", error);
+	process.exit(1);
+});
 await runMain(defineCommand({
 	meta: {
 		name: "github-router",
@@ -1925,6 +2199,8 @@ await runMain(defineCommand({
 	subCommands: {
 		auth,
 		start,
+		claude,
+		codex,
 		"check-usage": checkUsage,
 		debug
 	}