@usearete/a4 0.6.0 → 0.7.1

package/bin/a4.js

@@ -7,54 +7,100 @@ const fs = require("fs");
 const binName = process.platform === "win32" ? "a4.exe" : "a4";
 const localBinPath = path.join(__dirname, binName);
 
-// Try local binary first, then fall back to PATH
-function getBinaryPath() {
+const RECURSION_SENTINEL = "ARETE_A4_LAUNCHER_ACTIVE";
+
+function canonicalPath(candidate) {
+  try {
+    return fs.realpathSync(candidate);
+  } catch {
+    return path.resolve(candidate);
+  }
+}
+
+function pathCandidates(env = process.env, platform = process.platform) {
+  const names = platform === "win32" ? ["a4.exe"] : ["a4"];
+  return (env.PATH || "")
+    .split(path.delimiter)
+    .filter(Boolean)
+    .flatMap((directory) => names.map((name) => path.join(directory, name)));
+}
+
+function isExecutableFile(candidate, platform = process.platform) {
+  try {
+    if (!fs.statSync(candidate).isFile()) return false;
+    if (platform !== "win32") {
+      fs.accessSync(candidate, fs.constants.X_OK);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Try the concrete postinstall destination first, then every PATH candidate
+// except this JavaScript launcher (including symlinks in node_modules/.bin).
+function getBinaryPath(env = process.env, platform = process.platform) {
+  const launcherPaths = new Set(
+    [__filename, process.argv[1]].filter(Boolean).map(canonicalPath)
+  );
+
   // 1. Check for bundled binary (npm postinstall)
-  if (fs.existsSync(localBinPath)) {
+  if (
+    isExecutableFile(localBinPath, platform)
+    && !launcherPaths.has(canonicalPath(localBinPath))
+  ) {
     return localBinPath;
   }
 
   // 2. Check system PATH (cargo install, manual install)
-  const whichCmd = process.platform === "win32" ? "where" : "which";
-  const result = spawnSync(whichCmd, ["a4"], { encoding: "utf8" });
-  if (result.status === 0 && result.stdout) {
-    const systemBin = result.stdout.trim().split("\n")[0];
-    if (fs.existsSync(systemBin)) {
-      return systemBin;
-    }
+  for (const candidate of pathCandidates(env, platform)) {
+    if (!isExecutableFile(candidate, platform)) continue;
+    if (launcherPaths.has(canonicalPath(candidate))) continue;
+    return candidate;
   }
 
   return null;
 }
 
-const binPath = getBinaryPath();
-
-if (!binPath) {
-  console.error(
-    "Arete CLI binary not found. This usually means the postinstall script failed.\n" +
-    "Try reinstalling: npm install @usearete/a4\n" +
-    "\n" +
-    "If the problem persists, you can install the CLI via Cargo:\n" +
-    "  cargo install a4-cli"
-  );
-  process.exit(1);
-}
+function main() {
+  if (process.env[RECURSION_SENTINEL] === "1") {
+    console.error("Refusing to recursively launch the Arete CLI shim.");
+    process.exit(1);
+  }
 
-const result = spawnSync(binPath, process.argv.slice(2), {
-  stdio: "inherit",
-  env: process.env,
-});
+  const binPath = getBinaryPath();
 
-if (result.error) {
-  if (result.error.code === "EACCES") {
+  if (!binPath) {
     console.error(
-      "Permission denied. Try running:\n" +
-      `  chmod +x "${binPath}"`
+      "Arete CLI binary not found. This usually means the postinstall script failed.\n" +
+      "Try reinstalling: npm install @usearete/a4\n" +
+      "\n" +
+      "If the problem persists, you can install the CLI via Cargo:\n" +
+      "  cargo install a4-cli"
     );
-  } else {
-    console.error("Failed to run Arete CLI:", result.error.message);
+    process.exit(1);
   }
-  process.exit(1);
+
+  const result = spawnSync(binPath, process.argv.slice(2), {
+    stdio: "inherit",
+    env: { ...process.env, [RECURSION_SENTINEL]: "1" },
+  });
+
+  if (result.error) {
+    if (result.error.code === "EACCES") {
+      console.error(
+        "Permission denied. Try running:\n" +
+        `  chmod +x "${binPath}"`
+      );
+    } else {
+      console.error("Failed to run Arete CLI:", result.error.message);
+    }
+    process.exit(1);
+  }
+
+  process.exit(result.status ?? 1);
 }
 
-process.exit(result.status ?? 1);
+if (require.main === module) main();
+
+module.exports = { canonicalPath, getBinaryPath, pathCandidates };

package/bin/a4.test.js

@@ -0,0 +1,86 @@
+const assert = require("node:assert/strict");
+const { spawnSync } = require("node:child_process");
+const fs = require("node:fs");
+const os = require("node:os");
+const path = require("node:path");
+const test = require("node:test");
+
+const { canonicalPath, getBinaryPath } = require("./a4.js");
+
+test("skips a symlink to the launcher and selects the next native binary", (t) => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "arete-a4-launcher-"));
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+  const shimDir = path.join(root, "shim");
+  const nativeDir = path.join(root, "native");
+  fs.mkdirSync(shimDir);
+  fs.mkdirSync(nativeDir);
+  fs.symlinkSync(__dirname + "/a4.js", path.join(shimDir, "a4"));
+  const native = path.join(nativeDir, "a4");
+  fs.writeFileSync(native, "#!/bin/sh\nexit 0\n", { mode: 0o755 });
+
+  const selected = getBinaryPath({ PATH: [shimDir, nativeDir].join(path.delimiter) }, "darwin");
+  assert.equal(canonicalPath(selected), canonicalPath(native));
+});
+
+test("returns null when PATH only resolves to the launcher", (t) => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "arete-a4-launcher-"));
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+  fs.symlinkSync(__dirname + "/a4.js", path.join(root, "a4"));
+  assert.equal(getBinaryPath({ PATH: root }, "darwin"), null);
+});
+
+test(
+  "skips non-executable files and directories before a native binary",
+  { skip: process.platform === "win32" },
+  (t) => {
+    const root = fs.mkdtempSync(path.join(os.tmpdir(), "arete-a4-launcher-"));
+    t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+    const fileDir = path.join(root, "file");
+    const directoryDir = path.join(root, "directory");
+    const nativeDir = path.join(root, "native");
+    fs.mkdirSync(fileDir);
+    fs.mkdirSync(directoryDir);
+    fs.mkdirSync(nativeDir);
+    fs.writeFileSync(path.join(fileDir, "a4"), "not executable\n", { mode: 0o644 });
+    fs.mkdirSync(path.join(directoryDir, "a4"));
+    const native = path.join(nativeDir, "a4");
+    fs.writeFileSync(native, "#!/bin/sh\nexit 0\n", { mode: 0o755 });
+
+    const selected = getBinaryPath({
+      PATH: [fileDir, directoryDir, nativeDir].join(path.delimiter),
+    });
+    assert.equal(canonicalPath(selected), canonicalPath(native));
+  }
+);
+
+test("skips Windows command shims and directories before a native binary", (t) => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "arete-a4-launcher-"));
+  t.after(() => fs.rmSync(root, { recursive: true, force: true }));
+  const shimDir = path.join(root, "shim");
+  const directoryDir = path.join(root, "directory");
+  const nativeDir = path.join(root, "native");
+  fs.mkdirSync(shimDir);
+  fs.mkdirSync(directoryDir);
+  fs.mkdirSync(nativeDir);
+  fs.writeFileSync(path.join(shimDir, "a4"), "#!/bin/sh\n");
+  fs.writeFileSync(path.join(shimDir, "a4.cmd"), "@echo off\n");
+  fs.writeFileSync(path.join(shimDir, "a4.bat"), "@echo off\n");
+  fs.mkdirSync(path.join(directoryDir, "a4.exe"));
+  const native = path.join(nativeDir, "a4.exe");
+  fs.writeFileSync(native, "native binary placeholder\n");
+
+  const selected = getBinaryPath({
+    PATH: [shimDir, directoryDir, nativeDir].join(path.delimiter),
+  }, "win32");
+  assert.equal(canonicalPath(selected), canonicalPath(native));
+});
+
+test("recursion sentinel stops the launcher before resolving another a4", () => {
+  const result = spawnSync(process.execPath, [path.join(__dirname, "a4.js")], {
+    encoding: "utf8",
+    env: { ...process.env, ARETE_A4_LAUNCHER_ACTIVE: "1" },
+  });
+
+  assert.equal(result.status, 1);
+  assert.match(result.stderr, /Refusing to recursively launch/);
+});

package/package.json

@@ -1,12 +1,13 @@
 {
   "name": "@usearete/a4",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "description": "Arete CLI (a4) - Real-time Solana streaming pipelines",
   "bin": {
     "a4": "bin/a4.js"
   },
   "scripts": {
-    "postinstall": "node scripts/postinstall.js"
+    "postinstall": "node scripts/postinstall.js",
+    "test": "node --test bin/*.test.js"
   },
   "repository": {
     "type": "git",