Merge pull request #22 from tomaszk8266/master

Add macOS signing

index.js

@@ -1,6 +1,6 @@
 // @ts-check
 import { spawn, execSync } from "child_process";
-import asar from "@electron/asar";
+import * as asar from "@electron/asar";
 import chalk from "chalk";
 import path from "path";
 import fs from "fs";
@@ -73,7 +73,7 @@ function fetchJson(url) {
 		const options = {
 			headers: {
 				"User-Agent": "httptoolkit-patcher",
-				"Accept": "application/vnd.github.v3+json",
+				Accept: "application/vnd.github.v3+json",
 			},
 		};
 		https
@@ -126,10 +126,10 @@ async function checkForUpdates() {
 		const latestVersion = latestTag.replace(/^v/, "");
 
 		if (compareVersions(latestVersion, LOCAL_VERSION) > 0) {
-			console.log(chalk.yellowBright`\n╔════════════════════════════════════════════════════════════╗`);
-			console.log(chalk.yellowBright`║` + chalk.white`  A new version is available: ` + chalk.greenBright`v${latestVersion}` + chalk.white` (current: ` + chalk.gray`v${LOCAL_VERSION}` + chalk.white`)  ` + chalk.yellowBright`    ║`);
-			console.log(chalk.yellowBright`║` + chalk.white`  Update: ` + chalk.cyanBright`https://github.com/${GITHUB_REPO}` + chalk.white`  ` + chalk.yellowBright`║`);
-			console.log(chalk.yellowBright`╚════════════════════════════════════════════════════════════╝\n`);
+			console.log(chalk.yellowBright('\n╔════════════════════════════════════════════════════════════╗'));
+			console.log(chalk.yellowBright('║') + chalk.white('   A new version is available: ') + chalk.greenBright(`v${latestVersion}`) + chalk.white(' (current: ') + chalk.gray(`v${LOCAL_VERSION}`) + chalk.white(')  ') + chalk.yellowBright('  ║'));
+			console.log(chalk.yellowBright('║') + chalk.white('  Update: ') + chalk.cyanBright(`https://github.com/${GITHUB_REPO}`) + chalk.white('  ') + chalk.yellowBright('║'));
+			console.log(chalk.yellowBright('╚════════════════════════════════════════════════════════════╝\n'));
 		}
 	} catch (e) {
 		// Silently ignore update check errors (network issues, etc.)
@@ -150,7 +150,11 @@ function rm(dirPath) {
 
 // Find HTTP Toolkit installation path
 async function findAppPath() {
-	const possiblePaths = isWin ? [path.join("C:", "Program Files", "HTTP Toolkit", "resources"), path.join("C:", "Program Files (x86)", "HTTP Toolkit", "resources"), path.join(process.env.LOCALAPPDATA || path.join(process.env.USERPROFILE || "", "AppData", "Local"), "Programs", "HTTP Toolkit", "resources")] : isMac ? ["/Applications/HTTP Toolkit.app/Contents/Resources"] : ["/opt/HTTP Toolkit/resources", "/opt/httptoolkit/resources"];
+	const possiblePaths = isWin
+		? [path.join("C:", "Program Files", "HTTP Toolkit", "resources"), path.join("C:", "Program Files (x86)", "HTTP Toolkit", "resources"), path.join(process.env.LOCALAPPDATA || path.join(process.env.USERPROFILE || "", "AppData", "Local"), "Programs", "HTTP Toolkit", "resources")]
+		: isMac
+		? ["/Applications/HTTP Toolkit.app/Contents/Resources"]
+		: ["/opt/HTTP Toolkit/resources", "/opt/httptoolkit/resources"];
 
 	for (const p of possiblePaths) {
 		if (fs.existsSync(path.join(p, "app.asar"))) {
@@ -158,11 +162,11 @@ async function findAppPath() {
 		}
 	}
 
-	console.log(chalk.yellowBright`[!] HTTP Toolkit not found in default locations`);
+	console.log(chalk.yellowBright('[!] HTTP Toolkit not found in default locations'));
 	const userPath = await prompt("Please enter the path to HTTP Toolkit executable/app: ");
 
 	if (!userPath) {
-		console.error(chalk.redBright`[-] No path provided`);
+		console.error(chalk.redBright('[-] No path provided'));
 		process.exit(1);
 	}
 
@@ -173,7 +177,7 @@ async function findAppPath() {
 	if (!resourcesPath.endsWith("resources")) resourcesPath = path.join(resourcesPath, "resources");
 
 	if (!fs.existsSync(path.join(resourcesPath, "app.asar"))) {
-		console.error(chalk.redBright`[-] app.asar not found at ${resourcesPath}`);
+		console.error(chalk.redBright(`[-] app.asar not found at ${resourcesPath}`));
 		process.exit(1);
 	}
 
@@ -182,7 +186,7 @@ async function findAppPath() {
 
 // Request elevated permissions
 async function requestElevation() {
-	console.log(chalk.yellowBright`[!] Requesting elevated permissions...`);
+	console.log(chalk.yellowBright('[!] Requesting elevated permissions...'));
 
 	// @ts-ignore - pkg adds this property at runtime
 	const isBundled = process.pkg;
@@ -197,28 +201,28 @@ async function requestElevation() {
 		}
 
 		try {
-			console.log(chalk.greenBright`[+] Spawning PowerShell with script: ${script}`);
+			console.log(chalk.greenBright(`[+] Spawning PowerShell with script: ${script}`));
 			execSync(`powershell -Command "${script}"`, { stdio: "inherit" });
-			console.log(chalk.blueBright`[+] Restarting with administrator privileges...`);
+			console.log(chalk.blueBright('[+] Restarting with administrator privileges...'));
 			process.exit(0);
 		} catch (e) {
-			console.error(chalk.redBright`[-] Failed to elevate permissions: ${e.message}`);
-			console.error(chalk.redBright`[-] Please run as administrator manually`);
+			console.error(chalk.redBright(`[-] Failed to elevate permissions: ${e.message}`));
+			console.error(chalk.redBright('[-] Please run as administrator manually'));
 			process.exit(1);
 		}
 	} else if (isLinux) {
 		// Linux: Cannot auto-elevate with sudo, show instructions instead
-		console.log(chalk.yellowBright`[!] Elevated permissions are required for patching on Linux`);
-		console.log(chalk.yellowBright`[!] Please re-run this script with sudo:`);
+		console.log(chalk.yellowBright('[!] Elevated permissions are required for patching on Linux'));
+		console.log(chalk.yellowBright('[!] Please re-run this script with sudo:'));
 		if (isBundled) {
-			console.log(chalk.blueBright`    sudo ${__filename}`);
+			console.log(chalk.blueBright(`    sudo ${__filename}`));
 		} else {
-			console.log(chalk.blueBright`    sudo node ${__filename}`);
+			console.log(chalk.blueBright(`    sudo node ${__filename}`));
 		}
 		process.exit(1);
 	} else {
 		// macOS: Try to elevate with sudo
-		console.log(chalk.blueBright`[+] Restarting with sudo...`);
+		console.log(chalk.blueBright('[+] Restarting with sudo...'));
 		try {
 			let child;
 			if (isBundled) {
@@ -232,8 +236,8 @@ async function requestElevation() {
 			}
 			child.on("exit", code => process.exit(code || 0));
 		} catch (e) {
-			console.error(chalk.redBright`[-] Failed to elevate permissions: ${e.message}`);
-			console.error(chalk.redBright`[-] Please run with sudo manually`);
+			console.error(chalk.redBright(`[-] Failed to elevate permissions: ${e.message}`));
+			console.error(chalk.redBright('[-] Please run with sudo manually'));
 			process.exit(1);
 		}
 	}
@@ -251,76 +255,207 @@ function checkPermissions(filePath) {
 			fs.mkdirSync(testDirPath, { recursive: true });
 			fs.rmdirSync(testDirPath);
 		} catch (dirError) {
-			console.error(chalk.redBright`[-] Cannot create directories in ${path.dirname(filePath)}: ${dirError.message}`);
+			console.error(chalk.redBright(`[-] Cannot create directories in ${path.dirname(filePath)}: ${dirError.message}`));
 			return false;
 		}
 
-		console.log(chalk.greenBright`[+] Permissions check passed for ${filePath}`);
+		console.log(chalk.greenBright(`[+] Permissions check passed for ${filePath}`));
 		return true;
 	} catch (e) {
-		console.error(chalk.redBright`[-] Permissions check failed for ${filePath}: ${e.message}`);
+		console.error(chalk.redBright(`[-] Permissions check failed for ${filePath}: ${e.message}`));
 		return false;
 	}
 }
 
 // Kill HTTP Toolkit processes
 async function killHttpToolkit() {
-	console.log(chalk.yellowBright`[+] Checking for running HTTP Toolkit processes...`);
+	console.log(chalk.yellowBright('[+] Checking for running HTTP Toolkit processes...'));
 
 	try {
 		if (isWin) {
 			// Windows: Use tasklist to find and taskkill to terminate
 			const output = execSync('tasklist /FI "IMAGENAME eq HTTP Toolkit.exe" /FO CSV /NH', { encoding: "utf-8" });
 			if (output.includes("HTTP Toolkit.exe")) {
-				console.log(chalk.yellowBright`[!] HTTP Toolkit is running, attempting to close it...`);
+				console.log(chalk.yellowBright('[!] HTTP Toolkit is running, attempting to close it...'));
 				execSync('taskkill /F /IM "HTTP Toolkit.exe" /T', { stdio: "ignore" });
-				console.log(chalk.greenBright`[+] HTTP Toolkit processes terminated`);
+				console.log(chalk.greenBright('[+] HTTP Toolkit processes terminated'));
 				// Wait a moment for the process to fully close
 				await new Promise(resolve => setTimeout(resolve, 2000));
 			} else {
-				console.log(chalk.greenBright`[+] HTTP Toolkit is not running`);
+				console.log(chalk.greenBright('[+] HTTP Toolkit is not running'));
 			}
 		} else if (isMac) {
 			// macOS: Use pgrep and pkill
 			try {
 				execSync('pgrep -f "HTTP Toolkit"', { stdio: "ignore" });
-				console.log(chalk.yellowBright`[!] HTTP Toolkit is running, attempting to close it...`);
+				console.log(chalk.yellowBright('[!] HTTP Toolkit is running, attempting to close it...'));
 				execSync('pkill -f "HTTP Toolkit"', { stdio: "ignore" });
-				console.log(chalk.greenBright`[+] HTTP Toolkit processes terminated`);
+				console.log(chalk.greenBright('[+] HTTP Toolkit processes terminated'));
 				await new Promise(resolve => setTimeout(resolve, 2000));
 			} catch (e) {
-				console.log(chalk.greenBright`[+] HTTP Toolkit is not running`);
+				console.log(chalk.greenBright('[+] HTTP Toolkit is not running'));
 			}
 		} else {
 			// Linux: Use pgrep and pkill
 			try {
 				execSync('pgrep -f "HTTP Toolkit"', { stdio: "ignore" });
-				console.log(chalk.yellowBright`[!] HTTP Toolkit is running, attempting to close it...`);
+				console.log(chalk.yellowBright('[!] HTTP Toolkit is running, attempting to close it...'));
 				execSync('pkill -f "HTTP Toolkit"', { stdio: "ignore" });
-				console.log(chalk.greenBright`[+] HTTP Toolkit processes terminated`);
+				console.log(chalk.greenBright('[+] HTTP Toolkit processes terminated'));
 				await new Promise(resolve => setTimeout(resolve, 2000));
 			} catch (e) {
-				console.log(chalk.greenBright`[+] HTTP Toolkit is not running`);
+				console.log(chalk.greenBright('[+] HTTP Toolkit is not running'));
 			}
 		}
 	} catch (e) {
-		console.log(chalk.yellowBright`[!] Could not check/kill processes: ${e.message}`);
-		console.log(chalk.yellowBright`[!] If HTTP Toolkit is running, please close it manually`);
+		console.log(chalk.yellowBright(`[!] Could not check/kill processes: ${e.message}`));
+		console.log(chalk.yellowBright('[!] If HTTP Toolkit is running, please close it manually'));
 	}
 }
 
+// Resolve the base installation directory (without the trailing resources folder)
+function getBinaryBasePath(resourcesPath) {
+	const normalized = resourcesPath.replace(/[\\/]+$/, "");
+	if (normalized.toLowerCase().endsWith("resources")) {
+		return path.dirname(normalized);
+	}
+	return normalized;
+}
+
+// Determine the executable path for HTTP Toolkit based on platform
+function getExecutablePath(resourcesPath) {
+	const basePath = getBinaryBasePath(resourcesPath);
+	const candidates = isWin ? [path.join(basePath, "HTTP Toolkit.exe"), path.join(basePath, "httptoolkit.exe")] : isMac ? [path.join(basePath, "MacOS", "HTTP Toolkit"), path.join(basePath, "MacOS", "HTTP Toolkit Preview")] : [path.join(basePath, "httptoolkit"), path.join(basePath, "HTTP Toolkit")];
+
+	for (const candidate of candidates) {
+		if (fs.existsSync(candidate)) {
+			return candidate;
+		}
+	}
+
+	throw new Error(`Could not locate HTTP Toolkit executable near ${resourcesPath}`);
+}
+
+// Extract hashes from integrity check output
+function extractIntegrityHashes(output) {
+	const regex = /Integrity check failed for asar archive[\s\S]*?\(\s*([0-9a-f]{64})\s*vs\s*([0-9a-f]{64})\s*\)/i;
+	const match = output.match(regex);
+	if (!match) return null;
+	return {
+		originalHash: match[1],
+		newHash: match[2],
+	};
+}
+
+// Launch the app once to grab integrity hashes from its crash output
+async function captureIntegrityHashes(executablePath) {
+	return new Promise((resolve, reject) => {
+		let output = "";
+		let finished = false;
+		const child = spawn(executablePath, {
+			cwd: path.dirname(executablePath),
+			stdio: ["ignore", "pipe", "pipe"],
+			windowsHide: true,
+		});
+
+		const timeout = setTimeout(() => {
+			if (!finished) {
+				finished = true;
+				child.kill();
+				reject(new Error("Timed out waiting for integrity check output"));
+			}
+		}, 30000);
+
+		const handleData = data => {
+			output += data.toString();
+			const hashes = extractIntegrityHashes(output);
+			if (hashes && !finished) {
+				finished = true;
+				clearTimeout(timeout);
+				child.kill();
+				resolve(hashes);
+			}
+		};
+
+		child.stdout.on("data", handleData);
+		child.stderr.on("data", handleData);
+
+		child.on("error", err => {
+			if (!finished) {
+				finished = true;
+				clearTimeout(timeout);
+				reject(err);
+			}
+		});
+
+		child.on("exit", () => {
+			if (!finished) {
+				clearTimeout(timeout);
+				const hashes = extractIntegrityHashes(output);
+				if (hashes) {
+					resolve(hashes);
+				} else {
+					reject(new Error("Could not find integrity hashes in HTTP Toolkit output"));
+				}
+			}
+		});
+	});
+}
+
+// Replace all occurrences of the original hash with the new hash inside the binary
+function patchExecutableHash(executablePath, originalHash, newHash) {
+	if (originalHash.length !== newHash.length) {
+		throw new Error("Hash lengths do not match; cannot safely patch binary");
+	}
+
+	const binary = fs.readFileSync(executablePath);
+	const originalBuf = Buffer.from(originalHash, "utf-8");
+	const newBuf = Buffer.from(newHash, "utf-8");
+
+	let occurrences = 0;
+	let idx = binary.indexOf(originalBuf);
+	while (idx !== -1) {
+		newBuf.copy(binary, idx);
+		occurrences += 1;
+		idx = binary.indexOf(originalBuf, idx + originalBuf.length);
+	}
+
+	if (occurrences === 0) {
+		throw new Error("Original hash not found in binary");
+	}
+
+	fs.writeFileSync(executablePath, binary);
+	return occurrences;
+}
+
+// Replace the asar integrity hash inside the macOS Info.plist
+function patchInfoPlistHash(resourcesPath, originalHash, newHash) {
+	const basePath = getBinaryBasePath(resourcesPath);
+	const plistPath = path.join(basePath, "Info.plist");
+
+	if (!fs.existsSync(plistPath)) {
+		throw new Error(`Info.plist not found at ${plistPath}`);
+	}
+
+	let content = fs.readFileSync(plistPath, "utf-8");
+
+	if (!content.includes(originalHash)) {
+		throw new Error("Original hash not found in Info.plist");
+	}
+
+	content = content.replaceAll(originalHash, newHash);
+	fs.writeFileSync(plistPath, content, "utf-8");
+}
+
 // Unpatch/restore function
 async function unpatchApp() {
-	console.log(chalk.blueBright`[+] HTTP Toolkit Unpatcher Started`);
+	console.log(chalk.blueBright('[+] HTTP Toolkit Unpatcher Started'));
 
-	// Step 1: Find app path
 	const appPath = await findAppPath();
-	console.log(chalk.greenBright`[+] HTTP Toolkit found at ${appPath}`);
+	console.log(chalk.greenBright(`[+] HTTP Toolkit found at ${appPath}`));
 
-	// Step 2: Kill HTTP Toolkit if running
 	await killHttpToolkit();
 
-	// Step 3: Check permissions
 	const asarPath = path.join(appPath, "app.asar");
 	const backupPath = path.join(appPath, "app.asar.bak");
 	const extractPath = path.join(appPath, "app.asar_extracted");
@@ -329,120 +464,114 @@ async function unpatchApp() {
 	const hasPermissions = checkPermissions(appPath) && checkPermissions(asarPath);
 
 	if (!hasPermissions) {
-		console.log(chalk.yellowBright`[!] No write permissions for ${appPath}`);
+		console.log(chalk.yellowBright(`[!] No write permissions for ${appPath}`));
 
 		if (isElevated()) {
-			console.error(chalk.redBright`[-] Still no permissions even with elevated privileges`);
+			console.error(chalk.redBright('[-] Still no permissions even with elevated privileges'));
 			process.exit(1);
 		}
 
-		console.log(chalk.yellowBright`[!] Administrator/sudo privileges required for unpatching`);
+		console.log(chalk.yellowBright('[!] Administrator/sudo privileges required for unpatching'));
 		await requestElevation();
 	}
 
-	// Step 4: Check if backup exists
 	if (!fs.existsSync(backupPath)) {
-		console.error(chalk.redBright`[-] Backup file not found at ${backupPath}`);
-		console.error(chalk.redBright`[-] Cannot unpatch without backup file`);
+		console.error(chalk.redBright(`[-] Backup file not found at ${backupPath}`));
+		console.error(chalk.redBright('[-] Cannot unpatch without backup file'));
 		process.exit(1);
 	}
 
-	// Step 5: Restore from backup
-	console.log(chalk.yellowBright`[+] Restoring from backup...`);
+	console.log(chalk.yellowBright('[+] Restoring from backup...'));
 	try {
 		fs.copyFileSync(backupPath, asarPath);
-		console.log(chalk.greenBright`[+] Restored app.asar from backup`);
+		console.log(chalk.greenBright('[+] Restored app.asar from backup'));
 	} catch (e) {
-		console.error(chalk.redBright`[-] Failed to restore backup: ${e.message}`);
+		console.error(chalk.redBright(`[-] Failed to restore backup: ${e.message}`));
 		process.exit(1);
 	}
 
-	// Step 6: Clean up extracted files if they exist
 	if (fs.existsSync(extractPath)) {
-		console.log(chalk.yellowBright`[+] Removing extracted files...`);
+		console.log(chalk.yellowBright('[+] Removing extracted files...'));
 		rm(extractPath);
-		console.log(chalk.greenBright`[+] Cleaned up extracted files`);
+		console.log(chalk.greenBright('[+] Cleaned up extracted files'));
 	}
 
-	// Step 7: Optionally remove backup
 	const removeBackup = await prompt("Do you want to remove the backup file? (y/n): ");
 	if (removeBackup.toLowerCase() === "y" || removeBackup.toLowerCase() === "yes") {
 		fs.rmSync(backupPath, { force: true });
-		console.log(chalk.greenBright`[+] Backup file removed`);
+		console.log(chalk.greenBright('[+] Backup file removed'));
 	}
 
-	console.log(chalk.greenBright`[+] Successfully unpatched!`);
+	console.log(chalk.greenBright('[+] Successfully unpatched!'));
 }
 
 // Main patching function
 async function patchApp() {
-	console.log(chalk.blueBright`[+] HTTP Toolkit Patcher Started`);
+	console.log(chalk.blueBright('[+] HTTP Toolkit Patcher Started'));
 
-	// Step 1: Find app path
 	const appPath = await findAppPath();
-	console.log(chalk.greenBright`[+] HTTP Toolkit found at ${appPath}`);
+	console.log(chalk.greenBright(`[+] HTTP Toolkit found at ${appPath}`));
 
-	// Step 2: Kill HTTP Toolkit if running
 	await killHttpToolkit();
 
-	// Step 3: Check permissions
 	const asarPath = path.join(appPath, "app.asar");
 
 	// Check if we have write permissions on both the directory and the file
 	const hasPermissions = checkPermissions(appPath) && checkPermissions(asarPath);
 
 	if (!hasPermissions) {
-		console.log(chalk.yellowBright`[!] No write permissions for ${appPath}`);
+		console.log(chalk.yellowBright(`[!] No write permissions for ${appPath}`));
 
 		if (isElevated()) {
-			console.error(chalk.redBright`[-] Still no permissions even with elevated privileges`);
+			console.error(chalk.redBright('[-] Still no permissions even with elevated privileges'));
 			process.exit(1);
 		}
 
-		console.log(chalk.yellowBright`[!] Administrator/sudo privileges required for patching`);
+		console.log(chalk.yellowBright('[!] Administrator/sudo privileges required for patching'));
 		await requestElevation();
 	}
 
-	// Step 4: Backup app.asar
 	const backupPath = path.join(appPath, "app.asar.bak");
 	if (!fs.existsSync(backupPath)) {
-		console.log(chalk.yellowBright`[+] Creating backup...`);
+		console.log(chalk.yellowBright('[+] Creating backup...'));
 		fs.copyFileSync(asarPath, backupPath);
-		console.log(chalk.greenBright`[+] Backup created at ${backupPath}`);
+		console.log(chalk.greenBright(`[+] Backup created at ${backupPath}`));
 	}
 
-	// Step 5: Extract app.asar
 	const extractPath = path.join(appPath, "app.asar_extracted");
-	console.log(chalk.yellowBright`[+] Extracting app.asar...`);
+	console.log(chalk.yellowBright('[+] Extracting app.asar...'));
 	rm(extractPath);
 	asar.extractAll(asarPath, extractPath);
-	console.log(chalk.greenBright`[+] Extracted to ${extractPath}`);
+	console.log(chalk.greenBright(`[+] Extracted to ${extractPath}`));
 
-	// Step 6: Check if preload.cjs exists
 	const preloadPath = path.join(extractPath, "build", "preload.cjs");
 	if (!fs.existsSync(preloadPath)) {
-		console.error(chalk.redBright`[-] preload.cjs not found in ${path.join(extractPath, "build")}`);
-		console.error(chalk.yellowBright`[!] Please download the latest version of HTTP Toolkit from https://httptoolkit.com/`);
+		console.error(chalk.redBright(`[-] preload.cjs not found in ${path.join(extractPath, "build")}`));
+		console.error(chalk.yellowBright('[!] Please download the latest version of HTTP Toolkit from https://httptoolkit.com/'));
 		rm(extractPath);
 		process.exit(1);
 	}
-	console.log(chalk.greenBright`[+] Found preload.cjs`);
+	console.log(chalk.greenBright('[+] Found preload.cjs'));
 
-	// Step 7: Read inject.js from local file (same directory as this script)
-	console.log(chalk.yellowBright`[+] Reading inject code from local file...`);
+	console.log(chalk.yellowBright('[+] Reading inject code from local file...'));
 	const injectJsPath = path.join(path.dirname(__filename), "inject.js");
 	if (!fs.existsSync(injectJsPath)) {
-		console.error(chalk.redBright`[-] inject.js not found at ${injectJsPath}`);
+		console.error(chalk.redBright(`[-] inject.js not found at ${injectJsPath}`));
 		rm(extractPath);
 		process.exit(1);
 	}
 	const injectCode = fs.readFileSync(injectJsPath, "utf-8");
 	if (!injectCode || !injectCode.includes("PAGE-INJECT")) {
-		console.error(chalk.redBright`[-] Invalid inject.js file`);
+		console.error(chalk.redBright('[-] Invalid inject.js file'));
 		rm(extractPath);
 		process.exit(1);
 	}
-	console.log(chalk.greenBright`[+] Inject code loaded successfully`);
+	console.log(chalk.greenBright('[+] Inject code loaded successfully'));
+
+	let preloadContent = fs.readFileSync(preloadPath, "utf-8");
+
+	const electronVarName = preloadContent.includes("electron_1") ? "electron_1" : "electron";
+	console.log(chalk.greenBright(`[+] Detected electron variable: ${electronVarName}`));
 
 	const preloadPatchCode = `
 (function loadInjectScript() {
@@ -450,7 +579,7 @@ async function patchApp() {
 
 	function injectViaWebFrame() {
 		try {
-			const { webFrame } = electron_1;
+			const { webFrame } = ${electronVarName};
 			if (webFrame && webFrame.executeJavaScript) {
 				webFrame.executeJavaScript(injectCode).then(() => console.log("[PRELOAD] Injected via webFrame.executeJavaScript")).catch(err => console.error("[PRELOAD] webFrame injection failed:", err));
 				return true;
@@ -476,43 +605,40 @@ async function patchApp() {
 	}
 })();
 `;
-
-	// Step 8: Read files and check if already patched
-	let preloadContent = fs.readFileSync(preloadPath, "utf-8");
 	const isPreloadPatched = preloadContent.includes("loadInjectScript");
 
 	if (isPreloadPatched) {
-		console.log(chalk.yellowBright`[!] Files already patched`);
+		console.log(chalk.yellowBright('[!] Files already patched'));
 		const answer = await prompt("Do you want to repatch? (y/n): ");
 
 		if (answer.toLowerCase() !== "y" && answer.toLowerCase() !== "yes") {
-			console.log(chalk.blueBright`[+] Patching cancelled`);
+			console.log(chalk.blueBright('[+] Patching cancelled'));
 			rm(extractPath);
 			process.exit(0);
 		}
 
 		// Remove existing patches
-		console.log(chalk.yellowBright`[+] Replacing existing patches...`);
+		console.log(chalk.yellowBright('[+] Replacing existing patches...'));
 
 		// Remove preload patch
 		const preloadPatchRegex = /\n?\(function loadInjectScript\(\) \{[\s\S]*?\}\)\(\);/;
 		preloadContent = preloadContent.replace(preloadPatchRegex, "");
 	}
 
-	// Step 9: Patch preload file - find line with electron_1 and insert patch code below it
-	console.log(chalk.yellowBright`[+] Applying preload patch...`);
+	console.log(chalk.yellowBright('[+] Applying preload patch...'));
 	const preloadLines = preloadContent.split("\n");
 	let preloadInsertIndex = -1;
 
 	for (let i = 0; i < preloadLines.length; i++) {
-		if (preloadLines[i].includes("electron_1")) {
+		const line = preloadLines[i];
+		if (line.includes('require("electron")') || line.includes("require('electron')") || line.includes("electron_1")) {
 			preloadInsertIndex = i + 1;
 			break;
 		}
 	}
 
 	if (preloadInsertIndex === -1) {
-		console.error(chalk.redBright`[-] Could not find insertion point (electron_1) in ${path.basename(preloadPath)}`);
+		console.error(chalk.redBright(`[-] Could not find insertion point (electron import) in ${path.basename(preloadPath)}`));
 		rm(extractPath);
 		process.exit(1);
 	}
@@ -522,40 +648,85 @@ async function patchApp() {
 
 	// Write patched preload file
 	fs.writeFileSync(preloadPath, preloadContent, "utf-8");
-	console.log(chalk.greenBright`[+] ${path.basename(preloadPath)} patched successfully`);
+	console.log(chalk.greenBright(`[+] ${path.basename(preloadPath)} patched successfully`));
 
-
-	// Step 10: Repackage app.asar
-	console.log(chalk.yellowBright`[+] Repackaging app.asar...`);
+	console.log(chalk.yellowBright('[+] Repackaging app.asar...'));
 	await asar.createPackage(extractPath, asarPath);
-	console.log(chalk.greenBright`[+] app.asar repackaged successfully`);
+	console.log(chalk.greenBright('[+] app.asar repackaged successfully'));
 
-	// Step 11: Clean up
-	console.log(chalk.yellowBright`[+] Cleaning up temporary files...`);
-	rm(extractPath);
-	console.log(chalk.greenBright`[+] Successfully patched!`);
-
-	// Step 12: Open HTTP Toolkit as detached process
-	console.log(chalk.blueBright`[+] Opening HTTP Toolkit...`);
+	let executablePath;
 	try {
-		if (isLinux) {
-			// Linux: Cannot auto-launch reliably, show manual instructions
-			console.log(chalk.yellowBright`[!] HTTP Toolkit has been successfully patched`);
-			console.log(chalk.yellowBright`[!] Please manually launch HTTP Toolkit from your applications menu or using the command:`);
-			console.log(chalk.blueBright`    httptoolkit`);
+		executablePath = getExecutablePath(appPath);
+	} catch (e) {
+		rm(extractPath);
+		console.error(chalk.redBright(`[-] ${e.message}`));
+		process.exit(1);
+	}
+
+  // macOS: Sign the patched app
+  if (isMac) {
+    const appBundlePath = path.resolve(appPath, '..', '..');
+    console.log(chalk.yellowBright('[+] Signing HTTP Toolkit with ad-hoc signature...'));
+    try {
+      execSync(`codesign --deep --force --sign - "${appBundlePath}"`, {stdio: "pipe"});
+      console.log(chalk.greenBright('[+] HTTP Toolkit signed successfully'));
+      console.log(chalk.yellowBright(`    Make sure to whitelist the app in privacy and security settings!`));
+    } catch (e) {
+      rm(extractPath);
+      console.error(chalk.redBright(`[!] Failed to sign HTTP Toolkit: ${e.message}`));
+      process.exit(1);
+    }
+    try {
+      execSync(`xattr -d com.apple.quarantine "${appBundlePath}" 2>/dev/null`, {stdio: 'pipe'});
+    } catch (e) {
+      console.log(chalk.redBright('[!] Failed to remove the quarantine attribute'));
+    }
+  }
+
+	console.log(chalk.yellowBright('[+] Launching HTTP Toolkit to read integrity hashes...'));
+	let hashes;
+	try {
+		hashes = await captureIntegrityHashes(executablePath);
+	} catch (e) {
+		rm(extractPath);
+		console.error(chalk.redBright(`[-] Failed to capture integrity hashes: ${e.message}`));
+		process.exit(1);
+	}
+
+	console.log(chalk.greenBright('[+] Integrity hashes captured'));
+	console.log(chalk.white(`    Original hash: ${hashes.originalHash}`));
+	console.log(chalk.white(`    New asar hash: ${hashes.newHash}`));
+
+	try {
+		if (isMac) {
+			patchInfoPlistHash(appPath, hashes.originalHash, hashes.newHash);
+			console.log(chalk.greenBright('[+] Patched Info.plist hash'));
 		} else {
-			const command = isWin ? `"${path.resolve(appPath, "..", "HTTP Toolkit.exe")}"` : isMac ? 'open -a "HTTP Toolkit"' : "httptoolkit";
-			const child = spawn(command, {
+			const replacements = patchExecutableHash(executablePath, hashes.originalHash, hashes.newHash);
+			console.log(chalk.greenBright(`[+] Patched binary hash (${replacements} replacement${replacements === 1 ? "" : "s"})`));
+		}
+	} catch (e) {
+		rm(extractPath);
+		console.error(chalk.redBright(`[-] Failed to patch hash: ${e.message}`));
+		process.exit(1);
+	}
+
+	console.log(chalk.yellowBright('[+] Cleaning up temporary files...'));
+	rm(extractPath);
+	console.log(chalk.greenBright('[+] Successfully patched!'));
+
+	console.log(chalk.blueBright('[+] Opening HTTP Toolkit...'));
+	try {
+		const child = spawn(executablePath, {
 			stdio: "ignore",
-				shell: true,
+			shell: false,
 			detached: true,
 		});
 		child.unref();
-			console.log(chalk.greenBright`[+] HTTP Toolkit launched successfully`);
-		}
+		console.log(chalk.greenBright('[+] HTTP Toolkit launched successfully'));
 	} catch (e) {
-		console.error(chalk.yellowBright`[!] Could not auto-start HTTP Toolkit: ${e.message}`);
-		console.log(chalk.blueBright`[+] Please start HTTP Toolkit manually`);
+		console.error(chalk.yellowBright(`[!] Could not auto-start HTTP Toolkit: ${e.message}`));
+		console.log(chalk.blueBright('[+] Please start HTTP Toolkit manually'));
 	}
 }
 
@@ -580,30 +751,30 @@ const commandName = (() => {
 		if (command === "unpatch" || command === "restore") {
 			await unpatchApp();
 		} else if (command === "help" || command === "-h" || command === "--help") {
-			console.log(chalk.blueBright`HTTP Toolkit Patcher`);
-			console.log(chalk.white`\nUsage:`);
-			console.log(chalk.white`  ${commandName} [command]`);
-			console.log(chalk.white`\nCommands:`);
-			console.log(chalk.white`  patch    ${chalk.gray`- Patch HTTP Toolkit (default)`}`);
-			console.log(chalk.white`  unpatch  ${chalk.gray`- Restore original HTTP Toolkit from backup`}`);
-			console.log(chalk.white`  restore  ${chalk.gray`- Alias for unpatch`}`);
-			console.log(chalk.white`  help     ${chalk.gray`- Show this help message`}`);
+			console.log(chalk.blueBright('HTTP Toolkit Patcher'));
+			console.log(chalk.white('\nUsage:'));
+			console.log(chalk.white(`  ${commandName} [command]`));
+			console.log(chalk.white('\nCommands:'));
+			console.log(chalk.white(`  patch    ${chalk.gray('- Patch HTTP Toolkit (default)')}`));
+			console.log(chalk.white(`  unpatch  ${chalk.gray('- Restore original HTTP Toolkit from backup')}`));
+			console.log(chalk.white(`  restore  ${chalk.gray('- Alias for unpatch')}`));
+			console.log(chalk.white(`  help     ${chalk.gray('- Show this help message')}`));
 			process.exit(0);
 		} else if (!command || command === "patch") {
 			// Ask for confirmation before patching
 			const answer = await prompt("Do you want to patch HTTP Toolkit? [Y/n]: ");
 			if (answer.toLowerCase() === "n" || answer.toLowerCase() === "no") {
-				console.log(chalk.blueBright`[+] Patching cancelled`);
+				console.log(chalk.blueBright('[+] Patching cancelled'));
 				process.exit(0);
 			}
 			await patchApp();
 		} else {
-			console.error(chalk.redBright`[-] Unknown command: ${command}`);
-			console.log(chalk.yellowBright`[!] Use 'help' to see available commands`);
+			console.error(chalk.redBright(`[-] Unknown command: ${command}`));
+			console.log(chalk.yellowBright('[!] Use \'help\' to see available commands'));
 			process.exit(1);
 		}
 	} catch (error) {
-		console.error(chalk.redBright`[-] Error: ${error.message}`);
+		console.error(chalk.redBright(`[-] Error: ${error.message}`));
 		process.exit(1);
 	}
 })();

inject.js

@@ -1,14 +1,11 @@
 (function () {
 	console.log("[PAGE-INJECT] Installing hooks in page context");
 
+	// Properties to hook directly on accountStore (still exist as computed properties)
 	const propertyHooks = {
-		isPaidUser: true,
 		isLoggedIn: true,
-		userHasSubscription: true,
 		userEmail: "hi@httptoolkit.com",
 		mightBePaidUser: true,
-		isPastDueUser: false,
-		isStatusUnexpired: true,
 		userSubscription: {
 			state: "fulfilled",
 			status: "active",
@@ -25,12 +22,35 @@
 		},
 	};
 
+	// Methods to hook on the user object (moved from accountStore properties to user methods in v3.1.0)
+	const userMethodHooks = {
+		isPaidUser: true,
+		isPastDueUser: false,
+		userHasSubscription: true,
+	};
+
 	const hookedObjects = new WeakSet();
+	const hookedUsers = new WeakSet();
+
+	// Patch user object methods
+	function patchUserObject(user) {
+		if (!user || typeof user !== "object" || hookedUsers.has(user)) return;
+
+		for (const methodName of Object.keys(userMethodHooks)) {
+			if (typeof user[methodName] === "function") {
+				console.log("[PAGE-INJECT] Patching user." + methodName + "()");
+				user[methodName] = function () {
+					return userMethodHooks[methodName];
+				};
+			}
+		}
+
+		hookedUsers.add(user);
+	}
 
 	// Override Object.defineProperty to intercept all property definitions
 	const originalDefineProperty = Object.defineProperty;
 	Object.defineProperty = function (target, prop, descriptor) {
-		// Intercept our target properties
 		if (prop in propertyHooks) {
 			console.log("[PAGE-INJECT] Intercepting defineProperty for: " + prop);
 
@@ -47,6 +67,22 @@
 			}
 		}
 
+		// Intercept the 'user' property to patch its methods when it's set/accessed
+		if (prop === "user") {
+			console.log("[PAGE-INJECT] Intercepting defineProperty for: user");
+
+			if (descriptor && descriptor.get) {
+				const originalGetter = descriptor.get;
+				descriptor.get = function () {
+					const user = originalGetter.call(this);
+					if (user) patchUserObject(user);
+					return user;
+				};
+			} else if (descriptor && descriptor.value !== undefined && descriptor.value) {
+				patchUserObject(descriptor.value);
+			}
+		}
+
 		return originalDefineProperty.call(this, target, prop, descriptor);
 	};
 
@@ -67,6 +103,20 @@
 					props[prop].value = propertyHooks[prop];
 				}
 			}
+
+			if (prop === "user") {
+				console.log("[PAGE-INJECT] Intercepting defineProperties for: user");
+				if (props[prop].get) {
+					const originalGetter = props[prop].get;
+					props[prop].get = function () {
+						const user = originalGetter.call(this);
+						if (user) patchUserObject(user);
+						return user;
+					};
+				} else if (props[prop].value !== undefined && props[prop].value) {
+					patchUserObject(props[prop].value);
+				}
+			}
 		}
 		return originalDefineProperties.call(this, target, props);
 	};
@@ -80,6 +130,7 @@
 			if (!obj || hookedObjects.has(obj)) return;
 
 			try {
+				// Patch direct property hooks
 				Object.keys(propertyHooks).forEach(prop => {
 					try {
 						const desc = Object.getOwnPropertyDescriptor(obj, prop);
@@ -88,7 +139,7 @@
 
 							if (desc.get) {
 								const originalGetter = desc.get;
-								Object.defineProperty(obj, prop, {
+								originalDefineProperty(obj, prop, {
 									get: function () {
 										const originalValue = originalGetter.call(this);
 										console.log("[PAGE-INJECT] " + prop + " getter intercepted, original=" + originalValue + ", returning=" + JSON.stringify(propertyHooks[prop]));
@@ -108,6 +159,14 @@
 					}
 				});
 
+				// Patch user object if present
+				try {
+					if (obj.user && typeof obj.user === "object") {
+						console.log("[PAGE-INJECT] Found user object on object #" + idx + ", patching methods...");
+						patchUserObject(obj.user);
+					}
+				} catch (e) {}
+
 				hookedObjects.add(obj);
 			} catch (e) {
 				// Ignore object access errors
@@ -128,7 +187,7 @@
 									const desc = Object.getOwnPropertyDescriptor(store, prop);
 									if (desc && desc.configurable && desc.get) {
 										const originalGetter = desc.get;
-										Object.defineProperty(store, prop, {
+										originalDefineProperty(store, prop, {
 											get: function () {
 												const originalValue = originalGetter.call(this);
 												console.log("[PAGE-INJECT] accountStore." + prop + " intercepted, original=" + originalValue + ", returning=" + JSON.stringify(propertyHooks[prop]));
@@ -141,6 +200,15 @@
 									}
 								} catch (e) {}
 							});
+
+							// Patch user methods on the store
+							try {
+								if (store.user && typeof store.user === "object") {
+									console.log("[PAGE-INJECT] Found user object in accountStore, patching methods...");
+									patchUserObject(store.user);
+								}
+							} catch (e) {}
+
 							hookedObjects.add(store);
 						}
 					}
@@ -160,7 +228,7 @@
 
 		if (scanCount >= 50) {
 			clearInterval(scanInterval);
-			console.log("[PAGE-INJECT] Stopped periodic scanning after 10 attempts");
+			console.log("[PAGE-INJECT] Stopped periodic scanning after 50 attempts");
 		}
 	}, 100);
 

package-lock.json

@@ -1,238 +1,218 @@
 {
 	"name": "httptoolkit-patcher",
-	"version": "2.0.5",
+	"version": "2.0.11",
 	"lockfileVersion": 3,
 	"requires": true,
 	"packages": {
 		"": {
 			"name": "httptoolkit-patcher",
-			"version": "2.0.5",
+			"version": "2.0.11",
 			"license": "MIT",
 			"dependencies": {
-				"@electron/asar": "^3.2.9",
-				"chalk": "4"
+				"@electron/asar": "^4.1.0",
+				"chalk": "5.6.2"
 			},
 			"bin": {
 				"httptoolkit-patcher": "index.js"
 			},
 			"devDependencies": {
-				"@types/node": "^20.14.9"
+				"@types/node": "^25.5.0"
 			}
 		},
 		"node_modules/@electron/asar": {
-			"version": "3.4.1",
-			"resolved": "https://registry.npmjs.org/@electron/asar/-/asar-3.4.1.tgz",
-			"integrity": "sha512-i4/rNPRS84t0vSRa2HorerGRXWyF4vThfHesw0dmcWHp+cspK743UanA0suA5Q5y8kzY2y6YKrvbIUn69BCAiA==",
+			"version": "4.1.0",
+			"resolved": "https://registry.npmjs.org/@electron/asar/-/asar-4.1.0.tgz",
+			"integrity": "sha512-DflfXtTFuTYHcyupbhnCWi+hBFdhsWl878NuA1UmW7YVFlqPlY0SHdREVnigEO3zjS2vh4hp1A4dEl3I6mgd9w==",
 			"license": "MIT",
 			"dependencies": {
-				"commander": "^5.0.0",
-				"glob": "^7.1.6",
-				"minimatch": "^3.0.4"
+				"commander": "^13.1.0",
+				"glob": "^13.0.2",
+				"minimatch": "^10.0.1",
+				"plist": "^3.1.0"
 			},
 			"bin": {
-				"asar": "bin/asar.js"
+				"asar": "bin/asar.mjs"
 			},
 			"engines": {
-				"node": ">=10.12.0"
+				"node": ">=22.12.0"
 			}
 		},
 		"node_modules/@types/node": {
-			"version": "20.19.23",
-			"resolved": "https://registry.npmjs.org/@types/node/-/node-20.19.23.tgz",
-			"integrity": "sha512-yIdlVVVHXpmqRhtyovZAcSy0MiPcYWGkoO4CGe/+jpP0hmNuihm4XhHbADpK++MsiLHP5MVlv+bcgdF99kSiFQ==",
+			"version": "25.5.0",
+			"resolved": "https://registry.npmjs.org/@types/node/-/node-25.5.0.tgz",
+			"integrity": "sha512-jp2P3tQMSxWugkCUKLRPVUpGaL5MVFwF8RDuSRztfwgN1wmqJeMSbKlnEtQqU8UrhTmzEmZdu2I6v2dpp7XIxw==",
 			"dev": true,
 			"license": "MIT",
 			"dependencies": {
-				"undici-types": "~6.21.0"
+				"undici-types": "~7.18.0"
 			}
 		},
-		"node_modules/ansi-styles": {
-			"version": "4.3.0",
-			"resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
-			"integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+		"node_modules/@xmldom/xmldom": {
+			"version": "0.8.13",
+			"resolved": "https://registry.npmjs.org/@xmldom/xmldom/-/xmldom-0.8.13.tgz",
+			"integrity": "sha512-KRYzxepc14G/CEpEGc3Yn+JKaAeT63smlDr+vjB8jRfgTBBI9wRj/nkQEO+ucV8p8I9bfKLWp37uHgFrbntPvw==",
 			"license": "MIT",
-			"dependencies": {
-				"color-convert": "^2.0.1"
-			},
 			"engines": {
-				"node": ">=8"
-			},
-			"funding": {
-				"url": "https://github.com/chalk/ansi-styles?sponsor=1"
+				"node": ">=10.0.0"
 			}
 		},
 		"node_modules/balanced-match": {
-			"version": "1.0.2",
-			"resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
-			"integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+			"version": "4.0.4",
+			"resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-4.0.4.tgz",
+			"integrity": "sha512-BLrgEcRTwX2o6gGxGOCNyMvGSp35YofuYzw9h1IMTRmKqttAZZVU67bdb9Pr2vUHA8+j3i2tJfjO6C6+4myGTA==",
+			"license": "MIT",
+			"engines": {
+				"node": "18 || 20 || >=22"
+			}
+		},
+		"node_modules/base64-js": {
+			"version": "1.5.1",
+			"resolved": "https://registry.npmjs.org/base64-js/-/base64-js-1.5.1.tgz",
+			"integrity": "sha512-AKpaYlHn8t4SVbOHCy+b5+KKgvR4vrsD8vbvrbiQJps7fKDTkjkDry6ji0rUJjC0kzbNePLwzxq8iypo41qeWA==",
+			"funding": [
+				{
+					"type": "github",
+					"url": "https://github.com/sponsors/feross"
+				},
+				{
+					"type": "patreon",
+					"url": "https://www.patreon.com/feross"
+				},
+				{
+					"type": "consulting",
+					"url": "https://feross.org/support"
+				}
+			],
 			"license": "MIT"
 		},
 		"node_modules/brace-expansion": {
-			"version": "1.1.12",
-			"resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-1.1.12.tgz",
-			"integrity": "sha512-9T9UjW3r0UW5c1Q7GTwllptXwhvYmEzFhzMfZ9H7FQWt+uZePjZPjBP/W1ZEyZ1twGWom5/56TF4lPcqjnDHcg==",
+			"version": "5.0.5",
+			"resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-5.0.5.tgz",
+			"integrity": "sha512-VZznLgtwhn+Mact9tfiwx64fA9erHH/MCXEUfB/0bX/6Fz6ny5EGTXYltMocqg4xFAQZtnO3DHWWXi8RiuN7cQ==",
 			"license": "MIT",
 			"dependencies": {
-				"balanced-match": "^1.0.0",
-				"concat-map": "0.0.1"
+				"balanced-match": "^4.0.2"
+			},
+			"engines": {
+				"node": "18 || 20 || >=22"
 			}
 		},
 		"node_modules/chalk": {
-			"version": "4.1.2",
-			"resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
-			"integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
+			"version": "5.6.2",
+			"resolved": "https://registry.npmjs.org/chalk/-/chalk-5.6.2.tgz",
+			"integrity": "sha512-7NzBL0rN6fMUW+f7A6Io4h40qQlG+xGmtMxfbnH/K7TAtt8JQWVQK+6g0UXKMeVJoyV5EkkNsErQ8pVD3bLHbA==",
 			"license": "MIT",
-			"dependencies": {
-				"ansi-styles": "^4.1.0",
-				"supports-color": "^7.1.0"
-			},
 			"engines": {
-				"node": ">=10"
+				"node": "^12.17.0 || ^14.13 || >=16.0.0"
 			},
 			"funding": {
 				"url": "https://github.com/chalk/chalk?sponsor=1"
 			}
 		},
-		"node_modules/color-convert": {
-			"version": "2.0.1",
-			"resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
-			"integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
-			"license": "MIT",
-			"dependencies": {
-				"color-name": "~1.1.4"
-			},
-			"engines": {
-				"node": ">=7.0.0"
-			}
-		},
-		"node_modules/color-name": {
-			"version": "1.1.4",
-			"resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
-			"integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
-			"license": "MIT"
-		},
 		"node_modules/commander": {
-			"version": "5.1.0",
-			"resolved": "https://registry.npmjs.org/commander/-/commander-5.1.0.tgz",
-			"integrity": "sha512-P0CysNDQ7rtVw4QIQtm+MRxV66vKFSvlsQvGYXZWR3qFU0jlMKHZZZgw8e+8DSah4UDKMqnknRDQz+xuQXQ/Zg==",
+			"version": "13.1.0",
+			"resolved": "https://registry.npmjs.org/commander/-/commander-13.1.0.tgz",
+			"integrity": "sha512-/rFeCpNJQbhSZjGVwO9RFV3xPqbnERS8MmIQzCtD/zl6gpJuV/bMLuN92oG3F7d8oDEHHRrujSXNUr8fpjntKw==",
 			"license": "MIT",
 			"engines": {
-				"node": ">= 6"
+				"node": ">=18"
 			}
 		},
-		"node_modules/concat-map": {
-			"version": "0.0.1",
-			"resolved": "https://registry.npmjs.org/concat-map/-/concat-map-0.0.1.tgz",
-			"integrity": "sha512-/Srv4dswyQNBfohGpz9o6Yb3Gz3SrUDqBH5rTuhGR7ahtlbYKnVxw2bCFMRljaA7EXHaXZ8wsHdodFvbkhKmqg==",
-			"license": "MIT"
-		},
-		"node_modules/fs.realpath": {
-			"version": "1.0.0",
-			"resolved": "https://registry.npmjs.org/fs.realpath/-/fs.realpath-1.0.0.tgz",
-			"integrity": "sha512-OO0pH2lK6a0hZnAdau5ItzHPI6pUlvI7jMVnxUQRtw4owF2wk8lOSabtGDCTP4Ggrg2MbGnWO9X8K1t4+fGMDw==",
-			"license": "ISC"
-		},
 		"node_modules/glob": {
-			"version": "7.2.3",
-			"resolved": "https://registry.npmjs.org/glob/-/glob-7.2.3.tgz",
-			"integrity": "sha512-nFR0zLpU2YCaRxwoCJvL6UvCH2JFyFVIvwTLsIf21AuHlMskA1hhTdk+LlYJtOlYt9v6dvszD2BGRqBL+iQK9Q==",
-			"deprecated": "Glob versions prior to v9 are no longer supported",
-			"license": "ISC",
+			"version": "13.0.6",
+			"resolved": "https://registry.npmjs.org/glob/-/glob-13.0.6.tgz",
+			"integrity": "sha512-Wjlyrolmm8uDpm/ogGyXZXb1Z+Ca2B8NbJwqBVg0axK9GbBeoS7yGV6vjXnYdGm6X53iehEuxxbyiKp8QmN4Vw==",
+			"license": "BlueOak-1.0.0",
 			"dependencies": {
-				"fs.realpath": "^1.0.0",
-				"inflight": "^1.0.4",
-				"inherits": "2",
-				"minimatch": "^3.1.1",
-				"once": "^1.3.0",
-				"path-is-absolute": "^1.0.0"
+				"minimatch": "^10.2.2",
+				"minipass": "^7.1.3",
+				"path-scurry": "^2.0.2"
 			},
 			"engines": {
-				"node": "*"
+				"node": "18 || 20 || >=22"
 			},
 			"funding": {
 				"url": "https://github.com/sponsors/isaacs"
 			}
 		},
-		"node_modules/has-flag": {
-			"version": "4.0.0",
-			"resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
-			"integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
-			"license": "MIT",
+		"node_modules/lru-cache": {
+			"version": "11.2.7",
+			"resolved": "https://registry.npmjs.org/lru-cache/-/lru-cache-11.2.7.tgz",
+			"integrity": "sha512-aY/R+aEsRelme17KGQa/1ZSIpLpNYYrhcrepKTZgE+W3WM16YMCaPwOHLHsmopZHELU0Ojin1lPVxKR0MihncA==",
+			"license": "BlueOak-1.0.0",
 			"engines": {
-				"node": ">=8"
+				"node": "20 || >=22"
 			}
 		},
-		"node_modules/inflight": {
-			"version": "1.0.6",
-			"resolved": "https://registry.npmjs.org/inflight/-/inflight-1.0.6.tgz",
-			"integrity": "sha512-k92I/b08q4wvFscXCLvqfsHCrjrF7yiXsQuIVvVE7N82W3+aqpzuUdBbfhWcy/FZR3/4IgflMgKLOsvPDrGCJA==",
-			"deprecated": "This module is not supported, and leaks memory. Do not use it. Check out lru-cache if you want a good and tested way to coalesce async requests by a key value, which is much more comprehensive and powerful.",
-			"license": "ISC",
-			"dependencies": {
-				"once": "^1.3.0",
-				"wrappy": "1"
-			}
-		},
-		"node_modules/inherits": {
-			"version": "2.0.4",
-			"resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
-			"integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
-			"license": "ISC"
-		},
 		"node_modules/minimatch": {
-			"version": "3.1.2",
-			"resolved": "https://registry.npmjs.org/minimatch/-/minimatch-3.1.2.tgz",
-			"integrity": "sha512-J7p63hRiAjw1NDEww1W7i37+ByIrOWO5XQQAzZ3VOcL0PNybwpfmV/N05zFAzwQ9USyEcX6t3UO+K5aqBQOIHw==",
-			"license": "ISC",
+			"version": "10.2.4",
+			"resolved": "https://registry.npmjs.org/minimatch/-/minimatch-10.2.4.tgz",
+			"integrity": "sha512-oRjTw/97aTBN0RHbYCdtF1MQfvusSIBQM0IZEgzl6426+8jSC0nF1a/GmnVLpfB9yyr6g6FTqWqiZVbxrtaCIg==",
+			"license": "BlueOak-1.0.0",
 			"dependencies": {
-				"brace-expansion": "^1.1.7"
+				"brace-expansion": "^5.0.2"
 			},
 			"engines": {
-				"node": "*"
+				"node": "18 || 20 || >=22"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/isaacs"
 			}
 		},
-		"node_modules/once": {
-			"version": "1.4.0",
-			"resolved": "https://registry.npmjs.org/once/-/once-1.4.0.tgz",
-			"integrity": "sha512-lNaJgI+2Q5URQBkccEKHTQOPaXdUxnZZElQTZY0MFUAuaEqe1E+Nyvgdz/aIyNi6Z9MzO5dv1H8n58/GELp3+w==",
-			"license": "ISC",
-			"dependencies": {
-				"wrappy": "1"
-			}
-		},
-		"node_modules/path-is-absolute": {
-			"version": "1.0.1",
-			"resolved": "https://registry.npmjs.org/path-is-absolute/-/path-is-absolute-1.0.1.tgz",
-			"integrity": "sha512-AVbw3UJ2e9bq64vSaS9Am0fje1Pa8pbGqTTsmXfaIiMpnr5DlDhfJOuLj9Sf95ZPVDAUerDfEk88MPmPe7UCQg==",
-			"license": "MIT",
+		"node_modules/minipass": {
+			"version": "7.1.3",
+			"resolved": "https://registry.npmjs.org/minipass/-/minipass-7.1.3.tgz",
+			"integrity": "sha512-tEBHqDnIoM/1rXME1zgka9g6Q2lcoCkxHLuc7ODJ5BxbP5d4c2Z5cGgtXAku59200Cx7diuHTOYfSBD8n6mm8A==",
+			"license": "BlueOak-1.0.0",
 			"engines": {
-				"node": ">=0.10.0"
+				"node": ">=16 || 14 >=14.17"
 			}
 		},
-		"node_modules/supports-color": {
-			"version": "7.2.0",
-			"resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
-			"integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+		"node_modules/path-scurry": {
+			"version": "2.0.2",
+			"resolved": "https://registry.npmjs.org/path-scurry/-/path-scurry-2.0.2.tgz",
+			"integrity": "sha512-3O/iVVsJAPsOnpwWIeD+d6z/7PmqApyQePUtCndjatj/9I5LylHvt5qluFaBT3I5h3r1ejfR056c+FCv+NnNXg==",
+			"license": "BlueOak-1.0.0",
+			"dependencies": {
+				"lru-cache": "^11.0.0",
+				"minipass": "^7.1.2"
+			},
+			"engines": {
+				"node": "18 || 20 || >=22"
+			},
+			"funding": {
+				"url": "https://github.com/sponsors/isaacs"
+			}
+		},
+		"node_modules/plist": {
+			"version": "3.1.0",
+			"resolved": "https://registry.npmjs.org/plist/-/plist-3.1.0.tgz",
+			"integrity": "sha512-uysumyrvkUX0rX/dEVqt8gC3sTBzd4zoWfLeS29nb53imdaXVvLINYXTI2GNqzaMuvacNx4uJQ8+b3zXR0pkgQ==",
 			"license": "MIT",
 			"dependencies": {
-				"has-flag": "^4.0.0"
+				"@xmldom/xmldom": "^0.8.8",
+				"base64-js": "^1.5.1",
+				"xmlbuilder": "^15.1.1"
 			},
 			"engines": {
-				"node": ">=8"
+				"node": ">=10.4.0"
 			}
 		},
 		"node_modules/undici-types": {
-			"version": "6.21.0",
-			"resolved": "https://registry.npmjs.org/undici-types/-/undici-types-6.21.0.tgz",
-			"integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ==",
+			"version": "7.18.2",
+			"resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.18.2.tgz",
+			"integrity": "sha512-AsuCzffGHJybSaRrmr5eHr81mwJU3kjw6M+uprWvCXiNeN9SOGwQ3Jn8jb8m3Z6izVgknn1R0FTCEAP2QrLY/w==",
 			"dev": true,
 			"license": "MIT"
 		},
-		"node_modules/wrappy": {
-			"version": "1.0.2",
-			"resolved": "https://registry.npmjs.org/wrappy/-/wrappy-1.0.2.tgz",
-			"integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
-			"license": "ISC"
+		"node_modules/xmlbuilder": {
+			"version": "15.1.1",
+			"resolved": "https://registry.npmjs.org/xmlbuilder/-/xmlbuilder-15.1.1.tgz",
+			"integrity": "sha512-yMqGBqtXyeN1e3TGYvgNgDVZ3j84W4cwkOXQswghol6APgZWaff9lnbvN7MHYJOiXsvGPXtjTYJEiC9J2wv9Eg==",
+			"license": "MIT",
+			"engines": {
+				"node": ">=8.0"
+			}
 		}
 	}
 }

package.json

@@ -1,6 +1,6 @@
 {
 	"name": "httptoolkit-patcher",
-	"version": "2.0.8",
+	"version": "2.0.11",
 	"description": "HTTP Toolkit Pro Patcher",
 	"main": "index.js",
 	"type": "module",
@@ -14,10 +14,10 @@
 	},
 	"license": "MIT",
 	"dependencies": {
-		"@electron/asar": "^3.2.9",
-		"chalk": "4"
+		"@electron/asar": "^4.1.0",
+		"chalk": "5.6.2"
 	},
 	"devDependencies": {
-		"@types/node": "^20.14.9"
+		"@types/node": "^25.5.0"
 	}
 }