codecane 1.0.402 → 1.0.404

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codecane",
-  "version": "1.0.402",
+  "version": "1.0.404",
   "description": "AI coding agent",
   "license": "MIT",
   "bin": {
@@ -8,7 +8,6 @@
   },
   "files": [
     "scripts/codebuff-wrapper.js",
-    "scripts/download-binary.js",
     "README.md"
   ],
   "os": [
@@ -24,7 +23,8 @@
     "node": ">=16"
   },
   "dependencies": {
-    "tar": "^6.2.0"
+    "tar": "^6.2.0",
+    "adm-zip": "^0.5.10"
   },
   "repository": {
     "type": "git",

package/scripts/codebuff-wrapper.js

@@ -4,44 +4,308 @@ const fs = require('fs')
 const path = require('path')
 const os = require('os')
 const { spawn, execSync } = require('child_process')
+const https = require('https')
+const zlib = require('zlib')
+const tar = require('tar')
 
-const homeDir = os.homedir()
-const manicodeDir = path.join(homeDir, '.config', 'manicode')
-const binaryName = process.platform === 'win32' ? 'codebuff.exe' : 'codebuff'
-const binaryPath = path.join(manicodeDir, binaryName)
+// Configuration
+const CONFIG = {
+  homeDir: os.homedir(),
+  configDir: path.join(os.homedir(), '.config', 'manicode'),
+  binaryName: process.platform === 'win32' ? 'codebuff.exe' : 'codebuff',
+  githubRepo: 'CodebuffAI/codebuff-community',
+  userAgent: 'codebuff-cli',
+  requestTimeout: 10000,
+  updateCheckTimeout: 5000,
+}
+
+CONFIG.binaryPath = path.join(CONFIG.configDir, CONFIG.binaryName)
+
+// Platform target mapping
+const PLATFORM_TARGETS = {
+  'linux-x64': 'codebuff-linux-x64.tar.gz',
+  'linux-arm64': 'codebuff-linux-arm64.tar.gz',
+  'darwin-x64': 'codebuff-darwin-x64.tar.gz',
+  'darwin-arm64': 'codebuff-darwin-arm64.tar.gz',
+  'win32-x64': 'codebuff-win32-x64.zip',
+}
+
+// Utility functions
+function httpGet(url, options = {}) {
+  return new Promise((resolve, reject) => {
+    const parsedUrl = new URL(url)
+    const reqOptions = {
+      hostname: parsedUrl.hostname,
+      path: parsedUrl.pathname + parsedUrl.search,
+      headers: {
+        'User-Agent': CONFIG.userAgent,
+        ...options.headers,
+      },
+    }
 
-// Check if binary exists
-if (!fs.existsSync(binaryPath)) {
-  console.log('🔄 Codebuff binary not found. Downloading...')
-  
+    const req = https.get(reqOptions, (res) => {
+      if (res.statusCode === 302 || res.statusCode === 301) {
+        return httpGet(res.headers.location, options)
+          .then(resolve)
+          .catch(reject)
+      }
+      resolve(res)
+    })
+
+    req.on('error', reject)
+
+    const timeout = options.timeout || CONFIG.requestTimeout
+    req.setTimeout(timeout, () => {
+      req.destroy()
+      reject(new Error('Request timeout'))
+    })
+  })
+}
+
+async function getLatestVersion() {
   try {
-    // Run the download script synchronously
-    const downloadScript = path.join(__dirname, 'download-binary.js')
-    execSync(`node "${downloadScript}"`, { stdio: 'inherit' })
+    const res = await httpGet(
+      `https://api.github.com/repos/${CONFIG.githubRepo}/releases/latest`
+    )
+
+    let data = ''
+    for await (const chunk of res) {
+      data += chunk
+    }
+
+    const release = JSON.parse(data)
+    return release.tag_name?.replace(/^v/, '') || null
   } catch (error) {
-    console.error('❌ Failed to download codebuff binary')
-    console.error('Please try running: npm install -g codebuff')
-    process.exit(1)
+    return null
   }
 }
 
-// Check if binary is executable (Unix only)
-if (process.platform !== 'win32') {
+function getCurrentVersion() {
+  if (!fs.existsSync(CONFIG.binaryPath)) return null
+
   try {
-    fs.accessSync(binaryPath, fs.constants.X_OK)
+    const result = execSync(`"${CONFIG.binaryPath}" --version`, {
+      encoding: 'utf-8',
+      stdio: 'pipe',
+      timeout: 1000,
+    })
+    return result.trim()
   } catch (error) {
-    console.error(`❌ Codebuff binary is not executable: ${binaryPath}`)
-    console.error('Please try running: npm install -g codebuff')
-    process.exit(1)
+    return null
   }
 }
 
-// Execute the binary with all arguments passed through
-const child = spawn(binaryPath, process.argv.slice(2), {
-  stdio: 'inherit',
-  cwd: process.cwd()
-})
+function compareVersions(v1, v2) {
+  if (!v1 || !v2) return 0
+
+  const parts1 = v1.split('.').map(Number)
+  const parts2 = v2.split('.').map(Number)
+
+  for (let i = 0; i < Math.max(parts1.length, parts2.length); i++) {
+    const p1 = parts1[i] || 0
+    const p2 = parts2[i] || 0
+
+    if (p1 < p2) return -1
+    if (p1 > p2) return 1
+  }
+
+  return 0
+}
+
+function showProgress(downloaded, total) {
+  if (total > 0) {
+    const percentage = Math.round((downloaded / total) * 100)
+    process.stderr.write(`\r${percentage}%`)
+  } else {
+    const downloadedMB = (downloaded / 1024 / 1024).toFixed(1)
+    process.stderr.write(`\r${downloadedMB} MB`)
+  }
+}
+
+async function downloadBinary(version) {
+  const platformKey = `${process.platform}-${process.arch}`
+  const fileName = PLATFORM_TARGETS[platformKey]
+
+  if (!fileName) {
+    throw new Error(`Unsupported platform: ${process.platform} ${process.arch}`)
+  }
+
+  const downloadUrl = `https://github.com/${CONFIG.githubRepo}/releases/download/v${version}/${fileName}`
+
+  // Ensure config directory exists
+  fs.mkdirSync(CONFIG.configDir, { recursive: true })
+
+  console.log(`Downloading codebuff v${version}...`)
+
+  const res = await httpGet(downloadUrl)
+
+  if (res.statusCode !== 200) {
+    throw new Error(`Download failed: HTTP ${res.statusCode}`)
+  }
+
+  const totalSize = parseInt(res.headers['content-length'] || '0', 10)
+  let downloadedSize = 0
+  let lastProgressTime = Date.now()
+
+  const chunks = []
+
+  for await (const chunk of res) {
+    chunks.push(chunk)
+    downloadedSize += chunk.length
+
+    const now = Date.now()
+    if (now - lastProgressTime >= 100 || downloadedSize === totalSize) {
+      lastProgressTime = now
+      showProgress(downloadedSize, totalSize)
+    }
+  }
+
+  process.stderr.write('\n')
+  console.log('Extracting...')
+
+  const buffer = Buffer.concat(chunks)
+
+  if (fileName.endsWith('.zip')) {
+    // Windows ZIP extraction
+    const AdmZip = require('adm-zip')
+    const zipPath = path.join(CONFIG.configDir, fileName)
+
+    fs.writeFileSync(zipPath, buffer)
+
+    const zip = new AdmZip(zipPath)
+    zip.extractAllTo(CONFIG.configDir, true)
+
+    fs.unlinkSync(zipPath)
+  } else {
+    // Unix tar.gz extraction
+    await new Promise((resolve, reject) => {
+      const gunzip = zlib.createGunzip()
+      const extract = tar.extract({ cwd: CONFIG.configDir })
+
+      gunzip.pipe(extract).on('finish', resolve).on('error', reject)
+
+      gunzip.end(buffer)
+    })
+  }
+
+  // Rename extracted binary to standard name
+  const extractedName = fileName.replace(/\.(tar\.gz|zip)$/, '')
+  const extractedPath = path.join(CONFIG.configDir, extractedName)
+
+  if (fs.existsSync(extractedPath)) {
+    if (process.platform !== 'win32') {
+      fs.chmodSync(extractedPath, 0o755)
+    }
+    fs.renameSync(extractedPath, CONFIG.binaryPath)
+  } else {
+    throw new Error(`Binary not found after extraction`)
+  }
+}
+
+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)
+    }
+
+    try {
+      await downloadBinary(version)
+    } catch (error) {
+      console.error('❌ Failed to download codebuff:', error.message)
+      console.error('Please try again later.')
+      process.exit(1)
+    }
+  }
+
+  // Verify binary is executable (Unix only)
+  if (process.platform !== 'win32') {
+    try {
+      fs.accessSync(CONFIG.binaryPath, fs.constants.X_OK)
+    } catch (error) {
+      console.error(`❌ Binary is not executable: ${CONFIG.binaryPath}`)
+      console.error('Run: chmod +x', CONFIG.binaryPath)
+      process.exit(1)
+    }
+  }
+}
+
+async function checkForUpdates(runningProcess, exitListener) {
+  try {
+    const currentVersion = getCurrentVersion()
+    if (!currentVersion) return
+
+    const latestVersion = await getLatestVersion()
+    if (!latestVersion) return
+
+    console.log(`Current version: ${currentVersion}`)
+    console.log(`Latest version: ${latestVersion}`)
+
+    if (compareVersions(currentVersion, latestVersion) < 0) {
+      process.stdout.write(`Updating...`)
+
+      // 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')
+          }
+          resolve()
+        }, 5000)
+      })
+
+      await downloadBinary(latestVersion)
+
+      // Restart with new binary
+      const newChild = spawn(CONFIG.binaryPath, process.argv.slice(2), {
+        stdio: 'inherit',
+        cwd: process.cwd(),
+      })
+
+      newChild.on('exit', (code) => {
+        process.exit(code || 0)
+      })
+    }
+  } catch (error) {
+    // Silently ignore update check errors
+  }
+}
+
+async function main() {
+  // Ensure binary exists
+  await ensureBinaryExists()
+
+  // Start codebuff
+  const child = spawn(CONFIG.binaryPath, process.argv.slice(2), {
+    stdio: 'inherit',
+    cwd: process.cwd(),
+  })
+
+  // 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)
+}
 
