saeeol 1.4.9 → 1.5.1

package/bin/saeeol

@@ -0,0 +1,44 @@
+#!/usr/bin/env node
+// Proxy script — delegates to platform-specific binary
+const path = require("path")
+const { execFileSync } = require("child_process")
+const os = require("os")
+const fs = require("fs")
+
+const platform = os.platform()
+const arch = os.arch()
+
+function findBinary() {
+  const dir = path.resolve(__dirname, "..")
+  // Try optionalDependency packages first
+  const pkgNames = platform === "win32"
+    ? [`saeeol-windows-${arch}`]
+    : platform === "darwin"
+      ? [`saeeol-darwin-${arch}`, `saeeol-darwin-${arch}-baseline`]
+      : [`saeeol-linux-${arch}`, `saeeol-linux-${arch}-baseline`, `saeeol-linux-${arch}-musl`]
+
+  for (const pkg of pkgNames) {
+    try {
+      const pkgDir = path.resolve(__dirname, "..", "..", pkg)
+      const exe = platform === "win32" ? "saeeol.exe" : "saeeol"
+      const binPath = path.join(pkgDir, "bin", exe)
+      if (fs.existsSync(binPath)) return binPath
+    } catch {}
+  }
+
+  // Try bundled bin
+  const localExe = platform === "win32" ? "saeeol.exe" : "saeeol"
+  const localPath = path.join(__dirname, localExe)
+  if (fs.existsSync(localPath)) return localPath
+
+  console.error("Could not find saeeol binary for " + platform + "-" + arch)
+  process.exit(1)
+}
+
+const binary = findBinary()
+const result = execFileSync(binary, process.argv.slice(2), {
+  stdio: "inherit",
+  env: { ...process.env },
+  windowsHide: true,
+})
+if (result != null) process.exit(result)

package/package.json

@@ -1,56 +1,11 @@
 {
   "name": "saeeol",
-  "version": "1.4.9",
+  "version": "1.5.1",
   "description": "AI agent engine for SAEEOL — CLI + Desktop in one package",
-  "author": "byfabulist",
+  "bin": { "saeeol": "./bin/saeeol", "fabulist": "./bin/saeeol" },
+  "scripts": { "postinstall": "node ./postinstall.mjs" },
   "license": "Apache-2.0",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/byfabulist/fabulist"
-  },
-  "bin": {
-    "saeeol": "cli.js",
-    "fabulist": "desktop.js"
-  },
-  "files": [
-    "cli.js",
-    "desktop.js",
-    "postinstall.js",
-    "web/**/*"
-  ],
-  "scripts": {
-    "postinstall": "node postinstall.js"
-  },
-  "optionalDependencies": {
-    "saeeol-windows-x64": "1.4.8",
-    "saeeol-windows-x64-baseline": "1.4.5",
-    "saeeol-darwin-x64": "1.4.5",
-    "saeeol-darwin-x64-baseline": "1.4.5",
-    "saeeol-darwin-arm64": "1.4.5",
-    "saeeol-linux-x64": "1.4.5",
-    "saeeol-linux-x64-baseline": "1.4.5",
-    "saeeol-linux-arm64": "1.4.5",
-    "saeeol-linux-arm64-musl": "1.4.5",
-    "saeeol-linux-x64-musl": "1.4.5",
-    "saeeol-linux-x64-musl-baseline": "1.4.5",
-    "saeeol-win32-arm64": "1.4.5",
-    "electron": "^35.2.1"
-  },
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org"
-  },
-  "engines": {
-    "node": ">=18"
-  },
-  "keywords": [
-    "ai",
-    "agent",
-    "cli",
-    "coding",
-    "assistant",
-    "saeeol",
-    "fabulist",
-    "desktop"
-  ]
+  "optionalDependencies": { "saeeol-windows-x64": "1.5.0" },
+  "repository": { "type": "git", "url": "https://github.com/byfabulist/fabulist" },
+  "keywords": ["ai", "agent", "cli", "coding", "assistant", "saeeol", "fabulist", "desktop"]
 }

package/postinstall.mjs

