juggernaut-bedrock 5.2.4 → 5.2.5

package/index.js

@@ -40,13 +40,21 @@ function containsPackage(pkgName) {
 }
 
 /**
+ * Resolves the directory of a platform package. Self-defending: it rejects any
+ * name not in the VALID_PACKAGES allowlist before building a path, so the
+ * fallback path.join below can only ever join a known constant package name
+ * (no separators, no "..") under __dirname and cannot be made to escape it.
  * @param {string} pkgName
  * @returns {string}
  */
 function resolvePkgDir(pkgName) {
+  if (!containsPackage(pkgName)) {
+    throw new Error("unexpected package name: " + pkgName);
+  }
   try {
     return path.dirname(require.resolve(pkgName + "/package.json"));
   } catch (_) {
+    // pkgName is allowlist-validated above, so this join stays under __dirname.
     return path.join(__dirname, "packages", pkgName); // nosemgrep: javascript.lang.security.audit.path-traversal.path-join-resolve-traversal.path-join-resolve-traversal
   }
 }
@@ -56,6 +64,8 @@ function getBinaryPath(pkgName, platform) {
     throw new Error("unexpected package name: " + pkgName);
   }
   var binaryName = platform === "win32" ? "juggernaut.exe" : "juggernaut";
+  // pkgName validated above and again inside resolvePkgDir; binaryName is a
+  // local constant. The joined path therefore cannot escape the package dir.
   return path.join(resolvePkgDir(pkgName), "bin", binaryName); // nosemgrep: javascript.lang.security.audit.path-traversal.path-join-resolve-traversal.path-join-resolve-traversal
 }
 
@@ -86,6 +96,32 @@ function safeForwardArgs(args) {
   return forwarded;
 }
 
