railwise-ai 1.2.30 → 1.2.32

package/bin/railwise

@@ -160,7 +160,15 @@ function findBinary(startDir) {
   }
 }
 
-const resolved = findBinary(scriptDir)
+function findVendor() {
+  const root = path.resolve(scriptDir, "..")
+  for (const name of names) {
+    const candidate = path.join(root, "vendor", name, "bin", binary)
+    if (fs.existsSync(candidate)) return candidate
+  }
+}
+
+const resolved = findBinary(scriptDir) || findVendor()
 if (!resolved) {
   // Fallback: run from source via bun for local development
   const srcEntry = path.resolve(scriptDir, "..", "src", "index.ts")

package/package.json

@@ -1,25 +1,24 @@
 {
   "name": "railwise-ai",
   "bin": {
-    "railwise": "./bin/railwise",
-    "rw": "./bin/railwise"
+    "railwise": "./bin/railwise"
   },
   "scripts": {
     "postinstall": "node ./postinstall.mjs"
   },
-  "version": "1.2.30",
+  "version": "1.2.32",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/railwise-cn/RAILWISE-CLI"
+    "url": "git+https://github.com/railwise-cn/RAILWISE-CLI.git"
   },
   "optionalDependencies": {
-    "railwise-darwin-x64": "1.2.30",
-    "railwise-linux-x64-baseline-musl": "1.2.30",
-    "railwise-linux-x64-baseline": "1.2.30",
-    "railwise-linux-arm64": "1.2.30",
-    "railwise-darwin-arm64": "1.2.30",
-    "railwise-windows-x64": "1.2.30",
-    "railwise-linux-x64": "1.2.30"
+    "railwise-linux-arm64": "1.2.32",
+    "railwise-darwin-x64": "1.2.32",
+    "railwise-windows-x64": "1.2.32",
+    "railwise-linux-x64": "1.2.32",
+    "railwise-linux-x64-baseline": "1.2.32",
+    "railwise-darwin-arm64": "1.2.32",
+    "railwise-linux-x64-baseline-musl": "1.2.32"
   }
 }

package/postinstall.mjs

@@ -1,125 +1,219 @@
 #!/usr/bin/env node
 
 import fs from "fs"
-import path from "path"
 import os from "os"
-import { fileURLToPath } from "url"
+import path from "path"
+import { spawnSync } from "child_process"
 import { createRequire } from "module"
+import { fileURLToPath } from "url"
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 const require = createRequire(import.meta.url)
+const pkg = JSON.parse(fs.readFileSync(path.join(__dirname, "package.json"), "utf8"))
+
+function platform() {
+  if (os.platform() === "darwin") return "darwin"
+  if (os.platform() === "linux") return "linux"
+  if (os.platform() === "win32") return "windows"
+  return os.platform()
+}
+
+function arch() {
+  if (os.arch() === "x64") return "x64"
+  if (os.arch() === "arm64") return "arm64"
+  if (os.arch() === "arm") return "arm"
+  return os.arch()
+}
+
+const system = platform()
+const cpu = arch()
+const base = `railwise-${system}-${cpu}`
+const binary = system === "windows" ? "railwise.exe" : "railwise"
 
