copilot-api-plus 1.0.13 → 1.0.15

package/dist/main.js

@@ -1,12 +1,13 @@
 #!/usr/bin/env node
 import { PATHS, ensurePaths } from "./paths-Ch0ixSo2.js";
 import { state } from "./state-CcLGr8VN.js";
-import { GITHUB_API_BASE_URL, copilotBaseUrl, copilotHeaders, githubHeaders } from "./get-user-BFf5xJXg.js";
+import { GITHUB_API_BASE_URL, copilotBaseUrl, copilotHeaders, githubHeaders } from "./get-user-BzIEATcF.js";
 import { HTTPError, forwardError } from "./error-CvU5otz-.js";
-import { cacheModels, cacheVSCodeVersion, clearGithubToken, isNullish, setupCopilotToken, setupGitHubToken, sleep } from "./token-B8crDDoA.js";
-import { clearAntigravityAuth, disableCurrentAccount, getAntigravityAuthPath, getValidAccessToken, rotateAccount } from "./auth-Cm_0h9bp.js";
+import { cacheModels, cacheVSCodeVersion, clearGithubToken, isNullish, setupCopilotToken, setupGitHubToken, sleep } from "./token-BUmQ_BcM.js";
+import { clearAntigravityAuth, disableCurrentAccount, getAntigravityAuthPath, getApiKey, getValidAccessToken, rotateAccount } from "./auth-CsslwaJY.js";
 import { clearZenAuth, getZenAuthPath } from "./auth-Cua-c0dq.js";
-import { getAntigravityModels, isThinkingModel } from "./get-models-Bbb8B5jI.js";
+import { getAntigravityModels, isThinkingModel } from "./get-models-DZR1TS4C.js";
+import { createRequire } from "node:module";
 import { defineCommand, runMain } from "citty";
 import consola from "consola";
 import fs from "node:fs/promises";
@@ -27,13 +28,21 @@ import { HTTPException } from "hono/http-exception";
 import { streamSSE } from "hono/streaming";
 import { events } from "fetch-event-stream";
 
+//#region rolldown:runtime
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
 //#region src/auth.ts
