@zackees/soldr 0.7.28 → 0.7.30

package/bin/soldr.js

@@ -6,7 +6,8 @@ const fs = require("fs");
 const path = require("path");
 
 const binaryName = process.platform === "win32" ? "soldr.exe" : "soldr";
-const binaryPath = path.join(__dirname, "native", binaryName);
+const nativeDir = path.join(__dirname, "native");
+const binaryPath = path.join(nativeDir, binaryName);
 
 if (!fs.existsSync(binaryPath)) {
   console.error(
@@ -19,8 +20,41 @@ if (!fs.existsSync(binaryPath)) {
   process.exit(1);
 }
 
+// Wire the bundled zccache trio (zccache, zccache-daemon, zccache-fp,
+// shipped alongside soldr in `bin/native/` since the combined-archive
+// release format landed) into soldr's local-zccache resolution path.
+// Soldr's `fetch_zccache_with_paths` checks SOLDR_ZCCACHE_LOCAL_DIR
+// ahead of the managed-download chain, so this turns the bundled
+// binaries into the active zccache automatically — no manual env
+// setup, no managed fetch over the network. Users who explicitly set
+// the env var themselves keep their override.
+const exeExt = process.platform === "win32" ? ".exe" : "";
+const childEnv = { ...process.env };
+if (
+  !childEnv.SOLDR_ZCCACHE_LOCAL_DIR &&
+  fs.existsSync(path.join(nativeDir, `zccache${exeExt}`)) &&
+  fs.existsSync(path.join(nativeDir, `zccache-daemon${exeExt}`)) &&
+  fs.existsSync(path.join(nativeDir, `zccache-fp${exeExt}`))
+) {
+  childEnv.SOLDR_ZCCACHE_LOCAL_DIR = nativeDir;
+}
+
+// Same wiring for the bundled crgx binary (shipped alongside soldr
+// since the crgx-bundling follow-up to the combined-archive release
+// format). soldr's `fetch_tool_with_paths` honors
+// SOLDR_CRGX_LOCAL_DIR ahead of the GitHub Releases / crates.io
+// fetch chain, so `soldr crgx ...` runs the bundled binary with no
+// network round trip. Caller-set overrides win.
+if (
+  !childEnv.SOLDR_CRGX_LOCAL_DIR &&
+  fs.existsSync(path.join(nativeDir, `crgx${exeExt}`))
+) {
+  childEnv.SOLDR_CRGX_LOCAL_DIR = nativeDir;
+}
+
 const child = childProcess.spawn(binaryPath, process.argv.slice(2), {
   stdio: "inherit",
+  env: childEnv,
   windowsHide: false,
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zackees/soldr",
-  "version": "0.7.28",
+  "version": "0.7.30",
   "description": "Instant Rust tools and builds from one command.",
   "license": "BSD-3-Clause",
   "homepage": "https://github.com/zackees/soldr",

package/scripts/install.js

@@ -12,43 +12,86 @@ const path = require("path");
 const PACKAGE_ROOT = path.resolve(__dirname, "..");
 const PACKAGE_JSON = require(path.join(PACKAGE_ROOT, "package.json"));
 
+// Every release ships a single .tar.zst per target that bundles soldr
+// alongside its matching-target zccache trio (zccache, zccache-daemon,
+// zccache-fp) and a same-target crgx. One fetch installs everything,
+// and `bin/soldr.js` wires SOLDR_ZCCACHE_LOCAL_DIR + SOLDR_CRGX_LOCAL_DIR
+// to the install dir so soldr finds the sibling binaries without going
+// through the managed-download path.
+const ARCHIVE_EXT = "tar.zst";
+
 const TARGETS = {
-  "linux-x64": {
-    triple: "x86_64-unknown-linux-gnu",
-    archive: "tar.gz",
-    binary: "soldr",
-  },
-  "linux-arm64": {
-    triple: "aarch64-unknown-linux-gnu",
-    archive: "tar.gz",
-    binary: "soldr",
-  },
-  "darwin-x64": {
-    triple: "x86_64-apple-darwin",
-    archive: "tar.gz",
-    binary: "soldr",
-  },
-  "darwin-arm64": {
-    triple: "aarch64-apple-darwin",
-    archive: "tar.gz",
-    binary: "soldr",
-  },
-  "win32-x64": {
-    triple: "x86_64-pc-windows-msvc",
-    archive: "zip",
-    binary: "soldr.exe",
-  },
-  "win32-arm64": {
-    triple: "aarch64-pc-windows-msvc",
-    archive: "zip",
-    binary: "soldr.exe",
-  },
+  "linux-x64-gnu": { triple: "x86_64-unknown-linux-gnu", binary: "soldr" },
+  "linux-x64-musl": { triple: "x86_64-unknown-linux-musl", binary: "soldr" },
+  "linux-arm64-gnu": { triple: "aarch64-unknown-linux-gnu", binary: "soldr" },
+  "linux-arm64-musl": { triple: "aarch64-unknown-linux-musl", binary: "soldr" },
+  "darwin-x64": { triple: "x86_64-apple-darwin", binary: "soldr" },
+  "darwin-arm64": { triple: "aarch64-apple-darwin", binary: "soldr" },
+  "win32-x64": { triple: "x86_64-pc-windows-msvc", binary: "soldr.exe" },
+  "win32-arm64": { triple: "aarch64-pc-windows-msvc", binary: "soldr.exe" },
 };
 
-function platformTarget(platform = process.platform, arch = process.arch) {
-  const target = TARGETS[`${platform}-${arch}`];
+// Files we expect to find at the root of every extracted release
+// archive. Names line up with what `release-auto.yml`'s
+// `Fetch matched zccache release`, `Stage soldr binary`, and
+// `Build crgx from pinned source` steps drop into `dist/package/`
+// before the tar.zst is built. `.exe` suffix is appended at install
+// time based on `target.binary`.
+const BUNDLED_BINARIES = [
+  "soldr",
+  "zccache",
+  "zccache-daemon",
+  "zccache-fp",
+  "crgx",
+];
+
+// Detect whether the running Linux uses musl or glibc. Three layered probes:
+//   1. process.report.header.glibcVersionRuntime is the documented Node
+//      surface for runtime glibc version — present on glibc, absent /
+//      empty on musl. Same approach used by @swc/core, @napi-rs/*, etc.
+//   2. Filesystem check for `/lib/ld-musl-*.so.1` covers cases where the
+//      Node binary itself is glibc (e.g. someone running glibc Node on
+//      alpine via apk add nodejs-current) but the system is musl — the
+//      soldr binary we download must match the SYSTEM libc, not Node's.
+//   3. Final fallback: assume glibc. The mismatch will surface
+//      immediately at runtime as "soldr: not found" or
+//      "soldr: error while loading shared libraries", which is louder
+//      than silently downloading the wrong tarball.
+function detectLibc(platform = process.platform) {
+  if (platform !== "linux") {
+    return null;
+  }
+  try {
+    const header = process.report && process.report.getReport && process.report.getReport().header;
+    if (header && typeof header.glibcVersionRuntime === "string" && header.glibcVersionRuntime.length > 0) {
+      return "gnu";
+    }
+    if (header && Object.prototype.hasOwnProperty.call(header, "glibcVersionRuntime")) {
+      // Field present but empty / null → Node was built against musl.
+      return "musl";
+    }
+  } catch (err) {
+    // process.report can throw on locked-down environments; fall through.
+  }
+  try {
+    const entries = fs.readdirSync("/lib");
+    if (entries.some((name) => /^ld-musl-.+\.so\.1$/.test(name))) {
+      return "musl";
+    }
+  } catch (err) {
+    // /lib may not be readable in heavily sandboxed containers; fall through.
+  }
+  return "gnu";
+}
+
+function platformTarget(platform = process.platform, arch = process.arch, libc = detectLibc(platform)) {
+  const key =
+    platform === "linux"
+      ? `${platform}-${arch}-${libc || "gnu"}`
+      : `${platform}-${arch}`;
+  const target = TARGETS[key];
   if (!target) {
-    throw new Error(`unsupported platform for soldr npm package: ${platform}-${arch}`);
+    throw new Error(`unsupported platform for soldr npm package: ${key}`);
   }
   return target;
 }
@@ -128,31 +171,32 @@ function run(command, args, options = {}) {
   }
 }
 
-function extractArchive(archivePath, archiveType, destination) {
-  if (archiveType === "tar.gz") {
-    run("tar", ["-xzf", archivePath, "-C", destination]);
-    return;
-  }
-
-  if (archiveType === "zip" && process.platform === "win32") {
-    run("powershell", [
-      "-NoProfile",
-      "-NonInteractive",
-      "-ExecutionPolicy",
-      "Bypass",
-      "-Command",
-      "Expand-Archive -LiteralPath $env:SOLDR_NPM_ARCHIVE -DestinationPath $env:SOLDR_NPM_EXTRACT -Force",
-    ], {
-      env: {
-        ...process.env,
-        SOLDR_NPM_ARCHIVE: archivePath,
-        SOLDR_NPM_EXTRACT: destination,
-      },
-    });
-    return;
+function extractArchive(archivePath, destination) {
+  // GNU tar 1.31+ and bsdtar (default on macOS / Windows) both support
+  // `--zstd` for zstandard. If a host's tar predates that flag, fall
+  // back to `--use-compress-program=unzstd` which only needs the
+  // `unzstd` CLI on PATH — installed alongside `zstd` on every modern
+  // package manager. As a last resort, `zstd` decompresses to a temp
+  // .tar and we extract that explicitly.
+  const attempts = [
+    ["tar", ["--zstd", "-xf", archivePath, "-C", destination]],
+    ["tar", ["--use-compress-program=unzstd", "-xf", archivePath, "-C", destination]],
+  ];
+  for (const [cmd, args] of attempts) {
+    const result = childProcess.spawnSync(cmd, args, { stdio: "inherit" });
+    if (!result.error && result.status === 0) {
+      return;
+    }
+    if (result.error && result.error.code === "ENOENT") {
+      throw result.error;
+    }
+    // status != 0 → fall through to the next strategy.
   }
-
-  run("tar", ["-xf", archivePath, "-C", destination]);
+  // Last resort: decompress to a sibling .tar, then untar.
+  const intermediate = `${archivePath}.tar`;
+  run("zstd", ["-d", "-o", intermediate, archivePath]);
+  run("tar", ["-xf", intermediate, "-C", destination]);
+  fs.rmSync(intermediate, { force: true });
 }
 
 function findExtractedBinary(root, binaryName) {
@@ -180,7 +224,7 @@ async function install() {
 
   const version = PACKAGE_JSON.version;
   const target = platformTarget();
-  const filename = `soldr-v${version}-${target.triple}.${target.archive}`;
+  const filename = `soldr-v${version}-${target.triple}.${ARCHIVE_EXT}`;
   const baseUrl = releaseBaseUrl(version);
   const archiveUrl = `${baseUrl}/${filename}`;
   const checksumUrl = `${baseUrl}/soldr-v${version}-SHA256SUMS.txt`;
@@ -203,24 +247,44 @@ async function install() {
     const extractDir = path.join(tmp, "extract");
     fs.writeFileSync(archivePath, archive);
     fs.mkdirSync(extractDir, { recursive: true });
-    extractArchive(archivePath, target.archive, extractDir);
-
-    const extracted = findExtractedBinary(extractDir, target.binary);
-    if (!extracted) {
-      throw new Error(`release archive did not contain ${target.binary}`);
-    }
+    extractArchive(archivePath, extractDir);
 
     const nativeDir = path.join(PACKAGE_ROOT, "bin", "native");
     fs.rmSync(nativeDir, { recursive: true, force: true });
     fs.mkdirSync(nativeDir, { recursive: true });
 
-    const destination = path.join(nativeDir, target.binary);
-    fs.copyFileSync(extracted, destination);
-    if (process.platform !== "win32") {
-      fs.chmodSync(destination, 0o755);
+    // Copy every bundled binary so soldr can find its sibling zccache
+    // via SOLDR_ZCCACHE_LOCAL_DIR and its sibling crgx via
+    // SOLDR_CRGX_LOCAL_DIR (both wired up by `bin/soldr.js` before
+    // exec). The archive layout is flat — all five binaries live at
+    // the archive root.
+    const binaryExt = target.binary.endsWith(".exe") ? ".exe" : "";
+    for (const baseName of BUNDLED_BINARIES) {
+      const fileName = `${baseName}${binaryExt}`;
+      const src = findExtractedBinary(extractDir, fileName);
+      if (!src) {
+        throw new Error(`release archive ${filename} did not contain ${fileName}`);
+      }
+      const dst = path.join(nativeDir, fileName);
+      fs.copyFileSync(src, dst);
+      if (process.platform !== "win32") {
+        fs.chmodSync(dst, 0o755);
+      }
+    }
+
+    // Drop manifest.json alongside the binaries so downstream tooling
+    // (and humans reading `bin/native/`) can introspect provenance —
+    // soldr / zccache versions, target triples, build commit, sha256s.
+    // Best-effort: archives shipped before the manifest convention
+    // landed simply won't have one.
+    const manifestSrc = findExtractedBinary(extractDir, "manifest.json");
+    if (manifestSrc) {
+      fs.copyFileSync(manifestSrc, path.join(nativeDir, "manifest.json"));
     }
 
-    console.log(`soldr: installed ${target.triple} binary`);
+    console.log(
+      `soldr: installed ${target.triple} (soldr + zccache trio + crgx) into ${nativeDir}`,
+    );
   } finally {
     fs.rmSync(tmp, { recursive: true, force: true });
   }
@@ -234,7 +298,11 @@ if (require.main === module) {
 }
 
 module.exports = {
+  ARCHIVE_EXT,
+  BUNDLED_BINARIES,
+  TARGETS,
   checksumFor,
+  detectLibc,
   platformTarget,
   releaseBaseUrl,
 };

package/scripts/test-npm-package.js

@@ -75,17 +75,87 @@ assert.deepStrictEqual(pkg.files, [
 const bin = fs.readFileSync(path.join(root, pkg.bin.soldr), "utf8");
 assert(bin.startsWith("#!/usr/bin/env node"), "bin/soldr.js must have a node shebang");
 
-assert.strictEqual(install.platformTarget("linux", "x64").triple, "x86_64-unknown-linux-gnu");
-assert.strictEqual(install.platformTarget("linux", "arm64").triple, "aarch64-unknown-linux-gnu");
+// Linux: triple selection branches on libc. `platformTarget` accepts an
+// explicit `libc` arg so tests don't depend on the runtime detector.
+assert.strictEqual(
+  install.platformTarget("linux", "x64", "gnu").triple,
+  "x86_64-unknown-linux-gnu",
+);
+assert.strictEqual(
+  install.platformTarget("linux", "x64", "musl").triple,
+  "x86_64-unknown-linux-musl",
+);
+assert.strictEqual(
+  install.platformTarget("linux", "arm64", "gnu").triple,
+  "aarch64-unknown-linux-gnu",
+);
+assert.strictEqual(
+  install.platformTarget("linux", "arm64", "musl").triple,
+  "aarch64-unknown-linux-musl",
+);
+// Default (no libc arg) falls back to detectLibc; on most CI hosts that's
+// gnu. We don't assert the triple here — just that the call resolves.
+assert.ok(install.platformTarget("linux", "x64").triple.startsWith("x86_64-unknown-linux-"));
 assert.strictEqual(install.platformTarget("darwin", "x64").triple, "x86_64-apple-darwin");
 assert.strictEqual(install.platformTarget("darwin", "arm64").triple, "aarch64-apple-darwin");
 assert.strictEqual(install.platformTarget("win32", "x64").triple, "x86_64-pc-windows-msvc");
 assert.strictEqual(install.platformTarget("win32", "arm64").triple, "aarch64-pc-windows-msvc");
 assert.throws(() => install.platformTarget("freebsd", "x64"), /unsupported platform/);
 
+// detectLibc must return null on non-Linux platforms so the platform key
+// stays `<platform>-<arch>` rather than `<platform>-<arch>-gnu`.
+assert.strictEqual(install.detectLibc("darwin"), null);
+assert.strictEqual(install.detectLibc("win32"), null);
+// On Linux it must always resolve to one of the two known families so
+// `platformTarget` can build a well-formed key.
+const linuxLibc = install.detectLibc("linux");
+assert.ok(linuxLibc === "gnu" || linuxLibc === "musl", `unexpected libc: ${linuxLibc}`);
+
 assert.strictEqual(
-  install.checksumFor("abc123  soldr-v0.7.5-x86_64-unknown-linux-gnu.tar.gz\n", "soldr-v0.7.5-x86_64-unknown-linux-gnu.tar.gz"),
+  install.checksumFor(
+    "abc123  soldr-v0.7.29-x86_64-unknown-linux-gnu.tar.zst\n",
+    "soldr-v0.7.29-x86_64-unknown-linux-gnu.tar.zst",
+  ),
   "abc123",
 );
 
+// Every TARGETS entry must drop the `archive` field — the combined
+// archive format is fixed (.tar.zst) so the per-target field is dead
+// data. Catch a regression early if anyone re-adds it.
+for (const [key, target] of Object.entries(install.TARGETS || {})) {
+  assert.ok(
+    typeof target.triple === "string" && target.triple.length > 0,
+    `TARGETS[${key}].triple must be a non-empty string`,
+  );
+  assert.ok(
+    typeof target.binary === "string" && target.binary.length > 0,
+    `TARGETS[${key}].binary must be a non-empty string`,
+  );
+  assert.strictEqual(
+    target.archive,
+    undefined,
+    `TARGETS[${key}].archive must be removed — archive format is fixed at .tar.zst`,
+  );
+}
+
+// BUNDLED_BINARIES must include soldr, the zccache trio, and crgx.
+// Locks the per-archive layout contract so a future bundling
+// refactor can't quietly drop a binary.
+assert.ok(
+  Array.isArray(install.BUNDLED_BINARIES),
+  "install.BUNDLED_BINARIES must be exported as an array",
+);
+for (const required of [
+  "soldr",
+  "zccache",
+  "zccache-daemon",
+  "zccache-fp",
+  "crgx",
+]) {
+  assert.ok(
+    install.BUNDLED_BINARIES.includes(required),
+    `BUNDLED_BINARIES must include "${required}" (got ${JSON.stringify(install.BUNDLED_BINARIES)})`,
+  );
+}
+
 console.log("npm package and PyPI version checks passed");