dreamer-b2b-flux- 0.2.0

package/README.md

@@ -0,0 +1,7 @@
+# dreamer-b2b-flux-
+
+Platform-aware npm wrapper package for `dreamer-b2b-flux-`.
+
+The package installs a platform-specific binary from this release:
+
+`https://github.com/yehezkieldio/dreamer-b2b-yinlin-e2e-/releases/tag/v0.2.0`

package/binary-install.js

@@ -0,0 +1,166 @@
+const fs = require("node:fs");
+const http = require("node:http");
+const https = require("node:https");
+const path = require("node:path");
+const { spawnSync } = require("node:child_process");
+const { URL } = require("node:url");
+
+const MAX_REDIRECTS = 5;
+const DOWNLOAD_TIMEOUT_MS = 30000;
+
+function fail(message) {
+  console.error(message);
+  process.exit(1);
+}
+
+function downloadToFile(url, destination, redirects = 0) {
+  return new Promise((resolve, reject) => {
+    let parsed;
+    try {
+      parsed = new URL(url);
+    } catch (error) {
+      reject(new Error(`Invalid download URL ${url}: ${error.message}`));
+      return;
+    }
+
+    const client = parsed.protocol === "https:" ? https : parsed.protocol === "http:" ? http : null;
+    if (!client) {
+      reject(new Error(`Unsupported download URL protocol: ${parsed.protocol}`));
+      return;
+    }
+
+    const request = client.get(parsed, (response) => {
+      if (
+        response.statusCode &&
+        response.statusCode >= 300 &&
+        response.statusCode < 400 &&
+        response.headers.location
+      ) {
+        if (redirects >= MAX_REDIRECTS) {
+          response.resume();
+          reject(new Error(`Too many redirects while downloading ${url}`));
+          return;
+        }
+        const redirectUrl = new URL(response.headers.location, parsed).toString();
+        response.resume();
+        downloadToFile(redirectUrl, destination, redirects + 1).then(resolve, reject);
+        return;
+      }
+
+      if (response.statusCode !== 200) {
+        response.resume();
+        reject(new Error(`HTTP ${response.statusCode} while downloading ${url}`));
+        return;
+      }
+
+      const out = fs.createWriteStream(destination, { mode: 0o755 });
+      out.on("error", reject);
+      out.on("finish", () => out.close(resolve));
+      response.pipe(out);
+    });
+
+    request.setTimeout(DOWNLOAD_TIMEOUT_MS, () => {
+      request.destroy(new Error(`Timed out downloading ${url}`));
+    });
+    request.on("error", reject);
+  });
+}
+
+class Package {
+  constructor(platform, name, artifactDownloadUrl) {
+    this.platform = platform;
+    this.name = name;
+    this.artifactDownloadUrl = artifactDownloadUrl;
+    this.installDirectory = path.join(__dirname, "node_modules", ".bin_real");
+  }
+
+  uniqueBinaryPaths() {
+    return [...new Set(Object.values(this.platform.bins || {}))];
+  }
+
+  exists() {
+    const binaryPaths = this.uniqueBinaryPaths();
+    if (binaryPaths.length === 0) {
+      return false;
+    }
+    return binaryPaths.every((relativePath) =>
+      fs.existsSync(path.join(this.installDirectory, relativePath))
+    );
+  }
+
+  install(suppressLogs = false) {
+    const binaryPaths = this.uniqueBinaryPaths();
+    if (binaryPaths.length !== 1) {
+      fail(
+        `${this.name} expected exactly one binary for ${this.platform.artifactName}, got ${binaryPaths.length}`
+      );
+    }
+
+    if (this.exists()) {
+      if (!suppressLogs) {
+        console.error(`${this.name} is already installed.`);
+      }
+      return Promise.resolve();
+    }
+
+    fs.rmSync(this.installDirectory, { recursive: true, force: true });
+
+    const relativePath = binaryPaths[0];
+    const destination = path.join(this.installDirectory, relativePath);
+    const temporary = `${destination}.tmp-${process.pid}`;
+    fs.mkdirSync(path.dirname(destination), { recursive: true });
+
+    const url = `${this.artifactDownloadUrl}/${this.platform.artifactName}`;
+    if (!suppressLogs) {
+      console.error(`Downloading ${url}`);
+    }
+
+    fs.rmSync(temporary, { force: true });
+    return downloadToFile(url, temporary)
+      .then(() => {
+        fs.renameSync(temporary, destination);
+        if (process.platform !== "win32") {
+          fs.chmodSync(destination, 0o755);
+        }
+        if (!suppressLogs) {
+          console.error(`${this.name} installed.`);
+        }
+      })
+      .catch((error) => {
+        fs.rmSync(temporary, { force: true });
+        fail(`Failed to install ${this.name}: ${error.message}`);
+      });
+  }
+
+  run(binaryName) {
+    const execute = () => {
+      const relativePath = this.platform.bins[binaryName];
+      if (!relativePath) {
+        fail(`${binaryName} is not published in ${this.name}`);
+      }
+
+      const binaryPath = path.join(this.installDirectory, relativePath);
+      const result = spawnSync(binaryPath, process.argv.slice(2), {
+        cwd: process.cwd(),
+        stdio: "inherit",
+      });
+
+      if (result.error) {
+        fail(result.error.message);
+      }
+
+      process.exit(result.status ?? 1);
+    };
+
+    if (!this.exists()) {
+      this.install(true).then(execute, (error) => fail(error.message));
+      return;
+    }
+
+    execute();
+  }
+}
+
+module.exports = {
+  Package,
+};