-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
+function supportsAvx2() {
+  if (cpu !== "x64") return false
+
+  if (system === "linux") {
+    if (!fs.existsSync("/proc/cpuinfo")) return false
+    return /(^|\s)avx2(\s|$)/i.test(fs.readFileSync("/proc/cpuinfo", "utf8"))
+  }
+
+  if (system === "darwin") {
+    const result = spawnSync("sysctl", ["-n", "hw.optional.avx2_0"], {
+      encoding: "utf8",
+      timeout: 1500,
+    })
+    if (result.status !== 0) return false
+    return (result.stdout || "").trim() === "1"
   }
 
-  // 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
+  if (system === "windows") {
+    const cmd =
+      '(Add-Type -MemberDefinition "[DllImport(""kernel32.dll"")] public static extern bool IsProcessorFeaturePresent(int ProcessorFeature);" -Name Kernel32 -Namespace Win32 -PassThru)::IsProcessorFeaturePresent(40)'
+    return ["powershell.exe", "pwsh.exe", "pwsh", "powershell"].some((exe) => {
+      const result = spawnSync(exe, ["-NoProfile", "-NonInteractive", "-Command", cmd], {
+        encoding: "utf8",
+        timeout: 3000,
+        windowsHide: true,
+      })
+      if (result.status !== 0) return false
+      return ["true", "1"].includes((result.stdout || "").trim().toLowerCase())
+    })
   }
 
-  return { platform, arch }
+  return false
+}
+
+function musl() {
+  if (system !== "linux") return false
+  if (fs.existsSync("/etc/alpine-release")) return true
+  const result = spawnSync("ldd", ["--version"], { encoding: "utf8" })
+  return `${result.stdout || ""}${result.stderr || ""}`.toLowerCase().includes("musl")
 }
 
