lucentracode 0.2.6 → 0.2.9

package/bin/lucentracode.js

@@ -1,227 +1,227 @@
-#!/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)
-}
-
-// Make sure the binary is actually executable before trying to run it.
-//
-// It frequently is not. These packages are built and published from Windows, which has
-// no POSIX permission bits, so npm records mode 0644 in the tar header and every macOS
-// and Linux install extracts a binary it is not allowed to execute:
-//
-//     spawnSync .../bin/lucentracode EACCES
-//
-// Fixing it at pack time would mean the release only ever being publishable from a
-// POSIX machine -- a rule that holds until the day someone publishes from a laptop.
-// Fixing it here makes the tar mode irrelevant, which is the property worth having.
-function ensureExecutable(file) {
-  if (platform === "windows") return null
-  try {
-    const mode = fs.statSync(file).mode
-    if (mode & 0o111) return null
-    fs.chmodSync(file, (mode & 0o7777) | 0o755)
-    return null
-  } catch (err) {
-    // A read-only or root-owned install directory. Report it rather than failing with
-    // a bare EACCES, because the fix is one command and the user cannot guess it.
-    return err
-  }
-}
-
-const chmodError = ensureExecutable(resolved)
-
-// `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) {
-  const lines = [`${PRODUCT}: could not start the binary.`, `  ${resolved}`, ``, `${result.error.message}`]
-  if (result.error.code === "EACCES") {
-    lines.push(
-      ``,
-      `The binary is not marked executable.` +
-        (chmodError ? ` Making it executable failed: ${chmodError.message}` : ``),
-      ``,
-      `Fix it with:`,
-      `  chmod +x ${resolved}`,
-      ``,
-      `If that is denied, reinstall somewhere you own, or use sudo for the chmod.`,
-    )
-  }
-  process.stderr.write(lines.join("\n") + "\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)
+#!/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)
+}
+
+// Make sure the binary is actually executable before trying to run it.
+//
+// It frequently is not. These packages are built and published from Windows, which has
+// no POSIX permission bits, so npm records mode 0644 in the tar header and every macOS
+// and Linux install extracts a binary it is not allowed to execute:
+//
+//     spawnSync .../bin/lucentracode EACCES
+//
+// Fixing it at pack time would mean the release only ever being publishable from a
+// POSIX machine -- a rule that holds until the day someone publishes from a laptop.
+// Fixing it here makes the tar mode irrelevant, which is the property worth having.
+function ensureExecutable(file) {
+  if (platform === "windows") return null
+  try {
+    const mode = fs.statSync(file).mode
+    if (mode & 0o111) return null
+    fs.chmodSync(file, (mode & 0o7777) | 0o755)
+    return null
+  } catch (err) {
+    // A read-only or root-owned install directory. Report it rather than failing with
+    // a bare EACCES, because the fix is one command and the user cannot guess it.
+    return err
+  }
+}
+
+const chmodError = ensureExecutable(resolved)
+
+// `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) {
+  const lines = [`${PRODUCT}: could not start the binary.`, `  ${resolved}`, ``, `${result.error.message}`]
+  if (result.error.code === "EACCES") {
+    lines.push(
+      ``,
+      `The binary is not marked executable.` +
+        (chmodError ? ` Making it executable failed: ${chmodError.message}` : ``),
+      ``,
+      `Fix it with:`,
+      `  chmod +x ${resolved}`,
+      ``,
+      `If that is denied, reinstall somewhere you own, or use sudo for the chmod.`,
+    )
+  }
+  process.stderr.write(lines.join("\n") + "\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.2.6",
+  "version": "0.2.9",
   "description": "AI coding agent for the terminal, powered by the LucentraCode gateway.",
   "license": "MIT",
   "repository": {
@@ -36,17 +36,17 @@
     "x64"
   ],
   "optionalDependencies": {
-    "lucentracode-windows-x64-baseline": "0.2.6",
-    "lucentracode-windows-x64": "0.2.6",
-    "lucentracode-windows-arm64": "0.2.6",
-    "lucentracode-linux-x64-musl": "0.2.6",
-    "lucentracode-linux-x64-baseline-musl": "0.2.6",
-    "lucentracode-linux-x64-baseline": "0.2.6",
-    "lucentracode-linux-x64": "0.2.6",
-    "lucentracode-linux-arm64-musl": "0.2.6",
-    "lucentracode-linux-arm64": "0.2.6",
-    "lucentracode-darwin-x64-baseline": "0.2.6",
-    "lucentracode-darwin-x64": "0.2.6",
-    "lucentracode-darwin-arm64": "0.2.6"
+    "lucentracode-windows-x64-baseline": "0.2.9",
+    "lucentracode-windows-x64": "0.2.9",
+    "lucentracode-windows-arm64": "0.2.9",
+    "lucentracode-linux-x64-musl": "0.2.9",
+    "lucentracode-linux-x64-baseline-musl": "0.2.9",
+    "lucentracode-linux-x64-baseline": "0.2.9",
+    "lucentracode-linux-x64": "0.2.9",
+    "lucentracode-linux-arm64-musl": "0.2.9",
+    "lucentracode-linux-arm64": "0.2.9",
+    "lucentracode-darwin-x64-baseline": "0.2.9",
+    "lucentracode-darwin-x64": "0.2.9",
+    "lucentracode-darwin-arm64": "0.2.9"
   }
 }