xiaodcs-copilot-api 2.1.0-recovery.1

package/dist/auth-BB3ETAFy.js

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

package/dist/auth-KY033tLZ.js

@@ -0,0 +1,355 @@
+import { M as PATHS, N as ensurePaths, a as normalizeProviderBaseUrl, c as setProviderConfig, n as getRawProviderConfig, r as isSupportedProviderType, y as SUPPORTED_PROVIDER_TYPES } from "./config-RMZKaZqy.js";
+import { B as state, O as loginCodex, a as setupGitHubToken, n as persistCodexCredentials } from "./token--3EQGrXj.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: false
+	},
+	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-BmWaOfKV.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 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"]
+			});
+		}
+	}) },
+	run({ args }) {
+		if ((args._[0] ?? "").trim()) return;
+		return runAuthLogin({
+			provider: args.provider,
+			verbose: args.verbose,
+			showToken: args["show-token"]
+		});
+	}
+});
+//#endregion
+export { runAuthLogin as n, runProviderSetup as r, auth as t };