github-router 0.3.263 → 0.3.270

package/dist/{token-C8Uh7aUe.js → token-iaSGp76k.js}

@@ -1,4 +1,4 @@
-import { t as PATHS } from "./paths-BXrbboAS.js";
+import { t as PATHS } from "./paths-Bg1_DWhi.js";
 import consola from "consola";
 import path from "node:path";
 import { randomBytes, randomUUID } from "node:crypto";
@@ -83,123 +83,6 @@ const githubAgentGraphQLHeaders = (state, features) => ({
 	...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`).
@@ -234,6 +117,154 @@ const DEFAULT_RETRY_STATUSES = [
 	503,
 	504
 ];
+const TRANSPORT_MESSAGE_MAX = 512;
+const TRANSIENT_CODES = /* @__PURE__ */ new Set([
+	"ECONNRESET",
+	"ETIMEDOUT",
+	"EPIPE",
+	"EAI_AGAIN",
+	"UND_ERR_CONNECT_TIMEOUT",
+	"UND_ERR_HEADERS_TIMEOUT",
+	"UND_ERR_SOCKET"
+]);
+const DETERMINISTIC_CODES = /* @__PURE__ */ new Set([
+	"ENOTFOUND",
+	"ECONNREFUSED",
+	"DEPTH_ZERO_SELF_SIGNED_CERT",
+	"SELF_SIGNED_CERT_IN_CHAIN",
+	"UNABLE_TO_GET_ISSUER_CERT",
+	"UNABLE_TO_GET_ISSUER_CERT_LOCALLY",
+	"UNABLE_TO_VERIFY_LEAF_SIGNATURE",
+	"CERT_HAS_EXPIRED",
+	"CERT_NOT_YET_VALID",
+	"ERR_TLS_CERT_ALTNAME_INVALID",
+	"ERR_TLS_CERT_SIGNATURE_ALGORITHM_UNSUPPORTED",
+	"ERR_SSL_WRONG_VERSION_NUMBER"
+]);
+const CREDENTIAL_RE = /\b(eyJ[A-Za-z0-9_-]{20,}(?:\.[A-Za-z0-9_-]+){0,2}|gh[opsu]_[A-Za-z0-9_]{20,}|Bearer\s+\S{20,})\b/gi;
+const SECRET_ASSIGNMENT_RE = /\b(authorization|api[_-]?key|access[_-]?token|token|password)\s*[:=]\s*([^\s,;]+)/gi;
+const REQUEST_BODY_RE = /\b(request\s+body|body)\s*[:=]\s*.*$/gi;
+var TransportExhaustionError = class extends Error {
+	endpoint;
+	label;
+	attempts;
+	classification;
+	lastError;
+	constructor(metadata, cause) {
+		const target = metadata.endpoint ?? metadata.label ?? "upstream";
+		const lastError = {
+			name: sanitizeTransportText(metadata.lastError.name),
+			message: sanitizeTransportText(metadata.lastError.message),
+			code: metadata.lastError.code ? sanitizeTransportText(metadata.lastError.code) : void 0,
+			causeCode: metadata.lastError.causeCode ? sanitizeTransportText(metadata.lastError.causeCode) : void 0
+		};
+		const code = lastError.causeCode ?? lastError.code;
+		const suffix = code ? ` (${code})` : "";
+		super(`Upstream transport ${metadata.classification === "transient" ? "failed" : "is unreachable"} at ${sanitizeTransportText(target)} after ${metadata.attempts} attempt${metadata.attempts === 1 ? "" : "s"}: ${lastError.name}: ${lastError.message}${suffix}`, { cause });
+		this.name = "TransportExhaustionError";
+		this.endpoint = metadata.endpoint ? sanitizeTransportText(metadata.endpoint) : void 0;
+		this.label = metadata.label ? sanitizeTransportText(metadata.label) : void 0;
+		this.attempts = metadata.attempts;
+		this.classification = metadata.classification;
+		this.lastError = lastError;
+	}
+};
+function readStringProperty(value, key) {
+	if (typeof value !== "object" && typeof value !== "function" || value === null) return;
+	try {
+		const property = value[key];
+		return typeof property === "string" ? property : void 0;
+	} catch {
+		return;
+	}
+}
+function readCause(value) {
+	if (typeof value !== "object" && typeof value !== "function" || value === null) return;
+	try {
+		return value.cause;
+	} catch {
+		return;
+	}
+}
+function safeString(value) {
+	try {
+		return String(value);
+	} catch {
+		return "[unserializable error]";
+	}
+}
+function sanitizeTransportText(value) {
+	const sanitized = value.replace(/\r\n|\r|\n/g, " ").replace(CREDENTIAL_RE, "[REDACTED]").replace(SECRET_ASSIGNMENT_RE, "$1=[REDACTED]").replace(REQUEST_BODY_RE, "$1=[REDACTED]");
+	return sanitized.length > TRANSPORT_MESSAGE_MAX ? `${sanitized.slice(0, TRANSPORT_MESSAGE_MAX)}…` : sanitized;
+}
+/**
+* Classify errors thrown before the first response byte. Deterministic
+* connectivity/configuration signals win over generic runtime wording such as
+* TypeError("fetch failed"), because the nested cause is more specific.
+*/
+function classifyTransportError(error, opts = {}) {
+	const name = readStringProperty(error, "name") ?? "Error";
+	const rawMessage = readStringProperty(error, "message") ?? (typeof error === "string" ? error : safeString(error));
+	const message = sanitizeTransportText(rawMessage);
+	const code = readStringProperty(error, "code");
+	const causes = [];
+	const seen = /* @__PURE__ */ new Set();
+	let current = readCause(error);
+	for (let depth = 0; current !== void 0 && depth < 4; depth++) {
+		if ((typeof current === "object" || typeof current === "function") && current !== null) {
+			if (seen.has(current)) break;
+			seen.add(current);
+		}
+		causes.push(current);
+		current = readCause(current);
+	}
+	const causeCode = causes.map((cause) => readStringProperty(cause, "code")).find((value) => value !== void 0);
+	const codes = [code, ...causes.map((cause) => readStringProperty(cause, "code"))].filter((value) => value !== void 0).map((value) => value.toUpperCase());
+	const messages = [rawMessage, ...causes.map((cause) => readStringProperty(cause, "message") ?? "")].join(" ").toLowerCase();
+	if (opts.callerCancelled) return {
+		classification: "cancelled",
+		name,
+		message,
+		code,
+		causeCode
+	};
+	if (codes.some((value) => DETERMINISTIC_CODES.has(value)) || messages.includes("self signed certificate") || messages.includes("certificate has expired") || messages.includes("unable to verify the first certificate") || messages.includes("unable to get local issuer certificate") || messages.includes("hostname/ip does not match certificate") || messages.includes("tls handshake") || messages.includes("ssl routines") || messages.includes("econnrefused") || messages.includes("enotfound")) return {
+		classification: "deterministic",
+		name,
+		message,
+		code,
+		causeCode
+	};
+	if (name === "AbortError" || name === "TimeoutError" || name === "InactivityTimeout" || codes.some((value) => TRANSIENT_CODES.has(value)) || messages.includes("terminated") || messages.includes("fetch failed") || messages.includes("network error") || messages.includes("socket hang up") || messages.includes("socket closed") || messages.includes("econnreset") || messages.includes("etimedout") || messages.includes("epipe") || messages.includes("eai_again")) return {
+		classification: "transient",
+		name,
+		message,
+		code,
+		causeCode
+	};
+	return {
+		classification: "non_transport",
+		name,
+		message,
+		code,
+		causeCode
+	};
+}
+function transportExhaustion(error, attempts, opts, details) {
+	if (details.classification !== "transient" && details.classification !== "deterministic") throw new TypeError("transportExhaustion requires a transport error");
+	return new TransportExhaustionError({
+		endpoint: opts.endpoint ?? opts.label,
+		label: opts.label,
+		attempts,
+		classification: details.classification,
+		lastError: {
+			name: details.name,
+			message: details.message,
+			code: details.code,
+			causeCode: details.causeCode
+		}
+	}, error);
+}
 function parseRetryAfter(headerValue) {
 	if (!headerValue) return void 0;
 	const secs = Number(headerValue);
@@ -241,27 +272,6 @@ function parseRetryAfter(headerValue) {
 	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) {
@@ -310,11 +320,14 @@ async function fetchWithTransientRetry(doFetch, opts = {}) {
 		if (res && !retryStatuses.includes(res.status)) return res;
 		if (caught !== void 0) {
 			if (signal?.aborted) throw caught;
-			if (!isTransientNetworkError(caught)) throw caught;
+			const details = classifyTransportError(caught);
+			if (details.classification === "deterministic") throw transportExhaustion(caught, attempt, opts, details);
+			if (details.classification !== "transient") throw caught;
 		}
 		if (attempt >= attempts) {
 			if (res) return res;
-			throw caught;
+			const details = classifyTransportError(caught);
+			throw transportExhaustion(caught, attempt, opts, details);
 		}
 		const retryAfterMs = res ? parseRetryAfter(res.headers.get("retry-after")) : void 0;
 		if (res?.body) try {
@@ -364,7 +377,14 @@ async function withTransientRetry(fn, opts = {}) {
 		} 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 details = classifyTransportError(err);
+			if (status !== void 0) {
+				if (!retryStatuses.includes(status) || attempt >= attempts) throw err;
+			} else {
+				if (details.classification === "deterministic") throw transportExhaustion(err, attempt, opts, details);
+				if (details.classification !== "transient") throw err;
+				if (attempt >= attempts) throw transportExhaustion(err, attempt, opts, details);
+			}
 			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));
@@ -374,6 +394,146 @@ async function withTransientRetry(fn, opts = {}) {
 	}
 }
 //#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 TransportExhaustionError) {
+		const target = sanitizeTransportText(error.endpoint ?? error.label ?? c.req.path);
+		const diagnostic = formatTransportDiagnostic(error);
+		if (error.classification === "transient") return c.json({
+			type: "error",
+			error: {
+				type: "overloaded_error",
+				message: `Upstream transport was interrupted at ${target} after ${error.attempts} attempts; retry later. ${diagnostic}`
+			}
+		}, 503);
+		return c.json({
+			type: "error",
+			error: {
+				type: "api_error",
+				message: `Could not connect to upstream at ${target}. Check DNS, proxy, firewall, and TLS configuration. ${diagnostic}`
+			}
+		}, 502);
+	}
+	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 formatTransportDiagnostic(error) {
+	const code = error.lastError.causeCode ?? error.lastError.code;
+	const codeText = code ? ` (${sanitizeTransportText(code)})` : "";
+	return `${sanitizeTransportText(error.lastError.name)}: ${sanitizeTransportText(error.lastError.message)}${codeText}`;
+}
+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/services/github/get-copilot-token.ts
 /**
 * Allowlist of hosts the router will trust as the Copilot API base URL.
@@ -936,7 +1096,22 @@ async function pollAccessToken(deviceCode, clientId = GITHUB_CLIENT_ID) {
 //#region src/lib/token.ts
 const readGithubToken = () => fs.readFile(PATHS.GITHUB_TOKEN_PATH, "utf8");
 /**
-* Replace a credential file atomically: temp + rename.
+* Backoff for a transient Windows rename failure. On Windows `fs.rename` over
+* an existing destination transiently fails with EPERM / EBUSY / EACCES when
+* anything else holds the target open for a moment (antivirus, the search
+* indexer, a backup agent). Nothing is wrong and the handle closes microseconds
+* later — but without a retry, a scan landing on the wrong millisecond throws
+* out of a credential write and costs the user a re-auth. Same delays as
+* `renameWithRetry` in `~/lib/claude-md-injection`, which documents the
+* underlying behavior at length.
+*/
+const RENAME_RETRY_DELAYS_MS = [
+	50,
+	200,
+	500
+];
+/**
+* Replace a credential file atomically: temp + rename, with bounded retry.
 *
 * A plain `fs.writeFile` truncates the destination before it writes, so a
 * crash, a full disk, or a kill mid-write leaves a truncated token on disk and
@@ -963,7 +1138,17 @@ async function writeTokenFileAtomic(filePath, token) {
 			mode: 384,
 			flag: "wx"
 		});
-		await fs.rename(tmp, filePath);
+		let lastErr;
+		let renamed = false;
+		for (let attempt = 0; attempt <= RENAME_RETRY_DELAYS_MS.length; attempt++) try {
+			await fs.rename(tmp, filePath);
+			renamed = true;
+			break;
+		} catch (err) {
+			lastErr = err;
+			if (attempt < RENAME_RETRY_DELAYS_MS.length) await new Promise((resolve) => setTimeout(resolve, RENAME_RETRY_DELAYS_MS[attempt]));
+		}
+		if (!renamed) throw lastErr;
 	} catch (err) {
 		await fs.unlink(tmp).catch(() => {});
 		throw err;
@@ -972,15 +1157,39 @@ async function writeTokenFileAtomic(filePath, token) {
 const writeGithubToken = (token) => writeTokenFileAtomic(PATHS.GITHUB_TOKEN_PATH, token);
 const readGithubAgentToken = () => fs.readFile(PATHS.GITHUB_AGENT_TOKEN_PATH, "utf8");
 const writeGithubAgentToken = (token) => writeTokenFileAtomic(PATHS.GITHUB_AGENT_TOKEN_PATH, token);
+/**
+* Fetch the Copilot token and keep it fresh in the background.
+*
+* Returns a disposer that stops the refresh loop. **Long-lived callers**
+* (`start`/`claude`/`codex`, via `setupAndServe`) can ignore it — the interval
+* is `unref()`d, so it never holds the event loop open on its own. The one-shot
+* `models` command calls it, so ownership of the timer is explicit rather than
+* implied by a runtime flag. (`check-usage` does not call this function at all;
+* it only needs `setupGitHubToken`.)
+*
+* Both halves are load-bearing, for different failure modes. Without the
+* `unref()`, `github-router models` printed its full correct output and then
+* hung forever: its success path just returns (only the failure branches call
+* `process.exit`), and the un-unref'd interval pinned the event loop. Without
+* the disposer, that fix would depend on a property no caller can see, so the
+* next one-shot command would inherit the same trap.
+*/
 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(() => {
+	const handle = setInterval(() => {
 		refreshCopilotToken("interval");
 	}, refreshInterval);
+	handle.unref?.();
+	let stopped = false;
+	return () => {
+		if (stopped) return;
+		stopped = true;
+		clearInterval(handle);
+	};
 };
 let inflightRefresh;
 let lastRefreshSuccess = 0;
@@ -1131,6 +1340,6 @@ async function warnIfAgentScopesInsufficient() {
 	}
 }
 //#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 };
+export { state as A, GITHUB_GRAPHQL_URL as C, githubAgentGraphQLHeaders as D, copilotVersion as E, githubAgentHeaders as O, GITHUB_API_BASE_URL as S, copilotHeaders as T, forwardError as _, cacheCopilotVersion as a, sanitizeTransportText as b, filterBetaHeader as c, resolveModel as d, sleep as f, HTTPError as g, isAllowedCopilotHost as h, tryRefreshAndRetry as i, githubHeaders as k, 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, classifyTransportError as v, copilotBaseUrl as w, withTransientRetry as x, fetchWithTransientRetry as y };
 
-//# sourceMappingURL=token-C8Uh7aUe.js.map
+//# sourceMappingURL=token-iaSGp76k.js.map