xiaodcs-copilot-api-edge 2.3.9-edge.0

package/dist/auth-BiVetBYt.js

@@ -0,0 +1,446 @@
+import { F as ensurePaths, N as setConfiguredApiKeys, P as PATHS, a as normalizeProviderBaseUrl, c as setProviderConfig, n as getRawProviderConfig, r as isSupportedProviderType, y as SUPPORTED_PROVIDER_TYPES } from "./config-SytZjLq8.js";
+import { A as getConfiguredApiKeys, K as state, M as loginCodex, a as setupGitHubToken, n as persistCodexCredentials } from "./token-D9svRIYW.js";
+import { defineCommand } from "citty";
+import consola from "consola";
+//#region src/lib/quick-providers.ts
+const QUICK_PROVIDER_CONFIGS = {
+	"opencode-go": {
+		type: "openai-compatible",
+		baseUrl: "https://opencode.ai/zen/go",
+		pricingCurrency: "USD",
+		editableType: false
+	},
+	kimi: {
+		type: "openai-compatible",
+		baseUrl: "https://api.kimi.com/coding",
+		pricingCurrency: "USD",
+		editableType: true
+	},
+	deepseek: {
+		type: "anthropic",
+		baseUrl: "https://api.deepseek.com/anthropic",
+		pricingCurrency: "CNY",
+		editableType: true
+	},
+	dashscope: {
+		type: "openai-compatible",
+		baseUrl: "https://dashscope.aliyuncs.com/compatible-mode",
+		pricingCurrency: "CNY",
+		editableType: true
+	},
+	openrouter: {
+		type: "anthropic",
+		baseUrl: "https://openrouter.ai/api",
+		pricingCurrency: "USD",
+		editableType: false
+	}
+};
+//#endregion
+//#region src/auth.ts
+const authArgs = {
+	provider: {
+		type: "string",
+		description: "Provider to log in with or configure (copilot, codex, opencode-go, kimi, deepseek, dashscope, openrouter, custom)"
+	},
+	verbose: {
+		alias: "v",
+		type: "boolean",
+		default: false,
+		description: "Enable verbose logging"
+	},
+	"show-token": {
+		type: "boolean",
+		default: false,
+		description: "Show provider access token on auth"
+	}
+};
+const BUILTIN_PROVIDER_NAMES = ["copilot", "codex"];
+const QUICK_PROVIDER_NAMES = Object.keys(QUICK_PROVIDER_CONFIGS);
+const AUTH_PROVIDER_NAMES = [
+	...BUILTIN_PROVIDER_NAMES,
+	...QUICK_PROVIDER_NAMES,
+	"custom"
+];
+const CUSTOM_PROVIDER_AUTH_TYPE_OPTION = "__default__";
+const QUICK_PROVIDER_DEFAULT_TYPE_OPTION = "__default__";
+const CUSTOM_PROVIDER_AUTH_TYPES = ["x-api-key", "authorization"];
+const AUTH_PROVIDER_LABELS = {
+	copilot: "GitHub Copilot",
+	codex: "OpenAI Codex",
+	"opencode-go": "OpenCode Go",
+	kimi: "Kimi",
+	deepseek: "DeepSeek",
+	dashscope: "DashScope",
+	openrouter: "OpenRouter",
+	custom: "Custom provider"
+};
+function isAuthProviderName(providerName) {
+	return AUTH_PROVIDER_NAMES.includes(providerName);
+}
+function isCustomProviderAuthType(value) {
+	return CUSTOM_PROVIDER_AUTH_TYPES.includes(value);
+}
+function isQuickProviderName(providerName) {
+	return QUICK_PROVIDER_NAMES.includes(providerName);
+}
+async function resolveProviderSelection(providerArg) {
+	const availableProviders = [...AUTH_PROVIDER_NAMES];
+	if (providerArg !== void 0) {
+		const providerName = providerArg.trim();
+		if (!isAuthProviderName(providerName)) throw new Error(`Unknown provider '${providerArg}'. Expected one of: ${availableProviders.join(", ")}`);
+		return providerName;
+	}
+	if (availableProviders.length === 1) return availableProviders[0];
+	const provider = await consola.prompt("Select a provider to log in with", {
+		type: "select",
+		options: availableProviders.map((providerName) => ({
+			label: `${AUTH_PROVIDER_LABELS[providerName]} (${providerName})`,
+			value: providerName
+		}))
+	});
+	if (!provider || !isAuthProviderName(provider)) throw new Error("No provider selected");
+	return provider;
+}
+function assertCustomProviderName(providerName) {
+	if (!providerName) throw new Error("Provider name must be a non-empty string");
+	if (!/^[A-Za-z0-9][A-Za-z0-9_-]*$/u.test(providerName)) throw new Error("Provider name must start with a letter or number and contain only letters, numbers, underscores, or hyphens");
+	if (providerName === "copilot" || providerName === "codex") throw new Error(`Provider name '${providerName}' is reserved for a builtin provider`);
+}
+async function promptRequiredText(message, fieldName) {
+	const value = await consola.prompt(message, { type: "text" });
+	const normalizedValue = typeof value === "string" ? value.trim() : "";
+	if (!normalizedValue) throw new Error(`${fieldName} must be a non-empty string`);
+	return normalizedValue;
+}
+function canUseMaskedPrompt() {
+	return Boolean(process.stdin.isTTY && process.stdout.isTTY && typeof process.stdin.setRawMode === "function");
+}
+async function promptMaskedText(message) {
+	if (!canUseMaskedPrompt()) {
+		const value = await consola.prompt(message, { type: "text" });
+		return typeof value === "string" ? value : "";
+	}
+	return await new Promise((resolve, reject) => {
+		let value = "";
+		const rawModeWasEnabled = process.stdin.isRaw === true;
+		function cleanup() {
+			process.stdin.off("data", onData);
+			process.stdin.setRawMode(rawModeWasEnabled);
+			process.stdin.pause();
+		}
+		function finish() {
+			cleanup();
+			process.stdout.write("\n");
+			resolve(value);
+		}
+		function cancel() {
+			cleanup();
+			process.stdout.write("\n");
+			reject(/* @__PURE__ */ new Error("Prompt cancelled"));
+		}
+		function onData(chunk) {
+			const input = chunk.toString("utf8");
+			if (input.startsWith("\x1B")) return;
+			for (const char of input) {
+				if (char === "") {
+					cancel();
+					return;
+				}
+				if (char === "\r" || char === "\n") {
+					finish();
+					return;
+				}
+				if (char === "\b" || char === "") {
+					if (value.length > 0) {
+						value = value.slice(0, -1);
+						process.stdout.write("\b \b");
+					}
+					continue;
+				}
+				if (char >= " ") {
+					value += char;
+					process.stdout.write("*");
+				}
+			}
+		}
+		process.stdout.write(`${message}: `);
+		process.stdin.setRawMode(true);
+		process.stdin.resume();
+		process.stdin.on("data", onData);
+	});
+}
+async function promptRequiredSecret(message, fieldName) {
+	const normalizedValue = (await promptMaskedText(message)).trim();
+	if (!normalizedValue) throw new Error(`${fieldName} must be a non-empty string`);
+	return normalizedValue;
+}
+async function promptCustomProviderName() {
+	const providerName = await promptRequiredText("Enter provider name", "Provider name");
+	assertCustomProviderName(providerName);
+	return providerName;
+}
+async function promptCustomProviderType() {
+	const providerType = await consola.prompt("Select provider type", {
+		type: "select",
+		options: SUPPORTED_PROVIDER_TYPES.map((type) => ({
+			label: type,
+			value: type
+		}))
+	});
+	if (typeof providerType !== "string" || !isSupportedProviderType(providerType)) throw new Error("No provider type selected");
+	return providerType;
+}
+async function promptQuickProviderType(defaultType) {
+	const providerType = await consola.prompt(`Select provider type (default: ${defaultType})`, {
+		type: "select",
+		options: [{
+			label: `Default (${defaultType})`,
+			value: QUICK_PROVIDER_DEFAULT_TYPE_OPTION
+		}, ...SUPPORTED_PROVIDER_TYPES.map((type) => ({
+			label: type,
+			value: type
+		}))]
+	});
+	if (providerType === QUICK_PROVIDER_DEFAULT_TYPE_OPTION) return defaultType;
+	if (typeof providerType === "string" && isSupportedProviderType(providerType)) return providerType;
+	throw new Error("No provider type selected");
+}
+function getDefaultProviderAuthType(providerType) {
+	return providerType === "anthropic" ? "x-api-key" : "authorization";
+}
+async function promptCustomProviderAuthType(providerType) {
+	const defaultAuthType = getDefaultProviderAuthType(providerType);
+	const authType = await consola.prompt("Select provider auth type", {
+		type: "select",
+		options: [{
+			label: `Default (${defaultAuthType})`,
+			value: CUSTOM_PROVIDER_AUTH_TYPE_OPTION
+		}, ...CUSTOM_PROVIDER_AUTH_TYPES.map((value) => ({
+			label: value,
+			value
+		}))]
+	});
+	if (authType === CUSTOM_PROVIDER_AUTH_TYPE_OPTION) return;
+	if (typeof authType === "string" && isCustomProviderAuthType(authType)) return authType;
+	throw new Error("No provider auth type selected");
+}
+async function promptQuickProviderBaseUrl(defaultBaseUrl) {
+	const value = await consola.prompt(`Enter provider baseUrl (default: ${defaultBaseUrl})`, {
+		type: "text",
+		default: defaultBaseUrl,
+		initial: defaultBaseUrl
+	});
+	const baseUrl = normalizeProviderBaseUrl(typeof value === "string" && value.trim() ? value : defaultBaseUrl);
+	if (!baseUrl) throw new Error("baseUrl must be a non-empty string");
+	return baseUrl;
+}
+function buildCustomProviderConfig(existingProviderConfig, options) {
+	return {
+		type: options.type,
+		enabled: true,
+		baseUrl: options.baseUrl,
+		apiKey: options.apiKey,
+		...options.authType ? { authType: options.authType } : {},
+		pricingCurrency: options.pricingCurrency ?? existingProviderConfig.pricingCurrency,
+		...existingProviderConfig.models ? { models: existingProviderConfig.models } : {}
+	};
+}
+async function configureCustomProvider() {
+	const providerName = await promptCustomProviderName();
+	const type = await promptCustomProviderType();
+	const baseUrl = normalizeProviderBaseUrl(await promptRequiredText("Enter provider baseUrl", "baseUrl"));
+	if (!baseUrl) throw new Error("baseUrl must be a non-empty string");
+	const apiKey = await promptRequiredSecret("Enter provider apiKey", "apiKey");
+	const authType = await promptCustomProviderAuthType(type);
+	setProviderConfig(providerName, buildCustomProviderConfig(getRawProviderConfig(providerName) ?? {}, {
+		apiKey,
+		authType,
+		baseUrl,
+		type
+	}));
+	consola.success(`Custom provider '${providerName}' written to ${PATHS.CONFIG_PATH}`);
+}
+async function configureQuickProvider(providerName) {
+	const defaultProviderConfig = QUICK_PROVIDER_CONFIGS[providerName];
+	const apiKey = await promptRequiredSecret(`Enter ${providerName} apiKey`, "apiKey");
+	const type = defaultProviderConfig.editableType ? await promptQuickProviderType(defaultProviderConfig.type) : defaultProviderConfig.type;
+	const baseUrl = await promptQuickProviderBaseUrl(defaultProviderConfig.baseUrl);
+	setProviderConfig(providerName, buildCustomProviderConfig(getRawProviderConfig(providerName) ?? {}, {
+		apiKey,
+		baseUrl,
+		pricingCurrency: defaultProviderConfig.pricingCurrency,
+		type
+	}));
+	consola.success(`${AUTH_PROVIDER_LABELS[providerName]} provider '${providerName}' written to ${PATHS.CONFIG_PATH}`);
+}
+async function loginWithCodex() {
+	await persistCodexCredentials(await loginCodex({
+		onAuth(info) {
+			consola.info("Open the following URL to authenticate with Codex:");
+			consola.log(info.url);
+			if (info.instructions) consola.info(info.instructions);
+		},
+		onPrompt(message) {
+			return consola.prompt(message, { type: "text" });
+		},
+		onProgress(message) {
+			consola.debug(message);
+		}
+	}), { enableProvider: true });
+	consola.success(`Codex provider config written to ${PATHS.CONFIG_PATH} and credentials written to ${PATHS.CODEX_CREDENTIAL_PATH}`);
+}
+async function loginWithProvider(provider) {
+	if (provider === "copilot") {
+		await setupGitHubToken({ force: true });
+		consola.success("GitHub token written to", PATHS.GITHUB_TOKEN_PATH);
+		return;
+	}
+	if (provider === "codex") {
+		await loginWithCodex();
+		return;
+	}
+	if (isQuickProviderName(provider)) {
+		await configureQuickProvider(provider);
+		return;
+	}
+	await configureCustomProvider();
+}
+async function runProviderSetup() {
+	const provider = await resolveProviderSelection(void 0);
+	consola.info(`Logging in with ${AUTH_PROVIDER_LABELS[provider]}`);
+	await loginWithProvider(provider);
+}
+async function runAuthLogin(options) {
+	(await import("./tls-Aq1Dd8E2.js")).enableSystemCACompat();
+	if (options.verbose) {
+		consola.level = 5;
+		consola.info("Verbose logging enabled");
+	}
+	state.showToken = options.showToken;
+	await ensurePaths();
+	const provider = await resolveProviderSelection(options.provider);
+	consola.info(`Logging in with ${AUTH_PROVIDER_LABELS[provider]}`);
+	await loginWithProvider(provider);
+}
+const authKeysArgs = {
+	add: {
+		alias: "a",
+		type: "string",
+		description: "Add an API key for gateway authentication"
+	},
+	remove: {
+		alias: "r",
+		type: "string",
+		description: "Remove an API key"
+	},
+	list: {
+		alias: "l",
+		type: "boolean",
+		default: false,
+		description: "List configured API keys"
+	},
+	clear: {
+		type: "boolean",
+		default: false,
+		description: "Remove all configured API keys"
+	}
+};
+function normalizeAuthKeyValue(value) {
+	const normalizedKey = value.trim();
+	if (!normalizedKey) throw new Error("API key must be a non-empty string");
+	return normalizedKey;
+}
+async function runAuthKeys(options) {
+	(await import("./tls-Aq1Dd8E2.js")).enableSystemCACompat();
+	await ensurePaths();
+	const operations = [
+		...options.add !== void 0 ? ["add"] : [],
+		...options.remove !== void 0 ? ["remove"] : [],
+		...options.list ? ["list"] : [],
+		...options.clear ? ["clear"] : []
+	];
+	if (operations.length > 1) throw new Error("Use only one of --add, --remove, --list, or --clear per invocation");
+	const operation = operations[0] ?? "list";
+	if (operation === "add") {
+		const apiKey = normalizeAuthKeyValue(options.add ?? "");
+		const currentKeys = getConfiguredApiKeys();
+		if (currentKeys.includes(apiKey)) {
+			consola.info(`API key already configured. ${currentKeys.length} API key(s) configured.`);
+			return;
+		}
+		const storedKeys = setConfiguredApiKeys([...currentKeys, apiKey]);
+		consola.success(`API key added to ${PATHS.CONFIG_PATH}. ${storedKeys.length} API key(s) configured.`);
+		return;
+	}
+	if (operation === "remove") {
+		const apiKey = normalizeAuthKeyValue(options.remove ?? "");
+		const currentKeys = getConfiguredApiKeys();
+		if (!currentKeys.includes(apiKey)) {
+			consola.info(`API key not found. ${currentKeys.length} API key(s) configured.`);
+			return;
+		}
+		const storedKeys = setConfiguredApiKeys(currentKeys.filter((key) => key !== apiKey));
+		consola.success(`API key removed from ${PATHS.CONFIG_PATH}. ${storedKeys.length} API key(s) configured.`);
+		return;
+	}
+	if (operation === "clear") {
+		setConfiguredApiKeys([]);
+		consola.success(`Removed all API keys from ${PATHS.CONFIG_PATH}.`);
+		return;
+	}
+	const currentKeys = getConfiguredApiKeys();
+	if (currentKeys.length === 0) {
+		consola.info("No API keys configured. Run `npx copilot-api auth keys --add <key>` to add one.");
+		return;
+	}
+	consola.info("Configured API keys:");
+	for (const key of currentKeys) consola.info(`- ${key}`);
+}
+const auth = defineCommand({
+	meta: {
+		name: "auth",
+		description: "Run authentication flows without running the server"
+	},
+	args: authArgs,
+	subCommands: {
+		login: defineCommand({
+			meta: {
+				name: "login",
+				description: "Authenticate or configure a provider without running the server"
+			},
+			args: authArgs,
+			run({ args }) {
+				return runAuthLogin({
+					provider: args.provider,
+					verbose: args.verbose,
+					showToken: args["show-token"]
+				});
+			}
+		}),
+		keys: defineCommand({
+			meta: {
+				name: "keys",
+				description: "Manage gateway API keys (auth.apiKeys) in the config"
+			},
+			args: authKeysArgs,
+			run({ args }) {
+				return runAuthKeys({
+					add: args.add,
+					remove: args.remove,
+					list: args.list,
+					clear: args.clear
+				});
+			}
+		})
+	},
+	run({ args }) {
+		if ((args._[0] ?? "").trim()) return;
+		return runAuthLogin({
+			provider: args.provider,
+			verbose: args.verbose,
+			showToken: args["show-token"]
+		});
+	}
+});
+//#endregion
+export { runProviderSetup as i, runAuthKeys as n, runAuthLogin as r, auth as t };

package/dist/auth-Bu4MXadr.js

@@ -0,0 +1,2 @@
+import { t as auth } from "./auth-BiVetBYt.js";
+export { auth };