fatou-cli 0.10.0 → 0.11.1

package/bin/fatou.js

@@ -1,81 +1,140 @@
 #!/usr/bin/env node
 
-const { execFileSync } = require("node:child_process");
+const { execFileSync, spawnSync } = require("node:child_process");
+
+const PACKAGES = {
+  "linux-x64-gnu": "@fatou-cli/linux-x64-gnu",
+  "linux-arm64-gnu": "@fatou-cli/linux-arm64-gnu",
+  "linux-x64-musl": "@fatou-cli/linux-x64-musl",
+  "linux-arm64-musl": "@fatou-cli/linux-arm64-musl",
+  "darwin-x64": "@fatou-cli/darwin-x64",
+  "darwin-arm64": "@fatou-cli/darwin-arm64",
+  "win32-x64": "@fatou-cli/win32-x64",
+  "win32-arm64": "@fatou-cli/win32-arm64",
+};
 
 function detectLibc() {
-	if (process.platform !== "linux") return null;
-	try {
-		const report = process.report.getReport();
-		return report.header.glibcVersionRuntime ? "gnu" : "musl";
-	} catch {
-		return "gnu";
-	}
+  if (process.platform !== "linux") return null;
+  try {
+    const report = process.report.getReport();
+    return report.header.glibcVersionRuntime ? "gnu" : "musl";
+  } catch {
+    return "gnu";
+  }
+}
+
+// Candidate platform keys in preference order. On linux the other libc
+// flavor is kept as a fallback: a host can report glibc yet be unable to
+// run generic glibc binaries (NixOS has no loader at the standard path),
+// while the musl build is statically linked and runs anywhere.
+function candidateKeys() {
+  const { platform, arch } = process;
+  const libc = detectLibc();
+  if (!libc) return [`${platform}-${arch}`];
+  const other = libc === "gnu" ? "musl" : "gnu";
+  return [`${platform}-${arch}-${libc}`, `${platform}-${arch}-${other}`];
 }
 
