codecane 1.0.420-beta.26 → 1.0.420-beta.261

package/README.md

@@ -39,7 +39,7 @@ Once running, simply chat with Codecane to say what coding task you want done.
 - Can run your tests or type checker or linter; can install packages
 - It's powerful: ask Codecane to keep working until it reaches a condition and it will.
 
-Our users regularly use Codecane to implement new features, write unit tests, refactor code,write scripts, or give advice.
+Our users regularly use Codecane to implement new features, write unit tests, refactor code, write scripts, or give advice.
 
 ## Knowledge Files
 
@@ -69,5 +69,3 @@ If you still have errors, it's a good idea to [reinstall Node](https://nodejs.or
 ## Feedback
 
 We value your input! Please email your feedback to `founders@codebuff.com`. Thank you for using Codecane!
-
-<!-- Test comment for staging workflow -->

package/index.js

@@ -1,14 +1,14 @@
 #!/usr/bin/env node
 
-const fs = require('fs')
-const path = require('path')
-const os = require('os')
 const { spawn } = require('child_process')
+const fs = require('fs')
 const https = require('https')
+const os = require('os')
+const path = require('path')
 const zlib = require('zlib')
+
 const tar = require('tar')
 
-// Hardcoded package name for codecane
 const packageName = 'codecane'
 
 function createConfig(packageName) {
@@ -22,16 +22,15 @@ function createConfig(packageName) {
     configDir,
     binaryName,
     binaryPath: path.join(configDir, binaryName),
-    githubRepo: 'CodebuffAI/codebuff-community',
+    metadataPath: path.join(configDir, 'codecane-metadata.json'),
+    tempDownloadDir: path.join(configDir, '.download-temp-staging'),
     userAgent: `${packageName}-cli`,
     requestTimeout: 20000,
-    isPrerelease: true, // codecane always looks for prereleases
   }
 }
 
 const CONFIG = createConfig(packageName)
 
