htn-tunnel 0.2.2 → 0.2.4

package/lib/install.js

@@ -5,12 +5,12 @@ const os = require("os");
 const https = require("https");
 const { execSync } = require("child_process");
 
-// Binary version from GitHub Releases (may differ from npm package version).
+// Binary version from GitHub Releases.
 const VERSION = "0.2.0";
 const REPO = "nhh0718/htn-tunnel";
 
-const platform = os.platform();  // darwin, linux, win32
-const arch = os.arch();          // x64, arm64
+const platform = os.platform();
+const arch = os.arch();
 const goOS = platform === "win32" ? "windows" : platform;
 const goArch = arch === "x64" ? "amd64" : arch;
 const ext = platform === "win32" ? ".exe" : "";
@@ -19,112 +19,79 @@ const archiveExt = platform === "win32" ? ".zip" : ".tar.gz";
 const binDir = path.join(__dirname, "..", "bin");
 const binPath = path.join(binDir, `htn-tunnel${ext}`);
 
-// Skip if binary already exists and is correct version
-if (fs.existsSync(binPath) && fs.statSync(binPath).size > 0) {
-  try {
-    const out = execSync(`"${binPath}" --version`, { encoding: "utf8", timeout: 5000 });
-    if (out.includes(VERSION)) {
-      process.exit(0);
-    }
-  } catch { /* re-download */ }
+// Skip if binary exists and works.
+if (fs.existsSync(binPath) && fs.statSync(binPath).size > 1000) {
+  console.log("htn-tunnel: binary already installed.");
+  process.exit(0);
 }
 
 const archiveName = `htn-tunnel_${VERSION}_${goOS}_${goArch}${archiveExt}`;
 const url = `https://github.com/${REPO}/releases/download/v${VERSION}/${archiveName}`;
 
 console.log(`htn-tunnel: downloading v${VERSION} for ${platform}/${arch}...`);
-console.log(`  ${url}`);
 
-function follow(url, cb, redirects) {
-  if (redirects > 5) { console.error("htn-tunnel: too many redirects"); process.exit(1); }
-  https.get(url, { headers: { "User-Agent": "htn-tunnel-npm" } }, (res) => {
-    if (res.statusCode === 301 || res.statusCode === 302) {
-      return follow(res.headers.location, cb, redirects + 1);
-    }
-    cb(res);
-  }).on("error", (err) => {
-    console.error("htn-tunnel: download failed:", err.message);
-    printManual();
-    process.exit(1);
+const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "htn-"));
+const tmpFile = path.join(tmpDir, archiveName);
+
+function follow(url, dest, redirects) {
+  return new Promise((resolve, reject) => {
+    if (redirects > 5) return reject(new Error("too many redirects"));
+    https.get(url, { headers: { "User-Agent": "htn-tunnel-npm" } }, (res) => {
+      if (res.statusCode === 301 || res.statusCode === 302) {
+        return follow(res.headers.location, dest, redirects + 1).then(resolve, reject);
+      }
+      if (res.statusCode !== 200) {
+        return reject(new Error(`HTTP ${res.statusCode}`));
+      }
+      const file = fs.createWriteStream(dest);
+      res.pipe(file);
+      file.on("finish", () => { file.close(); resolve(); });
+      file.on("error", reject);
+    }).on("error", reject);
   });
 }
 
-fs.mkdirSync(binDir, { recursive: true });
-
-follow(url, (res) => {
-  if (res.statusCode !== 200) {
-    console.error(`htn-tunnel: download failed (HTTP ${res.statusCode})`);
-    printManual();
-    process.exit(1);
-  }
+async function main() {
+  try {
+    await follow(url, tmpFile, 0);
+    fs.mkdirSync(binDir, { recursive: true });
 
-  const chunks = [];
-  res.on("data", (chunk) => chunks.push(chunk));
-  res.on("end", () => {
-    const data = Buffer.concat(chunks);
-    try {
-      if (archiveExt === ".zip") {
-        extractZip(data, `htn-tunnel${ext}`, binPath);
-      } else {
-        extractTarGz(data, `htn-tunnel${ext}`, binPath);
-      }
-      fs.chmodSync(binPath, 0o755);
-      console.log("htn-tunnel: installed successfully!");
-    } catch (err) {
-      console.error("htn-tunnel: extract failed:", err.message);
-      printManual();
-      process.exit(1);
+    if (archiveExt === ".zip") {
+      // Windows 10+ has tar that handles zip.
+      execSync(`tar -xf "${tmpFile}" -C "${tmpDir}"`, { stdio: "pipe" });
+    } else {
+      execSync(`tar -xzf "${tmpFile}" -C "${tmpDir}"`, { stdio: "pipe" });
     }
-  });
-}, 0);
 
-function extractTarGz(gzData, filename, dest) {
-  const zlib = require("zlib");
-  const tarData = zlib.gunzipSync(gzData);
-  let offset = 0;
-  while (offset < tarData.length) {
-    const header = tarData.subarray(offset, offset + 512);
-    if (header[0] === 0) break;
-    const name = header.toString("utf8", 0, 100).replace(/\0/g, "");
-    const sizeStr = header.toString("utf8", 124, 136).replace(/\0/g, "").trim();
-    const size = parseInt(sizeStr, 8) || 0;
-    offset += 512;
-    if (name.endsWith(filename) || name === filename) {
-      fs.writeFileSync(dest, tarData.subarray(offset, offset + size));
-      return;
-    }
-    offset += Math.ceil(size / 512) * 512;
+    // Find the binary in extracted files.
+    const binaryName = `htn-tunnel${ext}`;
+    const extracted = findFile(tmpDir, binaryName);
+    if (!extracted) throw new Error(`${binaryName} not found in archive`);
+
+    fs.copyFileSync(extracted, binPath);
+    fs.chmodSync(binPath, 0o755);
+    console.log("htn-tunnel: installed successfully!");
+  } catch (err) {
+    console.error("htn-tunnel: install failed:", err.message);
+    console.error(`\nInstall manually: https://github.com/${REPO}/releases/tag/v${VERSION}`);
+    console.error(`Or: go install github.com/${REPO}/cmd/htn-tunnel@latest\n`);
+    process.exit(1);
+  } finally {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
   }
-  throw new Error(`${filename} not found in archive`);
 }
 
-function extractZip(zipData, filename, dest) {
-  let offset = 0;
-  while (offset < zipData.length - 4) {
-    if (zipData.readUInt32LE(offset) !== 0x04034b50) break;
-    const compMethod = zipData.readUInt16LE(offset + 8);
-    const compSize = zipData.readUInt32LE(offset + 18);
-    const nameLen = zipData.readUInt16LE(offset + 26);
-    const extraLen = zipData.readUInt16LE(offset + 28);
-    const name = zipData.toString("utf8", offset + 30, offset + 30 + nameLen);
-    const dataStart = offset + 30 + nameLen + extraLen;
-    if (name.endsWith(filename) || name === filename) {
-      if (compMethod === 0) {
-        fs.writeFileSync(dest, zipData.subarray(dataStart, dataStart + compSize));
-      } else {
-        const zlib = require("zlib");
-        const raw = zipData.subarray(dataStart, dataStart + compSize);
-        fs.writeFileSync(dest, zlib.inflateRawSync(raw));
-      }
-      return;
+function findFile(dir, name) {
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      const found = findFile(full, name);
+      if (found) return found;
+    } else if (entry.name === name) {
+      return full;
     }
-    offset = dataStart + compSize;
   }
-  throw new Error(`${filename} not found in archive`);
+  return null;
 }
 
-function printManual() {
-  console.error("\nInstall manually:");
-  console.error(`  https://github.com/${REPO}/releases/tag/v${VERSION}`);
-  console.error("\nOr use: go install github.com/nhh0718/htn-tunnel/cmd/htn-tunnel@latest\n");
-}
+main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "htn-tunnel",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Self-hosted tunnel client — expose localhost to the internet",
   "bin": {
     "htn-tunnel": "./bin/htn-tunnel.js"