@nick3/copilot-api 1.0.3

package/dist/main.js

@@ -0,0 +1,746 @@
+#!/usr/bin/env node
+import { GITHUB_APP_SCOPES, GITHUB_BASE_URL, GITHUB_CLIENT_ID, HTTPError, PATHS, accountsManager, addAccountToRegistry, cacheVSCodeVersion, ensurePaths, getCopilotUsage, getGitHubUser, isFreeModelLoadBalancingEnabled, listAccountsFromRegistry, loadAccountToken, mergeConfigWithDefaults, removeAccountFromRegistry, removeAccountToken, saveAccountToken, saveRegistry, sleep, standardHeaders, state } from "./accounts-manager-CxuKJ4qv.js";
+import { defineCommand, runMain } from "citty";
+import consola from "consola";
+import fs from "node:fs/promises";
+import os from "node:os";
+import clipboard from "clipboardy";
+import { serve } from "srvx";
+import invariant from "tiny-invariant";
+import { getProxyForUrl } from "proxy-from-env";
+import { Agent, ProxyAgent, setGlobalDispatcher } from "undici";
+import { execSync } from "node:child_process";
+import process$1 from "node:process";
+
+//#region src/lib/types/account.ts
+const ACCOUNT_TYPE_VALUES = [
+	"individual",
+	"business",
+	"enterprise"
+];
+function isAccountType(value) {
+	return typeof value === "string" && ACCOUNT_TYPE_VALUES.includes(value);
+}
+function parseAccountType(value) {
+	if (!isAccountType(value)) throw new Error(`Invalid account type: ${String(value)}. Valid values: ${ACCOUNT_TYPE_VALUES.join(", ")}`);
+	return value;
+}
+
+//#endregion
+//#region src/services/github/get-device-code.ts
+async function getDeviceCode() {
+	const response = await fetch(`${GITHUB_BASE_URL}/login/device/code`, {
+		method: "POST",
+		headers: standardHeaders(),
+		body: JSON.stringify({
+			client_id: GITHUB_CLIENT_ID,
+			scope: GITHUB_APP_SCOPES
+		})
+	});
+	if (!response.ok) throw new HTTPError("Failed to get device code", response);
+	return await response.json();
+}
+
+//#endregion
+//#region src/services/github/poll-access-token.ts
+async function pollAccessToken(deviceCode) {
+	const sleepDuration = (deviceCode.interval + 1) * 1e3;
+	consola.debug(`Polling access token with interval of ${sleepDuration}ms`);
+	while (true) {
+		const response = await fetch(`${GITHUB_BASE_URL}/login/oauth/access_token`, {
+			method: "POST",
+			headers: standardHeaders(),
+			body: JSON.stringify({
+				client_id: GITHUB_CLIENT_ID,
+				device_code: deviceCode.device_code,
+				grant_type: "urn:ietf:params:oauth:grant-type:device_code"
+			})
+		});
+		if (!response.ok) {
+			await sleep(sleepDuration);
+			consola.error("Failed to poll access token:", await response.text());
+			continue;
+		}
+		const json = await response.json();
+		consola.debug("Polling access token response:", json);
+		const { access_token } = json;
+		if (access_token) return access_token;
+		else await sleep(sleepDuration);
+	}
+}
+
+//#endregion
+//#region src/auth.ts
+/**
+* Fetch quota info for an account (used by auth ls -q)
+*/
+async function fetchQuotaInfo(account) {
+	try {
+		const token = await loadAccountToken(account.id);
+		if (!token) return " | Quota: (no token)";
+		const premium = (await getCopilotUsage({
+			githubToken: token,
+			accountType: account.accountType
+		})).quota_snapshots.premium_interactions;
+		return premium.unlimited ? " | Quota: unlimited" : ` | Quota: ${premium.remaining}/${premium.entitlement}`;
+	} catch (error) {
+		consola.debug(`Failed to fetch quota for ${account.id}:`, error);
+		return " | Quota: (failed to fetch)";
+	}
+}
+/**
+* auth add - Add a new GitHub Copilot account
+*/
+const authAdd = defineCommand({
+	meta: {
+		name: "add",
+		description: "Add a new GitHub Copilot account"
+	},
+	args: {
+		"account-type": {
+			alias: "a",
+			type: "string",
+			default: "individual",
+			description: "Account type (individual, business, enterprise)"
+		},
+		verbose: {
+			alias: "v",
+			type: "boolean",
+			default: false,
+			description: "Enable verbose logging"
+		},
+		"show-token": {
+			type: "boolean",
+			default: false,
+			description: "Show GitHub token after auth"
+		}
+	},
+	async run({ args }) {
+		if (args.verbose) {
+			consola.level = 5;
+			consola.info("Verbose logging enabled");
+		}
+		state.showToken = args["show-token"];
+		let accountType;
+		try {
+			accountType = parseAccountType(args["account-type"]);
+		} catch (error) {
+			consola.error(error instanceof Error ? error.message : String(error));
+			process.exit(1);
+		}
+		await ensurePaths();
+		consola.info("Starting GitHub device code authentication...");
+		const deviceResponse = await getDeviceCode();
+		consola.debug("Device code response:", deviceResponse);
+		consola.info(`Please enter the code "${deviceResponse.user_code}" at ${deviceResponse.verification_uri}`);
+		const token = await pollAccessToken(deviceResponse);
+		if (state.showToken) consola.info("GitHub token:", token);
+		const accountId = (await getGitHubUser({
+			githubToken: token,
+			accountType
+		})).login;
+		await saveAccountToken(accountId, token);
+		const existingAccounts = await listAccountsFromRegistry();
+		if (existingAccounts.some((acc) => acc.id === accountId)) {
+			await saveRegistry({
+				version: 1,
+				accounts: existingAccounts
+			});
+			consola.success(`Account "${accountId}" already exists. Token has been updated.`);
+		} else {
+			await addAccountToRegistry({
+				id: accountId,
+				accountType,
+				addedAt: Date.now()
+			});
+			consola.success(`Account "${accountId}" added successfully!`);
+		}
+		consola.info(`Account type: ${accountType}`);
+	}
+});
+/**
+* auth ls - List all registered accounts
+*/
+const authLs = defineCommand({
+	meta: {
+		name: "ls",
+		description: "List all registered accounts"
+	},
+	args: {
+		"show-quota": {
+			alias: "q",
+			type: "boolean",
+			default: false,
+			description: "Show quota information (requires API call)"
+		},
+		verbose: {
+			alias: "v",
+			type: "boolean",
+			default: false,
+			description: "Enable verbose logging"
+		}
+	},
+	async run({ args }) {
+		if (args.verbose) consola.level = 5;
+		await ensurePaths();
+		const accounts = await listAccountsFromRegistry();
+		if (accounts.length === 0) {
+			consola.info("No accounts registered. Use 'auth add' to add an account.");
+			return;
+		}
+		consola.info(`Found ${accounts.length} account(s):\n`);
+		for (const [i, account] of accounts.entries()) {
+			const addedDate = new Date(account.addedAt).toLocaleString();
+			const quotaInfo = args["show-quota"] ? await fetchQuotaInfo(account) : "";
+			console.log(`  ${i + 1}. ${account.id} (${account.accountType})${quotaInfo}`);
+			console.log(`     Added: ${addedDate}\n`);
+		}
+	}
+});
+/**
+* auth rm - Remove an account
+*/
+const authRm = defineCommand({
+	meta: {
+		name: "rm",
+		description: "Remove an account"
+	},
+	args: {
+		target: {
+			type: "positional",
+			description: "Account ID or index (1-based)",
+			required: true
+		},
+		force: {
+			alias: "f",
+			type: "boolean",
+			default: false,
+			description: "Skip confirmation prompt"
+		},
+		verbose: {
+			alias: "v",
+			type: "boolean",
+			default: false,
+			description: "Enable verbose logging"
+		}
+	},
+	async run({ args }) {
+		if (args.verbose) consola.level = 5;
+		await ensurePaths();
+		const target = args.target;
+		const accounts = await listAccountsFromRegistry();
+		if (accounts.length === 0) {
+			consola.error("No accounts to remove.");
+			return;
+		}
+		let accountToRemove;
+		const index = Number.parseInt(target, 10);
+		if (!Number.isNaN(index) && index >= 1 && index <= accounts.length) accountToRemove = {
+			id: accounts[index - 1].id,
+			index: index - 1
+		};
+		else {
+			const foundIndex = accounts.findIndex((acc) => acc.id === target);
+			if (foundIndex !== -1) accountToRemove = {
+				id: accounts[foundIndex].id,
+				index: foundIndex
+			};
+		}
+		if (!accountToRemove) {
+			consola.error(`Account "${target}" not found.`);
+			consola.info("Use 'auth ls' to see available accounts.");
+			return;
+		}
+		if (!args.force) {
+			if (!await consola.prompt(`Are you sure you want to remove account "${accountToRemove.id}"?`, { type: "confirm" })) {
+				consola.info("Cancelled.");
+				return;
+			}
+		}
+		await removeAccountToken(accountToRemove.id);
+		await removeAccountFromRegistry(accountToRemove.id);
+		consola.success(`Account "${accountToRemove.id}" removed.`);
+	}
+});
+/**
+* Main auth command with subcommands
+*/
+const auth = defineCommand({
+	meta: {
+		name: "auth",
+		description: "Manage GitHub Copilot accounts"
+	},
+	subCommands: {
+		add: authAdd,
+		ls: authLs,
+		rm: authRm
+	},
+	args: {
+		"account-type": {
+			alias: "a",
+			type: "string",
+			default: "individual",
+			description: "Account type (individual, business, enterprise)"
+		},
+		verbose: {
+			alias: "v",
+			type: "boolean",
+			default: false,
+			description: "Enable verbose logging"
+		},
+		"show-token": {
+			type: "boolean",
+			default: false,
+			description: "Show GitHub token after auth"
+		}
+	},
+	async run(ctx) {
+		const firstArg = ctx.rawArgs[0];
+		if (!(firstArg === "add" || firstArg === "ls" || firstArg === "rm") && authAdd.run) await authAdd.run(ctx);
+	}
+});
+
+//#endregion
+//#region src/lib/token.ts
+const readGithubToken = () => fs.readFile(PATHS.GITHUB_TOKEN_PATH, "utf8");
+const writeGithubToken = (token) => fs.writeFile(PATHS.GITHUB_TOKEN_PATH, token);
+async function setupGitHubToken(options) {
+	try {
+		const githubToken = await readGithubToken();
+		if (githubToken && !options?.force) {
+			state.githubToken = githubToken;
+			if (state.showToken) consola.info("GitHub token:", githubToken);
+			await logUser();
+			return;
+		}
+		consola.info("Not logged in, getting new access token");
+		const response = await getDeviceCode();
+		consola.debug("Device code response:", response);
+		consola.info(`Please enter the code "${response.user_code}" in ${response.verification_uri}`);
+		const token = await pollAccessToken(response);
+		await writeGithubToken(token);
+		state.githubToken = token;
+		if (state.showToken) consola.info("GitHub token:", token);
+		await logUser();
+	} catch (error) {
+		if (error instanceof HTTPError) {
+			consola.error("Failed to get GitHub token:", await error.response.json());
+			throw error;
+		}
+		consola.error("Failed to get GitHub token:", error);
+		throw error;
+	}
+}
+async function logUser() {
+	const user = await getGitHubUser();
+	consola.info(`Logged in as ${user.login}`);
+}
+
+//#endregion
+//#region src/check-usage.ts
+const checkUsage = defineCommand({
+	meta: {
+		name: "check-usage",
+		description: "Show current GitHub Copilot usage/quota information"
+	},
+	async run() {
+		await ensurePaths();
+		await setupGitHubToken();
+		try {
+			const usage = await getCopilotUsage();
+			const premium = usage.quota_snapshots.premium_interactions;
+			const premiumTotal = premium.entitlement;
+			const premiumUsed = premiumTotal - premium.remaining;
+			const premiumPercentUsed = premiumTotal > 0 ? premiumUsed / premiumTotal * 100 : 0;
+			const premiumPercentRemaining = premium.percent_remaining;
+			function summarizeQuota(name, snap) {
+				if (!snap) return `${name}: N/A`;
+				const total = snap.entitlement;
+				const used = total - snap.remaining;
+				const percentUsed = total > 0 ? used / total * 100 : 0;
+				const percentRemaining = snap.percent_remaining;
+				return `${name}: ${used}/${total} used (${percentUsed.toFixed(1)}% used, ${percentRemaining.toFixed(1)}% remaining)`;
+			}
+			const premiumLine = `Premium: ${premiumUsed}/${premiumTotal} used (${premiumPercentUsed.toFixed(1)}% used, ${premiumPercentRemaining.toFixed(1)}% remaining)`;
+			const chatLine = summarizeQuota("Chat", usage.quota_snapshots.chat);
+			const completionsLine = summarizeQuota("Completions", usage.quota_snapshots.completions);
+			consola.box(`Copilot Usage (plan: ${usage.copilot_plan})\nQuota resets: ${usage.quota_reset_date}\n\nQuotas:\n  ${premiumLine}\n  ${chatLine}\n  ${completionsLine}`);
+		} catch (err) {
+			consola.error("Failed to fetch Copilot usage:", err);
+			process.exit(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
+		},
+		tokenExists
+	};
+}
+function printDebugInfoPlain(info) {
+	consola.info(`copilot-api 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
+function initProxyFromEnv() {
+	if (typeof Bun !== "undefined") return;
+	try {
+		const direct = new Agent();
+		const proxies = /* @__PURE__ */ new Map();
+		setGlobalDispatcher({
+			dispatch(options, handler) {
+				try {
+					const origin = typeof options.origin === "string" ? new URL(options.origin) : options.origin;
+					const raw = getProxyForUrl(origin.toString());
+					const proxyUrl = raw && raw.length > 0 ? raw : void 0;
+					if (!proxyUrl) {
+						consola.debug(`HTTP proxy bypass: ${origin.hostname}`);
+						return direct.dispatch(options, handler);
+					}
+					let agent = proxies.get(proxyUrl);
+					if (!agent) {
+						agent = new ProxyAgent(proxyUrl);
+						proxies.set(proxyUrl, agent);
+					}
+					let label = proxyUrl;
+					try {
+						const u = new URL(proxyUrl);
+						label = `${u.protocol}//${u.host}`;
+					} catch {}
+					consola.debug(`HTTP proxy route: ${origin.hostname} via ${label}`);
+					return agent.dispatch(options, handler);
+				} catch {
+					return direct.dispatch(options, handler);
+				}
+			},
+			close() {
+				return direct.close();
+			},
+			destroy() {
+				return direct.destroy();
+			}
+		});
+		consola.debug("HTTP proxy configured from environment (per-URL)");
+	} catch (err) {
+		consola.debug("Proxy setup skipped:", err);
+	}
+}
+
+//#endregion
+//#region src/lib/shell.ts
+function getShell() {
+	const { platform, ppid, env } = process$1;
+	if (platform === "win32") {
+		try {
+			const command = `wmic process get ParentProcessId,Name | findstr "${ppid}"`;
+			if (execSync(command, { stdio: "pipe" }).toString().toLowerCase().includes("powershell.exe")) return "powershell";
+		} catch {
+			return "cmd";
+		}
+		return "cmd";
+	} else {
+		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";
+	}
+}
+/**
+* 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} = ${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} ${value}`).join("; ");
+			break;
+		default: {
+			const assignments = filteredEnvVars.map(([key, value]) => `${key}=${value}`).join(" ");
+			commandBlock = filteredEnvVars.length > 0 ? `export ${assignments}` : "";
+			break;
+		}
+	}
+	if (commandBlock && commandToRun) return `${commandBlock}${shell === "cmd" ? " & " : " && "}${commandToRun}`;
+	return commandBlock || commandToRun;
+}
+
+//#endregion
+//#region src/start.ts
+/**
+* Run the interactive authentication flow to add a new account.
+* Called automatically when no accounts are found.
+*/
+async function runAuthFlow(accountType) {
+	consola.warn("No accounts found. Starting authentication flow...");
+	const deviceResponse = await getDeviceCode();
+	consola.info(`Please enter the code "${deviceResponse.user_code}" at ${deviceResponse.verification_uri}`);
+	const token = await pollAccessToken(deviceResponse);
+	if (state.showToken) consola.info("GitHub token:", token);
+	const accountId = (await getGitHubUser({
+		githubToken: token,
+		accountType
+	})).login;
+	await saveAccountToken(accountId, token);
+	await addAccountToRegistry({
+		id: accountId,
+		accountType,
+		addedAt: Date.now()
+	});
+	consola.success(`Account "${accountId}" added successfully!`);
+}
+async function runServer(options) {
+	mergeConfigWithDefaults();
+	accountsManager.setFreeModelLoadBalancingEnabled(isFreeModelLoadBalancingEnabled());
+	if (options.proxyEnv) initProxyFromEnv();
+	state.verbose = options.verbose;
+	if (options.verbose) {
+		consola.level = 5;
+		consola.info("Verbose logging enabled");
+	}
+	state.accountType = options.accountType;
+	if (options.accountType !== "individual") consola.info(`Using ${options.accountType} plan GitHub account`);
+	state.manualApprove = options.manual;
+	state.rateLimitSeconds = options.rateLimit;
+	state.rateLimitWait = options.rateLimitWait;
+	state.showToken = options.showToken;
+	await ensurePaths();
+	await cacheVSCodeVersion();
+	await accountsManager.initialize(state.vsCodeVersion);
+	if (options.githubToken) {
+		await accountsManager.setTemporaryAccount(options.githubToken, options.accountType);
+		consola.info("Using provided GitHub token as temporary account");
+	}
+	if (!accountsManager.hasAccounts()) try {
+		await runAuthFlow(options.accountType);
+		accountsManager.shutdown();
+		await accountsManager.initialize(state.vsCodeVersion);
+	} catch (error) {
+		consola.error("Failed to add account:", error);
+		process.exit(1);
+	}
+	const models = accountsManager.getFirstAccountModels();
+	consola.info(`Available models: \n${models?.data.map((model) => `- ${model.id}`).join("\n") ?? "(no models loaded)"}`);
+	const serverUrl = `http://localhost:${options.port}`;
+	if (options.claudeCode) {
+		invariant(models, "Models should be loaded by now");
+		const selectedModel = await consola.prompt("Select a model to use with Claude Code", {
+			type: "select",
+			options: models.data.map((model) => model.id)
+		});
+		const selectedSmallModel = await consola.prompt("Select a small model to use with Claude Code", {
+			type: "select",
+			options: models.data.map((model) => model.id)
+		});
+		const command = 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");
+		try {
+			clipboard.writeSync(command);
+			consola.success("Copied Claude Code command to clipboard!");
+		} catch {
+			consola.warn("Failed to copy to clipboard. Here is the Claude Code command:");
+			consola.log(command);
+		}
+	}
+	consola.box(`🌐 Usage Viewer: https://ericc-ch.github.io/copilot-api?endpoint=${serverUrl}/usage`);
+	const { server } = await import("./server-D05YP0C0.js");
+	serve({
+		fetch: server.fetch,
+		port: options.port,
+		bun: { idleTimeout: 0 }
+	});
+}
+const start = defineCommand({
+	meta: {
+		name: "start",
+		description: "Start the Copilot API server"
+	},
+	args: {
+		port: {
+			alias: "p",
+			type: "string",
+			default: "4141",
+			description: "Port to listen on"
+		},
+		verbose: {
+			alias: "v",
+			type: "boolean",
+			default: false,
+			description: "Enable verbose logging"
+		},
+		"account-type": {
+			alias: "a",
+			type: "string",
+			default: "individual",
+			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)"
+		},
+		"claude-code": {
+			alias: "c",
+			type: "boolean",
+			default: false,
+			description: "Generate a command to launch Claude Code 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"
+		}
+	},
+	run({ args }) {
+		const rateLimitRaw = args["rate-limit"];
+		const rateLimit = rateLimitRaw === void 0 ? void 0 : Number.parseInt(rateLimitRaw, 10);
+		let accountType;
+		try {
+			accountType = parseAccountType(args["account-type"]);
+		} catch (error) {
+			consola.error(error instanceof Error ? error.message : String(error));
+			process.exit(1);
+		}
+		return runServer({
+			port: Number.parseInt(args.port, 10),
+			verbose: args.verbose,
+			accountType,
+			manual: args.manual,
+			rateLimit,
+			rateLimitWait: args.wait,
+			githubToken: args["github-token"],
+			claudeCode: args["claude-code"],
+			showToken: args["show-token"],
+			proxyEnv: args["proxy-env"]
+		});
+	}
+});
+
+//#endregion
+//#region src/main.ts
+const main = defineCommand({
+	meta: {
+		name: "copilot-api",
+		description: "A wrapper around GitHub Copilot API to make it OpenAI compatible, making it usable for other tools."
+	},
+	subCommands: {
+		auth,
+		start,
+		"check-usage": checkUsage,
+		debug
+	}
+});
+await runMain(main);
+
+//#endregion
+export {  };
+//# sourceMappingURL=main.js.map