Merge pull request #17 from F4RAN/fix/issue-16-windows-binary-download

F4RAN · web-flow · commit 1508f4d07d07 · 2025-12-07T01:21:48.000+03:30
Fix/issue 16 windows binary download
diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "cuimp",
-  "version": "1.4.1",
+  "version": "1.5.0",
   "description": "Node wrapper for curl-impersonate (lexiforest) via CLI - Enhanced with raw buffer support and extra curl args",
   "keywords": [
     "cuimp",
@@ -68,7 +68,6 @@
     "vitest": "^2.1.8"
   },
   "dependencies": {
-    "cuimp": "^1.1.2",
     "tar": "^7.4.3"
   }
 }
diff --git a/src/helpers/parser.ts b/src/helpers/parser.ts
@@ -63,12 +63,22 @@ const BINARY_SEARCH_PATHS = [
 ]
 
 // Binary name patterns to search for
+// Windows binaries can be .exe or .bat files
 const BINARY_PATTERNS = [
     'curl-impersonate',
     'curl-impersonate.exe',
+    'curl-impersonate.bat',
+    'curl_chrome*.exe',
+    'curl_chrome*.bat',
     'curl_chrome*',
+    'curl_firefox*.exe',
+    'curl_firefox*.bat',
     'curl_firefox*',
+    'curl_edge*.exe',
+    'curl_edge*.bat',
     'curl_edge*',
+    'curl_safari*.exe',
+    'curl_safari*.bat',
     'curl_safari*',
 ]
 
