juggernaut-bedrock 4.1.0 → 4.2.2

package/index.js

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+"use strict";
+
+var path = require("path");
+var child_process = require("child_process");
+var fs = require("fs");
+
+var PACKAGES_DIR = path.join(__dirname, "packages");
+
+var PLATFORM_MAP = {
+  "linux-x64": "juggernaut-bedrock-linux-x64",
+  "linux-arm64": "juggernaut-bedrock-linux-arm64",
+  "darwin-x64": "juggernaut-bedrock-darwin-x64",
+  "darwin-arm64": "juggernaut-bedrock-darwin-arm64",
+  "win32-x64": "juggernaut-bedrock-win32-x64"
+};
+
+var VALID_PACKAGES = [
+  "juggernaut-bedrock-linux-x64",
+  "juggernaut-bedrock-linux-arm64",
+  "juggernaut-bedrock-darwin-x64",
+  "juggernaut-bedrock-darwin-arm64",
+  "juggernaut-bedrock-win32-x64"
+];
+
+/**
+ * @param {string} platform
+ * @param {string} arch
+ * @returns {string|void}
+ */
+function getPlatformPackage(platform, arch) {
+  return PLATFORM_MAP[platform + "-" + arch] || void 0;
+}
+
+function containsPackage(pkgName) {
+  for (var i = 0; i < VALID_PACKAGES.length; i++) {
+    if (VALID_PACKAGES[i] === pkgName) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * @param {string} pkgName
+ * @param {string} platform
+ * @returns {string}
+ */
+function getBinaryPath(pkgName, platform) {
+  if (!containsPackage(pkgName)) {
+    throw new Error("unexpected package name: " + pkgName);
+  }
+  var binaryName = platform === "win32" ? "juggernaut.exe" : "juggernaut";
+  return path.join(PACKAGES_DIR, pkgName, "bin", binaryName); // nosemgrep: javascript.lang.security.audit.path-traversal.path-join-resolve-traversal.path-join-resolve-traversal
+}
+
+if (require.main === module) {
+  var pkg = getPlatformPackage(process.platform, process.arch);
+  if (!pkg) {
+    process.stderr.write(
+      "juggernaut-bedrock: unsupported platform " + process.platform + "/" + process.arch + "\n" +
+      "Please file an issue: https://github.com/jpvelasco/juggernaut/issues\n"
+    );
+    process.exit(1);
+  }
+
+  var bin = getBinaryPath(pkg, process.platform);
+  // nosemgrep: javascript_pathtraversal_rule-non-literal-fs-filename, javascript.lang.security.audit.detect-non-literal-fs-filename
+  if (!fs.existsSync(bin)) {
+    process.stderr.write(
+      "juggernaut-bedrock: binary not found at " + bin + "\n" +
+      "Try reinstalling: npm install -g juggernaut-bedrock\n" +
+      "If the problem persists, file an issue: https://github.com/jpvelasco/juggernaut/issues\n"
+    );
+    process.exit(1);
+  }
+
+  // nosemgrep: javascript.lang.security.detect-child-process, javascript_exec_rule-child-process
+  var result = child_process.spawnSync(bin, process.argv.slice(2), {
+    stdio: "inherit",
+    env: process.env
+  });
+  process.exit(result.status !== null ? result.status : 1);
+}
+
+module.exports = { getPlatformPackage: getPlatformPackage, getBinaryPath: getBinaryPath };

package/package.json

@@ -1,12 +1,19 @@
 {
   "name": "juggernaut-bedrock",
-  "version": "4.1.0",
+  "version": "4.2.2",
   "description": "Route Claude Code through Amazon Bedrock in one command — IAM, SSO, or API key. Cross-platform CLI for GenAI developers.",
   "bin": {
-    "juggernaut": "./bin/juggernaut"
+    "juggernaut": "./index.js"
   },
   "scripts": {
-    "postinstall": "node install.js"
+    "test": "node --test index.test.js"
+  },
+  "optionalDependencies": {
+    "juggernaut-bedrock-linux-x64": "4.2.2",
+    "juggernaut-bedrock-linux-arm64": "4.2.2",
+    "juggernaut-bedrock-darwin-x64": "4.2.2",
+    "juggernaut-bedrock-darwin-arm64": "4.2.2",
+    "juggernaut-bedrock-win32-x64": "4.2.2"
   },
   "os": [
     "darwin",
@@ -33,10 +40,13 @@
     "sso",
     "developer-tools"
   ],
+  "engines": {
+    "node": ">=20.0.0"
+  },
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/jpvelasco/juggernaut"
+    "url": "git+https://github.com/jpvelasco/juggernaut.git"
   },
   "bugs": {
     "url": "https://github.com/jpvelasco/juggernaut/issues"

package/install.js

@@ -1,204 +0,0 @@
-"use strict";
-
-const https = require("https");
-const fs = require("fs");
-const path = require("path");
-const os = require("os");
-const crypto = require("crypto");
-const { execFile, execFileSync } = require("child_process");
-const { promisify } = require("util");
-
-const execFileAsync = promisify(execFile);
-
-const REPO = "jpvelasco/juggernaut";
-const PACKAGE_DIR = __dirname;
-const BIN_DIR = path.join(PACKAGE_DIR, "bin");
-const TMP_PREFIX = path.join(os.tmpdir(), "juggernaut-install-");
-const ARCHIVE_TAR = "archive.tar.gz";
-const ARCHIVE_ZIP = "archive.zip";
-const BIN_NAME = "juggernaut";
-const ALLOWED_HOSTS = new Set([
-  "github.com",
-  "api.github.com",
-  "release-assets.githubusercontent.com"
-]);
-
-function joinUnder(base, ...segments) {
-  if (base.indexOf("\0") !== -1) {
-    throw new Error("Invalid base path");
-  }
-  for (const seg of segments) {
-    if (seg.indexOf("..") !== -1 || seg.indexOf("/") !== -1 || seg.indexOf("\\") !== -1) {
-      throw new Error(`Invalid path segment: ${seg}`);
-    }
-  }
-  const joined = path.join(base, ...segments);
-  const normalBase = path.normalize(base) + path.sep;
-  const normalJoined = path.normalize(joined);
-  const compare = process.platform === "win32"
-    ? (a, b) => a.toLowerCase().startsWith(b.toLowerCase())
-    : (a, b) => a.startsWith(b);
-  if (!compare(normalJoined, normalBase)) {
-    const exactBase = process.platform === "win32"
-      ? path.normalize(base).toLowerCase()
-      : path.normalize(base);
-    const exactJoined = process.platform === "win32"
-      ? normalJoined.toLowerCase()
-      : normalJoined;
-    if (exactJoined !== exactBase) {
-      throw new Error(`Path traversal detected: ${joined} is outside ${base}`);
-    }
-  }
-  return normalJoined;
-}
-
-function getPlatform() {
-  const osMap = { darwin: "darwin", linux: "linux", win32: "windows" };
-  const archMap = { x64: "amd64", arm64: "arm64" };
-  const p = osMap[process.platform];
-  const a = archMap[process.arch];
-  if (!p || !a) {
-    throw new Error(`Unsupported platform: ${process.platform}/${process.arch}`);
-  }
-  return { os: p, arch: a, platform: `${p}_${a}` };
-}
-
-function httpsGetBuffer(url) {
-  const parsed = new URL(url);
-  if (!ALLOWED_HOSTS.has(parsed.hostname)) {
-    throw new Error(`URL host not allowed: ${parsed.hostname}`);
-  }
-  return new Promise((resolve, reject) => {
-    https
-      .get(url, { headers: { "User-Agent": "juggernaut-npm-installer/1.0" } }, (res) => {
-        if (res.statusCode === 301 || res.statusCode === 302) {
-          const location = res.headers.location;
-          const redirectParsed = new URL(location);
-          if (!ALLOWED_HOSTS.has(redirectParsed.hostname)) {
-            reject(new Error(`Redirect host not allowed: ${redirectParsed.hostname}`));
-            return;
-          }
-          httpsGetBuffer(location).then(resolve).catch(reject);
-          return;
-        }
-        const chunks = [];
-        res.on("data", (chunk) => chunks.push(chunk));
-        res.on("end", () => resolve(Buffer.concat(chunks)));
-        res.on("error", reject);
-      })
-      .on("error", reject);
-  });
-}
-
-async function getLatestVersion() {
-  const data = await httpsGetBuffer(`https://api.github.com/repos/${REPO}/releases/latest`);
-  const release = JSON.parse(data.toString());
-  return release.tag_name.replace(/^v/, "");
-}
-
-function pickArchive(platform, checksumsText) {
-  const tarArchive = `juggernaut_${platform}.tar.gz`;
-  if (checksumsText.includes(tarArchive)) return { name: tarArchive, kind: "tar.gz" };
-  const zipArchive = `juggernaut_${platform}.zip`;
-  if (process.platform === "win32" && checksumsText.includes(zipArchive)) {
-    return { name: zipArchive, kind: "zip" };
-  }
-  throw new Error(`No supported archive found in release checksums for ${platform}`);
-}
-
-function extractTarGz(archiveBuf) {
-  const tmpDir = fs.mkdtempSync(TMP_PREFIX);
-  const archivePath = joinUnder(tmpDir, ARCHIVE_TAR);
-  const prevCwd = process.cwd();
-  try {
-    process.chdir(tmpDir);
-    fs.writeFileSync(ARCHIVE_TAR, archiveBuf);
-    process.chdir(PACKAGE_DIR);
-    fs.mkdirSync("bin", { recursive: true });
-    try {
-      execFileSync("tar", ["-xzf", archivePath, "-C", BIN_DIR], { stdio: "pipe" });
-    } catch (err) {
-      if (err.code === "ENOENT") {
-        throw new Error(
-          "tar not found on PATH. On Windows, use Windows 10 version 1803 or later (includes tar.exe)."
-        );
-      }
-      const detail = err.stderr ? err.stderr.toString().trim() : err.message;
-      throw new Error(`tar extraction failed: ${detail}`);
-    }
-    if (process.platform !== "win32") {
-      process.chdir(BIN_DIR);
-      if (fs.existsSync(BIN_NAME)) {
-        fs.chmodSync(BIN_NAME, 0o700);
-      }
-    }
-  } finally {
-    process.chdir(prevCwd);
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  }
-}
-
-async function extractZip(archiveBuf) {
-  const tmpDir = fs.mkdtempSync(TMP_PREFIX);
-  const archivePath = joinUnder(tmpDir, ARCHIVE_ZIP);
-  const prevCwd = process.cwd();
-  try {
-    process.chdir(tmpDir);
-    fs.writeFileSync(ARCHIVE_ZIP, archiveBuf);
-    process.chdir(PACKAGE_DIR);
-    fs.mkdirSync("bin", { recursive: true });
-    const script = [
-      "$ErrorActionPreference = 'Stop'",
-      `Expand-Archive -LiteralPath '${archivePath.replace(/'/g, "''")}' -DestinationPath '${BIN_DIR.replace(/'/g, "''")}' -Force`
-    ].join("; ");
-    try {
-      await execFileAsync(
-        "powershell",
-        ["-NoProfile", "-NonInteractive", "-Command", script],
-        { stdio: "pipe" }
-      );
-    } catch (err) {
-      if (err.code === "ENOENT") {
-        throw new Error(
-          "PowerShell not found. PowerShell 5.0+ is required to extract archives on Windows."
-        );
-      }
-      const detail = err.stderr ? err.stderr.toString().trim() : err.message;
-      throw new Error(`ZIP extraction failed: ${detail}`);
-    }
-  } finally {
-    process.chdir(prevCwd);
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  }
-}
-
-async function main() {
-  const { platform } = getPlatform();
-  const version = await getLatestVersion();
-  const baseUrl = `https://github.com/${REPO}/releases/download/v${version}`;
-  const checksumsBuf = await httpsGetBuffer(`${baseUrl}/checksums.txt`);
-  const checksums = checksumsBuf.toString("utf8");
-  const { name: archive, kind } = pickArchive(platform, checksums);
-
-  console.log(`Downloading Juggernaut v${version} (${platform})...`);
-  const archiveBuf = await httpsGetBuffer(`${baseUrl}/${archive}`);
-
-  const line = checksums.split("\n").find((l) => l.includes(archive));
-  if (!line) throw new Error(`Checksum not found for ${archive}`);
-  const expected = line.trim().split(/\s+/)[0].toLowerCase();
-  const actual = crypto.createHash("sha256").update(archiveBuf).digest("hex").toLowerCase();
-  if (actual !== expected) {
-    throw new Error(`Checksum mismatch for ${archive}\n  expected: ${expected}\n  got:      ${actual}`);
-  }
-
-  if (kind === "zip") await extractZip(archiveBuf);
-  else extractTarGz(archiveBuf);
-
-  console.log(`Juggernaut v${version} installed successfully.`);
-  console.log(`Run: juggernaut apply`);
-}
-
-main().catch((err) => {
-  console.error("Installation failed:", err.message);
-  process.exit(1);
-});