github-router 0.3.250 → 0.3.256

package/dist/token-R2ocFC3M.js

@@ -0,0 +1,1054 @@
+import { t as PATHS } from "./paths-C1cLZ7Ga.js";
+import consola from "consola";
+import path from "node:path";
+import { randomBytes, randomUUID } from "node:crypto";
+import fs from "node:fs/promises";
+//#region src/lib/state.ts
+const state = {
+	accountType: "enterprise",
+	manualApprove: false,
+	rateLimitWait: false,
+	showToken: false,
+	extendedBetas: false,
+	browseEnabled: false,
+	fleetEnabled: false,
+	agentsEnabled: false,
+	powerBrowseEnabled: false,
+	humanlikeForce: "auto",
+	sessionId: randomUUID(),
+	machineId: randomBytes(32).toString("hex")
+};
+//#endregion
+//#region src/lib/api-config.ts
+const standardHeaders = () => ({
+	"content-type": "application/json",
+	accept: "application/json"
+});
+const DEFAULT_COPILOT_VERSION = "0.43.2026033101";
+function copilotVersion(state) {
+	return state.copilotVersion ?? DEFAULT_COPILOT_VERSION;
+}
+const API_VERSION = "2026-01-09";
+const copilotBaseUrl = (state) => state.copilotApiUrl ?? "https://api.githubcopilot.com";
+const copilotHeaders = (state, vision = false, integrationId = "vscode-chat") => {
+	const version = copilotVersion(state);
+	const headers = {
+		Authorization: `Bearer ${state.copilotToken}`,
+		"content-type": standardHeaders()["content-type"],
+		"copilot-integration-id": integrationId,
+		"editor-version": `vscode/${state.vsCodeVersion}`,
+		"editor-plugin-version": `copilot-chat/${version}`,
+		"user-agent": `GitHubCopilotChat/${version}`,
+		"openai-intent": "conversation-panel",
+		"x-interaction-type": "conversation-panel",
+		"x-github-api-version": API_VERSION,
+		"x-request-id": randomUUID(),
+		"x-vscode-user-agent-library-version": "electron-fetch",
+		"VScode-SessionId": state.sessionId,
+		"VScode-MachineId": state.machineId
+	};
+	if (vision) headers["copilot-vision-request"] = "true";
+	return headers;
+};
+const GITHUB_API_BASE_URL = process.env.GITHUB_API_URL ?? "https://api.github.com";
+const githubHeaders = (state) => ({
+	...standardHeaders(),
+	authorization: `token ${state.githubToken}`,
+	"editor-version": `vscode/${state.vsCodeVersion}`,
+	"editor-plugin-version": `copilot-chat/${copilotVersion(state)}`,
+	"user-agent": `GitHubCopilotChat/${copilotVersion(state)}`,
+	"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(" ");
+const GITHUB_AGENT_CLIENT_ID = "178c6fc778ccc68e1d6a";
+const GITHUB_AGENT_SCOPES = [
+	"repo",
+	"workflow",
+	"read:org"
+].join(" ");
+const GITHUB_GRAPHQL_URL = process.env.GITHUB_GRAPHQL_URL ?? "https://api.github.com/graphql";
+const GITHUB_REST_API_VERSION = "2022-11-28";
+const githubAgentHeaders = (state) => ({
+	...standardHeaders(),
+	authorization: `token ${state.githubAgentToken}`,
+	"x-github-api-version": GITHUB_REST_API_VERSION,
+	"user-agent": "github-router-first-mate"
+});
+const githubAgentGraphQLHeaders = (state, features) => ({
+	...githubAgentHeaders(state),
+	...features ? { "GraphQL-Features": features } : {}
+});
+//#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 at ${c.req.path}:`, error);
+	if (error instanceof HTTPError) {
+		const errorText = await error.response.text().catch(() => "");
+		let errorJson;
+		try {
+			errorJson = JSON.parse(errorText);
+		} catch {
+			errorJson = void 0;
+		}
+		if (isContextOverflow(error.response.status, errorJson, errorText)) {
+			const upstream = resolveErrorMessage(errorJson, errorText);
+			consola.error("HTTP error (mapped to overflow):", errorJson ?? errorText);
+			return c.json({
+				type: "error",
+				error: {
+					type: "invalid_request_error",
+					message: `prompt is too long: ${upstream}`
+				}
+			}, 400);
+		}
+		const responseStatus = error.response.status === 401 ? 503 : error.response.status;
+		if (isAnthropicError(errorJson)) {
+			consola.error("HTTP error:", errorJson);
+			return c.json(errorJson, responseStatus);
+		}
+		const message = resolveErrorMessage(errorJson, errorText);
+		consola.error("HTTP error:", errorJson ?? errorText);
+		return c.json({
+			type: "error",
+			error: {
+				type: resolveErrorType(responseStatus),
+				message
+			}
+		}, responseStatus);
+	}
+	return c.json({
+		type: "error",
+		error: {
+			type: "api_error",
+			message: error instanceof Error ? error.message : String(error)
+		}
+	}, 500);
+}
+function resolveErrorMessage(errorJson, fallback) {
+	if (typeof errorJson !== "object" || errorJson === null) return fallback;
+	const errorRecord = errorJson;
+	if (errorRecord.message !== void 0) return String(errorRecord.message);
+	if (typeof errorRecord.error === "object" && errorRecord.error !== null) {
+		const nestedRecord = errorRecord.error;
+		if (nestedRecord.message !== void 0) return String(nestedRecord.message);
+	}
+	return fallback;
+}
+/**
+* Check if a parsed JSON body is already in Anthropic error format:
+* { type: "error", error: { type: "...", message: "..." } }
+*/
+function isAnthropicError(json) {
+	if (typeof json !== "object" || json === null) return false;
+	const record = json;
+	if (record.type !== "error") return false;
+	if (typeof record.error !== "object" || record.error === null) return false;
+	const inner = record.error;
+	return typeof inner.type === "string" && typeof inner.message === "string";
+}
+const CONTEXT_OVERFLOW_SUBSTRINGS = [
+	"prompt is too long",
+	"context_length_exceeded",
+	"context length exceeded",
+	"input is too long",
+	"maximum context length",
+	"too many tokens"
+];
+/**
+* Detect upstream context-overflow errors so we can remap them to a 400
+* "prompt is too long" shape that triggers Claude Code self-compaction.
+*
+* Always remaps 413 (treated as a hard payload-size signal regardless of
+* body wording). Remaps 400 only when the error text contains one of the
+* known overflow substrings — a regular 400 (e.g. "model not found") must
+* NOT remap.
+*/
+function isContextOverflow(status, errorJson, errorText) {
+	if (status === 413) return true;
+	if (status !== 400) return false;
+	const haystack = (errorText + " " + (typeof errorJson === "object" && errorJson !== null ? JSON.stringify(errorJson) : "")).toLowerCase();
+	return CONTEXT_OVERFLOW_SUBSTRINGS.some((s) => haystack.includes(s));
+}
+/**
+* Map HTTP status to Anthropic error type.
+*
+* Note: a 401 from upstream is remapped to 503 in `forwardError` BEFORE
+* this function is called (no-401 invariant — see comment there). The
+* 401 → "authentication_error" mapping below is preserved for
+* defensive coverage in case any code path calls `resolveErrorType`
+* directly with an unsanitized status.
+*/
+function resolveErrorType(status) {
+	if (status === 400) return "invalid_request_error";
+	if (status === 401) return "authentication_error";
+	if (status === 403) return "permission_error";
+	if (status === 404) return "not_found_error";
+	if (status === 429) return "rate_limit_error";
+	if (status === 503) return "overloaded_error";
+	if (status === 529) return "overloaded_error";
+	return "api_error";
+}
+//#endregion
+//#region src/lib/upstream-retry.ts
+/**
+* Shared transient-failure retry for upstream calls (`src/lib/upstream-retry.ts`).
+*
+* Retries ONLY on transient conditions — never on success, never on a
+* deterministic 4xx (400/401/403/404…), so a malformed request or auth
+* failure fails fast instead of being hammered. 401 is intentionally NOT
+* retried here: it stays with the existing token-refresh path so the
+* 401→503 forwardError invariant is preserved.
+*
+* Retryable:
+*   - HTTP 429 + 5xx (500/502/503/504) — the "upstream is sick" class.
+*   - network errors (ECONNRESET / "fetch failed" / "terminated" / EPIPE …).
+*   - upstream TIMEOUT aborts: an AbortError thrown while the CALLER'S
+*     `signal` is NOT aborted (a user cancel aborts the caller's signal
+*     and is rethrown immediately, never retried).
+*
+* Exponential backoff + FULL jitter, capped, honoring `Retry-After`. The
+* inter-attempt sleep is abortable so a user cancel during backoff
+* returns promptly. Bounded `attempts` keep a single call from holding an
+* inflight slot indefinitely (robust AND fast).
+*
+* Streaming note: the user-facing passthrough and the worker loop must
+* only retry in the PRE-FIRST-BYTE window — a retry after bytes have
+* streamed would duplicate output. Callers there pass a `doFetch` that
+* has not yet handed its body to the consumer.
+*/
+const DEFAULT_RETRY_STATUSES = [
+	429,
+	500,
+	502,
+	503,
+	504
+];
+function parseRetryAfter(headerValue) {
+	if (!headerValue) return void 0;
+	const secs = Number(headerValue);
+	if (Number.isFinite(secs)) return Math.max(0, secs * 1e3);
+	const dateMs = Date.parse(headerValue);
+	if (Number.isFinite(dateMs)) return Math.max(0, dateMs - Date.now());
+}
+/**
+* A thrown fetch error that is worth retrying — network resets, broken
+* pipes, DNS hiccups, and timeout aborts. NOTE: the caller must already
+* have ruled out a user cancel (caller signal aborted) before calling
+* this, since a timeout abort and a user-cancel abort look identical.
+*/
+function isTransientNetworkError(err) {
+	const e = err;
+	if (!e) return false;
+	if (e.name === "AbortError" || e.name === "TimeoutError") return true;
+	const msg = (e.message ?? "").toLowerCase();
+	if (msg.includes("terminated") || msg.includes("fetch failed") || msg.includes("network") || msg.includes("socket") || msg.includes("econnreset") || msg.includes("etimedout") || msg.includes("econnrefused") || msg.includes("epipe") || msg.includes("enotfound")) return true;
+	const code = e.code ?? e.cause?.code;
+	return code !== void 0 && [
+		"ECONNRESET",
+		"ETIMEDOUT",
+		"ECONNREFUSED",
+		"EPIPE",
+		"ENOTFOUND"
+	].includes(code);
+}
+/** Sleep that resolves early (does not reject) when `signal` aborts — the
+*  retry loop re-checks `signal.aborted` at the top and throws there. */
+function abortableSleep(ms, signal) {
+	if (ms <= 0) return Promise.resolve();
+	return new Promise((resolve) => {
+		let settled = false;
+		const done = () => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timer);
+			signal?.removeEventListener("abort", done);
+			resolve();
+		};
+		const timer = setTimeout(done, ms);
+		if (signal) {
+			if (signal.aborted) {
+				done();
+				return;
+			}
+			signal.addEventListener("abort", done, { once: true });
+		}
+	});
+}
+/**
+* Run `doFetch` with bounded transient-failure retries. `doFetch` is a
+* thunk so each attempt issues a FRESH request (bodies can't be replayed
+* from a consumed stream). Returns the final `Response` — which may still
+* carry a retryable status if all attempts are exhausted (the caller
+* handles that as it would a single-shot failure).
+*/
+async function fetchWithTransientRetry(doFetch, opts = {}) {
+	const attempts = Math.max(1, opts.attempts ?? 3);
+	const retryStatuses = opts.retryStatuses ?? DEFAULT_RETRY_STATUSES;
+	const baseDelayMs = opts.baseDelayMs ?? 250;
+	const maxDelayMs = opts.maxDelayMs ?? 4e3;
+	const { signal, label } = opts;
+	for (let attempt = 1;; attempt++) {
+		if (signal?.aborted) throw new DOMException("This operation was aborted", "AbortError");
+		let res;
+		let caught;
+		try {
+			res = await doFetch(attempt);
+		} catch (err) {
+			caught = err;
+		}
+		if (res && !retryStatuses.includes(res.status)) return res;
+		if (caught !== void 0) {
+			if (signal?.aborted) throw caught;
+			if (!isTransientNetworkError(caught)) throw caught;
+		}
+		if (attempt >= attempts) {
+			if (res) return res;
+			throw caught;
+		}
+		const retryAfterMs = res ? parseRetryAfter(res.headers.get("retry-after")) : void 0;
+		if (res?.body) try {
+			await res.body.cancel();
+		} catch {}
+		const expCap = Math.min(maxDelayMs, baseDelayMs * 2 ** (attempt - 1));
+		const delay = Math.min(maxDelayMs, retryAfterMs ?? Math.round(Math.random() * expCap));
+		if (label) {
+			const why = res ? `HTTP ${res.status}` : caught?.name ?? "error";
+			consola.debug(`[upstream-retry] ${label}: attempt ${attempt}/${attempts} failed (${why}); retrying in ${delay}ms`);
+		}
+		await abortableSleep(delay, signal);
+	}
+}
+/** Extract an HTTP status from a thrown error (HTTPError carries
+*  `.response.status`; others may carry `.status`/`.statusCode`; last
+*  resort parses `"HTTP <code>"` from the message). */
+function errorStatus(err) {
+	const e = err;
+	for (const v of [
+		e?.status,
+		e?.statusCode,
+		e?.response?.status
+	]) if (typeof v === "number") return v;
+	const m = /\bHTTP (\d{3})\b/.exec(e?.message ?? "");
+	return m ? Number(m[1]) : void 0;
+}
+/**
+* Generic transient-retry for a non-`Response`-returning call (e.g. the
+* Copilot service clients, which throw `HTTPError` on non-OK and throw on
+* network errors). Retries `fn()` when it throws a transient error — an
+* `HTTPError`-like with a retryable status (429/5xx) OR a transient
+* network/timeout error — using the same backoff + abort semantics as
+* `fetchWithTransientRetry`. Never retries a deterministic 4xx (incl.
+* 401), a non-transient throw, or a user cancel.
+*/
+async function withTransientRetry(fn, opts = {}) {
+	const attempts = Math.max(1, opts.attempts ?? 3);
+	const retryStatuses = opts.retryStatuses ?? DEFAULT_RETRY_STATUSES;
+	const baseDelayMs = opts.baseDelayMs ?? 250;
+	const maxDelayMs = opts.maxDelayMs ?? 4e3;
+	const { signal, label } = opts;
+	for (let attempt = 1;; attempt++) {
+		if (signal?.aborted) throw new DOMException("This operation was aborted", "AbortError");
+		try {
+			return await fn(attempt);
+		} catch (err) {
+			if (signal?.aborted) throw err;
+			const status = errorStatus(err);
+			if (!(status !== void 0 && retryStatuses.includes(status) || isTransientNetworkError(err)) || attempt >= attempts) throw err;
+			const retryAfterMs = parseRetryAfter(err?.response?.headers?.get?.("retry-after") ?? null);
+			const expCap = Math.min(maxDelayMs, baseDelayMs * 2 ** (attempt - 1));
+			const delay = Math.min(maxDelayMs, retryAfterMs ?? Math.round(Math.random() * expCap));
+			if (label) consola.debug(`[upstream-retry] ${label}: attempt ${attempt}/${attempts} threw (${status !== void 0 ? `HTTP ${status}` : err?.name ?? "error"}); retrying in ${delay}ms`);
+			await abortableSleep(delay, signal);
+		}
+	}
+}
+//#endregion
+//#region src/services/github/get-copilot-token.ts
+/**
+* Allowlist of hosts the router will trust as the Copilot API base URL.
+* Anything else returned in `endpoints.api` (e.g. via a tampered or
+* misconfigured token-exchange response) is rejected — otherwise a
+* malicious value would receive the long-lived GitHub PAT we send to
+* `/mcp` for web search (see `src/services/copilot/web-search.ts`).
+*/
+const COPILOT_HOST_ALLOWLIST = [
+	"api.githubcopilot.com",
+	"api.individual.githubcopilot.com",
+	"api.business.githubcopilot.com",
+	"api.enterprise.githubcopilot.com"
+];
+/**
+* True iff `rawUrl` is an HTTPS URL whose host is a trusted Copilot API host.
+* Exported so every path that sends a long-lived token to a discovered
+* Copilot host (web search, first-mate CAPI session logs) shares one allowlist.
+*/
+function isAllowedCopilotHost(rawUrl) {
+	let parsed;
+	try {
+		parsed = new URL(rawUrl);
+	} catch {
+		return false;
+	}
+	if (parsed.protocol !== "https:") return false;
+	return COPILOT_HOST_ALLOWLIST.includes(parsed.hostname);
+}
+const getCopilotToken = async () => {
+	const response = await fetchWithTransientRetry(() => fetch(`${GITHUB_API_BASE_URL}/copilot_internal/v2/token`, { headers: githubHeaders(state) }), { label: "/copilot_internal/v2/token" });
+	if (!response.ok) throw new HTTPError("Failed to get Copilot token", response);
+	const data = await response.json();
+	if (data.endpoints?.api) if (isAllowedCopilotHost(data.endpoints.api)) state.copilotApiUrl = data.endpoints.api;
+	else consola.warn(`Refusing to honor Copilot API endpoint "${data.endpoints.api}" from the token-exchange response — not in allowlist (${COPILOT_HOST_ALLOWLIST.join(", ")}). ` + (state.copilotApiUrl ? `Keeping existing override "${state.copilotApiUrl}".` : `Falling back to the default api.githubcopilot.com.`));
+	return data;
+};
+//#endregion
+//#region src/services/github/get-device-code.ts
+const DEFAULT_DEVICE_APP = {
+	clientId: GITHUB_CLIENT_ID,
+	scope: GITHUB_APP_SCOPES
+};
+async function getDeviceCode(app = DEFAULT_DEVICE_APP) {
+	const response = await fetchWithTransientRetry(() => fetch(`${GITHUB_BASE_URL}/login/device/code`, {
+		method: "POST",
+		headers: standardHeaders(),
+		body: JSON.stringify({
+			client_id: app.clientId,
+			scope: app.scope
+		})
+	}), { label: "/login/device/code" });
+	if (!response.ok) throw new HTTPError("Failed to get device code", response);
+	return await response.json();
+}
+//#endregion
+//#region src/services/github/get-user.ts
+async function getGitHubUser() {
+	const response = await fetchWithTransientRetry(() => fetch(`${GITHUB_API_BASE_URL}/user`, { headers: {
+		authorization: `token ${state.githubToken}`,
+		...standardHeaders()
+	} }), { label: "/user" });
+	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 () => {
+	const response = await fetchWithTransientRetry(() => tryRefreshAndRetry(() => fetch(`${copilotBaseUrl(state)}/models`, { headers: copilotHeaders(state) }), "/models"), { label: "/models" });
+	if (!response.ok) throw new HTTPError("Failed to get models", response);
+	return await response.json();
+};
+//#endregion
+//#region src/services/get-copilot-version.ts
+/**
+* Last-resort floor when the lookup fails. A fallback must never become the
+* cached steady state — see the note on `VSCODE_VERSION_FALLBACK` in
+* `./get-vscode-version`.
+*/
+const COPILOT_CHAT_VERSION_FALLBACK = "0.43.2026033101";
+/**
+* The lookup, reporting failure as `undefined` rather than as the fallback.
+* See `getVSCodeVersionOrUndefined` for why the distinction matters to the
+* version cache.
+*/
+async function getCopilotChatVersionOrUndefined() {
+	const controller = new AbortController();
+	const timeout = setTimeout(() => {
+		controller.abort();
+	}, 5e3);
+	try {
+		const response = await fetch("https://marketplace.visualstudio.com/_apis/public/gallery/extensionquery", {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				Accept: "application/json;api-version=7.1-preview.1"
+			},
+			body: JSON.stringify({
+				filters: [{ criteria: [{
+					filterType: 7,
+					value: "GitHub.copilot-chat"
+				}] }],
+				flags: 914
+			}),
+			signal: controller.signal
+		});
+		if (!response.ok) return void 0;
+		return (await response.json())?.results?.[0]?.extensions?.[0]?.versions?.[0]?.version;
+	} catch {
+		return;
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+//#endregion
+//#region src/services/get-vscode-version.ts
+/**
+* Last-resort floor when the lookup fails. A fallback must never become the
+* cached steady state, or a transient outage would freeze the version we
+* impersonate. See `src/lib/editor-version-cache.ts`.
+*/
+const VSCODE_VERSION_FALLBACK = "1.104.3";
+/**
+* The lookup, reporting failure as `undefined` rather than as the fallback.
+*
+* The distinction is load-bearing for the cache: it must not infer "the fetch
+* failed" from `value === FALLBACK`, because the live version legitimately
+* equals the constant right after someone bumps `VSCODE_VERSION_FALLBACK` to
+* the then-current release — and that reading would refuse to cache a perfectly
+* good result, making every launch re-pay the ~1.5s network call forever.
+*/
+async function getVSCodeVersionOrUndefined() {
+	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.]+)/);
+		return match ? match[1] : void 0;
+	} catch {
+		return;
+	} finally {
+		clearTimeout(timeout);
+	}
+}
+//#endregion
+//#region src/lib/editor-version-cache.ts
+/**
+* Disk-backed TTL cache for the EDITOR IDENTITY versions the proxy sends
+* upstream: the VS Code version (`editor-version`) and the Copilot Chat
+* extension version (`editor-plugin-version`), see `src/lib/api-config.ts`.
+*
+* Why this exists: impersonating VS Code is non-negotiable — Copilot is
+* addressed as if by the real editor, so those headers must carry real,
+* current versions. But the two lookups are NETWORK calls to third parties
+* (the Arch AUR PKGBUILD and the VS Marketplace), and they sat on the
+* blocking launch path of EVERY invocation. The AUR fetch alone measured
+* ~1.5-1.8s, which every `github-router` process paid — including the
+* per-turn Claude Code hooks (`internal-prompt-submit`, `internal-stop-hook`,
+* …), each of which is a fresh `node dist/main.js` spawn.
+*
+* The fix is a cache, NOT a removal. Both fetches are still made; they are
+* just made at most once per `TTL_HOURS` instead of once (twice, before the
+* duplicate top-level await in `get-vscode-version.ts` was dropped) per
+* launch. A 12h TTL keeps the impersonated versions well inside the real
+* editor's release cadence.
+*
+* Two invariants that keep impersonation honest:
+*
+*   1. A FALLBACK is NEVER cached. `getVSCodeVersion()` /
+*      `getCopilotChatVersion()` return a hardcoded constant when the network
+*      fails, and that constant must stay a last-resort floor for the current
+*      process — never the persisted steady state. Persisting it would let a
+*      transient outage silently freeze the advertised version for 12h, and
+*      (worse) survive restarts. `writeEntry` is therefore only reached on a
+*      value that differs from the fallback.
+*   2. The timestamp is written only on SUCCESS. An offline machine retries
+*      on the next launch rather than pinning a stale entry, which is the
+*      opposite of `claude-version-check.ts`'s throttle (that one stamps
+*      after the probes regardless, so an offline box pays both timeouts
+*      hourly). Do not copy that detail here.
+*
+* The file lives beside `last-update-check` / `last-self-update-check` and is
+* deliberately named distinctly so the three throttles never cross-suppress.
+*/
+const TTL_HOURS = 12;
+function cacheFilePath() {
+	return path.join(PATHS.APP_DIR, "last-editor-versions");
+}
+async function readCache() {
+	try {
+		const parsed = JSON.parse(await fs.readFile(cacheFilePath(), "utf8"));
+		if (!parsed || typeof parsed !== "object") return {};
+		return parsed;
+	} catch {
+		return {};
+	}
+}
+function isFresh(entry) {
+	if (!entry || typeof entry.value !== "string" || entry.value.length === 0) return false;
+	const last = new Date(entry.checkedAt).getTime();
+	if (Number.isNaN(last)) return false;
+	const ageHours = (Date.now() - last) / 1e3 / 3600;
+	return ageHours >= 0 && ageHours < TTL_HOURS;
+}
+/**
+* Serializes the read-modify-write below.
+*
+* `setupAndServe` resolves both keys concurrently (`Promise.all`). Without
+* this, both callers would `readCache()` into their OWN object, spend ~1.5s in
+* their network fetch, and then write that stale object back — so whichever
+* finished last would clobber the other's entry, and one of the two versions
+* would re-fetch on every launch forever.
+*
+* The chain also re-reads immediately before mutating, so the write is against
+* current disk state rather than the snapshot taken before the fetch.
+*/
+let writeChain = Promise.resolve();
+function serializeWrite(fn) {
+	const next = writeChain.then(fn, fn);
+	writeChain = next.catch(() => {});
+	return next;
+}
+/**
+* Resolve `key` through the cache, calling `fetchFresh` only on a miss.
+*
+* `fetchFresh` signals failure by returning `undefined` — NOT by returning the
+* fallback constant. Inferring failure from `value === fallback` would break
+* exactly when the live version happens to equal the hardcoded constant, which
+* is the normal state right after someone bumps that constant to the
+* then-current version: the entry would never be written and every launch
+* would pay the ~1.5s fetch forever, silently defeating the cache.
+*
+* `fallback` is returned when the lookup fails and no usable cached value
+* exists. It is never persisted (invariant 1 above), so a transient outage
+* cannot freeze the version we impersonate.
+*/
+async function resolveEditorVersion(key, fetchFresh, fallback) {
+	const entry = (await readCache())[key];
+	const cachedValue = isFresh(entry) ? entry.value : void 0;
+	if (cachedValue !== void 0) return cachedValue;
+	const fetched = await fetchFresh();
+	if (fetched !== void 0 && fetched.length > 0) {
+		await serializeWrite(async () => {
+			const cache = await readCache();
+			cache[key] = {
+				value: fetched,
+				checkedAt: (/* @__PURE__ */ new Date()).toISOString()
+			};
+			try {
+				await fs.mkdir(path.dirname(cacheFilePath()), { recursive: true });
+				await fs.writeFile(cacheFilePath(), JSON.stringify(cache), { mode: 384 });
+			} catch (err) {
+				consola.debug("Failed to write editor-version cache:", err);
+			}
+		});
+		return fetched;
+	}
+	if (typeof entry?.value === "string" && entry.value.length > 0) return entry.value;
+	return fallback;
+}
+//#endregion
+//#region src/lib/utils.ts
+const sleep = (ms) => new Promise((resolve) => {
+	setTimeout(resolve, ms);
+});
+const isNullish = (value) => value === null || value === void 0;
+/**
+* Beta prefixes VS Code Copilot Chat v0.43 actually sends.
+* Default mode — makes proxy traffic indistinguishable from VS Code.
+*/
+const VSCODE_BETA_PREFIXES = [
+	"interleaved-thinking-",
+	"context-management-",
+	"advanced-tool-use-"
+];
+/**
+* Extended beta prefixes for Claude CLI compatibility.
+* Enabled via --extended-betas flag. Includes all betas confirmed
+* to work with the Copilot API.
+*
+* Notably absent (Copilot 400s on these — verified live):
+*   context-1m-, skills-, files-api-, code-execution-, output-128k-,
+*   advisor-tool- (see EXPLICITLY_STRIPPED_BETA_PREFIXES below).
+* 1M context is unlocked by selecting `claude-opus-4.7-1m-internal`
+* as the model id, not via a beta header.
+*
+* Empirical verification (2026-05-11 against api.enterprise.githubcopilot.com):
+*   task-budgets-2026-03-13          → 200 ACCEPTED (cost-ceiling leverage)
+*   token-efficient-tools-2026-03-28 → 200 ACCEPTED (per-tool token saving)
+*   summarize-connector-text-2026-03-13 → 200 (Anthropic-internal feature flag,
+*     won't fire for non-ant users; allowlisted defensively for ant edge case)
+*   afk-mode-2026-01-31              → 200 (Anthropic-internal feature flag)
+*   cli-internal-2026-02-09          → 200 (USER_TYPE=ant only)
+*   oauth-2025-04-20                 → 200 (Files-API path; Files-API itself
+*     is not supportable via Copilot, but the header alone is harmless)
+*   prompt-caching-scope-2026-01-05  → 200 even with body cache_control.scope
+*     stripped (already covered by `prompt-caching-` prefix above)
+*/
+const EXTENDED_BETA_PREFIXES = [
+	...VSCODE_BETA_PREFIXES,
+	"claude-code-",
+	"effort-",
+	"prompt-caching-",
+	"computer-use-",
+	"pdfs-",
+	"max-tokens-",
+	"token-counting-",
+	"compact-",
+	"structured-outputs-",
+	"fast-mode-",
+	"mcp-client-",
+	"mcp-servers-",
+	"redact-thinking-",
+	"web-search-",
+	"task-budgets-",
+	"token-efficient-tools-",
+	"summarize-connector-text-",
+	"afk-mode-",
+	"cli-internal-",
+	"oauth-"
+];
+/**
+* Beta prefixes the proxy explicitly STRIPS even from the extended
+* allowlist (and even if a future leverage mode broadens the allowlist
+* further). Defensive layer: today's allowlist-only filter would already
+* drop these because they're not in any allowlist, but keeping an
+* explicit deny-list catches future changes that broaden allow rules
+* (e.g. a hypothetical pattern-based mode that lets `claude-*` through).
+*
+* Empirical (2026-05-11): Copilot returns HTTP 400
+*   `unsupported beta header(s): advisor-tool-2026-03-01`
+* on every request that includes `advisor-tool-`. Stripping it is the
+* difference between a working request (no ADVISOR semantics) and a
+* fully-failed request. Document upstream limitation in CLAUDE.md.
+*/
+const EXPLICITLY_STRIPPED_BETA_PREFIXES = ["advisor-tool-"];
+/**
+* Filter an `anthropic-beta` header value, keeping only beta flags
+* in the active whitelist AND not in the explicit-strip list.
+* Uses extended prefixes when --extended-betas is enabled, VS Code-only
+* prefixes otherwise. Returns the filtered comma-separated string,
+* or undefined if nothing remains.
+*/
+function filterBetaHeader(value) {
+	const prefixes = state.extendedBetas ? EXTENDED_BETA_PREFIXES : VSCODE_BETA_PREFIXES;
+	return value.split(",").map((v) => v.trim()).filter((v) => v && prefixes.some((prefix) => v.startsWith(prefix)) && !EXPLICITLY_STRIPPED_BETA_PREFIXES.some((p) => v.startsWith(p))).join(",") || void 0;
+}
+/**
+* Normalize a model ID for fuzzy comparison: lowercase, replace dots with
+* dashes, insert dash at letter→digit boundaries, and collapse repeated
+* dashes. E.g. "gpt5.3-codex" → "gpt-5-3-codex", "GPT-5.3-Codex" → "gpt-5-3-codex".
+*/
+function normalizeModelId(id) {
+	return id.toLowerCase().replace(/\./g, "-").replace(/([a-z])(\d)/g, "$1-$2").replace(/-{2,}/g, "-");
+}
+/**
+* Resolve a model name to the best available variant in the Copilot model list.
+*
+* Resolution cascade:
+* 0. `[1m]` literal-bracket suffix: strip, delegate, warn if downgraded.
+*    Bracketed slug must never reach Copilot (400s on it). See cc-backup
+*    `src/utils/context.ts:35-40` for Claude Code's 1M unlock mechanism.
+* 1. Exact match
+* 2. Case-insensitive match
+* 3. Family preference (opus→1m, codex→highest version)
+* 4. Normalized match (dots→dashes, letter-digit boundaries)
+* 5. Anthropic dated-slug retry: if the input matches `claude-...-YYYYMMDD`,
+*    strip the date and re-run the cascade once. Family-guarded so non-claude
+*    8-digit suffixes can't be mis-stripped; runs after Steps 1-4 so explicit
+*    version pinning (a dated catalog id matched at Step 1) always wins.
+* 6. Return as-is with a warning
+*/
+/**
+* `[1m]`-downgrade warnings we've already emitted this process. `resolveModel`
+* is called many times per launch (env setup, model validation, the banner,
+* and — under `serve` — on every model-picker `/models` poll), so the downgrade
+* notice is deduped to once per model id to avoid log spam.
+*/
+const warnedOneMDowngrade = /* @__PURE__ */ new Set();
+function resolveModel(modelId) {
+	const models = state.models?.data;
+	if (!models) return modelId;
+	const oneMMatch = modelId.match(/^(.*)\[1m\]$/i);
+	if (oneMMatch) {
+		const stripped = oneMMatch[1];
+		const resolved = resolveModel(stripped);
+		if (!(/-1m(?:$|-)/.test(resolved) || (models.find((m) => m.id === resolved)?.capabilities?.limits?.max_context_window_tokens ?? 0) >= 1e6) && !warnedOneMDowngrade.has(modelId)) {
+			warnedOneMDowngrade.add(modelId);
+			consola.warn(`Model "${modelId}" requested 1M context but no 1M backend is in Copilot's catalog for this tier/family; downgrading upstream to "${resolved}" (200K). Claude Code's local context accounting will still assume 1M — expect premature auto-compact. Drop the [1m] suffix (or unset CLAUDE_CODE_DISABLE_1M_CONTEXT if you set it) to silence.`);
+		}
+		return resolved;
+	}
+	if (models.some((m) => m.id === modelId)) return modelId;
+	const lower = modelId.toLowerCase();
+	const ciMatch = models.find((m) => m.id.toLowerCase() === lower);
+	if (ciMatch) return ciMatch.id;
+	if (lower.includes("opus")) {
+		const oneMs = models.filter((m) => m.id.includes("opus") && /-1m(?:$|-)/.test(m.id));
+		const versionMatch = lower.match(/opus-(\d+)(?:[.-](\d+))?/);
+		const requestedVersion = versionMatch ? versionMatch[2] ? `${versionMatch[1]}.${versionMatch[2]}` : versionMatch[1] : void 0;
+		const oneM = (requestedVersion ? oneMs.find((m) => m.id.includes(`opus-${requestedVersion}-`)) : void 0) ?? (requestedVersion ? void 0 : oneMs[0]);
+		if (oneM) return oneM.id;
+	}
+	if (lower.includes("codex")) {
+		const codexModels = models.filter((m) => m.id.includes("codex") && !m.id.includes("mini"));
+		if (codexModels.length > 0) {
+			codexModels.sort((a, b) => b.id.localeCompare(a.id));
+			return codexModels[0].id;
+		}
+	}
+	const normalized = normalizeModelId(modelId);
+	const normMatch = models.find((m) => normalizeModelId(m.id) === normalized);
+	if (normMatch) return normMatch.id;
+	const dateStripped = modelId.replace(/^(claude-[\w.-]+)-20\d{6}$/i, "$1");
+	if (dateStripped !== modelId) {
+		const retried = resolveModel(dateStripped);
+		if (retried !== dateStripped || models.some((m) => m.id === dateStripped)) {
+			consola.info(`Resolved Anthropic dated slug "${modelId}" → "${retried}" (stripped -YYYYMMDD; pass an explicit catalog id to pin a snapshot)`);
+			return retried;
+		}
+	}
+	if (lower.startsWith("claude-")) {
+		const matchSonnet = /(?:^|-)sonnet(?:-|$)/.test(lower);
+		const matchHaiku = /(?:^|-)haiku(?:-|$)/.test(lower);
+		if (matchSonnet || matchHaiku) {
+			const family = matchSonnet ? "sonnet" : "haiku";
+			const familyMembers = models.filter((m) => new RegExp(`(?:^|-)${family}(?:-|$|\\.)`).test(m.id));
+			if (familyMembers.length > 0) {
+				familyMembers.sort((a, b) => b.id.localeCompare(a.id, void 0, { numeric: true }));
+				const best = familyMembers[0].id;
+				consola.info(`Model "${modelId}" not in Copilot catalog; falling back to highest available "${best}" (legacy ${family} slug). Pin a current catalog id to silence.`);
+				return best;
+			}
+		}
+	}
+	consola.warn(`Model "${modelId}" not found in Copilot model list. Available: ${models.map((m) => m.id).join(", ")}`);
+	return modelId;
+}
+/**
+* Resolve a codex model ID, falling back to the best available codex model.
+* Used by the codex subcommand for model selection.
+*/
+function resolveCodexModel(modelId) {
+	const resolved = resolveModel(modelId);
+	const models = state.models?.data;
+	if (!models) return resolved;
+	if (models.some((m) => m.id === resolved)) return resolved;
+	const candidates = models.filter((m) => {
+		const endpoints = m.supported_endpoints ?? [];
+		if (m.id.includes("mini") || m.id.includes("nano")) return false;
+		return endpoints.length === 0 || endpoints.includes("/responses");
+	});
+	if (candidates.length > 0) {
+		candidates.sort((a, b) => {
+			const aCodex = a.id.includes("codex") ? 1 : 0;
+			const bCodex = b.id.includes("codex") ? 1 : 0;
+			if (aCodex !== bCodex) return bCodex - aCodex;
+			return b.id.localeCompare(a.id);
+		});
+		const best = candidates[0].id;
+		consola.warn(`Model "${modelId}" not available, using "${best}" instead`);
+		return best;
+	}
+	return resolved;
+}
+async function cacheModels() {
+	const models = await getModels();
+	state.models = models;
+}
+const cacheVSCodeVersion = async () => {
+	const response = await resolveEditorVersion("vscode", getVSCodeVersionOrUndefined, VSCODE_VERSION_FALLBACK);
+	state.vsCodeVersion = response;
+	consola.info(`Using VSCode version: ${response}`);
+};
+const cacheCopilotVersion = async () => {
+	const version = await resolveEditorVersion("copilotChat", getCopilotChatVersionOrUndefined, COPILOT_CHAT_VERSION_FALLBACK);
+	state.copilotVersion = version;
+	consola.info(`Using Copilot Chat version: ${version}`);
+};
+//#endregion
+//#region src/services/github/poll-access-token.ts
+async function pollAccessToken(deviceCode, clientId = GITHUB_CLIENT_ID) {
+	const sleepDuration = (deviceCode.interval + 1) * 1e3;
+	consola.debug(`Polling access token with interval of ${sleepDuration}ms`);
+	const expiresAt = Date.now() + deviceCode.expires_in * 1e3;
+	while (Date.now() < expiresAt) {
+		const response = await fetch(`${GITHUB_BASE_URL}/login/oauth/access_token`, {
+			method: "POST",
+			headers: standardHeaders(),
+			body: JSON.stringify({
+				client_id: clientId,
+				device_code: deviceCode.device_code,
+				grant_type: "urn:ietf:params:oauth:grant-type:device_code"
+			})
+		});
+		if (!response.ok) {
+			consola.error("Failed to poll access token:", await response.text());
+			if (Date.now() >= expiresAt) break;
+			await sleep(sleepDuration);
+			continue;
+		}
+		const json = await response.json();
+		consola.debug("Polling access token response:", json);
+		const { access_token } = json;
+		if (access_token) return access_token;
+		if (Date.now() >= expiresAt) break;
+		await sleep(sleepDuration);
+	}
+	throw new Error("Device code expired. Please run auth again.");
+}
+//#endregion
+//#region src/lib/token.ts
+const readGithubToken = () => fs.readFile(PATHS.GITHUB_TOKEN_PATH, "utf8");
+const writeGithubToken = (token) => fs.writeFile(PATHS.GITHUB_TOKEN_PATH, token);
+const readGithubAgentToken = () => fs.readFile(PATHS.GITHUB_AGENT_TOKEN_PATH, "utf8");
+const writeGithubAgentToken = (token) => fs.writeFile(PATHS.GITHUB_AGENT_TOKEN_PATH, token, { mode: 384 });
+const setupCopilotToken = async () => {
+	const { token, refresh_in } = await getCopilotToken();
+	state.copilotToken = token;
+	consola.debug("GitHub Copilot Token fetched successfully!");
+	if (state.showToken) consola.info("Copilot token:", token);
+	const refreshInterval = Math.max((refresh_in - 60) * 1e3, 1e3);
+	setInterval(() => {
+		refreshCopilotToken("interval");
+	}, refreshInterval);
+};
+let inflightRefresh;
+let lastRefreshSuccess = 0;
+let lastRefreshFailure = 0;
+const REFRESH_SUCCESS_COOLDOWN_MS = 3e4;
+const REFRESH_FAILURE_COOLDOWN_MS = 5e3;
+async function refreshCopilotToken(reason) {
+	if (inflightRefresh) return inflightRefresh;
+	if (reason === "401-retry") {
+		const now = Date.now();
+		if (now - lastRefreshSuccess < REFRESH_SUCCESS_COOLDOWN_MS) {
+			consola.debug(`refreshCopilotToken(${reason}) skipped: prior success within ${REFRESH_SUCCESS_COOLDOWN_MS}ms`);
+			return;
+		}
+		if (now - lastRefreshFailure < REFRESH_FAILURE_COOLDOWN_MS) {
+			consola.debug(`refreshCopilotToken(${reason}) skipped: prior failure within ${REFRESH_FAILURE_COOLDOWN_MS}ms`);
+			return;
+		}
+	}
+	inflightRefresh = (async () => {
+		consola.debug(`Refreshing Copilot token (reason=${reason})`);
+		try {
+			const { token } = await getCopilotToken();
+			state.copilotToken = token;
+			lastRefreshSuccess = Date.now();
+			consola.debug("Copilot token refreshed");
+			if (state.showToken) consola.info("Refreshed Copilot token:", token);
+		} catch (error) {
+			lastRefreshFailure = Date.now();
+			consola.error(`Failed to refresh Copilot token (reason=${reason}):`, error);
+		} finally {
+			inflightRefresh = void 0;
+		}
+	})();
+	return inflightRefresh;
+}
+/**
+* Try `request()`. If it returns a 401, refresh the Copilot token (subject
+* to the single-flight + refresh-storm-protection of `refreshCopilotToken`)
+* and retry once. After one retry, propagate whatever the second attempt
+* returned — the caller's existing 401-handling path is preserved.
+*
+* The `request` callback is responsible for capturing `state.copilotToken`
+* locally before any await; this helper does NOT re-build the request
+* itself, just re-invokes the callback after a refresh.
+*/
+async function tryRefreshAndRetry(request, routePath) {
+	const first = await request();
+	if (first.status !== 401) return first;
+	consola.warn(`${routePath}: upstream returned 401, attempting one token refresh + retry`);
+	await refreshCopilotToken("401-retry");
+	return request();
+}
+async function setupGitHubToken(options) {
+	try {
+		const githubToken = await readGithubToken();
+		if (githubToken && !options?.force) {
+			state.githubToken = githubToken;
+			if (state.showToken) consola.info("GitHub token:", githubToken);
+			await logUser();
+			return;
+		}
+		consola.info("Not logged in, getting new access token");
+		const response = await getDeviceCode();
+		consola.debug("Device code response:", response);
+		consola.info(`Please enter the code "${response.user_code}" in ${response.verification_uri}`);
+		const token = await pollAccessToken(response);
+		await writeGithubToken(token);
+		state.githubToken = token;
+		if (state.showToken) consola.info("GitHub token:", token);
+		await logUser();
+	} catch (error) {
+		if (error instanceof HTTPError) {
+			consola.error("Failed to get GitHub token:", await error.response.json());
+			throw error;
+		}
+		consola.error("Failed to get GitHub token:", error);
+		throw error;
+	}
+}
+async function logUser() {
+	const user = await getGitHubUser();
+	consola.info(`Logged in as ${user.login}`);
+}
+/**
+* Set up the SECOND, write-capable GitHub token used by the first-mate
+* agent-orchestration surface (`--agents`). Mirrors `setupGitHubToken`
+* but authenticates against the GitHub CLI's OAuth client
+* (`GITHUB_AGENT_CLIENT_ID`) requesting `repo workflow read:org`, and
+* stores the result apart at `PATHS.GITHUB_AGENT_TOKEN_PATH`. The Copilot
+* App token (`state.githubToken`) is left completely untouched — this is
+* a distinct identity for a distinct capability.
+*
+* Long-lived (device-flow user token) → no refresh loop; a later 401 is
+* surfaced to the caller as a revoked grant to re-run the login. Called
+* once from `setupAndServe` when `state.agentsEnabled` is true.
+*/
+async function setupGitHubAgentToken(options) {
+	try {
+		const existing = (await readGithubAgentToken().catch(() => "")).trim();
+		if (existing && !options?.force) {
+			state.githubAgentToken = existing;
+			if (state.showToken) consola.info("GitHub agent token:", existing);
+			await warnIfAgentScopesInsufficient();
+			return;
+		}
+		consola.info("Agent mode (--agents): a second GitHub login is required for a write-capable token (repo, workflow, read:org).");
+		const response = await getDeviceCode({
+			clientId: GITHUB_AGENT_CLIENT_ID,
+			scope: GITHUB_AGENT_SCOPES
+		});
+		consola.debug("Agent device code response:", response);
+		consola.info(`Please enter the code "${response.user_code}" in ${response.verification_uri} to authorize github-router's cloud-agent orchestration to act on your repositories.`);
+		const token = await pollAccessToken(response, GITHUB_AGENT_CLIENT_ID);
+		await writeGithubAgentToken(token);
+		state.githubAgentToken = token;
+		if (state.showToken) consola.info("GitHub agent token:", token);
+		await warnIfAgentScopesInsufficient();
+	} catch (error) {
+		if (error instanceof HTTPError) {
+			consola.error("Failed to get GitHub agent token:", await error.response.json());
+			throw error;
+		}
+		consola.error("Failed to get GitHub agent token:", error);
+		throw error;
+	}
+}
+/**
+* Best-effort check that the agent token actually carries the scopes we
+* asked for. The GitHub CLI OAuth client is a classic OAuth App, so the
+* granted scopes are echoed in the `x-oauth-scopes` response header on
+* any authenticated call. Warn loudly (not fatal) if `repo`/`workflow`
+* are missing so the failure is diagnosable at login rather than at the
+* first write 403.
+*/
+async function warnIfAgentScopesInsufficient() {
+	try {
+		const res = await fetch(`${GITHUB_API_BASE_URL}/user`, { headers: githubAgentHeaders(state) });
+		if (res.status === 401) {
+			consola.warn("GitHub agent token was rejected (401) — the grant may have been revoked. Re-run with --agents to log in again.");
+			return;
+		}
+		const scopes = (res.headers.get("x-oauth-scopes") ?? "").split(",").map((s) => s.trim()).filter(Boolean);
+		const missing = ["repo", "workflow"].filter((s) => !scopes.includes(s));
+		if (missing.length > 0) consola.warn(`GitHub agent token is missing scope(s): ${missing.join(", ")}. The first-mate surface needs 'repo' + 'workflow' to create issues, assign cloud agents, and dispatch workflows. Re-run the agent login and grant the requested scopes.`);
+	} catch (err) {
+		consola.debug("Agent token scope check skipped:", err);
+	}
+}
+//#endregion
+export { copilotHeaders as C, githubHeaders as D, githubAgentHeaders as E, state as O, copilotBaseUrl as S, githubAgentGraphQLHeaders as T, withTransientRetry as _, cacheCopilotVersion as a, GITHUB_API_BASE_URL as b, filterBetaHeader as c, resolveModel as d, sleep as f, fetchWithTransientRetry as g, isAllowedCopilotHost as h, tryRefreshAndRetry as i, isNullish as l, getGitHubUser as m, setupGitHubAgentToken as n, cacheModels as o, getModels as p, setupGitHubToken as r, cacheVSCodeVersion as s, setupCopilotToken as t, resolveCodexModel as u, HTTPError as v, copilotVersion as w, GITHUB_GRAPHQL_URL as x, forwardError as y };
+
+//# sourceMappingURL=token-R2ocFC3M.js.map