-function platformPackage() {
-	const { platform, arch } = process;
-	const libc = detectLibc();
+function resolveCandidates() {
+  const keys = candidateKeys();
+  if (!PACKAGES[keys[0]]) {
+    throw new Error(
+      `fatou-cli does not ship a prebuilt binary for ${keys[0]}.\n` +
+        `Supported platforms: linux (x64/arm64, gnu+musl), darwin (x64/arm64), win32 (x64/arm64).\n` +
+        `See https://github.com/jolars/fatou for alternative install methods.`,
+    );
+  }
+  const binaryName = process.platform === "win32" ? "fatou.exe" : "fatou";
+  const candidates = [];
+  let firstError;
+  for (const key of keys) {
+    try {
+      candidates.push(require.resolve(`${PACKAGES[key]}/${binaryName}`));
+    } catch (err) {
+      firstError = firstError ?? err;
+    }
+  }
+  if (candidates.length === 0) {
+    throw new Error(
+      `fatou-cli expected the optional dependency ${PACKAGES[keys[0]]} to be installed, ` +
+        `but it could not be resolved.\n` +
+        `This usually means npm skipped it (e.g. \`--no-optional\` or a registry/network issue ` +
+        `during install). Try reinstalling with optional dependencies enabled.\n` +
+        `Original error: ${firstError.message}`,
+    );
+  }
+  return candidates;
+}
 
-	const map = {
-		"linux-x64-gnu": "@fatou-cli/linux-x64-gnu",
-		"linux-arm64-gnu": "@fatou-cli/linux-arm64-gnu",
-		"linux-x64-musl": "@fatou-cli/linux-x64-musl",
-		"linux-arm64-musl": "@fatou-cli/linux-arm64-musl",
-		"darwin-x64": "@fatou-cli/darwin-x64",
-		"darwin-arm64": "@fatou-cli/darwin-arm64",
-		"win32-x64": "@fatou-cli/win32-x64",
-		"win32-arm64": "@fatou-cli/win32-arm64",
-	};
+function runnable(binary) {
+  const probe = spawnSync(binary, ["--version"], { stdio: "ignore" });
+  return probe.error == null && probe.status === 0;
+}
+
+// With a single candidate, trust it: probing every invocation would cost an
+// extra process spawn in the common case. Probing is reserved for the
+// unusual setup where both libc flavors are installed side by side.
+function pickBinary(candidates) {
+  if (candidates.length === 1) return candidates[0];
+  for (const binary of candidates) {
+    if (runnable(binary)) return binary;
+  }
+  return candidates[0];
+}
 
-	const key = libc ? `${platform}-${arch}-${libc}` : `${platform}-${arch}`;
-	return { key, name: map[key] };
+function loaderHint() {
+  const libc = detectLibc();
+  if (libc !== "gnu") return;
+  const muslPackage = PACKAGES[`${process.platform}-${process.arch}-musl`];
+  process.stderr.write(
+    `The glibc build of fatou cannot run on this system (no standard glibc loader; ` +
+      `on NixOS this is expected).\n` +
+      `The statically linked musl build works anywhere. Package managers skip it on ` +
+      `glibc hosts, so add it explicitly:\n` +
+      `  npm:  npm install --force ${muslPackage}\n` +
+      `  pnpm: pnpm config set supportedArchitectures.libc '["glibc","musl"]' && pnpm install\n` +
+      `Or install fatou via other means; ` +
+      `see https://github.com/jolars/fatou.\n`,
+  );
 }
 
 function resolveBinary() {
-	const { key, name } = platformPackage();
-	if (!name) {
-		throw new Error(
-			`fatou-cli does not ship a prebuilt binary for ${key}.\n` +
-				`Supported platforms: linux (x64/arm64, gnu+musl), darwin (x64/arm64), win32 (x64/arm64).\n` +
-				`See https://github.com/jolars/fatou for alternative install methods.`,
-		);
-	}
-	const binaryName = process.platform === "win32" ? "fatou.exe" : "fatou";
-	try {
-		return require.resolve(`${name}/${binaryName}`);
-	} catch (err) {
-		throw new Error(
-			`fatou-cli expected the optional dependency ${name} to be installed, ` +
-				`but it could not be resolved.\n` +
-				`This usually means npm skipped it (e.g. \`--no-optional\` or a registry/network issue ` +
-				`during install). Try reinstalling with optional dependencies enabled.\n` +
-				`Original error: ${err.message}`,
-		);
-	}
+  return pickBinary(resolveCandidates());
 }
 
 function main() {
-	let binary;
-	try {
-		binary = resolveBinary();
-	} catch (err) {
-		process.stderr.write(`${err.message}\n`);
-		process.exit(1);
-	}
+  let binary;
+  try {
+    binary = resolveBinary();
+  } catch (err) {
+    process.stderr.write(`${err.message}\n`);
+    process.exit(1);
+  }
 
-	try {
-		execFileSync(binary, process.argv.slice(2), { stdio: "inherit" });
-	} catch (err) {
-		if (typeof err.status === "number") {
-			process.exit(err.status);
-		}
-		if (err.signal) {
-			process.kill(process.pid, err.signal);
-			return;
-		}
-		process.stderr.write(`Failed to execute fatou: ${err.message}\n`);
-		process.exit(1);
-	}
+  try {
+    execFileSync(binary, process.argv.slice(2), { stdio: "inherit" });
+  } catch (err) {
+    if (typeof err.status === "number") {
+      // 127 is the loader stub's exit code on hosts that cannot run the
+      // glibc build; probe to distinguish that from fatou itself
+      // exiting 127 before hinting.
+      if (err.status === 127 && !runnable(binary)) {
+        loaderHint();
+      }
+      process.exit(err.status);
+    }
+    if (err.signal) {
+      process.kill(process.pid, err.signal);
+      return;
+    }
+    // The binary resolved but could not be spawned; a missing dynamic
+    // loader surfaces as ENOENT on hosts without NixOS's stub.
+    if (err.code === "ENOENT") {
+      loaderHint();
+    }
+    process.stderr.write(`Failed to execute fatou: ${err.message}\n`);
+    process.exit(1);
+  }
 }
 
 main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fatou-cli",
-  "version": "0.10.0",
+  "version": "0.11.1",
   "description": "A language server, formatter, and linter for Julia",
   "keywords": [
     "julia",
@@ -28,13 +28,13 @@
     "node": ">=20"
   },
   "optionalDependencies": {
-    "@fatou-cli/linux-x64-gnu": "0.10.0",
-    "@fatou-cli/linux-arm64-gnu": "0.10.0",
-    "@fatou-cli/linux-x64-musl": "0.10.0",
-    "@fatou-cli/linux-arm64-musl": "0.10.0",
-    "@fatou-cli/darwin-x64": "0.10.0",
-    "@fatou-cli/darwin-arm64": "0.10.0",
-    "@fatou-cli/win32-x64": "0.10.0",
-    "@fatou-cli/win32-arm64": "0.10.0"
+    "@fatou-cli/linux-x64-gnu": "0.11.1",
+    "@fatou-cli/linux-arm64-gnu": "0.11.1",
+    "@fatou-cli/linux-x64-musl": "0.11.1",
+    "@fatou-cli/linux-arm64-musl": "0.11.1",
+    "@fatou-cli/darwin-x64": "0.11.1",
+    "@fatou-cli/darwin-arm64": "0.11.1",
+    "@fatou-cli/win32-x64": "0.11.1",
+    "@fatou-cli/win32-arm64": "0.11.1"
   }
 }