@backendsystems/nibble 0.3.1 → 0.4.1

package/bin/install.js

@@ -1,211 +1,120 @@
 #!/usr/bin/env node
 
+const https = require('https');
 const fs = require('fs');
 const os = require('os');
 const path = require('path');
-const https = require('https');
 const crypto = require('crypto');
-const { spawnSync } = require('child_process');
+const tar = require('tar');
 
 const PROJECT = 'nibble';
 const OWNER = 'backendsystems';
-const REPO = 'nibble';
 const ROOT = path.resolve(__dirname, '..');
 const VENDOR_DIR = path.join(ROOT, 'vendor');
-const PACKAGE_JSON = require(path.join(ROOT, 'package.json'));
-
-function mapPlatform() {
-  const platformMap = {
-    linux: 'linux',
-    darwin: 'darwin',
-    win32: 'windows',
-  };
-
-  const archMap = {
-    x64: 'amd64',
-    arm64: 'arm64',
-  };
-
-  const osName = platformMap[process.platform];
-  const arch = archMap[process.arch];
-  if (!osName || !arch) {
-    throw new Error(`unsupported platform: ${process.platform}/${process.arch}`);
-  }
+const { version } = require(path.join(ROOT, 'package.json'));
 
-  return { osName, arch };
-}
+const platformMap = { linux: 'linux', darwin: 'darwin', win32: 'windows' };
+const archMap = { x64: 'amd64', arm64: 'arm64' };
 
-function download(url, outFile) {
-  return new Promise((resolve, reject) => {
-    const req = https.get(url, (res) => {
-      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
-        res.resume();
-        return resolve(download(res.headers.location, outFile));
-      }
-
-      if (res.statusCode !== 200) {
-        res.resume();
-        return reject(new Error(`download failed (${res.statusCode}): ${url}`));
-      }
-
-      const file = fs.createWriteStream(outFile);
-      res.pipe(file);
-      file.on('finish', () => file.close(() => resolve()));
-      file.on('error', reject);
-    });
-    req.on('error', reject);
-  });
+const osPlatform = platformMap[process.platform];
+const osArch = archMap[process.arch];
+
+if (!osPlatform || !osArch) {
+  console.error(`Unsupported platform: ${process.platform}/${process.arch}`);
+  process.exit(1);
 }
 
-function downloadText(url) {
+const tag = `v${version}`;
+const base = `https://github.com/${OWNER}/${PROJECT}/releases/download/${tag}`;
+const archiveName = `${PROJECT}_${osPlatform}_${osArch}.tar.gz`;
+const binName = process.platform === 'win32' ? `${PROJECT}.exe` : PROJECT;
+const destPath = path.join(VENDOR_DIR, binName);
+
+function download(url, dest) {
   return new Promise((resolve, reject) => {
-    const req = https.get(url, (res) => {
-      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
-        res.resume();
-        return resolve(downloadText(res.headers.location));
-      }
-
-      if (res.statusCode !== 200) {
-        res.resume();
-        return reject(new Error(`download failed (${res.statusCode}): ${url}`));
-      }
-
-      let data = '';
-      res.setEncoding('utf8');
-      res.on('data', (chunk) => {
-        data += chunk;
-      });
-      res.on('end', () => resolve(data));
-      res.on('error', reject);
-    });
-    req.on('error', reject);
+    const file = fs.createWriteStream(dest);
+    function get(url) {
+      https.get(url, (res) => {
+        if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+          return get(res.headers.location);
+        }
+        if (res.statusCode !== 200) {
+          return reject(new Error(`HTTP ${res.statusCode} downloading ${url}`));
+        }
+        res.pipe(file);
+        file.on('finish', () => file.close(resolve));
+        file.on('error', reject);
+      }).on('error', reject);
+    }
+    get(url);
   });
 }
 
