lucentracode 0.1.0 → 0.2.0

package/README.md

@@ -32,9 +32,13 @@ lucentracode logout
 
 ## Install notes
 
-This package contains no binary. On install it pulls the one
-`lucentracode-<os>-<arch>` package that matches your machine, so you download one
-platform's worth of bytes rather than all of them.
+This package contains no binary. On install npm pulls only the
+`lucentracode-<os>-<arch>` packages matching your machine, not all twelve.
+
+On arm64 that is one package. On x64 it is two or more: the `-baseline` build
+exists for CPUs without AVX2, and package.json cannot express "requires AVX2" --
+only `os` and `cpu`, which both x64 variants declare identically. npm therefore
+fetches both and the postinstall picks the right one at runtime.
 
 If you install with `--ignore-scripts` (or with pnpm, which defaults to that),
 run the postinstall by hand:

package/bin/lucentracode.js

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+"use strict"
+
+// Shipped as `bin/lucentracode.js` inside the published `lucentracode` package, and it
+// is the package's only `bin` entry.
+//
+// WHY A LAUNCHER INSTEAD OF A POSTINSTALL
+//
+// The first release used the conventional trick: ship a placeholder at the `bin` path
+// and have a postinstall script overwrite it with the real platform binary. That is
+// broken on current npm and cannot be fixed from the package side.
+//
+// npm made install scripts opt-in (npm 11.10) and off by default (npm 12), so
+// `postinstall` simply does not run. The package then presents a placeholder as its
+// executable. Ours began `#!/bin/sh`, so npm generated a Windows shim that invoked
+// `/bin/sh` and users got:
+//
+//     The term '/bin/sh.exe' is not recognized...
+//
+// And there is no recovery path for a global install: the warning npm prints tells the
+// user to run `npm approve-scripts`, which refuses global installs with EGLOBAL
+// (npm/cli#9463).
+//
+// So resolution moved from install time to run time. This file is plain CommonJS with a
+// node shebang, which means npm generates an ordinary `node`-invoking shim on every
+// platform, and the package declares no install scripts at all -- nothing to approve,
+// nothing to block, no warning.
+//
+// The cost is one Node process in front of the binary. That is the price of an install
+// that works, and it is what esbuild and friends settled on for the same reason.
+
+const { spawnSync } = require("child_process")
+const fs = require("fs")
+const os = require("os")
+const path = require("path")
+
+const PRODUCT = "lucentracode"
+
+const platformMap = { darwin: "darwin", linux: "linux", win32: "windows" }
+const archMap = { x64: "x64", arm64: "arm64" }
+
+const platform = platformMap[os.platform()] || os.platform()
+const arch = archMap[os.arch()] || os.arch()
+const base = `${PRODUCT}-${platform}-${arch}`
+const binaryName = platform === "windows" ? `${PRODUCT}.exe` : PRODUCT
+
+// Bun's default x64 build assumes AVX2. On a CPU without it the binary dies with an
+// illegal instruction and no explanation, so pre-~2013 hardware needs `-baseline`.
+//
+// This detection is why the choice cannot be left to npm: `package.json` has no field
+// meaning "requires AVX2" -- only `os` and `cpu`, which both x64 variants declare
+// identically. npm therefore installs both and the decision lands here.
+function supportsAvx2() {
+  if (arch !== "x64") return false
+
+  try {
+    if (platform === "linux") {
+      return /(^|\s)avx2(\s|$)/i.test(fs.readFileSync("/proc/cpuinfo", "utf8"))
+    }
+
+    if (platform === "darwin") {
+      const r = spawnSync("sysctl", ["-n", "hw.optional.avx2_0"], { encoding: "utf8", timeout: 1500 })
+      return r.status === 0 && (r.stdout || "").trim() === "1"
+    }
+
+    if (platform === "windows") {
+      // PF_AVX2_INSTRUCTIONS_AVAILABLE == 40
+      const command =
+        '(Add-Type -MemberDefinition "[DllImport(""kernel32.dll"")] public static extern bool IsProcessorFeaturePresent(int ProcessorFeature);" -Name K32 -Namespace W32 -PassThru)::IsProcessorFeaturePresent(40)'
+      for (const exe of ["powershell.exe", "pwsh.exe"]) {
+        const r = spawnSync(exe, ["-NoProfile", "-NonInteractive", "-Command", command], {
+          encoding: "utf8",
+          timeout: 3000,
+          windowsHide: true,
+        })
+        if (r.status !== 0) continue
+        const out = (r.stdout || "").trim().toLowerCase()
+        if (out === "true") return true
+        if (out === "false") return false
+      }
+    }
+  } catch {
+    // Detection is best-effort; a failure falls through to the safe answer below.
+  }
+
+  // Unknown means "assume the older CPU": a baseline binary runs everywhere, while an
+  // AVX2 binary on a pre-AVX2 chip crashes with no usable message.
+  return false
+}
+
+// Alpine and other musl distros need a musl-linked build; a glibc one fails at load
+// with an error naming neither libc nor the product.
+function isMusl() {
+  if (platform !== "linux") return false
+  try {
+    if (fs.existsSync("/etc/alpine-release")) return true
+  } catch {
+    /* probing may be blocked; fall through */
+  }
+  try {
+    const r = spawnSync("ldd", ["--version"], { encoding: "utf8" })
+    return `${r.stdout || ""}${r.stderr || ""}`.toLowerCase().includes("musl")
+  } catch {
+    return false
+  }
+}
+
+// Ordered best-first. Detection can be wrong -- a container may hide /proc/cpuinfo,
+// `ldd` may be absent -- so a bad guess falls through to the next candidate instead of
+// failing outright.
+function candidates() {
+  const baseline = arch === "x64" && !supportsAvx2()
+
+  if (platform === "linux") {
+    if (isMusl()) {
+      if (arch === "x64") {
+        return baseline
+          ? [`${base}-baseline-musl`, `${base}-musl`, `${base}-baseline`, base]
+          : [`${base}-musl`, `${base}-baseline-musl`, base, `${base}-baseline`]
+      }
+      return [`${base}-musl`, base]
+    }
+    if (arch === "x64") {
+      return baseline
+        ? [`${base}-baseline`, base, `${base}-baseline-musl`, `${base}-musl`]
+        : [base, `${base}-baseline`, `${base}-musl`, `${base}-baseline-musl`]
+    }
+    return [base, `${base}-musl`]
+  }
+
+  if (arch === "x64") return baseline ? [`${base}-baseline`, base] : [base, `${base}-baseline`]
+  return [base]
+}
+
+function resolveBinary() {
+  const tried = []
+  for (const name of candidates()) {
+    try {
+      const pkgJson = require.resolve(`${name}/package.json`)
+      const candidate = path.join(path.dirname(pkgJson), "bin", binaryName)
+      if (fs.existsSync(candidate)) return candidate
+      tried.push(`${name} (installed, but ${binaryName} missing)`)
+    } catch {
+      tried.push(`${name} (not installed)`)
+    }
+  }
+  return { error: tried }
+}
+
+const resolved = resolveBinary()
+
+if (typeof resolved !== "string") {
+  const lines = [
+    `${PRODUCT}: no binary for your platform (${os.platform()} ${os.arch()}).`,
+    "",
+    "Looked for:",
+    ...resolved.error.map((t) => `  - ${t}`),
+    "",
+    "This usually means the install was partial. Try:",
+    `  npm install -g ${PRODUCT} --force`,
+    "",
+    `If it persists, report it with your OS and CPU at`,
+    `  https://github.com/aryanbains/lucencode-cli/issues`,
+  ]
+  process.stderr.write(lines.join("\n") + "\n")
+  process.exit(1)
+}
+
+// `stdio: "inherit"` hands the real terminal to the child, which the TUI requires: it
+// needs a genuine TTY for raw mode, resize events and colour. It also means the
+// terminal delivers Ctrl+C to the foreground process group, so the child sees the
+// signal directly rather than depending on the parent to relay it.
+const result = spawnSync(resolved, process.argv.slice(2), { stdio: "inherit", windowsHide: false })
+
+if (result.error) {
+  process.stderr.write(`${PRODUCT}: could not start ${resolved}\n${result.error.message}\n`)
+  process.exit(1)
+}
+
+// Report a signal death as a signal death (128+n), the way a shell does, so wrappers
+// and CI can tell "interrupted" from "exited non-zero".
+if (result.signal) {
+  const signals = { SIGINT: 2, SIGQUIT: 3, SIGKILL: 9, SIGTERM: 15, SIGHUP: 1 }
+  process.exit(128 + (signals[result.signal] || 0))
+}
+
+process.exit(result.status === null ? 1 : result.status)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lucentracode",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "AI coding agent for the terminal, powered by the LucentraCode gateway.",
   "license": "MIT",
   "repository": {
@@ -21,10 +21,10 @@
     "lucentracode"
   ],
   "bin": {
-    "lucentracode": "./bin/lucentracode.exe"
+    "lucentracode": "./bin/lucentracode.js"
   },