-async function runAuth(options) {
-	if (options.verbose) {
+async function runAuth(options$1) {
+	if (options$1.verbose) {
 		consola.level = 5;
 		consola.info("Verbose logging enabled");
 	}
-	state.showToken = options.showToken;
+	state.showToken = options$1.showToken;
 	await ensurePaths();
 	await setupGitHubToken({ force: true });
 	consola.success("GitHub token written to", PATHS.GITHUB_TOKEN_PATH);
@@ -132,9 +141,9 @@ async function loadConfig() {
 /**
 * Save configuration to file
 */
-async function saveConfig(config) {
+async function saveConfig(config$1) {
 	const configPath = getConfigPath();
-	await fs.writeFile(configPath, JSON.stringify(config, null, 2), "utf8");
+	await fs.writeFile(configPath, JSON.stringify(config$1, null, 2), "utf8");
 	consola.debug(`Configuration saved to ${configPath}`);
 }
 /**
@@ -147,17 +156,17 @@ async function getProxyConfig() {
 * Save proxy configuration
 */
 async function saveProxyConfig(proxyConfig) {
-	const config = await loadConfig();
-	config.proxy = proxyConfig;
-	await saveConfig(config);
+	const config$1 = await loadConfig();
+	config$1.proxy = proxyConfig;
+	await saveConfig(config$1);
 }
 /**
 * Clear proxy configuration
 */
 async function clearProxyConfig() {
-	const config = await loadConfig();
-	delete config.proxy;
-	await saveConfig(config);
+	const config$1 = await loadConfig();
+	delete config$1.proxy;
+	await saveConfig(config$1);
 }
 /**
 * Apply saved proxy configuration to environment variables
@@ -212,10 +221,10 @@ async function checkTokenExists() {
 		return false;
 	}
 }
-async function checkFileExists(path$1) {
+async function checkFileExists(path$2) {
 	try {
-		if (!(await fs.stat(path$1)).isFile()) return false;
-		return (await fs.readFile(path$1, "utf8")).trim().length > 0;
+		if (!(await fs.stat(path$2)).isFile()) return false;
+		return (await fs.readFile(path$2, "utf8")).trim().length > 0;
 	} catch {
 		return false;
 	}
@@ -223,7 +232,7 @@ async function checkFileExists(path$1) {
 async function getDebugInfo() {
 	const zenAuthPath = getZenAuthPath();
 	const antigravityAuthPath = getAntigravityAuthPath();
-	const [version, githubExists, zenExists, antigravityExists, proxyConfig] = await Promise.all([
+	const [version$1, githubExists, zenExists, antigravityExists, proxyConfig] = await Promise.all([
 		getPackageVersion(),
 		checkTokenExists(),
 		checkFileExists(zenAuthPath),
@@ -231,7 +240,7 @@ async function getDebugInfo() {
 		getProxyConfig()
 	]);
 	return {
-		version,
+		version: version$1,
 		runtime: getRuntimeInfo(),
 		paths: {
 			APP_DIR: PATHS.APP_DIR,
@@ -271,9 +280,9 @@ Proxy: ${proxyStatus}`);
 function printDebugInfoJson(info) {
 	console.log(JSON.stringify(info, null, 2));
 }
-async function runDebug(options) {
+async function runDebug(options$1) {
 	const debugInfo = await getDebugInfo();
-	if (options.json) printDebugInfoJson(debugInfo);
+	if (options$1.json) printDebugInfoJson(debugInfo);
 	else printDebugInfoPlain(debugInfo);
 }
 const debug = defineCommand({
@@ -293,9 +302,9 @@ const debug = defineCommand({
 
 //#endregion
 //#region src/logout.ts
-async function runLogout(options) {
+async function runLogout(options$1) {
 	await ensurePaths();
-	if (options.all) {
+	if (options$1.all) {
 		await clearGithubToken();
 		await clearZenAuth();
 		await clearAntigravityAuth();
@@ -305,19 +314,19 @@ async function runLogout(options) {
 		consola.info(`Antigravity accounts: ${getAntigravityAuthPath()}`);
 		return;
 	}
-	if (options.github) {
+	if (options$1.github) {
 		await clearGithubToken();
 		consola.success("Logged out from GitHub Copilot");
 		consola.info(`Token file location: ${PATHS.GITHUB_TOKEN_PATH}`);
 		return;
 	}
-	if (options.zen) {
+	if (options$1.zen) {
 		await clearZenAuth();
 		consola.success("Logged out from OpenCode Zen");
 		consola.info(`Zen API key location: ${getZenAuthPath()}`);
 		return;
 	}
-	if (options.antigravity) {
+	if (options$1.antigravity) {
 		await clearAntigravityAuth();
 		consola.success("Logged out from Google Antigravity");
 		consola.info(`Antigravity accounts location: ${getAntigravityAuthPath()}`);
@@ -444,8 +453,8 @@ const proxy = defineCommand({
 	async run({ args }) {
 		await ensurePaths();
 		if (args.show || !args.set && !args.enable && !args.disable && !args.clear && !args["http-proxy"] && !args["https-proxy"]) {
-			const config = await getProxyConfig();
-			if (!config) {
+			const config$1 = await getProxyConfig();
+			if (!config$1) {
 				consola.info("No proxy configuration saved.");
 				consola.info("");
 				consola.info("To configure proxy, use one of:");
@@ -454,10 +463,10 @@ const proxy = defineCommand({
 				return;
 			}
 			consola.info("Current proxy configuration:");
-			consola.info(`  Status: ${config.enabled ? "✅ Enabled" : "❌ Disabled"}`);
-			if (config.httpProxy) consola.info(`  HTTP_PROXY: ${config.httpProxy}`);
-			if (config.httpsProxy) consola.info(`  HTTPS_PROXY: ${config.httpsProxy}`);
-			if (config.noProxy) consola.info(`  NO_PROXY: ${config.noProxy}`);
+			consola.info(`  Status: ${config$1.enabled ? "✅ Enabled" : "❌ Disabled"}`);
+			if (config$1.httpProxy) consola.info(`  HTTP_PROXY: ${config$1.httpProxy}`);
+			if (config$1.httpsProxy) consola.info(`  HTTPS_PROXY: ${config$1.httpsProxy}`);
+			if (config$1.noProxy) consola.info(`  NO_PROXY: ${config$1.noProxy}`);
 			return;
 		}
 		if (args.clear) {
@@ -466,24 +475,24 @@ const proxy = defineCommand({
 			return;
 		}
 		if (args.enable) {
-			const config = await getProxyConfig();
-			if (!config) {
+			const config$1 = await getProxyConfig();
+			if (!config$1) {
 				consola.error("No proxy configuration saved. Use --set to configure first.");
 				return;
 			}
-			config.enabled = true;
-			await saveProxyConfig(config);
+			config$1.enabled = true;
+			await saveProxyConfig(config$1);
 			consola.success("Proxy enabled. It will be used on next server start.");
 			return;
 		}
 		if (args.disable) {
-			const config = await getProxyConfig();
-			if (!config) {
+			const config$1 = await getProxyConfig();
+			if (!config$1) {
 				consola.info("No proxy configuration to disable.");
 				return;
 			}
-			config.enabled = false;
-			await saveProxyConfig(config);
+			config$1.enabled = false;
+			await saveProxyConfig(config$1);
 			consola.success("Proxy disabled. Settings are preserved.");
 			return;
 		}
@@ -550,6 +559,383 @@ const proxy = defineCommand({
 	}
 });
 
+//#endregion
+//#region node_modules/dotenv/package.json
+var require_package = /* @__PURE__ */ __commonJS({ "node_modules/dotenv/package.json": ((exports, module) => {
+	module.exports = {
+		"name": "dotenv",
+		"version": "17.2.3",
+		"description": "Loads environment variables from .env file",
+		"main": "lib/main.js",
+		"types": "lib/main.d.ts",
+		"exports": {
+			".": {
+				"types": "./lib/main.d.ts",
+				"require": "./lib/main.js",
+				"default": "./lib/main.js"
+			},
+			"./config": "./config.js",
+			"./config.js": "./config.js",
+			"./lib/env-options": "./lib/env-options.js",
+			"./lib/env-options.js": "./lib/env-options.js",
+			"./lib/cli-options": "./lib/cli-options.js",
+			"./lib/cli-options.js": "./lib/cli-options.js",
+			"./package.json": "./package.json"
+		},
+		"scripts": {
+			"dts-check": "tsc --project tests/types/tsconfig.json",
+			"lint": "standard",
+			"pretest": "npm run lint && npm run dts-check",
+			"test": "tap run tests/**/*.js --allow-empty-coverage --disable-coverage --timeout=60000",
+			"test:coverage": "tap run tests/**/*.js --show-full-coverage --timeout=60000 --coverage-report=text --coverage-report=lcov",
+			"prerelease": "npm test",
+			"release": "standard-version"
+		},
+		"repository": {
+			"type": "git",
+			"url": "git://github.com/motdotla/dotenv.git"
+		},
+		"homepage": "https://github.com/motdotla/dotenv#readme",
+		"funding": "https://dotenvx.com",
+		"keywords": [
+			"dotenv",
+			"env",
+			".env",
+			"environment",
+			"variables",
+			"config",
+			"settings"
+		],
+		"readmeFilename": "README.md",
+		"license": "BSD-2-Clause",
+		"devDependencies": {
+			"@types/node": "^18.11.3",
+			"decache": "^4.6.2",
+			"sinon": "^14.0.1",
+			"standard": "^17.0.0",
+			"standard-version": "^9.5.0",
+			"tap": "^19.2.0",
+			"typescript": "^4.8.4"
+		},
+		"engines": { "node": ">=12" },
+		"browser": { "fs": false }
+	};
+}) });
+
+//#endregion
+//#region node_modules/dotenv/lib/main.js
+var require_main = /* @__PURE__ */ __commonJS({ "node_modules/dotenv/lib/main.js": ((exports, module) => {
+	const fs$1 = __require("fs");
+	const path$1 = __require("path");
+	const os$1 = __require("os");
+	const crypto = __require("crypto");
+	const version = require_package().version;
+	const TIPS = [
+		"🔐 encrypt with Dotenvx: https://dotenvx.com",
+		"🔐 prevent committing .env to code: https://dotenvx.com/precommit",
+		"🔐 prevent building .env in docker: https://dotenvx.com/prebuild",
+		"📡 add observability to secrets: https://dotenvx.com/ops",
+		"👥 sync secrets across teammates & machines: https://dotenvx.com/ops",
+		"🗂️ backup and recover secrets: https://dotenvx.com/ops",
+		"✅ audit secrets and track compliance: https://dotenvx.com/ops",
+		"🔄 add secrets lifecycle management: https://dotenvx.com/ops",
+		"🔑 add access controls to secrets: https://dotenvx.com/ops",
+		"🛠️  run anywhere with `dotenvx run -- yourcommand`",
+		"⚙️  specify custom .env file path with { path: '/custom/path/.env' }",
+		"⚙️  enable debug logging with { debug: true }",
+		"⚙️  override existing env vars with { override: true }",
+		"⚙️  suppress all logs with { quiet: true }",
+		"⚙️  write to custom object with { processEnv: myObject }",
+		"⚙️  load multiple .env files with { path: ['.env.local', '.env'] }"
+	];
+	function _getRandomTip() {
+		return TIPS[Math.floor(Math.random() * TIPS.length)];
+	}
+	function parseBoolean(value) {
+		if (typeof value === "string") return ![
+			"false",
+			"0",
+			"no",
+			"off",
+			""
+		].includes(value.toLowerCase());
+		return Boolean(value);
+	}
+	function supportsAnsi() {
+		return process.stdout.isTTY;
+	}
+	function dim(text) {
+		return supportsAnsi() ? `\x1b[2m${text}\x1b[0m` : text;
+	}
+	const LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/gm;
+	function parse(src) {
+		const obj = {};
+		let lines = src.toString();
+		lines = lines.replace(/\r\n?/gm, "\n");
+		let match;
+		while ((match = LINE.exec(lines)) != null) {
+			const key = match[1];
+			let value = match[2] || "";
+			value = value.trim();
+			const maybeQuote = value[0];
+			value = value.replace(/^(['"`])([\s\S]*)\1$/gm, "$2");
+			if (maybeQuote === "\"") {
+				value = value.replace(/\\n/g, "\n");
+				value = value.replace(/\\r/g, "\r");
+			}
+			obj[key] = value;
+		}
+		return obj;
+	}
+	function _parseVault(options$1) {
+		options$1 = options$1 || {};
+		const vaultPath = _vaultPath(options$1);
+		options$1.path = vaultPath;
+		const result = DotenvModule.configDotenv(options$1);
+		if (!result.parsed) {
+			const err = /* @__PURE__ */ new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
+			err.code = "MISSING_DATA";
+			throw err;
+		}
+		const keys = _dotenvKey(options$1).split(",");
+		const length = keys.length;
+		let decrypted;
+		for (let i = 0; i < length; i++) try {
+			const key = keys[i].trim();
+			const attrs = _instructions(result, key);
+			decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+			break;
+		} catch (error) {
+			if (i + 1 >= length) throw error;
+		}
+		return DotenvModule.parse(decrypted);
+	}
+	function _warn(message) {
+		console.error(`[dotenv@${version}][WARN] ${message}`);
+	}
+	function _debug(message) {
+		console.log(`[dotenv@${version}][DEBUG] ${message}`);
+	}
+	function _log(message) {
+		console.log(`[dotenv@${version}] ${message}`);
+	}
+	function _dotenvKey(options$1) {
+		if (options$1 && options$1.DOTENV_KEY && options$1.DOTENV_KEY.length > 0) return options$1.DOTENV_KEY;
+		if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) return process.env.DOTENV_KEY;
+		return "";
+	}
+	function _instructions(result, dotenvKey) {
+		let uri;
+		try {
+			uri = new URL(dotenvKey);
+		} catch (error) {
+			if (error.code === "ERR_INVALID_URL") {
+				const err = /* @__PURE__ */ new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
+				err.code = "INVALID_DOTENV_KEY";
+				throw err;
+			}
+			throw error;
+		}
+		const key = uri.password;
+		if (!key) {
+			const err = /* @__PURE__ */ new Error("INVALID_DOTENV_KEY: Missing key part");
+			err.code = "INVALID_DOTENV_KEY";
+			throw err;
+		}
+		const environment = uri.searchParams.get("environment");
+		if (!environment) {
+			const err = /* @__PURE__ */ new Error("INVALID_DOTENV_KEY: Missing environment part");
+			err.code = "INVALID_DOTENV_KEY";
+			throw err;
+		}
+		const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
+		const ciphertext = result.parsed[environmentKey];
+		if (!ciphertext) {
+			const err = /* @__PURE__ */ new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
+			err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
+			throw err;
+		}
+		return {
+			ciphertext,
+			key
+		};
+	}
+	function _vaultPath(options$1) {
+		let possibleVaultPath = null;
+		if (options$1 && options$1.path && options$1.path.length > 0) if (Array.isArray(options$1.path)) {
+			for (const filepath of options$1.path) if (fs$1.existsSync(filepath)) possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
+		} else possibleVaultPath = options$1.path.endsWith(".vault") ? options$1.path : `${options$1.path}.vault`;
+		else possibleVaultPath = path$1.resolve(process.cwd(), ".env.vault");
+		if (fs$1.existsSync(possibleVaultPath)) return possibleVaultPath;
+		return null;
+	}
+	function _resolveHome(envPath) {
+		return envPath[0] === "~" ? path$1.join(os$1.homedir(), envPath.slice(1)) : envPath;
+	}
+	function _configVault(options$1) {
+		const debug$1 = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options$1 && options$1.debug);
+		const quiet = parseBoolean(process.env.DOTENV_CONFIG_QUIET || options$1 && options$1.quiet);
+		if (debug$1 || !quiet) _log("Loading env from encrypted .env.vault");
+		const parsed = DotenvModule._parseVault(options$1);
+		let processEnv = process.env;
+		if (options$1 && options$1.processEnv != null) processEnv = options$1.processEnv;
+		DotenvModule.populate(processEnv, parsed, options$1);
+		return { parsed };
+	}
+	function configDotenv(options$1) {
+		const dotenvPath = path$1.resolve(process.cwd(), ".env");
+		let encoding = "utf8";
+		let processEnv = process.env;
+		if (options$1 && options$1.processEnv != null) processEnv = options$1.processEnv;
+		let debug$1 = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || options$1 && options$1.debug);
+		let quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || options$1 && options$1.quiet);
+		if (options$1 && options$1.encoding) encoding = options$1.encoding;
+		else if (debug$1) _debug("No encoding is specified. UTF-8 is used by default");
+		let optionPaths = [dotenvPath];
+		if (options$1 && options$1.path) if (!Array.isArray(options$1.path)) optionPaths = [_resolveHome(options$1.path)];
+		else {
+			optionPaths = [];
+			for (const filepath of options$1.path) optionPaths.push(_resolveHome(filepath));
+		}
+		let lastError;
+		const parsedAll = {};
+		for (const path$2 of optionPaths) try {
+			const parsed = DotenvModule.parse(fs$1.readFileSync(path$2, { encoding }));
+			DotenvModule.populate(parsedAll, parsed, options$1);
+		} catch (e) {
+			if (debug$1) _debug(`Failed to load ${path$2} ${e.message}`);
+			lastError = e;
+		}
+		const populated = DotenvModule.populate(processEnv, parsedAll, options$1);
+		debug$1 = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || debug$1);
+		quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || quiet);
+		if (debug$1 || !quiet) {
+			const keysCount = Object.keys(populated).length;
+			const shortPaths = [];
+			for (const filePath of optionPaths) try {
+				const relative = path$1.relative(process.cwd(), filePath);
+				shortPaths.push(relative);
+			} catch (e) {
+				if (debug$1) _debug(`Failed to load ${filePath} ${e.message}`);
+				lastError = e;
+			}
+			_log(`injecting env (${keysCount}) from ${shortPaths.join(",")} ${dim(`-- tip: ${_getRandomTip()}`)}`);
+		}
+		if (lastError) return {
+			parsed: parsedAll,
+			error: lastError
+		};
+		else return { parsed: parsedAll };
+	}
+	function config(options$1) {
+		if (_dotenvKey(options$1).length === 0) return DotenvModule.configDotenv(options$1);
+		const vaultPath = _vaultPath(options$1);
+		if (!vaultPath) {
+			_warn(`You set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}. Did you forget to build it?`);
+			return DotenvModule.configDotenv(options$1);
+		}
+		return DotenvModule._configVault(options$1);
+	}
+	function decrypt(encrypted, keyStr) {
+		const key = Buffer.from(keyStr.slice(-64), "hex");
+		let ciphertext = Buffer.from(encrypted, "base64");
+		const nonce = ciphertext.subarray(0, 12);
+		const authTag = ciphertext.subarray(-16);
+		ciphertext = ciphertext.subarray(12, -16);
+		try {
+			const aesgcm = crypto.createDecipheriv("aes-256-gcm", key, nonce);
+			aesgcm.setAuthTag(authTag);
+			return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
+		} catch (error) {
+			const isRange = error instanceof RangeError;
+			const invalidKeyLength = error.message === "Invalid key length";
+			const decryptionFailed = error.message === "Unsupported state or unable to authenticate data";
+			if (isRange || invalidKeyLength) {
+				const err = /* @__PURE__ */ new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
+				err.code = "INVALID_DOTENV_KEY";
+				throw err;
+			} else if (decryptionFailed) {
+				const err = /* @__PURE__ */ new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
+				err.code = "DECRYPTION_FAILED";
+				throw err;
+			} else throw error;
+		}
+	}
+	function populate(processEnv, parsed, options$1 = {}) {
+		const debug$1 = Boolean(options$1 && options$1.debug);
+		const override = Boolean(options$1 && options$1.override);
+		const populated = {};
+		if (typeof parsed !== "object") {
+			const err = /* @__PURE__ */ new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
+			err.code = "OBJECT_REQUIRED";
+			throw err;
+		}
+		for (const key of Object.keys(parsed)) if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+			if (override === true) {
+				processEnv[key] = parsed[key];
+				populated[key] = parsed[key];
+			}
+			if (debug$1) if (override === true) _debug(`"${key}" is already defined and WAS overwritten`);
+			else _debug(`"${key}" is already defined and was NOT overwritten`);
+		} else {
+			processEnv[key] = parsed[key];
+			populated[key] = parsed[key];
+		}
+		return populated;
+	}
+	const DotenvModule = {
+		configDotenv,
+		_configVault,
+		_parseVault,
+		config,
+		decrypt,
+		parse,
+		populate
+	};
+	module.exports.configDotenv = DotenvModule.configDotenv;
+	module.exports._configVault = DotenvModule._configVault;
+	module.exports._parseVault = DotenvModule._parseVault;
+	module.exports.config = DotenvModule.config;
+	module.exports.decrypt = DotenvModule.decrypt;
+	module.exports.parse = DotenvModule.parse;
+	module.exports.populate = DotenvModule.populate;
+	module.exports = DotenvModule;
+}) });
+
+//#endregion
+//#region node_modules/dotenv/lib/env-options.js
+var require_env_options = /* @__PURE__ */ __commonJS({ "node_modules/dotenv/lib/env-options.js": ((exports, module) => {
+	const options = {};
+	if (process.env.DOTENV_CONFIG_ENCODING != null) options.encoding = process.env.DOTENV_CONFIG_ENCODING;
+	if (process.env.DOTENV_CONFIG_PATH != null) options.path = process.env.DOTENV_CONFIG_PATH;
+	if (process.env.DOTENV_CONFIG_QUIET != null) options.quiet = process.env.DOTENV_CONFIG_QUIET;
+	if (process.env.DOTENV_CONFIG_DEBUG != null) options.debug = process.env.DOTENV_CONFIG_DEBUG;
+	if (process.env.DOTENV_CONFIG_OVERRIDE != null) options.override = process.env.DOTENV_CONFIG_OVERRIDE;
+	if (process.env.DOTENV_CONFIG_DOTENV_KEY != null) options.DOTENV_KEY = process.env.DOTENV_CONFIG_DOTENV_KEY;
+	module.exports = options;
+}) });
+
+//#endregion
+//#region node_modules/dotenv/lib/cli-options.js
+var require_cli_options = /* @__PURE__ */ __commonJS({ "node_modules/dotenv/lib/cli-options.js": ((exports, module) => {
+	const re = /^dotenv_config_(encoding|path|quiet|debug|override|DOTENV_KEY)=(.+)$/;
+	module.exports = function optionMatcher(args) {
+		const options$1 = args.reduce(function(acc, cur) {
+			const matches = cur.match(re);
+			if (matches) acc[matches[1]] = matches[2];
+			return acc;
+		}, {});
+		if (!("quiet" in options$1)) options$1.quiet = "true";
+		return options$1;
+	};
+}) });
+
+//#endregion
+//#region node_modules/dotenv/config.js
+(function() {
+	require_main().config(Object.assign({}, require_env_options(), require_cli_options()(process.argv)));
+})();
+
 //#endregion
 //#region src/lib/proxy.ts
 function initProxyFromEnv() {
@@ -558,14 +944,14 @@ function initProxyFromEnv() {
 		const direct = new Agent();
 		const proxies = /* @__PURE__ */ new Map();
 		setGlobalDispatcher({
-			dispatch(options, handler) {
+			dispatch(options$1, handler) {
 				try {
-					const origin = typeof options.origin === "string" ? new URL(options.origin) : options.origin;
+					const origin = typeof options$1.origin === "string" ? new URL(options$1.origin) : options$1.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);
+						return direct.dispatch(options$1, handler);
 					}
 					let agent = proxies.get(proxyUrl);
 					if (!agent) {
@@ -578,9 +964,9 @@ function initProxyFromEnv() {
 						label = `${u.protocol}//${u.host}`;
 					} catch {}
 					consola.debug(`HTTP proxy route: ${origin.hostname} via ${label}`);
-					return agent.dispatch(options, handler);
+					return agent.dispatch(options$1, handler);
 				} catch {
-					return direct.dispatch(options, handler);
+					return direct.dispatch(options$1, handler);
 				}
 			},
 			close() {
@@ -846,6 +1232,9 @@ const ANTIGRAVITY_API_HOST$1 = "daily-cloudcode-pa.sandbox.googleapis.com";
 const ANTIGRAVITY_STREAM_URL$1 = `https://${ANTIGRAVITY_API_HOST$1}/v1internal:streamGenerateContent?alt=sse`;
 const ANTIGRAVITY_NO_STREAM_URL$1 = `https://${ANTIGRAVITY_API_HOST$1}/v1internal:generateContent`;
 const ANTIGRAVITY_USER_AGENT$1 = "antigravity/1.11.3 windows/amd64";
+const GEMINI_API_HOST = "generativelanguage.googleapis.com";
+const getGeminiStreamUrl = (model, apiKey) => `https://${GEMINI_API_HOST}/v1beta/models/${model}:streamGenerateContent?alt=sse&key=${apiKey}`;
+const getGeminiNoStreamUrl = (model, apiKey) => `https://${GEMINI_API_HOST}/v1beta/models/${model}:generateContent?key=${apiKey}`;
 /**
 * Convert OpenAI format messages to Antigravity format
 */
@@ -957,11 +1346,40 @@ function createErrorResponse$1(message, type, status, details) {
 	});
 }
 /**
-* Create chat completion with Antigravity
+* Create chat completion with Antigravity or standard Gemini API
+* Priority: API Key > OAuth
 */
 async function createAntigravityChatCompletion(request) {
+	const apiKey = getApiKey();
+	if (apiKey) return await createWithApiKey(request, apiKey);
 	const accessToken = await getValidAccessToken();
-	if (!accessToken) return createErrorResponse$1("No valid Antigravity access token available. Please run login first.", "auth_error", 401);
+	if (!accessToken) return createErrorResponse$1("No valid authentication available. Please set GEMINI_API_KEY environment variable or run OAuth login.", "auth_error", 401);
+	return await createWithOAuth(request, accessToken);
+}
+/**
+* Create chat completion using API Key (standard Gemini API)
+*/
+async function createWithApiKey(request, apiKey) {
+	const endpoint = request.stream ? getGeminiStreamUrl(request.model, apiKey) : getGeminiNoStreamUrl(request.model, apiKey);
+	const body = buildRequestBody(request);
+	consola.debug(`Gemini API request with model ${request.model}`);
+	try {
+		const response = await fetch(endpoint, {
+			method: "POST",
+			headers: { "Content-Type": "application/json" },
+			body: JSON.stringify(body)
+		});
+		if (!response.ok) return await handleApiError$1(response);
+		return request.stream ? transformStreamResponse$1(response, request.model) : await transformNonStreamResponse$1(response, request.model);
+	} catch (error) {
+		consola.error("Gemini API request error:", error);
+		return createErrorResponse$1(`Request failed: ${String(error)}`, "request_error", 500);
+	}
+}
+/**
+* Create chat completion using OAuth (Antigravity private API)
+*/
+async function createWithOAuth(request, accessToken) {
 	const endpoint = request.stream ? ANTIGRAVITY_STREAM_URL$1 : ANTIGRAVITY_NO_STREAM_URL$1;
 	const body = buildRequestBody(request);
 	consola.debug(`Antigravity request to ${endpoint} with model ${request.model}`);
@@ -1882,14 +2300,23 @@ const createChatCompletions = async (payload) => {
 		...copilotHeaders(state, enableVision),
 		"X-Initiator": isAgentCall ? "agent" : "user"
 	};
+	consola.info("Sending request to Copilot:", {
+		model: payload.model,
+		endpoint: `${copilotBaseUrl(state)}/chat/completions`
+	});
 	const response = await fetch(`${copilotBaseUrl(state)}/chat/completions`, {
 		method: "POST",
 		headers,
 		body: JSON.stringify(payload)
 	});
 	if (!response.ok) {
-		consola.error("Failed to create chat completions", response);
-		throw new HTTPError("Failed to create chat completions", response);
+		const errorBody = await response.text();
+		consola.error("Failed to create chat completions", {
+			status: response.status,
+			statusText: response.statusText,
+			body: errorBody
+		});
+		throw new HTTPError(`Failed to create chat completions: ${response.status} ${errorBody}`, response);
 	}
 	if (payload.stream) return events(response);
 	return await response.json();
@@ -2351,18 +2778,13 @@ function translateChunkToAnthropicEvents(chunk, state$1) {
 async function handleCompletion(c) {
 	await checkRateLimit(state);
 	const anthropicPayload = await c.req.json();
-	consola.debug("Anthropic request payload:", JSON.stringify(anthropicPayload));
 	const openAIPayload = translateToOpenAI(anthropicPayload);
-	consola.debug("Translated OpenAI request payload:", JSON.stringify(openAIPayload));
 	if (state.manualApprove) await awaitApproval();
 	const response = await createChatCompletions(openAIPayload);
 	if (isNonStreaming(response)) {
-		consola.debug("Non-streaming response from Copilot:", JSON.stringify(response).slice(-400));
 		const anthropicResponse = translateToAnthropic(response);
-		consola.debug("Translated Anthropic response:", JSON.stringify(anthropicResponse));
 		return c.json(anthropicResponse);
 	}
-	consola.debug("Streaming response from Copilot");
 	return streamSSE(c, async (stream) => {
 		const streamState = {
 			messageStartSent: false,
@@ -2371,18 +2793,14 @@ async function handleCompletion(c) {
 			toolCalls: {}
 		};
 		for await (const rawEvent of response) {
-			consola.debug("Copilot raw stream event:", JSON.stringify(rawEvent));
 			if (rawEvent.data === "[DONE]") break;
 			if (!rawEvent.data) continue;
 			const chunk = JSON.parse(rawEvent.data);
 			const events$1 = translateChunkToAnthropicEvents(chunk, streamState);
-			for (const event of events$1) {
-				consola.debug("Translated Anthropic event:", JSON.stringify(event));
-				await stream.writeSSE({
-					event: event.type,
-					data: JSON.stringify(event)
-				});
-			}
+			for (const event of events$1) await stream.writeSSE({
+				event: event.type,
+				data: JSON.stringify(event)
+			});
 		}
 	});
 }
@@ -2602,35 +3020,75 @@ server.use(logger());
 server.use(cors());
 server.use(apiKeyAuthMiddleware);
 server.get("/", (c) => c.text("Server running"));
-server.route("/chat/completions", new Hono().all("/*", async (c, _next) => {
-	if (state.zenMode) return zenCompletionRoutes.fetch(c.req.raw, c.env);
-	if (state.antigravityMode) return antigravityChatCompletionsRoute.fetch(c.req.raw, c.env);
-	return completionRoutes.fetch(c.req.raw, c.env);
-}));
-server.route("/models", new Hono().all("/*", async (c, _next) => {
-	if (state.zenMode) return zenModelRoutes.fetch(c.req.raw, c.env);
-	if (state.antigravityMode) return antigravityModelsRoute.fetch(c.req.raw, c.env);
-	return modelRoutes.fetch(c.req.raw, c.env);
-}));
+function createSubRequest(c, basePath) {
+	const url = new URL(c.req.url);
+	url.pathname = url.pathname.slice(basePath.length) || "/";
+	return new Request(url.toString(), c.req.raw);
+}
+server.all("/chat/completions/*", async (c) => {
+	const req = createSubRequest(c, "/chat/completions");
+	if (state.zenMode) return zenCompletionRoutes.fetch(req, c.env);
+	if (state.antigravityMode) return antigravityChatCompletionsRoute.fetch(req, c.env);
+	return completionRoutes.fetch(req, c.env);
+});
+server.all("/chat/completions", async (c) => {
+	const req = createSubRequest(c, "/chat/completions");
+	if (state.zenMode) return zenCompletionRoutes.fetch(req, c.env);
+	if (state.antigravityMode) return antigravityChatCompletionsRoute.fetch(req, c.env);
+	return completionRoutes.fetch(req, c.env);
+});
+server.all("/models/*", async (c) => {
+	const req = createSubRequest(c, "/models");
+	if (state.zenMode) return zenModelRoutes.fetch(req, c.env);
+	if (state.antigravityMode) return antigravityModelsRoute.fetch(req, c.env);
+	return modelRoutes.fetch(req, c.env);
+});
+server.all("/models", async (c) => {
+	const req = createSubRequest(c, "/models");
+	if (state.zenMode) return zenModelRoutes.fetch(req, c.env);
+	if (state.antigravityMode) return antigravityModelsRoute.fetch(req, c.env);
+	return modelRoutes.fetch(req, c.env);
+});
 server.route("/embeddings", embeddingRoutes);
 server.route("/usage", usageRoute);
 server.route("/token", tokenRoute);
-server.route("/v1/chat/completions", new Hono().all("/*", async (c, _next) => {
-	if (state.zenMode) return zenCompletionRoutes.fetch(c.req.raw, c.env);
-	if (state.antigravityMode) return antigravityChatCompletionsRoute.fetch(c.req.raw, c.env);
-	return completionRoutes.fetch(c.req.raw, c.env);
-}));
-server.route("/v1/models", new Hono().all("/*", async (c, _next) => {
-	if (state.zenMode) return zenModelRoutes.fetch(c.req.raw, c.env);
-	if (state.antigravityMode) return antigravityModelsRoute.fetch(c.req.raw, c.env);
-	return modelRoutes.fetch(c.req.raw, c.env);
-}));
+server.all("/v1/chat/completions/*", async (c) => {
+	const req = createSubRequest(c, "/v1/chat/completions");
+	if (state.zenMode) return zenCompletionRoutes.fetch(req, c.env);
+	if (state.antigravityMode) return antigravityChatCompletionsRoute.fetch(req, c.env);
+	return completionRoutes.fetch(req, c.env);
+});
+server.all("/v1/chat/completions", async (c) => {
+	const req = createSubRequest(c, "/v1/chat/completions");
+	if (state.zenMode) return zenCompletionRoutes.fetch(req, c.env);
+	if (state.antigravityMode) return antigravityChatCompletionsRoute.fetch(req, c.env);
+	return completionRoutes.fetch(req, c.env);
+});
+server.all("/v1/models/*", async (c) => {
+	const req = createSubRequest(c, "/v1/models");
+	if (state.zenMode) return zenModelRoutes.fetch(req, c.env);
+	if (state.antigravityMode) return antigravityModelsRoute.fetch(req, c.env);
+	return modelRoutes.fetch(req, c.env);
+});
+server.all("/v1/models", async (c) => {
+	const req = createSubRequest(c, "/v1/models");
+	if (state.zenMode) return zenModelRoutes.fetch(req, c.env);
+	if (state.antigravityMode) return antigravityModelsRoute.fetch(req, c.env);
+	return modelRoutes.fetch(req, c.env);
+});
 server.route("/v1/embeddings", embeddingRoutes);
-server.route("/v1/messages", new Hono().all("/*", async (c, _next) => {
-	if (state.zenMode) return zenMessageRoutes.fetch(c.req.raw, c.env);
-	if (state.antigravityMode) return antigravityMessagesRoute.fetch(c.req.raw, c.env);
-	return messageRoutes.fetch(c.req.raw, c.env);
-}));
+server.all("/v1/messages/*", async (c) => {
+	const req = createSubRequest(c, "/v1/messages");
+	if (state.zenMode) return zenMessageRoutes.fetch(req, c.env);
+	if (state.antigravityMode) return antigravityMessagesRoute.fetch(req, c.env);
+	return messageRoutes.fetch(req, c.env);
+});
+server.all("/v1/messages", async (c) => {
+	const req = createSubRequest(c, "/v1/messages");
+	if (state.zenMode) return zenMessageRoutes.fetch(req, c.env);
+	if (state.antigravityMode) return antigravityMessagesRoute.fetch(req, c.env);
+	return messageRoutes.fetch(req, c.env);
+});
 server.route("/zen/v1/chat/completions", zenCompletionRoutes);
 server.route("/zen/v1/models", zenModelRoutes);
 server.route("/zen/v1/messages", zenMessageRoutes);
@@ -2662,29 +3120,32 @@ server.route("/antigravity/v1/messages", antigravityMessagesRoute);
 *   - apiKeys: Optional list of API keys to enable API key authentication
 *   - zen: Enable OpenCode Zen mode (proxy to Zen instead of GitHub Copilot)
 *   - zenApiKey: OpenCode Zen API key (optional; if omitted will prompt for setup)
+*   - antigravity: Enable Google Antigravity mode
+*   - antigravityClientId: Google OAuth Client ID (optional; overrides env/default)
+*   - antigravityClientSecret: Google OAuth Client Secret (optional; overrides env/default)
 */
-async function runServer(options) {
+async function runServer(options$1) {
 	const savedProxyApplied = await applyProxyConfig();
-	if (options.proxyEnv) initProxyFromEnv();
+	if (options$1.proxyEnv) initProxyFromEnv();
 	else if (savedProxyApplied) initProxyFromEnv();
-	if (options.verbose) {
+	if (options$1.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;
-	state.apiKeys = options.apiKeys;
+	state.accountType = options$1.accountType;
+	if (options$1.accountType !== "individual") consola.info(`Using ${options$1.accountType} plan GitHub account`);
+	state.manualApprove = options$1.manual;
+	state.rateLimitSeconds = options$1.rateLimit;
+	state.rateLimitWait = options$1.rateLimitWait;
+	state.showToken = options$1.showToken;
+	state.apiKeys = options$1.apiKeys;
 	if (state.apiKeys && state.apiKeys.length > 0) consola.info(`API key authentication enabled with ${state.apiKeys.length} key(s)`);
 	await ensurePaths();
-	if (options.zen) {
+	if (options$1.zen) {
 		consola.info("OpenCode Zen mode enabled");
 		state.zenMode = true;
-		if (options.zenApiKey) {
-			state.zenApiKey = options.zenApiKey;
+		if (options$1.zenApiKey) {
+			state.zenApiKey = options$1.zenApiKey;
 			consola.info("Using provided Zen API key");
 		} else {
 			const { setupZenApiKey, loadZenAuth } = await import("./auth-BO-mwvoU.js");
@@ -2697,30 +3158,49 @@ async function runServer(options) {
 		const { cacheZenModels } = await import("./get-models-DJfPj_Rg.js");
 		await cacheZenModels();
 		consola.info(`Available Zen models: \n${state.zenModels?.data.map((model) => `- ${model.id}`).join("\n")}`);
-	} else if (options.antigravity) {
+	} else if (options$1.antigravity) {
 		consola.info("Google Antigravity mode enabled");
 		state.antigravityMode = true;
-		const { loadAntigravityAuth, setupAntigravity, getCurrentAccount } = await import("./auth-D2wtETTq.js");
-		const existingAuth = await loadAntigravityAuth();
-		if (!existingAuth || existingAuth.accounts.length === 0) {
-			consola.warn("No Antigravity accounts found");
-			await setupAntigravity();
+		const { loadAntigravityAuth, setupAntigravity, getCurrentAccount, hasApiKey, getApiKey: getApiKey$1, setOAuthCredentials } = await import("./auth-DqWzJajV.js");
+		if (options$1.antigravityClientId && options$1.antigravityClientSecret) {
+			setOAuthCredentials(options$1.antigravityClientId, options$1.antigravityClientSecret);
+			consola.info("Using provided OAuth credentials from CLI");
+		}
+		if (hasApiKey()) {
+			consola.info("Using Gemini API Key for authentication (from GEMINI_API_KEY)");
+			consola.info("API Key: " + getApiKey$1()?.slice(0, 10) + "...");
 		} else {
-			const enabledCount = existingAuth.accounts.filter((a) => a.enable).length;
-			consola.info(`Found ${existingAuth.accounts.length} Antigravity accounts (${enabledCount} enabled)`);
+			const existingAuth = await loadAntigravityAuth();
+			if (!existingAuth || existingAuth.accounts.length === 0) {
+				consola.warn("No Antigravity accounts found and no GEMINI_API_KEY set");
+				consola.info("");
+				consola.info("You can authenticate using one of these methods:");
+				consola.info("");
+				consola.info("Method 1: API Key (Recommended - Simplest)");
+				consola.info("  Set environment variable: GEMINI_API_KEY=your_api_key");
+				consola.info("  Get your API key from: https://aistudio.google.com/apikey");
+				consola.info("");
+				consola.info("Method 2: OAuth (Current setup)");
+				consola.info("  Will proceed with OAuth login flow...");
+				consola.info("");
+				await setupAntigravity();
+			} else {
+				const enabledCount = existingAuth.accounts.filter((a) => a.enable).length;
+				consola.info(`Found ${existingAuth.accounts.length} Antigravity accounts (${enabledCount} enabled)`);
+			}
+			if (!await getCurrentAccount() && !hasApiKey()) throw new Error("No enabled Antigravity accounts available");
 		}
-		if (!await getCurrentAccount()) throw new Error("No enabled Antigravity accounts available");
-		const { getAntigravityModels: getAntigravityModels$1 } = await import("./get-models-Dq2ZDU9m.js");
+		const { getAntigravityModels: getAntigravityModels$1 } = await import("./get-models-BOgYoUAJ.js");
 		const models = await getAntigravityModels$1();
 		state.antigravityModels = models;
 		consola.info(`Available Antigravity models: \n${models.data.map((model) => `- ${model.id}`).join("\n")}`);
 	} else {
 		await cacheVSCodeVersion();
-		if (options.githubToken) {
-			state.githubToken = options.githubToken;
+		if (options$1.githubToken) {
+			state.githubToken = options$1.githubToken;
 			consola.info("Using provided GitHub token");
 			try {
-				const { getGitHubUser } = await import("./get-user-hpkh0FzZ.js");
+				const { getGitHubUser } = await import("./get-user-CsQCc3Qx.js");
 				const user = await getGitHubUser();
 				consola.info(`Logged in as ${user.login}`);
 			} catch (error) {
@@ -2734,7 +3214,7 @@ async function runServer(options) {
 			const { HTTPError: HTTPError$1 } = await import("./error-CsShqJjE.js");
 			if (error instanceof HTTPError$1 && error.response.status === 401) {
 				consola.error("Failed to get Copilot token - GitHub token may be invalid or Copilot access revoked");
-				const { clearGithubToken: clearGithubToken$1 } = await import("./token-DS09XjQ5.js");
+				const { clearGithubToken: clearGithubToken$1 } = await import("./token-DhdRMuOy.js");
 				await clearGithubToken$1();
 				consola.info("Please restart to re-authenticate");
 			}
@@ -2743,8 +3223,8 @@ async function runServer(options) {
 		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) {
+	const serverUrl = `http://localhost:${options$1.port}`;
+	if (options$1.claudeCode) {
 		let models = state.models;
 		if (state.zenMode) models = state.zenModels;
 		else if (state.antigravityMode) models = state.antigravityModels;
@@ -2778,7 +3258,7 @@ async function runServer(options) {
 	consola.box(`🌐 Usage Viewer: https://imbuxiangnan-cyber.github.io/copilot-api-plus?endpoint=${serverUrl}/usage`);
 	serve({
 		fetch: server.fetch,
-		port: options.port
+		port: options$1.port
 	});
 }
 const start = defineCommand({
@@ -2860,6 +3340,14 @@ const start = defineCommand({
 			type: "boolean",
 			default: false,
 			description: "Enable Google Antigravity mode (proxy to Antigravity instead of GitHub Copilot)"
+		},
+		"antigravity-client-id": {
+			type: "string",
+			description: "Google OAuth Client ID for Antigravity (create at https://console.cloud.google.com/apis/credentials)"
+		},
+		"antigravity-client-secret": {
+			type: "string",
+			description: "Google OAuth Client Secret for Antigravity"
 		}
 	},
 	run({ args }) {
@@ -2882,7 +3370,9 @@ const start = defineCommand({
 			apiKeys,
 			zen: args.zen,
 			zenApiKey: args["zen-api-key"],
-			antigravity: args.antigravity
+			antigravity: args.antigravity,
+			antigravityClientId: args["antigravity-client-id"],
+			antigravityClientSecret: args["antigravity-client-secret"]
 		});
 	}
 });