@abacus-ai/cli 2.5.5-canary.8 → 2.6.0-canary.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@abacus-ai/cli",
-  "version": "2.5.5-canary.8",
+  "version": "2.6.0-canary.10",
   "bin": {
     "abacusai": "scripts/npm-wrapper/shim.cjs"
   },

package/scripts/npm-wrapper/install.cjs

@@ -20,21 +20,103 @@ function detectInstallPm() {
   return "npm";
 }
 
+// glibc builds report a runtime glibc version; musl builds do not.
+function isMuslLinux() {
+  if (process.platform !== "linux") return false;
+  try {
+    return !process.report.getReport().header.glibcVersionRuntime;
+  } catch {
+    return false;
+  }
+}
+
+// Native CPU arch — corrected for emulation so we match what install.sh/install.ps1
+// resolve. process.arch reports x64 for a Rosetta-translated process on Apple Silicon
+// and for an x64-emulated process on Windows ARM64; both should get the arm64 build.
+function detectArch() {
+  let arch = process.arch;
+  if (arch === "x64" && process.platform === "darwin") {
+    try {
+      if (
+        execFileSync("sysctl", ["-n", "sysctl.proc_translated"], { encoding: "utf8" }).trim() ===
+        "1"
+      )
+        arch = "arm64";
+    } catch {}
+  }
+  if (arch === "x64" && process.platform === "win32") {
+    try {
+      const out = execFileSync(
+        "reg",
+        [
+          "query",
+          "HKLM\\SYSTEM\\CurrentControlSet\\Control\\Session Manager\\Environment",
+          "/v",
+          "PROCESSOR_ARCHITECTURE",
+        ],
+        { encoding: "utf8" },
+      );
+      if (/\bARM64\b/i.test(out)) arch = "arm64";
+    } catch {}
+  }
+  return arch;
+}
+
+// x64 CPUs without AVX2 need the -baseline build.
+function isBaselineX64(arch) {
+  if (arch !== "x64") return false;
+  try {
+    if (process.platform === "linux") {
+      return !fs.readFileSync("/proc/cpuinfo", "utf8").includes("avx2");
+    }
+    if (process.platform === "darwin") {
+      return !/avx2/i.test(
+        execFileSync("sysctl", ["-n", "machdep.cpu.leaf7_features"], { encoding: "utf8" }),
+      );
+    }
+    if (process.platform === "win32") {
+      // PF_AVX2_INSTRUCTIONS_AVAILABLE = 40
+      const out = execFileSync(
+        "powershell.exe",
+        [
+          "-NoProfile",
+          "-NonInteractive",
+          "-Command",
+          "[int]((Add-Type -PassThru -Name AbacusCpu -Namespace Win32 -MemberDefinition '[DllImport(\"kernel32.dll\")] public static extern bool IsProcessorFeaturePresent(int f);')::IsProcessorFeaturePresent(40))",
+        ],
+        { encoding: "utf8" },
+      );
+      return out.trim() === "0";
+    }
+  } catch {
+    return false; // detection failed → assume modern CPU
+  }
+  return false;
+}
+
+// -musl wins over -baseline: a glibc binary won't load on musl, and there's no
+// combined artifact (a non-AVX2 musl host is an unbuilt combo).
+function variantSuffix(arch) {
+  if (isMuslLinux()) return "-musl";
+  if (isBaselineX64(arch)) return "-baseline";
+  return "";
+}
+
 function detectPlatform() {
-  const arch = process.arch;
+  const arch = detectArch();
   if (arch !== "x64" && arch !== "arm64") {
     throw new Error(`Unsupported architecture: ${arch}`);
   }
-  switch (process.platform) {
-    case "darwin":
-      return { target: `darwin-${arch}`, ext: "tar.gz", binaryName: "abacusai" };
-    case "linux":
-      return { target: `linux-${arch}`, ext: "tar.gz", binaryName: "abacusai" };
-    case "win32":
-      return { target: `win32-${arch}`, ext: "zip", binaryName: "abacusai.exe" };
-    default:
-      throw new Error(`Unsupported operating system: ${process.platform}`);
+  const platform = process.platform;
+  if (platform !== "darwin" && platform !== "linux" && platform !== "win32") {
+    throw new Error(`Unsupported operating system: ${platform}`);
   }
+  const win = platform === "win32";
+  return {
+    target: `${platform}-${arch}${variantSuffix(arch)}`,
+    ext: win ? "zip" : "tar.gz",
+    binaryName: win ? "abacusai.exe" : "abacusai",
+  };
 }
 
 function download(url, dest) {
@@ -86,48 +168,52 @@ function extract(archivePath, destDir, ext) {
   }
 }
 
-function readStamp(stampPath) {
-  try {
-    return fs.readFileSync(stampPath, "utf8").trim();
-  } catch {
-    return null;
-  }
-}
+// Per-version cache under the user's home, shared across npm installs and every
+// npx/bunx run — so the same version is downloaded once, and older versions stay
+// available to roll back to if a release fails to launch.
+const VERSIONS_DIR = path.join(os.homedir(), ".abacusai", "versions");
+const MAX_CACHED_VERSIONS = 3;
 
-function replaceBinary(stagedPath, targetPath) {
+// Keep the newest few version dirs (by mtime); the cache is ~80 MB each.
+function pruneOldVersions(keep) {
+  let dirs;
   try {
-    fs.renameSync(stagedPath, targetPath);
+    dirs = fs.readdirSync(VERSIONS_DIR);
+  } catch {
     return;
-  } catch (err) {
-    if (process.platform !== "win32") throw err;
   }
-  const oldPath = `${targetPath}.old`;
-  try {
-    fs.unlinkSync(oldPath);
-  } catch {}
-  try {
-    fs.renameSync(targetPath, oldPath);
-  } catch {}
-  fs.renameSync(stagedPath, targetPath);
+  const scored = [];
+  for (const v of dirs) {
+    try {
+      scored.push({ v, mtime: fs.statSync(path.join(VERSIONS_DIR, v)).mtimeMs });
+    } catch {}
+  }
+  scored.sort((a, b) => b.mtime - a.mtime);
+  for (const { v } of scored.slice(MAX_CACHED_VERSIONS)) {
+    if (v === keep) continue;
+    try {
+      fs.rmSync(path.join(VERSIONS_DIR, v), { recursive: true, force: true });
+    } catch {}
+  }
 }
 
 async function main() {
   const { target, ext, binaryName } = detectPlatform();
-  const binDir = path.join(PKG_ROOT, "bin");
-  const targetPath = path.join(binDir, binaryName);
-  const stampPath = path.join(binDir, ".version");
+  const version = process.env.ABACUSAI_TARGET_VERSION || VERSION;
+  const versionDir = path.join(VERSIONS_DIR, version);
+  const targetPath = path.join(versionDir, binaryName);
 
-  if (readStamp(stampPath) === VERSION && fs.existsSync(targetPath)) return;
+  if (fs.existsSync(targetPath)) return;
 
-  fs.mkdirSync(binDir, { recursive: true });
+  fs.mkdirSync(versionDir, { recursive: true });
 
   const archiveName = `abacusai-${target}.${ext}`;
-  const url = `${BASE_URL}/${VERSION}/${archiveName}`;
+  const url = `${BASE_URL}/${version}/${archiveName}`;
 
   const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "abacusai-install-"));
   const archivePath = path.join(tmpDir, archiveName);
 
-  process.stdout.write(`abacusai: downloading v${VERSION} for ${target}...\n`);
+  process.stdout.write(`abacusai: downloading v${version} for ${target}...\n`);
 
   try {
     await download(url, archivePath);
@@ -137,13 +223,12 @@ async function main() {
     const stagedPath = `${targetPath}.new`;
     fs.copyFileSync(sourceBinary, stagedPath);
     if (process.platform !== "win32") fs.chmodSync(stagedPath, 0o755);
+    fs.renameSync(stagedPath, targetPath); // atomic within the version dir
 
-    replaceBinary(stagedPath, targetPath);
-
-    fs.writeFileSync(stampPath, VERSION);
-    fs.writeFileSync(path.join(binDir, ".install-source"), detectInstallPm());
+    fs.writeFileSync(path.join(versionDir, ".install-source"), detectInstallPm());
+    pruneOldVersions(version);
 
-    process.stdout.write(`abacusai: installed v${VERSION} to ${targetPath}\n`);
+    process.stdout.write(`abacusai: installed v${version} to ${targetPath}\n`);
   } finally {
     try {
       fs.rmSync(tmpDir, { recursive: true, force: true });

package/scripts/npm-wrapper/shim.cjs

@@ -2,44 +2,107 @@
 "use strict";
 
 const fs = require("node:fs");
+const os = require("node:os");
 const path = require("node:path");
 const { spawnSync } = require("node:child_process");
 
 const PKG_ROOT = path.resolve(__dirname, "..", "..");
-const BIN_DIR = path.join(PKG_ROOT, "bin");
+const VERSION = require(path.join(PKG_ROOT, "package.json")).version;
 const BINARY_NAME = process.platform === "win32" ? "abacusai.exe" : "abacusai";
-const BINARY_PATH = path.join(BIN_DIR, BINARY_NAME);
-
-if (!fs.existsSync(BINARY_PATH)) {
-  const installer = path.join(__dirname, "install.cjs");
-  const res = spawnSync(process.execPath, [installer], { stdio: "inherit" });
-  if (res.status !== 0 || !fs.existsSync(BINARY_PATH)) {
-    process.stderr.write(`abacusai: failed to install native binary at ${BINARY_PATH}\n`);
-    process.exit(res.status ?? 1);
-  }
-}
+
+// Binaries are cached per-version under the user's home, NOT inside the package
+// dir — so ephemeral runners (npx/bunx) that recreate the package each run still
+// reuse the download, and so older versions remain available to roll back to.
+const VERSIONS_DIR = path.join(os.homedir(), ".abacusai", "versions");
+const binaryFor = (version) => path.join(VERSIONS_DIR, version, BINARY_NAME);
+
+// A binary that dies with one of these never actually ran — wrong arch, missing
+// libc, truncated download. Distinct from a normal non-zero exit.
+const FATAL_SIGNALS = new Set(["SIGILL", "SIGSEGV", "SIGABRT", "SIGTRAP", "SIGBUS"]);
+const LAUNCH_FAILURE_MS = 3000;
 
 function readInstallSource() {
   try {
-    return fs.readFileSync(path.join(BIN_DIR, ".install-source"), "utf8").trim() || "npm";
+    return (
+      fs.readFileSync(path.join(VERSIONS_DIR, VERSION, ".install-source"), "utf8").trim() || "npm"
+    );
   } catch {
     return "npm";
   }
 }
 
-const result = spawnSync(BINARY_PATH, process.argv.slice(2), {
-  stdio: "inherit",
-  env: { ...process.env, ABACUSAI_INSTALL_SOURCE: readInstallSource() },
-});
+function ensureBinary(version) {
+  const target = binaryFor(version);
+  if (fs.existsSync(target)) return target;
+  spawnSync(process.execPath, [path.join(__dirname, "install.cjs")], {
+    stdio: "inherit",
+    env: { ...process.env, ABACUSAI_TARGET_VERSION: version },
+  });
+  return fs.existsSync(target) ? target : null;
+}
+
+// Newest cached binary other than `exclude` (by mtime), to roll back to.
+function newestCachedFallback(exclude) {
+  let versions;
+  try {
+    versions = fs.readdirSync(VERSIONS_DIR);
+  } catch {
+    return null;
+  }
+  let best = null;
+  for (const v of versions) {
+    if (v === exclude) continue;
+    const bin = binaryFor(v);
+    let mtime;
+    try {
+      mtime = fs.statSync(bin).mtimeMs;
+    } catch {
+      continue;
+    }
+    if (!best || mtime > best.mtime) best = { version: v, bin, mtime };
+  }
+  return best;
+}
+
+function run(binPath) {
+  const start = Date.now();
+  const res = spawnSync(binPath, process.argv.slice(2), {
+    stdio: "inherit",
+    env: { ...process.env, ABACUSAI_INSTALL_SOURCE: readInstallSource() },
+  });
+  const launchFailed =
+    !!res.error ||
+    (!!res.signal && FATAL_SIGNALS.has(res.signal) && Date.now() - start < LAUNCH_FAILURE_MS);
+  return { res, launchFailed };
+}
 
-if (result.error) {
-  process.stderr.write(`abacusai: failed to launch binary: ${result.error.message}\n`);
+const binPath = ensureBinary(VERSION);
+if (!binPath) {
+  process.stderr.write(`abacusai: failed to install native binary for v${VERSION}\n`);
   process.exit(1);
 }
 
-if (result.signal) {
-  process.kill(process.pid, result.signal);
-  return;
+let { res, launchFailed } = run(binPath);
+
+// A corrupt/incompatible release must not brick the CLI: if the binary couldn't
+// launch, fall back to the newest other cached version so the user keeps working
+// (and can update past the bad release).
+if (launchFailed) {
+  const fallback = newestCachedFallback(VERSION);
+  if (fallback) {
+    process.stderr.write(
+      `abacusai: v${VERSION} failed to launch — falling back to cached v${fallback.version}.\n`,
+    );
+    ({ res } = run(fallback.bin));
+  }
 }
 
-process.exit(result.status ?? 0);
+if (res.error) {
+  process.stderr.write(`abacusai: failed to launch binary: ${res.error.message}\n`);
+  process.exit(1);
+}
+if (res.signal) {
+  process.kill(process.pid, res.signal);
+} else {
+  process.exit(res.status ?? 0);
+}