dsh-plugin-subscriptions 0.5.1 → 0.5.2

package/lib/index.js

@@ -2,13 +2,14 @@ import z from "@deepseek-ai/schemastery";
 import { CONTEXT_WINDOW_EXCEEDED_CODE, CallId, EMPTY_RESPONSE_CODE, LlmAdapter, LlmError, QUOTA_EXCEEDED_CODE, ReasoningEffortId, attributionHeaders, errorChain, isContextWindowExceededError, isQuotaExceededError, resolveRetryPolicy } from "@deepseek-ai/dsh-llm";
 import { createServer } from "node:http";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
+import { ProxyAgent, fetch as fetch$1 } from "undici";
 import { chmod, mkdir, readFile, rename, rm, writeFile } from "node:fs/promises";
 import { basename, dirname, join } from "node:path";
+import { dshHomePath } from "@deepseek-ai/dsh-home-paths";
 import { execFileSync } from "node:child_process";
 import { chmodSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { AttachmentId } from "@deepseek-ai/dsh-attachment";
-import { dshHomePath } from "@deepseek-ai/dsh-home-paths";
 import { defineTool } from "@deepseek-ai/dsh-tools";
 
 //#region src/auth/pkce.ts
@@ -251,16 +252,355 @@ var OAuthFlowManager = class {
 };
 
 //#endregion
-//#region src/auth/device-flow.ts
+//#region src/http.ts
+/**
+* undici's own fetch, typed to the DOM fetch signature: its bundled types are
+* stricter (Request requires `duplex`, `RequestInit.body` is non-null) and
+* incompatible with the DOM shapes the provider code passes. The runtime
+* object is the same Web-fetch implementation Node uses.
+*/
+const dispatchFetch = fetch$1;
+/** Destination the `proxyTest` endpoint probes when none is given. */
+const DEFAULT_PROXY_TEST_URL = "https://api.x.ai/v1/models";
+/** Probe deadline; a hung proxy must not pin the Settings dialog forever. */
+const DEFAULT_PROXY_TEST_TIMEOUT_MS = 15e3;
+/** Disabled configuration: the module state before the first load. */
+const DISABLED = {
+	enabled: false,
+	url: "",
+	bypass: []
+};
+/** Current config; updated by every load/apply/save. */
+let current = DISABLED;
+/** The live dispatcher, or undefined when proxies are off/errored. */
+let agent;
+/** Last load/apply failure, surfaced by the config view. */
+let configError;
+/** One lazy load of the on-disk config (module-import cheap; file read once). */
+let ready;
+/** Absolute path of the proxy config file. */
+function proxyFilePath() {
+	return dshHomePath("plugins", "subscriptions", "proxy.json");
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+/**
+* Flatten a fetch failure into a readable message: undici wraps the true
+* cause (`connect ECONNREFUSED ...`) behind a bare "fetch failed", so walk
+* the cause chain and append each distinct layer (up to four, cycle-safe).
+* A hostname resolving to several addresses (e.g. `localhost` → ::1 and
+* 127.0.0.1) fails as an `AggregateError` with an empty message, so its
+* per-address `errors` entries are folded in too.
+*/
+function describeFetchError(error) {
+	const parts = [];
+	let node = error;
+	for (let depth = 0; depth < 4 && node !== void 0 && node !== null; depth += 1) {
+		const layer = node;
+		if (Array.isArray(layer.errors)) for (const child of layer.errors) {
+			const childText = child instanceof Error && child.message !== "" ? child.message : String(child);
+			if (childText !== "" && !parts.includes(childText)) parts.push(childText);
+		}
+		let text = layer instanceof Error ? layer.message : String(node);
+		const code = layer.code;
+		if (typeof code === "string" && code !== "") {
+			if (text === "") text = code;
+			else if (!text.includes(code)) text = `${text} (${code})`;
+		}
+		if (text !== "" && !parts.includes(text)) parts.push(text);
+		const next = layer.cause;
+		if (next === void 0 || next === null || next === node) break;
+		node = next;
+	}
+	return parts.join(" → ");
+}
+function withError(error) {
+	configError = errorMessage(error);
+}
+/**
+* Parse and validate a proxy URL. Only HTTP(S) proxies are supported because
+* the undici dispatcher speaks CONNECT over HTTP; socks5 is not supported.
+* @param raw - the URL the user configured.
+* @returns the parsed URL (credentials attached by the caller).
+*/
+function parseProxyUrl(raw) {
+	let url;
+	try {
+		url = new URL(raw);
+	} catch {
+		throw new Error(`proxy URL "${raw}" is not a valid URL`);
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") throw new Error(`proxy URL must use the http:// or https:// scheme (got "${raw}")`);
+	if (url.hostname === "") throw new Error("proxy URL must include a host");
+	return url;
+}
+/**
+* Whether a request hostname bypasses the proxy.
+* @param hostname - the request's hostname.
+* @param entries - configured bypass entries: exact host, plain suffix
+*   (`example.com` also matches `api.example.com`), or `*.example.com`.
+*/
+function matchesBypass(hostname, entries) {
+	const host = hostname.toLowerCase();
+	for (const raw of entries) {
+		let entry = raw.trim().toLowerCase();
+		if (entry === "") continue;
+		if (entry.includes("://")) try {
+			entry = new URL(entry).hostname;
+		} catch {
+			continue;
+		}
+		entry = entry.replace(/:\d+$/, "");
+		if (entry === "" || entry === "*") continue;
+		if (entry.startsWith("*.")) {
+			if (host.endsWith(entry.slice(1))) return true;
+		} else if (host === entry || host.endsWith(`.${entry}`)) return true;
+	}
+	return false;
+}
+/** Validate and normalize one config (throws with a user-facing message). */
+function normalizeConfig(input) {
+	const url = input.url.trim();
+	if (input.enabled && url === "") throw new Error("a proxy URL is required when the proxy is enabled");
+	if (url !== "") parseProxyUrl(url);
+	const bypass = Array.from(new Set((input.bypass ?? []).map((entry) => entry.trim()).filter((entry) => entry !== "")));
+	return {
+		enabled: input.enabled,
+		url,
+		...input.username !== void 0 && input.username !== "" ? { username: input.username.trim() } : {},
+		...input.password !== void 0 && input.password !== "" && input.password !== null ? { password: input.password } : {},
+		bypass
+	};
+}
+/** Build the undici agent for a config (throws on an unusable URL). */
+function buildAgent(cfg) {
+	if (!cfg.enabled || cfg.url === "") return void 0;
+	const url = parseProxyUrl(cfg.url);
+	if (cfg.username !== void 0) url.username = cfg.username;
+	if (cfg.password !== void 0) url.password = cfg.password;
+	return new ProxyAgent(url.toString());
+}
+/** Swap in a config and its agent; a failed agent keeps the requests direct. */
+async function applyConfig(cfg) {
+	let next;
+	if (cfg !== void 0) {
+		configError = void 0;
+		try {
+			next = buildAgent(cfg);
+		} catch (error) {
+			withError(error);
+			next = void 0;
+		}
+		current = cfg;
+	}
+	const previous = agent;
+	agent = next;
+	if (previous !== void 0) previous.close().catch(() => void 0);
+}
+/** Read the on-disk config. A missing file is the disabled default. */
+async function loadConfigFile(path) {
+	let text;
+	try {
+		text = await readFile(path, "utf8");
+	} catch (error) {
+		if (error.code === "ENOENT") return {
+			...DISABLED,
+			bypass: []
+		};
+		throw error;
+	}
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch {
+		throw new Error(`subscriptions proxy config at ${path} is not valid JSON; fix or delete the file`);
+	}
+	if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) throw new Error("subscriptions proxy config must be a JSON object");
+	const record = parsed;
+	const enabled = record.enabled === true;
+	const url = typeof record.url === "string" ? record.url : "";
+	const username = typeof record.username === "string" ? record.username : void 0;
+	const password = typeof record.password === "string" ? record.password : void 0;
+	const bypass = Array.isArray(record.bypass) ? record.bypass.filter((entry) => typeof entry === "string") : [];
+	return normalizeConfig({
+		enabled,
+		url,
+		...username === void 0 ? {} : { username },
+		...password === void 0 ? {} : { password },
+		bypass
+	});
+}
+/** Resolve the module state once from disk; failures disable the proxy. */
+async function ensureReady() {
+	ready ??= loadConfigFile(proxyFilePath()).then(async (cfg) => {
+		await applyConfig(cfg);
+		return current;
+	}, async (error) => {
+		withError(error);
+		await applyConfig(void 0);
+		return current;
+	});
+	return ready;
+}
+/** Persist a config atomically with owner-only permissions, then apply it. */
+async function persistConfig(cfg, path) {
+	await mkdir(dirname(path), { recursive: true });
+	const tmp = `${path}.tmp-${process.pid}-${Math.random().toString(36).slice(2)}`;
+	try {
+		await writeFile(tmp, JSON.stringify(cfg, null, 2), { mode: 384 });
+		await chmod(tmp, 384);
+		await rename(tmp, path);
+	} catch (error) {
+		await rm(tmp, { force: true });
+		throw error;
+	}
+}
 /**
-* GitHub OAuth device-authorization flow (RFC 8628) for providers that cannot
-* use the loopback redirect engine: no redirect URI, no PKCE, no client
-* secret. The user opens a verification URL and types a short code while the
-* plugin polls the token endpoint until GitHub releases the access token.
-* The management model (one attempt per provider, `isBusy`/`pending`/`cancel`)
-* mirrors {@link OAuthFlowManager} so the auth controller can treat both
-* engines uniformly.
+* Current proxy config as served to the client (secrets omitted).
+* @returns the view; {@link ProxyConfigView.error} carries the last
+*   load/apply failure when the stored config is unusable.
 */
+async function proxyGetConfig() {
+	await ensureReady();
+	return {
+		enabled: current.enabled,
+		url: current.url,
+		...current.username === void 0 ? {} : { username: current.username },
+		passwordSet: current.password !== void 0 && current.password !== "",
+		bypass: [...current.bypass],
+		...configError === void 0 ? {} : { error: configError }
+	};
+}
+/**
+* Validate, persist, and apply one proxy config. A `password` of `undefined`
+* keeps the stored value; `null` or `''` clears it.
+* @param input - the client's payload.
+* @returns the resulting view (secrets omitted).
+*/
+async function proxySetConfig(input) {
+	await ensureReady();
+	const password = input.password === void 0 ? current.password : input.password === null || input.password === "" ? void 0 : input.password;
+	const next = normalizeConfig({
+		enabled: input.enabled,
+		url: input.url,
+		...input.username === void 0 ? {} : { username: input.username },
+		...password === void 0 ? {} : { password },
+		bypass: input.bypass ?? current.bypass
+	});
+	await persistConfig(next, proxyFilePath());
+	await applyConfig(next);
+	return proxyGetConfig();
+}
+/**
+* The fetch caller all subscription code uses: routes through the configured
+* proxy unless the host bypasses it. Identity-passthrough otherwise.
+*
+* Proxied requests run on undici's own fetch (not the global one) so the
+* ProxyAgent dispatcher always comes from the same undici build the request
+* is issued with — a mismatched dispatcher can be silently ignored by the
+* host's global fetch.
+*/
+async function proxiedFetch(input, init = {}) {
+	await ensureReady();
+	let dispatcher;
+	if (current.enabled && agent !== void 0) {
+		let hostname = "";
+		try {
+			hostname = (typeof input === "string" ? new URL(input) : input instanceof URL ? input : new URL(input.url)).hostname;
+		} catch {
+			hostname = "";
+		}
+		if (!matchesBypass(hostname, current.bypass)) dispatcher = agent;
+	}
+	if (dispatcher === void 0) return fetch(input, init);
+	return dispatchFetch(input, {
+		...init,
+		dispatcher
+	});
+}
+/**
+* Probe a destination through a proxy, answering with the HTTP status or a
+* flattened transport error. The probe uses `draft` when given (the dialog's
+* current inputs, without saving) and the stored config otherwise.
+* @param target - `http(s)` URL to fetch; defaults to {@link DEFAULT_PROXY_TEST_URL}.
+* @param draft - unsaved proxy inputs to test; absent means the stored config.
+* @returns the result; any HTTP status counts as a successful connection,
+*   only a transport failure is an error.
+*/
+async function proxyTestConnection(target = DEFAULT_PROXY_TEST_URL, draft) {
+	let parsed;
+	try {
+		parsed = new URL(target);
+		if (parsed.protocol !== "https:" && parsed.protocol !== "http:") return {
+			ok: false,
+			viaProxy: false,
+			error: `test destination must be http or https (got "${parsed.protocol}//")`
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			viaProxy: false,
+			error: errorMessage(error)
+		};
+	}
+	await ensureReady();
+	let probeAgent;
+	let viaProxy;
+	let closeProbe = false;
+	if (draft !== void 0) try {
+		probeAgent = buildAgent(normalizeConfig({
+			enabled: true,
+			url: draft.url,
+			...draft.username === void 0 || draft.username === "" ? {} : { username: draft.username },
+			...draft.password === void 0 || draft.password === "" ? {} : { password: draft.password },
+			bypass: []
+		}));
+		viaProxy = probeAgent !== void 0;
+		closeProbe = true;
+	} catch (error) {
+		return {
+			ok: false,
+			viaProxy: false,
+			error: errorMessage(error)
+		};
+	}
+	else {
+		viaProxy = current.enabled && agent !== void 0 && !matchesBypass(parsed.hostname, current.bypass);
+		probeAgent = viaProxy ? agent : void 0;
+	}
+	const started = Date.now();
+	try {
+		const init = probeAgent !== void 0 ? {
+			method: "GET",
+			dispatcher: probeAgent,
+			signal: AbortSignal.timeout(DEFAULT_PROXY_TEST_TIMEOUT_MS)
+		} : {
+			method: "GET",
+			signal: AbortSignal.timeout(DEFAULT_PROXY_TEST_TIMEOUT_MS)
+		};
+		const response = probeAgent !== void 0 ? await dispatchFetch(parsed.toString(), init) : await fetch(parsed.toString(), init);
+		response.arrayBuffer().catch(() => void 0);
+		return {
+			ok: true,
+			viaProxy,
+			status: response.status,
+			latencyMs: Date.now() - started
+		};
+	} catch (error) {
+		return {
+			ok: false,
+			viaProxy,
+			latencyMs: Date.now() - started,
+			error: describeFetchError(error)
+		};
+	} finally {
+		if (closeProbe && probeAgent !== void 0) await probeAgent.close().catch(() => void 0);
+	}
+}
+
+//#endregion
+//#region src/auth/device-flow.ts
 /** Default poll interval when the device-code response omits one. */
 const DEFAULT_INTERVAL_SEC = 5;
 /** Default device-code lifetime when the response omits one (GitHub: 15 minutes). */
@@ -316,7 +656,7 @@ var DeviceFlowManager = class {
 	*/
 	async start(provider, spec) {
 		if (this.attempts.has(provider)) throw new Error(`a ${provider} login attempt is already in progress`);
-		const fetchFn = spec.fetchFn ?? fetch;
+		const fetchFn = spec.fetchFn ?? proxiedFetch;
 		const response = await fetchFn(spec.deviceCodeUrl, {
 			method: "POST",
 			headers: {
@@ -835,7 +1175,69 @@ function readSessionId(payload) {
 	if (typeof payload !== "object" || payload === null) throw new BadRequest("payload must be an object");
 	return readString(payload, "sessionId");
 }
-async function dispatch(controller, speed, endpoint, payload, signal) {
+/** Validate a `proxySet` payload into a shape `ProxyInput` accepts. */
+function readProxyInput(payload) {
+	if (typeof payload !== "object" || payload === null) throw new BadRequest("payload must be an object");
+	const record = payload;
+	if (typeof record.enabled !== "boolean") throw new BadRequest("payload.enabled must be a boolean");
+	if (typeof record.url !== "string") throw new BadRequest("payload.url must be a string");
+	let username;
+	if (record.username !== void 0) {
+		if (typeof record.username !== "string") throw new BadRequest("payload.username must be a string when present");
+		username = record.username;
+	}
+	let password;
+	if (record.password !== void 0) {
+		if (record.password !== null && typeof record.password !== "string") throw new BadRequest("payload.password must be a string or null when present");
+		password = record.password;
+	}
+	let bypass;
+	if (record.bypass !== void 0) {
+		if (!Array.isArray(record.bypass) || record.bypass.some((entry) => typeof entry !== "string")) throw new BadRequest("payload.bypass must be an array of strings when present");
+		bypass = record.bypass;
+	}
+	return {
+		enabled: record.enabled,
+		url: record.url,
+		...username === void 0 ? {} : { username },
+		...password === void 0 ? {} : { password },
+		...bypass === void 0 ? {} : { bypass }
+	};
+}
+/** Validate a `proxyTest` payload (the destination URL and an optional draft). */
+function readProxyTestPayload(payload) {
+	if (typeof payload !== "object" || payload === null) return {};
+	const record = payload;
+	const url = record.url;
+	if (url === void 0 && record.proxy === void 0) return {};
+	if (url !== void 0 && (typeof url !== "string" || url.length === 0)) throw new BadRequest("payload.url must be a non-empty string when present");
+	let proxy;
+	if (record.proxy !== void 0) {
+		if (typeof record.proxy !== "object" || record.proxy === null) throw new BadRequest("payload.proxy must be an object when present");
+		const draftRecord = record.proxy;
+		if (typeof draftRecord.url !== "string" || draftRecord.url.length === 0) throw new BadRequest("payload.proxy.url must be a non-empty string");
+		let username;
+		if (draftRecord.username !== void 0) {
+			if (typeof draftRecord.username !== "string") throw new BadRequest("payload.proxy.username must be a string when present");
+			username = draftRecord.username;
+		}
+		let password;
+		if (draftRecord.password !== void 0) {
+			if (typeof draftRecord.password !== "string") throw new BadRequest("payload.proxy.password must be a string when present");
+			password = draftRecord.password;
+		}
+		proxy = {
+			url: draftRecord.url,
+			...username === void 0 ? {} : { username },
+			...password === void 0 ? {} : { password }
+		};
+	}
+	return {
+		...url === void 0 ? {} : { url },
+		...proxy === void 0 ? {} : { proxy }
+	};
+}
+async function dispatch(controller, speed, proxy, endpoint, payload, signal) {
 	switch (endpoint) {
 		case "status": {
 			const entries = await Promise.all(PROVIDER_IDS.map(async (provider) => [provider, await controller.status(provider)]));
@@ -860,6 +1262,15 @@ async function dispatch(controller, speed, endpoint, payload, signal) {
 		case "setSpeed":
 			await speed.setSpeed(readSessionId(payload), readSpeedTier(payload));
 			return ok({ ok: true });
+		case "proxyGet":
+			if (proxy === void 0) throw new BadRequest("proxy configuration is unavailable");
+			return ok(await proxy.get());
+		case "proxySet":
+			if (proxy === void 0) throw new BadRequest("proxy configuration is unavailable");
+			return ok(await proxy.set(readProxyInput(payload)));
+		case "proxyTest":
+			if (proxy === void 0) throw new BadRequest("proxy configuration is unavailable");
+			return ok(await proxy.test(readProxyTestPayload(payload)));
 		default: throw new BadRequest(`unknown /subscriptions-auth endpoint "${endpoint}"`);
 	}
 }
@@ -868,13 +1279,14 @@ async function dispatch(controller, speed, endpoint, payload, signal) {
 * @param ctx - the plugin context (headless profiles have no `connection`).
 * @param controller - the auth operations backing the endpoints.
 * @param speed - the per-session speed-tier state backing the Speed toggle.
+* @param proxy - optional proxy-config controller backing `proxyGet`/`proxySet`/`proxyTest`.
 */
-function registerAuthRpc(ctx, controller, speed) {
+function registerAuthRpc(ctx, controller, speed, proxy = void 0) {
 	ctx.inject(["connection"], (ctx$1) => {
 		const connection = ctx$1.get("connection");
 		ctx$1.effect(() => connection.rpc.handle(SUBSCRIPTIONS_AUTH_CHANNEL, async (endpoint, payload, signal) => {
 			try {
-				return await dispatch(controller, speed, endpoint, payload, signal);
+				return await dispatch(controller, speed, proxy, endpoint, payload, signal);
 			} catch (error) {
 				return failure(error);
 			}
@@ -1075,9 +1487,9 @@ var TokenManager = class {
 		}
 	}
 	async doRefresh(session) {
-		const current = await this.options.load();
-		if (current !== void 0 && current.accessToken !== session.accessToken && current.expiresAt - Date.now() > this.options.preemptMs) return current;
-		const next = await this.options.refresh(current ?? session);
+		const current$1 = await this.options.load();
+		if (current$1 !== void 0 && current$1.accessToken !== session.accessToken && current$1.expiresAt - Date.now() > this.options.preemptMs) return current$1;
+		const next = await this.options.refresh(current$1 ?? session);
 		await this.options.save(next);
 		return next;
 	}
@@ -1960,7 +2372,7 @@ function codexSession(tokens, fallback) {
 * @returns the session to store.
 */
 async function exchangeCodexCode(code, verifier, redirectUri) {
-	const response = await fetch(CODEX_TOKEN_URL, {
+	const response = await proxiedFetch(CODEX_TOKEN_URL, {
 		method: "POST",
 		headers: { "content-type": "application/x-www-form-urlencoded" },
 		body: new URLSearchParams({
@@ -1980,7 +2392,7 @@ async function exchangeCodexCode(code, verifier, redirectUri) {
 * @returns the fresh session to store.
 */
 async function refreshCodex(session) {
-	const response = await fetch(CODEX_TOKEN_URL, {
+	const response = await proxiedFetch(CODEX_TOKEN_URL, {
 		method: "POST",
 		headers: { "content-type": "application/json" },
 		body: JSON.stringify({
@@ -2048,7 +2460,7 @@ function codexUsageWindow(value, fallbackKind) {
 * @param signal - caller cancellation from the RPC transport.
 * @returns the mapped usage snapshot.
 */
-async function fetchCodexUsage(session, fetchFn = fetch, signal) {
+async function fetchCodexUsage(session, fetchFn = proxiedFetch, signal) {
 	const response = await fetchFn(CODEX_USAGE_URL, {
 		headers: {
 			"authorization": `Bearer ${session.accessToken}`,
@@ -2098,7 +2510,7 @@ function supportsFastTier(entry) {
 * @param fetchFn - fetch implementation (injectable for tests).
 * @returns discovered models: hidden entries dropped, sorted by priority.
 */
-async function fetchCodexModels(session, fetchFn = fetch) {
+async function fetchCodexModels(session, fetchFn = proxiedFetch) {
 	const response = await fetchFn(`${CODEX_MODELS_URL}?client_version=${CODEX_CLIENT_VERSION}`, { headers: {
 		"authorization": `Bearer ${session.accessToken}`,
 		"chatgpt-account-id": session.accountId,
@@ -2311,7 +2723,7 @@ var CodexAdapter = class extends LlmAdapter {
 		const messages = await resolveImages(options.messages, this.options.resolveAttachments?.(), signal);
 		const fast = this.options.speedFor !== void 0 && await this.options.speedFor(options.sessionId, options.model);
 		const body = codexRequestBody(options, toResponsesInput(messages, options.system), fast);
-		return fetch(CODEX_API_URL, {
+		return proxiedFetch(CODEX_API_URL, {
 			method: "POST",
 			headers: {
 				"authorization": `Bearer ${session.accessToken}`,
@@ -2846,7 +3258,7 @@ const claudeFlow = {
 /** Best-effort account profile; login must not fail when this does. */
 async function fetchClaudeProfile(accessToken) {
 	try {
-		const response = await fetch(CLAUDE_PROFILE_URL, { headers: { authorization: `Bearer ${accessToken}` } });
+		const response = await proxiedFetch(CLAUDE_PROFILE_URL, { headers: { authorization: `Bearer ${accessToken}` } });
 		if (!response.ok) return {};
 		const profile = await response.json();
 		const account = typeof profile.account === "object" && profile.account !== null ? profile.account : {};
@@ -2884,7 +3296,7 @@ async function claudeSession(tokens, fallbackRefreshToken, withProfile) {
 * @returns the session to store.
 */
 async function exchangeClaudeCode(code, verifier, redirectUri, state) {
-	const response = await fetch(CLAUDE_TOKEN_URL, {
+	const response = await proxiedFetch(CLAUDE_TOKEN_URL, {
 		method: "POST",
 		headers: { "content-type": "application/json" },
 		body: JSON.stringify({
@@ -2905,7 +3317,7 @@ async function exchangeClaudeCode(code, verifier, redirectUri, state) {
 * @returns the fresh session to store.
 */
 async function refreshClaude(session) {
-	const response = await fetch(CLAUDE_TOKEN_URL, {
+	const response = await proxiedFetch(CLAUDE_TOKEN_URL, {
 		method: "POST",
 		headers: { "content-type": "application/json" },
 		body: JSON.stringify({
@@ -2980,7 +3392,7 @@ function claudeLimitsWindows(value) {
 * @param signal - caller cancellation from the RPC transport.
 * @returns the mapped usage snapshot.
 */
-async function fetchClaudeUsage(session, fetchFn = fetch, signal) {
+async function fetchClaudeUsage(session, fetchFn = proxiedFetch, signal) {
 	const response = await fetchFn(CLAUDE_USAGE_URL, {
 		headers: {
 			"authorization": `Bearer ${session.accessToken}`,
@@ -3033,7 +3445,7 @@ function claudeReasoning(capabilities) {
 	return efforts.length > 0 ? { efforts } : void 0;
 }
 /** Fetch the live model catalog from the subscription endpoint. */
-async function fetchClaudeModels(session, fetchFn = fetch) {
+async function fetchClaudeModels(session, fetchFn = proxiedFetch) {
 	const response = await fetchFn(CLAUDE_MODELS_URL, { headers: {
 		"authorization": `Bearer ${session.accessToken}`,
 		"anthropic-version": "2023-06-01",
@@ -3215,7 +3627,7 @@ var ClaudeAdapter = class extends LlmAdapter {
 		const maxTokens = options.maxTokens ?? this.options.models.find((entry) => entry.id === options.model)?.maxTokens ?? CLAUDE_DEFAULT_MAX_TOKENS;
 		const disc = await this.discovered(options.model);
 		const body = claudeRequestBody(options, messages, maxTokens, this.thinkingParam(disc?.thinkingType, maxTokens), options.reasoningEffort !== void 0 && disc?.reasoning !== void 0 ? String(options.reasoningEffort) : void 0);
-		return fetch(CLAUDE_API_URL, {
+		return proxiedFetch(CLAUDE_API_URL, {
 			method: "POST",
 			headers: {
 				"authorization": `Bearer ${session.accessToken}`,
@@ -3262,7 +3674,7 @@ let discoveryCache;
 */
 async function grokDiscovery() {
 	if (discoveryCache !== void 0) return discoveryCache;
-	const response = await fetch(GROK_DISCOVERY_URL);
+	const response = await proxiedFetch(GROK_DISCOVERY_URL);
 	if (!response.ok) throw await oauthEndpointError(response, "grok OIDC discovery");
 	const document = await response.json();
 	if (typeof document.authorization_endpoint !== "string" || typeof document.token_endpoint !== "string") throw new Error("grok OIDC discovery document is missing endpoints");
@@ -3363,7 +3775,7 @@ function grokSession(tokens, tokenEndpoint, fallbackRefreshToken) {
 */
 async function exchangeGrokCode(code, verifier, redirectUri, challenge) {
 	const discovery = await grokDiscovery();
-	const response = await fetch(discovery.tokenEndpoint, {
+	const response = await proxiedFetch(discovery.tokenEndpoint, {
 		method: "POST",
 		headers: { "content-type": "application/x-www-form-urlencoded" },
 		body: new URLSearchParams({
@@ -3386,7 +3798,7 @@ async function exchangeGrokCode(code, verifier, redirectUri, challenge) {
 * @returns the fresh session to store.
 */
 async function refreshGrok(session) {
-	const response = await fetch(session.tokenEndpoint, {
+	const response = await proxiedFetch(session.tokenEndpoint, {
 		method: "POST",
 		headers: { "content-type": "application/x-www-form-urlencoded" },
 		body: new URLSearchParams({
@@ -3433,7 +3845,7 @@ function grokResetsAt(value) {
 * @param signal - caller cancellation from the RPC transport.
 * @returns the mapped usage snapshot.
 */
-async function fetchGrokUsage(session, fetchFn = fetch, signal) {
+async function fetchGrokUsage(session, fetchFn = proxiedFetch, signal) {
 	const response = await fetchFn(GROK_BILLING_URL, {
 		headers: {
 			"authorization": `Bearer ${session.accessToken}`,
@@ -3508,7 +3920,7 @@ function grokCliReasoning(entry) {
 * @param fetchFn - fetch implementation (injectable for tests).
 * @returns model id → contributed metadata.
 */
-async function fetchGrokCliCatalog(session, fetchFn = fetch) {
+async function fetchGrokCliCatalog(session, fetchFn = proxiedFetch) {
 	const response = await fetchFn(GROK_CLI_MODELS_URL, { headers: {
 		"authorization": `Bearer ${session.accessToken}`,
 		"x-xai-token-auth": "xai-grok-cli",
@@ -3569,7 +3981,7 @@ function grokPriorMeta(prior) {
 *   catalog is down or omits a model.
 * @returns discovered chat models in endpoint order.
 */
-async function fetchGrokModels(session, fetchFn = fetch, onWarn, previous) {
+async function fetchGrokModels(session, fetchFn = proxiedFetch, onWarn, previous) {
 	const previousById = previous === void 0 || previous.length === 0 ? void 0 : new Map(previous.map((model) => [model.id, model]));
 	const [response, cliCatalog] = await Promise.all([fetchFn(GROK_MODELS_URL, { headers: {
 		"authorization": `Bearer ${session.accessToken}`,
@@ -3703,7 +4115,7 @@ var GrokAdapter = class extends LlmAdapter {
 			store: false,
 			stream: true
 		};
-		return fetch(GROK_API_URL, {
+		return proxiedFetch(GROK_API_URL, {
 			method: "POST",
 			headers: {
 				"authorization": `Bearer ${session.accessToken}`,
@@ -4117,7 +4529,7 @@ let vscodeVersionInflight;
 * @param forceRefresh - bypass the cache (a 401 `IDE token expired` retry).
 * @returns a `major.minor.patch` version string.
 */
-async function latestVsCodeVersion(fetchFn = fetch, forceRefresh = false) {
+async function latestVsCodeVersion(fetchFn = proxiedFetch, forceRefresh = false) {
 	if (!forceRefresh && vscodeVersionCache !== void 0 && Date.now() - vscodeVersionCache.at < VSCODE_VERSION_TTL_MS) return vscodeVersionCache.version;
 	vscodeVersionInflight ??= (async () => {
 		try {
@@ -4177,7 +4589,7 @@ function copilotHeaders(hasVision = false, vscodeVersion = FALLBACK_VSCODE_VERSI
 * @param fetchFn - fetch implementation (injectable for tests).
 * @returns the Copilot API token and its expiry.
 */
-async function exchangeCopilotToken(githubToken, fetchFn = fetch) {
+async function exchangeCopilotToken(githubToken, fetchFn = proxiedFetch) {
 	const response = await fetchFn(COPILOT_TOKEN_URL, { headers: {
 		"authorization": `Bearer ${githubToken}`,
 		"accept": "application/json",
@@ -4198,7 +4610,7 @@ async function exchangeCopilotToken(githubToken, fetchFn = fetch) {
 * @param fetchFn - fetch implementation (injectable for tests).
 * @returns the session to store.
 */
-async function completeCopilotLogin(githubToken, fetchFn = fetch) {
+async function completeCopilotLogin(githubToken, fetchFn = proxiedFetch) {
 	const pair = await exchangeCopilotToken(githubToken, fetchFn);
 	let account;
 	try {
@@ -4226,7 +4638,7 @@ async function completeCopilotLogin(githubToken, fetchFn = fetch) {
 * @param fetchFn - fetch implementation (injectable for tests).
 * @returns the fresh session to store.
 */
-async function refreshCopilot(session, fetchFn = fetch) {
+async function refreshCopilot(session, fetchFn = proxiedFetch) {
 	const pair = await exchangeCopilotToken(session.refreshToken, fetchFn);
 	return {
 		accessToken: pair.accessToken,
@@ -4284,7 +4696,7 @@ function copilotReasoning(entry) {
 * @param fetchFn - fetch implementation (injectable for tests).
 * @returns discovered chat models in endpoint order.
 */
-async function fetchCopilotModels(session, fetchFn = fetch) {
+async function fetchCopilotModels(session, fetchFn = proxiedFetch) {
 	const response = await fetchFn(COPILOT_MODELS_URL, { headers: {
 		"authorization": `Bearer ${session.accessToken}`,
 		"accept": "application/json",
@@ -4696,7 +5108,7 @@ var CopilotAdapter = class CopilotAdapter extends LlmAdapter {
 			const scope = this.replayScope(session.refreshToken, options);
 			let response = await this.request(options, session, watchdog.signal, wire, scope);
 			if (response.status === 401) {
-				await latestVsCodeVersion(this.options.fetchFn ?? fetch, true);
+				await latestVsCodeVersion(this.options.fetchFn ?? proxiedFetch, true);
 				session = await this.options.tokens.session(true);
 				response = await this.request(options, session, watchdog.signal, wire, scope);
 			}
@@ -4721,13 +5133,13 @@ var CopilotAdapter = class CopilotAdapter extends LlmAdapter {
 		const messages = await resolveImages(options.messages, this.options.resolveAttachments?.(), signal);
 		const hasVision = messages.some((message) => message.content.some((block) => block.type === "image"));
 		const body = wire === "responses" ? copilotResponsesRequestBody(options, toResponsesInput(messages, options.system, (callId) => this.replayFor(replayScopeKey, callId))) : copilotChatRequestBody(options, toChatMessages(messages, options.system));
-		return fetch(wire === "responses" ? COPILOT_RESPONSES_URL : COPILOT_API_URL, {
+		return proxiedFetch(wire === "responses" ? COPILOT_RESPONSES_URL : COPILOT_API_URL, {
 			method: "POST",
 			headers: {
 				"authorization": `Bearer ${session.accessToken}`,
 				"accept": "text/event-stream",
 				"content-type": "application/json",
-				...copilotHeaders(hasVision, await latestVsCodeVersion(this.options.fetchFn ?? fetch))
+				...copilotHeaders(hasVision, await latestVsCodeVersion(this.options.fetchFn ?? proxiedFetch))
 			},
 			body: JSON.stringify(body),
 			signal
@@ -4895,7 +5307,7 @@ function createXSearchTool(options) {
 		async execute(args, exec) {
 			const request = buildXSearchRequest(args);
 			const session = await options.tokens.session();
-			const response = await (options.fetchFn ?? fetch)(X_SEARCH_URL, {
+			const response = await (options.fetchFn ?? proxiedFetch)(X_SEARCH_URL, {
 				method: "POST",
 				headers: {
 					"authorization": `Bearer ${session.accessToken}`,
@@ -5160,7 +5572,7 @@ function createImageGenerateTool(options) {
 			content: result.content.filter((block) => block.type === "text")
 		}),
 		async execute(args, exec) {
-			const fetchFn = options.fetchFn ?? fetch;
+			const fetchFn = options.fetchFn ?? proxiedFetch;
 			const preferGrok = args.provider === "grok";
 			const codexReady = options.codexTokens !== void 0 && await options.codexTokens.hasSession();
 			const grokReady = options.grokTokens !== void 0 && await options.grokTokens.hasSession();
@@ -5430,7 +5842,7 @@ function createVideoGenerateTool(options) {
 		async execute(args, exec) {
 			const body = buildVideoGenerateBody(args);
 			const session = await options.tokens.session();
-			const fetchFn = options.fetchFn ?? fetch;
+			const fetchFn = options.fetchFn ?? proxiedFetch;
 			const headers = {
 				"authorization": `Bearer ${session.accessToken}`,
 				"accept": "application/json"
@@ -5852,7 +6264,7 @@ function apply(ctx, config) {
 				}
 			});
 			codexTokens = tokens;
-			usageFetchers.codex = async (signal) => fetchCodexUsage(await tokens.session(), fetch, signal);
+			usageFetchers.codex = async (signal) => fetchCodexUsage(await tokens.session(), proxiedFetch, signal);
 			let adapter;
 			adapter = new CodexAdapter({
 				models: catalog.codex,
@@ -5882,7 +6294,7 @@ function apply(ctx, config) {
 				}
 			});
 			claudeTokens = tokens;
-			usageFetchers.claude = async (signal) => fetchClaudeUsage(await tokens.session(), fetch, signal);
+			usageFetchers.claude = async (signal) => fetchClaudeUsage(await tokens.session(), proxiedFetch, signal);
 			handles.set("claude", ctx.llm.registerAdapter(["claude"], new ClaudeAdapter({
 				models: catalog.claude,
 				streamIdleTimeoutMs,
@@ -5909,7 +6321,7 @@ function apply(ctx, config) {
 				}
 			});
 			grokTokens = tokens;
-			usageFetchers.grok = async (signal) => fetchGrokUsage(await tokens.session(), fetch, signal);
+			usageFetchers.grok = async (signal) => fetchGrokUsage(await tokens.session(), proxiedFetch, signal);
 			handles.set("grok", ctx.llm.registerAdapter(["grok"], new GrokAdapter({
 				models: catalog.grok,
 				streamIdleTimeoutMs,
@@ -5958,6 +6370,10 @@ function apply(ctx, config) {
 			if (tier === "standard") speedBySession.delete(sessionId);
 			else speedBySession.set(sessionId, tier);
 		}
+	}, {
+		get: () => proxyGetConfig(),
+		set: (input) => proxySetConfig(input),
+		test: (payload) => proxyTestConnection(payload.url, payload.proxy)
 	});
 	if (claudeTokens !== void 0) {
 		const syncTimer = setInterval(() => {