-child.on('exit', (code) => {
-  process.exit(code || 0)
+// Run the main function
+main().catch((error) => {
+  console.error('❌ Unexpected error:', error.message)
+  process.exit(1)
 })

package/scripts/download-binary.js

@@ -1,153 +0,0 @@
-#!/usr/bin/env node
-
-const https = require('https')
-const fs = require('fs')
-const path = require('path')
-const os = require('os')
-const { platform, arch } = process
-
-// Get version from package.json
-const packageJsonPath = path.join(__dirname, '..', 'package.json')
-let version
-try {
-  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'))
-  version = packageJson.version
-} catch (error) {
-  console.error('❌ Could not read package.json version')
-  process.exit(1)
-}
-
-const targets = {
-  'linux-x64': 'codebuff-linux-x64.tar.gz',
-  'linux-arm64': 'codebuff-linux-arm64.tar.gz',
-  'darwin-x64': 'codebuff-darwin-x64.tar.gz', 
-  'darwin-arm64': 'codebuff-darwin-arm64.tar.gz',
-  'win32-x64': 'codebuff-win32-x64.zip'
-}
-
-const key = `${platform}-${arch}`
-const file = targets[key]
-
-if (!file) {
-  console.error(`❌ Unsupported platform: ${platform} ${arch}`)
-  console.error('Supported platforms:', Object.keys(targets).join(', '))
-  process.exit(1)
-}
-
-const url = `https://github.com/CodebuffAI/codebuff-community/releases/download/v${version}/${file}`
-const homeDir = os.homedir()
-const manicodeDir = path.join(homeDir, '.config', 'manicode')
-const binaryName = platform === 'win32' ? 'codebuff.exe' : 'codebuff'
-const binaryPath = path.join(manicodeDir, binaryName)
-
-// Check if binary already exists
-if (fs.existsSync(binaryPath)) {
-  console.log('✅ Binary already exists')
-  process.exit(0)
-}
-
-// Create .config/manicode directory
-fs.mkdirSync(manicodeDir, { recursive: true })
-
-console.log(`⬇️  Downloading ${file} from GitHub releases...`)
-console.log(`📍 Installing to: ${manicodeDir}`)
-
-const request = https.get(url, (res) => {
-  if (res.statusCode === 302 || res.statusCode === 301) {
-    // Follow redirect
-    return https.get(res.headers.location, handleResponse)
-  }
-  handleResponse(res)
-})
-
-request.on('error', (err) => {
-  console.error(`❌ Download failed: ${err.message}`)
-  process.exit(1)
-})
-
-function handleResponse(res) {
-  if (res.statusCode !== 200) {
-    console.error(`❌ Download failed: HTTP ${res.statusCode}`)
-    console.error(`URL: ${url}`)
-    process.exit(1)
-  }
-
-  const totalSize = parseInt(res.headers['content-length'] || '0', 10)
-  let downloadedSize = 0
-  let lastProgressTime = Date.now()
-
-  // Show progress for downloads
-  const showProgress = (downloaded, total) => {
-    const now = Date.now()
-    // Update progress every 100ms to avoid too frequent updates
-    if (now - lastProgressTime < 100 && downloaded < total) return
-    lastProgressTime = now
-
-    if (total > 0) {
-      const percentage = Math.round((downloaded / total) * 100)
-      const downloadedMB = (downloaded / 1024 / 1024).toFixed(1)
-      const totalMB = (total / 1024 / 1024).toFixed(1)
-      process.stderr.write(`\r📥 Downloaded ${downloadedMB}MB / ${totalMB}MB (${percentage}%)`)
-    } else {
-      const downloadedMB = (downloaded / 1024 / 1024).toFixed(1)
-      process.stderr.write(`\r📥 Downloaded ${downloadedMB}MB`)
-    }
-  }
-
-  res.on('data', (chunk) => {
-    downloadedSize += chunk.length
-    showProgress(downloadedSize, totalSize)
-  })
-
-  if (file.endsWith('.zip')) {
-    // Handle zip files (Windows)
-    const zipPath = path.join(manicodeDir, file)
-    const writeStream = fs.createWriteStream(zipPath)
-    
-    res.pipe(writeStream)
-    
-    writeStream.on('finish', () => {
-      process.stderr.write('\n') // New line after progress
-      console.log('📦 Extracting...')
-      // Extract zip file
-      const { execSync } = require('child_process')
-      try {
-        execSync(`cd "${manicodeDir}" && unzip -o "${file}"`, { stdio: 'inherit' })
-        fs.unlinkSync(zipPath) // Clean up zip file
-        console.log('✅ codebuff installed successfully!')
-      } catch (error) {
-        console.error('❌ Failed to extract zip:', error.message)
-        process.exit(1)
-      }
-    })
-  } else {
-    // Handle tar.gz files (Unix)
-    const zlib = require('zlib')
-    const tar = require('tar')
-    
-    res.pipe(zlib.createGunzip())
-       .pipe(tar.extract({ cwd: manicodeDir }))
-       .on('finish', () => {
-         process.stderr.write('\n') // New line after progress
-         // The extracted binary will have the platform/arch in the name
-         const extractedBinaryName = file.replace('.tar.gz', '').replace('.zip', '')
-         const finalBinaryName = platform === 'win32' ? 'codebuff.exe' : 'codebuff'
-         const extractedBinaryPath = path.join(manicodeDir, extractedBinaryName)
-         const finalBinaryPath = path.join(manicodeDir, finalBinaryName)
-         
-         if (fs.existsSync(extractedBinaryPath)) {
-           fs.chmodSync(extractedBinaryPath, 0o755)
-           // Rename to the standard name
-           fs.renameSync(extractedBinaryPath, finalBinaryPath)
-           console.log('✅ codebuff installed successfully!')
-         } else {
-           console.error(`❌ Binary not found at ${extractedBinaryPath}`)
-           process.exit(1)
-         }
-       })
-       .on('error', (err) => {
-         console.error(`❌ Extraction failed: ${err.message}`)
-         process.exit(1)
-       })
-  }
-}