node-nim 10.9.71-beta.87 → 10.9.71

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-nim",
-    "version": "10.9.71-beta.87",
+    "version": "10.9.71",
     "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",
-        "postinstall": "node script/download-sdk.js",
-        "download_sdk": "node script/download-sdk.js",
+        "install": "npm run download_sdk",
+        "download_sdk": "node -e \"require('./script/download-sdk.js').downloadSDK()\"",
         "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,10 +33,10 @@
         ]
     },
     "dependencies": {
-        "axios": "^1.6.2",
         "compare-versions": "^4.1.4",
-        "decompress": "^4.2.1",
-        "eventemitter3": "^4.0.7"
+        "download": "^8.0.0",
+        "eventemitter3": "^4.0.7",
+        "node-fetch": "^2.6.9"
     },
     "devDependencies": {
         "@babel/preset-env": "^7.24.0",

package/script/download-sdk.js

@@ -1,8 +1,8 @@
-const axios = require('axios')
+const fetch = require('node-fetch')
 const fs = require('fs')
 const path = require('path')
 const compareVersions = require('compare-versions')
-const decompress = require('decompress')
+const download = require('download')
 
 // Global variables
 const default_arch = 'universal'
@@ -14,136 +14,56 @@ const product = 'nim'
 const savePath = path.join(__dirname, '..', 'temporary')
 
 if (process.env.npm_config_ignoredownloadsdk) {
-    console.log('[node-nim] Ignore download product')
+    console.log('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]
 }
 if (process.env.npm_config_nimsdkversion) {
     version = process.env.npm_config_nimsdkversion
 }
-
-// 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)
-}
-
-// 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`)
-        }
-    }
-}
-
-// 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]
-}
-
-// Download and extract function using axios + decompress
-async function downloadAndExtract(url, destination) {
-    if (!fs.existsSync(destination)) {
-        fs.mkdirSync(destination, { recursive: true })
+async function downloadSDK(custom_sdk_url) {
+    if (custom_sdk_url) {
+        downloadUrl = custom_sdk_url
     }
-    // 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)
-                }
+    // 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
+                    }
+                })
             }
-        })
-        // 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 (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
+                    }
+                })
             }
         })
-        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)
+        if (!downloadUrl || downloadUrl.length === 0) {
+            console.log(`[node-nim] Product [${product}] version ${version} not found, use latest version ${latestVersion}`)
+            downloadUrl = latestDownloadUrl
         }
-        throw error
+        console.log(`[node-nim] Downloading product: ${product}, platform: ${platform}, arch: ${arch}`)
     }
-}
-async function downloadSDK(customPackageUrl) {
-    // Use custom URL if provided, otherwise fetch from official server
-    let downloadUrl = customPackageUrl
     if (!downloadUrl) {
-        // 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.error(`[node-nim] Downloading product: ${product}, platform: ${platform}, arch: ${arch} not found`)
+        return
     }
+    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)) {
@@ -154,7 +74,12 @@ async function downloadSDK(customPackageUrl) {
     }
     // download sdk
     try {
-        await downloadAndExtract(downloadUrl, savePath)
+        await download(downloadUrl, savePath, {
+            extract: true,
+            filter: (file) => {
+                return !file.path.includes('._')
+            }
+        })
         // create build/Release folder
         if (!fs.existsSync(target)) {
             fs.mkdirSync(target, { recursive: true })
@@ -163,217 +88,20 @@ async function downloadSDK(customPackageUrl) {
         const from = path.join(savePath, platform === 'win32' ? 'bin' : 'lib')
         const files = fs.readdirSync(from)
         files.forEach((file) => {
-            log(` 📁 Installing ${file}`)
+            console.info(`[node-nim] move ${file} to ${target}`)
             fs.renameSync(path.join(from, file), path.join(target, file))
         })
         // remove temporary download folder
         fs.rmSync(savePath, { recursive: true })
-        log(` ✅ Package installation complete!`)
+        console.info(`[node-nim] Downloading prebuilt SDK complete`)
     } catch (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
+        console.error(`[node-nim] Failed to download, error: ${err}`)
     }
-    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 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)
-        }
-    })()
+    const downloadUrlIndex = args.indexOf('--nimSdkUrl');
+    const url = downloadUrlIndex !== -1 ? args[downloadUrlIndex + 1] : '';
+    downloadSDK(url)
 }
 exports.downloadSDK = downloadSDK