@gxp-dev/tools 2.0.62 → 2.0.64

package/browser-extensions/chrome/background.js

@@ -25,17 +25,17 @@ let config = {
 	maskingMode: false,
 	clearCacheOnEnable: true,
 	disableCacheForRedirects: true,
-};
+}
 
-let notificationTimeouts = new Map();
-let cacheBlacklist = new Set();
+let notificationTimeouts = new Map()
+let cacheBlacklist = new Set()
 
 // Initialize extension
-chrome.runtime.onStartup.addListener(initializeExtension);
-chrome.runtime.onInstalled.addListener(initializeExtension);
+chrome.runtime.onStartup.addListener(initializeExtension)
+chrome.runtime.onInstalled.addListener(initializeExtension)
 
 async function initializeExtension() {
-	console.log("[JavaScript Proxy] Initializing extension...");
+	console.log("[JavaScript Proxy] Initializing extension...")
 	try {
 		// Load saved configuration
 		const defaultConfig = {
@@ -66,22 +66,22 @@ async function initializeExtension() {
 			maskingMode: false,
 			clearCacheOnEnable: true,
 			disableCacheForRedirects: true,
-		};
+		}
 
-		const result = await chrome.storage.sync.get(defaultConfig);
-		config = result;
+		const result = await chrome.storage.sync.get(defaultConfig)
+		config = result
 
 		// Migrate legacy configuration to new rules format
-		config = migrateConfig(config);
+		config = migrateConfig(config)
 
-		console.log("[JavaScript Proxy] Loaded configuration:", config);
+		console.log("[JavaScript Proxy] Loaded configuration:", config)
 
-		updateIcon();
-		updateRequestListener();
+		updateIcon()
+		updateRequestListener()
 
-		console.log("[JavaScript Proxy] Extension initialized successfully");
+		console.log("[JavaScript Proxy] Extension initialized successfully")
 	} catch (error) {
-		console.error("[JavaScript Proxy] Failed to initialize:", error);
+		console.error("[JavaScript Proxy] Failed to initialize:", error)
 	}
 }
 
@@ -107,7 +107,7 @@ function migrateConfig(config) {
 				returnBlank: false,
 				useCustomPattern: false,
 			},
-		};
+		}
 	} else {
 		// Ensure all required fields exist
 		if (!config.rules.js) {
@@ -119,7 +119,7 @@ function migrateConfig(config) {
 				redirectUrl:
 					config.redirectUrl || "https://localhost:3060/src/Plugin.vue",
 				useCustomPattern: config.useCustomPattern || false,
-			};
+			}
 		}
 		if (!config.rules.css) {
 			config.rules.css = {
@@ -129,16 +129,16 @@ function migrateConfig(config) {
 				redirectUrl: "",
 				returnBlank: true,
 				useCustomPattern: false,
-			};
+			}
 		}
 	}
 
-	return config;
+	return config
 }
 
 // Update toolbar icon based on state
 function updateIcon() {
-	const iconPath = config.enabled ? "icons/gx_on" : "icons/gx_off";
+	const iconPath = config.enabled ? "icons/gx_on" : "icons/gx_off"
 	chrome.action.setIcon({
 		path: {
 			16: `${iconPath}_16.png`,
@@ -146,39 +146,39 @@ function updateIcon() {
 			64: `${iconPath}_64.png`,
 			128: `${iconPath}_128.png`,
 		},
-	});
+	})
 
 	const title = config.enabled
 		? "JavaScript Proxy (ON)"
-		: "JavaScript Proxy (OFF)";
-	chrome.action.setTitle({ title });
+		: "JavaScript Proxy (OFF)"
+	chrome.action.setTitle({ title })
 }
 
 // Cache management functions
 async function clearCacheForPattern(urlPattern) {
 	try {
-		console.log(`[JavaScript Proxy] Clearing cache for pattern: ${urlPattern}`);
+		console.log(`[JavaScript Proxy] Clearing cache for pattern: ${urlPattern}`)
 
 		// Clear browser cache
 		await chrome.browsingData.removeCache({
 			origins: [], // Empty array means all origins
 			since: 0, // Clear all cache entries
-		});
+		})
 
 		// Clear service worker caches by injecting script into active tabs
-		await clearServiceWorkerCaches(urlPattern);
+		await clearServiceWorkerCaches(urlPattern)
 
