copilot-api-node20 0.5.14-node20 → 0.7.0

package/dist/main.js

@@ -4,7 +4,7 @@ import consola from "consola";
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { randomUUID } from "node:crypto";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
 import clipboard from "clipboardy";
 import process$1 from "node:process";
 import { serve } from "srvx";
@@ -12,21 +12,26 @@ import invariant from "tiny-invariant";
 import { execSync } from "node:child_process";
 import { Hono } from "hono";
 import { cors } from "hono/cors";
-import { logger } from "hono/logger";
 import { streamSSE } from "hono/streaming";
-import { countTokens } from "gpt-tokenizer/model/gpt-4o";
 import { events } from "fetch-event-stream";
+import { request } from "undici";
 
 //#region src/lib/paths.ts
 const APP_DIR = path.join(os.homedir(), ".local", "share", "copilot-api");
 const GITHUB_TOKEN_PATH = path.join(APP_DIR, "github_token");
+const MACHINE_ID_PATH = path.join(APP_DIR, "machine_id");
+const SESSION_ID_PATH = path.join(APP_DIR, "session_id");
 const PATHS = {
 	APP_DIR,
-	GITHUB_TOKEN_PATH
+	GITHUB_TOKEN_PATH,
+	MACHINE_ID_PATH,
+	SESSION_ID_PATH
 };
 async function ensurePaths() {
 	await fs.mkdir(PATHS.APP_DIR, { recursive: true });
 	await ensureFile(PATHS.GITHUB_TOKEN_PATH);
+	await ensureFile(PATHS.MACHINE_ID_PATH);
+	await ensureFile(PATHS.SESSION_ID_PATH);
 }
 async function ensureFile(filePath) {
 	try {
@@ -43,32 +48,230 @@ const state = {
 	accountType: "individual",
 	manualApprove: false,
 	rateLimitWait: false,
-	showToken: false
+	showToken: false,
+	connectivity: {
+		enabled: true,
+		probeEndpoints: [
+			"https://api.github.com",
+			"https://www.google.com",
+			"https://1.1.1.1"
+		],
+		fastProbeInterval: 5e3,
+		slowProbeInterval: 6e4,
+		timeoutMs: 5e3,
+		jitterMaxMs: 1e3,
+		connectionPooling: true,
+		dnsCache: true
+	}
 };
 
+//#endregion
+//#region src/lib/connectivity.ts
+var ConnectivityMonitor = class extends EventTarget {
+	isOnline = true;
+	lastChecked = (/* @__PURE__ */ new Date()).toISOString();
+	consecutiveFailures = 0;
+	lastErrorType;
+	lastErrorMessage;
+	lastSuccessfulEndpoint;
+	endpointFailureStats = {};
+	checkInterval;
+	abortController;
+	on(event, listener) {
+		this.addEventListener(event, listener);
+		return this;
+	}
+	off(event, listener) {
+		this.removeEventListener(event, listener);
+		return this;
+	}
+	start() {
+		if (!state.connectivity.enabled) {
+			consola.debug("Connectivity monitoring disabled");
+			return;
+		}
+		consola.info("Starting connectivity monitor", {
+			probeEndpoints: state.connectivity.probeEndpoints,
+			fastInterval: state.connectivity.fastProbeInterval
+		});
+		this.scheduleNextCheck();
+		const cleanup = () => {
+			this.stop();
+			process.exit(0);
+		};
+		process.on("SIGINT", cleanup);
+		process.on("SIGTERM", cleanup);
+	}
+	stop() {
+		consola.debug("Stopping connectivity monitor");
+		if (this.checkInterval) {
+			clearTimeout(this.checkInterval);
+			this.checkInterval = void 0;
+		}
+		if (this.abortController) {
+			this.abortController.abort();
+			this.abortController = void 0;
+		}
+	}
+	scheduleNextCheck() {
+		if (this.checkInterval) clearTimeout(this.checkInterval);
+		const baseInterval = this.isOnline ? state.connectivity.slowProbeInterval : state.connectivity.fastProbeInterval;
+		const jitter = Math.random() * state.connectivity.jitterMaxMs;
+		const interval = baseInterval + jitter;
+		this.checkInterval = setTimeout(() => {
+			this.performConnectivityCheck().catch((error) => {
+				consola.error("Connectivity check failed:", error);
+			});
+		}, interval);
+	}
+	async performConnectivityCheck() {
+		this.abortController = new AbortController();
+		const timeoutId = setTimeout(() => this.abortController?.abort(), state.connectivity.timeoutMs);
+		try {
+			let success = false;
+			for (const endpoint of state.connectivity.probeEndpoints) try {
+				const response = await fetch(endpoint, {
+					method: "HEAD",
+					signal: this.abortController.signal,
+					headers: {
+						"User-Agent": "copilot-api-connectivity-monitor/1.0",
+						...state.connectivity.dnsCache && { "Cache-Control": "max-age=300" }
+					}
+				});
+				if (response.ok) {
+					success = true;
+					this.lastSuccessfulEndpoint = endpoint;
+					break;
+				}
+			} catch (error) {
+				this.endpointFailureStats[endpoint] = (this.endpointFailureStats[endpoint] || 0) + 1;
+				consola.debug(`Probe failed for ${endpoint}:`, error);
+			}
+			this.updateConnectivityState(success);
+		} catch (error) {
+			this.handleConnectivityError(error);
+		} finally {
+			clearTimeout(timeoutId);
+			this.scheduleNextCheck();
+		}
+	}
+	updateConnectivityState(isOnline) {
+		const wasOnline = this.isOnline;
+		this.isOnline = isOnline;
+		this.lastChecked = (/* @__PURE__ */ new Date()).toISOString();
+		if (isOnline) {
+			if (this.consecutiveFailures > 0) consola.info(`Connectivity restored after ${this.consecutiveFailures} failures`);
+			this.consecutiveFailures = 0;
+			this.lastErrorType = void 0;
+			this.lastErrorMessage = void 0;
+			if (!wasOnline) this.dispatchEvent(new CustomEvent("online"));
+		} else {
+			this.consecutiveFailures++;
+			if (wasOnline) {
+				consola.warn("Connectivity lost");
+				this.dispatchEvent(new CustomEvent("offline"));
+			}
+		}
+	}
+	handleConnectivityError(error) {
+		this.lastErrorType = error.name;
+		this.lastErrorMessage = error.message;
+		consola.error("Connectivity check failed:", error);
+		this.updateConnectivityState(false);
+	}
+	getConnectivityStats() {
+		return {
+			isOnline: this.isOnline,
+			lastChecked: this.lastChecked,
+			consecutiveFailures: this.consecutiveFailures,
+			lastErrorType: this.lastErrorType,
+			lastErrorMessage: this.lastErrorMessage
+		};
+	}
+	getPerformanceStats() {
+		const currentInterval = this.isOnline ? state.connectivity.slowProbeInterval : state.connectivity.fastProbeInterval;
+		const nextCheckEstimate = new Date(Date.now() + currentInterval + Math.random() * state.connectivity.jitterMaxMs).toISOString();
+		return {
+			currentInterval,
+			nextCheckEstimate,
+			lastSuccessfulEndpoint: this.lastSuccessfulEndpoint,
+			endpointFailureStats: { ...this.endpointFailureStats },
+			jitterEnabled: state.connectivity.jitterMaxMs > 0,
+			connectionPooling: state.connectivity.connectionPooling,
+			dnsCache: state.connectivity.dnsCache
+		};
+	}
+};
+const connectivityMonitor = new ConnectivityMonitor();
+
 //#endregion
 //#region src/lib/api-config.ts
 const standardHeaders = () => ({
 	"content-type": "application/json",
 	accept: "application/json"
 });
-const COPILOT_VERSION = "0.26.7";
+const COPILOT_VERSION = "0.32.2025100203";
 const EDITOR_PLUGIN_VERSION = `copilot-chat/${COPILOT_VERSION}`;
 const USER_AGENT = `GitHubCopilotChat/${COPILOT_VERSION}`;
-const API_VERSION = "2025-04-01";
+const API_VERSION = "2025-08-20";
+const generateMachineId = () => {
+	const hash = createHash("sha256");
+	hash.update(process.platform);
+	hash.update(process.arch);
+	hash.update(process.env.USER || process.env.USERNAME || "anonymous");
+	hash.update(os.hostname());
+	hash.update(Date.now().toString());
+	hash.update(randomBytes(16));
+	return hash.digest("hex");
+};
+const readMachineId = async () => {
+	try {
+		const machineId = await fs.readFile(PATHS.MACHINE_ID_PATH, "utf8");
+		if (machineId.trim()) return machineId.trim();
+	} catch {}
+	const newMachineId = generateMachineId();
+	await fs.writeFile(PATHS.MACHINE_ID_PATH, newMachineId);
+	await fs.chmod(PATHS.MACHINE_ID_PATH, 384);
+	return newMachineId;
+};
+const readSessionId = async () => {
+	try {
+		const sessionId = await fs.readFile(PATHS.SESSION_ID_PATH, "utf8");
+		if (sessionId.trim()) return sessionId.trim();
+	} catch {}
+	const newSessionId = randomUUID();
+	await fs.writeFile(PATHS.SESSION_ID_PATH, newSessionId);
+	await fs.chmod(PATHS.SESSION_ID_PATH, 384);
+	return newSessionId;
+};
+const initializeVSCodeIdentifiers = async (state$1) => {
+	if (!state$1.machineId) state$1.machineId = await readMachineId();
+	if (!state$1.sessionId) state$1.sessionId = await readSessionId();
+};
 const copilotBaseUrl = (state$1) => state$1.accountType === "individual" ? "https://api.githubcopilot.com" : `https://api.${state$1.accountType}.githubcopilot.com`;
 const copilotHeaders = (state$1, vision = false) => {
+	if (!state$1.machineId || !state$1.sessionId) throw new Error("VSCode identifiers not initialized. Call initializeVSCodeIdentifiers() during startup.");
 	const headers = {
 		Authorization: `Bearer ${state$1.copilotToken}`,
-		"content-type": standardHeaders()["content-type"],
-		"copilot-integration-id": "vscode-chat",
-		"editor-version": `vscode/${state$1.vsCodeVersion}`,
-		"editor-plugin-version": EDITOR_PLUGIN_VERSION,
-		"user-agent": USER_AGENT,
-		"openai-intent": "conversation-panel",
-		"x-github-api-version": API_VERSION,
-		"x-request-id": randomUUID(),
-		"x-vscode-user-agent-library-version": "electron-fetch"
+		"Content-Type": "application/json",
+		accept: "*/*",
+		"accept-encoding": "br, gzip, deflate",
+		"accept-language": "*",
+		"sec-fetch-mode": "cors",
+		"Copilot-Integration-Id": "vscode-chat",
+		"Editor-Version": `vscode/${state$1.vsCodeVersion}`,
+		"Editor-Plugin-Version": EDITOR_PLUGIN_VERSION,
+		"User-Agent": USER_AGENT,
+		"VScode-MachineId": state$1.machineId,
+		"VScode-SessionId": state$1.sessionId,
+		"OpenAI-Intent": "conversation-agent",
+		"X-Interaction-Type": "conversation-agent",
+		"X-VSCode-User-Agent-Library-Version": "node-fetch",
+		"X-GitHub-Api-Version": API_VERSION,
+		"X-Interaction-Id": randomUUID(),
+		"X-Request-Id": randomUUID(),
+		"openai-intent": "conversation-agent",
+		"x-interaction-type": "conversation-agent"
 	};
 	if (vision) headers["copilot-vision-request"] = "true";
 	return headers;
@@ -81,11 +284,119 @@ const githubHeaders = (state$1) => ({
 	"editor-plugin-version": EDITOR_PLUGIN_VERSION,
 	"user-agent": USER_AGENT,
 	"x-github-api-version": API_VERSION,
-	"x-vscode-user-agent-library-version": "electron-fetch"
+	"x-vscode-user-agent-library-version": "node-fetch"
 });
 const GITHUB_BASE_URL = "https://github.com";
-const GITHUB_CLIENT_ID = "Iv1.b507a08c87ecfe98";
-const GITHUB_APP_SCOPES = ["read:user"].join(" ");
+const GITHUB_CLIENT_ID = "01ab8ac9400c4e429b23";
+const GITHUB_APP_SCOPES = ["user:email"].join(" ");
+
+//#endregion
+//#region src/lib/logger/completion-logger.ts
+const humanize = (num) => {
+	if (num >= 1e5) return `${Math.round(num / 1e3)}K`;
+	if (num >= 1e4) return `${Math.round(num / 1e3)}K`;
+	if (num >= 1e3) return `${(num / 1e3).toFixed(1)}K`;
+	return num.toString();
+};
+const pad = (str, length) => str.padEnd(length);
+const getContextPercentage = (contextWindow, model) => {
+	if (!state.models) return "";
+	const selectedModel = state.models.data.find((m) => m.id === model);
+	if (!selectedModel) return "";
+	const maxContextTokens = selectedModel.capabilities.limits.max_context_window_tokens;
+	if (!maxContextTokens) return "";
+	const percentage = (contextWindow / maxContextTokens * 100).toFixed(1);
+	return ` (${percentage}%)`;
+};
+const formatTokenUsage = (requestData) => {
+	const parts = [];
+	if (requestData.model) {
+		const model = pad(requestData.model, 18);
+		parts.push(model);
+	}
+	if (requestData.tokenUsage) {
+		const usage = requestData.tokenUsage;
+		const contextWindow = (usage.inputTokens || 0) + (usage.outputTokens || 0);
+		const contextPercentage = requestData.model ? getContextPercentage(contextWindow, requestData.model) : "";
+		const input = humanize(usage.inputTokens || 0).padStart(5);
+		const output = humanize(usage.outputTokens || 0).padStart(5);
+		const tokenPart = `↑${input} │ ↓${output}`;
+		const tokens = pad(tokenPart, 18);
+		const contextNum = contextWindow.toString();
+		const contextFormatted = contextPercentage ? `${contextNum}${contextPercentage.padStart(15 - contextNum.length)}` : contextNum.padEnd(15);
+		parts.push(`Tokens: ${tokens} | Context: ${contextFormatted}`);
+	} else if (requestData.model) {
+		const tokens = pad("N/A", 18);
+		const context = "N/A".padEnd(15);
+		parts.push(`Tokens: ${tokens} | Context: ${context}`);
+	}
+	if (requestData.copilotDuration) {
+		const apiDuration = pad(`${Math.round(requestData.copilotDuration)}ms`, 8);
+		parts.push(`API: ${apiDuration}`);
+	}
+	return parts.length > 0 ? ` | ${parts.join(" | ")}` : "";
+};
+const CompletionLogger = {
+	completionCallbacks: /* @__PURE__ */ new Map(),
+	registerCompletion(requestId, context, startTime) {
+		this.completionCallbacks.set(requestId, {
+			context,
+			startTime,
+			requestId
+		});
+	},
+	executeCompletion(requestId) {
+		const data = this.completionCallbacks.get(requestId);
+		if (data) {
+			this.logCompletion(data);
+			this.completionCallbacks.delete(requestId);
+		}
+	},
+	logCompletion(data) {
+		const { context: c, startTime } = data;
+		const end = Date.now();
+		const duration = end - startTime;
+		const requestData = c.get("requestData");
+		const method = pad(c.req.method, 4);
+		const path$1 = pad(c.req.path, 18);
+		const status = pad(c.res.status.toString(), 3);
+		const durationStr = pad(`${duration}ms`, 8);
+		let logLine = `  --> ${method}${path$1}${status} ${durationStr}`;
+		if (requestData) logLine += formatTokenUsage(requestData);
+		consola.info(logLine);
+	},
+	logRateLimit(data, response) {
+		const { context: c, startTime } = data;
+		const end = Date.now();
+		const duration = end - startTime;
+		const rateLimitExceeded = response.headers.get("x-ratelimit-exceeded") || "";
+		const rateLimitType = rateLimitExceeded.split(":")[1] || "unknown";
+		const retry = response.headers.get("retry-after") || response.headers.get("x-ratelimit-user-retry-after") || "?";
+		const method = pad(c.req.method, 4);
+		const path$1 = pad(c.req.path, 18);
+		const status = pad("429", 3);
+		const durationStr = pad(`${duration}ms`, 8);
+		let logLine = `⚠   --> ${method}${path$1}${status} ${durationStr}`;
+		logLine += ` | Rate limited (${retry}s retry) | ${rateLimitType}`;
+		const requestData = c.get("requestData");
+		if (requestData?.copilotDuration) {
+			const apiDuration = pad(`${Math.round(requestData.copilotDuration)}ms`, 8);
+			logLine += ` | API: ${apiDuration}`;
+		}
+		consola.info(logLine);
+	},
+	cleanup() {
+		const MAX_CALLBACKS = 1e3;
+		const fiveMinutesAgo = Date.now() - 300 * 1e3;
+		for (const [requestId, data] of this.completionCallbacks) if (data.startTime < fiveMinutesAgo) this.completionCallbacks.delete(requestId);
+		if (this.completionCallbacks.size > MAX_CALLBACKS) {
+			const entries = Array.from(this.completionCallbacks.entries()).sort(([, a], [, b]) => a.startTime - b.startTime);
+			const toRemove = entries.slice(0, entries.length - MAX_CALLBACKS);
+			for (const [requestId] of toRemove) this.completionCallbacks.delete(requestId);
+		}
+	}
+};
+setInterval(() => CompletionLogger.cleanup(), 60 * 1e3);
 
 //#endregion
 //#region src/lib/error.ts
@@ -97,6 +408,25 @@ var HTTPError = class extends Error {
 	}
 };
 async function forwardError(c, error) {
+	if (error instanceof HTTPError && error.response.status === 429) {
+		const requestId = c.get("requestId");
+		const completionData = CompletionLogger.completionCallbacks.get(requestId);
+		if (completionData) {
+			CompletionLogger.logRateLimit(completionData, error.response);
+			CompletionLogger.completionCallbacks.delete(requestId);
+		}
+		const errorText = await error.response.text();
+		let errorJson;
+		try {
+			errorJson = JSON.parse(errorText);
+		} catch {
+			errorJson = { error: {
+				message: errorText,
+				type: "error"
+			} };
+		}
+		return c.json(errorJson, 429);
+	}
 	consola.error("Error occurred:", error);
 	if (error instanceof HTTPError) {
 		const errorText = await error.response.text();
@@ -208,26 +538,10 @@ const getModels = async () => {
 
 //#endregion
 //#region src/services/get-vscode-version.ts
-const FALLBACK = "1.98.1";
-async function getVSCodeVersion() {
-	const controller = new AbortController();
-	const timeout = setTimeout(() => {
-		controller.abort();
-	}, 5e3);
-	try {
-		const response = await fetch("https://aur.archlinux.org/cgit/aur.git/plain/PKGBUILD?h=visual-studio-code-bin", { signal: controller.signal });
-		const pkgbuild = await response.text();
-		const pkgverRegex = /pkgver=([0-9.]+)/;
-		const match = pkgbuild.match(pkgverRegex);
-		if (match) return match[1];
-		return FALLBACK;
-	} catch {
-		return FALLBACK;
-	} finally {
-		clearTimeout(timeout);
-	}
+function getVSCodeVersion() {
+	return "1.105.0-insider";
 }
-await getVSCodeVersion();
+getVSCodeVersion();
 
 //#endregion
 //#region src/lib/utils.ts
@@ -239,8 +553,8 @@ async function cacheModels() {
 	const models = await getModels();
 	state.models = models;
 }
-const cacheVSCodeVersion = async () => {
-	const response = await getVSCodeVersion();
+const cacheVSCodeVersion = () => {
+	const response = getVSCodeVersion();
 	state.vsCodeVersion = response;
 	consola.info(`Using VSCode version: ${response}`);
 };
@@ -292,6 +606,25 @@ async function pollAccessToken(deviceCode) {
 
 //#endregion
 //#region src/lib/token.ts
+let tokenRefreshInterval;
+let isRefreshPending = false;
+let onlineHandler;
+let offlineHandler;
+function cleanupTokenManagement() {
+	consola.debug("Cleaning up token management");
+	if (tokenRefreshInterval) {
+		clearInterval(tokenRefreshInterval);
+		tokenRefreshInterval = void 0;
+	}
+	if (onlineHandler) {
+		connectivityMonitor.off("online", onlineHandler);
+		onlineHandler = void 0;
+	}
+	if (offlineHandler) {
+		connectivityMonitor.off("offline", offlineHandler);
+		offlineHandler = void 0;
+	}
+}
 const readGithubToken = () => fs.readFile(PATHS.GITHUB_TOKEN_PATH, "utf8");
 const writeGithubToken = (token) => fs.writeFile(PATHS.GITHUB_TOKEN_PATH, token);
 const setupCopilotToken = async () => {
@@ -300,18 +633,52 @@ const setupCopilotToken = async () => {
 	consola.debug("GitHub Copilot Token fetched successfully!");
 	if (state.showToken) consola.info("Copilot token:", token);
 	const refreshInterval = (refresh_in - 60) * 1e3;
-	setInterval(async () => {
-		consola.debug("Refreshing Copilot token");
+	const refreshTokenWithRetry = async (maxRetries = 5, baseDelay = 1e3, reason = "scheduled") => {
+		if (isRefreshPending) {
+			consola.debug("Token refresh already in progress, skipping");
+			return;
+		}
+		isRefreshPending = true;
 		try {
-			const { token: token$1 } = await getCopilotToken();
-			state.copilotToken = token$1;
-			consola.debug("Copilot token refreshed");
-			if (state.showToken) consola.info("Refreshed Copilot token:", token$1);
-		} catch (error) {
-			consola.error("Failed to refresh Copilot token:", error);
-			throw error;
+			for (let attempt = 1; attempt <= maxRetries; attempt++) try {
+				consola.debug(`Refreshing Copilot token (${reason}, attempt ${attempt}/${maxRetries})`);
+				const { token: token$1 } = await getCopilotToken();
+				state.copilotToken = token$1;
+				consola.debug("Copilot token refreshed successfully");
+				if (state.showToken) consola.info("Refreshed Copilot token:", token$1);
+				return;
+			} catch (error) {
+				const isLastAttempt = attempt === maxRetries;
+				consola.error(`Failed to refresh Copilot token (attempt ${attempt}/${maxRetries}):`, error);
+				if (isLastAttempt) {
+					consola.error("All token refresh attempts failed. Service may be unavailable until next scheduled refresh.");
+					return;
+				}
+				const delay = baseDelay * Math.pow(2, attempt - 1);
+				consola.debug(`Retrying token refresh in ${delay}ms...`);
+				await new Promise((resolve) => setTimeout(resolve, delay));
+			}
+		} finally {
+			isRefreshPending = false;
 		}
+	};
+	tokenRefreshInterval = setInterval(() => {
+		refreshTokenWithRetry(5, 1e3, "scheduled").catch((error) => {
+			consola.error("Unexpected error in scheduled token refresh:", error);
+		});
 	}, refreshInterval);
+	connectivityMonitor.start();
+	onlineHandler = () => {
+		consola.debug("Network connectivity restored, attempting immediate token refresh");
+		refreshTokenWithRetry(3, 500, "network-restored").catch((error) => {
+			consola.error("Unexpected error in network-restored token refresh:", error);
+		});
+	};
+	offlineHandler = () => {
+		consola.debug("Network connectivity lost");
+	};
+	connectivityMonitor.on("online", onlineHandler);
+	connectivityMonitor.on("offline", offlineHandler);
 };
 async function setupGitHubToken(options) {
 	try {
@@ -444,7 +811,8 @@ const checkUsage = defineCommand({
 async function getPackageVersion() {
 	try {
 		const packageJsonPath = new URL("../package.json", import.meta.url).pathname;
-		const packageJson = JSON.parse(await fs.readFile(packageJsonPath, "utf8"));
+		const packageJsonBuffer = await fs.readFile(packageJsonPath);
+		const packageJson = JSON.parse(packageJsonBuffer.toString());
 		return packageJson.version;
 	} catch {
 		return "unknown";
@@ -573,6 +941,24 @@ function generateEnvScript(envVars, commandToRun = "") {
 	return commandBlock || commandToRun;
 }
 
+//#endregion
+//#region src/lib/logger/enhanced-hono-logger.ts
+function generateRequestId() {
+	return `req_${Date.now()}_${Math.random().toString(36).slice(2, 11)}`;
+}
+function enhancedLogger() {
+	return async (c, next) => {
+		const start$1 = Date.now();
+		const requestId = generateRequestId();
+		c.set("requestId", requestId);
+		c.header("x-request-id", requestId);
+		CompletionLogger.registerCompletion(requestId, c, start$1);
+		await next();
+		const requestData = c.get("requestData");
+		if (requestData?.tokenUsage) CompletionLogger.executeCompletion(requestId);
+	};
+}
+
 //#endregion
 //#region src/lib/approval.ts
 const awaitApproval = async () => {
@@ -580,6 +966,28 @@ const awaitApproval = async () => {
 	if (!response) throw new HTTPError("Request rejected", Response.json({ message: "Request rejected" }, { status: 403 }));
 };
 
+//#endregion
+//#region src/lib/logger/token-tracker.ts
+const TOKEN_PRICING = {
+	input: 3e-6,
+	output: 15e-6
+};
+function parseGitHubCopilotUsage(usageData) {
+	const inputTokens = usageData.prompt_tokens || 0;
+	const outputTokens = usageData.completion_tokens || 0;
+	const totalTokens = usageData.total_tokens || inputTokens + outputTokens;
+	const estimatedCost = inputTokens * TOKEN_PRICING.input + outputTokens * TOKEN_PRICING.output;
+	return {
+		inputTokens,
+		outputTokens,
+		totalTokens,
+		estimatedCost,
+		cachedTokens: usageData.prompt_tokens_details?.cached_tokens,
+		acceptedPredictionTokens: usageData.completion_tokens_details?.accepted_prediction_tokens,
+		rejectedPredictionTokens: usageData.completion_tokens_details?.rejected_prediction_tokens
+	};
+}
+
 //#endregion
 //#region src/lib/rate-limit.ts
 async function checkRateLimit(state$1) {
@@ -607,40 +1015,52 @@ async function checkRateLimit(state$1) {
 }
 
 //#endregion
-//#region src/lib/tokenizer.ts
-const getTokenCount = (messages) => {
-	const simplifiedMessages = messages.map((message) => {
-		let content = "";
-		if (typeof message.content === "string") content = message.content;
-		else if (Array.isArray(message.content)) content = message.content.filter((part) => part.type === "text").map((part) => part.text).join("");
-		return {
-			...message,
-			content
-		};
-	});
-	let inputMessages = simplifiedMessages.filter((message) => {
-		return message.role !== "tool";
-	});
-	let outputMessages = [];
-	const lastMessage = simplifiedMessages.at(-1);
-	if (lastMessage?.role === "assistant") {
-		inputMessages = simplifiedMessages.slice(0, -1);
-		outputMessages = [lastMessage];
-	}
-	const inputTokens = countTokens(inputMessages);
-	const outputTokens = countTokens(outputMessages);
-	return {
-		input: inputTokens,
-		output: outputTokens
-	};
-};
+//#region src/lib/sanitize.ts
+/**
+* Sanitizes JSON payloads by removing ANSI escape sequences and invisible Unicode characters
+* that can cause GitHub Copilot API to return 400 Bad Request errors.
+*/
+/**
+* Removes ANSI escape sequences and problematic Unicode characters from a string
+*/
+function sanitizeString(str) {
+	let result = str;
+	const escChar = String.fromCodePoint(27);
+	const parts = result.split(escChar);
+	if (parts.length > 1) {
+		result = parts[0];
+		for (let i = 1; i < parts.length; i++) {
+			const part = parts[i];
+			const match = part.match(/^\[[0-9;]*[a-z]/i);
+			result += match ? part.slice(match[0].length) : escChar + part;
+		}
+	}
+	return result.replaceAll(/[\u200B-\u200D\uFEFF]/g, "").replaceAll(/[\u2060-\u2064]/g, "").replaceAll(/[\u206A-\u206F]/g, "").replaceAll(/[\u180E\u2000-\u200A\u2028\u2029\u202F\u205F\u3000]/g, "").replaceAll(/[\uFFF0-\uFFFF]/g, "").replaceAll(/[\x00-\x08\v\f\x0E-\x1F]/g, "");
+}
+/**
+* Recursively sanitizes all string values in an object or array
+*/
+function sanitizePayload(payload) {
+	if (typeof payload === "string") return sanitizeString(payload);
+	if (Array.isArray(payload)) {
+		const sanitizedArray = payload.map((item) => sanitizePayload(item));
+		return sanitizedArray;
+	}
+	if (payload && typeof payload === "object") {
+		const sanitized = {};
+		for (const [key, value] of Object.entries(payload)) sanitized[key] = sanitizePayload(value);
+		return sanitized;
+	}
+	return payload;
+}
 
 //#endregion
 //#region src/services/copilot/create-chat-completions.ts
 const createChatCompletions = async (payload) => {
 	if (!state.copilotToken) throw new Error("Copilot token not found");
-	const enableVision = payload.messages.some((x) => typeof x.content !== "string" && x.content?.some((x$1) => x$1.type === "image_url"));
-	const isAgentCall = payload.messages.some((msg) => ["assistant", "tool"].includes(msg.role));
+	const sanitizedPayload = sanitizePayload(payload);
+	const enableVision = sanitizedPayload.messages.some((x) => typeof x.content !== "string" && x.content?.some((x$1) => x$1.type === "image_url"));
+	const isAgentCall = sanitizedPayload.messages.some((msg) => ["assistant", "tool"].includes(msg.role));
 	const headers = {
 		...copilotHeaders(state, enableVision),
 		"X-Initiator": isAgentCall ? "agent" : "user"
@@ -651,17 +1071,20 @@ const createChatCompletions = async (payload) => {
 		controller.abort();
 	}, timeoutMs);
 	try {
-		const response = await fetch(`${copilotBaseUrl(state)}/chat/completions`, {
+		const { statusCode, headers: responseHeaders, body } = await request(`${copilotBaseUrl(state)}/chat/completions`, {
 			method: "POST",
 			headers,
-			body: JSON.stringify(payload),
-			signal: controller.signal
+			body: JSON.stringify(sanitizedPayload),
+			signal: controller.signal,
+			headersTimeout: timeoutMs,
+			bodyTimeout: timeoutMs * 3
 		});
-		if (!response.ok) {
-			consola.error("Failed to create chat completions", response);
-			throw new HTTPError("Failed to create chat completions", response);
-		}
-		if (payload.stream) return events(response);
+		const response = new Response(body, {
+			status: statusCode,
+			headers: responseHeaders
+		});
+		if (!response.ok) throw new HTTPError("Failed to create chat completions", response);
+		if (sanitizedPayload.stream) return events(response);
 		return await response.json();
 	} finally {
 		clearTimeout(timeout);
@@ -674,7 +1097,7 @@ async function handleCompletion$1(c) {
 	await checkRateLimit(state);
 	let payload = await c.req.json();
 	consola.debug("Request payload:", JSON.stringify(payload).slice(-400));
-	consola.info("Current token count:", getTokenCount(payload.messages));
+	c.set("requestData", { model: payload.model });
 	if (state.manualApprove) await awaitApproval();
 	if (isNullish(payload.max_tokens)) {
 		const selectedModel = state.models?.data.find((model) => model.id === payload.model);
@@ -684,17 +1107,42 @@ async function handleCompletion$1(c) {
 		};
 		consola.debug("Set max_tokens to:", JSON.stringify(payload.max_tokens));
 	}
+	const copilotStart = performance.now();
 	const response = await createChatCompletions(payload);
+	const copilotDuration = performance.now() - copilotStart;
 	if (isNonStreaming$1(response)) {
+		const requestData = c.get("requestData") || {};
+		if (response.usage) requestData.tokenUsage = parseGitHubCopilotUsage(response.usage);
+		requestData.copilotDuration = copilotDuration;
+		c.set("requestData", requestData);
 		consola.debug("Non-streaming response:", JSON.stringify(response));
 		return c.json(response);
 	}
-	consola.debug("Streaming response");
 	return streamSSE(c, async (stream) => {
+		let finalUsage = null;
 		for await (const chunk of response) {
-			consola.debug("Streaming chunk:", JSON.stringify(chunk));
+			if (chunk.data && chunk.data !== "[DONE]") try {
+				const parsed = JSON.parse(chunk.data);
+				if (parsed.usage) {
+					finalUsage = parsed.usage;
+					const requestData = c.get("requestData") || {};
+					requestData.tokenUsage = parseGitHubCopilotUsage(finalUsage);
+					requestData.copilotDuration = copilotDuration;
+					c.set("requestData", requestData);
+				}
+			} catch {}
 			await stream.writeSSE(chunk);
 		}
+		if (finalUsage) {
+			const requestData = c.get("requestData") || {};
+			if (!requestData.tokenUsage) {
+				requestData.tokenUsage = parseGitHubCopilotUsage(finalUsage);
+				requestData.copilotDuration = copilotDuration;
+				c.set("requestData", requestData);
+			}
+		}
+		const requestId = c.get("requestId");
+		if (requestId) CompletionLogger.executeCompletion(requestId);
 	});
 }
 const isNonStreaming$1 = (response) => Object.hasOwn(response, "choices");
@@ -738,8 +1186,15 @@ const createEmbeddings = async (payload) => {
 const embeddingRoutes = new Hono();
 embeddingRoutes.post("/", async (c) => {
 	try {
-		const paylod = await c.req.json();
-		const response = await createEmbeddings(paylod);
+		const payload = await c.req.json();
+		c.set("requestData", { model: payload.model });
+		const copilotStart = performance.now();
+		const response = await createEmbeddings(payload);
+		const copilotDuration = performance.now() - copilotStart;
+		const requestData = c.get("requestData") || {};
+		requestData.tokenUsage = parseGitHubCopilotUsage(response.usage);
+		requestData.copilotDuration = copilotDuration;
+		c.set("requestData", requestData);
 		return c.json(response);
 	} catch (error) {
 		return await forwardError(c, error);
@@ -807,7 +1262,7 @@ function handleUserMessage(message) {
 		for (const block of toolResultBlocks) newMessages.push({
 			role: "tool",
 			tool_call_id: block.tool_use_id,
-			content: block.content
+			content: mapContent(block.content)
 		});
 		if (otherBlocks.length > 0) newMessages.push({
 			role: "user",
@@ -1076,9 +1531,16 @@ async function handleCompletion(c) {
 	consola.debug("Anthropic request payload:", JSON.stringify(anthropicPayload));
 	const openAIPayload = translateToOpenAI(anthropicPayload);
 	consola.debug("Translated OpenAI request payload:", JSON.stringify(openAIPayload));
+	c.set("requestData", { model: openAIPayload.model });
+	const copilotStart = performance.now();
 	if (state.manualApprove) await awaitApproval();
 	const response = await createChatCompletions(openAIPayload);
+	const copilotDuration = performance.now() - copilotStart;
 	if (isNonStreaming(response)) {
+		const requestData = c.get("requestData") || {};
+		if (response.usage) requestData.tokenUsage = parseGitHubCopilotUsage(response.usage);
+		requestData.copilotDuration = copilotDuration;
+		c.set("requestData", requestData);
 		consola.debug("Non-streaming response from Copilot:", JSON.stringify(response).slice(-400));
 		const anthropicResponse = translateToAnthropic(response);
 		consola.debug("Translated Anthropic response:", JSON.stringify(anthropicResponse));
@@ -1086,6 +1548,7 @@ async function handleCompletion(c) {
 	}
 	consola.debug("Streaming response from Copilot");
 	return streamSSE(c, async (stream) => {
+		let finalUsage = null;
 		const streamState = {
 			messageStartSent: false,
 			contentBlockIndex: 0,
@@ -1097,6 +1560,13 @@ async function handleCompletion(c) {
 			if (rawEvent.data === "[DONE]") break;
 			if (!rawEvent.data) continue;
 			const chunk = JSON.parse(rawEvent.data);
+			if (chunk.usage) {
+				finalUsage = chunk.usage;
+				const requestData = c.get("requestData") || {};
+				requestData.tokenUsage = parseGitHubCopilotUsage(finalUsage);
+				requestData.copilotDuration = copilotDuration;
+				c.set("requestData", requestData);
+			}
 			const events$1 = translateChunkToAnthropicEvents(chunk, streamState);
 			for (const event of events$1) {
 				consola.debug("Translated Anthropic event:", JSON.stringify(event));
@@ -1106,6 +1576,16 @@ async function handleCompletion(c) {
 				});
 			}
 		}
+		if (finalUsage) {
+			const requestData = c.get("requestData") || {};
+			if (!requestData.tokenUsage) {
+				requestData.tokenUsage = parseGitHubCopilotUsage(finalUsage);
+				requestData.copilotDuration = copilotDuration;
+				c.set("requestData", requestData);
+			}
+		}
+		const requestId = c.get("requestId");
+		if (requestId) CompletionLogger.executeCompletion(requestId);
 	});
 }
 const isNonStreaming = (response) => Object.hasOwn(response, "choices");
@@ -1177,7 +1657,7 @@ usageRoute.get("/", async (c) => {
 //#endregion
 //#region src/server.ts
 const server = new Hono();
-server.use(logger());
+server.use(enhancedLogger());
 server.use(cors());
 server.get("/", (c) => c.text("Server running"));
 server.route("/chat/completions", completionRoutes);
@@ -1193,7 +1673,86 @@ server.post("/v1/messages/count_tokens", (c) => c.json({ input_tokens: 1 }));
 
 //#endregion
 //#region src/start.ts
+const cleanupFunctions = [];
+function setupGracefulShutdown() {
+	const cleanup = async () => {
+		consola.info("Gracefully shutting down...");
+		for (const cleanupFn of cleanupFunctions) try {
+			await cleanupFn();
+		} catch (error) {
+			consola.error("Error during cleanup:", error);
+		}
+		consola.info("Shutdown complete");
+		process$1.exit(0);
+	};
+	process$1.on("SIGINT", cleanup);
+	process$1.on("SIGTERM", cleanup);
+	process$1.on("uncaughtException", (error) => {
+		consola.error("Uncaught exception:", error);
+		cleanup().finally(() => process$1.exit(1));
+	});
+	process$1.on("unhandledRejection", (reason, promise) => {
+		consola.error("Unhandled promise rejection at:", promise, "reason:", reason);
+		cleanup().finally(() => process$1.exit(1));
+	});
+}
+async function setupClaudeCodeConfiguration(options, serverUrl) {
+	if (!options.claudeCode) return;
+	invariant(state.models, "Models should be loaded by now");
+	let selectedModel;
+	let selectedSmallModel;
+	if (options.model && options.smallModel) {
+		const availableModelIds = state.models.data.map((model) => model.id);
+		if (!availableModelIds.includes(options.model)) {
+			consola.error(`Invalid model: ${options.model}`);
+			consola.info(`Available models: \n${availableModelIds.join("\n")}`);
+			process$1.exit(1);
+		}
+		if (!availableModelIds.includes(options.smallModel)) {
+			consola.error(`Invalid small model: ${options.smallModel}`);
+			consola.info(`Available models: \n${availableModelIds.join("\n")}`);
+			process$1.exit(1);
+		}
+		selectedModel = options.model;
+		selectedSmallModel = options.smallModel;
+		consola.info(`Using model: ${selectedModel}`);
+		consola.info(`Using small model: ${selectedSmallModel}`);
+	} else if (options.model || options.smallModel) {
+		consola.error("Both --model and --small-model must be specified when using command-line model selection");
+		process$1.exit(1);
+	} else {
+		selectedModel = await consola.prompt("Select a model to use with Claude Code", {
+			type: "select",
+			options: state.models.data.map((model) => model.id)
+		});
+		selectedSmallModel = await consola.prompt("Select a small model to use with Claude Code", {
+			type: "select",
+			options: state.models.data.map((model) => model.id)
+		});
+	}
+	const command = generateEnvScript({
+		ANTHROPIC_BASE_URL: serverUrl,
+		ANTHROPIC_AUTH_TOKEN: "dummy",
+		ANTHROPIC_MODEL: selectedModel,
+		ANTHROPIC_SMALL_FAST_MODEL: selectedSmallModel
+	}, "claude");
+	try {
+		clipboard.writeSync(command);
+		consola.success("Copied Claude Code command to clipboard!");
+	} catch {
+		consola.warn("Failed to copy to clipboard. Here is the Claude Code command:");
+		consola.log(command);
+	}
+}
 async function runServer(options) {
+	setupGracefulShutdown();
+	cleanupFunctions.push(() => {
+		consola.debug("Cleaning up connectivity monitor");
+		connectivityMonitor.stop();
+	}, () => {
+		consola.debug("Cleaning up token management");
+		cleanupTokenManagement();
+	});
 	if (options.verbose) {
 		consola.level = 5;
 		consola.info("Verbose logging enabled");
@@ -1205,8 +1764,10 @@ async function runServer(options) {
 	state.rateLimitWait = options.rateLimitWait;
 	state.showToken = options.showToken;
 	state.timeoutMs = options.timeout;
+	state.connectivity.enabled = !options.disableConnectivityMonitoring;
 	await ensurePaths();
-	await cacheVSCodeVersion();
+	cacheVSCodeVersion();
+	await initializeVSCodeIdentifiers(state);
 	if (options.githubToken) {
 		state.githubToken = options.githubToken;
 		consola.info("Using provided GitHub token");
@@ -1215,53 +1776,7 @@ async function runServer(options) {
 	await cacheModels();
 	consola.info(`Available models: \n${state.models?.data.map((model) => `- ${model.id}`).join("\n")}`);
 	const serverUrl = `http://localhost:${options.port}`;
-	if (options.claudeCode) {
-		invariant(state.models, "Models should be loaded by now");
-		let selectedModel;
-		let selectedSmallModel;
-		if (options.model && options.smallModel) {
-			const availableModelIds = state.models.data.map((model) => model.id);
-			if (!availableModelIds.includes(options.model)) {
-				consola.error(`Invalid model: ${options.model}`);
-				consola.info(`Available models: \n${availableModelIds.join("\n")}`);
-				process$1.exit(1);
-			}
-			if (!availableModelIds.includes(options.smallModel)) {
-				consola.error(`Invalid small model: ${options.smallModel}`);
-				consola.info(`Available models: \n${availableModelIds.join("\n")}`);
-				process$1.exit(1);
-			}
-			selectedModel = options.model;
-			selectedSmallModel = options.smallModel;
-			consola.info(`Using model: ${selectedModel}`);
-			consola.info(`Using small model: ${selectedSmallModel}`);
-		} else if (options.model || options.smallModel) {
-			consola.error("Both --model and --small-model must be specified when using command-line model selection");
-			process$1.exit(1);
-		} else {
-			selectedModel = await consola.prompt("Select a model to use with Claude Code", {
-				type: "select",
-				options: state.models.data.map((model) => model.id)
-			});
-			selectedSmallModel = await consola.prompt("Select a small model to use with Claude Code", {
-				type: "select",
-				options: state.models.data.map((model) => model.id)
-			});
-		}
-		const command = generateEnvScript({
-			ANTHROPIC_BASE_URL: serverUrl,
-			ANTHROPIC_AUTH_TOKEN: "dummy",
-			ANTHROPIC_MODEL: selectedModel,
-			ANTHROPIC_SMALL_FAST_MODEL: selectedSmallModel
-		}, "claude");
-		try {
-			clipboard.writeSync(command);
-			consola.success("Copied Claude Code command to clipboard!");
-		} catch {
-			consola.warn("Failed to copy to clipboard. Here is the Claude Code command:");
-			consola.log(command);
-		}
-	}
+	await setupClaudeCodeConfiguration(options, serverUrl);
 	consola.box(`🌐 Usage Viewer: https://ericc-ch.github.io/copilot-api?endpoint=${serverUrl}/usage`);
 	serve({
 		fetch: server.fetch,
@@ -1338,6 +1853,11 @@ const start = defineCommand({
 			alias: "t",
 			type: "string",
 			description: "API timeout in milliseconds (default: 120000)"
+		},
+		"disable-connectivity-monitoring": {
+			type: "boolean",
+			default: false,
+			description: "Disable automatic network connectivity monitoring for token refresh"
 		}
 	},
 	run({ args }) {
@@ -1357,7 +1877,8 @@ const start = defineCommand({
 			model: args.model,
 			smallModel: args["small-model"],
 			showToken: args["show-token"],
-			timeout
+			timeout,
+			disableConnectivityMonitoring: args["disable-connectivity-monitoring"]
 		});
 	}
 });