@mcesystems/apple-kit 1.0.27 → 1.0.28

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcesystems/apple-kit",
-  "version": "1.0.27",
+  "version": "1.0.28",
   "description": "iOS device management toolkit using libimobiledevice command-line tools",
   "main": "dist/index.js",
   "module": "dist/index.mjs",

package/scripts/export-resources.ts

@@ -17,15 +17,16 @@
  *   - Windows: Builds from source using MSYS2/MinGW (requires manual setup)
  */
 
-import { exec } from "node:child_process";
+import { exec, spawn } from "node:child_process";
 import {
-    chmodSync,
-    copyFileSync,
-    existsSync,
-    mkdirSync,
-    readFileSync,
-    readlinkSync,
-    writeFileSync,
+	chmodSync,
+	copyFileSync,
+	existsSync,
+	mkdirSync,
+	readFileSync,
+	readdirSync,
+	readlinkSync,
+	writeFileSync,
 } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
@@ -43,21 +44,21 @@ const execAsync = promisify(exec);
 
 // Tools we need to bundle
 const REQUIRED_TOOLS = [
-    "idevice_id",
-    "ideviceinfo",
-    "idevicepair",
-    "idevicename",
-    "idevicedebug",
-    "ideviceinstaller",
-    "iproxy",
+	"idevice_id",
+	"ideviceinfo",
+	"idevicepair",
+	"idevicename",
+	"idevicedebug",
+	"ideviceinstaller",
+	"iproxy",
 ];
 
 // Optional tools (won't fail if not found)
 const OPTIONAL_TOOLS = [
-    "ideviceactivation",
-    "idevicesyslog",
-    "idevicescreenshot",
-    "idevicediagnostics",
+	"ideviceactivation",
+	"idevicesyslog",
+	"idevicescreenshot",
+	"idevicediagnostics",
 ];
 
 // Homebrew paths on macOS
@@ -67,17 +68,27 @@ const HOMEBREW_INTEL_PATH = "/usr/local";
 // MSYS2 paths on Windows
 const MSYS2_DEFAULT_PATH = "C:\\msys64";
 