-		console.log("[JavaScript Proxy] Cache cleared successfully");
+		console.log("[JavaScript Proxy] Cache cleared successfully")
 	} catch (error) {
-		console.error("[JavaScript Proxy] Error clearing cache:", error);
-		throw error; // Re-throw to let the caller handle the error
+		console.error("[JavaScript Proxy] Error clearing cache:", error)
+		throw error // Re-throw to let the caller handle the error
 	}
 }
 
 async function clearServiceWorkerCaches(urlPattern) {
 	try {
 		// Get all active tabs
-		const tabs = await chrome.tabs.query({});
+		const tabs = await chrome.tabs.query({})
 
 		// Inject the script into each tab
 		for (const tab of tabs) {
@@ -193,20 +193,20 @@ async function clearServiceWorkerCaches(urlPattern) {
 						func: async function (pattern) {
 							try {
 								if ("caches" in window) {
-									const cacheNames = await caches.keys();
-									const regex = new RegExp(pattern, "i");
+									const cacheNames = await caches.keys()
+									const regex = new RegExp(pattern, "i")
 
 									for (const cacheName of cacheNames) {
-										const cache = await caches.open(cacheName);
-										const requests = await cache.keys();
+										const cache = await caches.open(cacheName)
+										const requests = await cache.keys()
 
 										for (const request of requests) {
 											if (regex.test(request.url)) {
-												await cache.delete(request);
+												await cache.delete(request)
 												console.log(
 													"[JavaScript Proxy] Deleted from cache:",
-													request.url
-												);
+													request.url,
+												)
 											}
 										}
 									}
@@ -219,77 +219,77 @@ async function clearServiceWorkerCaches(urlPattern) {
 										navigator.serviceWorker.controller.postMessage({
 											type: "CLEAR_CACHE_FOR_PATTERN",
 											pattern: pattern,
-										});
+										})
 									}
 								}
 							} catch (error) {
 								console.error(
 									"[JavaScript Proxy] Error clearing service worker cache:",
-									error
-								);
+									error,
+								)
 							}
 						},
 						args: [urlPattern.replace(/\\/g, "\\\\")],
-					});
+					})
 				}
 			} catch (error) {
 				// Tab might not allow script injection, continue with others
 				console.debug(
 					`[JavaScript Proxy] Could not inject cache clear script into tab ${tab.id}:`,
-					error
-				);
+					error,
+				)
 			}
 		}
 
-		console.log("[JavaScript Proxy] Service worker cache clearing attempted");
+		console.log("[JavaScript Proxy] Service worker cache clearing attempted")
 	} catch (error) {
 		console.error(
 			"[JavaScript Proxy] Error clearing service worker caches:",
-			error
-		);
+			error,
+		)
 	}
 }
 
 async function addToCacheBlacklist(url) {
 	try {
-		const urlObj = new URL(url);
-		const origin = urlObj.origin;
-		cacheBlacklist.add(origin);
-		console.log(`[JavaScript Proxy] Added ${origin} to cache blacklist`);
+		const urlObj = new URL(url)
+		const origin = urlObj.origin
+		cacheBlacklist.add(origin)
+		console.log(`[JavaScript Proxy] Added ${origin} to cache blacklist`)
 	} catch (error) {
-		console.error("[JavaScript Proxy] Error adding to cache blacklist:", error);
+		console.error("[JavaScript Proxy] Error adding to cache blacklist:", error)
 	}
 }
 
 function shouldDisableCache(url) {
-	if (!config.disableCacheForRedirects) return false;
+	if (!config.disableCacheForRedirects) return false
 
 	try {
 		// Check against all enabled rules
 		for (const [ruleType, rule] of Object.entries(config.rules || {})) {
 			if (rule.enabled) {
 				const pattern =
-					rule.useCustomPattern && rule.pattern ? rule.pattern : rule.pattern;
-				const regex = new RegExp(pattern, "i");
+					rule.useCustomPattern && rule.pattern ? rule.pattern : rule.pattern
+				const regex = new RegExp(pattern, "i")
 				if (regex.test(url)) {
-					return true;
+					return true
 				}
 			}
 		}
 
 		// Fallback to legacy pattern for backward compatibility
 		if (config.urlPattern) {
-			const regex = new RegExp(config.urlPattern, "i");
-			return regex.test(url);
+			const regex = new RegExp(config.urlPattern, "i")
+			return regex.test(url)
 		}
 
-		return false;
+		return false
 	} catch (error) {
 		console.error(
 			"[JavaScript Proxy] Error checking cache disable pattern:",
-			error
-		);
-		return false;
+			error,
+		)
+		return false
 	}
 }
 
