@nick3/copilot-api 1.0.3

package/dist/accounts-manager-CxuKJ4qv.js

@@ -0,0 +1,1326 @@
+import consola from "consola";
+import fs from "node:fs/promises";
+import { z } from "zod";
+import os from "node:os";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import fs$1 from "node:fs";
+
+//#region src/lib/paths.ts
+const APP_DIR = path.join(os.homedir(), ".local", "share", "copilot-api");
+const GITHUB_TOKEN_PATH = path.join(APP_DIR, "github_token");
+const CONFIG_PATH = path.join(APP_DIR, "config.json");
+const MODELS_PATH = path.join(APP_DIR, "models.json");
+const TOKENS_DIR = path.join(APP_DIR, "tokens");
+const ACCOUNTS_REGISTRY_PATH = path.join(APP_DIR, "accounts-registry.json");
+const PATHS = {
+	APP_DIR,
+	GITHUB_TOKEN_PATH,
+	CONFIG_PATH,
+	MODELS_PATH,
+	TOKENS_DIR,
+	ACCOUNTS_REGISTRY_PATH
+};
+/**
+* Get the token file path for a specific account.
+* @param id - The account ID (GitHub login)
+* @returns The absolute path to the account's token file
+*/
+function accountTokenPath(id) {
+	return path.join(TOKENS_DIR, `github_${id}`);
+}
+async function ensurePaths() {
+	await fs.mkdir(PATHS.APP_DIR, { recursive: true });
+	await fs.mkdir(PATHS.TOKENS_DIR, { recursive: true });
+	await ensureFile(PATHS.GITHUB_TOKEN_PATH);
+	await ensureFile(PATHS.CONFIG_PATH);
+}
+async function ensureFile(filePath) {
+	try {
+		await fs.access(filePath, fs.constants.W_OK);
+	} catch {
+		await fs.writeFile(filePath, "");
+		await fs.chmod(filePath, 384);
+	}
+}
+
+//#endregion
+//#region src/lib/accounts-registry.ts
+/**
+* Validate account ID (GitHub login).
+* Rules:
+* - Only alphanumeric characters or single hyphens
+* - 1-39 chars
+* - Cannot begin or end with a hyphen
+* - No consecutive hyphens
+*/
+function validateAccountId(id) {
+	if (id.length === 0 || id.length > 39) return false;
+	if (!/^[a-z0-9-]+$/i.test(id)) return false;
+	if (id.startsWith("-") || id.endsWith("-")) return false;
+	if (id.includes("--")) return false;
+	return true;
+}
+const accountMetaSchema = z.object({
+	id: z.string().refine(validateAccountId, { message: "Invalid account id. Expected a GitHub login (1-39 chars, alphanumeric or single hyphens, no leading/trailing hyphen, no consecutive hyphens)." }),
+	accountType: z.enum([
+		"individual",
+		"business",
+		"enterprise"
+	]),
+	addedAt: z.number()
+});
+const accountRegistrySchema = z.object({
+	version: z.literal(1),
+	accounts: z.array(accountMetaSchema)
+});
+/**
+* Create an empty registry with the current schema version.
+*/
+function createEmptyRegistry() {
+	return {
+		version: 1,
+		accounts: []
+	};
+}
+/**
+* Load the accounts registry from disk.
+* Returns an empty registry if the file doesn't exist.
+*/
+async function loadRegistry() {
+	try {
+		const content = await fs.readFile(PATHS.ACCOUNTS_REGISTRY_PATH, "utf8");
+		if (!content.trim()) return createEmptyRegistry();
+		let parsed;
+		try {
+			parsed = JSON.parse(content);
+		} catch (error) {
+			throw new Error(`Invalid accounts registry JSON at ${PATHS.ACCOUNTS_REGISTRY_PATH}: ${error instanceof Error ? error.message : String(error)}`);
+		}
+		const result = accountRegistrySchema.safeParse(parsed);
+		if (!result.success) {
+			const issues = result.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; ");
+			throw new Error(`Invalid accounts registry at ${PATHS.ACCOUNTS_REGISTRY_PATH}: ${issues}`);
+		}
+		const registry = result.data;
+		const seen = /* @__PURE__ */ new Set();
+		for (const account of registry.accounts) {
+			if (seen.has(account.id)) throw new Error(`Invalid accounts registry at ${PATHS.ACCOUNTS_REGISTRY_PATH}: duplicate account id "${account.id}"`);
+			seen.add(account.id);
+		}
+		return registry;
+	} catch (error) {
+		if (error.code === "ENOENT") return createEmptyRegistry();
+		throw error;
+	}
+}
+/**
+* Save the accounts registry to disk with secure permissions.
+*/
+async function saveRegistry(registry) {
+	const content = JSON.stringify(registry, null, 2);
+	await fs.writeFile(PATHS.ACCOUNTS_REGISTRY_PATH, content, { mode: 384 });
+}
+/**
+* Add an account to the registry.
+* The account is appended to the end of the list (lowest priority).
+*/
+async function addAccountToRegistry(meta) {
+	if (!validateAccountId(meta.id)) throw new Error(`Invalid account ID: ${meta.id}`);
+	const registry = await loadRegistry();
+	if (registry.accounts.some((a) => a.id === meta.id)) throw new Error(`Account already exists: ${meta.id}`);
+	registry.accounts.push(meta);
+	await saveRegistry(registry);
+}
+/**
+* Remove an account from the registry by ID or index (1-based).
+* Returns the removed account metadata.
+*/
+async function removeAccountFromRegistry(idOrIndex) {
+	const registry = await loadRegistry();
+	let index;
+	if (typeof idOrIndex === "number") {
+		index = idOrIndex - 1;
+		if (index < 0 || index >= registry.accounts.length) throw new Error(`Invalid account index: ${idOrIndex}`);
+	} else {
+		index = registry.accounts.findIndex((a) => a.id === idOrIndex);
+		if (index === -1) throw new Error(`Account not found: ${idOrIndex}`);
+	}
+	const [removed] = registry.accounts.splice(index, 1);
+	await saveRegistry(registry);
+	return removed;
+}
+/**
+* List all accounts from the registry.
+*/
+async function listAccountsFromRegistry() {
+	return (await loadRegistry()).accounts;
+}
+/**
+* Load the GitHub token for a specific account.
+* Returns null if the token file doesn't exist.
+*/
+async function loadAccountToken(id) {
+	if (!validateAccountId(id)) throw new Error(`Invalid account ID: ${id}`);
+	try {
+		const tokenPath = accountTokenPath(id);
+		return (await fs.readFile(tokenPath, "utf8")).trim() || null;
+	} catch (error) {
+		if (error.code === "ENOENT") return null;
+		throw error;
+	}
+}
+/**
+* Save the GitHub token for a specific account with secure permissions.
+*/
+async function saveAccountToken(id, token) {
+	if (!validateAccountId(id)) throw new Error(`Invalid account ID: ${id}`);
+	const tokenPath = accountTokenPath(id);
+	await fs.writeFile(tokenPath, token, { mode: 384 });
+}
+/**
+* Remove the GitHub token file for a specific account.
+*/
+async function removeAccountToken(id) {
+	if (!validateAccountId(id)) throw new Error(`Invalid account ID: ${id}`);
+	const tokenPath = accountTokenPath(id);
+	try {
+		await fs.unlink(tokenPath);
+	} catch (error) {
+		if (error.code !== "ENOENT") throw error;
+	}
+}
+/**
+* Check if the legacy github_token file exists.
+*/
+async function hasLegacyToken() {
+	try {
+		return (await fs.readFile(PATHS.GITHUB_TOKEN_PATH, "utf8")).trim().length > 0;
+	} catch {
+		return false;
+	}
+}
+/**
+* Read the legacy github_token file.
+* Returns null if the file doesn't exist or is empty.
+*/
+async function readLegacyToken() {
+	try {
+		return (await fs.readFile(PATHS.GITHUB_TOKEN_PATH, "utf8")).trim() || null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Check if the registry file exists and has accounts.
+*/
+async function hasRegistry() {
+	return (await loadRegistry()).accounts.length > 0;
+}
+
+//#endregion
+//#region src/lib/state.ts
+const state = {
+	accountType: "individual",
+	manualApprove: false,
+	rateLimitWait: false,
+	showToken: false,
+	verbose: false
+};
+/**
+* Create an AccountContext from the current global state.
+* This is a compatibility layer for transitioning to multi-account support.
+* @throws Error if githubToken is not set in state
+*/
+function accountFromState() {
+	if (!state.githubToken) throw new Error("GitHub token not set in state");
+	return {
+		githubToken: state.githubToken,
+		copilotToken: state.copilotToken,
+		accountType: state.accountType,
+		vsCodeVersion: state.vsCodeVersion
+	};
+}
+
+//#endregion
+//#region src/lib/api-config.ts
+const standardHeaders = () => ({
+	"content-type": "application/json",
+	accept: "application/json"
+});
+const COPILOT_VERSION = "0.35.0";
+const EDITOR_PLUGIN_VERSION = `copilot-chat/${COPILOT_VERSION}`;
+const USER_AGENT = `GitHubCopilotChat/${COPILOT_VERSION}`;
+const API_VERSION = "2025-10-01";
+const copilotBaseUrl = (account) => account.accountType === "individual" ? "https://api.githubcopilot.com" : `https://api.${account.accountType}.githubcopilot.com`;
+const copilotHeaders = (account, vision = false, requestId) => {
+	const resolvedRequestId = requestId ?? randomUUID();
+	const headers = {
+		Authorization: `Bearer ${account.copilotToken}`,
+		"content-type": standardHeaders()["content-type"],
+		"copilot-integration-id": "vscode-chat",
+		"editor-version": `vscode/${account.vsCodeVersion}`,
+		"editor-plugin-version": EDITOR_PLUGIN_VERSION,
+		"user-agent": USER_AGENT,
+		"openai-intent": "conversation-agent",
+		"x-github-api-version": API_VERSION,
+		"x-request-id": resolvedRequestId,
+		"x-vscode-user-agent-library-version": "electron-fetch"
+	};
+	if (vision) headers["copilot-vision-request"] = "true";
+	return headers;
+};
+const GITHUB_API_BASE_URL = "https://api.github.com";
+const githubHeaders = (account) => ({
+	...standardHeaders(),
+	authorization: `token ${account.githubToken}`,
+	"editor-version": `vscode/${account.vsCodeVersion}`,
+	"editor-plugin-version": EDITOR_PLUGIN_VERSION,
+	"user-agent": USER_AGENT,
+	"x-github-api-version": API_VERSION,
+	"x-vscode-user-agent-library-version": "electron-fetch"
+});
+const GITHUB_BASE_URL = "https://github.com";
+const GITHUB_CLIENT_ID = "Iv1.b507a08c87ecfe98";
+const GITHUB_APP_SCOPES = ["read:user"].join(" ");
+
+//#endregion
+//#region src/lib/error.ts
+var HTTPError = class extends Error {
+	response;
+	constructor(message, response) {
+		super(message);
+		this.response = response;
+	}
+};
+async function forwardError(c, error) {
+	consola.error("Error occurred:", error);
+	if (error instanceof HTTPError) {
+		const errorText = await error.response.text();
+		let errorJson;
+		try {
+			errorJson = JSON.parse(errorText);
+		} catch {
+			errorJson = errorText;
+		}
+		consola.error("HTTP error:", errorJson);
+		return c.json({ error: {
+			message: errorText,
+			type: "error"
+		} }, error.response.status);
+	}
+	return c.json({ error: {
+		message: error.message,
+		type: "error"
+	} }, 500);
+}
+
+//#endregion
+//#region src/services/github/get-copilot-usage.ts
+const getCopilotUsage = async (account) => {
+	const ctx = account ?? accountFromState();
+	const response = await fetch(`${GITHUB_API_BASE_URL}/copilot_internal/user`, { headers: githubHeaders(ctx) });
+	if (!response.ok) throw new HTTPError("Failed to get Copilot usage", response);
+	return await response.json();
+};
+
+//#endregion
+//#region src/services/github/get-user.ts
+async function getGitHubUser(account) {
+	const token = account?.githubToken ?? state.githubToken;
+	const response = await fetch(`${GITHUB_API_BASE_URL}/user`, { headers: {
+		authorization: `token ${token}`,
+		...standardHeaders()
+	} });
+	if (!response.ok) throw new HTTPError("Failed to get GitHub user", response);
+	return await response.json();
+}
+
+//#endregion
+//#region src/services/copilot/get-models.ts
+const getModels = async (account) => {
+	const ctx = account ?? accountFromState();
+	const response = await fetch(`${copilotBaseUrl(ctx)}/models`, { headers: copilotHeaders(ctx) });
+	if (!response.ok) throw new HTTPError("Failed to get models", response);
+	const models = await response.json();
+	try {
+		await fs.mkdir(PATHS.APP_DIR, { recursive: true });
+		await fs.writeFile(PATHS.MODELS_PATH, `${JSON.stringify(models, null, 2)}\n`, {
+			encoding: "utf8",
+			mode: 384
+		});
+	} catch {}
+	return models;
+};
+
+//#endregion
+//#region src/services/get-vscode-version.ts
+const FALLBACK = "1.107.0";
+async function getVSCodeVersion() {
+	const controller = new AbortController();
+	const timeout = setTimeout(() => {
+		controller.abort();
+	}, 5e3);
+	try {
+		const match = (await (await fetch("https://aur.archlinux.org/cgit/aur.git/plain/PKGBUILD?h=visual-studio-code-bin", { signal: controller.signal })).text()).match(/pkgver=([0-9.]+)/);
+		if (match) return match[1];
+		return FALLBACK;
+	} catch {
+		return FALLBACK;
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+await getVSCodeVersion();
+
+//#endregion
+//#region src/lib/utils.ts
+const sleep = (ms) => new Promise((resolve) => {
+	setTimeout(resolve, ms);
+});
+const isNullish = (value) => value === null || value === void 0;
+const cacheVSCodeVersion = async () => {
+	const response = await getVSCodeVersion();
+	state.vsCodeVersion = response;
+	consola.info(`Using VSCode version: ${response}`);
+};
+
+//#endregion
+//#region src/services/github/get-copilot-token.ts
+const getCopilotToken = async (account) => {
+	const ctx = account ?? accountFromState();
+	const response = await fetch(`${GITHUB_API_BASE_URL}/copilot_internal/v2/token`, { headers: githubHeaders(ctx) });
+	if (!response.ok) throw new HTTPError("Failed to get Copilot token", response);
+	return await response.json();
+};
+
+//#endregion
+//#region src/lib/config.ts
+const gpt5ExplorationPrompt = `## Exploration and reading files
+- **Think first.** Before any tool call, decide ALL files/resources you will need.
+- **Batch everything.** If you need multiple files (even from different places), read them together.
+- **multi_tool_use.parallel** Use multi_tool_use.parallel to parallelize tool calls and only this.
+- **Only make sequential calls if you truly cannot know the next file without seeing a result first.**
+- **Workflow:** (a) plan all needed reads → (b) issue one parallel batch → (c) analyze results → (d) repeat if new, unpredictable reads arise.`;
+const defaultConfig = {
+	extraPrompts: {
+		"gpt-5-mini": gpt5ExplorationPrompt,
+		"gpt-5.1-codex-max": gpt5ExplorationPrompt
+	},
+	smallModel: "gpt-5-mini",
+	freeModelLoadBalancing: true,
+	modelReasoningEfforts: { "gpt-5-mini": "low" },
+	allowOriginalModelNamesForAliases: false,
+	useFunctionApplyPatch: true,
+	compactUseSmallModel: true
+};
+let cachedConfig = null;
+function ensureConfigFile() {
+	try {
+		fs$1.accessSync(PATHS.CONFIG_PATH, fs$1.constants.R_OK);
+		return;
+	} catch {}
+	try {
+		fs$1.mkdirSync(PATHS.APP_DIR, { recursive: true });
+		fs$1.writeFileSync(PATHS.CONFIG_PATH, `${JSON.stringify(defaultConfig, null, 2)}\n`, "utf8");
+		try {
+			fs$1.chmodSync(PATHS.CONFIG_PATH, 384);
+		} catch {}
+	} catch {}
+}
+function readConfigFromDisk() {
+	ensureConfigFile();
+	try {
+		const raw = fs$1.readFileSync(PATHS.CONFIG_PATH, "utf8");
+		if (!raw.trim()) {
+			fs$1.writeFileSync(PATHS.CONFIG_PATH, `${JSON.stringify(defaultConfig, null, 2)}\n`, "utf8");
+			return defaultConfig;
+		}
+		return JSON.parse(raw);
+	} catch (error) {
+		consola.error("Failed to read config file, using default config", error);
+		return defaultConfig;
+	}
+}
+function mergeDefaultExtraPrompts(config) {
+	const extraPrompts = config.extraPrompts ?? {};
+	const defaultExtraPrompts = defaultConfig.extraPrompts ?? {};
+	if (Object.keys(defaultExtraPrompts).filter((model) => !Object.hasOwn(extraPrompts, model)).length === 0) return {
+		mergedConfig: config,
+		changed: false
+	};
+	return {
+		mergedConfig: {
+			...config,
+			extraPrompts: {
+				...defaultExtraPrompts,
+				...extraPrompts
+			}
+		},
+		changed: true
+	};
+}
+function mergeDefaultFreeModelLoadBalancing(config) {
+	if (typeof config.freeModelLoadBalancing === "boolean") return {
+		mergedConfig: config,
+		changed: false
+	};
+	return {
+		mergedConfig: {
+			...config,
+			freeModelLoadBalancing: defaultConfig.freeModelLoadBalancing ?? true
+		},
+		changed: true
+	};
+}
+function applyConfigMerges(config, mergeFns) {
+	return mergeFns.reduce((acc, mergeFn) => {
+		const result = mergeFn(acc.mergedConfig);
+		return {
+			mergedConfig: result.mergedConfig,
+			changed: acc.changed || result.changed
+		};
+	}, {
+		mergedConfig: config,
+		changed: false
+	});
+}
+function mergeConfigWithDefaults() {
+	const config = readConfigFromDisk();
+	const { mergedConfig, changed } = applyConfigMerges(config, [mergeDefaultExtraPrompts, mergeDefaultFreeModelLoadBalancing]);
+	if (changed) try {
+		fs$1.writeFileSync(PATHS.CONFIG_PATH, `${JSON.stringify(mergedConfig, null, 2)}\n`, "utf8");
+	} catch (writeError) {
+		consola.warn("Failed to write merged config defaults", writeError);
+	}
+	cachedConfig = mergedConfig;
+	return mergedConfig;
+}
+function getConfig() {
+	cachedConfig ??= readConfigFromDisk();
+	return cachedConfig;
+}
+function normalizeAliasKey(value) {
+	const trimmed = value.trim().toLowerCase();
+	return trimmed.length > 0 ? trimmed : null;
+}
+function normalizeAliasTarget(value) {
+	const trimmed = value.trim();
+	return trimmed.length > 0 ? trimmed : null;
+}
+function normalizeAliasSpec(value) {
+	if (typeof value === "string") {
+		const normalizedTarget$1 = normalizeAliasTarget(value);
+		return normalizedTarget$1 ? { target: normalizedTarget$1 } : null;
+	}
+	if (!value || typeof value !== "object") return null;
+	const targetValue = value.target;
+	if (typeof targetValue !== "string") return null;
+	const normalizedTarget = normalizeAliasTarget(targetValue);
+	if (!normalizedTarget) return null;
+	const allowOriginalValue = value.allowOriginal;
+	return {
+		target: normalizedTarget,
+		allowOriginal: typeof allowOriginalValue === "boolean" ? allowOriginalValue : void 0
+	};
+}
+function getModelAliasesInfo() {
+	const raw = getConfig().modelAliases ?? {};
+	const normalized = {};
+	for (const [alias, rawSpec] of Object.entries(raw)) {
+		const normalizedAlias = normalizeAliasKey(alias);
+		const normalizedSpec = normalizeAliasSpec(rawSpec);
+		if (!normalizedAlias || !normalizedSpec) continue;
+		if (!Object.hasOwn(normalized, normalizedAlias)) normalized[normalizedAlias] = normalizedSpec;
+	}
+	return normalized;
+}
+function getModelAliases() {
+	const info = getModelAliasesInfo();
+	const normalized = {};
+	for (const [alias, spec] of Object.entries(info)) normalized[alias] = spec.target;
+	return normalized;
+}
+function resolveModelAlias(modelId) {
+	const normalized = normalizeAliasKey(modelId);
+	if (!normalized) return modelId;
+	return getModelAliases()[normalized] ?? modelId;
+}
+function isOriginalModelNameAllowedForAliases() {
+	return getConfig().allowOriginalModelNamesForAliases ?? false;
+}
+function getAliasTargetSet() {
+	const aliases = getModelAliasesInfo();
+	const allowOriginalDefault = isOriginalModelNameAllowedForAliases();
+	const targetAllowMap = /* @__PURE__ */ new Map();
+	for (const { target, allowOriginal } of Object.values(aliases)) {
+		const normalizedTarget = target.toLowerCase();
+		const effectiveAllow = allowOriginal ?? allowOriginalDefault;
+		const currentAllow = targetAllowMap.get(normalizedTarget);
+		if (currentAllow === true) continue;
+		if (effectiveAllow) targetAllowMap.set(normalizedTarget, true);
+		else if (currentAllow === void 0) targetAllowMap.set(normalizedTarget, false);
+	}
+	const blockedTargets = /* @__PURE__ */ new Set();
+	for (const [target, allowed] of targetAllowMap.entries()) if (!allowed) blockedTargets.add(target);
+	return blockedTargets;
+}
+function isOriginalModelNameAllowedForTarget(modelId) {
+	const normalized = normalizeAliasKey(modelId);
+	if (!normalized) return true;
+	return !getAliasTargetSet().has(normalized);
+}
+function getPreferredAliasForTarget(modelId) {
+	const aliases = getModelAliases();
+	return getAliasKeysForTarget(modelId, aliases)[0] ?? null;
+}
+function getAliasKeysForTarget(target, aliases) {
+	const normalizedTarget = target.toLowerCase();
+	return Object.entries(aliases).filter(([, model]) => model.toLowerCase() === normalizedTarget).map(([alias]) => alias).sort();
+}
+function getAliasFallbackValue(record, modelId, aliases) {
+	if (!record) return void 0;
+	const aliasKeys = getAliasKeysForTarget(modelId, aliases);
+	if (aliasKeys.length === 0) return void 0;
+	const recordByAlias = /* @__PURE__ */ new Map();
+	for (const [key, value] of Object.entries(record)) {
+		const normalized = normalizeAliasKey(key);
+		if (normalized) recordByAlias.set(normalized, value);
+	}
+	for (const alias of aliasKeys) {
+		const value = recordByAlias.get(alias);
+		if (value !== void 0) return value;
+	}
+}
+function getExtraPromptForModel(model) {
+	const config = getConfig();
+	const direct = config.extraPrompts?.[model];
+	if (direct !== void 0) return direct;
+	const aliases = getModelAliases();
+	return getAliasFallbackValue(config.extraPrompts, model, aliases) ?? "";
+}
+function getSmallModel() {
+	const model = getConfig().smallModel ?? "gpt-5-mini";
+	if (isOriginalModelNameAllowedForTarget(model)) return model;
+	return getPreferredAliasForTarget(model) ?? model;
+}
+function isFreeModelLoadBalancingEnabled() {
+	return getConfig().freeModelLoadBalancing ?? true;
+}
+function getReasoningEffortForModel(model) {
+	const config = getConfig();
+	const direct = config.modelReasoningEfforts?.[model];
+	if (direct !== void 0) return direct;
+	const aliases = getModelAliases();
+	return getAliasFallbackValue(config.modelReasoningEfforts, model, aliases) ?? "high";
+}
+function isForceAgentEnabled() {
+	return getConfig().forceAgent ?? false;
+}
+function shouldCompactUseSmallModel() {
+	return getConfig().compactUseSmallModel ?? true;
+}
+
+//#endregion
+//#region src/lib/accounts-manager-auth.ts
+const takeAuthSnapshot = (account) => ({
+	githubToken: account.githubToken,
+	accountType: account.accountType
+});
+const isAuthSnapshotCurrent = (account, snapshot) => account.githubToken === snapshot.githubToken && account.accountType === snapshot.accountType;
+const isSameAuthSnapshot = (a, b) => {
+	if (!a) return false;
+	return a.githubToken === b.githubToken && a.accountType === b.accountType;
+};
+const toAccountContextFromSnapshot = (account, snapshot, copilotToken) => ({
+	githubToken: snapshot.githubToken,
+	copilotToken,
+	accountType: snapshot.accountType,
+	vsCodeVersion: account.vsCodeVersion
+});
+const applyCopilotTokenIfCurrent = (account, snapshot, copilotToken) => {
+	if (!isAuthSnapshotCurrent(account, snapshot)) return false;
+	account.copilotToken = copilotToken;
+	return true;
+};
+const applyModelsIfCurrent = (account, snapshot, models) => {
+	if (!isAuthSnapshotCurrent(account, snapshot)) return false;
+	account.models = models;
+	return true;
+};
+const applyTokenRefreshSuccessIfCurrent = (account, snapshot, token) => {
+	if (!isAuthSnapshotCurrent(account, snapshot)) return false;
+	account.copilotToken = token;
+	account.failed = false;
+	account.failureReason = void 0;
+	return true;
+};
+const applyTokenRefreshFailureIfCurrent = (account, snapshot, error) => {
+	if (!isAuthSnapshotCurrent(account, snapshot)) return false;
+	account.failed = true;
+	account.failureReason = String(error);
+	return true;
+};
+const applyQuotaRefreshSuccessIfCurrent = (account, snapshot, premium) => {
+	if (!isAuthSnapshotCurrent(account, snapshot)) return false;
+	account.premiumEntitlement = premium.entitlement;
+	account.premiumRemaining = premium.remaining;
+	account.unlimited = premium.unlimited;
+	account.lastQuotaFetch = Date.now();
+	account.failed = false;
+	account.failureReason = void 0;
+	return true;
+};
+const setAccountFailedState = (account, reason) => {
+	account.failed = true;
+	account.failureReason = reason;
+	consola.warn(`Account ${account.id} marked as failed: ${reason}`);
+};
+const applyUnauthorizedIfCurrent = (account, snapshot, reason) => {
+	if (!isAuthSnapshotCurrent(account, snapshot)) return false;
+	setAccountFailedState(account, reason);
+	return true;
+};
+
+//#endregion
+//#region src/lib/accounts-manager-quota.ts
+const getCostUnits = (model) => {
+	const billing = model.billing;
+	if (!billing) return 0;
+	if (billing.is_premium !== true) return 0;
+	const multiplier = billing.multiplier;
+	if (typeof multiplier !== "number" || !Number.isFinite(multiplier) || multiplier <= 0) return 1;
+	return multiplier;
+};
+const getEffectivePremiumRemaining = (account) => {
+	if (account.premiumRemaining === void 0) return;
+	const reserved = account.premiumReserved ?? 0;
+	return account.premiumRemaining - reserved;
+};
+const reservePremiumUnits = (account, units) => {
+	if (units <= 0) return;
+	const id = Symbol("quotaReservation");
+	if (!account.premiumReservations) account.premiumReservations = /* @__PURE__ */ new Map();
+	account.premiumReservations.set(id, units);
+	account.premiumReserved = (account.premiumReserved ?? 0) + units;
+	return { id };
+};
+const releasePremiumReservation = (account, reservation) => {
+	if (!reservation) return;
+	const reservations = account.premiumReservations;
+	if (!reservations) return;
+	const reservedUnits = reservations.get(reservation.id);
+	if (reservedUnits === void 0) return;
+	reservations.delete(reservation.id);
+	const nextReserved = (account.premiumReserved ?? 0) - reservedUnits;
+	account.premiumReserved = Math.max(0, nextReserved);
+	if (reservations.size === 0) account.premiumReservations = void 0;
+};
+
+//#endregion
+//#region src/lib/accounts-manager.ts
+/** Quota cache TTL in milliseconds (45 seconds) for pre-request selection. */
+const QUOTA_CACHE_TTL = 45 * 1e3;
+/** Debounce delay for registry reload in milliseconds */
+const RELOAD_DEBOUNCE_MS = 500;
+/** Registry watcher restart initial delay in milliseconds */
+const WATCHER_RESTART_INITIAL_DELAY_MS = 1e3;
+/** Registry watcher restart max delay in milliseconds */
+const WATCHER_RESTART_MAX_DELAY_MS = 60 * 1e3;
+/** Manages multiple GitHub Copilot accounts at runtime. */
+var AccountsManager = class {
+	accounts = /* @__PURE__ */ new Map();
+	accountOrder = [];
+	temporaryAccount;
+	vsCodeVersion;
+	freeModelCursor = 0;
+	freeModelLoadBalancingEnabled = true;
+	quotaRefreshSnapshotByAccount = /* @__PURE__ */ new WeakMap();
+	tokenRefreshEnabledAccounts = /* @__PURE__ */ new WeakSet();
+	registryWatcher;
+	reloadDebounceTimer;
+	registryWatcherRestartTimer;
+	registryWatcherRestartDelayMs = WATCHER_RESTART_INITIAL_DELAY_MS;
+	isReloading = false;
+	/** Initialize accounts manager (load registry, migrate legacy token). */
+	async initialize(vsCodeVersion) {
+		this.vsCodeVersion = vsCodeVersion;
+		const hasReg = await hasRegistry();
+		const hasLegacy = await hasLegacyToken();
+		if (!hasReg && hasLegacy) await this.migrateLegacyToken();
+		const accountMetas = await listAccountsFromRegistry();
+		for (const meta of accountMetas) {
+			const token = await loadAccountToken(meta.id);
+			if (!token) {
+				consola.warn(`No token found for account ${meta.id}, skipping`);
+				continue;
+			}
+			const runtime = {
+				...meta,
+				githubToken: token,
+				vsCodeVersion: this.vsCodeVersion
+			};
+			this.accounts.set(meta.id, runtime);
+			this.accountOrder.push(meta.id);
+		}
+		for (const account of this.accounts.values()) try {
+			await this.initializeAccount(account);
+		} catch (error) {
+			consola.error(`Failed to initialize account ${account.id}:`, error);
+			account.failed = true;
+			account.failureReason = String(error);
+		}
+		consola.info(`Loaded ${this.accounts.size} account(s)`);
+		this.startRegistryWatcher();
+	}
+	setFreeModelLoadBalancingEnabled(enabled) {
+		this.freeModelLoadBalancingEnabled = enabled;
+	}
+	computeTokenRefreshDelayMs(refreshInSeconds) {
+		return Math.max((refreshInSeconds - 60) * 1e3, 1e3);
+	}
+	shouldContinueTokenRefresh(account, snapshot) {
+		return this.tokenRefreshEnabledAccounts.has(account) && isAuthSnapshotCurrent(account, snapshot);
+	}
+	async runTokenRefreshTick(account, snapshot, refreshInSeconds) {
+		if (!this.shouldContinueTokenRefresh(account, snapshot)) return;
+		try {
+			const ctx = toAccountContextFromSnapshot(account, snapshot);
+			const { token, refresh_in } = await getCopilotToken(ctx);
+			if (!this.shouldContinueTokenRefresh(account, snapshot)) return;
+			if (!applyTokenRefreshSuccessIfCurrent(account, snapshot, token)) return;
+			consola.debug(`Refreshed token for account ${account.id}`);
+			if (!this.shouldContinueTokenRefresh(account, snapshot)) return;
+			this.startTokenRefresh(account, refresh_in);
+		} catch (error) {
+			consola.error(`Failed to refresh token for ${account.id}:`, error);
+			if (!this.shouldContinueTokenRefresh(account, snapshot)) return;
+			applyTokenRefreshFailureIfCurrent(account, snapshot, error);
+			if (!this.shouldContinueTokenRefresh(account, snapshot)) return;
+			this.startTokenRefresh(account, refreshInSeconds);
+		}
+	}
+	finalizeQuotaRefreshPromise(account, promise) {
+		if (account.quotaRefreshPromise !== promise) return;
+		account.isRefreshingQuota = false;
+		account.quotaRefreshPromise = void 0;
+		this.quotaRefreshSnapshotByAccount.delete(account);
+	}
+	/** Initialize a single account. */
+	async initializeAccount(account) {
+		const snapshot = takeAuthSnapshot(account);
+		try {
+			const tokenCtx = toAccountContextFromSnapshot(account, snapshot);
+			const { token, refresh_in } = await getCopilotToken(tokenCtx);
+			if (!applyCopilotTokenIfCurrent(account, snapshot, token)) return;
+			this.startTokenRefresh(account, refresh_in);
+			const modelsCtx = toAccountContextFromSnapshot(account, snapshot, token);
+			const models = await getModels(modelsCtx);
+			if (!applyModelsIfCurrent(account, snapshot, models)) return;
+			await this.refreshQuota(account);
+			consola.debug(`Account ${account.id} initialized`);
+		} catch (error) {
+			if (!isAuthSnapshotCurrent(account, snapshot)) return;
+			throw error;
+		}
+	}
+	/** Migrate legacy github_token to the new multi-account system. */
+	async migrateLegacyToken() {
+		const token = await readLegacyToken();
+		if (!token) return;
+		try {
+			const id = (await getGitHubUser({
+				githubToken: token,
+				accountType: "individual"
+			})).login;
+			await saveAccountToken(id, token);
+			await addAccountToRegistry({
+				id,
+				accountType: "individual",
+				addedAt: Date.now()
+			});
+			consola.info(`Migrated legacy token to account: ${id}`);
+		} catch (error) {
+			consola.error("Failed to migrate legacy token:", error);
+		}
+	}
+	/** Start token refresh timer for an account. */
+	startTokenRefresh(account, refreshInSeconds) {
+		this.stopTokenRefresh(account);
+		this.tokenRefreshEnabledAccounts.add(account);
+		const snapshot = takeAuthSnapshot(account);
+		const delayMs = this.computeTokenRefreshDelayMs(refreshInSeconds);
+		account.refreshTimer = setTimeout(() => {
+			this.runTokenRefreshTick(account, snapshot, refreshInSeconds);
+		}, delayMs);
+	}
+	/** Stop token refresh timer for an account. */
+	stopTokenRefresh(account) {
+		this.tokenRefreshEnabledAccounts.delete(account);
+		if (account.refreshTimer) {
+			clearTimeout(account.refreshTimer);
+			account.refreshTimer = void 0;
+		}
+	}
+	/** Stop all token refresh timers. */
+	stopAllTokenRefresh() {
+		for (const account of this.accounts.values()) this.stopTokenRefresh(account);
+		if (this.temporaryAccount) this.stopTokenRefresh(this.temporaryAccount);
+	}
+	/** Refresh quota information for an account. */
+	async refreshQuota(account) {
+		const snapshot = takeAuthSnapshot(account);
+		if (account.quotaRefreshPromise) {
+			const existingSnapshot = this.quotaRefreshSnapshotByAccount.get(account);
+			if (isSameAuthSnapshot(existingSnapshot, snapshot)) {
+				await account.quotaRefreshPromise;
+				return;
+			}
+		}
+		account.isRefreshingQuota = true;
+		const ctx = toAccountContextFromSnapshot(account, snapshot);
+		const promise = (async () => {
+			try {
+				const premium = (await getCopilotUsage(ctx)).quota_snapshots.premium_interactions;
+				applyQuotaRefreshSuccessIfCurrent(account, snapshot, premium);
+			} catch (error) {
+				if (error instanceof HTTPError && error.response.status === 401) {
+					applyUnauthorizedIfCurrent(account, snapshot, "Unauthorized (401)");
+					return;
+				}
+				consola.error(`Failed to refresh quota for ${account.id}:`, error);
+			}
+		})();
+		account.quotaRefreshPromise = promise;
+		this.quotaRefreshSnapshotByAccount.set(account, snapshot);
+		promise.finally(() => {
+			this.finalizeQuotaRefreshPromise(account, promise);
+		});
+		await promise;
+	}
+	/** Check if quota cache is expired. */
+	isQuotaCacheExpired(account) {
+		if (!account.lastQuotaFetch) return true;
+		return Date.now() - account.lastQuotaFetch > QUOTA_CACHE_TTL;
+	}
+	isAccountFailed(account) {
+		return account.failed === true;
+	}
+	isModelSupportedForEndpoint(model, endpoint) {
+		if (endpoint === "/responses") return model.supported_endpoints?.includes(endpoint) ?? false;
+		const supported = model.supported_endpoints;
+		if (!supported) return true;
+		return supported.includes(endpoint);
+	}
+	pickSupportedCandidate(account, candidates) {
+		const models = account.models?.data;
+		if (!models) return null;
+		for (const candidate of candidates) {
+			const model = models.find((m) => m.id === candidate.modelId);
+			if (!model) continue;
+			if (!this.isModelSupportedForEndpoint(model, candidate.endpoint)) continue;
+			return {
+				candidate,
+				model
+			};
+		}
+		return null;
+	}
+	selectFreeAccountForRequest(orderedAccounts, candidates) {
+		const count = orderedAccounts.length;
+		const start = this.freeModelCursor % count;
+		let supportedCandidateFound = false;
+		for (let i = 0; i < count; i++) {
+			const idx = (start + i) % count;
+			const account = orderedAccounts[idx];
+			if (this.isAccountFailed(account)) continue;
+			const supported = this.pickSupportedCandidate(account, candidates);
+			if (!supported) continue;
+			supportedCandidateFound = true;
+			const { candidate, model } = supported;
+			const costUnits = getCostUnits(model);
+			if (costUnits > 0) continue;
+			this.freeModelCursor = (idx + 1) % count;
+			return {
+				ok: true,
+				account,
+				selectedModel: model,
+				endpoint: candidate.endpoint,
+				costUnits
+			};
+		}
+		if (!supportedCandidateFound) return {
+			ok: false,
+			reason: "MODEL_NOT_SUPPORTED"
+		};
+		return {
+			ok: false,
+			reason: "NO_QUOTA"
+		};
+	}
+	async selectAccountForCandidates(orderedAccounts, candidates) {
+		if (orderedAccounts.length === 0) return {
+			ok: false,
+			reason: "NO_ACCOUNTS"
+		};
+		let supportedCandidateFound = false;
+		for (const account of orderedAccounts) {
+			if (this.isAccountFailed(account)) continue;
+			const supported = this.pickSupportedCandidate(account, candidates);
+			if (!supported) continue;
+			supportedCandidateFound = true;
+			const { candidate, model } = supported;
+			const costUnits = getCostUnits(model);
+			if (costUnits <= 0) {
+				if (this.freeModelLoadBalancingEnabled) return this.selectFreeAccountForRequest(orderedAccounts, candidates);
+				return {
+					ok: true,
+					account,
+					selectedModel: model,
+					endpoint: candidate.endpoint,
+					costUnits
+				};
+			}
+			if (!account.unlimited && this.isQuotaCacheExpired(account)) await this.refreshQuota(account);
+			if (this.isAccountFailed(account)) continue;
+			if (account.unlimited) return {
+				ok: true,
+				account,
+				selectedModel: model,
+				endpoint: candidate.endpoint,
+				costUnits
+			};
+			const effectiveRemaining = getEffectivePremiumRemaining(account);
+			if (effectiveRemaining !== void 0 && effectiveRemaining < costUnits) continue;
+			const reservation = reservePremiumUnits(account, costUnits);
+			return {
+				ok: true,
+				account,
+				selectedModel: model,
+				endpoint: candidate.endpoint,
+				costUnits,
+				reservation
+			};
+		}
+		if (!supportedCandidateFound) return {
+			ok: false,
+			reason: "MODEL_NOT_SUPPORTED"
+		};
+		return {
+			ok: false,
+			reason: "NO_QUOTA"
+		};
+	}
+	/**
+	* Select an available account for a specific request (model + endpoint).
+	* Uses reservation to avoid oversubscribing premium quota under concurrency.
+	*/
+	async selectAccountForRequest(candidates) {
+		if (candidates.length === 0) throw new Error("selectAccountForRequest requires at least one candidate");
+		const orderedAccounts = [...this.temporaryAccount ? [this.temporaryAccount] : [], ...this.accountOrder.map((id) => this.accounts.get(id)).filter((account) => account !== void 0)];
+		const primary = await this.selectAccountForCandidates(orderedAccounts, candidates);
+		if (primary.ok || primary.reason !== "MODEL_NOT_SUPPORTED") return primary;
+		const aliasCandidates = candidates.map((candidate) => {
+			const modelId = resolveModelAlias(candidate.modelId);
+			if (modelId === candidate.modelId) return candidate;
+			return {
+				...candidate,
+				modelId
+			};
+		});
+		if (!aliasCandidates.some((candidate, index) => candidate.modelId !== candidates[index].modelId)) return primary;
+		return this.selectAccountForCandidates(orderedAccounts, aliasCandidates);
+	}
+	/**
+	* Finalize quota after a request completes.
+	* This releases any in-flight reservation and refreshes the actual quota from the API.
+	*/
+	async finalizeQuota(account, reservation) {
+		releasePremiumReservation(account, reservation);
+		try {
+			await this.refreshQuota(account);
+		} catch (error) {
+			consola.debug(`Failed to finalize quota for ${account.id}:`, error);
+		}
+	}
+	/**
+	* Mark an account as failed.
+	*/
+	markAccountFailed(id, reason) {
+		const account = this.accounts.get(id);
+		if (account) {
+			setAccountFailedState(account, reason);
+			return;
+		}
+		if (this.temporaryAccount && this.temporaryAccount.id === id) setAccountFailedState(this.temporaryAccount, reason);
+	}
+	/**
+	* Get status of all accounts.
+	*/
+	getAccountStatus() {
+		const statuses = [];
+		if (this.temporaryAccount) statuses.push({
+			id: "(temporary)",
+			entitlement: this.temporaryAccount.premiumEntitlement,
+			remaining: this.temporaryAccount.premiumRemaining,
+			unlimited: this.temporaryAccount.unlimited,
+			failed: this.temporaryAccount.failed,
+			failureReason: this.temporaryAccount.failureReason
+		});
+		for (const id of this.accountOrder) {
+			const account = this.accounts.get(id);
+			if (account) statuses.push({
+				id: account.id,
+				entitlement: account.premiumEntitlement,
+				remaining: account.premiumRemaining,
+				unlimited: account.unlimited,
+				failed: account.failed,
+				failureReason: account.failureReason
+			});
+		}
+		return statuses;
+	}
+	/**
+	* Set a temporary account from a GitHub token (--github-token).
+	* This account takes priority over registered accounts.
+	*/
+	async setTemporaryAccount(githubToken, accountType) {
+		const runtime = {
+			id: "(temporary)",
+			accountType,
+			addedAt: Date.now(),
+			githubToken,
+			vsCodeVersion: this.vsCodeVersion
+		};
+		try {
+			await this.initializeAccount(runtime);
+			this.temporaryAccount = runtime;
+			consola.info("Temporary account initialized");
+		} catch (error) {
+			consola.error("Failed to initialize temporary account:", error);
+			throw error;
+		}
+	}
+	/**
+	* Check if any accounts are available.
+	*/
+	hasAccounts() {
+		return this.accounts.size > 0 || this.temporaryAccount !== void 0;
+	}
+	/**
+	* Get the first available account's models.
+	* Used for caching models in legacy compatibility mode.
+	*/
+	getFirstAccountModels() {
+		if (this.temporaryAccount?.models) return this.temporaryAccount.models;
+		for (const id of this.accountOrder) {
+			const account = this.accounts.get(id);
+			if (account?.models) return account.models;
+		}
+	}
+	/**
+	* Get account context by index.
+	* Index 0 is the temporary account (if exists), otherwise the first registered account.
+	* Returns null if index is out of bounds.
+	*/
+	getAccountContextByIndex(index) {
+		const allAccounts = [];
+		if (this.temporaryAccount) allAccounts.push(this.temporaryAccount);
+		for (const id of this.accountOrder) {
+			const account = this.accounts.get(id);
+			if (account) allAccounts.push(account);
+		}
+		if (index < 0 || index >= allAccounts.length) return null;
+		return this.toAccountContext(allAccounts[index]);
+	}
+	/**
+	* Get the total number of accounts (including temporary).
+	*/
+	getAccountCount() {
+		return (this.temporaryAccount ? 1 : 0) + this.accountOrder.length;
+	}
+	/**
+	* Convert AccountRuntime to AccountContext for service calls.
+	*/
+	toAccountContext(account) {
+		return {
+			githubToken: account.githubToken,
+			copilotToken: account.copilotToken,
+			accountType: account.accountType,
+			vsCodeVersion: account.vsCodeVersion
+		};
+	}
+	/**
+	* Start watching the registry file for changes.
+	* Enables hot reload of accounts when the file is modified.
+	*/
+	startRegistryWatcher() {
+		this.stopRegistryWatcher();
+		try {
+			this.registryWatcher = fs$1.watch(PATHS.ACCOUNTS_REGISTRY_PATH, (eventType) => {
+				if (eventType === "change") this.scheduleReload();
+			});
+			this.registryWatcherRestartDelayMs = WATCHER_RESTART_INITIAL_DELAY_MS;
+			if (this.registryWatcherRestartTimer) {
+				clearTimeout(this.registryWatcherRestartTimer);
+				this.registryWatcherRestartTimer = void 0;
+			}
+			this.registryWatcher.on("error", (error) => {
+				consola.debug("Registry watcher error:", error);
+				const delayMs = this.registryWatcherRestartDelayMs;
+				this.registryWatcherRestartDelayMs = Math.min(this.registryWatcherRestartDelayMs * 2, WATCHER_RESTART_MAX_DELAY_MS);
+				this.stopRegistryWatcher();
+				this.registryWatcherRestartTimer = setTimeout(() => {
+					this.registryWatcherRestartTimer = void 0;
+					this.startRegistryWatcher();
+				}, delayMs);
+				consola.debug(`Restarting registry watcher in ${delayMs}ms`);
+			});
+			consola.debug("Started registry file watcher");
+		} catch (error) {
+			consola.warn("Failed to start registry watcher:", error);
+		}
+	}
+	/**
+	* Schedule a registry reload with debouncing.
+	*/
+	scheduleReload() {
+		if (this.reloadDebounceTimer) clearTimeout(this.reloadDebounceTimer);
+		this.reloadDebounceTimer = setTimeout(() => {
+			this.reloadRegistry();
+		}, RELOAD_DEBOUNCE_MS);
+	}
+	/**
+	* Reload the registry and perform incremental updates.
+	* Adds new accounts, removes deleted ones, and reinitializes existing accounts
+	* when token/accountType changes.
+	*/
+	async reloadRegistry() {
+		if (this.isReloading) return;
+		this.isReloading = true;
+		try {
+			const newMetas = await listAccountsFromRegistry();
+			const newIds = new Set(newMetas.map((m) => m.id));
+			const currentIds = new Set(this.accountOrder);
+			const added = [];
+			const removed = [];
+			const updated = [];
+			this.removeDeletedAccounts(currentIds, newIds, removed);
+			for (const meta of newMetas) if (!currentIds.has(meta.id)) await this.addNewAccount(meta, added);
+			await this.reinitializeUpdatedAccounts(newMetas, currentIds, updated);
+			this.accountOrder = newMetas.map((m) => m.id).filter((id) => this.accounts.has(id));
+			this.freeModelCursor = 0;
+			this.logRegistryReloadChanges(added, removed, updated);
+		} catch (error) {
+			consola.error("Failed to reload registry:", error);
+			this.shutdown();
+			process.exit(1);
+		} finally {
+			this.isReloading = false;
+		}
+	}
+	removeDeletedAccounts(currentIds, newIds, removed) {
+		for (const id of currentIds) if (!newIds.has(id)) {
+			const account = this.accounts.get(id);
+			if (!account) continue;
+			this.stopTokenRefresh(account);
+			this.accounts.delete(id);
+			removed.push(id);
+		}
+	}
+	async reinitializeUpdatedAccounts(newMetas, currentIds, updated) {
+		for (const meta of newMetas) {
+			if (!currentIds.has(meta.id)) continue;
+			const account = this.accounts.get(meta.id);
+			if (!account) continue;
+			const token = await loadAccountToken(meta.id);
+			if (!token) {
+				consola.warn(`No token found for account ${meta.id}, skipping update`);
+				continue;
+			}
+			const accountTypeChanged = account.accountType !== meta.accountType;
+			const tokenChanged = account.githubToken !== token;
+			const addedAtChanged = account.addedAt !== meta.addedAt;
+			if (accountTypeChanged) account.accountType = meta.accountType;
+			if (addedAtChanged) account.addedAt = meta.addedAt;
+			if (tokenChanged) account.githubToken = token;
+			if (!accountTypeChanged && !tokenChanged) continue;
+			try {
+				await this.initializeAccount(account);
+				updated.push(meta.id);
+			} catch (error) {
+				consola.error(`Failed to reinitialize account ${meta.id} after update:`, error);
+				account.failed = true;
+				account.failureReason = String(error);
+				updated.push(`${meta.id} (failed)`);
+			}
+		}
+	}
+	logRegistryReloadChanges(added, removed, updated) {
+		if (added.length === 0 && removed.length === 0 && updated.length === 0) return;
+		const changes = [];
+		if (added.length > 0) changes.push(`added: ${added.join(", ")}`);
+		if (removed.length > 0) changes.push(`removed: ${removed.join(", ")}`);
+		if (updated.length > 0) changes.push(`updated: ${updated.join(", ")}`);
+		consola.info(`Registry reloaded (${changes.join("; ")}). Total: ${this.accounts.size} account(s)`);
+	}
+	/**
+	* Helper to add a new account during reload.
+	*/
+	async addNewAccount(meta, added) {
+		const token = await loadAccountToken(meta.id);
+		if (!token) {
+			consola.warn(`No token found for new account ${meta.id}, skipping`);
+			return;
+		}
+		const runtime = {
+			...meta,
+			githubToken: token,
+			vsCodeVersion: this.vsCodeVersion
+		};
+		try {
+			await this.initializeAccount(runtime);
+			this.accounts.set(meta.id, runtime);
+			added.push(meta.id);
+		} catch (error) {
+			consola.error(`Failed to initialize new account ${meta.id}:`, error);
+			runtime.failed = true;
+			runtime.failureReason = String(error);
+			this.accounts.set(meta.id, runtime);
+			added.push(`${meta.id} (failed)`);
+		}
+	}
+	/**
+	* Stop the registry file watcher.
+	*/
+	stopRegistryWatcher() {
+		if (this.reloadDebounceTimer) {
+			clearTimeout(this.reloadDebounceTimer);
+			this.reloadDebounceTimer = void 0;
+		}
+		if (this.registryWatcherRestartTimer) {
+			clearTimeout(this.registryWatcherRestartTimer);
+			this.registryWatcherRestartTimer = void 0;
+		}
+		if (this.registryWatcher) {
+			this.registryWatcher.close();
+			this.registryWatcher = void 0;
+		}
+	}
+	/**
+	* Shutdown the manager and clean up resources.
+	*/
+	shutdown() {
+		this.stopRegistryWatcher();
+		this.stopAllTokenRefresh();
+		this.accounts.clear();
+		this.accountOrder = [];
+		this.temporaryAccount = void 0;
+	}
+};
+/** Singleton instance of AccountsManager */
+const accountsManager = new AccountsManager();
+
+//#endregion
+export { GITHUB_APP_SCOPES, GITHUB_BASE_URL, GITHUB_CLIENT_ID, HTTPError, PATHS, accountFromState, accountsManager, addAccountToRegistry, cacheVSCodeVersion, copilotBaseUrl, copilotHeaders, ensurePaths, forwardError, getAliasTargetSet, getConfig, getCopilotUsage, getExtraPromptForModel, getGitHubUser, getModelAliases, getReasoningEffortForModel, getSmallModel, isForceAgentEnabled, isFreeModelLoadBalancingEnabled, isNullish, listAccountsFromRegistry, loadAccountToken, mergeConfigWithDefaults, removeAccountFromRegistry, removeAccountToken, saveAccountToken, saveRegistry, shouldCompactUseSmallModel, sleep, standardHeaders, state };
+//# sourceMappingURL=accounts-manager-CxuKJ4qv.js.map