@abacus-ai/cli 2.5.2-canary.3 → 2.5.3-canary.0

package/package.json

@@ -1,21 +1,18 @@
 {
   "name": "@abacus-ai/cli",
-  "version": "2.5.2-canary.3",
-  "type": "module",
+  "version": "2.5.3-canary.0",
   "bin": {
-    "abacusai": "dist/index.mjs"
+    "abacusai": "scripts/npm-wrapper/shim.cjs"
+  },
+  "scripts": {
+    "postinstall": "node scripts/npm-wrapper/install.cjs"
   },
   "files": [
-    "dist",
+    "scripts/npm-wrapper/install.cjs",
+    "scripts/npm-wrapper/shim.cjs",
     "LICENSE.txt"
   ],
   "engines": {
     "node": ">=18"
-  },
-  "dependencies": {
-    "koffi": "^2.15.1",
-    "@vscode/ripgrep": "1.17.1",
-    "trash": "^10.1.1",
-    "node-notifier": "^10.0.1"
   }
 }

package/scripts/npm-wrapper/install.cjs

@@ -0,0 +1,159 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+const https = require("node:https");
+const { execFileSync } = require("node:child_process");
+const { pipeline } = require("node:stream/promises");
+
+const BASE_URL = "https://static.abacus.ai/cli/releases";
+const PKG_ROOT = path.resolve(__dirname, "..", "..");
+const PKG_JSON = require(path.join(PKG_ROOT, "package.json"));
+const VERSION = PKG_JSON.version;
+
+function detectInstallPm() {
+  const ua = process.env.npm_config_user_agent ?? "";
+  const name = ua.split("/")[0];
+  if (name === "yarn" || name === "pnpm" || name === "bun" || name === "npm") return name;
+  return "npm";
+}
+
+function detectPlatform() {
+  const arch = process.arch;
+  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}`);
+  }
+}
+
+function download(url, dest) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(dest);
+    https
+      .get(url, { headers: { "user-agent": "abacusai-npm-installer" } }, (res) => {
+        if (
+          res.statusCode &&
+          res.statusCode >= 300 &&
+          res.statusCode < 400 &&
+          res.headers.location
+        ) {
+          file.close();
+          fs.unlink(dest, () => {});
+          download(res.headers.location, dest).then(resolve, reject);
+          return;
+        }
+        if (res.statusCode !== 200) {
+          file.close();
+          fs.unlink(dest, () => {});
+          reject(new Error(`Download failed: HTTP ${res.statusCode} for ${url}`));
+          return;
+        }
+        pipeline(res, file).then(resolve, reject);
+      })
+      .on("error", (err) => {
+        file.close();
+        fs.unlink(dest, () => {});
+        reject(err);
+      });
+  });
+}
+
+function extract(archivePath, destDir, ext) {
+  if (ext === "tar.gz") {
+    execFileSync("tar", ["-xzf", archivePath, "-C", destDir], { stdio: "ignore" });
+  } else {
+    execFileSync(
+      "powershell.exe",
+      [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        `Expand-Archive -Path '${archivePath}' -DestinationPath '${destDir}' -Force`,
+      ],
+      { stdio: "ignore" },
+    );
+  }
+}
+
+function readStamp(stampPath) {
+  try {
+    return fs.readFileSync(stampPath, "utf8").trim();
+  } catch {
+    return null;
+  }
+}
+
+function replaceBinary(stagedPath, targetPath) {
+  try {
+    fs.renameSync(stagedPath, targetPath);
+    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);
+}
+
+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");
+
+  if (readStamp(stampPath) === VERSION && fs.existsSync(targetPath)) return;
+
+  fs.mkdirSync(binDir, { recursive: true });
+
+  const archiveName = `abacusai-${target}.${ext}`;
+  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`);
+
+  try {
+    await download(url, archivePath);
+    extract(archivePath, tmpDir, ext);
+
+    const sourceBinary = path.join(tmpDir, binaryName);
+    const stagedPath = `${targetPath}.new`;
+    fs.copyFileSync(sourceBinary, stagedPath);
+    if (process.platform !== "win32") fs.chmodSync(stagedPath, 0o755);
+
+    replaceBinary(stagedPath, targetPath);
+    fs.writeFileSync(stampPath, VERSION);
+    fs.writeFileSync(path.join(binDir, ".install-source"), detectInstallPm());
+
+    process.stdout.write(`abacusai: installed v${VERSION} to ${targetPath}\n`);
+  } finally {
+    try {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    } catch {}
+  }
+}
+
+main().catch((err) => {
+  process.stderr.write(`abacusai: install failed: ${err && err.message ? err.message : err}\n`);
+  process.stderr.write(
+    `         Re-run with: npm rebuild ${PKG_JSON.name}  (or run \`abacusai\` to retry)\n`,
+  );
+  process.exit(0);
+});

package/scripts/npm-wrapper/shim.cjs

@@ -0,0 +1,45 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require("node:fs");
+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 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);
+  }
+}
+
+function readInstallSource() {
+  try {
+    return fs.readFileSync(path.join(BIN_DIR, ".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() },
+});
+
+if (result.error) {
+  process.stderr.write(`abacusai: failed to launch binary: ${result.error.message}\n`);
+  process.exit(1);
+}
+
+if (result.signal) {
+  process.kill(process.pid, result.signal);
+  return;
+}
+
+process.exit(result.status ?? 0);