electerm 3.2.0 → 3.3.1

package/npm/electerm

@@ -1,4 +1,100 @@
-#!/bin/bash
-cd `dirname $0`
-cd ..
-./lib/node_modules/electerm/electerm/electerm
+#!/usr/bin/env node
+/**
+ * electerm CLI launcher (cross-platform)
+ * After npm i -g electerm, the postinstall script downloads and installs the binary.
+ * This script simply finds and launches the installed binary.
+ *
+ * Binary locations:
+ *   macOS:   /Applications/electerm.app/Contents/MacOS/electerm
+ *   Windows: <package>/electerm/electerm.exe
+ *   Linux:   <package>/electerm/electerm
+ */
+
+const path = require('path')
+const fs = require('fs')
+const { spawn } = require('child_process')
+const os = require('os')
+
+const plat = os.platform()
+const packageRoot = path.resolve(__dirname, '..')
+
+/**
+ * Get the path to the installed electerm binary
+ */
+function getElectermExePath () {
+  // macOS: prefer the installed app in /Applications
+  if (plat === 'darwin') {
+    const appBinary = '/Applications/electerm.app/Contents/MacOS/electerm'
+    if (fs.existsSync(appBinary)) {
+      return appBinary
+    }
+    // Fallback: extracted folder
+    return path.join(packageRoot, 'electerm', 'electerm')
+  }
+
+  // Windows
+  if (plat === 'win32') {
+    return path.join(packageRoot, 'electerm', 'electerm.exe')
+  }
+
+  // Linux
+  return path.join(packageRoot, 'electerm', 'electerm')
+}
+
+/**
+ * Check if the electerm binary exists
+ */
+function isElectermInstalled () {
+  return fs.existsSync(getElectermExePath())
+}
+
+/**
+ * Launch the installed electerm binary
+ */
+function launchElecterm () {
+  const exePath = getElectermExePath()
+
+  if (!fs.existsSync(exePath)) {
+    console.error('Error: electerm binary not found at:', exePath)
+    console.error('')
+    console.error('The binary may not have been installed. Try running:')
+    console.error('  node', path.join(packageRoot, 'npm', 'install.js'))
+    process.exit(1)
+  }
+
+  // Spawn the binary, passing through all args
+  const child = spawn(exePath, process.argv.slice(2), {
+    stdio: 'inherit',
+    // On macOS/Linux, detach so the app survives if the terminal closes
+    detached: plat !== 'win32',
+    // On Windows, don't create a console window for the spawn
+    windowsHide: false
+  })
+
+  if (plat !== 'win32') {
+    child.unref()
+  }
+
+  child.on('error', (err) => {
+    console.error('Failed to start electerm:', err.message)
+    process.exit(1)
+  })
+
+  child.on('exit', (code) => {
+    process.exit(code || 0)
+  })
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+if (!isElectermInstalled()) {
+  console.error('electerm binary not found. It should have been installed during npm install.')
+  console.error('')
+  console.error('Try running manually:')
+  console.error('  node', path.join(packageRoot, 'npm', 'install.js'))
+  process.exit(1)
+}
+
+launchElecterm()

package/npm/install.js

@@ -1,28 +1,62 @@
 /**
  * install electerm from binary
+ * After npm i -g electerm, running `electerm` command will:
+ * 1. Download the appropriate binary for the platform
+ * 2. Extract it to the package directory (electerm/)
+ * 3. The bash script (npm/electerm) then launches the extracted binary
+ *
+ * This script only downloads and extracts. Launching is handled by the bash script.
  */
 
 const os = require('os')
-const { resolve } = require('path')
-const { exec, rm, mv } = require('shelljs')
-const rp = require('phin').promisified
-const download = require('download')
+const { resolve, join } = require('path')
+const { execSync, rm, mv } = require('shelljs')
+const { execFile } = require('child_process')
+const fs = require('fs')
+const { phin, download, extractTarGz, GITHUB_PROXY, applyProxy } = require('./utils')
+
 const plat = os.platform()
 const arch = os.arch()
 const { homepage } = require('../package.json')
+
 const releaseInfoUrl = `${homepage}/data/electerm-github-release.json?_=${+new Date()}`
 const versionUrl = `${homepage}/version.html?_=${+new Date()}`
 
-function down (url, extract = true) {
-  const local = resolve(__dirname, '../')
-  console.log('downloading ' + url)
-  return download(url, local, { extract }).then(() => {
-    console.log('done!')
-  })
+// Directory where electerm package is installed
+const packageRoot = resolve(__dirname, '..')
+// Directory where the extracted binary will live
+const extractDir = join(packageRoot, 'electerm')
+
+// ---------------------------------------------------------------------------
+// Security helpers
+// ---------------------------------------------------------------------------
+
+function sanitizeVersion (ver) {
+  const clean = String(ver).trim().replace(/^v/, '')
+  if (!/^\d+\.\d+\.\d+$/.test(clean)) {
+    throw new Error(
+      `Refusing to continue: remote version string failed validation: "${ver}"`
+    )
+  }
+  return clean
 }
 
+function sanitizeFilename (name) {
+  const clean = String(name).trim()
+  if (!/^[\w.-]+$/.test(clean)) {
+    throw new Error(
+      `Refusing to continue: remote filename failed validation: "${name}"`
+    )
+  }
+  return clean
+}
+
+// ---------------------------------------------------------------------------
+// Core helpers
+// ---------------------------------------------------------------------------
+
 function getVer () {
-  return rp({
+  return phin({
     url: versionUrl,
     timeout: 15000
   })
@@ -30,7 +64,7 @@ function getVer () {
 }
 
 function getReleaseInfo (filter) {
-  return rp({
+  return phin({
     url: releaseInfoUrl,
     timeout: 15000
   })
@@ -43,46 +77,42 @@ function getReleaseInfo (filter) {
 }
 
 function showFinalMessage () {
-  console.log('\n========================================')
+  console.log('')
+  console.log('========================================')
   console.log('electerm installation complete!')
   console.log('========================================')
-  console.log('\nFor more information, documentation, and updates, please visit:')
-  console.log('\x1b[36m%s\x1b[0m', 'https://electerm.html5beta.com')
-  console.log('\nThank you for using electerm!')
-  console.log('========================================\n')
+  console.log('')
+  console.log('For more information, documentation, and updates, please visit:')
+  console.log('https://electerm.html5beta.com')
+  console.log('')
+  console.log('Thank you for using electerm!')
+  console.log('========================================')
+  console.log('')
 }
 
-// Check if running on Windows 7 or earlier
+// ---------------------------------------------------------------------------
+// Platform detection helpers
+// ---------------------------------------------------------------------------
+
 function isWindows7OrEarlier (platform, release) {
   if (platform !== 'win32') return false
-  // Windows 7 is NT 6.1, Windows 8 is NT 6.2, Windows 10 is NT 10.0
   const [major, minor] = release.split('.').map(Number)
   return major < 10 && (major < 6 || (major === 6 && minor <= 1))
 }
 
-// Check if running on macOS 10.x (older than Big Sur 11.0)
 function isMacOS10 (platform, release) {
   if (platform !== 'darwin') return false
-  // Darwin kernel version: macOS 11 (Big Sur) = Darwin 20.x, macOS 10.15 = Darwin 19.x
   const majorVersion = parseInt(release.split('.')[0], 10)
   return majorVersion < 20
 }
 
-// Check if running on Linux with old glibc (< 2.34)
-function isLinuxLegacy (platform, glibcVersion) {
+function isLinuxLegacy (platform) {
   if (platform !== 'linux') return false
-  if (typeof glibcVersion === 'number') {
-    return glibcVersion < 2.34
-  }
   try {
-    const result = exec('ldd --version 2>&1 | head -n1', { silent: true })
-    if (result.code !== 0) return false
-    const output = result.stdout || ''
-    // Extract version number like "ldd (GNU libc) 2.31" or "ldd (Ubuntu GLIBC 2.35-0ubuntu3) 2.35"
-    const match = output.match(/(\d+\.\d+)\s*$/)
+    const result = execSync('ldd --version 2>&1 | head -n1', { encoding: 'utf8' })
+    const match = result.match(/(\d+\.\d+)\s*$/)
     if (match) {
-      const version = parseFloat(match[1])
-      return version < 2.34
+      return parseFloat(match[1]) < 2.34
     }
     return false
   } catch (e) {
@@ -90,186 +120,428 @@ function isLinuxLegacy (platform, glibcVersion) {
   }
 }
 
-// Get the file pattern for download based on platform/arch/legacy status
-function getDownloadPattern (platform, architecture, options = {}) {
-  const { win7, mac10, linuxLegacy } = options
+// ---------------------------------------------------------------------------
+// Launch the extracted binary
+// ---------------------------------------------------------------------------
 
-  if (platform === 'win32') {
-    if (win7) {
-      return { pattern: /electerm-\d+\.\d+\.\d+-win7\.tar\.gz$/, type: 'win7' }
-    } else if (architecture === 'arm64') {
-      return { pattern: /electerm-\d+\.\d+\.\d+-win-arm64\.tar\.gz$/, type: 'win-arm64' }
-    } else {
-      return { pattern: /electerm-\d+\.\d+\.\d+-win-x64\.tar\.gz$/, type: 'win-x64' }
-    }
-  } else if (platform === 'darwin') {
-    if (mac10) {
-      return { pattern: /mac10-x64\.dmg$/, type: 'mac10-x64' }
-    } else if (architecture === 'arm64') {
-      return { pattern: /mac-arm64\.dmg$/, type: 'mac-arm64' }
-    } else {
-      return { pattern: /mac-x64\.dmg$/, type: 'mac-x64' }
-    }
-  } else if (platform === 'linux') {
-    const suffix = linuxLegacy ? '-legacy' : ''
-    if (architecture === 'arm64') {
-      return { pattern: new RegExp(`linux-arm64${suffix}\\.tar\\.gz$`), type: `linux-arm64${suffix}` }
-    } else if (architecture === 'arm') {
-      return { pattern: new RegExp(`linux-armv7l${suffix}\\.tar\\.gz$`), type: `linux-armv7l${suffix}` }
-    } else {
-      return { pattern: new RegExp(`linux-x64${suffix}\\.tar\\.gz$`), type: `linux-x64${suffix}` }
-    }
+/**
+ * Get the path to the extracted electerm executable
+ */
+function getElectermExePath () {
+  if (plat === 'win32') {
+    return join(extractDir, 'electerm.exe')
   }
-  return { pattern: null, type: 'unsupported' }
+  // Linux and macOS (if extracted)
+  return join(extractDir, 'electerm')
 }
 
+/**
+ * Check if the electerm binary has been extracted already
+ */
+function isElectermExtracted () {
+  const exePath = getElectermExePath()
+  return fs.existsSync(exePath)
+}
+
+// ---------------------------------------------------------------------------
+// Platform installers
+// ---------------------------------------------------------------------------
+
 async function runLinux (folderName, filePattern) {
-  const ver = await getVer()
-  const target = resolve(__dirname, `../electerm-${ver.replace('v', '')}-${folderName}`)
-  const targetNew = resolve(__dirname, '../electerm')
-  exec(`rm -rf ${target} ${targetNew}`)
+  const rawVer = await getVer()
+  const ver = sanitizeVersion(rawVer)
+
+  console.log(`  Version: ${ver}`)
+  console.log(`  Target: ${folderName}`)
+
+  const target = join(packageRoot, `electerm-${ver}-${folderName}`)
+
+  // Clean up old installations
+  rm('-rf', [target, extractDir])
+
+  console.log('  Fetching release info...')
   const releaseInfo = await getReleaseInfo(r => r.name.includes(filePattern))
   if (!releaseInfo) {
     throw new Error(`No release found for pattern: ${filePattern}`)
   }
-  await down(releaseInfo.browser_download_url)
-  exec(`mv ${target} ${targetNew}`)
+
+  // Download without extracting to packageRoot directly
+  // We'll extract to a temp location first
+  const tmpDir = join(packageRoot, '.electerm-tmp')
+  rm('-rf', tmpDir)
+  fs.mkdirSync(tmpDir, { recursive: true })
+
+  const proxyUrl = applyProxy(releaseInfo.browser_download_url)
+  console.log(`  URL: ${proxyUrl}`)
+
+  const { filepath } = await download(releaseInfo.browser_download_url, tmpDir, { extract: false, displayName: releaseInfo.name })
+
+  // Extract to tmpDir (keeps top-level folder name)
+  await extractTarGz(filepath, tmpDir)
+
+  // Find the extracted folder (should be the only directory)
+  const entries = fs.readdirSync(tmpDir)
+  const extractedFolder = entries.find(e => fs.statSync(join(tmpDir, e)).isDirectory())
+
+  if (!extractedFolder) {
+    throw new Error('No folder found in extracted archive')
+  }
+
+  // Move to extractDir
+  console.log(`  Installing to: ${extractDir}`)
+  mv(join(tmpDir, extractedFolder), extractDir)
+
+  // Clean up temp files
+  rm('-rf', tmpDir)
+
   showFinalMessage()
-  exec('electerm')
 }
 
-async function runMac (archName) {
-  const pattern = new RegExp(`mac-${archName}\\.dmg$`)
+async function runWin (archName) {
+  const rawVer = await getVer()
+  const ver = sanitizeVersion(rawVer)
+
+  console.log(`  Version: ${ver}`)
+  console.log(`  Target: win-${archName}`)
+
+  const target = join(packageRoot, `electerm-${ver}-win-${archName}`)
+
+  rm('-rf', [target, extractDir])
+
+  const pattern = new RegExp(`electerm-\\d+\\.\\d+\\.\\d+-win-${archName}\\.tar\\.gz$`)
+  console.log('  Fetching release info...')
   const releaseInfo = await getReleaseInfo(r => pattern.test(r.name))
   if (!releaseInfo) {
-    throw new Error(`No release found for Mac ${archName}`)
+    throw new Error(`No release found for Windows ${archName}`)
+  }
+
+  // Extract to temp, then move
+  const tmpDir = join(packageRoot, '.electerm-tmp')
+  rm('-rf', tmpDir)
+  fs.mkdirSync(tmpDir, { recursive: true })
+
+  const proxyUrl = applyProxy(releaseInfo.browser_download_url)
+  console.log(`  URL: ${proxyUrl}`)
+
+  const { filepath } = await download(releaseInfo.browser_download_url, tmpDir, { extract: false, displayName: releaseInfo.name })
+
+  await extractTarGz(filepath, tmpDir)
+
+  const entries = fs.readdirSync(tmpDir)
+  const extractedFolder = entries.find(e => fs.statSync(join(tmpDir, e)).isDirectory())
+
+  if (!extractedFolder) {
+    throw new Error('No folder found in extracted archive')
   }
-  await down(releaseInfo.browser_download_url, false)
-  const target = resolve(__dirname, '../', releaseInfo.name)
+
+  console.log(`  Installing to: ${extractDir}`)
+  mv(join(tmpDir, extractedFolder), extractDir)
+  rm('-rf', tmpDir)
+
   showFinalMessage()
-  exec(`open ${target}`)
 }
 
-// macOS 10.x specific version
-async function runMac10 () {
-  const releaseInfo = await getReleaseInfo(r => /mac10-x64\.dmg$/.test(r.name))
+async function runWin7 () {
+  const rawVer = await getVer()
+  const ver = sanitizeVersion(rawVer)
+
+  console.log(`  Version: ${ver}`)
+  console.log('  Target: win7')
+
+  const target = join(packageRoot, `electerm-${ver}-win7`)
+
+  rm('-rf', [target, extractDir])
+
+  console.log('  Fetching release info...')
+  const releaseInfo = await getReleaseInfo(r => /electerm-\d+\.\d+\.\d+-win7\.tar\.gz$/.test(r.name))
   if (!releaseInfo) {
-    throw new Error('No release found for macOS 10.x')
+    throw new Error('No release found for Windows 7')
   }
-  await down(releaseInfo.browser_download_url, false)
-  const target = resolve(__dirname, '../', releaseInfo.name)
+
+  // Extract to temp, then move
+  const tmpDir = join(packageRoot, '.electerm-tmp')
+  rm('-rf', tmpDir)
+  fs.mkdirSync(tmpDir, { recursive: true })
+
+  const proxyUrl = applyProxy(releaseInfo.browser_download_url)
+  console.log(`  URL: ${proxyUrl}`)
+
+  const { filepath } = await download(releaseInfo.browser_download_url, tmpDir, { extract: false, displayName: releaseInfo.name })
+
+  await extractTarGz(filepath, tmpDir)
+
+  const entries = fs.readdirSync(tmpDir)
+  const extractedFolder = entries.find(e => fs.statSync(join(tmpDir, e)).isDirectory())
+
+  if (!extractedFolder) {
+    throw new Error('No folder found in extracted archive')
+  }
+
+  console.log(`  Installing to: ${extractDir}`)
+  mv(join(tmpDir, extractedFolder), extractDir)
+  rm('-rf', tmpDir)
+
   showFinalMessage()
-  exec(`open ${target}`)
 }
 
-async function runWin (archName) {
-  const ver = await getVer()
-  const target = resolve(__dirname, `../electerm-${ver.replace('v', '')}-win-${archName}`)
-  const targetNew = resolve(__dirname, '../electerm')
-  rm('-rf', [
-    target,
-    targetNew
-  ])
-  const pattern = new RegExp(`electerm-\\d+\\.\\d+\\.\\d+-win-${archName}\\.tar\\.gz$`)
+/**
+ * Mount a DMG, copy the .app to /Applications, then detach
+ * @param {string} dmgPath - Path to the DMG file
+ * @returns {Promise<string>} - Path to the installed app
+ */
+function installFromDmg (dmgPath) {
+  return new Promise((resolve, reject) => {
+    // Step 1: Mount the DMG
+    console.log('  Mounting DMG...')
+    execFile('hdiutil', ['attach', dmgPath, '-nobrowse', '-readonly'], (err, stdout) => {
+      if (err) {
+        reject(new Error(`Failed to mount DMG: ${err.message}`))
+        return
+      }
+
+      // Parse mount point
+      const mountMatch = stdout.match(/(\/Volumes\/[^\n]+)/)
+      if (!mountMatch) {
+        reject(new Error('Could not find mount point'))
+        return
+      }
+
+      const mountPoint = mountMatch[1].trim()
+      console.log(`  Mounted at: ${mountPoint}`)
+
+      // Step 2: Find the .app bundle
+      try {
+        const entries = fs.readdirSync(mountPoint)
+        const appFile = entries.find(e => e.endsWith('.app'))
+
+        if (!appFile) {
+          // Try to detach before rejecting
+          execFileSyncIgnore('hdiutil', ['detach', mountPoint])
+          reject(new Error('No .app bundle found in DMG'))
+          return
+        }
+
+        const appSource = join(mountPoint, appFile)
+        const appDest = `/Applications/${appFile}`
+
+        // Check if app already exists
+        if (fs.existsSync(appDest)) {
+          console.log(`  Existing app found at ${appDest}, replacing...`)
+          // Remove existing app
+          rm('-rf', appDest)
+        }
+
+        // Step 3: Copy the app to /Applications
+        console.log(`  Installing ${appFile} to /Applications...`)
+        execFile('cp', ['-R', appSource, appDest], (cpErr) => {
+          // Step 4: Detach the DMG (always, regardless of copy result)
+          console.log('  Detaching DMG...')
+          execFile('hdiutil', ['detach', mountPoint], (detachErr) => {
+            if (detachErr) {
+              console.log('  Warning: Failed to detach DMG:', detachErr.message)
+            } else {
+              console.log('  DMG detached')
+            }
+
+            if (cpErr) {
+              reject(new Error(`Failed to copy app: ${cpErr.message}`))
+              return
+            }
+
+            console.log(`  App installed to: ${appDest}`)
+            resolve(appDest)
+          })
+        })
+      } catch (e) {
+        // Try to detach before rejecting
+        execFileSyncIgnore('hdiutil', ['detach', mountPoint])
+        reject(e)
+      }
+    })
+  })
+}
+
+/**
+ * Execute a file synchronously, ignoring errors
+ */
+function execFileSyncIgnore (cmd, args) {
+  try {
+    execSync(cmd, args, { stdio: 'ignore' })
+  } catch (e) {
+    // Ignore
+  }
+}
+
+async function runMac (archName) {
+  const pattern = new RegExp(`mac-${archName}\\.dmg$`)
+  console.log('  Fetching release info...')
   const releaseInfo = await getReleaseInfo(r => pattern.test(r.name))
   if (!releaseInfo) {
-    throw new Error(`No release found for Windows ${archName}`)
+    throw new Error(`No release found for Mac ${archName}`)
   }
-  await down(releaseInfo.browser_download_url)
-  await mv(target, targetNew)
+
+  const safeName = sanitizeFilename(releaseInfo.name)
+  const proxyUrl = applyProxy(releaseInfo.browser_download_url)
+  console.log(`  URL: ${proxyUrl}`)
+
+  await download(releaseInfo.browser_download_url, packageRoot, { extract: false, displayName: releaseInfo.name })
+
+  const dmgPath = join(packageRoot, safeName)
   showFinalMessage()
-  require('child_process').execFile(`${targetNew}\\electerm.exe`)
+
+  // Install from DMG automatically
+  try {
+    await installFromDmg(dmgPath)
+
+    // Clean up DMG
+    try {
+      fs.unlinkSync(dmgPath)
+      console.log('  Cleaned up DMG file')
+    } catch (e) {
+      // Ignore cleanup errors
+    }
+
+    console.log('')
+    console.log('  Installation complete! You can now launch electerm from /Applications')
+  } catch (err) {
+    console.error('')
+    console.error('  Warning: Automatic installation failed:', err.message)
+    console.error('  Please manually copy the app from the DMG to /Applications')
+    console.error('')
+    console.log('  Opening DMG for manual installation...')
+    execFile('open', [dmgPath])
+  }
 }
 
-// Windows 7 specific version
-async function runWin7 () {
-  const ver = await getVer()
-  const target = resolve(__dirname, `../electerm-${ver.replace('v', '')}-win7`)
-  const targetNew = resolve(__dirname, '../electerm')
-  rm('-rf', [
-    target,
-    targetNew
-  ])
-  const releaseInfo = await getReleaseInfo(r => /electerm-\d+\.\d+\.\d+-win7\.tar\.gz$/.test(r.name))
+async function runMac10 () {
+  console.log('  Fetching release info...')
+  const releaseInfo = await getReleaseInfo(r => /mac10-x64\.dmg$/.test(r.name))
   if (!releaseInfo) {
-    throw new Error('No release found for Windows 7')
+    throw new Error('No release found for macOS 10.x')
   }
-  await down(releaseInfo.browser_download_url)
-  await mv(target, targetNew)
+
+  const safeName = sanitizeFilename(releaseInfo.name)
+  const proxyUrl = applyProxy(releaseInfo.browser_download_url)
+  console.log(`  URL: ${proxyUrl}`)
+
+  await download(releaseInfo.browser_download_url, packageRoot, { extract: false, displayName: releaseInfo.name })
+
+  const dmgPath = join(packageRoot, safeName)
   showFinalMessage()
-  require('child_process').execFile(`${targetNew}\\electerm.exe`)
+
+  // Install from DMG automatically
+  try {
+    await installFromDmg(dmgPath)
+
+    // Clean up DMG
+    try {
+      fs.unlinkSync(dmgPath)
+      console.log('  Cleaned up DMG file')
+    } catch (e) {
+      // Ignore cleanup errors
+    }
+
+    console.log('')
+    console.log('  Installation complete! You can now launch electerm from /Applications')
+  } catch (err) {
+    console.error('')
+    console.error('  Warning: Automatic installation failed:', err.message)
+    console.error('  Please manually copy the app from the DMG to /Applications')
+    console.error('')
+    console.log('  Opening DMG for manual installation...')
+    execFile('open', [dmgPath])
+  }
 }
 
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
 async function main () {
-  console.log(`Detected platform: ${plat}, architecture: ${arch}`)
+  console.log('')
+  console.log('========================================')
+  console.log('electerm binary installer')
+  console.log('========================================')
+  console.log(`Platform: ${plat}, Architecture: ${arch}`)
+
+  if (GITHUB_PROXY) {
+    console.log(`GitHub Proxy: ${GITHUB_PROXY}`)
+  }
+
+  console.log('')
 
   // Check for legacy systems
   const win7 = isWindows7OrEarlier(plat, os.release())
   const mac10 = isMacOS10(plat, os.release())
   const linuxLegacy = isLinuxLegacy(plat)
 
-  if (win7) console.log('Detected: Windows 7 or earlier')
-  if (mac10) console.log('Detected: macOS 10.x')
-  if (linuxLegacy) console.log('Detected: Linux with glibc < 2.34 (legacy)')
+  if (win7) console.log('  Detected: Windows 7 or earlier')
+  if (mac10) console.log('  Detected: macOS 10.x')
+  if (linuxLegacy) console.log('  Detected: Linux with glibc < 2.34 (legacy)')
 
-  console.log('Fetching release information...\n')
+  console.log('  Fetching release information...')
 
   try {
     if (plat === 'win32') {
-      // Windows: x64, arm64, win7
       if (win7) {
         await runWin7()
       } else if (arch === 'arm64') {
         await runWin('arm64')
       } else {
-        // Default to x64 for all other Windows architectures
         await runWin('x64')
       }
     } else if (plat === 'darwin') {
-      // macOS: x64, arm64, mac10
       if (mac10) {
         await runMac10()
       } else if (arch === 'arm64') {
         await runMac('arm64')
       } else {
-        // Default to x64 for Intel Macs
         await runMac('x64')
       }
     } else if (plat === 'linux') {
-      // Linux: x64, arm64, armv7l (with legacy variants)
       const suffix = linuxLegacy ? '-legacy' : ''
-      if (arch === 'arm64') {
+      if (arch === 'arm64' || arch === 'aarch64') {
         await runLinux(`linux-arm64${suffix}`, `linux-arm64${suffix}.tar.gz`)
       } else if (arch === 'arm') {
         await runLinux(`linux-armv7l${suffix}`, `linux-armv7l${suffix}.tar.gz`)
       } else {
-        // Default to x64 for all other Linux architectures
         await runLinux(`linux-x64${suffix}`, `linux-x64${suffix}.tar.gz`)
       }
     } else {
       throw new Error(`Platform "${plat}" is not supported.`)
     }
   } catch (err) {
-    console.error('\n========================================')
+    console.error('')
+    console.error('========================================')
     console.error('Installation failed!')
     console.error('========================================')
     console.error(`Error: ${err.message}`)
-    console.error(`\nPlatform: ${plat}, Architecture: ${arch}`)
-    console.error('\nPlease visit https://electerm.html5beta.com for manual download options.')
-    console.error('========================================\n')
+    console.error(`Platform: ${plat}, Architecture: ${arch}`)
+    console.error('')
+    console.error('Please visit https://electerm.html5beta.com for manual download options.')
+    console.error('========================================')
+    console.error('')
     process.exit(1)
   }
 }
 
-// Export functions for testing
+// ---------------------------------------------------------------------------
+// Exports for testing
+// ---------------------------------------------------------------------------
+
 module.exports = {
   isWindows7OrEarlier,
   isMacOS10,
   isLinuxLegacy,
-  getDownloadPattern
+  sanitizeVersion,
+  sanitizeFilename,
+  getElectermExePath,
+  isElectermExtracted,
+  // Expose for test injection
+  _packageRoot: packageRoot,
+  _extractDir: extractDir
 }
 
-// Run main only if this file is executed directly
 if (require.main === module) {
   main()
 }

package/npm/utils.js

@@ -0,0 +1,263 @@
+/**
+ * Utility functions for npm installer
+ * Replaces download and phin packages with native Node.js http/https and tar
+ * Supports Node.js 16+
+ * Supports GITHUB_PROXY environment variable for proxying GitHub URLs
+ */
+
+const https = require('https')
+const http = require('http')
+const fs = require('fs')
+const path = require('path')
+const tar = require('tar')
+
+// GitHub proxy support
+const GITHUB_PROXY = process.env.GITHUB_PROXY || ''
+
+/**
+ * Apply GitHub proxy to URLs if configured
+ * @param {string} url - Original URL
+ * @returns {string} - Proxy URL or original URL
+ */
+function applyProxy (url) {
+  if (!GITHUB_PROXY) return url
+  if (!url.includes('github.com')) return url
+
+  // Remove trailing slash from proxy if present
+  const proxy = GITHUB_PROXY.replace(/\/+$/, '')
+  // Ensure url has protocol
+  const urlWithProto = url.startsWith('http') ? url : `https://${url}`
+
+  return `${proxy}/${urlWithProto}`
+}
+
+/**
+ * Format bytes to human readable
+ */
+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]
+}
+
+/**
+ * Make an HTTP GET request and download to a file with progress
+ * @param {string} url - URL to fetch
+ * @param {string} filepath - Destination file path
+ * @param {number} timeout - Request timeout in milliseconds (default: 300000 = 5min)
+ * @param {function} onProgress - Progress callback (received, total, percent)
+ * @returns {Promise<string>} Path to downloaded file
+ */
+function httpDownload (url, filepath, timeout = 300000, onProgress) {
+  return new Promise((resolve, reject) => {
+    const client = url.startsWith('https') ? https : http
+
+    const req = client.get(url, { timeout }, (res) => {
+      // Handle redirects
+      if (res.statusCode === 301 || res.statusCode === 302 || res.statusCode === 307) {
+        if (res.headers.location) {
+          // Handle relative URLs
+          let redirectUrl = res.headers.location
+          if (!redirectUrl.startsWith('http://') && !redirectUrl.startsWith('https://')) {
+            const parsedUrl = new URL(url)
+            redirectUrl = `${parsedUrl.protocol}//${parsedUrl.host}${redirectUrl}`
+          }
+          resolve(httpDownload(redirectUrl, filepath, timeout, onProgress))
+          return
+        }
+      }
+
+      if (res.statusCode !== 200) {
+        reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage || 'Unknown error'}`))
+        return
+      }
+
+      const total = parseInt(res.headers['content-length'] || '0', 10)
+      let received = 0
+      let lastPercent = -1
+
+      const fileStream = fs.createWriteStream(filepath)
+
+      res.on('data', (chunk) => {
+        received += chunk.length
+        if (onProgress && total > 0) {
+          const percent = Math.round((received / total) * 100)
+          if (percent !== lastPercent) {
+            lastPercent = percent
+            onProgress(received, total, percent)
+          }
+        }
+      })
+
+      res.pipe(fileStream)
+      fileStream.on('finish', () => {
+        fileStream.close()
+        resolve(filepath)
+      })
+      fileStream.on('error', (err) => {
+        fs.unlink(filepath, () => {}) // Clean up partial download
+        reject(err)
+      })
+    })
+
+    req.on('error', reject)
+    req.on('timeout', () => {
+      req.destroy()
+      reject(new Error(`Request timeout after ${timeout}ms`))
+    })
+  })
+}
+
+/**
+ * Make an HTTP GET request and return response body as string
+ * @param {string} url - URL to fetch
+ * @param {number} timeout - Request timeout in milliseconds (default: 15000)
+ * @returns {Promise<string>} Response body as string
+ */
+function httpGet (url, timeout = 15000) {
+  return new Promise((resolve, reject) => {
+    const client = url.startsWith('https') ? https : http
+
+    const req = client.get(url, { timeout }, (res) => {
+      // Handle redirects
+      if (res.statusCode === 301 || res.statusCode === 302 || res.statusCode === 307) {
+        if (res.headers.location) {
+          // Handle relative URLs
+          let redirectUrl = res.headers.location
+          if (!redirectUrl.startsWith('http://') && !redirectUrl.startsWith('https://')) {
+            const parsedUrl = new URL(url)
+            redirectUrl = `${parsedUrl.protocol}//${parsedUrl.host}${redirectUrl}`
+          }
+          resolve(httpGet(redirectUrl, timeout))
+          return
+        }
+      }
+
+      if (res.statusCode !== 200) {
+        reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage || 'Unknown error'}`))
+        return
+      }
+
+      const chunks = []
+      res.on('data', (chunk) => chunks.push(chunk))
+      res.on('end', () => {
+        const buffer = Buffer.concat(chunks)
+        resolve(buffer.toString())
+      })
+      res.on('error', reject)
+    })
+
+    req.on('error', reject)
+    req.on('timeout', () => {
+      req.destroy()
+      reject(new Error(`Request timeout after ${timeout}ms`))
+    })
+  })
+}
+
+/**
+ * Extract a tar.gz file to destination directory
+ * @param {string} filepath - Path to tar.gz file
+ * @param {string} dest - Destination directory
+ * @param {number} strip - Number of leading path components to strip (default: 0)
+ * @returns {Promise<void>}
+ */
+function extractTarGz (filepath, dest, strip = 0) {
+  return tar.extract({
+    file: filepath,
+    cwd: dest,
+    strip
+  })
+}
+
+/**
+ * Download and optionally extract a file with progress
+ * @param {string} url - URL to download from
+ * @param {string} dest - Destination directory
+ * @param {object} options - Options
+ * @param {boolean} options.extract - Whether to extract the file (default: true)
+ * @param {string} options.displayName - Display name for progress output
+ * @returns {Promise<{filepath: string, extracted: boolean}>}
+ */
+async function download (url, dest, { extract: doExtract = true, displayName } = {}) {
+  // Ensure dest directory exists
+  if (!fs.existsSync(dest)) {
+    fs.mkdirSync(dest, { recursive: true })
+  }
+
+  // Extract filename from URL
+  const urlParts = url.split('/')
+  const filename = urlParts[urlParts.length - 1].split('?')[0] || 'download'
+  const filepath = path.join(dest, filename)
+
+  // Apply proxy if configured
+  const downloadUrl = applyProxy(url)
+
+  const label = displayName || filename
+  const proxyInfo = GITHUB_PROXY ? ' [via proxy]' : ''
+
+  console.log('')
+  console.log(`  Downloading: ${label}${proxyInfo}`)
+
+  let lastPercent = -1
+  await httpDownload(downloadUrl, filepath, 300000, (received, total, percent) => {
+    if (percent !== lastPercent && percent % 10 === 0) {
+      lastPercent = percent
+      const receivedStr = formatBytes(received)
+      const totalStr = formatBytes(total)
+      process.stdout.write(`  Progress: ${percent}% (${receivedStr} / ${totalStr})\n`)
+    }
+  })
+
+  console.log(`  Progress: 100% (${formatBytes(fs.statSync(filepath).size)})`)
+  console.log('  Download complete!')
+
+  let extracted = false
+  if (doExtract && (filepath.endsWith('.tar.gz') || filepath.endsWith('.tgz'))) {
+    console.log('  Extracting archive...')
+    await extractTarGz(filepath, dest)
+    // Clean up the downloaded archive
+    try {
+      fs.unlinkSync(filepath)
+    } catch (err) {
+      // Ignore cleanup errors
+    }
+    extracted = true
+    console.log('  Extraction complete!')
+  }
+
+  return { filepath, extracted }
+}
+
+/**
+ * Phin replacement - simple promisified HTTP client
+ * @param {object} options - Request options
+ * @param {string} options.url - URL to fetch
+ * @param {number} options.timeout - Request timeout (default: 15000)
+ * @returns {Promise<{body: Buffer, statusCode: number, headers: object}>}
+ */
+async function phin (options) {
+  const { url, timeout = 15000 } = options
+  const body = await httpGet(url, timeout)
+
+  return {
+    body: Buffer.from(body),
+    statusCode: 200,
+    headers: {}
+  }
+}
+
+phin.promisified = phin
+
+module.exports = {
+  httpGet,
+  httpDownload,
+  extractTarGz,
+  download,
+  phin,
+  applyProxy,
+  formatBytes,
+  GITHUB_PROXY
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "electerm",
-  "version": "3.2.0",
+  "version": "3.3.1",
   "description": "Terminal/ssh/telnet/serialport/sftp client(linux, mac, win)",
   "main": "app.js",
   "bin": "npm/electerm",
@@ -28,8 +28,7 @@
   "preferGlobal": true,
   "dependencies": {
     "shelljs": "*",
-    "phin": "*",
-    "download": "*"
+    "tar": "*"
   },
   "files": [
     "npm",