htn-tunnel 0.2.0 → 0.2.1

package/bin/htn-tunnel.js

@@ -1,42 +1,11 @@
 #!/usr/bin/env node
-
-// Platform detection shim — finds the correct prebuilt binary from
-// @htn-tunnel/<platform> optional dependency and executes it.
-
-const { execFileSync } = require("child_process");
+// Shim: finds and executes the htn-tunnel binary downloaded by postinstall.
 const path = require("path");
 const os = require("os");
 const fs = require("fs");
 
-const PLATFORMS = {
-  "darwin:arm64": "@htn-tunnel/darwin-arm64",
-  "darwin:x64": "@htn-tunnel/darwin-x64",
-  "linux:arm64": "@htn-tunnel/linux-arm64",
-  "linux:x64": "@htn-tunnel/linux-x64",
-  "win32:arm64": "@htn-tunnel/win32-arm64",
-  "win32:x64": "@htn-tunnel/win32-x64",
-};
-
-const platform = os.platform();
-const arch = os.arch();
-const key = `${platform}:${arch}`;
-const pkg = PLATFORMS[key];
-const ext = platform === "win32" ? ".exe" : "";
-
-if (!pkg) {
-  console.error(`htn-tunnel: unsupported platform ${key}`);
-  process.exit(1);
-}
-
-// Try 1: resolve from optionalDependencies package
-let binPath;
-try {
-  const pkgDir = path.dirname(require.resolve(`${pkg}/package.json`));
-  binPath = path.join(pkgDir, "bin", `htn-tunnel${ext}`);
-} catch {
-  // Try 2: postinstall may have downloaded binary to our own bin/
-  binPath = path.join(__dirname, `htn-tunnel${ext}`);
-}
+const ext = os.platform() === "win32" ? ".exe" : "";
+const binPath = path.join(__dirname, `htn-tunnel${ext}`);
 
 if (!fs.existsSync(binPath)) {
   console.error("htn-tunnel: binary not found. Try reinstalling:");
@@ -44,13 +13,8 @@ if (!fs.existsSync(binPath)) {
   process.exit(1);
 }
 
-try {
-  const result = require("child_process").spawnSync(binPath, process.argv.slice(2), {
-    stdio: "inherit",
-    windowsHide: false,
-  });
-  process.exit(result.status ?? 1);
-} catch (e) {
-  console.error("htn-tunnel: failed to execute binary:", e.message);
-  process.exit(1);
-}
+const result = require("child_process").spawnSync(binPath, process.argv.slice(2), {
+  stdio: "inherit",
+  windowsHide: false,
+});
+process.exit(result.status ?? 1);

package/lib/install.js

@@ -1,63 +1,49 @@
-// Postinstall fallback — downloads binary from GitHub Releases
-// when optionalDependencies are disabled or unavailable.
-
+// Postinstall: download htn-tunnel binary from GitHub Releases.
 const fs = require("fs");
 const path = require("path");
 const os = require("os");
 const https = require("https");
+const { execSync } = require("child_process");
 
-const PLATFORMS = {
-  "darwin:arm64": "@htn-tunnel/darwin-arm64",
-  "darwin:x64": "@htn-tunnel/darwin-x64",
-  "linux:arm64": "@htn-tunnel/linux-arm64",
-  "linux:x64": "@htn-tunnel/linux-x64",
-  "win32:arm64": "@htn-tunnel/win32-arm64",
-  "win32:x64": "@htn-tunnel/win32-x64",
-};
-
-const platform = os.platform();
-const arch = os.arch();
-const key = `${platform}:${arch}`;
-const pkg = PLATFORMS[key];
-
-// Check if platform package already installed via optionalDependencies
-if (pkg) {
-  try {
-    require.resolve(`${pkg}/package.json`);
-    process.exit(0); // Already installed, nothing to do
-  } catch {
-    // Not installed — fall through to download
-  }
-}
+const VERSION = require("../package.json").version;
+const REPO = "nhh0718/htn-tunnel";
 
-const version = require("../package.json").version;
-const goArch = arch === "x64" ? "amd64" : arch;
+const platform = os.platform();  // darwin, linux, win32
+const arch = os.arch();          // x64, arm64
 const goOS = platform === "win32" ? "windows" : platform;
+const goArch = arch === "x64" ? "amd64" : arch;
 const ext = platform === "win32" ? ".exe" : "";
+const archiveExt = platform === "win32" ? ".zip" : ".tar.gz";
+
 const binDir = path.join(__dirname, "..", "bin");
 const binPath = path.join(binDir, `htn-tunnel${ext}`);
 
-// Already downloaded
+// Skip if binary already exists and is correct version
 if (fs.existsSync(binPath) && fs.statSync(binPath).size > 0) {
-  process.exit(0);
+  try {
+    const out = execSync(`"${binPath}" --version`, { encoding: "utf8", timeout: 5000 });
+    if (out.includes(VERSION)) {
+      process.exit(0);
+    }
+  } catch { /* re-download */ }
 }
 
-const baseUrl = `https://github.com/nhh0718/htn-tunnel/releases/download/v${version}`;
-const archiveName = `htn-tunnel_${version}_${goOS}_${goArch}`;
-const archiveExt = platform === "win32" ? ".zip" : ".tar.gz";
-const url = `${baseUrl}/${archiveName}${archiveExt}`;
+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(`htn-tunnel: downloading v${VERSION} for ${platform}/${arch}...`);
+console.log(`  ${url}`);
 
-function follow(url, cb) {
-  https.get(url, (res) => {
+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);
+      return follow(res.headers.location, cb, redirects + 1);
     }
     cb(res);
   }).on("error", (err) => {
     console.error("htn-tunnel: download failed:", err.message);
-    console.error("Install manually: https://github.com/nhh0718/htn-tunnel/releases");
+    printManual();
     process.exit(1);
   });
 }