@@ -299,27 +299,27 @@ async function updateRequestListener() {
 	try {
 		await chrome.declarativeNetRequest.updateDynamicRules({
 			removeRuleIds: [1, 2, 3, 4, 5], // Remove up to 5 rules
-		});
+		})
 	} catch (error) {
 		// Rules might not exist, that's fine
 	}
 
 	if (config.enabled && !config.maskingMode) {
-		const rulesToAdd = [];
-		let ruleId = 1;
+		const rulesToAdd = []
+		let ruleId = 1
 
 		// Process each rule type
 		for (const [ruleType, rule] of Object.entries(config.rules || {})) {
 			if (rule.enabled && rule.pattern) {
 				if (rule.returnBlank) {
 					// For blank returns, we'll handle in webRequest (can't return blank with declarativeNetRequest)
-					continue;
+					continue
 				}
 
 				if (rule.redirectUrl) {
 					// Clear cache if enabled
 					if (config.clearCacheOnEnable) {
-						await clearCacheForPattern(rule.pattern);
+						await clearCacheForPattern(rule.pattern)
 					}
 
 					// Add redirect rule using declarativeNetRequest
@@ -336,9 +336,9 @@ async function updateRequestListener() {
 							regexFilter: rule.pattern,
 							resourceTypes: ruleType === "js" ? ["script"] : ["stylesheet"],
 						},
-					};
+					}
 
-					rulesToAdd.push(redirectRule);
+					rulesToAdd.push(redirectRule)
 				}
 			}
 		}
@@ -346,7 +346,7 @@ async function updateRequestListener() {
 		// Add legacy rule for backward compatibility
 		if (config.urlPattern && config.redirectUrl && rulesToAdd.length === 0) {
 			if (config.clearCacheOnEnable) {
-				await clearCacheForPattern(config.urlPattern);
+				await clearCacheForPattern(config.urlPattern)
 			}
 
 			const legacyRule = {
@@ -362,30 +362,30 @@ async function updateRequestListener() {
 					regexFilter: config.urlPattern,
 					resourceTypes: ["script"],
 				},
-			};
+			}
 
-			rulesToAdd.push(legacyRule);
+			rulesToAdd.push(legacyRule)
 		}
 
 		if (rulesToAdd.length > 0) {
 			try {
 				await chrome.declarativeNetRequest.updateDynamicRules({
 					addRules: rulesToAdd,
-				});
-				console.log("[JavaScript Proxy] Added redirect rules:", rulesToAdd);
+				})
+				console.log("[JavaScript Proxy] Added redirect rules:", rulesToAdd)
 			} catch (error) {
-				console.error("[JavaScript Proxy] Error adding redirect rules:", error);
+				console.error("[JavaScript Proxy] Error adding redirect rules:", error)
 			}
 		}
 	}
 
 	// For masking mode or blank returns, we need webRequest API
