slopcode 0.2.65 → 0.2.67

package/bin/slopcode

@@ -5,6 +5,7 @@ const childProcess = require("child_process")
 const fs = require("fs")
 const path = require("path")
 const os = require("os")
+const pkg = require("../package.json")
 
 function run(target) {
   const result = childProcess.spawnSync(target, process.argv.slice(2), {
@@ -25,13 +26,9 @@ if (envPath) {
 
 const scriptPath = fs.realpathSync(__filename)
 const scriptDir = path.dirname(scriptPath)
-
-//
 const cached = path.join(scriptDir, ".slopcode")
-if (fs.existsSync(cached)) {
-  run(cached)
-}
-
+const meta = path.join(scriptDir, ".slopcode.json")
+const sidecar = path.join(scriptDir, "neovim")
 const platformMap = {
   darwin: "darwin",
   linux: "linux",
@@ -42,6 +39,11 @@ const archMap = {
   arm64: "arm64",
   arm: "arm",
 }
+const supported = {
+  darwin: ["arm64", "x64"],
+  linux: ["arm64", "x64"],
+  windows: ["x64"],
+}
 
 let platform = platformMap[os.platform()]
 if (!platform) {
@@ -53,28 +55,55 @@ if (!arch) {
 }
 const binary = platform === "windows" ? "slopcode.exe" : "slopcode"
 
+function remove(target) {
+  if (!fs.existsSync(target)) return
+  fs.rmSync(target, { recursive: true, force: true })
+}
+
+function clearCache() {
+  remove(cached)
+  remove(meta)
+  remove(sidecar)
+}
+
+function libc() {
+  if (platform !== "linux") return
+  const report = process.report?.getReport?.()
+  if (typeof report?.header?.glibcVersionRuntime === "string" && report.header.glibcVersionRuntime) {
+    return "glibc"
+  }
+  if (fs.existsSync("/etc/alpine-release")) return "musl"
+  const getconf = childProcess.spawnSync("getconf", ["GNU_LIBC_VERSION"], {
+    encoding: "utf8",
+    timeout: 1500,
+  })
+  const fromGetconf = ((getconf.stdout || "") + (getconf.stderr || "")).toLowerCase()
+  if (getconf.status === 0 && fromGetconf.includes("glibc")) return "glibc"
+  const result = childProcess.spawnSync("ldd", ["--version"], {
+    encoding: "utf8",
+    timeout: 1500,
+  })
+  const text = ((result.stdout || "") + (result.stderr || "")).toLowerCase()
+  if (text.includes("musl")) return "musl"
+  if (text.includes("glibc") || text.includes("gnu libc")) return "glibc"
+  const loader = arch === "arm64" ? "/lib/ld-musl-aarch64.so.1" : arch === "x64" ? "/lib/ld-musl-x86_64.so.1" : ""
+  if (loader && fs.existsSync(loader)) return "musl"
+}
+
 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
-    }
+    return /(^|\s)avx2(\s|$)/i.test(fs.readFileSync("/proc/cpuinfo", "utf8"))
   }
 
   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
-    }
+    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"
   }
 
   if (platform === "windows") {
@@ -82,22 +111,16 @@ function supportsAvx2() {
       '(Add-Type -MemberDefinition "[DllImport(""kernel32.dll"")] public static extern bool IsProcessorFeaturePresent(int ProcessorFeature);" -Name Kernel32 -Namespace Win32 -PassThru)::IsProcessorFeaturePresent(40)'
 
     for (const exe of ["powershell.exe", "pwsh.exe", "pwsh", "powershell"]) {
-      try {
-        const result = childProcess.spawnSync(exe, ["-NoProfile", "-NonInteractive", "-Command", cmd], {
-          encoding: "utf8",
-          timeout: 3000,
-          windowsHide: true,
-        })
-        if (result.status !== 0) continue
-        const out = (result.stdout || "").trim().toLowerCase()
-        if (out === "true" || out === "1") return true
-        if (out === "false" || out === "0") return false
-      } catch {
-        continue
-      }
+      const result = childProcess.spawnSync(exe, ["-NoProfile", "-NonInteractive", "-Command", cmd], {
+        encoding: "utf8",
+        timeout: 3000,
+        windowsHide: true,
+      })
+      if (result.error || result.status !== 0) continue
+      const out = (result.stdout || "").trim().toLowerCase()
+      if (out === "true" || out === "1") return true
+      if (out === "false" || out === "0") return false
     }
-
-    return false
   }
 
   return false
@@ -107,34 +130,23 @@ function names(prefix) {
   const base = `${prefix}-${platform}-${arch}`
   const avx2 = supportsAvx2()
   const baseline = arch === "x64" && !avx2
+  const kind = libc()
 
   if (platform === "linux") {
-    const musl = (() => {
-      try {
-        if (fs.existsSync("/etc/alpine-release")) return true
-      } catch {
-        // ignore
-      }
-
-      try {
-        const result = childProcess.spawnSync("ldd", ["--version"], { encoding: "utf8" })
-        const text = ((result.stdout || "") + (result.stderr || "")).toLowerCase()
-        if (text.includes("musl")) return true
-      } catch {
-        // ignore
-      }
-
-      return false
-    })()
-
-    if (musl) {
+    if (kind === "musl") {
       if (arch === "x64") {
         if (baseline) return [`${base}-baseline-musl`, `${base}-musl`, `${base}-baseline`, base]
         return [`${base}-musl`, `${base}-baseline-musl`, base, `${base}-baseline`]
       }
       return [`${base}-musl`, base]
     }
-
+    if (kind === "glibc") {
+      if (arch === "x64") {
+        if (baseline) return [`${base}-baseline`, base, `${base}-baseline-musl`, `${base}-musl`]
+        return [base, `${base}-baseline`, `${base}-musl`, `${base}-baseline-musl`]
+      }
+      return [base, `${base}-musl`]
+    }
     if (arch === "x64") {
       if (baseline) return [`${base}-baseline`, base, `${base}-baseline-musl`, `${base}-musl`]
       return [base, `${base}-baseline`, `${base}-musl`, `${base}-baseline-musl`]
@@ -149,8 +161,51 @@ function names(prefix) {
   return [base]
 }
 
+function readMeta() {
+  if (!fs.existsSync(meta)) return
+  try {
+    return JSON.parse(fs.readFileSync(meta, "utf8"))
+  } catch {
+    return
+  }
+}
+
+function cacheReady(names) {
+  if (!fs.existsSync(cached)) return
+  const info = readMeta()
+  if (!info) return
+  if (info.version !== pkg.version) return
+  if (info.platform !== platform || info.arch !== arch) return
+  if (info.binary !== binary) return
+  if (platform === "linux" && info.libc !== libc()) return
+  if (typeof info.package !== "string" || !names.includes(info.package)) return
+  if (info.sidecar === true && !fs.existsSync(sidecar)) return
+  return cached
+}
+
+function unsupported() {
+  const hit = supported[platform]
+  return !hit || !hit.includes(arch)
+}
+
+function supportedMessage() {
+  return Object.entries(supported)
+    .map(([platform, archs]) => `${platform}:${archs.join(",")}`)
+    .join(" ")
+}
+
 const packageNames = names("slopcode-bin")
 const resolvedNames = Array.from(new Set([...packageNames, ...names("slopcode")]))
+const hit = cacheReady(resolvedNames)
+if (hit) {
+  run(hit)
+}
+clearCache()
+
+if (unsupported()) {
+  console.error(`Unsupported platform ${platform}/${arch}. Supported targets: ${supportedMessage()}`)
+  process.exit(1)
+}
 
 function resolveBinary() {
   for (const name of resolvedNames) {
@@ -158,7 +213,7 @@ function resolveBinary() {
       const candidate = require.resolve(`${name}/bin/${binary}`, {
         paths: [scriptDir],
       })
-      if (fs.existsSync(candidate)) return candidate
+      if (fs.existsSync(candidate)) return { path: candidate, package: name }
     } catch {
       continue
     }
@@ -172,7 +227,7 @@ function findBinary(startDir) {
     if (fs.existsSync(modules)) {
       for (const name of resolvedNames) {
         const candidate = path.join(modules, name, "bin", binary)
-        if (fs.existsSync(candidate)) return candidate
+        if (fs.existsSync(candidate)) return { path: candidate, package: name }
       }
     }
     const parent = path.dirname(current)
@@ -193,4 +248,5 @@ if (!resolved) {
   process.exit(1)
 }
 
-run(resolved)
+run(resolved.path)
+

package/package.json

@@ -34,19 +34,19 @@
   "scripts": {
     "postinstall": "bun ./postinstall.mjs || node ./postinstall.mjs"
   },
-  "version": "0.2.65",
+  "version": "0.2.67",
   "license": "MIT",
   "optionalDependencies": {
-    "slopcode-bin-linux-arm64": "0.2.65",
-    "slopcode-bin-linux-x64-musl": "0.2.65",
-    "slopcode-bin-windows-x64": "0.2.65",
-    "slopcode-bin-linux-x64-baseline-musl": "0.2.65",
-    "slopcode-bin-linux-x64": "0.2.65",
-    "slopcode-bin-windows-x64-baseline": "0.2.65",
-    "slopcode-bin-darwin-x64-baseline": "0.2.65",
-    "slopcode-bin-linux-x64-baseline": "0.2.65",
-    "slopcode-bin-darwin-x64": "0.2.65",
-    "slopcode-bin-darwin-arm64": "0.2.65",
-    "slopcode-bin-linux-arm64-musl": "0.2.65"
+    "slopcode-bin-linux-arm64": "0.2.67",
+    "slopcode-bin-linux-x64-musl": "0.2.67",
+    "slopcode-bin-windows-x64": "0.2.67",
+    "slopcode-bin-linux-x64-baseline-musl": "0.2.67",
+    "slopcode-bin-linux-x64": "0.2.67",
+    "slopcode-bin-windows-x64-baseline": "0.2.67",
+    "slopcode-bin-darwin-x64-baseline": "0.2.67",
+    "slopcode-bin-linux-x64-baseline": "0.2.67",
+    "slopcode-bin-darwin-x64": "0.2.67",
+    "slopcode-bin-darwin-arm64": "0.2.67",
+    "slopcode-bin-linux-arm64-musl": "0.2.67"
   }
 }

package/postinstall.mjs

@@ -8,43 +8,51 @@ import { createRequire } from "module"
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 const require = createRequire(import.meta.url)
+const pkg = require("./package.json")
+const supported = {
+  darwin: ["arm64", "x64"],
+  linux: ["arm64", "x64"],
+  windows: ["x64"],
+}
 
 function detectPlatformAndArch() {
-  // Map platform names
-  let platform
-  switch (os.platform()) {
-    case "darwin":
-      platform = "darwin"
-      break
-    case "linux":
-      platform = "linux"
-      break
-    case "win32":
-      platform = "windows"
-      break
-    default:
-      platform = os.platform()
-      break
-  }
+  const platform =
+    {
+      darwin: "darwin",
+      linux: "linux",
+      win32: "windows",
+    }[os.platform()] ?? os.platform()
+  const arch =
+    {
+      x64: "x64",
+      arm64: "arm64",
+      arm: "arm",
+    }[os.arch()] ?? os.arch()
+  return { platform, arch }
+}
 
-  // Map architecture names
-  let arch
-  switch (os.arch()) {
-    case "x64":
-      arch = "x64"
-      break
-    case "arm64":
-      arch = "arm64"
-      break
-    case "arm":
-      arch = "arm"
-      break
-    default:
-      arch = os.arch()
-      break
+function detectLibc(platform, arch) {
+  if (platform !== "linux") return
+  const report = process.report?.getReport?.()
+  if (typeof report?.header?.glibcVersionRuntime === "string" && report.header.glibcVersionRuntime) {
+    return "glibc"
   }
-
-  return { platform, arch }
+  if (fs.existsSync("/etc/alpine-release")) return "musl"
+  const getconf = require("child_process").spawnSync("getconf", ["GNU_LIBC_VERSION"], {
+    encoding: "utf8",
+    timeout: 1500,
+  })
+  const fromGetconf = ((getconf.stdout || "") + (getconf.stderr || "")).toLowerCase()
+  if (getconf.status === 0 && fromGetconf.includes("glibc")) return "glibc"
+  const result = require("child_process").spawnSync("ldd", ["--version"], {
+    encoding: "utf8",
+    timeout: 1500,
+  })
+  const text = ((result.stdout || "") + (result.stderr || "")).toLowerCase()
+  if (text.includes("musl")) return "musl"
+  if (text.includes("glibc") || text.includes("gnu libc")) return "glibc"
+  const loader = arch === "arm64" ? "/lib/ld-musl-aarch64.so.1" : arch === "x64" ? "/lib/ld-musl-x86_64.so.1" : ""
+  if (loader && fs.existsSync(loader)) return "musl"
 }
 
 function supportsAvx2(platform, arch) {
@@ -78,35 +86,27 @@ function names(platform, arch) {
   const base = `slopcode-bin-${platform}-${arch}`
   const avx2 = supportsAvx2(platform, arch)
   const baseline = arch === "x64" && !avx2
+  const libc = detectLibc(platform, arch)
 
   if (platform === "linux") {
-    const musl = (() => {
-      try {
-        if (fs.existsSync("/etc/alpine-release")) return true
-      } catch {}
-
-      try {
-        const result = require("child_process").spawnSync("ldd", ["--version"], { encoding: "utf8" })
-        const text = ((result.stdout || "") + (result.stderr || "")).toLowerCase()
-        if (text.includes("musl")) return true
-      } catch {}
-
-      return false
-    })()
-
-    if (musl) {
+    if (libc === "musl") {
       if (arch === "x64") {
         if (baseline) return [`${base}-baseline-musl`, `${base}-musl`, `${base}-baseline`, base]
         return [`${base}-musl`, `${base}-baseline-musl`, base, `${base}-baseline`]
       }
       return [`${base}-musl`, base]
     }
-
+    if (libc === "glibc") {
+      if (arch === "x64") {
+        if (baseline) return [`${base}-baseline`, base, `${base}-baseline-musl`, `${base}-musl`]
+        return [base, `${base}-baseline`, `${base}-musl`, `${base}-baseline-musl`]
+      }
+      return [base, `${base}-musl`]
+    }
     if (arch === "x64") {
       if (baseline) return [`${base}-baseline`, base, `${base}-baseline-musl`, `${base}-musl`]
       return [base, `${base}-baseline`, `${base}-musl`, `${base}-baseline-musl`]
     }
-
     return [base, `${base}-musl`]
   }
 
@@ -118,6 +118,18 @@ function names(platform, arch) {
   return [base]
 }
 
+function clearCache() {
+  fs.rmSync(path.join(__dirname, "bin", ".slopcode"), { force: true })
+  fs.rmSync(path.join(__dirname, "bin", ".slopcode.json"), { force: true })
+  fs.rmSync(path.join(__dirname, "bin", "neovim"), { recursive: true, force: true })
+}
+
+function supportedMessage() {
+  return Object.entries(supported)
+    .map(([platform, archs]) => `${platform}:${archs.join(",")}`)
+    .join(" ")
+}
+
 function findBinary() {
   const { platform, arch } = detectPlatformAndArch()
   const binaryName = platform === "windows" ? "slopcode.exe" : "slopcode"
@@ -128,71 +140,95 @@ function findBinary() {
       const packageDir = path.dirname(packageJsonPath)
       const binaryPath = path.join(packageDir, "bin", binaryName)
       if (fs.existsSync(binaryPath)) {
-        return { binaryPath, binaryName }
+        return { binaryPath, binaryName, packageName: name, platform, arch, libc: detectLibc(platform, arch) }
       }
     } catch {
       continue
     }
   }
+}
 
-  return
+function cacheSidecar(sourcePath) {
+  const source = path.join(path.dirname(sourcePath), "neovim")
+  if (!fs.existsSync(source)) return false
+  const target = path.join(__dirname, "bin", "neovim")
+  fs.rmSync(target, { recursive: true, force: true })
+  fs.cpSync(source, target, { recursive: true, force: true })
+  return true
 }
 
 function prepareBinDirectory(binaryName) {
   const binDir = path.join(__dirname, "bin")
   const targetPath = path.join(binDir, binaryName)
 
-  // Ensure bin directory exists
   if (!fs.existsSync(binDir)) {
     fs.mkdirSync(binDir, { recursive: true })
   }
-
-  // Remove existing binary/symlink if it exists
   if (fs.existsSync(targetPath)) {
     fs.unlinkSync(targetPath)
   }
 
-  return { binDir, targetPath }
+  return { targetPath }
 }
 
-function symlinkBinary(sourcePath, binaryName) {
-  const { targetPath } = prepareBinDirectory(binaryName)
-
-  fs.symlinkSync(sourcePath, targetPath)
-  console.log(`slopcode binary symlinked: ${targetPath} -> ${sourcePath}`)
-
-  // Verify the file exists after operation
-  if (!fs.existsSync(targetPath)) {
-    throw new Error(`Failed to symlink binary to ${targetPath}`)
-  }
+function writeMeta(input) {
+  fs.writeFileSync(
+    path.join(__dirname, "bin", ".slopcode.json"),
+    JSON.stringify(
+      {
+        version: pkg.version,
+        platform: input.platform,
+        arch: input.arch,
+        libc: input.libc,
+        package: input.packageName,
+        binary: input.binaryName,
+        sidecar: input.sidecar,
+      },
+      null,
+      2,
+    ),
+  )
 }
 
 async function main() {
   try {
+    const { platform, arch } = detectPlatformAndArch()
+    if (!(supported[platform] ?? []).includes(arch)) {
+      clearCache()
+      console.log(
+        `Unsupported slopcode platform during postinstall: ${platform}/${arch}. Supported targets: ${supportedMessage()}`,
+      )
+      return
+    }
+
     if (os.platform() === "win32") {
-      // On Windows, the .exe is already included in the package and bin field points to it
-      // No postinstall setup needed
       console.log("Windows detected: binary setup not needed (using packaged .exe)")
       return
     }
 
-    // On non-Windows platforms, just verify the binary package exists
-    // Don't replace the wrapper script - it handles binary execution
     const found = findBinary()
     if (!found) {
+      clearCache()
       console.log("No platform binary package detected during postinstall; runtime resolver will handle it")
       return
     }
-    const binaryPath = found.binaryPath
+
+    clearCache()
     const target = path.join(__dirname, "bin", ".slopcode")
-    if (fs.existsSync(target)) fs.unlinkSync(target)
+    const { targetPath } = prepareBinDirectory(".slopcode")
     try {
-      fs.linkSync(binaryPath, target)
+      fs.linkSync(found.binaryPath, targetPath)
     } catch {
-      fs.copyFileSync(binaryPath, target)
+      fs.copyFileSync(found.binaryPath, target)
     }
     fs.chmodSync(target, 0o755)
+    const sidecar = cacheSidecar(found.binaryPath)
+    writeMeta({
+      ...found,
+      sidecar,
+    })
   } catch (error) {
+    clearCache()
     console.error("Failed to setup slopcode binary cache:", error.message)
     process.exit(0)
   }
@@ -201,6 +237,7 @@ async function main() {
 try {
   main()
 } catch (error) {
+  clearCache()
   console.error("Postinstall script error:", error.message)
   process.exit(0)
 }