@axionorbital/tamarind 1.6.1 → 1.6.2

package/bin/tamarind

@@ -1,5 +1,117 @@
-#!/usr/bin/env sh
-echo "Error: Tamarind's postinstall did not run, so the platform binary is missing." >&2
-echo "This happens with --ignore-scripts or package managers that skip postinstall." >&2
-echo "Fix: cd \"\$(npm root -g)/@axionorbital/tamarind\" && node postinstall.mjs" >&2
-exit 1
+#!/usr/bin/env node
+// Cross-platform launcher for the `tamarind` command (the resolver package's bin).
+//
+// WHY A NODE LAUNCHER (not the native binary directly): npm generates the platform
+// command shims (tamarind / tamarind.cmd / tamarind.ps1) from THIS file's shebang at
+// INSTALL time. A `#!/usr/bin/env sh` stub made npm bake `sh` into tamarind.cmd on
+// Windows → `'"sh"' is not recognized` even after postinstall swapped the file. And a
+// raw .exe can't be a static `bin` target across OSes (the field can't be per-platform,
+// and Windows needs the .exe extension). A Node launcher with `#!/usr/bin/env node`
+// makes npm bake `node` into every shim, and we resolve + spawn the correct platform
+// binary at runtime — so `npm i -g @axionorbital/tamarind` + `tamarind` works uniformly
+// on macOS, Linux (incl. musl/Alpine), and Windows.
+"use strict"
+const { spawnSync } = require("child_process")
+const fs = require("fs")
+const os = require("os")
+const path = require("path")
+
+const SCOPE = "@axionorbital/tamarind"
+const platform = { darwin: "darwin", linux: "linux", win32: "windows" }[os.platform()] || os.platform()
+const arch = { x64: "x64", arm64: "arm64", arm: "arm" }[os.arch()] || os.arch()
+const base = `${SCOPE}-${platform}-${arch}`
+// build.ts compiles the Windows target to `tamarind.exe` (Bun appends .exe); unix is `tamarind`.
+const exe = platform === "windows" ? "tamarind.exe" : "tamarind"
+
+function isMusl() {
+  if (platform !== "linux") return false
+  try {
+    if (fs.existsSync("/etc/alpine-release")) return true
+  } catch {}
+  try {
+    const r = spawnSync("ldd", ["--version"], { encoding: "utf8" })
+    return `${r.stdout || ""}${r.stderr || ""}`.toLowerCase().includes("musl")
+  } catch {
+    return false
+  }
+}
+
+// Candidate platform packages, most-preferred first. Mirrors postinstall.tamarind.mjs
+// (baseline = a build for x64 CPUs without AVX2; musl = Alpine/musl libc). We try the
+// full build first and fall back, so a missing baseline/musl variant still resolves.
+function candidates() {
+  if (platform === "linux") {
+    if (isMusl()) return arch === "x64" ? [`${base}-musl`, `${base}-baseline-musl`, base] : [`${base}-musl`, base]
+    return arch === "x64" ? [base, `${base}-baseline`, `${base}-musl`] : [base, `${base}-musl`]
+  }
+  return arch === "x64" ? [base, `${base}-baseline`] : [base]
+}
+
+// Resolve the platform binary. Prefer require.resolve (finds the optionalDependency npm
+// installed alongside this resolver), then fall back to scanning sibling node_modules
+// (covers odd hoisting layouts).
+function resolveBinary() {
+  const req = require
+  for (const name of candidates()) {
+    try {
+      const pkgJson = req.resolve(`${name}/package.json`)
+      const bin = path.join(path.dirname(pkgJson), "bin", exe)
+      if (fs.existsSync(bin)) return bin
+    } catch {}
+  }
+  // Fallback: walk up from here looking for node_modules/<name>/bin/<exe>.
+  let dir = __dirname
+  for (let i = 0; i < 6; i++) {
+    for (const name of candidates()) {
+      const bin = path.join(dir, "node_modules", ...name.split("/"), "bin", exe)
+      if (fs.existsSync(bin)) return bin
+    }
+    dir = path.dirname(dir)
+  }
+  return null
+}
+
+let binary = resolveBinary()
+
+// If the platform package isn't present (e.g. installed with --no-optional, or a stale
+// install), try a one-shot best-effort install of the matching package, then re-resolve.
+if (!binary) {
+  const version = (() => {
+    try {
+      return require(path.join(__dirname, "..", "package.json")).version
+    } catch {
+      return null
+    }
+  })()
+  for (const name of candidates()) {
+    const spec = version ? `${name}@${version}` : name
+    const r = spawnSync("npm", ["install", "-g", "--no-save", "--loglevel=error", spec], {
+      stdio: "ignore",
+      windowsHide: true,
+    })
+    if (r.status === 0) {
+      binary = resolveBinary()
+      if (binary) break
+    }
+  }
+}
+
+if (!binary) {
+  process.stderr.write(
+    `tamarind: could not find a binary for your platform (${platform}-${arch}).\n` +
+      `Reinstall with:  npm i -g @axionorbital/tamarind\n` +
+      `or install the platform package directly:  ${candidates()
+        .map((n) => `npm i -g ${n}`)
+        .join("\n  ")}\n`,
+  )
+  process.exit(1)
+}
+
+const result = spawnSync(binary, process.argv.slice(2), { stdio: "inherit", windowsHide: false })
+if (result.error) {
+  process.stderr.write(`tamarind: failed to launch (${result.error.message})\n`)
+  process.exit(1)
+}
+// Forward the child's signal/exit code faithfully.
+if (result.signal) process.kill(process.pid, result.signal)
+process.exit(result.status == null ? 1 : result.status)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@axionorbital/tamarind",
-  "version": "1.6.1",
+  "version": "1.6.2",
   "description": "Tamarind — verification-first coding agent for the terminal.",
   "bin": {
     "tamarind": "bin/tamarind"
@@ -24,10 +24,11 @@
     "x64"
   ],
   "optionalDependencies": {
-    "@axionorbital/tamarind-darwin-arm64": "1.6.1",
-    "@axionorbital/tamarind-linux-arm64": "1.6.1",
-    "@axionorbital/tamarind-linux-x64": "1.6.1",
-    "@axionorbital/tamarind-darwin-x64": "1.6.1"
+    "@axionorbital/tamarind-darwin-arm64": "1.6.2",
+    "@axionorbital/tamarind-windows-x64": "1.6.2",
+    "@axionorbital/tamarind-linux-arm64": "1.6.2",
+    "@axionorbital/tamarind-linux-x64": "1.6.2",
+    "@axionorbital/tamarind-darwin-x64": "1.6.2"
   },
   "license": "UNLICENSED",
   "private": false,