package/binary.js

@@ -0,0 +1,168 @@
+const { Package } = require("./binary-install");
+
+const {
+  name,
+  artifactDownloadUrl,
+  supportedPlatforms,
+  glibcMinimum,
+} = require("./package.json");
+
+function fail(message) {
+  console.error(message);
+  process.exit(1);
+}
+
+function parseVersion(version) {
+  if (!version || typeof version !== "string") {
+    return null;
+  }
+  const match = version.match(/^(\d+)\.(\d+)/);
+  if (!match) {
+    return null;
+  }
+  return {
+    major: Number(match[1]),
+    series: Number(match[2]),
+  };
+}
+
+function runtimeGlibcVersion() {
+  const report = process.report;
+  if (!report || typeof report.getReport !== "function") {
+    return null;
+  }
+  return parseVersion(report.getReport()?.header?.glibcVersionRuntime || null);
+}
+
+function glibcCompatible() {
+  const runtime = runtimeGlibcVersion();
+  if (!runtime) {
+    return false;
+  }
+  if (runtime.major > glibcMinimum.major) {
+    return true;
+  }
+  if (runtime.major < glibcMinimum.major) {
+    return false;
+  }
+  return runtime.series >= glibcMinimum.series;
+}
+
+function platformCandidates() {
+  const os = process.platform;
+  const arch = process.arch;
+
+  if (os === "darwin" && arch === "x64") {
+    return ["x86_64-apple-darwin"];
+  }
+  if (os === "darwin" && arch === "arm64") {
+    return ["aarch64-apple-darwin"];
+  }
+  if (os === "win32" && arch === "x64") {
+    return ["x86_64-pc-windows-msvc", "x86_64-pc-windows-gnu"];
+  }
+  if (os === "win32" && arch === "arm64") {
+    return ["aarch64-pc-windows-msvc", "aarch64-pc-windows-gnu"];
+  }
+  if (os === "win32" && arch === "ia32") {
+    return ["i686-pc-windows-msvc", "i686-pc-windows-gnu"];
+  }
+  if (os === "linux" && arch === "x64") {
+    if (glibcCompatible()) {
+      return [
+        "x86_64-unknown-linux-gnu",
+        "x86_64-unknown-linux-musl",
+        "x86_64-unknown-linux-musl-static",
+        "x86_64-unknown-linux-musl-dynamic",
+      ];
+    }
+    return [
+      "x86_64-unknown-linux-musl",
+      "x86_64-unknown-linux-musl-static",
+      "x86_64-unknown-linux-musl-dynamic",
+      "x86_64-unknown-linux-gnu",
+    ];
+  }
+  if (os === "linux" && arch === "arm64") {
+    if (glibcCompatible()) {
+      return [
+        "aarch64-unknown-linux-gnu",
+        "aarch64-unknown-linux-musl",
+        "aarch64-unknown-linux-musl-static",
+        "aarch64-unknown-linux-musl-dynamic",
+      ];
+    }
+    return [
+      "aarch64-unknown-linux-musl",
+      "aarch64-unknown-linux-musl-static",
+      "aarch64-unknown-linux-musl-dynamic",
+      "aarch64-unknown-linux-gnu",
+    ];
+  }
+  if (os === "linux" && arch === "arm") {
+    if (glibcCompatible()) {
+      return [
+        "armv7-unknown-linux-gnueabihf",
+        "arm-unknown-linux-gnueabihf",
+        "armv7-unknown-linux-musleabihf",
+        "arm-unknown-linux-musleabihf",
+      ];
+    }
+    return [
+      "armv7-unknown-linux-musleabihf",
+      "arm-unknown-linux-musleabihf",
+      "armv7-unknown-linux-gnueabihf",
+      "arm-unknown-linux-gnueabihf",
+    ];
+  }
+  if (os === "linux" && arch === "ia32") {
+    if (glibcCompatible()) {
+      return ["i686-unknown-linux-gnu", "i686-unknown-linux-musl"];
+    }
+    return ["i686-unknown-linux-musl", "i686-unknown-linux-gnu"];
+  }
+  if (os === "linux" && arch === "riscv64") {
+    if (glibcCompatible()) {
+      return ["riscv64gc-unknown-linux-gnu", "riscv64gc-unknown-linux-musl"];
+    }
+    return ["riscv64gc-unknown-linux-musl", "riscv64gc-unknown-linux-gnu"];
+  }
+
+  return [];
+}
+
+function getPlatform() {
+  for (const triple of platformCandidates()) {
+    const entry = supportedPlatforms[triple];
+    if (entry) {
+      return entry;
+    }
+  }
+
+  fail(
+    `Unsupported platform ${process.platform}/${process.arch} for ${name}. ` +
+      `Supported targets: ${Object.keys(supportedPlatforms).join(", ")}`
+  );
+}
+
+function getPackage() {
+  const platform = getPlatform();
+  return new Package(platform, name, artifactDownloadUrl);
+}
+
+function install(suppressLogs) {
+  if (!artifactDownloadUrl || typeof artifactDownloadUrl !== "string") {
+    fail(`Invalid artifactDownloadUrl for ${name}`);
+  }
+  return getPackage().install(suppressLogs);
+}
+
+function run(binaryName) {
+  return getPackage().run(binaryName);
+}
+
+module.exports = {
+  getPackage,
+  install,
+  run,
+};