-	updateWebRequestListener();
+	updateWebRequestListener()
 }
 
 // Handle web requests for masking mode and blank returns (fallback to webRequest for complex logic)
 function handleRequest(details) {
-	if (!config.enabled) return {};
+	if (!config.enabled) return {}
 
 	// Skip data URLs and blob URLs
 	if (
@@ -394,61 +394,61 @@ function handleRequest(details) {
 		details.url.startsWith("chrome:") ||
 		details.url.startsWith("chrome-extension:")
 	) {
-		return {};
+		return {}
 	}
 
 	try {
 		// Check each rule type
 		for (const [ruleType, rule] of Object.entries(config.rules || {})) {
-			if (!rule.enabled || !rule.pattern) continue;
+			if (!rule.enabled || !rule.pattern) continue
 
 			// Check if this rule type matches the resource type
-			if (ruleType === "js" && details.type !== "script") continue;
-			if (ruleType === "css" && details.type !== "stylesheet") continue;
+			if (ruleType === "js" && details.type !== "script") continue
+			if (ruleType === "css" && details.type !== "stylesheet") continue
 
-			const regex = new RegExp(rule.pattern, "i");
+			const regex = new RegExp(rule.pattern, "i")
 
 			// Test the full URL against the pattern
 			if (regex.test(details.url)) {
 				// Handle blank return for CSS
 				if (rule.returnBlank) {
 					console.log(
-						`[JavaScript Proxy] Returning blank for ${ruleType}: ${details.url}`
-					);
+						`[JavaScript Proxy] Returning blank for ${ruleType}: ${details.url}`,
+					)
 					// Return a data URL with empty content
 					const blankUrl =
 						ruleType === "css"
 							? "data:text/css;charset=utf-8,"
-							: "data:text/javascript;charset=utf-8,";
-					return { redirectUrl: blankUrl };
+							: "data:text/javascript;charset=utf-8,"
+					return { redirectUrl: blankUrl }
 				}
 
 				// Handle masking mode or rules without declarativeNetRequest redirect
 				if (config.maskingMode || !rule.redirectUrl) {
 					if (rule.redirectUrl) {
-						let newUrl = rule.redirectUrl;
+						let newUrl = rule.redirectUrl
 
 						// Ensure URL has protocol
 						if (!newUrl.includes("://")) {
-							newUrl = "https://" + newUrl;
+							newUrl = "https://" + newUrl
 						}
 
 						// Check if this would create a redirect loop
 						if (details.url === newUrl || details.url.includes("localhost")) {
 							console.log(
-								`[JavaScript Proxy] Skipping redirect loop: ${details.url}`
-							);
-							return {};
+								`[JavaScript Proxy] Skipping redirect loop: ${details.url}`,
+							)
+							return {}
 						}
 
 						// Store original URL for header modification
-						storeOriginalUrl(details.requestId, details.url, newUrl);
+						storeOriginalUrl(details.requestId, details.url, newUrl)
 
 						console.log(
-							`[JavaScript Proxy] Masking ${ruleType}: ${details.url} (routing to ${newUrl})`
-						);
+							`[JavaScript Proxy] Masking ${ruleType}: ${details.url} (routing to ${newUrl})`,
+						)
 
-						return { redirectUrl: newUrl };
+						return { redirectUrl: newUrl }
 					}
 				}
 			}
@@ -456,52 +456,52 @@ function handleRequest(details) {
 
 		// Fallback to legacy pattern for backward compatibility
 		if (config.maskingMode && config.urlPattern) {
-			const regex = new RegExp(config.urlPattern, "i");
+			const regex = new RegExp(config.urlPattern, "i")
 
 			if (regex.test(details.url) && details.type === "script") {
-				let newUrl = config.redirectUrl;
+				let newUrl = config.redirectUrl
 
 				if (!newUrl.includes("://")) {
-					newUrl = "https://" + newUrl;
+					newUrl = "https://" + newUrl
 				}
 
 				if (details.url === newUrl || details.url.includes("localhost")) {
 					console.log(
-						`[JavaScript Proxy] Skipping redirect loop: ${details.url}`
-					);
-					return {};
+						`[JavaScript Proxy] Skipping redirect loop: ${details.url}`,
+					)
+					return {}
 				}
 
-				storeOriginalUrl(details.requestId, details.url, newUrl);
+				storeOriginalUrl(details.requestId, details.url, newUrl)
 
 				console.log(
-					`[JavaScript Proxy] Legacy masking: ${details.url} (routing to ${newUrl})`
-				);
+					`[JavaScript Proxy] Legacy masking: ${details.url} (routing to ${newUrl})`,
+				)
 
-				return { redirectUrl: newUrl };
+				return { redirectUrl: newUrl }
 			}
 		}
 	} catch (error) {
-		console.error("[JavaScript Proxy] Error processing request:", error);
+		console.error("[JavaScript Proxy] Error processing request:", error)
 	}
 
-	return {};
+	return {}
 }
 
 // Store mapping of request IDs to proxy info for header modification
-const pendingProxyRequests = new Map();
+const pendingProxyRequests = new Map()
 
 function storeOriginalUrl(requestId, originalUrl, redirectUrl) {
 	pendingProxyRequests.set(requestId, {
 		originalUrl,
 		redirectUrl,
 		timestamp: Date.now(),
-	});
+	})
 
 	// Clean up old entries after 30 seconds
 	setTimeout(() => {
-		pendingProxyRequests.delete(requestId);
-	}, 30000);
+		pendingProxyRequests.delete(requestId)
+	}, 30000)
 }
 
 // Update webRequest listener for masking mode