@@ -135,8 +145,16 @@ const findExistingBinary = (browser: string = ''): string | null => {
     const packageDir = getPackageDir()
     const packageBinariesDir = path.resolve(packageDir, 'cuimp/binaries')
 
-    // Create search paths including both directories
-    const searchPaths = [homeBinariesDir, packageBinariesDir, ...BINARY_SEARCH_PATHS]
+    // On Windows, binaries are extracted to a 'bin' subdirectory
+    // Create search paths including both directories and Windows-specific bin subdirectory
+    const isWindows = process.platform === 'win32'
+    const searchPaths = [
+        homeBinariesDir,
+        ...(isWindows ? [path.resolve(homeBinariesDir, 'bin')] : []),
+        packageBinariesDir,
+        ...(isWindows ? [path.resolve(packageBinariesDir, 'bin')] : []),
+        ...BINARY_SEARCH_PATHS
+    ]
 
     for (const searchPath of searchPaths) {
         for (const pattern of patternsToSearch) {
@@ -211,6 +229,10 @@ const downloadAndExtractBinary = async (
             // macos uses specific naming: x86_64-macos, arm64-macos, etc.
             const macosArch = architecture === 'x64' ? 'x86_64' : 'arm64'
             assetName = `curl-impersonate-${latestVersion}.${macosArch}-macos.tar.gz`
+        } else if (platform === 'windows') {
+            // Windows uses libcurl-impersonate prefix and win32 suffix: x86_64-win32, arm64-win32, etc.
+            const windowsArch = architecture === 'x64' ? 'x86_64' : 'arm64'
+            assetName = `libcurl-impersonate-${latestVersion}.${windowsArch}-win32.tar.gz`
         } else {
             // Other platforms use the original naming
             assetName = `curl-impersonate-${latestVersion}.${architecture}-${platform}.tar.gz`
@@ -251,45 +273,95 @@ const downloadAndExtractBinary = async (
         // Clean up temporary file
         fs.unlinkSync(tempFileName)
         
-        // Find the extracted binary file in the binaries directory
-        // The main binary is usually named 'curl-impersonate'
-        const mainBinaryName = 'curl-impersonate'
-        const binaryPath = path.resolve(binariesDir, mainBinaryName)
+        // On Windows, binaries are extracted to a 'bin' subdirectory
+        // On other platforms, they're extracted directly to binariesDir
+        const searchDirs = platform === 'windows' 
+            ? [path.resolve(binariesDir, 'bin'), binariesDir]
+            : [binariesDir]
         
-        // Check if the main binary was extracted
-        if (!fs.existsSync(binaryPath)) {
-            // If main binary not found, look for browser-specific binaries
-            const browserSpecificPattern = `curl_${browser}*`
-            const files = fs.readdirSync(binariesDir)
-            const matchingFiles = files.filter(file => {
-                const regex = new RegExp(browserSpecificPattern.replace('*', '.*'))
-                return regex.test(file)
-            })
+        // Binary name patterns to search for (Windows uses .exe or .bat extension)
+        const binaryExtensions = platform === 'windows' ? ['.exe', '.bat', ''] : ['']
+        const mainBinaryNames = binaryExtensions.map(ext => `curl-impersonate${ext}`)
+        const browserSpecificPattern = `curl_${browser}*`
+        
+        let binaryPath: string | null = null
+        
+        // First, try to find the main binary (curl-impersonate)
+        for (const searchDir of searchDirs) {
+            if (!fs.existsSync(searchDir)) continue
             
-            if (matchingFiles.length > 0) {
-                // Use the highest version browser-specific binary
-                const sortedFiles = matchingFiles.sort((a, b) => {
-                    const versionA = extractVersionNumber(a)
-                    const versionB = extractVersionNumber(b)
-                    return versionB - versionA // Sort in descending order (highest first)
-                })
-                const bestMatch = sortedFiles[0]
-                const browserBinaryPath = path.resolve(binariesDir, bestMatch)
+            for (const mainBinaryName of mainBinaryNames) {
+                const candidatePath = path.resolve(searchDir, mainBinaryName)
+                if (fs.existsSync(candidatePath) && fs.statSync(candidatePath).isFile()) {
+                    binaryPath = candidatePath
+                    break
+                }
+            }
+            if (binaryPath) break
+        }
+        
+        // If main binary not found, look for browser-specific binaries
+        if (!binaryPath) {
+            for (const searchDir of searchDirs) {
+                if (!fs.existsSync(searchDir)) continue
                 
-                // Set executable permissions on the browser-specific binary
-                fs.chmodSync(browserBinaryPath, 0o755)
+                const files = fs.readdirSync(searchDir)
+                const matchingFiles = files.filter(file => {
+                    const regex = new RegExp(browserSpecificPattern.replace('*', '.*'))
+                    return regex.test(file) && fs.statSync(path.resolve(searchDir, file)).isFile()
+                })
                 
-                return {
-                    binaryPath: browserBinaryPath,
-                    version: actualVersion
+                if (matchingFiles.length > 0) {
+                    // Use the highest version browser-specific binary
+                    const sortedFiles = matchingFiles.sort((a, b) => {
+                        const versionA = extractVersionNumber(a)
+                        const versionB = extractVersionNumber(b)
+                        return versionB - versionA // Sort in descending order (highest first)
+                    })
+                    const bestMatch = sortedFiles[0]
+                    binaryPath = path.resolve(searchDir, bestMatch)
+                    break
                 }
             }
-            
-            throw new Error(`Binary not found after extraction. Expected: ${binaryPath}`)
         }
         
-        // Set executable permissions on the main binary
-        fs.chmodSync(binaryPath, 0o755)
+        if (!binaryPath) {
+            throw new Error(
+                `Binary not found after extraction. Searched in: ${searchDirs.join(', ')}. ` +
+                `Expected: curl-impersonate${platform === 'windows' ? '.exe' : ''} or curl_${browser}*`
+            )
+        }
+        
+        // Set executable permissions on the binary (chmod may not work on Windows, but it's safe to try)
+        try {
+            fs.chmodSync(binaryPath, 0o755)
+        } catch (error) {
+            // On Windows, chmod might fail, but that's okay - the file is still executable
+            if (platform !== 'windows') {
+                throw error
+            }
+        }
+        
+        // On Windows, download CA bundle if not present (required for SSL verification)
+        if (platform === 'windows') {
+            const binDir = path.dirname(binaryPath)
+            const caBundlePath = path.join(binDir, 'curl-ca-bundle.crt')
+            if (!fs.existsSync(caBundlePath)) {
+                logger.info('Downloading CA certificate bundle for Windows...')
+                try {
+                    const caResponse = await fetch('https://curl.se/ca/cacert.pem')
+                    if (caResponse.ok) {
+                        const caBundle = await caResponse.text()
+                        fs.writeFileSync(caBundlePath, caBundle)
+                        logger.info(`CA bundle saved to ${caBundlePath}`)
+                    } else {
+                        logger.warn('Failed to download CA bundle - SSL verification may fail')
+                    }
+                } catch (caError) {
+                    logger.warn(`Failed to download CA bundle: ${caError instanceof Error ? caError.message : String(caError)}`)
+                }
+            }
+        }
         
         return {
             binaryPath: binaryPath,
@@ -356,21 +428,18 @@ export const parseDescriptor = async (descriptor: CuimpDescriptor, logger: Logge
         if (!forceDownload) {
             const existingBinary = findExistingBinary(browser)
             if (existingBinary) {
-                const existingVersion = extractVersionNumber(path.basename(existingBinary)).toString()
-
-                // For 'latest', accept any existing binary
-                // For specific version, check if it matches
-                const versionMatches = version === 'latest' || existingVersion === version
+                // Extract browser version from filename (e.g., curl_chrome136 -> 136)
+                // Note: This is the browser version, not the curl-impersonate release version
+                const browserVersion = extractVersionNumber(path.basename(existingBinary)).toString()
 
-                if (versionMatches) {
-                    logger.info(`Found existing binary: ${existingBinary}`)
-                    return {
-                        binaryPath: existingBinary,
-                        isDownloaded: false,
-                        version: existingVersion || 'unknown'
-                    }
-                } else {
-                    logger.warn(`Found binary version ${existingVersion}, but version ${version} was requested. Re-downloading...`)
+                // Accept any existing binary for the requested browser
+                // The 'version' field in descriptor refers to curl-impersonate release version,
+                // which we can't easily determine from the cached binary filename
+                logger.info(`Found existing binary: ${existingBinary}`)
+                return {
+                    binaryPath: existingBinary,
+                    isDownloaded: false,
+                    version: browserVersion || 'unknown'
                 }
             }
         } else {
diff --git a/src/runner.ts b/src/runner.ts
@@ -1,5 +1,7 @@
 import { spawn } from 'node:child_process';
 import { RunResult } from './types/runTypes';
+import path from 'node:path';
+import fs from 'node:fs';
 
 
 
@@ -9,7 +11,40 @@ export function runBinary(
   opts?: { timeout?: number; signal?: AbortSignal }
 ): Promise<RunResult> {
   return new Promise((resolve, reject) => {
-    const child = spawn(binPath, args, { stdio: ['ignore', 'pipe', 'pipe'] });
+    // On Windows, .bat files need shell: true to execute properly
+    const isWindows = process.platform === 'win32';
+    const isBatFile = binPath.toLowerCase().endsWith('.bat');
+    const needsShell = isWindows && isBatFile;
+    
+    // On Windows, add --cacert argument if CA bundle exists and not already specified
+    // This fixes SSL certificate verification issues
+    let finalArgs = args;
+    if (isWindows && !args.includes('--cacert') && !args.includes('-k')) {
+      const binDir = path.dirname(binPath);
+      const caBundlePath = path.join(binDir, 'curl-ca-bundle.crt');
+      if (fs.existsSync(caBundlePath)) {
+        // Prepend --cacert to args so it's processed before the URL
+        finalArgs = ['--cacert', caBundlePath, ...args];
+      }
+    }
+    
+    // When using shell: true on Windows, we need to properly quote arguments
+    // to prevent & and other shell metacharacters from being interpreted
+    if (needsShell) {
+      finalArgs = finalArgs.map(arg => {
+        // If arg contains shell metacharacters, wrap in double quotes
+        // and escape any existing double quotes
+        if (/[&|<>^"\s]/.test(arg)) {
+          return `"${arg.replace(/"/g, '\\"')}"`;
+        }
+        return arg;
+      });
+    }
+    
+    const child = spawn(binPath, finalArgs, { 
+      stdio: ['ignore', 'pipe', 'pipe'],
+      shell: needsShell
+    });
 
     let killedByTimeout = false;
     let t: NodeJS.Timeout | undefined;
diff --git a/test/unit/parser.test.ts b/test/unit/parser.test.ts
@@ -68,17 +68,32 @@ describe('parseDescriptor', () => {
       ok: true,
       arrayBuffer: () => Promise.resolve(new ArrayBuffer(0))
     })
+    
+    // Default: directories don't exist, so readdirSync throws (simulating real behavior)
+    mockFs.readdirSync.mockImplementation(() => {
+      throw new Error('ENOENT: no such file or directory')
+    })
+    
+    // Default: files don't exist
+    mockFs.existsSync.mockReturnValue(false)
   })
 
   afterEach(() => {
     vi.restoreAllMocks()
   })
 
   it('should always download binary (force download)', async () => {
-    mockFs.existsSync.mockReturnValue(false)
+    // Mock: binary exists after extraction, binaries directory exists
+    mockFs.existsSync.mockImplementation((path: string) => {
+      // Return true for binaries directory and binary path check after extraction
+      if (typeof path === 'string' && (path.includes('.cuimp/binaries') || path.includes('curl-impersonate'))) {
+        return true
+      }
+      return false
+    })
     mockGetLatestRelease.mockResolvedValue('v1.0.0')
 
-    const descriptor: CuimpDescriptor = { browser: 'chrome' }
+    const descriptor: CuimpDescriptor = { browser: 'chrome', forceDownload: true }
     const result = await parseDescriptor(descriptor)
 
     expect(mockGetLatestRelease).toHaveBeenCalled()
@@ -87,7 +102,14 @@ describe('parseDescriptor', () => {
   })
 
   it('should download binary if not found locally', async () => {
-    mockFs.existsSync.mockReturnValue(false)
+    // Mock: binary exists after extraction, binaries directory exists
+    mockFs.existsSync.mockImplementation((path: string) => {
+      // Return true for binaries directory and binary path check after extraction
+      if (typeof path === 'string' && (path.includes('.cuimp/binaries') || path.includes('curl-impersonate'))) {
+        return true
+      }
+      return false
+    })
     mockGetLatestRelease.mockResolvedValue('v1.0.0')
 
     const descriptor: CuimpDescriptor = { 
@@ -104,7 +126,14 @@ describe('parseDescriptor', () => {
   })
 
   it('should handle empty descriptor', async () => {
-    mockFs.existsSync.mockReturnValue(false)
+    // Mock: binary exists after extraction, binaries directory exists
+    mockFs.existsSync.mockImplementation((path: string) => {
+      // Return true for binaries directory and binary path check after extraction
+      if (typeof path === 'string' && (path.includes('.cuimp/binaries') || path.includes('curl-impersonate'))) {
+        return true
+      }
+      return false
+    })
     mockGetLatestRelease.mockResolvedValue('v1.0.0')
     
     const descriptor: CuimpDescriptor = {}
@@ -115,7 +144,14 @@ describe('parseDescriptor', () => {
   })
 
   it('should handle partial descriptor', async () => {
-    mockFs.existsSync.mockReturnValue(false)
+    // Mock: binary exists after extraction, binaries directory exists
+    mockFs.existsSync.mockImplementation((path: string) => {
+      // Return true for binaries directory and binary path check after extraction
+      if (typeof path === 'string' && (path.includes('.cuimp/binaries') || path.includes('curl-impersonate'))) {
+        return true
+      }
+      return false
+    })
     mockGetLatestRelease.mockResolvedValue('v1.0.0')
 
     const descriptor: CuimpDescriptor = { browser: 'chrome' }
@@ -170,14 +206,27 @@ describe('parseDescriptor', () => {
   it('should handle missing assets in release', async () => {
     mockFs.existsSync.mockReturnValue(false)
     mockGetLatestRelease.mockResolvedValue('v1.0.0')
+    // Mock fetch to return 404
+    mockFetch.mockResolvedValue({
+      ok: false,
+      status: 404,
+      statusText: 'Not Found'
+    })
 
     const descriptor: CuimpDescriptor = { browser: 'chrome' }
     
     await expect(parseDescriptor(descriptor)).rejects.toThrow()
   })
 
   it('should handle multiple assets and select correct one', async () => {
-    mockFs.existsSync.mockReturnValue(false)
+    // Mock: binary exists after extraction, binaries directory exists
+    mockFs.existsSync.mockImplementation((path: string) => {
+      // Return true for binaries directory and binary path check after extraction
+      if (typeof path === 'string' && (path.includes('.cuimp/binaries') || path.includes('curl-impersonate'))) {
+        return true
+      }
+      return false
+    })
     mockGetLatestRelease.mockResolvedValue('v1.0.0')
 
     const descriptor: CuimpDescriptor = { 

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`	`2`	`"name": "cuimp",`
`3`		`- "version": "1.4.1",`
	`3`	`+ "version": "1.5.0",`
`4`	`4`	`"description": "Node wrapper for curl-impersonate (lexiforest) via CLI - Enhanced with raw buffer support and extra curl args",`
`5`	`5`	`"keywords": [`
`6`	`6`	`"cuimp",`
`@@ -68,7 +68,6 @@`
`68`	`68`	`"vitest": "^2.1.8"`
`69`	`69`	`},`
`70`	`70`	`"dependencies": {`
`71`		`- "cuimp": "^1.1.2",`
`72`	`71`	`"tar": "^7.4.3"`
`73`	`72`	`}`
`74`	`73`	`}`