package/install.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+const { install } = require("./binary");
+
+install(false);

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "dreamer-b2b-flux-",
+  "version": "0.2.0",
+  "private": false,
+  "description": "Platform-aware binary installer for dreamer-b2b-flux-",
+  "license": "MIT",
+  "artifactDownloadUrl": "https://github.com/yehezkieldio/dreamer-b2b-yinlin-e2e-/releases/download/v0.2.0",
+  "supportedPlatforms": {"x86_64-unknown-linux-gnu":{"artifactName":"dreamer-b2b-flux--x86_64-unknown-linux-gnu","bins":{"dreamer-b2b-flux-":"dreamer-b2b-flux-"},"zipExt":""}},
+  "glibcMinimum": {"major":2,"series":31},
+  "bin": {
+    "dreamer-b2b-flux-": "run-dreamer-b2b-flux-.js"
+  },
+  "scripts": {
+    "postinstall": "node ./install.js"
+  },
+  "files": [
+    "README.md",
+    "install.js",
+    "binary.js",
+    "binary-install.js",
+    "run-dreamer-b2b-flux-.js"
+  ]
+}

package/run-dreamer-b2b-flux-.js

@@ -0,0 +1,5 @@
+#!/usr/bin/env node
+
+const { run } = require("./binary");
+
+run("dreamer-b2b-flux-");