package/postinstall.mjs

@@ -93,65 +93,26 @@ function resolveBinary(name) {
   return binaryPath
 }
 
-function copyBinary(source, target) {
-  if (!fs.existsSync(source)) throw new Error(`Binary not found at ${source}`)
-  fs.mkdirSync(path.dirname(target), { recursive: true })
-  if (fs.existsSync(target)) fs.unlinkSync(target)
+// Best-effort ONLY. The `tamarind` command is a Node launcher (bin/tamarind) that
+// resolves + spawns the platform binary at RUNTIME (and self-heals a missing platform
+// package on first run), so this postinstall no longer writes bin/tamarind and MUST NOT
+// hard-fail the install — a non-zero exit here is exactly what made `npm i -g
+// @axionorbital/tamarind` abort on Windows. We just confirm the matching platform
+// package resolved (npm installs it via optionalDependencies); if not, we note it and
+// let the launcher fetch it on first run.
+function resolves(name) {
   try {
-    fs.linkSync(source, target)
-  } catch {
-    fs.copyFileSync(source, target)
-  }
-  fs.chmodSync(target, 0o755)
-}
-
-function installPackage(name) {
-  const version = packageJson.optionalDependencies?.[name]
-  if (!version) return
-  const temp = fs.mkdtempSync(path.join(os.tmpdir(), "tamarind-install-"))
-  try {
-    const result = childProcess.spawnSync(
-      "npm",
-      ["install", "--ignore-scripts", "--no-save", "--loglevel=error", "--prefix", temp, `${name}@${version}`],
-      { stdio: "inherit", windowsHide: true },
-    )
-    if (result.status !== 0) return
-    const packageDir = path.join(temp, "node_modules", name)
-    copyBinary(path.join(packageDir, "bin", sourceBinary), targetBinary)
+    resolveBinary(name)
     return true
-  } finally {
-    fs.rmSync(temp, { recursive: true, force: true })
+  } catch {
+    return false
   }
 }
 
-function verifyBinary() {
-  const result = childProcess.spawnSync(targetBinary, ["--version"], {
-    encoding: "utf8",
-    stdio: "ignore",
-    windowsHide: true,
-  })
-  return result.status === 0
-}
-
-function main() {
-  for (const name of packageNames()) {
-    try {
-      copyBinary(resolveBinary(name), targetBinary)
-      if (verifyBinary()) return
-    } catch {
-      if (installPackage(name) && verifyBinary()) return
-    }
-  }
-  throw new Error(
-    `Could not find a Tamarind binary for your platform. Try manually installing ${packageNames()
-      .map((name) => JSON.stringify(name))
-      .join(" or ")}.`,
+const ok = packageNames().some(resolves)
+if (!ok) {
+  console.warn(
+    "tamarind: platform binary not present yet — the `tamarind` command will fetch it on first run.",
   )
 }
-
-try {
-  main()
-} catch (error) {
-  console.error(error.message)
-  process.exit(1)
-}
+process.exit(0)