-function findBinary() {
-  const { platform, arch } = detectPlatformAndArch()
-  const packageName = `railwise-${platform}-${arch}`
-  const binaryName = platform === "windows" ? "railwise.exe" : "railwise"
+function names() {
+  const baseline = cpu === "x64" && !supportsAvx2()
 
-  try {
-    // Use require.resolve to find the package
-    const packageJsonPath = require.resolve(`${packageName}/package.json`)
-    const packageDir = path.dirname(packageJsonPath)
-    const binaryPath = path.join(packageDir, "bin", binaryName)
+  if (system === "linux") {
+    if (musl()) {
+      if (cpu === "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 (!fs.existsSync(binaryPath)) {
-      throw new Error(`Binary not found at ${binaryPath}`)
+    if (cpu === "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`]
+  }
 
-    return { binaryPath, binaryName }
-  } catch (error) {
-    throw new Error(`Could not find package ${packageName}: ${error.message}`)
+  if (cpu === "x64") {
+    if (baseline) return [`${base}-baseline`, base]
+    return [base, `${base}-baseline`]
   }
+  return [base]
 }
 
-function prepareBinDirectory(binaryName) {
-  const binDir = path.join(__dirname, "bin")
-  const targetPath = path.join(binDir, binaryName)
+function optional(name) {
+  const file = require.resolve(`${name}/package.json`)
+  const dir = path.dirname(file)
+  const found = path.join(dir, "bin", binary)
+  if (!fs.existsSync(found)) throw new Error(`Binary not found at ${found}`)
+  return found
+}
+
+function vendor(name) {
+  return path.join(__dirname, "vendor", name, "bin", binary)
+}
+
+function run(exe, args) {
+  const result = spawnSync(exe, args, { stdio: "inherit", windowsHide: true })
+  if (result.error) throw result.error
+  if (result.status !== 0) throw new Error(`${exe} exited with ${result.status}`)
+}
 
-  // Ensure bin directory exists
-  if (!fs.existsSync(binDir)) {
-    fs.mkdirSync(binDir, { recursive: true })
+function quote(value) {
+  return `'${value.replace(/'/g, "''")}'`
+}
+
+function extract(file, dir) {
+  if (file.endsWith(".tar.gz")) {
+    run("tar", ["-xzf", file, "-C", dir])
+    return
   }
 
-  // Remove existing binary/symlink if it exists
-  if (fs.existsSync(targetPath)) {
-    fs.unlinkSync(targetPath)
+  if (system === "windows") {
+    const cmd = `Expand-Archive -Path ${quote(file)} -DestinationPath ${quote(dir)} -Force`
+    const exe = ["powershell.exe", "pwsh.exe", "pwsh", "powershell"].find((item) => {
+      const result = spawnSync(item, ["-NoProfile", "-NonInteractive", "-Command", "$PSVersionTable.PSVersion"], {
+        stdio: "ignore",
+        windowsHide: true,
+      })
+      return result.status === 0
+    })
+    if (!exe) throw new Error("PowerShell is required to extract the Windows binary fallback")
+    run(exe, ["-NoProfile", "-NonInteractive", "-Command", cmd])
+    return
   }
 
-  return { binDir, targetPath }
+  run("unzip", ["-oq", file, "-d", dir])
 }
 
-function symlinkBinary(sourcePath, binaryName) {
-  const { targetPath } = prepareBinDirectory(binaryName)
-
-  fs.symlinkSync(sourcePath, targetPath)
-  console.log(`railwise binary symlinked: ${targetPath} -> ${sourcePath}`)
+function timeout() {
+  const value = Number(process.env.RAILWISE_DOWNLOAD_TIMEOUT_MS || 60000)
+  if (Number.isFinite(value) && value > 0) return value
+  return 60000
+}
 
-  // Verify the file exists after operation
-  if (!fs.existsSync(targetPath)) {
-    throw new Error(`Failed to symlink binary to ${targetPath}`)
+async function download(name) {
+  const ext = system === "linux" ? ".tar.gz" : ".zip"
+  const asset = `${name}${ext}`
+  const base = (
+    process.env.RAILWISE_RELEASE_BASE_URL ||
+    `https://github.com/railwise-cn/RAILWISE-CLI/releases/download/v${pkg.version}`
+  ).replace(/\/+$/, "")
+  const url = `${base}/${asset}`
+  const controller = new AbortController()
+  const timer = setTimeout(() => controller.abort(), timeout())
+  console.log(`Downloading ${asset} from ${base}`)
+
+  const tmp = path.join(os.tmpdir(), `${asset}.${process.pid}`)
+  const dir = path.join(__dirname, "vendor", name, "bin")
+  try {
+    const res = await fetch(url, {
+      signal: controller.signal,
+      headers: { "user-agent": `railwise-postinstall/${pkg.version}` },
+    })
+    if (!res.ok) throw new Error(`Download failed for ${asset}: ${res.status} ${res.statusText}`)
+
+    fs.rmSync(path.dirname(dir), { recursive: true, force: true })
+    fs.mkdirSync(dir, { recursive: true })
+    fs.writeFileSync(tmp, Buffer.from(await res.arrayBuffer()))
+    extract(tmp, dir)
+  } finally {
+    clearTimeout(timer)
+    fs.rmSync(tmp, { force: true })
   }
+
+  const found = vendor(name)
+  if (!fs.existsSync(found)) throw new Error(`Downloaded asset did not contain ${binary}`)
+  if (system !== "windows") fs.chmodSync(found, 0o755)
+  return found
 }
 
 async function main() {
-  try {
-    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
+  const items = names()
+  const installed = items.flatMap((name) => {
+    try {
+      return [optional(name)]
+    } catch {
+      return []
     }
-
-    // On non-Windows platforms, just verify the binary package exists
-    // Don't replace the wrapper script - it handles binary execution
-    const { binaryPath } = findBinary()
-    console.log(`Platform binary verified at: ${binaryPath}`)
-    console.log("Wrapper script will handle binary execution")
-  } catch (error) {
-    console.error("Failed to setup railwise binary:", error.message)
-    process.exit(1)
+  })[0]
+  if (installed) {
+    console.log(`Platform binary verified at: ${installed}`)
+    return
   }
-}
 
-try {
-  main()
-} catch (error) {
-  console.error("Postinstall script error:", error.message)
-  process.exit(0)
+  const found = await items.reduce(async (prev, name) => {
+    const value = await prev
+    if (value) return value
+    try {
+      return await download(name)
+    } catch (error) {
+      console.warn(`Could not install fallback binary ${name}: ${error instanceof Error ? error.message : String(error)}`)
+      return undefined
+    }
+  }, Promise.resolve(undefined))
+
+  if (!found) throw new Error(`Could not install a RAILWISE binary for ${system}/${cpu}`)
+  console.log(`Platform binary downloaded to: ${found}`)
 }
+
+main().catch((error) => {
+  console.error("Failed to setup railwise binary:", error instanceof Error ? error.message : String(error))
+  process.exit(1)
+})