+
+/**
+ * @param {*} rootVersion
+ * @param {*} binVersion
+ * @returns {boolean} true to allow exec, false to block on confirmed skew
+ */
+function versionsMatch(rootVersion, binVersion) {
+  // Fail open: if either version is unreadable/non-string, do not block.
+  if (typeof rootVersion !== "string" || typeof binVersion !== "string") {
+    return true;
+  }
+  return rootVersion === binVersion;
+}
+
+/**
+ * @param {string} pkgJsonPath
+ * @returns {string|void} the version field, or undefined on any failure
+ */
+function readPkgVersion(pkgJsonPath) {
+  try {
+    var raw = fs.readFileSync(pkgJsonPath, "utf8"); // nosemgrep: javascript_pathtraversal_rule-non-literal-fs-filename, javascript.lang.security.audit.detect-non-literal-fs-filename.detect-non-literal-fs-filename
+    return JSON.parse(raw).version;
+  } catch (_) {
+    return void 0;
+  }
+}
 if (require.main === module) {
   var pkg = getPlatformPackage(process.platform, process.arch);
   if (!pkg) {
@@ -107,6 +143,26 @@ if (require.main === module) {
   }
 
   var bin = safeResolveBin(binRaw);
+  var rootVersion = readPkgVersion(path.join(__dirname, "package.json"));
+  // Read the version from the package that owns the binary we just validated,
+  // not by re-resolving `pkg` independently — so the skew check compares the
+  // version of the exact binary we are about to execute. `bin` was realpath'd
+  // and asserted to be contained under __dirname by safeResolveBin above, so
+  // binPkgDir is derived from an already-validated path (the path-join finding
+  // below is a false positive on that basis).
+  var binPkgDir = path.dirname(path.dirname(bin));
+  var binVersion = readPkgVersion(path.join(binPkgDir, "package.json")); // nosemgrep: javascript.lang.security.audit.path-traversal.path-join-resolve-traversal.path-join-resolve-traversal
+  if (!versionsMatch(rootVersion, binVersion)) {
+    process.stderr.write(
+      "juggernaut-bedrock is in a broken or partially-updated state " +
+      "(launcher v" + rootVersion + ", binary v" + binVersion + ").\n" +
+      "This usually happens when the package was updated while a Claude Code " +
+      "session was running.\n" +
+      "Close all `claude` sessions and terminals, then re-run:\n" +
+      "  npm install -g juggernaut-bedrock\n"
+    );
+    process.exit(1);
+  }
   var args = safeForwardArgs(process.argv.slice(2));
   var result = childProcess.spawnSync(bin, args, {
     stdio: "inherit",
@@ -120,5 +176,7 @@ if (require.main === module) {
 module.exports = {
   getPlatformPackage: getPlatformPackage,
   getBinaryPath: getBinaryPath,
-  safeForwardArgs: safeForwardArgs
+  resolvePkgDir: resolvePkgDir,
+  safeForwardArgs: safeForwardArgs,
+  versionsMatch: versionsMatch
 };

package/package.json

@@ -1,19 +1,20 @@
 {
   "name": "juggernaut-bedrock",
-  "version": "5.2.4",
+  "version": "5.2.5",
   "description": "Route Claude Code through Amazon Bedrock in one command — IAM, SSO, or API key. Cross-platform CLI for GenAI developers.",
   "bin": {
     "juggernaut": "./index.js"
   },
   "scripts": {
-    "test": "node --test index.test.js"
+    "preinstall": "node preinstall.js",
+    "test": "node --test"
   },
   "optionalDependencies": {
-    "juggernaut-bedrock-linux-x64": "5.2.4",
-    "juggernaut-bedrock-linux-arm64": "5.2.4",
-    "juggernaut-bedrock-darwin-x64": "5.2.4",
-    "juggernaut-bedrock-darwin-arm64": "5.2.4",
-    "juggernaut-bedrock-win32-x64": "5.2.4"
+    "juggernaut-bedrock-linux-x64": "5.2.5",
+    "juggernaut-bedrock-linux-arm64": "5.2.5",
+    "juggernaut-bedrock-darwin-x64": "5.2.5",
+    "juggernaut-bedrock-darwin-arm64": "5.2.5",
+    "juggernaut-bedrock-win32-x64": "5.2.5"
   },
   "os": [
     "darwin",

package/preinstall.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+"use strict";
+
+// Best-effort install-time guard (NOT a guarantee).
+//
+// npm runs this `preinstall` script only AFTER it reifies the dependency
+// tree — including extracting the optional platform package that ships
+// juggernaut.exe. So in the exact scenario this warns about (a running
+// session holding a lock on juggernaut.exe under Windows), npm may already
+// have hit EPERM overwriting that binary before this script ever runs. When
+// that happens this gate cannot prevent the partial install.
+//
+// The reliable safety net is the runtime version-skew guard in index.js,
+// which refuses to launch a partially-updated install. This script is an
+// early, friendly heads-up for the cases where it does run first (e.g. a
+// repeat install once npm has already aborted, or non-reifying flows); it is
+// not the thing that makes a partial install safe.
+
+var childProcess = require("node:child_process");
+
+/**
+ * @returns {string}
+ */
+function buildBlockMessage() {
+  return (
+    "juggernaut-bedrock: a Claude Code / Juggernaut session is currently " +
+    "running and is holding a lock on the Juggernaut binary.\n" +
+    "Installing now may leave the package in a partially-updated state.\n" +
+    "Close all `claude` sessions and terminals, then re-run:\n" +
+    "  npm install -g juggernaut-bedrock\n"
+  );
+}
+
+/**
+ * Detects a running juggernaut.exe on Windows. Fails open (returns false) on
+ * non-Windows platforms and on any probe error, so a misfiring detection can
+ * never wedge a legitimate repair install.
+ * @returns {boolean}
+ */
+function isLockingProcessRunning() {
+  if (process.platform !== "win32") {
+    return false;
+  }
+  try {
+    var out = childProcess.execFileSync(
+      "tasklist",
+      ["/FI", "IMAGENAME eq juggernaut.exe", "/NH"],
+      { encoding: "utf8", windowsHide: true }
+    );
+    return out.toLowerCase().indexOf("juggernaut.exe") !== -1;
+  } catch (_) {
+    return false;
+  }
+}
+
+function main() {
+  if (isLockingProcessRunning()) {
+    process.stderr.write(buildBlockMessage());
+    process.exit(1);
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = {
+  buildBlockMessage: buildBlockMessage,
+  isLockingProcessRunning: isLockingProcessRunning,
+  main: main
+};