@@ -67,7 +53,7 @@ fs.mkdirSync(binDir, { recursive: true });
 follow(url, (res) => {
   if (res.statusCode !== 200) {
     console.error(`htn-tunnel: download failed (HTTP ${res.statusCode})`);
-    console.error("Install manually: https://github.com/nhh0718/htn-tunnel/releases");
+    printManual();
     process.exit(1);
   }
 
@@ -75,36 +61,34 @@ follow(url, (res) => {
   res.on("data", (chunk) => chunks.push(chunk));
   res.on("end", () => {
     const data = Buffer.concat(chunks);
-
-    if (archiveExt === ".zip") {
-      // Simple zip extraction — find the binary entry
-      extractZipBinary(data, `htn-tunnel${ext}`, binPath);
-    } else {
-      // tar.gz extraction
-      extractTarGzBinary(data, `htn-tunnel${ext}`, binPath);
+    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);
     }
-
-    fs.chmodSync(binPath, 0o755);
-    console.log("htn-tunnel: installed successfully");
   });
-});
+}, 0);
 
-function extractTarGzBinary(gzData, filename, dest) {
+function extractTarGz(gzData, filename, dest) {
   const zlib = require("zlib");
   const tarData = zlib.gunzipSync(gzData);
-
-  // Simple tar parser — find file entry matching filename
   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)) {
+    if (name.endsWith(filename) || name === filename) {
       fs.writeFileSync(dest, tarData.subarray(offset, offset + size));
       return;
     }
@@ -113,23 +97,33 @@ function extractTarGzBinary(gzData, filename, dest) {
   throw new Error(`${filename} not found in archive`);
 }
 
-function extractZipBinary(zipData, filename, dest) {
-  // Simple zip parser — find local file header for the binary
+function extractZip(zipData, filename, dest) {
   let offset = 0;
   while (offset < zipData.length - 4) {
-    if (zipData.readUInt32LE(offset) !== 0x04034b50) break; // PK\x03\x04
-
+    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 compSize = zipData.readUInt32LE(offset + 18);
     const name = zipData.toString("utf8", offset + 30, offset + 30 + nameLen);
-
     const dataStart = offset + 30 + nameLen + extraLen;
-    if (name.endsWith(filename)) {
-      fs.writeFileSync(dest, zipData.subarray(dataStart, dataStart + compSize));
+    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;
     }
     offset = dataStart + compSize;
   }
   throw new Error(`${filename} not found in archive`);
 }
+
+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");
+}

package/package.json

@@ -1,29 +1,14 @@
 {
   "name": "htn-tunnel",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Self-hosted tunnel client — expose localhost to the internet",
   "bin": {
     "htn-tunnel": "./bin/htn-tunnel.js"
   },
-  "optionalDependencies": {
-    "@htn-tunnel/darwin-arm64": "0.1.1",
-    "@htn-tunnel/darwin-x64": "0.1.1",
-    "@htn-tunnel/linux-arm64": "0.1.1",
-    "@htn-tunnel/linux-x64": "0.1.1",
-    "@htn-tunnel/win32-arm64": "0.1.1",
-    "@htn-tunnel/win32-x64": "0.1.1"
-  },
   "scripts": {
     "postinstall": "node lib/install.js"
   },
-  "keywords": [
-    "tunnel",
-    "ngrok",
-    "localhost",
-    "expose",
-    "dev",
-    "htn"
-  ],
+  "keywords": ["tunnel", "ngrok", "localhost", "expose", "dev", "htn"],
   "license": "MIT",
   "repository": {
     "type": "git",