@@ -511,19 +511,19 @@ function updateWebRequestListener() {
 		chrome.webRequest &&
 		chrome.webRequest.onBeforeRequest.hasListener(handleRequest)
 	) {
-		chrome.webRequest.onBeforeRequest.removeListener(handleRequest);
+		chrome.webRequest.onBeforeRequest.removeListener(handleRequest)
 	}
 	if (
 		chrome.webRequest &&
 		chrome.webRequest.onBeforeSendHeaders.hasListener(handleRequestHeaders)
 	) {
-		chrome.webRequest.onBeforeSendHeaders.removeListener(handleRequestHeaders);
+		chrome.webRequest.onBeforeSendHeaders.removeListener(handleRequestHeaders)
 	}
 	if (
 		chrome.webRequest &&
 		chrome.webRequest.onHeadersReceived.hasListener(handleResponseHeaders)
 	) {
-		chrome.webRequest.onHeadersReceived.removeListener(handleResponseHeaders);
+		chrome.webRequest.onHeadersReceived.removeListener(handleResponseHeaders)
 	}
 
 	// Check if we need webRequest for any features
@@ -531,60 +531,60 @@ function updateWebRequestListener() {
 		config.maskingMode ||
 		config.disableCacheForRedirects ||
 		Object.values(config.rules || {}).some(
-			(rule) => rule.enabled && rule.returnBlank
-		);
+			(rule) => rule.enabled && rule.returnBlank,
+		)
 
 	// Add webRequest listeners for masking mode, cache control, or blank returns
 	if (config.enabled && chrome.webRequest && needsWebRequest) {
 		chrome.webRequest.onBeforeRequest.addListener(
 			handleRequest,
 			{ urls: ["<all_urls>"] },
-			["blocking"]
-		);
+			["blocking"],
+		)
 
 		chrome.webRequest.onBeforeSendHeaders.addListener(
 			handleRequestHeaders,
 			{ urls: ["<all_urls>"] },
-			["blocking", "requestHeaders"]
-		);
+			["blocking", "requestHeaders"],
+		)
 
 		chrome.webRequest.onHeadersReceived.addListener(
 			handleResponseHeaders,
 			{ urls: ["<all_urls>"] },
-			["blocking", "responseHeaders"]
-		);
+			["blocking", "responseHeaders"],
+		)
 
 		console.log(
-			"[JavaScript Proxy] WebRequest listeners enabled for masking mode"
-		);
+			"[JavaScript Proxy] WebRequest listeners enabled for masking mode",
+		)
 	} else {
-		console.log("[JavaScript Proxy] WebRequest listeners disabled");
+		console.log("[JavaScript Proxy] WebRequest listeners disabled")
 	}
 }
 
 // Handle request headers for masking mode and cache control
 function handleRequestHeaders(details) {
-	if (!config.enabled) return {};
+	if (!config.enabled) return {}
 
 	// Initialize modifications
-	const modifications = { requestHeaders: details.requestHeaders };
-	let hasModifications = false;
+	const modifications = { requestHeaders: details.requestHeaders }
+	let hasModifications = false
 
 	// Handle masking mode
 	if (config.maskingMode) {
-		const proxyInfo = pendingProxyRequests.get(details.requestId);
+		const proxyInfo = pendingProxyRequests.get(details.requestId)
 		if (proxyInfo) {
 			// Add/modify headers to properly route to localhost
 			const hostHeader = modifications.requestHeaders.find(
-				(h) => h.name.toLowerCase() === "host"
-			);
+				(h) => h.name.toLowerCase() === "host",
+			)
 			if (hostHeader) {
 				try {
-					const proxyUrl = new URL(proxyInfo.redirectUrl);
-					hostHeader.value = proxyUrl.host;
-					hasModifications = true;
+					const proxyUrl = new URL(proxyInfo.redirectUrl)
+					hostHeader.value = proxyUrl.host
+					hasModifications = true
 				} catch (error) {
-					console.error("[JavaScript Proxy] Error parsing proxy URL:", error);
+					console.error("[JavaScript Proxy] Error parsing proxy URL:", error)
 				}
 			}
 		}
@@ -602,39 +602,39 @@ function handleRequestHeaders(details) {
 			{ name: "Expires", value: "0" },
 			{ name: "If-None-Match", value: "*" },
 			{ name: "If-Modified-Since", value: "Thu, 01 Jan 1970 00:00:00 GMT" },
-		];
+		]
 
 		cacheHeaders.forEach((cacheHeader) => {
 			const existingHeader = modifications.requestHeaders.find(
-				(h) => h.name.toLowerCase() === cacheHeader.name.toLowerCase()
-			);
+				(h) => h.name.toLowerCase() === cacheHeader.name.toLowerCase(),
+			)
 			if (existingHeader) {
-				existingHeader.value = cacheHeader.value;
+				existingHeader.value = cacheHeader.value
 			} else {
-				modifications.requestHeaders.push(cacheHeader);
+				modifications.requestHeaders.push(cacheHeader)
 			}
-			hasModifications = true;
-		});
+			hasModifications = true
+		})
 
 		console.log(
-			`[JavaScript Proxy] Added cache-busting headers for: ${details.url}`
-		);
+			`[JavaScript Proxy] Added cache-busting headers for: ${details.url}`,
+		)
 	}
 
