node-nim 10.9.71-beta.69 → 10.9.71-beta.87

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-nim",
-    "version": "10.9.71-beta.69",
+    "version": "10.9.71-beta.87",
     "description": "NetEase IM nodejs wrapper based on NetEase IM C++ SDK",
     "main": "dist/node-nim.js",
     "bin": {
@@ -20,8 +20,8 @@
         "build_ts": "rimraf ./dist && rimraf ./types && tsc",
         "build_html_doc": "typedoc --plugin typedoc-github-theme",
         "prepublishOnly": "npm run build_ts",
-        "install": "npm run download_sdk",
-        "download_sdk": "node -e \"require('./script/download-sdk.js').downloadSDK()\"",
+        "postinstall": "node script/download-sdk.js",
+        "download_sdk": "node script/download-sdk.js",
         "publish_to_netease_npm": "node script/publish-to-netease-npm.js http://npm.netease.im/",
         "publish_to_npmjs": "node script/publish-to-netease-npm.js https://registry.npmjs.org",
         "test": "npx cross-env BABEL_ENV=test mocha"
@@ -33,11 +33,10 @@
         ]
     },
     "dependencies": {
-        "eventemitter3": "^4.0.7",
+        "axios": "^1.6.2",
         "compare-versions": "^4.1.4",
-        "node-fetch": "^2.6.9",
-        "yauzl": "^2.10.0",
-        "tar": "^6.2.0"
+        "decompress": "^4.2.1",
+        "eventemitter3": "^4.0.7"
     },
     "devDependencies": {
         "@babel/preset-env": "^7.24.0",

package/script/download-sdk.js

@@ -1,12 +1,8 @@
-const fetch = require('node-fetch')
+const axios = require('axios')
 const fs = require('fs')
 const path = require('path')
 const compareVersions = require('compare-versions')
-const yauzl = require('yauzl')
-const tar = require('tar')
-const { pipeline } = require('stream')
-const { promisify } = require('util')
-const pipelineAsync = promisify(pipeline)
+const decompress = require('decompress')
 
 // Global variables
 const default_arch = 'universal'
@@ -18,11 +14,10 @@ const product = 'nim'
 const savePath = path.join(__dirname, '..', 'temporary')
 
 if (process.env.npm_config_ignoredownloadsdk) {
-    console.log('ignore download product')
+    console.log('[node-nim] Ignore download product')
     process.exit(0)
 }
 let version
-let downloadUrl = process.env.npm_config_nimsdkurl
 if (process.env.npm_package_version) {
     version = process.env.npm_package_version.split('-')[0]
 }
@@ -30,155 +25,125 @@ if (process.env.npm_config_nimsdkversion) {
     version = process.env.npm_config_nimsdkversion
 }
 
-// Download and extract function to replace the 'download' package
-async function downloadAndExtract(url, destination) {
-    if (!fs.existsSync(destination)) {
-        fs.mkdirSync(destination, { recursive: true })
-    }
-
-    // Download the file
-    const response = await fetch(url)
-    if (!response.ok) {
-        throw new Error(`Failed to download: ${response.statusText}`)
-    }
-
-    // Determine file type from URL
-    const isZip = url.toLowerCase().includes('.zip')
-    const isTarGz = url.toLowerCase().includes('.tar.gz') || url.toLowerCase().includes('.tgz')
-
-    let archivePath
-    let fileExtension
-
-    if (isZip) {
-        fileExtension = '.zip'
-        archivePath = path.join(destination, 'temp.zip')
-    } else if (isTarGz) {
-        fileExtension = '.tar.gz'
-        archivePath = path.join(destination, 'temp.tar.gz')
-    } else {
-        // Default to zip if we can't determine the type
-        fileExtension = '.zip'
-        archivePath = path.join(destination, 'temp.zip')
-        console.warn('[node-nim] Could not determine archive type from URL, assuming ZIP format')
-    }
-
-    // Save the downloaded file
-    const writeStream = fs.createWriteStream(archivePath)
-    await pipelineAsync(response.body, writeStream)
+// Simple logger that works with npm postinstall
+// Use console.error to ensure output is visible when installed as dependency
+// npm captures stdout but is less aggressive with stderr
+function log(message) {
+    console.error(message)
+}
 
-    // Extract based on file type
-    if (isTarGz) {
-        await extractTarGz(archivePath, destination)
-    } else {
-        await extractZip(archivePath, destination)
+// Progress bar utility - real-time progress bar
+function createProgressBar(total) {
+    let lastUpdate = 0
+    const updateInterval = 100 // Update every 100ms
+    return (loaded) => {
+        const now = Date.now()
+        const percent = Math.floor((loaded * 100) / total)
+        // Update based on time interval or when complete
+        if (now - lastUpdate < updateInterval && loaded < total) {
+            return
+        }
+        lastUpdate = now
+        const size = formatBytes(loaded)
+        const totalSize = formatBytes(total)
+        // Create progress bar
+        const barLength = 30
+        const filledLength = Math.floor((barLength * loaded) / total)
+        const bar = '█'.repeat(filledLength) + '░'.repeat(barLength - filledLength)
+        // Use \r to overwrite the same line
+        process.stderr.write(`\r[node-nim] ⬇  ${bar} ${percent}% (${size}/${totalSize})`)
+        // Print newline when complete
+        if (loaded >= total) {
+            process.stderr.write('\n')
+            log(` ✅ Download complete`)
+        }
     }
-
-    // Clean up the temporary archive file
-    fs.unlinkSync(archivePath)
 }
 
-// Extract ZIP files
-async function extractZip(zipPath, destination) {
-    return new Promise((resolve, reject) => {
-        yauzl.open(zipPath, { lazyEntries: true }, (err, zipfile) => {
-            if (err) return reject(err)
-
-            zipfile.readEntry()
-            zipfile.on('entry', (entry) => {
-                // Filter out macOS hidden files (._files)
-                if (entry.fileName.includes('._')) {
-                    zipfile.readEntry()
-                    return
-                }
-
-                if (/\/$/.test(entry.fileName)) {
-                    // Directory entry
-                    const dirPath = path.join(destination, entry.fileName)
-                    fs.mkdirSync(dirPath, { recursive: true })
-                    zipfile.readEntry()
-                } else {
-                    // File entry
-                    zipfile.openReadStream(entry, (err, readStream) => {
-                        if (err) return reject(err)
-
-                        const filePath = path.join(destination, entry.fileName)
-                        const fileDir = path.dirname(filePath)
-
-                        if (!fs.existsSync(fileDir)) {
-                            fs.mkdirSync(fileDir, { recursive: true })
-                        }
-
-                        const writeStream = fs.createWriteStream(filePath)
-                        readStream.pipe(writeStream)
-
-                        writeStream.on('close', () => {
-                            zipfile.readEntry()
-                        })
-
-                        writeStream.on('error', reject)
-                    })
-                }
-            })
-
-            zipfile.on('end', () => {
-                resolve()
-            })
-
-            zipfile.on('error', reject)
-        })
-    })
+// Format bytes to human readable format
+function formatBytes(bytes) {
+    if (bytes === 0) return '0 B'
+    const k = 1024
+    const sizes = ['B', 'KB', 'MB', 'GB']
+    const i = Math.floor(Math.log(bytes) / Math.log(k))
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + ' ' + sizes[i]
 }
 
-// Extract TAR.GZ files
-async function extractTarGz(tarPath, destination) {
-    return tar.extract({
-        file: tarPath,
-        cwd: destination,
-        filter: (path, entry) => {
-            // Filter out macOS hidden files (._files)
-            return !path.includes('/._') && !path.startsWith('._')
-        }
-    })
-}
-async function downloadSDK(custom_sdk_url) {
-    if (custom_sdk_url) {
-        downloadUrl = custom_sdk_url
+// Download and extract function using axios + decompress
+async function downloadAndExtract(url, destination) {
+    if (!fs.existsSync(destination)) {
+        fs.mkdirSync(destination, { recursive: true })
     }
-    // fetch publish list
-    const res = await fetch('https://admin.netease.im/public-service/free/publish/list')
-    const publish_json = await res.json()
-    // get sdk list
-    if (!downloadUrl) {
-        let latestVersion = '0.0.0'
-        let latestDownloadUrl = ''
-        Object.keys(publish_json.data[channel]).forEach((temp) => {
-            if (compareVersions.compare(latestVersion, temp, '<')) {
-                publish_json.data[channel][temp].forEach((member) => {
-                    if (member.filename.includes(product) && member.filename.includes(platform) && member.filename.includes(arch)) {
-                        latestVersion = temp
-                        latestDownloadUrl = member.cdnlink
-                    }
-                })
+    // Determine archive file name from URL
+    const urlPath = new URL(url).pathname
+    const fileName = path.basename(urlPath) || 'temp-archive'
+    const archivePath = path.join(destination, fileName)
+    log(` 📥 Starting download...`)
+    try {
+        // Download with progress tracking
+        const response = await axios({
+            method: 'GET',
+            url: url,
+            responseType: 'stream',
+            timeout: 300000, // 5 minutes timeout
+            onDownloadProgress: (progressEvent) => {
+                if (progressEvent.total) {
+                    const progressBar = createProgressBar(progressEvent.total)
+                    progressBar(progressEvent.loaded)
+                }
             }
-            if (version === temp) {
-                publish_json.data[channel][temp].forEach((member) => {
-                    if (member.filename.includes(product) && member.filename.includes(platform) && member.filename.includes(arch)) {
-                        downloadUrl = member.cdnlink
-                    }
-                })
+        })
+        // Save the downloaded file
+        const writeStream = fs.createWriteStream(archivePath)
+        response.data.pipe(writeStream)
+        // Wait for download to complete
+        await new Promise((resolve, reject) => {
+            writeStream.on('finish', resolve)
+            writeStream.on('error', reject)
+            response.data.on('error', reject)
+        })
+        log(` 📦 Extracting archive...`)
+        // Extract using decompress (auto-detects format)
+        await decompress(archivePath, destination, {
+            filter: (file) => {
+                // Filter out macOS hidden files (._files) and __MACOSX folders
+                const filePath = file.path
+                return !filePath.includes('._') &&
+                    !filePath.includes('__MACOSX') &&
+                    !filePath.startsWith('._')
+            },
+            map: (file) => {
+                // Remove any leading directory if needed
+                file.path = file.path.replace(/^[^\/]+\//, '')
+                return file
             }
         })
-        if (!downloadUrl || downloadUrl.length === 0) {
-            console.log(`[node-nim] Product [${product}] version ${version} not found, use latest version ${latestVersion}`)
-            downloadUrl = latestDownloadUrl
+        log(` ✅ Extraction complete`)
+        // Clean up the temporary archive file
+        fs.unlinkSync(archivePath)
+    } catch (error) {
+        // Clean up on error
+        if (fs.existsSync(archivePath)) {
+            fs.unlinkSync(archivePath)
         }
-        console.log(`[node-nim] Downloading product: ${product}, platform: ${platform}, arch: ${arch}`)
+        throw error
     }
+}
+async function downloadSDK(customPackageUrl) {
+    // Use custom URL if provided, otherwise fetch from official server
+    let downloadUrl = customPackageUrl
     if (!downloadUrl) {
-        console.error(`[node-nim] Downloading product: ${product}, platform: ${platform}, arch: ${arch} not found`)
-        return
+        // Fetch package list from official server
+        const res = await axios.get('https://admin.netease.im/public-service/free/publish/list')
+        const publishData = res.data.data[channel]
+        // Find package URL for specified version or latest
+        downloadUrl = findPackageUrl(publishData, version, platform, arch, product)
+        if (!downloadUrl) {
+            log(` ❌ ERROR: Package not found for ${platform} (${arch})`)
+            return
+        }
+        log(` 🚀 Preparing to download package for ${platform} (${arch})`)
     }
-    console.info(`[node-nim] Downloading prebuilt SDK from ${downloadUrl} to ${savePath}`)
     // remove temporary download folder and target folder
     const target = path.join(__dirname, '..', 'build', 'Release')
     if (fs.existsSync(savePath)) {
@@ -190,7 +155,6 @@ async function downloadSDK(custom_sdk_url) {
     // download sdk
     try {
         await downloadAndExtract(downloadUrl, savePath)
-
         // create build/Release folder
         if (!fs.existsSync(target)) {
             fs.mkdirSync(target, { recursive: true })
@@ -199,20 +163,217 @@ async function downloadSDK(custom_sdk_url) {
         const from = path.join(savePath, platform === 'win32' ? 'bin' : 'lib')
         const files = fs.readdirSync(from)
         files.forEach((file) => {
-            console.info(`[node-nim] move ${file} to ${target}`)
+            log(` 📁 Installing ${file}`)
             fs.renameSync(path.join(from, file), path.join(target, file))
         })
         // remove temporary download folder
         fs.rmSync(savePath, { recursive: true })
-        console.info(`[node-nim] Downloading prebuilt SDK complete`)
+        log(` ✅ Package installation complete!`)
     } catch (err) {
-        console.error(`[node-nim] Failed to download, error: ${err}`)
+        log(` ❌ ERROR: ${err.message}`)
+        throw err
+    }
+}
+// Helper function to find package download URL from publish data
+function findPackageUrl(publishData, targetVersion, platform, arch, product) {
+    let latestVersion = '0.0.0'
+    let latestDownloadUrl = ''
+    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)
+    }
+    // Iterate through all versions
+    Object.keys(publishData).forEach((versionKey) => {
+        const versionSDKs = publishData[versionKey]
+        // Track latest version
+        if (compareVersions.compare(latestVersion, versionKey, '<')) {
+            const latestPackage = versionSDKs.find(isMatchingPackage)
+            if (latestPackage) {
+                latestVersion = versionKey
+                latestDownloadUrl = latestPackage.cdnlink
+            }
+        }
+        // Find target version
+        if (targetVersion === versionKey) {
+            const targetPackage = versionSDKs.find(isMatchingPackage)
+            if (targetPackage) {
+                targetDownloadUrl = targetPackage.cdnlink
+            }
+        }
+    })
+    // Use target version if found, otherwise fallback to latest
+    if (targetDownloadUrl) {
+        return targetDownloadUrl
+    }
+    if (latestDownloadUrl) {
+        log(` ⚠️  Version ${targetVersion} not found, using latest version ${latestVersion}`)
+        return latestDownloadUrl
+    }
+    return null
+}
+
+// Parse directory listing from HTTP server
+async function parseDirectoryListing(url) {
+    try {
+        const response = await axios.get(url)
+        const html = response.data
+        // Extract directory/file names from href attributes
+        // Matches patterns like: href="dirname/" or href="filename.tar.gz"
+        const hrefRegex = /href="([^"]+)"/g
+        const items = []
+        let match
+        while ((match = hrefRegex.exec(html)) !== null) {
+            const item = match[1]
+            // Skip parent directory and absolute URLs
+            if (item !== '../' && !item.startsWith('http') && !item.startsWith('/')) {
+                items.push(item)
+            }
+        }
+        return items
+    } catch (error) {
+        throw new Error(`Failed to parse directory listing from ${url}: ${error.message}`)
+    }
+}
+
+// Find latest build number from directory listing
+async function findLatestBuild(baseUrl, branch) {
+    const branchUrl = `${baseUrl}/${branch}/`
+    log(` 🔍 Searching for latest build in ${branchUrl}`)
+    const items = await parseDirectoryListing(branchUrl)
+    // Filter directories (end with /) and extract build numbers
+    const buildNumbers = items
+        .filter(item => item.endsWith('/'))
+        .map(item => parseInt(item.replace('/', '')))
+        .filter(num => !isNaN(num))
+        .sort((a, b) => b - a) // Sort in descending order
+
+    if (buildNumbers.length === 0) {
+        throw new Error(`No build directories found in ${branchUrl}`)
     }
+    // Return all build numbers sorted by latest first
+    return buildNumbers
 }
+
+// Find latest build that contains the requested platform package
+async function findLatestBuildWithPackage(baseUrl, branch, nodePlatform, nodeArch) {
+    const buildNumbers = await findLatestBuild(baseUrl, branch)
+
+    // Try builds from latest to oldest
+    for (const buildNumber of buildNumbers) {
+        try {
+            const buildUrl = `${baseUrl}/${branch}/${buildNumber}/`
+            log(` 🔍 Checking build ${buildNumber} for ${nodePlatform}-${nodeArch} package...`)
+
+            // Try to find package in this build
+            const packageUrl = await findPackage(buildUrl, nodePlatform, nodeArch)
+            log(` ✅ Found package in build ${buildNumber}`)
+            return { buildNumber, packageUrl }
+        } catch (error) {
+            log(` ⚠️  Build ${buildNumber} does not contain ${nodePlatform}-${nodeArch} package, trying previous build...`)
+            // Continue to next build
+        }
+    }
+
+    throw new Error(`No build found with ${nodePlatform}-${nodeArch} package for branch ${branch}`)
+}
+
+// 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'
+    }
+    return `${platform}-${arch}/`
+}
+
+// Find package from directory listing
+async function findPackage(buildUrl, nodePlatform, nodeArch) {
+    const platformArchDir = getPlatformArchDir(nodePlatform, nodeArch)
+    const fullUrl = `${buildUrl}${platformArchDir}`
+    log(` 🔍 Searching for package in ${fullUrl}`)
+    const items = await parseDirectoryListing(fullUrl)
+    // Filter tar.gz files and exclude symbol files
+    const packageFiles = items.filter(item => {
+        if (!item.endsWith('.tar.gz') && !item.endsWith('.zip')) {
+            return false
+        }
+        // Exclude symbol files based on platform
+        if (nodePlatform === 'darwin' && item.includes('-dSYM')) {
+            return false
+        }
+        if (nodePlatform === 'win32' && item.includes('-PDB')) {
+            return false
+        }
+        if (nodePlatform === 'linux' && item.includes('-with-symbol')) {
+            return false
+        }
+        // Must start with nim- prefix
+        return item.startsWith('nim-')
+    })
+    if (packageFiles.length === 0) {
+        throw new Error(`No package found in ${fullUrl}`)
+    }
+    // If multiple files, prefer the first one (they should be the same package, just different compression)
+    const packageFile = packageFiles[0]
+    log(` ✅ Found package: ${packageFile}`)
+    return `${fullUrl}${packageFile}`
+}
+
+// Build package URL from branch name
+async function buildPackageUrlFromBranch(branch, nodePlatform, nodeArch) {
+    // Base64 encoded internal server URL (decode when needed)
+    const encodedBaseUrl = 'aHR0cDovLzEwLjIxOS4yNS4xMjc6ODgvSU0tTmF0aXZlL0Rlc2t0b3A='
+    const baseUrl = Buffer.from(encodedBaseUrl, 'base64').toString('utf-8')
+    log(` 🌿 Resolving package URL for branch: ${branch}`)
+
+    // Find latest build that contains the requested platform package
+    // This will automatically fallback to previous builds if the latest doesn't have the package
+    const { buildNumber, packageUrl } = await findLatestBuildWithPackage(baseUrl, branch, nodePlatform, nodeArch)
+
+    return packageUrl
+}
+
 if (require.main === module) {
     const args = process.argv
-    const downloadUrlIndex = args.indexOf('--nimSdkUrl');
-    const url = downloadUrlIndex !== -1 ? args[downloadUrlIndex + 1] : '';
-    downloadSDK(url)
+    const urlIndex = args.indexOf('--nimSdkUrl')
+    const branchIndex = args.indexOf('--branch')
+    ;(async () => {
+        try {
+            let url
+            let downloadUrl = process.env.npm_config_nimsdkurl
+            let branch = process.env.npm_config_branch
+
+            // 优先使用环境变量，然后才是命令行参数
+            if (branch || (branchIndex !== -1 && args[branchIndex + 1])) {
+                // Build URL from branch name
+                branch = branch || args[branchIndex + 1]
+                url = await buildPackageUrlFromBranch(branch, platform, process.arch)
+            } else if (downloadUrl || (urlIndex !== -1 && args[urlIndex + 1])) {
+                // Use provided URL directly
+                url = downloadUrl || args[urlIndex + 1]
+                // If URL is a directory path (ends with /), find the package
+                if (url.endsWith('/')) {
+                    url = await findPackage(url, platform, arch)
+                }
+            }
+            // Pass undefined to downloadSDK when no custom URL is provided
+            // This allows it to fetch the latest package from admin.netease.im
+            await downloadSDK(url)
+        } catch (error) {
+            log(` ❌ ERROR: ${error.message}`)
+            process.exit(1)
+        }
+    })()
 }
 exports.downloadSDK = downloadSDK