@bifrost-proxy/bifrost 0.0.42-beta → 0.0.44-beta

package/install.js

@@ -0,0 +1,206 @@
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+const zlib = require("zlib");
+const https = require("https");
+const child_process = require("child_process");
+
+const packageJSON = require(path.join(__dirname, "package.json"));
+
+const PLATFORM_MAP = {
+  "linux-x64-glibc": { pkg: "@bifrost-proxy/bifrost-linux-x64", binary: "bifrost" },
+  "linux-x64-musl": { pkg: "@bifrost-proxy/bifrost-linux-x64-musl", binary: "bifrost" },
+  "linux-arm64-glibc": { pkg: "@bifrost-proxy/bifrost-linux-arm64", binary: "bifrost" },
+  "linux-arm64-musl": { pkg: "@bifrost-proxy/bifrost-linux-arm64-musl", binary: "bifrost" },
+  "linux-arm-glibc": { pkg: "@bifrost-proxy/bifrost-linux-arm", binary: "bifrost" },
+  "darwin-x64": { pkg: "@bifrost-proxy/bifrost-darwin-x64", binary: "bifrost" },
+  "darwin-arm64": { pkg: "@bifrost-proxy/bifrost-darwin-arm64", binary: "bifrost" },
+  "win32-x64": { pkg: "@bifrost-proxy/bifrost-win32-x64", binary: "bifrost.exe" },
+  "win32-arm64": { pkg: "@bifrost-proxy/bifrost-win32-arm64", binary: "bifrost.exe" },
+};
+
+function detectLibc() {
+  if (process.platform !== "linux") return null;
+  try {
+    const lddOutput = child_process.execSync("ldd --version 2>&1 || true", {
+      stdio: ["pipe", "pipe", "pipe"],
+      encoding: "utf8",
+    });
+    if (/musl/i.test(lddOutput)) return "musl";
+    if (/GLIBC|GNU libc/i.test(lddOutput)) return "glibc";
+  } catch {}
+  try {
+    if (fs.existsSync("/lib/ld-musl-x86_64.so.1") ||
+        fs.existsSync("/lib/ld-musl-aarch64.so.1") ||
+        fs.existsSync("/lib/ld-musl-armhf.so.1")) {
+      return "musl";
+    }
+  } catch {}
+  return "glibc";
+}
+
+function getPlatformInfo() {
+  let key = `${process.platform}-${os.arch()}`;
+  if (process.platform === "linux") {
+    const libc = detectLibc();
+    key = `${key}-${libc}`;
+  }
+  const info = PLATFORM_MAP[key];
+  if (!info) {
+    throw new Error(
+      `Unsupported platform: ${key}. Supported: ${Object.keys(PLATFORM_MAP).join(", ")}`
+    );
+  }
+  return { ...info, key, subpath: `bin/${info.binary}` };
+}
+
+function downloadedBinPath(pkg, binary) {
+  return path.join(__dirname, `downloaded-${pkg.replace("/", "-").replace("@", "")}-${binary}`);
+}
+
+function fetch(url) {
+  return new Promise((resolve, reject) => {
+    https.get(url, (res) => {
+      if ((res.statusCode === 301 || res.statusCode === 302) && res.headers.location)
+        return fetch(res.headers.location).then(resolve, reject);
+      if (res.statusCode !== 200)
+        return reject(new Error(`Server responded with ${res.statusCode}`));
+      let chunks = [];
+      res.on("data", (chunk) => chunks.push(chunk));
+      res.on("end", () => resolve(Buffer.concat(chunks)));
+    }).on("error", reject);
+  });
+}
+
+function extractFileFromTarGzip(buffer, subpath) {
+  try {
+    buffer = zlib.unzipSync(buffer);
+  } catch (err) {
+    throw new Error(`Invalid gzip data in archive: ${err && err.message || err}`);
+  }
+  let str = (i, n) => String.fromCharCode(...buffer.subarray(i, i + n)).replace(/\0.*$/, "");
+  let offset = 0;
+  subpath = `package/${subpath}`;
+  while (offset < buffer.length) {
+    let name = str(offset, 100);
+    let size = parseInt(str(offset + 124, 12), 8);
+    offset += 512;
+    if (!isNaN(size)) {
+      if (name === subpath) return buffer.subarray(offset, offset + size);
+      offset += (size + 511) & ~511;
+    }
+  }
+  throw new Error(`Could not find ${JSON.stringify(subpath)} in archive`);
+}
+
+function installUsingNPM(pkg, subpath, binPath) {
+  const env = { ...process.env, npm_config_global: void 0 };
+  const installDir = path.join(__dirname, "npm-install");
+  fs.mkdirSync(installDir, { recursive: true });
+  try {
+    fs.writeFileSync(path.join(installDir, "package.json"), "{}");
+    child_process.execSync(
+      `npm install --loglevel=error --prefer-offline --no-audit --progress=false ${pkg}@${packageJSON.version}`,
+      { cwd: installDir, stdio: "pipe", env }
+    );
+    const installedBinPath = path.join(installDir, "node_modules", pkg, subpath);
+    fs.copyFileSync(installedBinPath, binPath);
+    fs.chmodSync(binPath, 0o755);
+  } finally {
+    try {
+      removeRecursive(installDir);
+    } catch {}
+  }
+}
+
+function removeRecursive(dir) {
+  for (const entry of fs.readdirSync(dir)) {
+    const entryPath = path.join(dir, entry);
+    let stats;
+    try {
+      stats = fs.lstatSync(entryPath);
+    } catch {
+      continue;
+    }
+    if (stats.isDirectory()) removeRecursive(entryPath);
+    else fs.unlinkSync(entryPath);
+  }
+  fs.rmdirSync(dir);
+}
+
+async function downloadDirectlyFromNPM(pkg, subpath, binPath) {
+  const tarballName = pkg.replace("@bifrost-proxy/", "");
+  const url = `https://registry.npmjs.org/${pkg}/-/${tarballName}-${packageJSON.version}.tgz`;
+  console.error(`[bifrost] Trying to download ${JSON.stringify(url)}`);
+  try {
+    const bytes = extractFileFromTarGzip(await fetch(url), subpath);
+    fs.writeFileSync(binPath, bytes);
+    fs.chmodSync(binPath, 0o755);
+  } catch (e) {
+    console.error(`[bifrost] Failed to download ${JSON.stringify(url)}: ${e && e.message || e}`);
+    throw e;
+  }
+}
+
+function validateBinary(binPath) {
+  try {
+    const stdout = child_process
+      .execFileSync(binPath, ["--version"], { stdio: "pipe" })
+      .toString()
+      .trim();
+    const version = stdout.replace(/^bifrost\s+/i, "").trim();
+    if (version !== packageJSON.version) {
+      console.warn(
+        `[bifrost] Warning: expected version ${packageJSON.version} but got ${version}`
+      );
+    }
+  } catch {
+    // validation is best-effort
+  }
+}
+
+async function checkAndPreparePackage() {
+  const { pkg, binary, subpath } = getPlatformInfo();
+
+  try {
+    const packageDir = path.dirname(require.resolve(`${pkg}/package.json`));
+    const binPath = path.join(packageDir, "bin", binary);
+    if (fs.existsSync(binPath)) {
+      validateBinary(binPath);
+      return;
+    }
+  } catch {}
+
+  console.error(
+    `[bifrost] Failed to find package "${pkg}" on the file system\n\n` +
+      `This can happen if you use the "--no-optional" flag. The "optionalDependencies"\n` +
+      `feature is used by bifrost to install the correct binary for your current platform.\n` +
+      `This install script will now attempt to work around this.\n`
+  );
+
+  const binPath = downloadedBinPath(pkg, binary);
+
+  try {
+    console.error(`[bifrost] Trying to install package "${pkg}" using npm`);
+    installUsingNPM(pkg, subpath, binPath);
+    validateBinary(binPath);
+    return;
+  } catch (e) {
+    console.error(
+      `[bifrost] Failed to install package "${pkg}" using npm: ${e && e.message || e}`
+    );
+  }
+
+  try {
+    await downloadDirectlyFromNPM(pkg, subpath, binPath);
+    validateBinary(binPath);
+    return;
+  } catch {
+    throw new Error(`Failed to install package "${pkg}"`);
+  }
+}
+
+checkAndPreparePackage().catch((e) => {
+  console.error(`[bifrost] ${e && e.message || e}`);
+  process.exit(1);
+});