-	return hasModifications ? modifications : {};
+	return hasModifications ? modifications : {}
 }
 
 // Handle response headers for masking mode and cache control
 function handleResponseHeaders(details) {
-	if (!config.enabled) return {};
+	if (!config.enabled) return {}
 
 	// Initialize modifications
-	const modifications = { responseHeaders: details.responseHeaders };
-	let hasModifications = false;
+	const modifications = { responseHeaders: details.responseHeaders }
+	let hasModifications = false
 
 	// Handle masking mode
 	if (config.maskingMode) {
-		const proxyInfo = pendingProxyRequests.get(details.requestId);
+		const proxyInfo = pendingProxyRequests.get(details.requestId)
 		if (proxyInfo) {
 			// Add CORS headers if needed
 			const corsHeaders = [
@@ -647,19 +647,19 @@ function handleResponseHeaders(details) {
 					name: "Access-Control-Allow-Headers",
 					value: "Content-Type, Authorization",
 				},
-			];
+			]
 
 			corsHeaders.forEach((corsHeader) => {
 				const existingHeader = modifications.responseHeaders.find(
-					(h) => h.name.toLowerCase() === corsHeader.name.toLowerCase()
-				);
+					(h) => h.name.toLowerCase() === corsHeader.name.toLowerCase(),
+				)
 				if (existingHeader) {
-					existingHeader.value = corsHeader.value;
+					existingHeader.value = corsHeader.value
 				} else {
-					modifications.responseHeaders.push(corsHeader);
+					modifications.responseHeaders.push(corsHeader)
 				}
-				hasModifications = true;
-			});
+				hasModifications = true
+			})
 		}
 	}
 
@@ -677,197 +677,204 @@ function handleResponseHeaders(details) {
 			{ name: "ETag", value: `"${Date.now()}-${Math.random()}"` },
 			{ name: "Vary", value: "*" },
 			{ name: "X-Cache-Control", value: "no-cache" },
-		];
+		]
 
 		cacheHeaders.forEach((cacheHeader) => {
 			const existingHeader = modifications.responseHeaders.find(
-				(h) => h.name.toLowerCase() === cacheHeader.name.toLowerCase()
-			);
+				(h) => h.name.toLowerCase() === cacheHeader.name.toLowerCase(),
+			)
 			if (existingHeader) {
-				existingHeader.value = cacheHeader.value;
+				existingHeader.value = cacheHeader.value
 			} else {
-				modifications.responseHeaders.push(cacheHeader);
+				modifications.responseHeaders.push(cacheHeader)
 			}
-			hasModifications = true;
-		});
+			hasModifications = true
+		})
 
 		console.log(
-			`[JavaScript Proxy] Added response cache-busting headers for: ${details.url}`
-		);
+			`[JavaScript Proxy] Added response cache-busting headers for: ${details.url}`,
+		)
 	}
 
 	if (hasModifications) {
 		console.log(
-			`[JavaScript Proxy] Modified response headers for: ${details.url}`
-		);
+			`[JavaScript Proxy] Modified response headers for: ${details.url}`,
+		)
 	}
 
