freebuff 0.0.98 → 0.0.100

package/index.js

@@ -74,6 +74,14 @@ function shouldExitAlternateScreen(code, signal) {
   return Boolean(signal) || isWindowsNativeCrashCode(code)
 }
 
+function isIllegalInstructionExit(code, signal) {
+  const unsignedCode = getUnsignedExitCode(code)
+  return (
+    signal === 'SIGILL' ||
+    (process.platform === 'win32' && unsignedCode === 0xC000001D)
+  )
+}
+
 function createConfig(packageName) {
   const homeDir = os.homedir()
   const configDir = path.join(homeDir, '.config', 'manicode')
@@ -164,10 +172,17 @@ function trackUpdateFailed(errorMessage, version, context = {}) {
 
 const PLATFORM_TARGETS = {
   'linux-x64': `${packageName}-linux-x64.tar.gz`,
+  'linux-x64-baseline': `${packageName}-linux-x64-baseline.tar.gz`,
   'linux-arm64': `${packageName}-linux-arm64.tar.gz`,
   'darwin-x64': `${packageName}-darwin-x64.tar.gz`,
   'darwin-arm64': `${packageName}-darwin-arm64.tar.gz`,
   'win32-x64': `${packageName}-win32-x64.tar.gz`,
+  'win32-x64-baseline': `${packageName}-win32-x64-baseline.tar.gz`,
+}
+
+const BASELINE_FALLBACK_TARGETS = {
+  'linux-x64': 'linux-x64-baseline',
+  'win32-x64': 'win32-x64-baseline',
 }
 
 const term = {
@@ -186,6 +201,84 @@ const term = {
   },
 }
 
+function getPlatformKey() {
+  return `${process.platform}-${process.arch}`
+}
+
+function getTargetOverride() {
+  const envNames = [
+    `${packageName.toUpperCase()}_BINARY_TARGET`,
+    'CODEBUFF_BINARY_TARGET',
+    'CLI_BINARY_TARGET',
+  ]
+
+  for (const envName of envNames) {
+    const target = process.env[envName]
+    if (target && PLATFORM_TARGETS[target]) {
+      return target
+    }
+  }
+
+  return null
+}
+
+function linuxCpuHasAvx2() {
+  if (process.platform !== 'linux' || process.arch !== 'x64') {
+    return true
+  }
+
+  try {
+    return /\bavx2\b/i.test(fs.readFileSync('/proc/cpuinfo', 'utf8'))
+  } catch {
+    return true
+  }
+}
+
+function getDefaultTargetKey() {
+  const override = getTargetOverride()
+  if (override) {
+    return override
+  }
+
+  const platformKey = getPlatformKey()
+  if (platformKey === 'linux-x64' && !linuxCpuHasAvx2()) {
+    return 'linux-x64-baseline'
+  }
+
+  return platformKey
+}
+
+function getBaselineFallbackTargetKey() {
+  // Windows has no reliable plain-Node CPU feature check here, so we keep
+  // the fast x64 binary first and fall back after the native SIGILL code.
+  return BASELINE_FALLBACK_TARGETS[getPlatformKey()] || null
+}
+
+function isTargetAllowedForThisMachine(target) {
+  const override = getTargetOverride()
+  if (override) {
+    return target === override
+  }
+  return (
+    target === getDefaultTargetKey() ||
+    target === getBaselineFallbackTargetKey()
+  )
+}
+
+function getDownloadTargetKey() {
+  const override = getTargetOverride()
+  if (override) {
+    return override
+  }
+
+  const metadata = getCurrentMetadata()
+  if (metadata?.target && isTargetAllowedForThisMachine(metadata.target)) {
+    return metadata.target
+  }
+
+  return getDefaultTargetKey()
+}
+
 async function getLatestVersion() {
   try {
     const res = await httpGet(
@@ -214,19 +307,34 @@ function streamToString(stream) {
 
 function getCurrentVersion() {
   try {
-    if (!fs.existsSync(CONFIG.metadataPath)) {
+    const metadata = getCurrentMetadata()
+    if (!metadata) {
       return null
     }
-    const metadata = JSON.parse(fs.readFileSync(CONFIG.metadataPath, 'utf8'))
     if (!fs.existsSync(CONFIG.binaryPath)) {
       return null
     }
+    const metadataTarget = metadata.target || getPlatformKey()
+    if (!isTargetAllowedForThisMachine(metadataTarget)) {
+      return null
+    }
     return metadata.version || null
   } catch (error) {
     return null
   }
 }
 
+function getCurrentMetadata() {
+  try {
+    if (!fs.existsSync(CONFIG.metadataPath)) {
+      return null
+    }
+    return JSON.parse(fs.readFileSync(CONFIG.metadataPath, 'utf8'))
+  } catch {
+    return null
+  }
+}
+
 function compareVersions(v1, v2) {
   if (!v1 || !v2) return 0
 
@@ -303,13 +411,12 @@ function createProgressBar(percentage, width = 30) {
   return '[' + '█'.repeat(filled) + '░'.repeat(empty) + ']'
 }
 
-async function downloadBinary(version) {
-  const platformKey = `${process.platform}-${process.arch}`
-  const fileName = PLATFORM_TARGETS[platformKey]
+async function downloadBinary(version, targetKey = getDownloadTargetKey()) {
+  const fileName = PLATFORM_TARGETS[targetKey]
 
   if (!fileName) {
     const error = new Error(`Unsupported platform: ${process.platform} ${process.arch}`)
-    trackUpdateFailed(error.message, version, { stage: 'platform_check' })
+    trackUpdateFailed(error.message, version, { stage: 'platform_check', target: targetKey })
     throw error
   }
 
@@ -331,7 +438,7 @@ async function downloadBinary(version) {
   if (res.statusCode !== 200) {
     fs.rmSync(CONFIG.tempDownloadDir, { recursive: true })
     const error = new Error(`Download failed: HTTP ${res.statusCode}`)
-    trackUpdateFailed(error.message, version, { stage: 'http_download', statusCode: res.statusCode })
+    trackUpdateFailed(error.message, version, { stage: 'http_download', statusCode: res.statusCode, target: targetKey })
     throw error
   }
 
@@ -373,7 +480,7 @@ async function downloadBinary(version) {
     const error = new Error(
       `Binary not found after extraction. Expected: ${CONFIG.binaryName}, Available files: ${files.join(', ')}`,
     )
-    trackUpdateFailed(error.message, version, { stage: 'extraction' })
+    trackUpdateFailed(error.message, version, { stage: 'extraction', target: targetKey })
     throw error
   }
 
@@ -423,7 +530,7 @@ async function downloadBinary(version) {
 
     fs.writeFileSync(
       CONFIG.metadataPath,
-      JSON.stringify({ version }, null, 2),
+      JSON.stringify({ version, target: targetKey }, null, 2),
     )
   } finally {
     if (fs.existsSync(CONFIG.tempDownloadDir)) {
@@ -505,14 +612,7 @@ async function checkForUpdates(runningProcess, exitListener) {
       await downloadBinary(latestVersion)
 
       const newChild = spawnInstalledBinary({ detached: false })
-
-      newChild.on('exit', (code, signal) => {
-        resetTerminal({
-          exitAlternateScreen: shouldExitAlternateScreen(code, signal),
-        })
-        printCrashDiagnostics(code, signal)
-        process.exit(signal ? 1 : (code || 0))
-      })
+      attachExitHandler(newChild)
 
       return new Promise(() => {})
     }
@@ -524,9 +624,7 @@ async function checkForUpdates(runningProcess, exitListener) {
 function printCrashDiagnostics(code, signal) {
   // Windows NTSTATUS codes (unsigned DWORD)
   const unsignedCode = getUnsignedExitCode(code)
-  const isIllegalInstruction =
-    signal === 'SIGILL' ||
-    (process.platform === 'win32' && unsignedCode === 0xC000001D)
+  const isIllegalInstruction = isIllegalInstructionExit(code, signal)
   const isAccessViolation =
     signal === 'SIGSEGV' ||
     (process.platform === 'win32' && unsignedCode === 0xC0000005)
@@ -635,12 +733,57 @@ function spawnInstalledBinary(options = {}) {
   return child
 }
 
-async function main() {
-  await ensureBinaryExists()
+async function tryFallbackToBaseline(code, signal) {
+  if (!isIllegalInstructionExit(code, signal)) {
+    return false
+  }
 
-  const child = spawnInstalledBinary()
+  const fallbackTarget = getBaselineFallbackTargetKey()
+  if (!fallbackTarget) {
+    return false
+  }
+
+  const metadata = getCurrentMetadata()
+  const currentTarget = metadata?.target || getDefaultTargetKey()
+  if (currentTarget === fallbackTarget) {
+    return false
+  }
+
+  const version = metadata?.version || (await getLatestVersion())
+  if (!version) {
+    return false
+  }
+
+  resetTerminal({
+    exitAlternateScreen: shouldExitAlternateScreen(code, signal),
+  })
+  console.error('')
+  console.error(
+    `${packageName} is switching to the older-CPU binary for this machine.`,
+  )
+
+  try {
+    await downloadBinary(version, fallbackTarget)
+  } catch (error) {
+    term.clearLine()
+    console.error(`Failed to download ${fallbackTarget}: ${error.message}`)
+    return false
+  }
+
+  const child = spawnInstalledBinary({ detached: false })
+  attachExitHandler(child, false)
+  return true
+}
+
+function attachExitHandler(child, allowBaselineFallback = true) {
+  const exitListener = async (code, signal) => {
+    if (
+      allowBaselineFallback &&
+      (await tryFallbackToBaseline(code, signal))
+    ) {
+      return
+    }
 
-  const exitListener = (code, signal) => {
     resetTerminal({
       exitAlternateScreen: shouldExitAlternateScreen(code, signal),
     })
@@ -649,6 +792,14 @@ async function main() {
   }
 
   child.on('exit', exitListener)
+  return exitListener
+}
+
+async function main() {
+  await ensureBinaryExists()
+
+  const child = spawnInstalledBinary()
+  const exitListener = attachExitHandler(child)
 
   setTimeout(() => {
     checkForUpdates(child, exitListener)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "freebuff",
-  "version": "0.0.98",
+  "version": "0.0.100",
   "description": "The world's strongest free coding agent",
   "license": "MIT",
   "bin": {
@@ -33,10 +33,11 @@
   },
   "repository": {
     "type": "git",
-    "url": "https://github.com/CodebuffAI/codebuff.git"
+    "url": "git+https://github.com/CodebuffAI/freebuff-private.git"
   },
-  "homepage": "https://codebuff.com",
+  "homepage": "https://freebuff.com",
   "publishConfig": {
-    "access": "public"
+    "access": "public",
+    "provenance": false
   }
 }