-function parseChecksums(text) {
-  const checksums = new Map();
-  for (const line of text.split(/\r?\n/)) {
-    const trimmed = line.trim();
-    if (!trimmed || trimmed.startsWith('#')) {
-      continue;
-    }
-
-    const match = trimmed.match(/^([a-fA-F0-9]{64})\s+\*?(.+)$/);
-    if (!match) {
-      continue;
+function fetch(url) {
+  return new Promise((resolve, reject) => {
+    function get(url) {
+      https.get(url, (res) => {
+        if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
+          return get(res.headers.location);
+        }
+        if (res.statusCode !== 200) {
+          return reject(new Error(`HTTP ${res.statusCode} fetching ${url}`));
+        }
+        const chunks = [];
+        res.on('data', c => chunks.push(c));
+        res.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
+        res.on('error', reject);
+      }).on('error', reject);
     }
-    checksums.set(match[2].trim(), match[1].toLowerCase());
-  }
-  return checksums;
+    get(url);
+  });
 }
 
 function sha256File(filePath) {
-  const hash = crypto.createHash('sha256');
-  hash.update(fs.readFileSync(filePath));
-  return hash.digest('hex');
-}
-
-async function verifyArchiveChecksum(urlBase, archivePath, archiveName, version) {
-  const checksumCandidates = [
-    'checksums.txt',
-    `${PROJECT}_${version}_checksums.txt`,
-  ];
-
-  let checksumFile = '';
-  let checksumName = '';
-  for (const candidate of checksumCandidates) {
-    try {
-      checksumFile = await downloadText(`${urlBase}/${candidate}`);
-      checksumName = candidate;
-      break;
-    } catch (err) {
-      if (!String(err.message).includes('download failed (404)')) {
-        throw err;
-      }
-    }
-  }
-
-  if (!checksumFile) {
-    throw new Error(`no checksum file found (tried: ${checksumCandidates.join(', ')})`);
-  }
-
-  const checksums = parseChecksums(checksumFile);
-  const expected = checksums.get(archiveName);
-  if (!expected) {
-    throw new Error(`checksum for ${archiveName} not found in ${checksumName}`);
-  }
-
-  const actual = sha256File(archivePath);
-  if (actual !== expected) {
-    throw new Error(`checksum mismatch for ${archiveName}`);
-  }
+  return new Promise((resolve, reject) => {
+    const hash = crypto.createHash('sha256');
+    fs.createReadStream(filePath)
+      .on('data', d => hash.update(d))
+      .on('end', () => resolve(hash.digest('hex')))
+      .on('error', reject);
+  });
 }
 
-function run(cmd, args) {
-  const result = spawnSync(cmd, args, { stdio: 'inherit' });
-  if (result.status !== 0) {
-    throw new Error(`command failed: ${cmd} ${args.join(' ')}`);
+function parseChecksum(checksumsTxt, filename) {
+  for (const line of checksumsTxt.split('\n')) {
+    const [hash, name] = line.trim().split(/\s+/);
+    if (name === filename) return hash;
   }
+  return null;
 }
 
-function installFromArchive(archivePath, osName) {
+async function main() {
+  console.log(`Installing ${PROJECT} ${version} for ${osPlatform}/${osArch}...`);
   fs.mkdirSync(VENDOR_DIR, { recursive: true });
 
-  const binName = osName === 'windows' ? `${PROJECT}.exe` : PROJECT;
-  const destBinary = path.join(VENDOR_DIR, binName);
-
-  if (archivePath.endsWith('.zip')) {
-    if (process.platform === 'win32') {
-      run('powershell', [
-        '-NoProfile',
-        '-Command',
-        `Expand-Archive -Path \"${archivePath}\" -DestinationPath \"${VENDOR_DIR}\" -Force`,
-      ]);
-    } else {
-      run('unzip', ['-o', archivePath, '-d', VENDOR_DIR]);
-    }
-  } else {
-    run('tar', ['-xzf', archivePath, '-C', VENDOR_DIR]);
+  const checksumsTxt = await fetch(`${base}/checksums.txt`);
+  const expectedHash = parseChecksum(checksumsTxt, archiveName);
+  if (!expectedHash) {
+    throw new Error(`No checksum found for ${archiveName} in checksums.txt`);
   }
 
-  if (!fs.existsSync(destBinary)) {
-    throw new Error(`binary not found after extraction: ${destBinary}`);
-  }
-
-  if (process.platform !== 'win32') {
-    fs.chmodSync(destBinary, 0o755);
-  }
-}
+  const tmpFile = path.join(os.tmpdir(), archiveName);
+  try {
+    await download(`${base}/${archiveName}`, tmpFile);
 
-async function main() {
-  const { osName, arch } = mapPlatform();
-  const pkgVersion = PACKAGE_JSON.version.replace(/^v/, '');
-  const tag = `v${pkgVersion}`;
-  const assetBase = `${PROJECT}_${osName}_${arch}`;
-  const ext = 'tar.gz';
-  const asset = `${assetBase}.${ext}`;
-  const urlBase = `https://github.com/${OWNER}/${REPO}/releases/download/${tag}`;
-  const url = `${urlBase}/${asset}`;
-
-  const cacheDir = fs.mkdtempSync(path.join(os.tmpdir(), 'nibble-npm-'));
-  const archivePath = path.join(cacheDir, asset);
+    const actualHash = await sha256File(tmpFile);
+    if (actualHash !== expectedHash) {
+      throw new Error(`Checksum mismatch for ${archiveName}: expected ${expectedHash}, got ${actualHash}`);
+    }
 
-  try {
-    console.log(`Downloading ${asset} from ${url}`);
-    await download(url, archivePath);
-    await verifyArchiveChecksum(urlBase, archivePath, asset, pkgVersion);
-    installFromArchive(archivePath, osName);
-    console.log('Installed nibble binary successfully');
+    await tar.extract({ file: tmpFile, cwd: VENDOR_DIR, filter: p => p === binName });
+    console.log(`Installed ${PROJECT} to ${destPath}`);
   } finally {
-    if (fs.rmSync) {
-      fs.rmSync(cacheDir, { recursive: true, force: true });
-    } else {
-      fs.rmdirSync(cacheDir, { recursive: true });
-    }
+    try { fs.unlinkSync(tmpFile); } catch {}
   }
 }
 
 main().catch((err) => {
-  console.error(`nibble install failed: ${err.message}`);
+  console.error(`${PROJECT} install failed: ${err.message}`);
   process.exit(1);
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@backendsystems/nibble",
-  "version": "0.3.1",
+  "version": "0.4.1",
   "description": "Fast local network scanner with hardware identification and a terminal UI",
   "bin": {
     "nibble": "bin/nibble.js"
@@ -8,6 +8,9 @@
   "scripts": {
     "postinstall": "node bin/install.js"
   },
+  "dependencies": {
+    "tar": "^7.0.0"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/backendsystems/nibble"