codecane 1.0.420-beta.26 → 1.0.420-beta.260

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,37 +1,34 @@
 #!/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 path = require('path')
 const zlib = require('zlib')
+
 const tar = require('tar')
 
-// Hardcoded package name for codecane
 const packageName = 'codecane'
 
 function createConfig(packageName) {
-  const homeDir = os.homedir()
-  const configDir = path.join(homeDir, '.config', 'manicode')
+  // Store binary in package directory instead of ~/.config/manicode
+  const packageDir = __dirname
+  const binDir = path.join(packageDir, 'bin')
   const binaryName =
     process.platform === 'win32' ? `${packageName}.exe` : packageName
 
   return {
-    homeDir,
-    configDir,
+    packageDir,
+    binDir,
     binaryName,
-    binaryPath: path.join(configDir, binaryName),
-    githubRepo: 'CodebuffAI/codebuff-community',
+    binaryPath: path.join(binDir, binaryName),
     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 +37,6 @@ const PLATFORM_TARGETS = {
   'win32-x64': `${packageName}-win32-x64.tar.gz`,
 }
 
-// Terminal utilities
 const term = {
   clearLine: () => {
     if (process.stderr.isTTY) {
@@ -57,7 +53,6 @@ const term = {
   },
 }
 
-// Utility functions
 function httpGet(url, options = {}) {
   return new Promise((resolve, reject) => {
     const parsedUrl = new URL(url)
@@ -70,13 +65,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 +87,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
   }
@@ -154,21 +114,20 @@ function getCurrentVersion() {
   if (!fs.existsSync(CONFIG.binaryPath)) return null
 
   try {
-    return new Promise((resolve, reject) => {
+    return new Promise((resolve) => {
       const child = spawn(CONFIG.binaryPath, ['--version'], {
-        cwd: os.homedir(),
+        cwd: CONFIG.packageDir,
         stdio: 'pipe',
       })
 
       let output = ''
-      let errorOutput = ''
 
       child.stdout.on('data', (data) => {
         output += data.toString()
       })
 
-      child.stderr.on('data', (data) => {
-        errorOutput += data.toString()
+      child.stderr.on('data', () => {
+        // Ignore stderr output
       })
 
       const timeout = setTimeout(() => {
@@ -177,9 +136,9 @@ function getCurrentVersion() {
           if (!child.killed) {
             child.kill('SIGKILL')
           }
-        }, 1000)
+        }, 4000)
         resolve('error')
-      }, 1000)
+      }, 4000)
 
       child.on('exit', (code) => {
         clearTimeout(timeout)
@@ -213,7 +172,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 +180,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 +195,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 +204,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,13 +239,29 @@ 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 })
+  // Create bin directory in package directory
+  fs.mkdirSync(CONFIG.binDir, { recursive: true })
 
   if (fs.existsSync(CONFIG.binaryPath)) {
-    fs.unlinkSync(CONFIG.binaryPath)
+    try {
+      fs.unlinkSync(CONFIG.binaryPath)
+    } catch (err) {
+      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}`,
+        )
+      }
+    }
   }
 
   term.write('Downloading...')
@@ -314,8 +285,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)}`)
@@ -326,15 +297,14 @@ async function downloadBinary(version) {
   await new Promise((resolve, reject) => {
     res
       .pipe(zlib.createGunzip())
-      .pipe(tar.x({ cwd: CONFIG.configDir }))
+      .pipe(tar.x({ cwd: CONFIG.binDir }))
       .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 files = fs.readdirSync(CONFIG.binDir)
+    const extractedPath = path.join(CONFIG.binDir, CONFIG.binaryName)
 
     if (fs.existsSync(extractedPath)) {
       if (process.platform !== 'win32') {
@@ -342,7 +312,7 @@ async function downloadBinary(version) {
       }
     } else {
       throw new Error(
-        `Binary not found after extraction. Expected: ${extractedPath}, Available files: ${files.join(', ')}`
+        `Binary not found after extraction. Expected: ${extractedPath}, Available files: ${files.join(', ')}`,
       )
     }
   } catch (error) {
@@ -356,22 +326,25 @@ 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 = await getCurrentVersion()
+  if (currentVersion !== null && currentVersion !== 'error') {
+    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)
   }
 }
 
@@ -384,22 +357,16 @@ async function checkForUpdates(runningProcess, exitListener) {
     if (!latestVersion) return
 
     if (
-      // Download new version if current binary errors.
       currentVersion === 'error' ||
       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 +379,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,13 +1,13 @@
 {
   "name": "codecane",
-  "version": "1.0.420-beta.26",
-  "description": "AI coding agent (staging)",
+  "version": "1.0.420-beta.260",
+  "description": "AI coding agent CLI (staging)",
   "license": "MIT",
   "bin": {
     "codecane": "index.js"
   },
   "scripts": {
-    "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 */ }\""
+    "postinstall": "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",
@@ -30,7 +30,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/CodebuffAI/codebuff-community.git"
+    "url": "https://github.com/CodebuffAI/codebuff.git"
   },
   "homepage": "https://codebuff.com",
   "publishConfig": {