@onescience/onecode 1.14.50-202606300908 → 1.14.50-202607010646

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onescience/onecode",
-  "version": "1.14.50-202606300908",
+  "version": "1.14.50-202607010646",
   "private": false,
   "license": "MIT",
   "description": "OneScience AI coding agent for the terminal.",
@@ -8,9 +8,6 @@
     "onecode": "./bin/onecode"
   },
   "scripts": {
-    "postinstall": "bun ./postinstall.mjs || node ./postinstall.mjs"
-  },
-  "optionalDependencies": {
-    "onecode-linux-x64": "1.14.50-202606300908"
+    "postinstall": "node ./postinstall.mjs"
   }
 }

package/postinstall.mjs

@@ -3,12 +3,13 @@
 import fs from "fs"
 import path from "path"
 import os from "os"
+import https from "https"
 import { fileURLToPath } from "url"
-import { createRequire } from "module"
+import { execSync } from "child_process"
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
-const require = createRequire(import.meta.url)
 const product = "onecode"
+const DEFAULT_TGZ_BASE = "https://218.90.133.98:4443/onecode_tgz"
 
 function detectPlatformAndArch() {
   let platform
@@ -40,30 +41,99 @@ function detectPlatformAndArch() {
       break
     default:
       arch = os.arch()
-      break
   }
 
   return { platform, arch }
 }
 
-function findBinary() {
+function ownVersion() {
+  return JSON.parse(fs.readFileSync(path.join(__dirname, "package.json"), "utf8")).version
+}
+
+function platformPackageName() {
   const { platform, arch } = detectPlatformAndArch()
-  const packageName = `${product}-${platform}-${arch}`
-  const binaryName = platform === "windows" ? `${product}.exe` : product
+  return `${product}-${platform}-${arch}`
+}
 
-  try {
-    const packageJsonPath = require.resolve(`${packageName}/package.json`)
-    const packageDir = path.dirname(packageJsonPath)
-    const binaryPath = path.join(packageDir, "bin", binaryName)
+function platformTgzUrl(version) {
+  const base = (process.env.ONECODE_TGZ_DOWNLOAD_BASE || DEFAULT_TGZ_BASE).replace(/\/$/, "")
+  const dir = encodeURIComponent(`onecode-${version}`)
+  const file = encodeURIComponent(`onecode-linux-x64-${version}.tgz`)
+  return `${base}/${dir}/${file}`
+}
 
-    if (!fs.existsSync(binaryPath)) {
-      throw new Error(`Binary not found at ${binaryPath}`)
-    }
+function downloadFile(url, dest) {
+  return new Promise((resolve, reject) => {
+    const file = fs.createWriteStream(dest)
+    const req = https.get(url, { rejectUnauthorized: false }, (res) => {
+      if (res.statusCode === 301 || res.statusCode === 302) {
+        file.close()
+        fs.unlinkSync(dest)
+        downloadFile(res.headers.location, dest).then(resolve).catch(reject)
+        return
+      }
+      if (res.statusCode !== 200) {
+        file.close()
+        fs.unlinkSync(dest)
+        reject(new Error(`HTTP ${res.statusCode} for ${url}`))
+        return
+      }
+      res.pipe(file)
+      file.on("finish", () => file.close(resolve))
+    })
+    req.on("error", (err) => {
+      file.close()
+      if (fs.existsSync(dest)) fs.unlinkSync(dest)
+      reject(err)
+    })
+  })
+}
 
-    return { binaryPath, binaryName }
-  } catch (error) {
-    throw new Error(`Could not find package ${packageName}: ${error.message}`, { cause: error })
+async function downloadAndExtractPlatformPackage() {
+  const packageName = platformPackageName()
+  const version = ownVersion()
+  const url = platformTgzUrl(version)
+  const nodeModulesDir = path.join(__dirname, "node_modules")
+  const targetDir = path.join(nodeModulesDir, packageName)
+  const tmpTgz = path.join(os.tmpdir(), `${packageName}-${version}.tgz`)
+  const tmpExtract = path.join(os.tmpdir(), `${packageName}-${version}-extract`)
+
+  console.log(`Downloading ${packageName} from ${url}`)
+  await downloadFile(url, tmpTgz)
+  console.log(`Downloaded ${path.basename(tmpTgz)} (${(fs.statSync(tmpTgz).size / 1024 / 1024).toFixed(1)} MB)`)
+
+  fs.rmSync(tmpExtract, { recursive: true, force: true })
+  fs.mkdirSync(tmpExtract, { recursive: true })
+  execSync(`tar -xzf "${tmpTgz}"`, { cwd: tmpExtract, stdio: "pipe" })
+  fs.unlinkSync(tmpTgz)
+
+  const extractedRoot = path.join(tmpExtract, "package")
+  if (!fs.existsSync(extractedRoot)) {
+    throw new Error(`Expected package/ inside tgz downloaded from ${url}`)
+  }
+
+  fs.rmSync(targetDir, { recursive: true, force: true })
+  fs.mkdirSync(nodeModulesDir, { recursive: true })
+  fs.renameSync(extractedRoot, targetDir)
+  fs.rmSync(tmpExtract, { recursive: true, force: true })
+
+  const binaryName = detectPlatformAndArch().platform === "windows" ? `${product}.exe` : product
+  const binaryPath = path.join(targetDir, "bin", binaryName)
+  if (!fs.existsSync(binaryPath)) {
+    throw new Error(`Binary not found at ${binaryPath} after extraction`)
   }
+  fs.chmodSync(binaryPath, 0o755)
+
+  return { binaryPath, binaryName }
+}
+
+function findExistingPlatformBinary() {
+  const packageName = platformPackageName()
+  const binaryName = detectPlatformAndArch().platform === "windows" ? `${product}.exe` : product
+  const targetDir = path.join(__dirname, "node_modules", packageName)
+  const binaryPath = path.join(targetDir, "bin", binaryName)
+  if (!fs.existsSync(binaryPath)) return null
+  return { binaryPath, binaryName }
 }
 
 async function main() {
@@ -73,15 +143,20 @@ async function main() {
       return
     }
 
-    const { binaryPath } = findBinary()
+    let result = findExistingPlatformBinary()
+    if (!result) {
+      result = await downloadAndExtractPlatformPackage()
+    }
+
     const target = path.join(__dirname, "bin", `.${product}`)
     if (fs.existsSync(target)) fs.unlinkSync(target)
     try {
-      fs.linkSync(binaryPath, target)
+      fs.linkSync(result.binaryPath, target)
     } catch {
-      fs.copyFileSync(binaryPath, target)
+      fs.copyFileSync(result.binaryPath, target)
     }
     fs.chmodSync(target, 0o755)
+    console.log(`${product} binary ready`)
   } catch (error) {
     console.error(`Failed to setup ${product} binary:`, error.message)
     process.exit(1)