@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+
+import fs from "fs"
+import path from "path"
+import os from "os"
+import childProcess from "child_process"
+import { fileURLToPath } from "url"
+import { createRequire } from "module"
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const require = createRequire(import.meta.url)
+
+// saeeolcode_change start - variant detection matching bin/saeeolcode logic
+const platformMap = {
+  darwin: "darwin",
+  linux: "linux",
+  win32: "windows",
+}
+const archMap = {
+  x64: "x64",
+  arm64: "arm64",
+  arm: "arm",
+}
+
+function detectPlatformAndArch() {
+  const platform = platformMap[os.platform()] || os.platform()
+  const arch = archMap[os.arch()] || os.arch()
+  return { platform, arch }
+}
+
+function supportsAvx2() {
+  const { platform, arch } = detectPlatformAndArch()
+  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
+    }
+  }
+
+  return false
+}
+
+function isMusl() {
+  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
+}
+
+function getPackageNames() {
+  const { platform, arch } = detectPlatformAndArch()
+  const base = `@saeeolcode/cli-${platform}-${arch}`
+  const avx2 = supportsAvx2()
+  const baseline = arch === "x64" && !avx2
+
+  if (platform === "linux") {
+    const musl = isMusl()
+    if (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 (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]
+    return [base, `${base}-baseline`]
+  }
+  return [base]
+}
+
+function findBinary() {
+  const { platform } = detectPlatformAndArch()
+  const binaryName = platform === "windows" ? "saeeolcode.exe" : "saeeolcode"
+  const names = getPackageNames()
+
+  for (const packageName of names) {
+    try {
+      const packageJsonPath = require.resolve(`${packageName}/package.json`)
+      const packageDir = path.dirname(packageJsonPath)
+      const binaryPath = path.join(packageDir, "bin", binaryName)
+
+      if (fs.existsSync(binaryPath)) {
+        return { binaryPath, binaryName }
+      }
+    } catch {
+      // package not installed, try next variant
+    }
+  }
+
+  throw new Error(`Could not find any binary package. Tried: ${names.map((n) => `"${n}"`).join(", ")}`)
+}
+// saeeolcode_change end
+
+function registerWindowsTerminalFragment() {
+  const localAppData = process.env.LOCALAPPDATA
+  if (!localAppData) return
+
+  const fragmentDir = path.join(
+    localAppData,
+    "Microsoft",
+    "Windows Terminal",
+    "Fragments",
+    "saeeolcode",
+  )
+  const iconPath = path.join(__dirname, "..", "assets", "saeeol.ico")
+  if (!fs.existsSync(iconPath)) return
+
+  const profile = {
+    profiles: [
+      {
+        name: "SAEEOL Code",
+        commandline: "powershell.exe -NoExit -Command saeeol",
+        icon: iconPath,
+        startingDirectory: "%USERPROFILE%",
+        tabTitle: "SAEEOL Code",
+      },
+    ],
+  }
+
+  fs.mkdirSync(fragmentDir, { recursive: true })
+  fs.writeFileSync(
+    path.join(fragmentDir, "profile.json"),
+    JSON.stringify(profile, null, 2),
+  )
+}
+
+function main() {
+  if (os.platform() === "win32") {
+    console.log("Windows detected: binary setup not needed (using packaged .exe)")
+    try {
+      registerWindowsTerminalFragment()
+    } catch (err) {
+      console.error("Failed to register Windows Terminal fragment:", err.message)
+    }
+    return
+  }
+
+  const { binaryPath } = findBinary()
+  const target = path.join(__dirname, "bin", ".saeeolcode") // saeeolcode_change
+  if (fs.existsSync(target)) fs.unlinkSync(target)
+  try {
+    fs.linkSync(binaryPath, target)
+  } catch {
+    fs.copyFileSync(binaryPath, target)
+  }
+  fs.chmodSync(target, 0o755)
+}
+
+try {
+  void main()
+} catch (error) {
+  console.error("Failed to setup saeeolcode binary:", error.message)
+  process.exit(1)
+}

package/cli.js

@@ -1,65 +0,0 @@
-#!/usr/bin/env node
-
-// saeeol bin wrapper — delegates to the platform-specific binary
-const { existsSync, chmodSync, realpathSync } = require("fs")
-const { join, resolve, dirname } = require("path")
-const { spawn } = require("child_process")
-
-function getBinaryName() {
-  const archMap = { x64: "x64", arm64: "arm64" }
-  const platformMap = { win32: "windows", darwin: "darwin", linux: "linux" }
-  const p = platformMap[process.platform] || process.platform
-  const a = archMap[process.arch] || process.arch
-  return `saeeol-${p}-${a}`
-}
-
-function findBinary() {
-  const binaryName = getBinaryName()
-  const binaryRel = process.platform === "win32" ? "bin/saeeol.exe" : "bin/saeeol"
-
-  // 1. Look in node_modules of this package
-  const scriptDir = dirname(realpathSync(__filename))
-  const localModules = join(scriptDir, "node_modules", binaryName, binaryRel)
-  if (existsSync(localModules)) return localModules
-
-  // 2. Walk up to find node_modules
-  let current = scriptDir
-  for (let i = 0; i < 10; i++) {
-    const candidate = join(current, "node_modules", binaryName, binaryRel)
-    if (existsSync(candidate)) return candidate
-    const parent = dirname(current)
-    if (parent === current) break
-    current = parent
-  }
-
-  // 3. Download directory (postinstall fallback)
-  const downloadPath = join(scriptDir, "download", process.platform === "win32" ? `${binaryName}.exe` : "saeeol")
-  if (existsSync(downloadPath)) return downloadPath
-
-  return null
-}
-
-const binaryPath = findBinary()
-
-if (!binaryPath) {
-  console.error(`saeeol binary not found for your platform (${getBinaryName()})`)
-  console.error(`Run: npm install saeeol`)
-  console.error(`Or: https://github.com/byfabulist/fabulist/releases`)
-  process.exit(1)
-}
-
-if (process.platform !== "win32") {
-  try { chmodSync(binaryPath, 0o755) } catch {}
-}
-
-const child = spawn(binaryPath, process.argv.slice(2), {
-  stdio: "inherit",
-  env: { ...process.env },
-  windowsHide: true,
-})
-
-child.on("exit", (code) => process.exit(code || 0))
-child.on("error", (err) => {
-  console.error(`Failed to start saeeol: ${err.message}`)
-  process.exit(1)
-})

package/desktop.js

@@ -1,167 +0,0 @@
-#!/usr/bin/env node
-
-// fabulist — saeeol server + Electron desktop with React UI
-"use strict"
-const { existsSync, realpathSync, createReadStream, statSync, mkdirSync, writeFileSync } = require("fs")
-const { join, dirname, extname } = require("path")
-const { spawn } = require("child_process")
-const http = require("http")
-
-// Resolve script directory (works with symlinks and global installs)
-function getScriptDir() {
-  // 1. process.argv[1] (how npm bin scripts invoke us)
-  if (process.argv[1]) {
-    try { const r = realpathSync(process.argv[1]); if (r) return dirname(r) } catch {}
-  }
-  // 2. __filename (CJS context)
-  try { if (typeof __filename === "string") return dirname(realpathSync(__filename)) } catch {}
-  // 3. require.main
-  try { if (require.main && require.main.filename) return dirname(realpathSync(require.main.filename)) } catch {}
-  // 4. find saeeol package in global node_modules
-  try { const p = require.resolve("saeeol/cli.js"); return dirname(p) } catch {}
-  return process.cwd()
-}
-const SCRIPT_DIR = getScriptDir()
-
-const MIME = {
-  ".html": "text/html", ".js": "text/javascript", ".css": "text/css",
-  ".json": "application/json", ".png": "image/png", ".ico": "image/x-icon",
-  ".svg": "image/svg+xml", ".woff2": "font/woff2", ".wasm": "application/wasm",
-}
-
-function getBinaryName() {
-  const a = { x64: "x64", arm64: "arm64" }
-  const p = { win32: "windows", darwin: "darwin", linux: "linux" }
-  return `saeeol-${p[process.platform] || process.platform}-${a[process.arch] || process.arch}`
-}
-
-function findBinary() {
-  const name = getBinaryName()
-  const rel = process.platform === "win32" ? "bin/saeeol.exe" : "bin/saeeol"
-  // node_modules of this package
-  const local = join(SCRIPT_DIR, "node_modules", name, rel)
-  if (existsSync(local)) return local
-  // walk up
-  let dir = SCRIPT_DIR
-  for (let i = 0; i < 10; i++) {
-    const c = join(dir, "node_modules", name, rel)
-    if (existsSync(c)) return c
-    const parent = dirname(dir)
-    if (parent === dir) break
-    dir = parent
-  }
-  // download fallback
-  const dl = join(SCRIPT_DIR, "download", process.platform === "win32" ? `${name}.exe` : "saeeol")
-  if (existsSync(dl)) return dl
-  return null
-}
-
-function findElectron() {
-  const exe = process.platform === "win32" ? "electron.exe" : "electron"
-  const p = join(SCRIPT_DIR, "node_modules", "electron", "dist", exe)
-  return existsSync(p) ? p : null
-}
-
-function serveStatic(webDir, port) {
-  return new Promise((resolve, reject) => {
-    const server = http.createServer((req, res) => {
-      let path = req.url.split("?")[0]
-      if (path === "/") path = "/index.html"
-      const fp = join(webDir, path)
-      if (!existsSync(fp)) { res.writeHead(404); res.end("not found"); return }
-      const ct = MIME[extname(fp)] || "application/octet-stream"
-      const s = statSync(fp)
-      res.writeHead(200, { "Content-Type": ct, "Content-Length": s.size })
-      createReadStream(fp).pipe(res)
-    })
-    server.listen(port, "127.0.0.1", () => resolve(server))
-    server.on("error", reject)
-  })
-}
-
-async function main() {
-  const binaryPath = findBinary()
-  if (!binaryPath) {
-    console.error(`saeeol binary not found (${getBinaryName()})`)
-    console.error("Run: npm install saeeol")
-    process.exit(1)
-  }
-
-  const electronPath = findElectron()
-  const webDir = join(SCRIPT_DIR, "web")
-  const hasWebUI = existsSync(join(webDir, "index.html"))
-
-  // Fallback to terminal mode if no electron or no web UI
-  if (!electronPath || !hasWebUI) {
-    console.log(!electronPath ? "Electron not found." : "Web UI not found.")
-    console.log("Starting in terminal mode.\n")
-    const child = spawn(binaryPath, process.argv.slice(2), {
-      stdio: "inherit", env: { ...process.env }, windowsHide: false,
-    })
-    child.on("exit", (code) => process.exit(code || 0))
-    return
-  }
-
-  const webPort = 31000 + Math.floor(Math.random() * 5000)
-  const apiPort = 32000 + Math.floor(Math.random() * 5000)
-
-  // 1. Start saeeol API server
-  console.log("Starting saeeol API server...")
-  const api = spawn(binaryPath, ["web", "--port", String(apiPort), "--hostname", "127.0.0.1"], {
-    stdio: "pipe", env: { ...process.env }, windowsHide: true,
-  })
-  api.stdout.on("data", (d) => { const m = d.toString().trim(); if (m) console.log(`[api] ${m}`) })
-  api.stderr.on("data", (d) => { const m = d.toString().trim(); if (m) console.error(`[api] ${m}`) })
-
-  // 2. Serve React UI
-  const staticServer = await serveStatic(webDir, webPort)
-  console.log(`UI: http://127.0.0.1:${webPort}`)
-
-  // 3. Wait for API
-  await new Promise((r) => setTimeout(r, 3000))
-
-  // 4. Write Electron app inline
-  console.log("Opening FABULIST desktop...")
-  const appDir = join(SCRIPT_DIR, ".desktop-cache")
-  mkdirSync(appDir, { recursive: true })
-  writeFileSync(join(appDir, "package.json"), '{"name":"fabulist-desktop"}')
-  writeFileSync(join(appDir, "main.js"), `
-const { app, BrowserWindow } = require("electron")
-let mainWindow = null
-function createWindow() {
-  mainWindow = new BrowserWindow({
-    width: 1400, height: 900, minWidth: 800, minHeight: 600,
-    title: "\uD30C\uBD88\uB9AC\uC2A4\uD2B8 \u2014 FABULIST",
-    autoHideMenuBar: true,
-    show: false,
-    webPreferences: { nodeIntegration: false, contextIsolation: true },
-  })
-  mainWindow.once("ready-to-show", () => mainWindow.show())
-  mainWindow.loadURL("http://127.0.0.1:${webPort}")
-  mainWindow.on("closed", () => { mainWindow = null })
-}
-app.on("ready", createWindow)
-app.on("window-all-closed", () => { /* keep running */ })
-app.on("activate", () => { if (!mainWindow) createWindow() })
-`)
-
-  // Remove ELECTRON_RUN_AS_NODE if set (prevents Electron from running as Node)
-  const env = { ...process.env }
-  delete env.ELECTRON_RUN_AS_NODE
-
-  const electron = spawn(electronPath, [join(appDir, "main.js")], {
-    stdio: "ignore",
-    env,
-    detached: true,
-    windowsHide: false,
-  })
-  electron.unref()
-
-  console.log("FABULIST desktop opened! Close the window to exit.")
-  console.log("Press Ctrl+C to stop the server.")
-
-  const cleanup = () => { api.kill(); staticServer.close(); process.exit(0) }
-  process.on("SIGINT", cleanup)
-}
-
-main().catch((err) => { console.error(err.message); process.exit(1) })

package/postinstall.js

@@ -1,162 +0,0 @@
-#!/usr/bin/env node
-
-// saeeol postinstall — downloads platform binary from GitHub Releases
-const https = require("https")
-const http = require("http")
-const fs = require("fs")
-const path = require("path")
-const zlib = require("zlib")
-const { execSync } = require("child_process")
-
-const REPO = "byfabulist/fabulist"
-const VERSION = require("./package.json").version
-
-function getPlatformInfo() {
-  const archMap = { x64: "x64", arm64: "arm64" }
-  const platformMap = { win32: "windows", darwin: "darwin", linux: "linux" }
-  const p = platformMap[process.platform] || process.platform
-  const a = archMap[process.arch] || process.arch
-  const ext = process.platform === "win32" ? ".zip" : ".tar.gz"
-  const archiveName = `saeeol-${p}-${a}${ext}`
-  const binaryName = process.platform === "win32" ? "saeeol.exe" : "saeeol"
-  return { archiveName, binaryName, platform: p, arch: a }
-}
-
-function fetch(url, redirects = 5) {
-  return new Promise((resolve, reject) => {
-    const mod = url.startsWith("https") ? https : http
-    mod.get(url, { timeout: 60000 }, (res) => {
-      if (res.statusCode >= 300 && res.statusCode < 400 && res.headers.location) {
-        if (redirects <= 0) return reject(new Error("Too many redirects"))
-        return fetch(res.headers.location, redirects - 1).then(resolve, reject)
-      }
-      if (res.statusCode !== 200) {
-        return reject(new Error(`HTTP ${res.statusCode} for ${url}`))
-      }
-      const chunks = []
-      res.on("data", (chunk) => chunks.push(chunk))
-      res.on("end", () => resolve(Buffer.concat(chunks)))
-      res.on("error", reject)
-    }).on("error", reject)
-  })
-}
-
-async function extractTarGz(buffer, destDir, binaryName) {
-  // Use tar on non-windows, or platform tar on windows (git bash)
-  const tmpFile = path.join(destDir, "download.tar.gz")
-  fs.writeFileSync(tmpFile, buffer)
-  try {
-    if (process.platform === "win32") {
-      // Try PowerShell Expand-Archive for .tar.gz or just use tar if available
-      try {
-        execSync(`tar -xzf "${tmpFile}" -C "${destDir}"`, { stdio: "pipe", windowsHide: true })
-      } catch {
-        // Fallback: use zlib + tar parsing manually not practical, try powershell
-        throw new Error("tar command not available on Windows. Install Git Bash or add tar to PATH.")
-      }
-    } else {
-      execSync(`tar -xzf "${tmpFile}" -C "${destDir}"`, { stdio: "pipe" })
-    }
-  } finally {
-    try { fs.unlinkSync(tmpFile) } catch {}
-  }
-}
-
-async function extractZip(buffer, destDir, binaryName) {
-  if (process.platform === "win32") {
-    const tmpFile = path.join(destDir, "download.zip")
-    fs.writeFileSync(tmpFile, buffer)
-    try {
-      execSync(`powershell -Command "Expand-Archive -Path '${tmpFile}' -DestinationPath '${destDir}' -Force"`, {
-        stdio: "pipe",
-        windowsHide: true,
-      })
-    } finally {
-      try { fs.unlinkSync(tmpFile) } catch {}
-    }
-  } else {
-    // On non-windows, try unzip
-    const tmpFile = path.join(destDir, "download.zip")
-    fs.writeFileSync(tmpFile, buffer)
-    try {
-      execSync(`unzip -o "${tmpFile}" -d "${destDir}"`, { stdio: "pipe" })
-    } finally {
-      try { fs.unlinkSync(tmpFile) } catch {}
-    }
-  }
-}
-
-async function main() {
-  const { archiveName, binaryName, platform: p, arch: a } = getPlatformInfo()
-  const binDir = path.join(__dirname, "download")
-
-  // Check if binary already exists
-  const binaryPath = path.join(binDir, binaryName)
-  if (fs.existsSync(binaryPath)) {
-    console.log(`saeeol binary already exists at ${binaryPath}`)
-    return
-  }
-
-  fs.mkdirSync(binDir, { recursive: true })
-
-  const url = `https://github.com/${REPO}/releases/download/v${VERSION}/${archiveName}`
-  console.log(`Downloading saeeol v${VERSION} for ${p}-${a}...`)
-  console.log(`  ${url}`)
-
-  let buffer
-  try {
-    buffer = await fetch(url)
-  } catch (err) {
-    // Fallback: try without version tag (latest)
-    const fallbackUrl = `https://github.com/${REPO}/releases/latest/download/${archiveName}`
-    console.log(`Version-specific download failed: ${err.message}`)
-    console.log(`Trying latest: ${fallbackUrl}`)
-    try {
-      buffer = await fetch(fallbackUrl)
-    } catch (err2) {
-      console.error(`Failed to download saeeol binary: ${err2.message}`)
-      console.error(`Please download manually from: https://github.com/${REPO}/releases`)
-      process.exit(0) // Don't fail npm install
-    }
-  }
-
-  console.log(`Downloaded ${(buffer.length / 1024 / 1024).toFixed(1)} MB`)
-
-  // Extract
-  if (archiveName.endsWith(".tar.gz")) {
-    await extractTarGz(buffer, binDir, binaryName)
-  } else {
-    await extractZip(buffer, binDir, binaryName)
-  }
-
-  // Verify
-  if (!fs.existsSync(binaryPath)) {
-    // The archive might extract to a subdirectory, search for the binary
-    const files = fs.readdirSync(binDir, { recursive: true })
-    const found = files.find((f) => {
-      const basename = path.basename(f)
-      return basename === "saeeol" || basename === "saeeol.exe"
-    })
-    if (found) {
-      const fullPath = path.join(binDir, found)
-      fs.copyFileSync(fullPath, binaryPath)
-    }
-  }
-
-  if (fs.existsSync(binaryPath)) {
-    if (process.platform !== "win32") {
-      fs.chmodSync(binaryPath, 0o755)
-    }
-    console.log(`saeeol v${VERSION} installed successfully!`)
-    console.log(`  Binary: ${binaryPath}`)
-  } else {
-    console.warn(`Warning: binary not found after extraction at ${binaryPath}`)
-    console.warn(`You may need to install manually from https://github.com/${REPO}/releases`)
-  }
-}
-
-main().catch((err) => {
-  console.error(`saeeol postinstall failed: ${err.message}`)
-  console.error(`Install manually: https://github.com/${REPO}/releases`)
-  process.exit(0) // Don't fail npm install
-})