-	return hasModifications ? modifications : {};
+	return hasModifications ? modifications : {}
 }
 
 // Show desktop notification for proxy activity (when using masking mode)
 function showProxyNotification(from, to, requestType = "") {
-	const shortFrom = from.length > 50 ? from.substring(0, 47) + "..." : from;
-	const shortTo = to.length > 30 ? to.substring(0, 27) + "..." : to;
+	const shortFrom = from.length > 50 ? from.substring(0, 47) + "..." : from
+	const shortTo = to.length > 30 ? to.substring(0, 27) + "..." : to
 
-	const notificationId = `proxy-${Date.now()}`;
+	const notificationId = `proxy-${Date.now()}`
 
 	chrome.notifications.create(notificationId, {
 		type: "basic",
 		iconUrl: "icons/gx_on_64.png",
 		title: "JavaScript Proxy Active",
 		message: `${requestType}\n${shortFrom}\n→ ${shortTo}`,
-	});
+	})
 
 	// Clear existing timeout for this type
 	if (notificationTimeouts.has("proxy")) {
-		clearTimeout(notificationTimeouts.get("proxy"));
+		clearTimeout(notificationTimeouts.get("proxy"))
 	}
 
 	// Auto-dismiss after 3 seconds
 	const timeoutId = setTimeout(() => {
-		chrome.notifications.clear(notificationId);
-		notificationTimeouts.delete("proxy");
-	}, 3000);
+		chrome.notifications.clear(notificationId)
+		notificationTimeouts.delete("proxy")
+	}, 3000)
 
-	notificationTimeouts.set("proxy", timeoutId);
+	notificationTimeouts.set("proxy", timeoutId)
 }
 
 // ============================================================
 // DevTools Panel Communication
 // ============================================================
 
-const devtoolsConnections = new Map();
+const devtoolsConnections = new Map()
 
 chrome.runtime.onConnect.addListener((port) => {
-	if (port.name === 'gxp-devtools-panel') {
+	if (port.name === "gxp-devtools-panel") {
 		const extensionListener = (message, port) => {
-			if (message.name === 'init') {
-				devtoolsConnections.set(message.tabId, port);
-				console.log('[GxP DevTools] Panel connected for tab:', message.tabId);
+			if (message.name === "init") {
+				devtoolsConnections.set(message.tabId, port)
+				console.log("[GxP DevTools] Panel connected for tab:", message.tabId)
 			}
 
 			// Forward messages to content script
 			if (message.tabId && message.action) {
 				chrome.tabs.sendMessage(message.tabId, message, (response) => {
-					port.postMessage(response);
-				});
+					port.postMessage(response)
+				})
 			}
-		};
+		}
 
-		port.onMessage.addListener(extensionListener);
+		port.onMessage.addListener(extensionListener)
 
 		port.onDisconnect.addListener(() => {
 			// Remove the connection when panel is closed
 			for (const [tabId, connectedPort] of devtoolsConnections.entries()) {
 				if (connectedPort === port) {
-					devtoolsConnections.delete(tabId);
-					console.log('[GxP DevTools] Panel disconnected for tab:', tabId);
-					break;
+					devtoolsConnections.delete(tabId)
+					console.log("[GxP DevTools] Panel disconnected for tab:", tabId)
+					break
 				}
 			}
-		});
+		})
 	}