-  "scripts": {
-    "postinstall": "node ./postinstall.mjs"
+  "engines": {
+    "node": ">=18"
   },
   "os": [
     "darwin",
@@ -36,17 +36,17 @@
     "x64"
   ],
   "optionalDependencies": {
-    "lucentracode-windows-x64-baseline": "0.1.0",
-    "lucentracode-windows-x64": "0.1.0",
-    "lucentracode-windows-arm64": "0.1.0",
-    "lucentracode-linux-x64-musl": "0.1.0",
-    "lucentracode-linux-x64-baseline-musl": "0.1.0",
-    "lucentracode-linux-x64-baseline": "0.1.0",
-    "lucentracode-linux-x64": "0.1.0",
-    "lucentracode-linux-arm64-musl": "0.1.0",
-    "lucentracode-linux-arm64": "0.1.0",
-    "lucentracode-darwin-x64-baseline": "0.1.0",
-    "lucentracode-darwin-x64": "0.1.0",
-    "lucentracode-darwin-arm64": "0.1.0"
+    "lucentracode-windows-x64-baseline": "0.2.0",
+    "lucentracode-windows-x64": "0.2.0",
+    "lucentracode-windows-arm64": "0.2.0",
+    "lucentracode-linux-x64-musl": "0.2.0",
+    "lucentracode-linux-x64-baseline-musl": "0.2.0",
+    "lucentracode-linux-x64-baseline": "0.2.0",
+    "lucentracode-linux-x64": "0.2.0",
+    "lucentracode-linux-arm64-musl": "0.2.0",
+    "lucentracode-linux-arm64": "0.2.0",
+    "lucentracode-darwin-x64-baseline": "0.2.0",
+    "lucentracode-darwin-x64": "0.2.0",
+    "lucentracode-darwin-arm64": "0.2.0"
   }
 }

