codebuff 1.0.534 → 1.0.536

package/index.js

@@ -22,6 +22,8 @@ function createConfig(packageName) {
     configDir,
     binaryName,
     binaryPath: path.join(configDir, binaryName),
+    metadataPath: path.join(configDir, 'codebuff-metadata.json'),
+    tempDownloadDir: path.join(configDir, '.download-temp'),
     userAgent: `${packageName}-cli`,
     requestTimeout: 20000,
   }
@@ -111,53 +113,64 @@ function streamToString(stream) {
 }
 
 function getCurrentVersion() {
-  if (!fs.existsSync(CONFIG.binaryPath)) return null
-
   try {
-    return new Promise((resolve, reject) => {
-      const child = spawn(CONFIG.binaryPath, ['--version'], {
-        cwd: os.homedir(),
-        stdio: 'pipe',
-      })
+    if (!fs.existsSync(CONFIG.metadataPath)) {
+      return null
+    }
+    const metadata = JSON.parse(fs.readFileSync(CONFIG.metadataPath, 'utf8'))
+    // Also verify the binary still exists
+    if (!fs.existsSync(CONFIG.binaryPath)) {
+      return null
+    }
+    return metadata.version || null
+  } catch (error) {
+    return null
+  }
+}
 
-      let output = ''
-      let errorOutput = ''
+function runSmokeTest(binaryPath) {
+  return new Promise((resolve) => {
+    if (!fs.existsSync(binaryPath)) {
+      resolve(false)
+      return
+    }
 
-      child.stdout.on('data', (data) => {
-        output += data.toString()
-      })
+    const child = spawn(binaryPath, ['--version'], {
+      cwd: os.homedir(),
+      stdio: 'pipe',
+    })
 
-      child.stderr.on('data', (data) => {
-        errorOutput += data.toString()
-      })
+    let output = ''
 
-      const timeout = setTimeout(() => {
-        child.kill('SIGTERM')
-        setTimeout(() => {
-          if (!child.killed) {
-            child.kill('SIGKILL')
-          }
-        }, 4000)
-        resolve('error')
-      }, 4000)
-
-      child.on('exit', (code) => {
-        clearTimeout(timeout)
-        if (code === 0) {
-          resolve(output.trim())
-        } else {
-          resolve('error')
+    child.stdout.on('data', (data) => {
+      output += data.toString()
+    })
+
+    const timeout = setTimeout(() => {
+      child.kill('SIGTERM')
+      setTimeout(() => {
+        if (!child.killed) {
+          child.kill('SIGKILL')
         }
-      })
+      }, 1000)
+      resolve(false)
+    }, 5000)
+
+    child.on('exit', (code) => {
+      clearTimeout(timeout)
+      // Check that it exits successfully and outputs something that looks like a version
+      if (code === 0 && output.trim().match(/^\d+(\.\d+)*$/)) {
+        resolve(true)
+      } else {
+        resolve(false)
+      }
+    })
 
-      child.on('error', () => {
-        clearTimeout(timeout)
-        resolve('error')
-      })
+    child.on('error', () => {
+      clearTimeout(timeout)
+      resolve(false)
     })
-  } catch (error) {
-    return 'error'
-  }
+  })
 }
 
 function compareVersions(v1, v2) {
@@ -250,33 +263,21 @@ async function downloadBinary(version) {
     process.env.NEXT_PUBLIC_CODEBUFF_APP_URL || 'https://codebuff.com'
   }/api/releases/download/${version}/${fileName}`
 
+  // Ensure config directory exists
   fs.mkdirSync(CONFIG.configDir, { recursive: true })
 
-  if (fs.existsSync(CONFIG.binaryPath)) {
-    try {
-      fs.unlinkSync(CONFIG.binaryPath)
-    } catch (err) {
-      // Fallback: try renaming the locked/undeletable binary
-      const backupPath = CONFIG.binaryPath + `.old.${Date.now()}`
-
-      try {
-        fs.renameSync(CONFIG.binaryPath, backupPath)
-      } catch (renameErr) {
-        // If we can't unlink OR rename, we can't safely proceed
-        throw new Error(
-          `Failed to replace existing binary. ` +
-            `unlink error: ${err.code || err.message}, ` +
-            `rename error: ${renameErr.code || renameErr.message}`,
-        )
-      }
-    }
+  // Clean up any previous temp download directory
+  if (fs.existsSync(CONFIG.tempDownloadDir)) {
+    fs.rmSync(CONFIG.tempDownloadDir, { recursive: true })
   }
+  fs.mkdirSync(CONFIG.tempDownloadDir, { recursive: true })
 
   term.write('Downloading...')
 
   const res = await httpGet(downloadUrl)
 
   if (res.statusCode !== 200) {
+    fs.rmSync(CONFIG.tempDownloadDir, { recursive: true })
     throw new Error(`Download failed: HTTP ${res.statusCode}`)
   }
 
@@ -302,31 +303,71 @@ async function downloadBinary(version) {
     }
   })
 
+  // Extract to temp directory
   await new Promise((resolve, reject) => {
     res
       .pipe(zlib.createGunzip())
-      .pipe(tar.x({ cwd: CONFIG.configDir }))
+      .pipe(tar.x({ cwd: CONFIG.tempDownloadDir }))
       .on('finish', resolve)
       .on('error', reject)
   })
 
-  try {
-    const files = fs.readdirSync(CONFIG.configDir)
-    const extractedPath = path.join(CONFIG.configDir, CONFIG.binaryName)
+  const tempBinaryPath = path.join(CONFIG.tempDownloadDir, CONFIG.binaryName)
+
+  // Verify the binary was extracted
+  if (!fs.existsSync(tempBinaryPath)) {
+    const files = fs.readdirSync(CONFIG.tempDownloadDir)
+    fs.rmSync(CONFIG.tempDownloadDir, { recursive: true })
+    throw new Error(
+      `Binary not found after extraction. Expected: ${CONFIG.binaryName}, Available files: ${files.join(', ')}`,
+    )
+  }
+
+  // Set executable permissions
+  if (process.platform !== 'win32') {
+    fs.chmodSync(tempBinaryPath, 0o755)
+  }
+
+  // Run smoke test on the downloaded binary
+  term.write('Verifying download...')
+  const smokeTestPassed = await runSmokeTest(tempBinaryPath)
 
-    if (fs.existsSync(extractedPath)) {
-      if (process.platform !== 'win32') {
-        fs.chmodSync(extractedPath, 0o755)
+  if (!smokeTestPassed) {
+    fs.rmSync(CONFIG.tempDownloadDir, { recursive: true })
+    throw new Error('Downloaded binary failed smoke test (--version check)')
+  }
+
+  // Smoke test passed - move binary to final location
+  try {
+    if (fs.existsSync(CONFIG.binaryPath)) {
+      try {
+        fs.unlinkSync(CONFIG.binaryPath)
+      } catch (err) {
+        // Fallback: try renaming the locked/undeletable binary (Windows)
+        const backupPath = CONFIG.binaryPath + `.old.${Date.now()}`
+        try {
+          fs.renameSync(CONFIG.binaryPath, backupPath)
+        } catch (renameErr) {
+          throw new Error(
+            `Failed to replace existing binary. ` +
+              `unlink error: ${err.code || err.message}, ` +
+              `rename error: ${renameErr.code || renameErr.message}`,
+          )
+        }
       }
-    } else {
-      throw new Error(
-        `Binary not found after extraction. Expected: ${extractedPath}, Available files: ${files.join(', ')}`,
-      )
     }
-  } catch (error) {
-    term.clearLine()
-    console.error(`Extraction failed: ${error.message}`)
-    process.exit(1)
+    fs.renameSync(tempBinaryPath, CONFIG.binaryPath)
+
+    // Save version metadata for fast version checking
+    fs.writeFileSync(
+      CONFIG.metadataPath,
+      JSON.stringify({ version }, null, 2),
+    )
+  } finally {
+    // Clean up temp directory even if rename fails
+    if (fs.existsSync(CONFIG.tempDownloadDir)) {
+      fs.rmSync(CONFIG.tempDownloadDir, { recursive: true })
+    }
   }
 
   term.clearLine()
@@ -334,8 +375,8 @@ async function downloadBinary(version) {
 }
 
 async function ensureBinaryExists() {
-  const currentVersion = await getCurrentVersion()
-  if (currentVersion !== null && currentVersion !== 'error') {
+  const currentVersion = getCurrentVersion()
+  if (currentVersion !== null) {
     return
   }
 
@@ -358,14 +399,14 @@ async function ensureBinaryExists() {
 
 async function checkForUpdates(runningProcess, exitListener) {
   try {
-    const currentVersion = await getCurrentVersion()
-    if (!currentVersion) return
+    const currentVersion = getCurrentVersion()
 
     const latestVersion = await getLatestVersion()
     if (!latestVersion) return
 
     if (
-      currentVersion === 'error' ||
+      // Download new version if current version is unknown or outdated.
+      currentVersion === null ||
       compareVersions(currentVersion, latestVersion) < 0
     ) {
       term.clearLine()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codebuff",
-  "version": "1.0.534",
+  "version": "1.0.536",
   "description": "AI coding agent",
   "license": "MIT",
   "bin": {

package/postinstall.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 const fs = require('fs');
-const path = require('path');
 const os = require('os');
+const path = require('path');
 
 // Clean up old binary
 const binaryPath = path.join(