package/lib/index.js

@@ -1,18 +1,46 @@
 const { platform, arch } = process;
 const path = require("path");
+const fs = require("fs");
+const child_process = require("child_process");
 
 const PLATFORM_MAP = {
-  "linux-x64": "@bifrost-proxy/bifrost-linux-x64",
-  "linux-arm64": "@bifrost-proxy/bifrost-linux-arm64",
-  "linux-arm": "@bifrost-proxy/bifrost-linux-arm",
+  "linux-x64-glibc": "@bifrost-proxy/bifrost-linux-x64",
+  "linux-x64-musl": "@bifrost-proxy/bifrost-linux-x64-musl",
+  "linux-arm64-glibc": "@bifrost-proxy/bifrost-linux-arm64",
+  "linux-arm64-musl": "@bifrost-proxy/bifrost-linux-arm64-musl",
+  "linux-arm-glibc": "@bifrost-proxy/bifrost-linux-arm",
   "darwin-x64": "@bifrost-proxy/bifrost-darwin-x64",
   "darwin-arm64": "@bifrost-proxy/bifrost-darwin-arm64",
   "win32-x64": "@bifrost-proxy/bifrost-win32-x64",
   "win32-arm64": "@bifrost-proxy/bifrost-win32-arm64",
 };
 
+function detectLibc() {
+  if (platform !== "linux") return null;
+  try {
+    const lddOutput = child_process.execSync("ldd --version 2>&1 || true", {
+      stdio: ["pipe", "pipe", "pipe"],
+      encoding: "utf8",
+    });
+    if (/musl/i.test(lddOutput)) return "musl";
+    if (/GLIBC|GNU libc/i.test(lddOutput)) return "glibc";
+  } catch {}
+  try {
+    if (fs.existsSync("/lib/ld-musl-x86_64.so.1") ||
+        fs.existsSync("/lib/ld-musl-aarch64.so.1") ||
+        fs.existsSync("/lib/ld-musl-armhf.so.1")) {
+      return "musl";
+    }
+  } catch {}
+  return "glibc";
+}
+
 function getBinaryPath() {
-  const key = `${platform}-${arch}`;
+  let key = `${platform}-${arch}`;
+  if (platform === "linux") {
+    const libc = detectLibc();
+    key = `${key}-${libc}`;
+  }
   const packageName = PLATFORM_MAP[key];
 
   if (!packageName) {
@@ -26,13 +54,21 @@ function getBinaryPath() {
 
   try {
     const packageDir = path.dirname(require.resolve(`${packageName}/package.json`));
-    return path.join(packageDir, "bin", binaryName);
-  } catch {
-    throw new Error(
-      `The platform-specific package ${packageName} is not installed. ` +
-        `Please reinstall @bifrost-proxy/bifrost to fix this.`
-    );
-  }
+    const binPath = path.join(packageDir, "bin", binaryName);
+    if (fs.existsSync(binPath)) return binPath;
+  } catch {}
+
+  const downloadedPath = path.join(
+    __dirname,
+    "..",
+    `downloaded-${packageName.replace("/", "-").replace("@", "")}-${binaryName}`
+  );
+  if (fs.existsSync(downloadedPath)) return downloadedPath;
+
+  throw new Error(
+    `The platform-specific package ${packageName} is not installed. ` +
+      `Please reinstall @bifrost-proxy/bifrost to fix this.`
+  );
 }
 
 exports.getBinaryPath = getBinaryPath;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bifrost-proxy/bifrost",
-  "version": "0.0.42-beta",
+  "version": "0.0.44-beta",
   "description": "High-performance HTTP/HTTPS/SOCKS5 proxy server written in Rust",
   "license": "MIT",
   "repository": {
@@ -22,18 +22,24 @@
     "bifrost": "bin/bifrost"
   },
   "main": "lib/index.js",
+  "scripts": {
+    "postinstall": "node install.js"
+  },
   "files": [
     "bin/bifrost",
     "lib/index.js",
+    "install.js",
     "README.md"
   ],
   "optionalDependencies": {
-    "@bifrost-proxy/bifrost-linux-x64": "0.0.42-beta",
-    "@bifrost-proxy/bifrost-linux-arm64": "0.0.42-beta",
-    "@bifrost-proxy/bifrost-linux-arm": "0.0.42-beta",
-    "@bifrost-proxy/bifrost-darwin-x64": "0.0.42-beta",
-    "@bifrost-proxy/bifrost-darwin-arm64": "0.0.42-beta",
-    "@bifrost-proxy/bifrost-win32-x64": "0.0.42-beta",
-    "@bifrost-proxy/bifrost-win32-arm64": "0.0.42-beta"
+    "@bifrost-proxy/bifrost-linux-x64": "0.0.44-beta",
+    "@bifrost-proxy/bifrost-linux-arm64": "0.0.44-beta",
+    "@bifrost-proxy/bifrost-linux-arm": "0.0.44-beta",
+    "@bifrost-proxy/bifrost-linux-x64-musl": "0.0.44-beta",
+    "@bifrost-proxy/bifrost-linux-arm64-musl": "0.0.44-beta",
+    "@bifrost-proxy/bifrost-darwin-x64": "0.0.44-beta",
+    "@bifrost-proxy/bifrost-darwin-arm64": "0.0.44-beta",
+    "@bifrost-proxy/bifrost-win32-x64": "0.0.44-beta",
+    "@bifrost-proxy/bifrost-win32-arm64": "0.0.44-beta"
   }
 }