-// Platform target mapping
 const PLATFORM_TARGETS = {
   'linux-x64': `${packageName}-linux-x64.tar.gz`,
   'linux-arm64': `${packageName}-linux-arm64.tar.gz`,
@@ -40,7 +39,6 @@ const PLATFORM_TARGETS = {
   'win32-x64': `${packageName}-win32-x64.tar.gz`,
 }
 
-// Terminal utilities
 const term = {
   clearLine: () => {
     if (process.stderr.isTTY) {
@@ -57,7 +55,6 @@ const term = {
   },
 }
 
-// Utility functions
 function httpGet(url, options = {}) {
   return new Promise((resolve, reject) => {
     const parsedUrl = new URL(url)
@@ -70,13 +67,6 @@ function httpGet(url, options = {}) {
       },
     }
 
-    // Add GitHub token if available
-    const token = process.env.GITHUB_TOKEN
-    if (token) {
-      console.log('Using your GITHUB_TOKEN to download the latest version.')
-      reqOptions.headers.Authorization = `Bearer ${token}`
-    }
-
     const req = https.get(reqOptions, (res) => {
       if (res.statusCode === 302 || res.statusCode === 301) {
         return httpGet(new URL(res.headers.location, url).href, options)
@@ -99,43 +89,15 @@ function httpGet(url, options = {}) {
 async function getLatestVersion() {
   try {
     const res = await httpGet(
-      `https://github.com/${CONFIG.githubRepo}/releases.atom`
+      `https://registry.npmjs.org/${packageName}/latest`,
     )
 
     if (res.statusCode !== 200) return null
 
     const body = await streamToString(res)
+    const packageData = JSON.parse(body)
 
-    // Parse the Atom XML to extract releases
-    const tagMatches = body.match(
-      /<id>tag:github\.com,2008:Repository\/\d+\/([^<]+)<\/id>/g
-    )
-
-    if (!tagMatches) return null
-
-    // Extract all version tags
-    const versions = tagMatches
-      .map((match) => {
-        const tagMatch = match.match(
-          /<id>tag:github\.com,2008:Repository\/\d+\/([^<]+)<\/id>/
-        )
-        return tagMatch ? tagMatch[1].replace(/^v/, '') : null
-      })
-      .filter(Boolean)
-
-    if (versions.length === 0) return null
-
-    // Filter versions based on whether we want prereleases or stable releases
-    const filteredVersions = versions.filter((version) => {
-      const isPrerelease = version.includes('-')
-      return CONFIG.isPrerelease === isPrerelease
-    })
-
-    if (filteredVersions.length === 0) return null
-
-    // Sort and return the latest version
-    filteredVersions.sort(compareVersions)
-    return filteredVersions[filteredVersions.length - 1]
+    return packageData.version || null
   } catch (error) {
     return null
   }
@@ -151,58 +113,75 @@ 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')
-          }
-        }, 1000)
-        resolve('error')
-      }, 1000)
+    child.stdout.on('data', (data) => {
+      output += data.toString()
+    })
 
-      child.on('exit', (code) => {
-        clearTimeout(timeout)
-        if (code === 0) {
-          resolve(output.trim())
-        } else {
-          resolve('error')
+    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+)*(-beta\.\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) {
   if (!v1 || !v2) return 0
 
+  // Always update if the current version is not a valid semver
+  // e.g. 1.0.420-beta.1
+  if (!v1.match(/^\d+(\.\d+)*$/)) {
+    return -1
+  }
+
   const parseVersion = (version) => {
     const parts = version.split('-')
     const mainParts = parts[0].split('.').map(Number)
@@ -213,7 +192,6 @@ function compareVersions(v1, v2) {
   const p1 = parseVersion(v1)
   const p2 = parseVersion(v2)
 
-  // Compare main version parts
   for (let i = 0; i < Math.max(p1.main.length, p2.main.length); i++) {
     const n1 = p1.main[i] || 0
     const n2 = p2.main[i] || 0
@@ -222,15 +200,13 @@ function compareVersions(v1, v2) {
     if (n1 > n2) return 1
   }
 
-  // If main versions are equal, compare prerelease parts
   if (p1.prerelease.length === 0 && p2.prerelease.length === 0) {
-    return 0 // No prerelease, versions are equal
+    return 0
   } else if (p1.prerelease.length === 0) {
-    return 1 // v1 is a release, v2 is prerelease, so v1 > v2
+    return 1
   } else if (p2.prerelease.length === 0) {
-    return -1 // v2 is a release, v1 is prerelease, so v1 < v2
+    return -1
   } else {
-    // Both have prerelease parts, compare them
     for (
       let i = 0;
       i < Math.max(p1.prerelease.length, p2.prerelease.length);
@@ -239,7 +215,6 @@ function compareVersions(v1, v2) {
       const pr1 = p1.prerelease[i] || ''
       const pr2 = p2.prerelease[i] || ''
 
-      // Handle numeric vs. string parts
       const isNum1 = !isNaN(parseInt(pr1))
       const isNum2 = !isNaN(parseInt(pr2))
 
@@ -249,16 +224,16 @@ function compareVersions(v1, v2) {
         if (num1 < num2) return -1
         if (num1 > num2) return 1
       } else if (isNum1 && !isNum2) {
-        return 1 // Numeric prerelease is generally higher than alpha/beta
+        return 1
       } else if (!isNum1 && isNum2) {
         return -1
-      } else {
-        // Lexicographical comparison for string parts
-        if (pr1 < pr2) return -1
-        if (pr1 > pr2) return 1
+      } else if (pr1 < pr2) {
+        return -1
+      } else if (pr1 > pr2) {
+        return 1
       }
     }
-    return 0 // Prerelease parts are equal
+    return 0
   }
 }
 
@@ -284,20 +259,25 @@ async function downloadBinary(version) {
     throw new Error(`Unsupported platform: ${process.platform} ${process.arch}`)
   }
 
-  const downloadUrl = `https://github.com/${CONFIG.githubRepo}/releases/download/v${version}/${fileName}`
+  const downloadUrl = `${
+    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)) {
-    fs.unlinkSync(CONFIG.binaryPath)
+  // 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}`)
   }
 
@@ -314,8 +294,8 @@ async function downloadBinary(version) {
         const pct = Math.round((downloadedSize / totalSize) * 100)
         term.write(
           `Downloading... ${createProgressBar(pct)} ${pct}% of ${formatBytes(
-            totalSize
-          )}`
+            totalSize,
+          )}`,
         )
       } else {
         term.write(`Downloading... ${formatBytes(downloadedSize)}`)
@@ -323,32 +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 {
-    // Find the extracted binary - it should be named "codebuff" or "codebuff.exe"
-    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(', ')}`,
+    )
+  }
 
-    if (fs.existsSync(extractedPath)) {
-      if (process.platform !== 'win32') {
-        fs.chmodSync(extractedPath, 0o755)
+  // 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 (!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()
@@ -356,50 +375,47 @@ async function downloadBinary(version) {
 }
 
 async function ensureBinaryExists() {
-  if (!fs.existsSync(CONFIG.binaryPath)) {
-    const version = await getLatestVersion()
-    if (!version) {
-      console.error('❌ Failed to determine latest version')
-      console.error('Please check your internet connection and try again')
-      process.exit(1)
-    }
+  const currentVersion = getCurrentVersion()
+  if (currentVersion !== null) {
+    return
+  }
 
-    try {
-      await downloadBinary(version)
-    } catch (error) {
-      term.clearLine()
-      console.error('❌ Failed to download codebuff:', error.message)
-      console.error('Please check your internet connection and try again')
-      process.exit(1)
-    }
+  const version = await getLatestVersion()
+  if (!version) {
+    console.error('❌ Failed to determine latest version')
+    console.error('Please check your internet connection and try again')
+    process.exit(1)
+  }
+
+  try {
+    await downloadBinary(version)
+  } catch (error) {
+    term.clearLine()
+    console.error('❌ Failed to download codecane:', error.message)
+    console.error('Please check your internet connection and try again')
+    process.exit(1)
   }
 }
 
 async function checkForUpdates(runningProcess, exitListener) {
   try {
-    const currentVersion = await getCurrentVersion()
-    if (!currentVersion) return
+    const currentVersion = getCurrentVersion()
 
     const latestVersion = await getLatestVersion()
     if (!latestVersion) return
 
     if (
-      // Download new version if current binary errors.
-      currentVersion === 'error' ||
+      // Download new version if current version is unknown or outdated.
+      currentVersion === null ||
       compareVersions(currentVersion, latestVersion) < 0
     ) {
       term.clearLine()
 
-      // Remove the specific exit listener to prevent it from interfering with the update
       runningProcess.removeListener('exit', exitListener)
-
-      // Kill the running process
       runningProcess.kill('SIGTERM')
 
-      // Wait for the process to actually exit
       await new Promise((resolve) => {
         runningProcess.on('exit', resolve)
-        // Fallback timeout in case the process doesn't exit gracefully
         setTimeout(() => {
           if (!runningProcess.killed) {
             runningProcess.kill('SIGKILL')
@@ -412,64 +428,48 @@ async function checkForUpdates(runningProcess, exitListener) {
 
       await downloadBinary(latestVersion)
 
-      // Restart with new binary - this replaces the current process
-      const newChild = spawn(
-        CONFIG.binaryPath,
-        [packageName, ...process.argv.slice(2)],
-        {
-          stdio: 'inherit',
-          detached: false,
-        }
-      )
+      const newChild = spawn(CONFIG.binaryPath, process.argv.slice(2), {
+        stdio: 'inherit',
+        detached: false,
+      })
 
-      // Set up exit handler for the new process
       newChild.on('exit', (code) => {
         process.exit(code || 0)
       })
 
-      // Don't return - keep this function running to maintain the wrapper
-      return new Promise(() => {}) // Never resolves, keeps wrapper alive
+      return new Promise(() => {})
     }
   } catch (error) {
-    // Silently ignore update check errors
+    // Ignore update failures
   }
 }
 
 async function main() {
-  // Bold, bright warning for staging environment
   console.log('\x1b[1m\x1b[91m' + '='.repeat(60) + '\x1b[0m')
   console.log('\x1b[1m\x1b[93m❄️ CODECANE STAGING ENVIRONMENT ❄️\x1b[0m')
   console.log(
-    '\x1b[1m\x1b[91mFOR TESTING PURPOSES ONLY - NOT FOR PRODUCTION USE\x1b[0m'
+    '\x1b[1m\x1b[91mFOR TESTING PURPOSES ONLY - NOT FOR PRODUCTION USE\x1b[0m',
   )
   console.log('\x1b[1m\x1b[91m' + '='.repeat(60) + '\x1b[0m')
   console.log('')
 
   await ensureBinaryExists()
 
-  // Start the binary with codecane argument
-  const child = spawn(
-    CONFIG.binaryPath,
-    [packageName, ...process.argv.slice(2)],
-    {
-      stdio: 'inherit',
-    }
-  )
+  const child = spawn(CONFIG.binaryPath, process.argv.slice(2), {
+    stdio: 'inherit',
+  })
 
-  // Store reference to the exit listener so we can remove it during updates
   const exitListener = (code) => {
     process.exit(code || 0)
   }
 
   child.on('exit', exitListener)
 
-  // Check for updates in background
   setTimeout(() => {
     checkForUpdates(child, exitListener)
   }, 100)
 }
 
-// Run the main function
 main().catch((error) => {
   console.error('❌ Unexpected error:', error.message)
   process.exit(1)

package/package.json

@@ -1,16 +1,18 @@
 {
   "name": "codecane",
-  "version": "1.0.420-beta.26",
-  "description": "AI coding agent (staging)",
+  "version": "1.0.420-beta.261",
+  "description": "AI coding agent CLI (staging)",
   "license": "MIT",
   "bin": {
     "codecane": "index.js"
   },
   "scripts": {
+    "postinstall": "node postinstall.js",
     "preuninstall": "node -e \"const fs = require('fs'); const path = require('path'); const os = require('os'); const binaryPath = path.join(os.homedir(), '.config', 'manicode', process.platform === 'win32' ? 'codecane.exe' : 'codecane'); try { fs.unlinkSync(binaryPath) } catch (e) { /* ignore if file doesn't exist */ }\""
   },
   "files": [
     "index.js",
+    "postinstall.js",
     "README.md"
   ],
   "os": [
@@ -30,7 +32,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/CodebuffAI/codebuff-community.git"
+    "url": "https://github.com/CodebuffAI/codebuff.git"
   },
   "homepage": "https://codebuff.com",
   "publishConfig": {

package/postinstall.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+// Clean up old binary
+const binaryPath = path.join(
+  os.homedir(),
+  '.config',
+  'manicode',
+  process.platform === 'win32' ? 'codecane.exe' : 'codecane'
+);
+
+try {
+  fs.unlinkSync(binaryPath);
+} catch (e) {
+  /* ignore if file doesn't exist */
+}
+
+// Print welcome message
+console.log('\n');
+console.log('🧪 Welcome to Codecane (Staging)!');
+console.log('\n');
+console.log('⚠️  This is a staging/beta release for testing purposes.');
+console.log('\n');
+console.log('To get started:');
+console.log('  1. cd to your project directory');
+console.log('  2. Run: codecane');
+console.log('\n');
+console.log('Example:');
+console.log('  $ cd ~/my-project');
+console.log('  $ codecane');
+console.log('\n');
+console.log('For more information, visit: https://codebuff.com/docs');
+console.log('\n');