node-nim 10.9.71-beta.87 → 10.9.72

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-nim",
-    "version": "10.9.71-beta.87",
+    "version": "10.9.72",
     "description": "NetEase IM nodejs wrapper based on NetEase IM C++ SDK",
     "main": "dist/node-nim.js",
     "bin": {

package/script/download-sdk.js

@@ -69,6 +69,72 @@ function formatBytes(bytes) {
     return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + ' ' + sizes[i]
 }
 
+// Compatibility function for removing directories (supports older Node.js versions)
+function removeDirectory(dirPath) {
+    if (!fs.existsSync(dirPath)) {
+        return
+    }
+
+    // Use rmSync if available (Node.js >= 14.14.0)
+    if (fs.rmSync) {
+        fs.rmSync(dirPath, { recursive: true, force: true })
+        return
+    }
+
+    // Fallback for older Node.js versions using rimraf-like logic
+    const rimraf = (path) => {
+        const stat = fs.lstatSync(path)
+
+        if (stat.isDirectory()) {
+            // Read directory contents
+            const files = fs.readdirSync(path)
+
+            // Recursively remove all contents
+            files.forEach(file => {
+                const fullPath = require('path').join(path, file)
+                rimraf(fullPath)
+            })
+
+            // Remove the empty directory
+            fs.rmdirSync(path)
+        } else {
+            // Remove file
+            // Handle readonly files on Windows
+            try {
+                fs.unlinkSync(path)
+            } catch (err) {
+                if (err.code === 'EBUSY' || err.code === 'ENOTEMPTY' || err.code === 'EPERM') {
+                    // Try to change permissions and retry
+                    try {
+                        fs.chmodSync(path, 0o666)
+                        fs.unlinkSync(path)
+                    } catch (retryErr) {
+                        // If still fails, just log and continue
+                        console.warn(`Warning: Could not remove file ${path}: ${retryErr.message}`)
+                    }
+                } else {
+                    throw err
+                }
+            }
+        }
+    }
+
+    try {
+        rimraf(dirPath)
+    } catch (err) {
+        // If rmSync and rimraf both fail, try the legacy recursive option
+        if (fs.rmdirSync && typeof fs.rmdirSync === 'function') {
+            try {
+                fs.rmdirSync(dirPath, { recursive: true })
+            } catch (legacyErr) {
+                console.warn(`Warning: Could not remove directory ${dirPath}: ${legacyErr.message}`)
+            }
+        } else {
+            console.warn(`Warning: Could not remove directory ${dirPath}: ${err.message}`)
+        }
+    }
+}
+
 // Download and extract function using axios + decompress
 async function downloadAndExtract(url, destination) {
     if (!fs.existsSync(destination)) {
@@ -112,11 +178,8 @@ async function downloadAndExtract(url, destination) {
                     !filePath.includes('__MACOSX') &&
                     !filePath.startsWith('._')
             },
-            map: (file) => {
-                // Remove any leading directory if needed
-                file.path = file.path.replace(/^[^\/]+\//, '')
-                return file
-            }
+            // Remove the map function to preserve original directory structure
+            // This keeps the complete directory hierarchy from the archive
         })
         log(` ✅ Extraction complete`)
         // Clean up the temporary archive file
@@ -146,12 +209,8 @@ async function downloadSDK(customPackageUrl) {
     }
     // remove temporary download folder and target folder
     const target = path.join(__dirname, '..', 'build', 'Release')
-    if (fs.existsSync(savePath)) {
-        fs.rmSync(savePath, { recursive: true })
-    }
-    if (fs.existsSync(target)) {
-        fs.rmSync(target, { recursive: true })
-    }
+    removeDirectory(savePath)
+    removeDirectory(target)
     // download sdk
     try {
         await downloadAndExtract(downloadUrl, savePath)
@@ -159,15 +218,80 @@ async function downloadSDK(customPackageUrl) {
         if (!fs.existsSync(target)) {
             fs.mkdirSync(target, { recursive: true })
         }
-        // move sdk/* files to build/Release
-        const from = path.join(savePath, platform === 'win32' ? 'bin' : 'lib')
-        const files = fs.readdirSync(from)
+        // Debug: List all extracted contents
+        log(` 🔍 Extracted contents in ${savePath}:`)
+        const extractedItems = fs.readdirSync(savePath)
+        extractedItems.forEach(item => {
+            const itemPath = path.join(savePath, item)
+            const isDir = fs.statSync(itemPath).isDirectory()
+            log(`   ${isDir ? '📁' : '📄'} ${item}`)
+        })
+
+        // Find the package directory (should be the first directory that contains bin/lib)
+        const expectedSubDir = platform === 'win32' ? 'bin' : 'lib'
+        let packageDir = null
+        let libraryDir = null
+
+        // Look for the main package directory
+        for (const item of extractedItems) {
+            const itemPath = path.join(savePath, item)
+            if (fs.statSync(itemPath).isDirectory()) {
+                const subDirPath = path.join(itemPath, expectedSubDir)
+                if (fs.existsSync(subDirPath)) {
+                    packageDir = itemPath
+                    libraryDir = subDirPath
+                    log(` ✅ Found package directory: ${item}`)
+                    log(` ✅ Found library directory: ${item}/${expectedSubDir}`)
+                    break
+                }
+            }
+        }
+
+        // Fallback: look for library files in any subdirectory
+        if (!libraryDir) {
+            log(` ⚠️  Standard package structure not found, searching for library files...`)
+
+            const searchForLibraryFiles = (searchPath, relativePath = '') => {
+                const items = fs.readdirSync(searchPath)
+                for (const item of items) {
+                    const fullPath = path.join(searchPath, item)
+                    const stat = fs.statSync(fullPath)
+
+                    if (stat.isDirectory()) {
+                        // Recursively search subdirectories
+                        const found = searchForLibraryFiles(fullPath, path.join(relativePath, item))
+                        if (found) return found
+                    } else {
+                        // Check if this directory contains library files
+                        if (item.endsWith('.node')) {
+                            return searchPath
+                        }
+                    }
+                }
+                return null
+            }
+
+            libraryDir = searchForLibraryFiles(savePath)
+            if (libraryDir) {
+                log(` ✅ Found library files in: ${path.relative(savePath, libraryDir)}`)
+            }
+        }
+
+        if (!libraryDir) {
+            throw new Error(`No library files found in extracted archive. Expected structure: packageDir/${expectedSubDir}/`)
+        }
+
+        // Install files from the found directory
+        const files = fs.readdirSync(libraryDir)
         files.forEach((file) => {
-            log(` 📁 Installing ${file}`)
-            fs.renameSync(path.join(from, file), path.join(target, file))
+            const filePath = path.join(libraryDir, file)
+            if (fs.statSync(filePath).isFile()) {
+                log(` 📁 Installing ${file}`)
+                fs.renameSync(filePath, path.join(target, file))
+            }
         })
         // remove temporary download folder
-        fs.rmSync(savePath, { recursive: true })
+        removeDirectory(savePath)
         log(` ✅ Package installation complete!`)
     } catch (err) {
         log(` ❌ ERROR: ${err.message}`)
@@ -181,9 +305,14 @@ function findPackageUrl(publishData, targetVersion, platform, arch, product) {
     let targetDownloadUrl = ''
     // Check if package matches current platform/arch
     const isMatchingPackage = (member) => {
-        return member.filename.includes(product) &&
-               member.filename.includes(platform) &&
-               member.filename.includes(arch)
+        const basicMatch = member.filename.includes(product) &&
+                          member.filename.includes(platform) &&
+                          member.filename.includes(arch)
+        // For win32 platform, also require 'multi-threaded' keyword
+        if (platform === 'win32') {
+            return basicMatch && member.filename.includes('multi-threaded')
+        }
+        return basicMatch
     }
     // Iterate through all versions
     Object.keys(publishData).forEach((versionKey) => {
@@ -282,19 +411,14 @@ async function findLatestBuildWithPackage(baseUrl, branch, nodePlatform, nodeArc
 
 // Map Node.js platform/arch to SDK directory format
 function getPlatformArchDir(nodePlatform, nodeArch) {
-    // darwin-arm64, darwin-x64, win32-ia32, linux-arm64, linux-x64
-    let platform = nodePlatform
-    let arch = nodeArch
-    // Map Node.js arch to package arch format
-    if (nodePlatform === 'darwin') {
-        arch = nodeArch === 'arm64' ? 'arm64' : 'x64'
-    } else if (nodePlatform === 'win32') {
-        platform = 'win32'
-        arch = nodeArch === 'ia32' ? 'ia32' : nodeArch === 'x64' ? 'x64' : nodeArch
-    } else if (nodePlatform === 'linux') {
-        arch = nodeArch === 'arm64' ? 'arm64' : 'x64'
+    // Normalize arch - default to x64 if not arm64
+    const arch = nodeArch === 'arm64' ? 'arm64' : (nodeArch === 'ia32' ? 'ia32' : 'x64')
+    // For win32, include multi-threaded suffix
+    if (nodePlatform === 'win32') {
+        return `win32-${arch}-multi-threaded/`
     }
-    return `${platform}-${arch}/`
+    // For other platforms (darwin, linux)
+    return `${nodePlatform}-${arch}/`
 }
 
 // Find package from directory listing