-});
+})
 
 // Forward messages from content script to DevTools panel
 function forwardToDevTools(tabId, message) {
-	const port = devtoolsConnections.get(tabId);
+	const port = devtoolsConnections.get(tabId)
 	if (port) {
 		try {
-			port.postMessage(message);
+			port.postMessage(message)
 		} catch (error) {
-			console.error('[GxP DevTools] Error forwarding to panel:', error);
+			console.error("[GxP DevTools] Error forwarding to panel:", error)
 		}
 	}
 }
 
 // Handle messages from popup
 chrome.runtime.onMessage.addListener((request, sender, sendResponse) => {
-	console.log("[JavaScript Proxy] Received message:", request);
+	console.log("[JavaScript Proxy] Received message:", request)
 
 	// Handle messages from content script about element selection
-	if (request.type === 'elementSelected' && sender.tab) {
-		forwardToDevTools(sender.tab.id, request);
-		return;
+	if (request.type === "elementSelected" && sender.tab) {
+		forwardToDevTools(sender.tab.id, request)
+		return
 	}
 
 	switch (request.action) {
 		case "toggleProxy":
-			config.enabled = request.enabled;
-			chrome.storage.sync.set({ enabled: config.enabled });
-			updateIcon();
-			updateRequestListener();
+			config.enabled = request.enabled
+			chrome.storage.sync.set({ enabled: config.enabled })
+			updateIcon()
+			updateRequestListener()
 			// Clear cache when enabling the proxy
 			if (config.enabled && config.clearCacheOnEnable) {
-				clearCacheForPattern(config.urlPattern);
+				clearCacheForPattern(config.urlPattern)
 			}
-			sendResponse({ success: true, enabled: config.enabled });
-			return false; // Synchronous response
+			sendResponse({ success: true, enabled: config.enabled })
+			return false // Synchronous response
 
 		case "updateConfig":
-			config = { ...config, ...request.config };
-			chrome.storage.sync.set(config);
-			updateIcon();
-			updateRequestListener();
-			sendResponse({ success: true });
-			return false; // Synchronous response
+			config = { ...config, ...request.config }
+			chrome.storage.sync.set(config)
+			updateIcon()
+			updateRequestListener()
+			sendResponse({ success: true })
+			return false // Synchronous response
 
 		case "getConfig":
-			sendResponse(config);
-			return false; // Synchronous response
+			sendResponse(config)
+			return false // Synchronous response
 
 		case "clearCache":
 			console.log(
 				"[JavaScript Proxy] Starting cache clear for pattern:",
-				config.urlPattern
-			);
+				config.urlPattern,
+			)
 			clearCacheForPattern(config.urlPattern)
 				.then(() => {
-					console.log("[JavaScript Proxy] Cache clear completed successfully");
-					sendResponse({ success: true });
+					console.log("[JavaScript Proxy] Cache clear completed successfully")
+					sendResponse({ success: true })
 				})
 				.catch((error) => {
-					console.error("[JavaScript Proxy] Cache clear error:", error);
+					console.error("[JavaScript Proxy] Cache clear error:", error)
 					sendResponse({
 						success: false,
 						error: error.message || error.toString(),
-					});
-				});
-			return true; // Keep message channel open for async response
+					})
+				})
+			return true // Keep message channel open for async response
 
 		case "openDevTools":
 			// Open DevTools for the specified tab
 			// Note: Chrome doesn't have a direct API to open DevTools to a specific panel
 			// We inject a script that triggers the inspector and prompt user to open DevTools
 			if (request.tabId) {
-				chrome.scripting.executeScript({
-					target: { tabId: request.tabId },
-					func: () => {
-						// Log a message suggesting to open DevTools
-						console.log('%c[GxP Inspector] Inspector enabled! Press F12 or Ctrl+Shift+J to open DevTools and see the GxP Inspector panel.', 'color: #667eea; font-weight: bold; font-size: 14px;');
-					}
-				}).catch(err => console.log('[GxP DevTools] Could not inject script:', err));
+				chrome.scripting
+					.executeScript({
+						target: { tabId: request.tabId },
+						func: () => {
+							// Log a message suggesting to open DevTools
+							console.log(
+								"%c[GxP Inspector] Inspector enabled! Press F12 or Ctrl+Shift+J to open DevTools and see the GxP Inspector panel.",
+								"color: #667eea; font-weight: bold; font-size: 14px;",
+							)
+						},
+					})
+					.catch((err) =>
+						console.log("[GxP DevTools] Could not inject script:", err),
+					)
 			}
-			sendResponse({ success: true });
-			return false;
+			sendResponse({ success: true })
+			return false
 
 		default:
-			console.warn("[JavaScript Proxy] Unknown action:", request.action);
-			sendResponse({ success: false, error: "Unknown action" });
-			return false; // Synchronous response
+			console.warn("[JavaScript Proxy] Unknown action:", request.action)
+			sendResponse({ success: false, error: "Unknown action" })
+			return false // Synchronous response
 	}
-});
+})
 
 // Clear expired proxy requests periodically
 setInterval(() => {
-	const now = Date.now();
+	const now = Date.now()
 	for (const [requestId, info] of pendingProxyRequests.entries()) {
 		if (now - info.timestamp > 30000) {
-			pendingProxyRequests.delete(requestId);
+			pendingProxyRequests.delete(requestId)
 		}
 	}
-}, 10000);
+}, 10000)
 
 // Initialize on startup
-initializeExtension();
+initializeExtension()