package/bin/lucentracode.exe

@@ -1,11 +0,0 @@
-#!/bin/sh
-echo "Error: lucentracode's postinstall script did not run." >&2
-echo "" >&2
-echo "This happens with --ignore-scripts, and with package managers such as pnpm" >&2
-echo "that do not run postinstall scripts by default." >&2
-echo "" >&2
-echo "Fix it by running:" >&2
-echo "  cd node_modules/lucentracode && node postinstall.mjs" >&2
-echo "" >&2
-echo "Or reinstall without --ignore-scripts." >&2
-exit 1

package/postinstall.mjs

@@ -1,224 +0,0 @@
-#!/usr/bin/env node
-
-// Installed as `postinstall.mjs` inside the published `lucentracode` package.
-//
-// LucentraCode fork of script/postinstall.mjs. It is a separate file rather than an
-// edit because the upstream one is still used by upstream's own release path, and
-// because every identifier in here is a published package name -- a merge that
-// silently reverted `lucentracode-linux-x64` to `opencode-linux-x64` would make our
-// installer pull a different product's binary. Keeping them apart makes that
-// impossible rather than merely unlikely.
-//
-// What it does: npm has already installed whichever `lucentracode-<platform>-<arch>`
-// optional dependency matches this machine. This finds it and hard-links (or
-// copies) the real binary over the placeholder shim at bin/lucentracode.exe.
-
-import childProcess from "child_process"
-import fs from "fs"
-import os from "os"
-import path from "path"
-import { createRequire } from "module"
-import { fileURLToPath } from "url"
-
-const __dirname = path.dirname(fileURLToPath(import.meta.url))
-const require = createRequire(import.meta.url)
-const packageJson = JSON.parse(fs.readFileSync(path.join(__dirname, "package.json"), "utf8"))
-
-const PRODUCT = "lucentracode"
-
-const platformMap = {
-  darwin: "darwin",
-  linux: "linux",
-  win32: "windows",
-}
-const archMap = {
-  x64: "x64",
-  arm64: "arm64",
-  arm: "arm",
-}
-
-const platform = platformMap[os.platform()] ?? os.platform()
-const arch = archMap[os.arch()] ?? os.arch()
-const base = `${PRODUCT}-${platform}-${arch}`
-const sourceBinary = platform === "windows" ? `${PRODUCT}.exe` : PRODUCT
-// Always `.exe`, on every platform. The published `bin` entry has to point at a
-// path that exists before this script runs, and the same path afterwards; using one
-// name everywhere means there is exactly one thing to replace. npm sets the
-// executable bit from the bin field regardless of the extension.
-const targetBinary = path.join(__dirname, "bin", `${PRODUCT}.exe`)
-
-// AVX2 detection. Bun's default x64 build assumes AVX2; on a CPU without it the
-// binary dies with an illegal instruction and no useful message, so pre-~2013
-// hardware needs the `-baseline` variant instead.
-function supportsAvx2() {
-  if (arch !== "x64") return false
-
-  if (platform === "linux") {
-    try {
-      return /(^|\s)avx2(\s|$)/i.test(fs.readFileSync("/proc/cpuinfo", "utf8"))
-    } catch {
-      return false
-    }
-  }
-
-  if (platform === "darwin") {
-    try {
-      const result = childProcess.spawnSync("sysctl", ["-n", "hw.optional.avx2_0"], {
-        encoding: "utf8",
-        timeout: 1500,
-      })
-      if (result.status !== 0) return false
-      return (result.stdout || "").trim() === "1"
-    } catch {
-      return false
-    }
-  }
-
-  if (platform === "windows") {
-    const command =
-      '(Add-Type -MemberDefinition "[DllImport(""kernel32.dll"")] public static extern bool IsProcessorFeaturePresent(int ProcessorFeature);" -Name Kernel32 -Namespace Win32 -PassThru)::IsProcessorFeaturePresent(40)'
-
-    for (const executable of ["powershell.exe", "pwsh.exe", "pwsh", "powershell"]) {
-      try {
-        const result = childProcess.spawnSync(executable, ["-NoProfile", "-NonInteractive", "-Command", command], {
-          encoding: "utf8",
-          timeout: 3000,
-          windowsHide: true,
-        })
-        if (result.status !== 0) continue
-        const output = (result.stdout || "").trim().toLowerCase()
-        if (output === "true" || output === "1") return true
-        if (output === "false" || output === "0") return false
-      } catch {
-        continue
-      }
-    }
-  }
-
-  return false
-}
-
-// Alpine and other musl distros need a musl-linked binary; a glibc one fails at
-// load time with an error that mentions neither libc nor LucentraCode.
-function isMusl() {
-  if (platform !== "linux") return false
-
-  try {
-    if (fs.existsSync("/etc/alpine-release")) return true
-  } catch {
-    // Ignore filesystem probes that are blocked by the host.
-  }
-
-  try {
-    const result = childProcess.spawnSync("ldd", ["--version"], { encoding: "utf8" })
-    return `${result.stdout || ""}${result.stderr || ""}`.toLowerCase().includes("musl")
-  } catch {
-    return false
-  }
-}
-
-// Ordered best-first, with fallbacks. Detection can be wrong -- a container may
-// hide /proc/cpuinfo, `ldd` may be absent -- so a wrong guess degrades to trying
-// the next candidate instead of failing the install.
-function packageNames() {
-  const baseline = arch === "x64" && !supportsAvx2()
-
-  if (platform === "linux") {
-    if (isMusl()) {
-      if (arch === "x64")
-        return baseline
-          ? [`${base}-baseline-musl`, `${base}-musl`, `${base}-baseline`, base]
-          : [`${base}-musl`, `${base}-baseline-musl`, base, `${base}-baseline`]
-      return [`${base}-musl`, base]
-    }
-
-    if (arch === "x64")
-      return baseline
-        ? [`${base}-baseline`, base, `${base}-baseline-musl`, `${base}-musl`]
-        : [base, `${base}-baseline`, `${base}-musl`, `${base}-baseline-musl`]
-    return [base, `${base}-musl`]
-  }
-
-  if (arch === "x64") return baseline ? [`${base}-baseline`, base] : [base, `${base}-baseline`]
-  return [base]
-}
-
-function resolveBinary(name) {
-  const packageJsonPath = require.resolve(`${name}/package.json`)
-  const binaryPath = path.join(path.dirname(packageJsonPath), "bin", sourceBinary)
-  if (!fs.existsSync(binaryPath)) throw new Error(`Binary not found at ${binaryPath}`)
-  return binaryPath
-}
-
-// pnpm and yarn PnP sometimes do not place optional dependencies where
-// require.resolve can see them. Rather than fail, fetch the one package we need
-// into a temp prefix and take the binary out of it.
-function installPackage(name) {
-  const version = packageJson.optionalDependencies?.[name]
-  if (!version) return
-
-  const temp = fs.mkdtempSync(path.join(os.tmpdir(), `${PRODUCT}-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)
-    return true
-  } finally {
-    fs.rmSync(temp, { recursive: true, force: true })
-  }
-}
-
-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)
-  try {
-    // A hard link avoids a second ~140 MB on disk. Falls back to a copy when the
-    // store and the project are on different filesystems.
-    fs.linkSync(source, target)
-  } catch {
-    fs.copyFileSync(source, target)
-  }
-  fs.chmodSync(target, 0o755)
-}
-
-// Actually run it. A binary that is present but cannot execute -- wrong libc,
-// wrong instruction set, truncated download -- must fall through to the next
-// candidate rather than be declared installed.
-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(
-    `Your package manager did not install a matching LucentraCode binary. Try installing ${packageNames()
-      .map((name) => JSON.stringify(name))
-      .join(" or ")} manually, or report this at https://github.com/aryanbains/lucencode-cli/issues with your OS and CPU architecture.`,
-  )
-}
-
-try {
-  main()
-} catch (error) {
-  console.error(error.message)
-  process.exit(1)
-}