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

package/dist/start-FFVCi8su.js

@@ -0,0 +1,528 @@
+import { F as ensurePaths, M as mergeConfigWithDefaults, i as listEnabledProviders } from "./config-SytZjLq8.js";
+import { K as state, S as initOpencodeVersion, _ as copilotModelsHeaders, h as copilotBaseUrl, i as setupCopilotToken, j as getMissingApiKeysMessage, m as readGitHubToken, q as HTTPError, t as logUser } from "./token-D9svRIYW.js";
+import { i as runProviderSetup } from "./auth-BiVetBYt.js";
+import { n as getLatestModelForFamily } from "./models-YMUf33c-.js";
+import { defineCommand } from "citty";
+import consola from "consola";
+import { createHash, randomUUID } from "node:crypto";
+import path from "node:path";
+import { networkInterfaces } from "node:os";
+import { getProxyForUrl } from "proxy-from-env";
+import { Agent, ProxyAgent, setGlobalDispatcher } from "undici";
+import { execSync } from "node:child_process";
+import clipboard from "clipboardy";
+import { serve } from "srvx";
+import invariant from "tiny-invariant";
+import process$1 from "node:process";
+//#region src/lib/proxy.ts
+let proxyEnvDispatcher;
+function initProxyFromEnv() {
+	try {
+		const direct = new Agent();
+		const proxies = /* @__PURE__ */ new Map();
+		proxyEnvDispatcher = {
+			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();
+			}
+		};
+		if (typeof Bun !== "undefined") {
+			consola.debug("WebSocket proxy configured from environment (per-URL)");
+			return;
+		}
+		setGlobalDispatcher(proxyEnvDispatcher);
+		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 {
+			if (execSync(`wmic process get ParentProcessId,Name | findstr "${ppid}"`, { 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/services/copilot/get-models.ts
+const getModels = async () => {
+	consola.info(`Fetching models from ${copilotBaseUrl(state)}/models`);
+	const response = await fetch(`${copilotBaseUrl(state)}/models`, { headers: copilotModelsHeaders(state) });
+	if (!response.ok) {
+		const errorText = await response.clone().text();
+		consola.error("Failed to get models response body", errorText);
+		throw new HTTPError("Failed to get models", response);
+	}
+	return await response.json();
+};
+//#endregion
+//#region src/services/copilot/models-cache.ts
+const MODELS_REFRESH_BASE_MS = 1800 * 1e3;
+let modelsRefreshTimer = null;
+const stopModelsRefreshLoop = () => {
+	if (modelsRefreshTimer) {
+		clearTimeout(modelsRefreshTimer);
+		modelsRefreshTimer = null;
+	}
+};
+const refreshModels = async (fetcher) => {
+	const prevIds = new Set(state.models?.data.map((m) => m.id) ?? []);
+	const models = await fetcher();
+	state.models = {
+		...models,
+		data: models.data.filter((model) => model.policy?.state !== "disabled" && (model.model_picker_enabled || model.capabilities.type === "embeddings"))
+	};
+	const nextIds = state.models.data.map((m) => m.id);
+	const added = nextIds.filter((id) => !prevIds.has(id));
+	if (added.length > 0) consola.info(`Models refresh: ${added.length} new`);
+	else consola.debug(`Models refresh: no changes (${nextIds.length} total)`);
+};
+const scheduleModelsRefresh = (fetcher, intervalMs) => {
+	const delay = intervalMs + Math.floor(Math.random() * (intervalMs / 6));
+	consola.debug(`Scheduling next models refresh in ${Math.round(delay / 1e3)} seconds`);
+	stopModelsRefreshLoop();
+	modelsRefreshTimer = setTimeout(async () => {
+		try {
+			await refreshModels(fetcher);
+		} catch (error) {
+			consola.warn("Failed to refresh models, keeping previous cache.", error);
+		} finally {
+			scheduleModelsRefresh(fetcher, intervalMs);
+		}
+	}, delay);
+};
+async function cacheModels(fetcher = getModels, intervalMs = MODELS_REFRESH_BASE_MS) {
+	await refreshModels(fetcher);
+	scheduleModelsRefresh(fetcher, intervalMs);
+}
+//#endregion
+//#region src/lib/deviceid.ts
+const WINDOWS_DEVICE_ID_KEY = String.raw`\SOFTWARE\Microsoft\DeveloperTools`;
+const WINDOWS_DEVICE_ID_NAME = "deviceid";
+const windows64Architectures = new Set([
+	"AMD64",
+	"ARM64",
+	"IA64"
+]);
+const getPosixHomeDir = () => {
+	if (!process.env.HOME) throw new Error("Home directory not found");
+	return process.env.HOME;
+};
+const getDeviceIdFilePath = () => {
+	let folder;
+	switch (process.platform) {
+		case "darwin":
+			folder = path.posix.join(getPosixHomeDir(), "Library", "Application Support");
+			break;
+		case "linux":
+			folder = process.env.XDG_CACHE_HOME ?? path.posix.join(getPosixHomeDir(), ".cache");
+			break;
+		default: throw new Error("Unsupported platform");
+	}
+	return path.posix.join(folder, "Microsoft", "DeveloperTools", "deviceid");
+};
+const isMissingFileError = (error) => {
+	return error instanceof Error && "code" in error && error.code === "ENOENT";
+};
+const readStoredDeviceIdFile = async (filePath) => {
+	const { readFile } = await import("node:fs/promises");
+	try {
+		return await readFile(filePath, "utf8");
+	} catch (error) {
+		if (isMissingFileError(error)) return;
+		throw error;
+	}
+};
+const writeStoredDeviceIdFile = async (filePath, deviceId) => {
+	const { mkdir, writeFile } = await import("node:fs/promises");
+	await mkdir(path.posix.dirname(filePath), { recursive: true });
+	await writeFile(filePath, deviceId, "utf8");
+};
+const getWindowsRegistryArch = () => {
+	const architecture = (process.env.PROCESSOR_ARCHITEW6432 ?? process.env.PROCESSOR_ARCHITECTURE)?.toUpperCase();
+	return architecture && windows64Architectures.has(architecture) ? "x64" : void 0;
+};
+const loadWinreg = async () => {
+	const module = await import("winreg");
+	return "default" in module ? module.default : module;
+};
+const isMissingRegistryError = (error) => {
+	if (!error) return false;
+	const errorCode = Number(error.code);
+	return Number.isFinite(errorCode) && errorCode === 1;
+};
+const createWindowsRegistry = async () => {
+	const Winreg = await loadWinreg();
+	return {
+		registry: new Winreg({
+			hive: Winreg.HKCU,
+			key: WINDOWS_DEVICE_ID_KEY,
+			arch: getWindowsRegistryArch()
+		}),
+		regSz: Winreg.REG_SZ
+	};
+};
+const readRegistryString = async (registry, name) => {
+	return new Promise((resolve, reject) => {
+		registry.get(name, (error, item) => {
+			if (isMissingRegistryError(error)) {
+				resolve(void 0);
+				return;
+			}
+			if (error) {
+				reject(error instanceof Error ? error : /* @__PURE__ */ new Error("Unknown registry error"));
+				return;
+			}
+			resolve(item?.value);
+		});
+	});
+};
+const writeRegistryString = async ({ registry, regSz, name, value }) => {
+	return new Promise((resolve, reject) => {
+		registry.set(name, regSz, value, (error) => {
+			if (error) {
+				reject(error instanceof Error ? error : /* @__PURE__ */ new Error("Unknown registry error"));
+				return;
+			}
+			resolve();
+		});
+	});
+};
+const getStoredVSCodeDeviceId = async () => {
+	switch (process.platform) {
+		case "win32": {
+			const { registry } = await createWindowsRegistry();
+			return readRegistryString(registry, WINDOWS_DEVICE_ID_NAME);
+		}
+		case "darwin":
+		case "linux": return readStoredDeviceIdFile(getDeviceIdFilePath());
+		default: throw new Error("Unsupported platform");
+	}
+};
+const setStoredVSCodeDeviceId = async (deviceId) => {
+	switch (process.platform) {
+		case "win32": {
+			const { registry, regSz } = await createWindowsRegistry();
+			await writeRegistryString({
+				registry,
+				regSz,
+				name: WINDOWS_DEVICE_ID_NAME,
+				value: deviceId
+			});
+			return;
+		}
+		case "darwin":
+		case "linux":
+			await writeStoredDeviceIdFile(getDeviceIdFilePath(), deviceId);
+			return;
+		default: throw new Error("Unsupported platform");
+	}
+};
+const createVSCodeDeviceId = () => randomUUID().toLowerCase();
+async function getVSCodeDeviceId() {
+	let deviceId;
+	try {
+		deviceId = await getStoredVSCodeDeviceId();
+	} catch (error) {
+		consola.debug("Failed to read VSCode device id", error);
+	}
+	if (deviceId) return deviceId;
+	const newDeviceId = createVSCodeDeviceId();
+	try {
+		await setStoredVSCodeDeviceId(newDeviceId);
+	} catch (error) {
+		consola.warn("Failed to persist VSCode device id, using ephemeral id", error);
+	}
+	return newDeviceId;
+}
+//#endregion
+//#region src/services/get-vscode-version.ts
+const FALLBACK = "1.130.0";
+async function getVSCodeVersion() {
+	await Promise.resolve();
+	return FALLBACK;
+}
+//#endregion
+//#region src/services/vscode-env.ts
+const cacheVSCodeVersion = async () => {
+	const response = await getVSCodeVersion();
+	state.vsCodeVersion = response;
+	consola.info(`Using VSCode version: ${response}`);
+};
+const invalidMacAddresses = new Set([
+	"00:00:00:00:00:00",
+	"ff:ff:ff:ff:ff:ff",
+	"ac:de:48:00:11:22"
+]);
+function validateMacAddress(candidate) {
+	const tempCandidate = candidate.replaceAll("-", ":").toLowerCase();
+	return !invalidMacAddresses.has(tempCandidate);
+}
+function getMac() {
+	const ifaces = networkInterfaces();
+	for (const name in ifaces) {
+		const networkInterface = ifaces[name];
+		if (networkInterface) {
+			for (const { mac } of networkInterface) if (validateMacAddress(mac)) return mac;
+		}
+	}
+	return null;
+}
+const cacheMacMachineId = () => {
+	const macAddress = getMac() ?? randomUUID();
+	state.macMachineId = createHash("sha256").update(macAddress, "utf8").digest("hex");
+	consola.debug(`Using machine ID: ${state.macMachineId}`);
+};
+const cacheVsCodeDeviceId = async () => {
+	state.vsCodeDeviceId = await getVSCodeDeviceId();
+	consola.debug(`Using VSCode device ID: ${state.vsCodeDeviceId}`);
+};
+const SESSION_REFRESH_BASE_MS = 3600 * 1e3;
+const SESSION_REFRESH_JITTER_MS = 1200 * 1e3;
+let vsCodeSessionRefreshTimer = null;
+const generateSessionId = () => {
+	state.vsCodeSessionId = randomUUID() + Date.now().toString();
+	consola.debug(`Generated VSCode session ID: ${state.vsCodeSessionId}`);
+};
+const stopVsCodeSessionRefreshLoop = () => {
+	if (vsCodeSessionRefreshTimer) {
+		clearTimeout(vsCodeSessionRefreshTimer);
+		vsCodeSessionRefreshTimer = null;
+	}
+};
+const scheduleSessionIdRefresh = () => {
+	const delay = SESSION_REFRESH_BASE_MS + Math.floor(Math.random() * SESSION_REFRESH_JITTER_MS);
+	consola.debug(`Scheduling next VSCode session ID refresh in ${Math.round(delay / 1e3)} seconds`);
+	stopVsCodeSessionRefreshLoop();
+	vsCodeSessionRefreshTimer = setTimeout(() => {
+		try {
+			generateSessionId();
+		} catch (error) {
+			consola.error("Failed to refresh session ID, rescheduling...", error);
+		} finally {
+			scheduleSessionIdRefresh();
+		}
+	}, delay);
+};
+const cacheVsCodeSessionId = () => {
+	stopVsCodeSessionRefreshLoop();
+	generateSessionId();
+	scheduleSessionIdRefresh();
+};
+//#endregion
+//#region src/start.ts
+async function setupCopilotMode(githubToken, fromCli, serverUrl, claudeCode) {
+	state.githubToken = githubToken;
+	consola.info(fromCli ? "Using provided GitHub token" : "Using GitHub token from local file");
+	await logUser();
+	await cacheVSCodeVersion();
+	cacheMacMachineId();
+	cacheVsCodeSessionId();
+	await cacheVsCodeDeviceId();
+	await setupCopilotToken();
+	await cacheModels();
+	consola.info(`Available models: \n${state.models?.data.map((model) => `- ${model.id}`).join("\n")}`);
+	if (claudeCode) runClaudeCode(serverUrl);
+}
+function runClaudeCode(serverUrl) {
+	consola.log("\n💡 Tip: The --claude-code flag simply generates a clipboard command for launching Claude Code. \nAll models remain fully accessible without this flag, just configure the model ID directly in your settings.json file.");
+	invariant(state.models, "Models should be loaded by now");
+	const opusModel = getLatestModelForFamily("opus")?.id;
+	const sonnetModel = getLatestModelForFamily("sonnet")?.id;
+	const haikuModel = getLatestModelForFamily("haiku")?.id;
+	consola.info(`Selected default Claude Code models:
+- Opus:   ${opusModel ?? "(none available)"}\n- Sonnet: ${sonnetModel ?? "(none available)"}\n- Haiku:  ${haikuModel ?? "(none available)"}`);
+	const command = generateEnvScript({
+		ANTHROPIC_BASE_URL: serverUrl,
+		ANTHROPIC_AUTH_TOKEN: "dummy",
+		ANTHROPIC_MODEL: sonnetModel ?? opusModel,
+		ANTHROPIC_DEFAULT_OPUS_MODEL: opusModel,
+		ANTHROPIC_DEFAULT_SONNET_MODEL: sonnetModel,
+		ANTHROPIC_DEFAULT_HAIKU_MODEL: haikuModel,
+		CLAUDE_CODE_USE_VERTEX: "0",
+		CLAUDE_CODE_USE_BEDROCK: "0",
+		DISABLE_NON_ESSENTIAL_MODEL_CALLS: "1",
+		CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1",
+		CLAUDE_CODE_ATTRIBUTION_HEADER: "0",
+		CLAUDE_CODE_ENABLE_PROMPT_SUGGESTION: "false",
+		CLAUDE_CODE_DISABLE_TERMINAL_TITLE: "true",
+		CLAUDE_CODE_ENABLE_AWAY_SUMMARY: "0",
+		CLAUDE_CODE_TOTAL_TOKENS_REMINDER: "off",
+		CLAUDE_CODE_EFFORT_LEVEL: "max",
+		MCP_CONNECT_TIMEOUT_MS: "20000"
+	}, "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);
+	}
+}
+async function setupProviderMode(serverUrl, claudeCode) {
+	const enabledProviders = listEnabledProviders();
+	if (enabledProviders.length > 0) {
+		consola.info(`Using enabled providers: ${enabledProviders.join(", ")}`);
+		return;
+	}
+	consola.info("No enabled providers found. Setting one up...");
+	await runProviderSetup();
+	if (state.githubToken) {
+		await setupCopilotMode(state.githubToken, false, serverUrl, claudeCode);
+		return;
+	}
+	const providersAfterSetup = listEnabledProviders();
+	if (providersAfterSetup.length === 0) throw new Error("Failed to configure any provider. Run `copilot-api auth login` to set one up.");
+	consola.info(`Configured providers: ${providersAfterSetup.join(", ")}`);
+}
+async function runServer(options) {
+	(await import("./tls-Aq1Dd8E2.js")).enableSystemCACompat();
+	consola.options.throttle = 0;
+	mergeConfigWithDefaults();
+	const missingApiKeysMessage = getMissingApiKeysMessage();
+	if (missingApiKeysMessage) consola.info(missingApiKeysMessage);
+	await initOpencodeVersion();
+	if (options.proxyEnv) initProxyFromEnv();
+	state.verbose = options.verbose;
+	if (options.verbose) {
+		consola.level = 5;
+		consola.info("Verbose logging enabled");
+	}
+	state.showToken = options.showToken;
+	await ensurePaths();
+	const serverUrl = `http://localhost:${options.port}`;
+	const githubToken = options.githubToken || await readGitHubToken();
+	if (githubToken) await setupCopilotMode(githubToken, Boolean(options.githubToken), serverUrl, options.claudeCode);
+	else await setupProviderMode(serverUrl, options.claudeCode);
+	consola.box(`🌐 Usage Viewer: ${serverUrl}/usage-viewer?endpoint=${serverUrl}/usage`);
+	const { server } = await import("./server-CFQmvoAJ.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"
+		},
+		"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 }) {
+		return runServer({
+			port: Number.parseInt(args.port, 10),
+			verbose: args.verbose,
+			githubToken: args["github-token"],
+			claudeCode: args["claude-code"],
+			showToken: args["show-token"],
+			proxyEnv: args["proxy-env"]
+		});
+	}
+});
+//#endregion
+export { start };

package/dist/tls-Aq1Dd8E2.js

@@ -0,0 +1,14 @@
+import consola from "consola";
+import tls from "node:tls";
+//#region src/lib/tls.ts
+function enableSystemCACompat() {
+	if (!(typeof Bun !== "undefined")) try {
+		const defaultCerts = tls.getCACertificates("default");
+		const systemCerts = tls.getCACertificates("system");
+		tls.setDefaultCACertificates([...defaultCerts, ...systemCerts]);
+	} catch {
+		consola.log("[tls] system ca not available");
+	}
+}
+//#endregion
+export { enableSystemCACompat };