+// System library prefixes that should NOT be copied (they exist on all macOS)
+const SYSTEM_LIB_PREFIXES = [
+	"/System/Library/",
+	"/usr/lib/",
+	"/Library/Apple/",
+];
+
 // ============================================================================
 // Utility Functions
 // ============================================================================
 
 function printUsage(): void {
-    console.log(`
+	console.log(`
 Usage: npx tsx export-resources.ts <target-path>
 
 Arguments:
   target-path    Directory where resources will be exported
 
+Options:
+  --skip-verify  Skip verification step
+
 Examples:
   npx tsx export-resources.ts ./my-app/resources/apple-kit
   npx tsx export-resources.ts /absolute/path/to/resources
@@ -93,113 +104,277 @@ The script will create the following structure:
 }
 
 function resolveSymlink(filePath: string): string {
-    try {
-        const linkTarget = readlinkSync(filePath);
-        if (path.isAbsolute(linkTarget)) {
-            return linkTarget;
-        }
-        return path.resolve(path.dirname(filePath), linkTarget);
-    } catch {
-        return filePath; // Not a symlink
-    }
+	try {
+		const linkTarget = readlinkSync(filePath);
+		if (path.isAbsolute(linkTarget)) {
+			return linkTarget;
+		}
+		return path.resolve(path.dirname(filePath), linkTarget);
+	} catch {
+		return filePath; // Not a symlink
+	}
 }
 
-interface DylibInfo {
-    path: string;
-    name: string;
+/**
+ * Check if a library path is a system library that doesn't need to be copied
+ */
+function isSystemLibrary(libPath: string): boolean {
+	return SYSTEM_LIB_PREFIXES.some((prefix) => libPath.startsWith(prefix));
 }
 
-async function getDylibDependencies(binaryPath: string): Promise<DylibInfo[]> {
-    const dylibs: DylibInfo[] = [];
-
-    try {
-        const { stdout } = await execAsync(`otool -L "${binaryPath}"`);
-        const lines = stdout.split("\n");
-
-        for (const line of lines) {
-            const match = line.match(/^\s+(\S+\.dylib)/);
-            if (match) {
-                const dylibPath = match[1];
-                if (
-                    dylibPath.includes("/opt/homebrew") ||
-                    dylibPath.includes("/usr/local/opt")
-                ) {
-                    dylibs.push({
-                        path: dylibPath,
-                        name: path.basename(dylibPath),
-                    });
-                }
-            }
-        }
-    } catch {
-        console.warn(`Warning: Could not get dependencies for ${binaryPath}`);
-    }
-
-    return dylibs;
+/**
+ * Check if a library path needs to be bundled (is from homebrew or similar)
+ */
+function needsBundling(libPath: string): boolean {
+	if (isSystemLibrary(libPath)) {
+		return false;
+	}
+	if (libPath.startsWith("@")) {
+		// Already a relocatable path
+		return false;
+	}
+	// Bundle anything from /opt/homebrew, /usr/local/opt, or /usr/local/Cellar
+	return (
+		libPath.includes("/opt/homebrew") ||
+		libPath.includes("/usr/local/opt") ||
+		libPath.includes("/usr/local/Cellar") ||
+		libPath.includes("/usr/local/lib")
+	);
 }
 
-async function getAllDylibs(binaries: string[]): Promise<Map<string, string>> {
-    const allDylibs = new Map<string, string>();
-    const processed = new Set<string>();
+interface DylibDependency {
+	originalPath: string;
+	name: string;
+	realPath: string;
+}
 
-    async function processBinary(binaryPath: string): Promise<void> {
-        if (processed.has(binaryPath)) return;
-        processed.add(binaryPath);
+/**
+ * Get all dylib dependencies for a binary, including the original path as referenced
+ */
+async function getDylibDependencies(binaryPath: string): Promise<DylibDependency[]> {
+	const dylibs: DylibDependency[] = [];
+
+	try {
+		const { stdout } = await execAsync(`otool -L "${binaryPath}"`);
+		const lines = stdout.split("\n");
+
+		for (const line of lines) {
+			// Match library paths (with or without version info in parentheses)
+			const match = line.match(/^\s+(.+?)\s+\(/);
+			if (match) {
+				const libPath = match[1].trim();
+				if (needsBundling(libPath)) {
+					const realPath = resolveSymlink(libPath);
+					dylibs.push({
+						originalPath: libPath,
+						name: path.basename(libPath),
+						realPath: existsSync(realPath) ? realPath : libPath,
+					});
+				}
+			}
+		}
+	} catch (error) {
+		console.warn(`Warning: Could not get dependencies for ${binaryPath}: ${error}`);
+	}
+
+	return dylibs;
+}
 
-        const deps = await getDylibDependencies(binaryPath);
-        for (const dep of deps) {
-            if (!allDylibs.has(dep.name)) {
-                allDylibs.set(dep.name, dep.path);
-                await processBinary(dep.path);
-            }
-        }
-    }
+/**
+ * Recursively collect ALL dylib dependencies
+ * Continues until no new dependencies are found
+ */
+async function collectAllDependencies(
+	initialBinaries: string[]
+): Promise<Map<string, DylibDependency>> {
+	const allDylibs = new Map<string, DylibDependency>();
+	const processedPaths = new Set<string>();
+	const toProcess: string[] = [...initialBinaries];
+
+	console.log("  Scanning for dependencies...");
+
+	let iteration = 0;
+	while (toProcess.length > 0) {
+		iteration++;
+		const currentPath = toProcess.pop()!;
+
+		if (processedPaths.has(currentPath)) {
+			continue;
+		}
+		processedPaths.add(currentPath);
+
+		const deps = await getDylibDependencies(currentPath);
+
+		for (const dep of deps) {
+			if (!allDylibs.has(dep.name)) {
+				allDylibs.set(dep.name, dep);
+				// Add this dylib to be processed for its own dependencies
+				if (existsSync(dep.realPath)) {
+					toProcess.push(dep.realPath);
+				}
+			}
+		}
+	}
+
+	console.log(`  Found ${allDylibs.size} unique dylib dependencies (${iteration} files scanned)`);
+	return allDylibs;
+}
 
-    for (const binary of binaries) {
-        await processBinary(binary);
-    }
+/**
+ * Fix all library paths in a binary to use @loader_path
+ * This rewrites ALL non-system library references
+ */
+async function fixAllLibraryPaths(
+	binaryPath: string,
+	allDylibNames: Set<string>
+): Promise<string[]> {
+	const unfixedPaths: string[] = [];
+
+	try {
+		const { stdout } = await execAsync(`otool -L "${binaryPath}"`);
+		const lines = stdout.split("\n");
+
+		for (const line of lines) {
+			const match = line.match(/^\s+(.+?)\s+\(/);
+			if (match) {
+				const libPath = match[1].trim();
+
+				// Skip system libraries and already-fixed paths
+				if (isSystemLibrary(libPath) || libPath.startsWith("@")) {
+					continue;
+				}
+
+				const libName = path.basename(libPath);
+
+				// Check if we have this dylib in our collection
+				if (allDylibNames.has(libName)) {
+					try {
+						await execAsync(
+							`install_name_tool -change "${libPath}" "@loader_path/${libName}" "${binaryPath}"`
+						);
+					} catch (error) {
+						console.warn(`  Warning: Could not fix path ${libPath} in ${path.basename(binaryPath)}`);
+						unfixedPaths.push(libPath);
+					}
+				} else {
+					// This is a non-system library we don't have - this is a problem
+					unfixedPaths.push(libPath);
+				}
+			}
+		}
+	} catch (error) {
+		console.warn(`Warning: Could not process ${binaryPath}: ${error}`);
+	}
+
+	return unfixedPaths;
+}
 
-    return allDylibs;
+/**
+ * Fix the install name (ID) of a dylib to use @loader_path
+ */
+async function fixDylibId(dylibPath: string): Promise<void> {
+	const dylibName = path.basename(dylibPath);
+	try {
+		await execAsync(`install_name_tool -id "@loader_path/${dylibName}" "${dylibPath}"`);
+	} catch {
+		console.warn(`  Warning: Could not fix dylib ID for ${dylibName}`);
+	}
 }
 
-async function fixDylibPaths(
-    binaryPath: string,
-    dylibs: Map<string, string>
-): Promise<void> {
-    const { stdout } = await execAsync(`otool -L "${binaryPath}"`);
-    const lines = stdout.split("\n");
-
-    for (const [dylibName] of dylibs) {
-        for (const line of lines) {
-            const match = line.match(/^\s+(\S+)/);
-            if (match) {
-                const depPath = match[1];
-                if (
-                    depPath.includes(dylibName) &&
-                    !depPath.startsWith("@loader_path")
-                ) {
-                    try {
-                        await execAsync(
-                            `install_name_tool -change "${depPath}" "@loader_path/${dylibName}" "${binaryPath}"`
-                        );
-                    } catch {
-                        // Ignore errors
-                    }
-                }
-            }
-        }
-    }
+/**
+ * Ad-hoc code sign a binary (required after modifying with install_name_tool on modern macOS)
+ */
+async function codesignBinary(binaryPath: string): Promise<boolean> {
+	try {
+		await execAsync(`codesign --force --sign - "${binaryPath}"`);
+		return true;
+	} catch (error) {
+		console.warn(`  Warning: Could not code sign ${path.basename(binaryPath)}: ${error}`);
+		return false;
+	}
 }
 
-async function fixDylibId(dylibPath: string): Promise<void> {
-    const dylibName = path.basename(dylibPath);
-    try {
-        await execAsync(
-            `install_name_tool -id "@loader_path/${dylibName}" "${dylibPath}"`
-        );
-    } catch {
-        console.warn(`Warning: Could not fix dylib id for ${dylibPath}`);
-    }
+/**
+ * Verify that a binary can be loaded and executed
+ */
+async function verifyBinary(binaryPath: string, binDir: string): Promise<{ success: boolean; error?: string }> {
+	const binaryName = path.basename(binaryPath);
+
+	// Check that otool shows no broken paths
+	try {
+		const { stdout } = await execAsync(`otool -L "${binaryPath}"`);
+		const lines = stdout.split("\n");
+
+		for (const line of lines) {
+			const match = line.match(/^\s+(.+?)\s+\(/);
+			if (match) {
+				const libPath = match[1].trim();
+
+				// Skip system libraries
+				if (isSystemLibrary(libPath)) {
+					continue;
+				}
+
+				// If it's an @loader_path reference, check the file exists
+				if (libPath.startsWith("@loader_path/")) {
+					const libName = libPath.replace("@loader_path/", "");
+					const fullPath = path.join(binDir, libName);
+					if (!existsSync(fullPath)) {
+						return { success: false, error: `Missing library: ${libName}` };
+					}
+				} else if (!libPath.startsWith("@")) {
+					// Absolute path that's not a system library - this is a problem
+					return { success: false, error: `Unfixed absolute path: ${libPath}` };
+				}
+			}
+		}
+	} catch (error) {
+		return { success: false, error: `otool failed: ${error}` };
+	}
+
+	// For executable binaries (not dylibs), try to run them with --help or -h
+	if (!binaryName.endsWith(".dylib")) {
+		try {
+			// Use spawn with a timeout to test if the binary loads
+			const result = await new Promise<{ success: boolean; error?: string }>((resolve) => {
+				const child = spawn(binaryPath, ["--help"], {
+					timeout: 5000,
+					env: { ...process.env, DYLD_LIBRARY_PATH: binDir },
+				});
+
+				let stderr = "";
+				child.stderr?.on("data", (data) => {
+					stderr += data.toString();
+				});
+
+				child.on("error", (err) => {
+					resolve({ success: false, error: `Spawn error: ${err.message}` });
+				});
+
+				child.on("close", (code) => {
+					// Exit codes 0, 1, or 2 are acceptable (0=success, 1=error, 2=usage)
+					// What we're checking is that the binary LOADS, not that --help works
+					if (code !== null && code <= 2) {
+						resolve({ success: true });
+					} else if (stderr.includes("Library not loaded") || stderr.includes("image not found")) {
+						resolve({ success: false, error: stderr.split("\n")[0] });
+					} else {
+						// Other exit codes might be fine too
+						resolve({ success: true });
+					}
+				});
+			});
+
+			if (!result.success) {
+				return result;
+			}
+		} catch (error) {
+			// If spawn fails entirely, that's a problem
+			return { success: false, error: `Execution test failed: ${error}` };
+		}
+	}
+
+	return { success: true };
 }
 
 // ============================================================================
@@ -207,111 +382,186 @@ async function fixDylibId(dylibPath: string): Promise<void> {
 // ============================================================================
 
 function getHomebrewPath(): string | null {
-    if (existsSync(path.join(HOMEBREW_ARM_PATH, "bin", "idevice_id"))) {
-        return HOMEBREW_ARM_PATH;
-    }
-    if (existsSync(path.join(HOMEBREW_INTEL_PATH, "bin", "idevice_id"))) {
-        return HOMEBREW_INTEL_PATH;
-    }
-    return null;
+	if (existsSync(path.join(HOMEBREW_ARM_PATH, "bin", "idevice_id"))) {
+		return HOMEBREW_ARM_PATH;
+	}
+	if (existsSync(path.join(HOMEBREW_INTEL_PATH, "bin", "idevice_id"))) {
+		return HOMEBREW_INTEL_PATH;
+	}
+	return null;
 }
 
-async function exportDarwinResources(targetDir: string): Promise<void> {
-    console.log("\n=== Exporting macOS (Darwin) Resources ===\n");
-
-    const homebrewPath = getHomebrewPath();
-    if (!homebrewPath) {
-        console.error("Error: Homebrew libimobiledevice not found.");
-        console.error(
-            "Please install it first: brew install libimobiledevice ideviceinstaller"
-        );
-        process.exit(1);
-    }
-
-    console.log(`Found Homebrew at: ${homebrewPath}`);
-
-    const darwinBinDir = path.join(targetDir, "bin", "darwin");
-    mkdirSync(darwinBinDir, { recursive: true });
-
-    // Collect all binaries that exist
-    const binaryPaths: string[] = [];
-    const copiedBinaries: string[] = [];
-
-    // Copy required tools
-    for (const tool of REQUIRED_TOOLS) {
-        const toolPath = path.join(homebrewPath, "bin", tool);
-        if (existsSync(toolPath)) {
-            const realPath = resolveSymlink(toolPath);
-            binaryPaths.push(realPath);
-
-            const destPath = path.join(darwinBinDir, tool);
-            copyFileSync(realPath, destPath);
-            chmodSync(destPath, 0o755);
-            copiedBinaries.push(destPath);
-            console.log(`✓ Copied ${tool}`);
-        } else {
-            console.error(`✗ Required tool not found: ${tool}`);
-            console.error(
-                `  Please install: brew install libimobiledevice ideviceinstaller`
-            );
-            process.exit(1);
-        }
-    }
-
-    // Copy optional tools
-    for (const tool of OPTIONAL_TOOLS) {
-        const toolPath = path.join(homebrewPath, "bin", tool);
-        if (existsSync(toolPath)) {
-            const realPath = resolveSymlink(toolPath);
-            binaryPaths.push(realPath);
-
-            const destPath = path.join(darwinBinDir, tool);
-            copyFileSync(realPath, destPath);
-            chmodSync(destPath, 0o755);
-            copiedBinaries.push(destPath);
-            console.log(`✓ Copied ${tool} (optional)`);
-        } else {
-            console.log(`- Skipping ${tool} (optional, not installed)`);
-        }
-    }
-
-    // Get all dylib dependencies
-    console.log("\nCollecting dylib dependencies...");
-    const allDylibs = await getAllDylibs(binaryPaths);
-
-    // Copy dylibs
-    console.log(`\nCopying ${allDylibs.size} dylibs...`);
-    const copiedDylibs: string[] = [];
-
-    for (const [dylibName, dylibPath] of allDylibs) {
-        const realPath = resolveSymlink(dylibPath);
-        const destPath = path.join(darwinBinDir, dylibName);
-
-        if (existsSync(realPath)) {
-            copyFileSync(realPath, destPath);
-            chmodSync(destPath, 0o755);
-            copiedDylibs.push(destPath);
-            console.log(`✓ Copied ${dylibName}`);
-        } else {
-            console.warn(`Warning: Dylib not found: ${realPath}`);
-        }
-    }
-
-    // Fix dylib paths in all binaries and dylibs
-    console.log("\nFixing dylib paths...");
-
-    for (const binaryPath of copiedBinaries) {
-        await fixDylibPaths(binaryPath, allDylibs);
-        console.log(`✓ Fixed paths in ${path.basename(binaryPath)}`);
-    }
-
-    for (const dylibPath of copiedDylibs) {
-        await fixDylibId(dylibPath);
-        await fixDylibPaths(dylibPath, allDylibs);
-        console.log(`✓ Fixed paths in ${path.basename(dylibPath)}`);
-    }
-
-    console.log(`\n✓ macOS resources exported to: ${darwinBinDir}`);
+async function exportDarwinResources(targetDir: string, skipVerify: boolean): Promise<void> {
+	console.log("\n=== Exporting macOS (Darwin) Resources ===\n");
+
+	const homebrewPath = getHomebrewPath();
+	if (!homebrewPath) {
+		console.error("Error: Homebrew libimobiledevice not found.");
+		console.error("Please install it first: brew install libimobiledevice ideviceinstaller");
+		process.exit(1);
+	}
+
+	console.log(`Found Homebrew at: ${homebrewPath}`);
+
+	const darwinBinDir = path.join(targetDir, "bin", "darwin");
+	mkdirSync(darwinBinDir, { recursive: true });
+
+	// =========================================================================
+	// Step 1: Copy all required and optional tools
+	// =========================================================================
+	console.log("\n--- Step 1: Copying binaries ---");
+
+	const binaryPaths: string[] = [];
+	const copiedBinaries: string[] = [];
+
+	// Copy required tools
+	for (const tool of REQUIRED_TOOLS) {
+		const toolPath = path.join(homebrewPath, "bin", tool);
+		if (existsSync(toolPath)) {
+			const realPath = resolveSymlink(toolPath);
+			binaryPaths.push(realPath);
+
+			const destPath = path.join(darwinBinDir, tool);
+			copyFileSync(realPath, destPath);
+			chmodSync(destPath, 0o755);
+			copiedBinaries.push(destPath);
+			console.log(`  ✓ Copied ${tool}`);
+		} else {
+			console.error(`  ✗ Required tool not found: ${tool}`);
+			console.error(`    Please install: brew install libimobiledevice ideviceinstaller`);
+			process.exit(1);
+		}
+	}
+
+	// Copy optional tools
+	for (const tool of OPTIONAL_TOOLS) {
+		const toolPath = path.join(homebrewPath, "bin", tool);
+		if (existsSync(toolPath)) {
+			const realPath = resolveSymlink(toolPath);
+			binaryPaths.push(realPath);
+
+			const destPath = path.join(darwinBinDir, tool);
+			copyFileSync(realPath, destPath);
+			chmodSync(destPath, 0o755);
+			copiedBinaries.push(destPath);
+			console.log(`  ✓ Copied ${tool} (optional)`);
+		} else {
+			console.log(`  - Skipping ${tool} (optional, not installed)`);
+		}
+	}
+
+	// =========================================================================
+	// Step 2: Recursively collect ALL dylib dependencies
+	// =========================================================================
+	console.log("\n--- Step 2: Collecting dependencies ---");
+
+	const allDylibs = await collectAllDependencies(binaryPaths);
+
+	// =========================================================================
+	// Step 3: Copy all dylibs
+	// =========================================================================
+	console.log("\n--- Step 3: Copying dylibs ---");
+
+	const copiedDylibs: string[] = [];
+	const allDylibNames = new Set<string>();
+
+	for (const [dylibName, dep] of allDylibs) {
+		allDylibNames.add(dylibName);
+		const destPath = path.join(darwinBinDir, dylibName);
+
+		if (existsSync(dep.realPath)) {
+			copyFileSync(dep.realPath, destPath);
+			chmodSync(destPath, 0o755);
+			copiedDylibs.push(destPath);
+			console.log(`  ✓ Copied ${dylibName}`);
+		} else {
+			console.warn(`  ✗ Warning: Dylib not found: ${dep.realPath}`);
+		}
+	}
+
+	// =========================================================================
+	// Step 4: Fix library paths in all copied files
+	// =========================================================================
+	console.log("\n--- Step 4: Fixing library paths ---");
+
+	const allCopiedFiles = [...copiedBinaries, ...copiedDylibs];
+	const unfixedPaths: Map<string, string[]> = new Map();
+
+	// First, fix dylib IDs
+	for (const dylibPath of copiedDylibs) {
+		await fixDylibId(dylibPath);
+	}
+
+	// Then, fix all library references
+	for (const filePath of allCopiedFiles) {
+		const unfixed = await fixAllLibraryPaths(filePath, allDylibNames);
+		if (unfixed.length > 0) {
+			unfixedPaths.set(path.basename(filePath), unfixed);
+		}
+		console.log(`  ✓ Fixed paths in ${path.basename(filePath)}`);
+	}
+
+	// Report any unfixed paths
+	if (unfixedPaths.size > 0) {
+		console.log("\n  ⚠ Warning: Some library paths could not be fixed:");
+		for (const [file, paths] of unfixedPaths) {
+			for (const p of paths) {
+				console.log(`    ${file}: ${p}`);
+			}
+		}
+	}
+
+	// =========================================================================
+	// Step 5: Code sign all binaries (required on modern macOS)
+	// =========================================================================
+	console.log("\n--- Step 5: Code signing ---");
+
+	let signedCount = 0;
+	for (const filePath of allCopiedFiles) {
+		const success = await codesignBinary(filePath);
+		if (success) {
+			signedCount++;
+		}
+	}
+	console.log(`  ✓ Signed ${signedCount}/${allCopiedFiles.length} files`);
+
+	// =========================================================================
+	// Step 6: Verify binaries work
+	// =========================================================================
+	if (!skipVerify) {
+		console.log("\n--- Step 6: Verifying binaries ---");
+
+		let verifyErrors = 0;
+		for (const binaryPath of copiedBinaries) {
+			const result = await verifyBinary(binaryPath, darwinBinDir);
+			if (result.success) {
+				console.log(`  ✓ ${path.basename(binaryPath)} OK`);
+			} else {
+				console.log(`  ✗ ${path.basename(binaryPath)} FAILED: ${result.error}`);
+				verifyErrors++;
+			}
+		}
+
+		// Also verify dylibs have valid paths
+		for (const dylibPath of copiedDylibs) {
+			const result = await verifyBinary(dylibPath, darwinBinDir);
+			if (!result.success) {
+				console.log(`  ✗ ${path.basename(dylibPath)} FAILED: ${result.error}`);
+				verifyErrors++;
+			}
+		}
+
+		if (verifyErrors > 0) {
+			console.log(`\n  ⚠ ${verifyErrors} verification errors found`);
+			console.log("  Run with DYLD_PRINT_LIBRARIES=1 to debug library loading issues");
+		} else {
+			console.log(`\n  ✓ All binaries verified successfully`);
+		}
+	} else {
+		console.log("\n--- Step 6: Verification skipped ---");
+	}
+
+	console.log(`\n✓ macOS resources exported to: ${darwinBinDir}`);
 }
 
 // ============================================================================
@@ -319,53 +569,48 @@ async function exportDarwinResources(targetDir: string): Promise<void> {
 // ============================================================================
 
 async function exportWindowsResources(targetDir: string): Promise<void> {
-    console.log("\n=== Exporting Windows Resources ===\n");
-
-    // Check if we're on Windows
-    if (process.platform !== "win32") {
-        console.log("Note: Windows resources can only be built on Windows.");
-        console.log("Generating build script for later use...\n");
-        generateWindowsBuildScript(targetDir);
-        return;
-    }
-
-    // Check for MSYS2
-    const msys2Path = process.env.MSYS2_PATH || MSYS2_DEFAULT_PATH;
-    if (!existsSync(msys2Path)) {
-        console.error(`Error: MSYS2 not found at ${msys2Path}`);
-        console.error("Please install MSYS2 from https://www.msys2.org/");
-        console.error(
-            "Or set MSYS2_PATH environment variable to your MSYS2 installation."
-        );
-        generateWindowsBuildScript(targetDir);
-        return;
-    }
-
-    // Generate the build script
-    generateWindowsBuildScript(targetDir);
-
-    console.log("\nTo build Windows resources:");
-    console.log("1. Open MSYS2 MinGW 64-bit shell");
-    console.log(`2. Run: bash "${path.join(targetDir, "build-windows.sh")}"`);
+	console.log("\n=== Exporting Windows Resources ===\n");
+
+	// Check if we're on Windows
+	if (process.platform !== "win32") {
+		console.log("Note: Windows resources can only be built on Windows.");
+		console.log("Generating build script for later use...\n");
+		generateWindowsBuildScript(targetDir);
+		return;
+	}
+
+	// Check for MSYS2
+	const msys2Path = process.env.MSYS2_PATH || MSYS2_DEFAULT_PATH;
+	if (!existsSync(msys2Path)) {
+		console.error(`Error: MSYS2 not found at ${msys2Path}`);
+		console.error("Please install MSYS2 from https://www.msys2.org/");
+		console.error("Or set MSYS2_PATH environment variable to your MSYS2 installation.");
+		generateWindowsBuildScript(targetDir);
+		return;
+	}
+
+	// Generate the build script
+	generateWindowsBuildScript(targetDir);
+
+	console.log("\nTo build Windows resources:");
+	console.log("1. Open MSYS2 MinGW 64-bit shell");
+	console.log(`2. Run: bash "${path.join(targetDir, "build-windows.sh")}"`);
 }
 
 function generateWindowsBuildScript(targetDir: string): void {
-    const windowsBinDir = path.join(targetDir, "bin", "windows");
-    mkdirSync(windowsBinDir, { recursive: true });
-
-    // Read the template file
-    const templatePath = path.join(__dirname, "build-windows.sh.template");
-    let buildScript = readFileSync(templatePath, "utf-8");
-
-    // Replace the placeholder with the actual target directory
-    buildScript = buildScript.replace(
-        "{{TARGET_DIR}}",
-        windowsBinDir.replace(/\\/g, "/")
-    );
-
-    const scriptPath = path.join(targetDir, "build-windows.sh");
-    writeFileSync(scriptPath, buildScript);
-    console.log(`✓ Generated Windows build script: ${scriptPath}`);
+	const windowsBinDir = path.join(targetDir, "bin", "windows");
+	mkdirSync(windowsBinDir, { recursive: true });
+
+	// Read the template file
+	const templatePath = path.join(__dirname, "build-windows.sh.template");
+	let buildScript = readFileSync(templatePath, "utf-8");
+
+	// Replace the placeholder with the actual target directory
+	buildScript = buildScript.replace("{{TARGET_DIR}}", windowsBinDir.replace(/\\/g, "/"));
+
+	const scriptPath = path.join(targetDir, "build-windows.sh");
+	writeFileSync(scriptPath, buildScript);
+	console.log(`✓ Generated Windows build script: ${scriptPath}`);
 }
 
 // ============================================================================
@@ -373,10 +618,10 @@ function generateWindowsBuildScript(targetDir: string): void {
 // ============================================================================
 
 function createLicenseFile(targetDir: string): void {
-    const licensesDir = path.join(targetDir, "licenses");
-    mkdirSync(licensesDir, { recursive: true });
+	const licensesDir = path.join(targetDir, "licenses");
+	mkdirSync(licensesDir, { recursive: true });
 
-    const lgplText = `GNU LESSER GENERAL PUBLIC LICENSE
+	const lgplText = `GNU LESSER GENERAL PUBLIC LICENSE
 Version 2.1, February 1999
 
 libimobiledevice and related tools are licensed under the
@@ -393,9 +638,9 @@ These binaries are bundled for convenience. The source code is available at:
 - https://github.com/libimobiledevice/ideviceinstaller
 `;
 
-    const licensePath = path.join(licensesDir, "LGPL-2.1.txt");
-    writeFileSync(licensePath, lgplText);
-    console.log(`✓ Created license file: ${licensePath}`);
+	const licensePath = path.join(licensesDir, "LGPL-2.1.txt");
+	writeFileSync(licensePath, lgplText);
+	console.log(`✓ Created license file: ${licensePath}`);
 }
 
 // ============================================================================
@@ -403,42 +648,42 @@ These binaries are bundled for convenience. The source code is available at:
 // ============================================================================
 
 async function main(): Promise<void> {
-    const args = process.argv.slice(2);
-
-    if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
-        printUsage();
-        process.exit(args.length === 0 ? 1 : 0);
-    }
-
-    const targetPath = path.resolve(args[0]);
-
-    console.log("=== Apple-kit Resources Export ===");
-    console.log(`Platform: ${process.platform}`);
-    console.log(`Target: ${targetPath}`);
-
-    // Create target directory
-    mkdirSync(targetPath, { recursive: true });
-
-    // Export based on platform
-    if (process.platform === "darwin") {
-        await exportDarwinResources(targetPath);
-    } else if (process.platform === "win32") {
-        await exportWindowsResources(targetPath);
-    } else {
-        console.log("\nNote: This script supports macOS and Windows.");
-        console.log("For Linux, install libimobiledevice-utils via your package manager.");
-    }
-
-    // Always create license file
-    console.log("");
-    createLicenseFile(targetPath);
-
-    console.log("\n=== Export Complete ===");
-    console.log(`Resources exported to: ${targetPath}`);
+	const args = process.argv.slice(2);
+
+	if (args.length === 0 || args.includes("--help") || args.includes("-h")) {
+		printUsage();
+		process.exit(args.length === 0 ? 1 : 0);
+	}
+
+	const skipVerify = args.includes("--skip-verify");
+	const targetPath = path.resolve(args.find((a) => !a.startsWith("--")) || ".");
+
+	console.log("=== Apple-kit Resources Export ===");
+	console.log(`Platform: ${process.platform}`);
+	console.log(`Target: ${targetPath}`);
+
+	// Create target directory
+	mkdirSync(targetPath, { recursive: true });
+
+	// Export based on platform
+	if (process.platform === "darwin") {
+		await exportDarwinResources(targetPath, skipVerify);
+	} else if (process.platform === "win32") {
+		await exportWindowsResources(targetPath);
+	} else {
+		console.log("\nNote: This script supports macOS and Windows.");
+		console.log("For Linux, install libimobiledevice-utils via your package manager.");
+	}
+
+	// Always create license file
+	console.log("");
+	createLicenseFile(targetPath);
+
+	console.log("\n=== Export Complete ===");
+	console.log(`Resources exported to: ${targetPath}`);
 }
 
 main().catch((error) => {
-    console.error("Export failed:", error);
-    process.exit(1);
+	console.error("Export failed:", error);
+	process.exit(1);
 });
-