lightweight-ai 1.2.19 → 1.2.20

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lightweight-ai",
-  "version": "1.2.19",
+  "version": "1.2.20",
   "bin": {
     "lightweight": "./bin/lightweight"
   },

package/postinstall.mjs

@@ -1,99 +1,131 @@
 #!/usr/bin/env node
 
-// Downloads the lightweight CLI binary from GitHub Releases.
-// This avoids publishing 11 x 57MB platform packages to npm.
-
-import { existsSync, mkdirSync, createWriteStream, unlinkSync, chmodSync, readFileSync } from "fs"
-import { join, dirname } from "path"
+import fs from "fs"
+import path from "path"
+import os from "os"
 import { fileURLToPath } from "url"
-import { execSync } from "child_process"
-import https from "https"
-import http from "http"
-
-const root = dirname(fileURLToPath(import.meta.url))
-const platforms = { darwin: "darwin", linux: "linux", win32: "windows" }
-const archs = { x64: "x64", arm64: "arm64" }
-const platform = platforms[process.platform]
-const arch = archs[process.arch]
-
-if (!platform || !arch) {
-  console.log(`lightweight: unsupported platform ${process.platform}-${process.arch}`)
-  process.exit(0)
-}
+import { createRequire } from "module"
 
-const pkg = JSON.parse(readFileSync(join(root, "package.json"), "utf8"))
-const isWindows = process.platform === "win32"
-const binary = isWindows ? "lightweight.exe" : "lightweight"
-const cliDir = join(root, "cli")
-const binaryPath = join(cliDir, binary)
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const require = createRequire(import.meta.url)
 
-if (existsSync(binaryPath)) {
-  console.log("lightweight: binary already installed")
-  process.exit(0)
+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
+  }
+
+  // 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
+  }
+
+  return { platform, arch }
 }
 
-const ext = isWindows ? "zip" : "tar.gz"
-const url = `https://github.com/templarsco/lightweight/releases/download/v${pkg.version}/lightweight-${platform}-${arch}.${ext}`
-const archive = join(root, `lightweight.${ext}`)
-
-console.log(`lightweight: downloading ${platform}-${arch} binary...`)
-mkdirSync(cliDir, { recursive: true })
-
-function download(url, dest) {
-  return new Promise((resolve, reject) => {
-    const follow = (url) => {
-      const client = url.startsWith("https") ? https : http
-      client
-        .get(url, (res) => {
-          if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
-            follow(res.headers.location)
-            return
-          }
-          if (res.statusCode !== 200) {
-            reject(new Error(`HTTP ${res.statusCode}`))
-            return
-          }
-          const stream = createWriteStream(dest)
-          res.pipe(stream)
-          stream.on("finish", () => {
-            stream.close()
-            resolve()
-          })
-          stream.on("error", reject)
-        })
-        .on("error", reject)
+function findBinary() {
+  const { platform, arch } = detectPlatformAndArch()
+  const packageName = `opencode-${platform}-${arch}`
+  const binaryName = platform === "windows" ? "opencode.exe" : "opencode"
+
+  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 (!fs.existsSync(binaryPath)) {
+      throw new Error(`Binary not found at ${binaryPath}`)
     }
-    follow(url)
-  })
+
+    return { binaryPath, binaryName }
+  } catch (error) {
+    throw new Error(`Could not find package ${packageName}: ${error.message}`)
+  }
 }
 
-try {
-  await download(url, archive)
-
-  if (isWindows) {
-    execSync(`powershell -NoProfile -Command "Expand-Archive -Path '${archive}' -DestinationPath '${cliDir}' -Force"`, {
-      stdio: "inherit",
-    })
-  } else {
-    execSync(`tar -xzf "${archive}" -C "${cliDir}"`, { stdio: "inherit" })
+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 })
   }
 
-  if (existsSync(archive)) unlinkSync(archive)
+  // Remove existing binary/symlink if it exists
+  if (fs.existsSync(targetPath)) {
+    fs.unlinkSync(targetPath)
+  }
+
+  return { binDir, targetPath }
+}
+
+function symlinkBinary(sourcePath, binaryName) {
+  const { targetPath } = prepareBinDirectory(binaryName)
 
-  if (!isWindows && existsSync(binaryPath)) {
-    chmodSync(binaryPath, 0o755)
+  fs.symlinkSync(sourcePath, targetPath)
+  console.log(`opencode binary symlinked: ${targetPath} -> ${sourcePath}`)
+
+  // Verify the file exists after operation
+  if (!fs.existsSync(targetPath)) {
+    throw new Error(`Failed to symlink binary to ${targetPath}`)
   }
+}
 
-  if (existsSync(binaryPath)) {
-    console.log("lightweight: installed successfully")
-  } else {
-    console.error("lightweight: binary not found after extraction")
-    console.error(`lightweight: download manually from ${url}`)
+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
+    }
+
+    // On non-Windows platforms, just verify the binary package exists
+    // Don't replace the wrapper script - it handles binary execution
+    const { binaryPath } = findBinary()
+    const target = path.join(__dirname, "bin", ".opencode")
+    if (fs.existsSync(target)) fs.unlinkSync(target)
+    try {
+      fs.linkSync(binaryPath, target)
+    } catch {
+      fs.copyFileSync(binaryPath, target)
+    }
+    fs.chmodSync(target, 0o755)
+  } catch (error) {
+    console.error("Failed to setup opencode binary:", error.message)
     process.exit(1)
   }
+}
+
+try {
+  main()
 } catch (error) {
-  console.error(`lightweight: download failed: ${error.message}`)
-  console.error(`lightweight: download manually from ${url}`)
-  if (existsSync(archive)) unlinkSync(archive)
-  process.exit(1)
+  console.error("Postinstall script error:", error.message)
+  process.exit(0)
 }