@openbuff/cli 0.1.0

package/README.md

@@ -0,0 +1,107 @@
+# The most powerful coding agent
+
+Openbuff is a CLI tool that writes code for you.
+
+1. Run `openbuff` from your project directory
+2. Tell it what to do
+3. It will read and write to files and run commands to produce the code you want
+
+Note: Openbuff will run commands in your terminal as it deems necessary to fulfill your request.
+
+## Installation
+
+To install Openbuff, run:
+
+```bash
+npm install -g openbuff
+```
+
+(Use `sudo` if you get a permission error.)
+
+## Usage
+
+After installation, you can start Openbuff by running:
+
+```bash
+openbuff [project-directory]
+```
+
+If no project directory is specified, Openbuff will use the current directory.
+
+Once running, simply chat with Openbuff to say what coding task you want done.
+
+## Features
+
+- Understands your whole codebase
+- Creates and edits multiple files based on your request
+- Can run your tests or type checker or linter; can install packages
+- It's powerful: ask Openbuff to keep working until it reaches a condition and it will.
+
+Our users regularly use Openbuff to implement new features, write unit tests, refactor code, write scripts, or give advice.
+
+## Knowledge Files
+
+To unlock the full benefits of modern LLMs, we recommend storing knowledge alongside your code. Add a `knowledge.md` file anywhere in your project to provide helpful context, guidance, and tips for the LLM as it performs tasks for you.
+
+Openbuff can fluently read and write files, so it will add knowledge as it goes. You don't need to write knowledge manually!
+
+Some have said every change should be paired with a unit test. In 2024, every change should come with a knowledge update!
+
+## Tips
+
+1. Type '/help' or just '/' to see available commands.
+2. Create a `knowledge.md` file and collect specific points of advice. The assistant will use this knowledge to improve its responses.
+3. Type `undo` or `redo` to revert or reapply file changes from the conversation.
+4. Press `Esc` or `Ctrl+C` while Openbuff is generating a response to stop it.
+
+## Troubleshooting
+
+### Permission Errors
+
+If you are getting permission errors during installation, try using sudo:
+
+```
+sudo npm install -g openbuff
+```
+
+If you still have errors, it's a good idea to [reinstall Node](https://nodejs.org/en/download).
+
+### Corporate Proxy / Firewall
+
+If you see `Failed to download openbuff: Request timeout` or `Failed to determine latest version`, you may be behind a corporate proxy or firewall.
+
+Openbuff respects standard proxy environment variables. Set `HTTPS_PROXY` to route traffic through your proxy:
+
+**Linux / macOS (bash/zsh):**
+```bash
+export HTTPS_PROXY=http://your-proxy-server:port
+openbuff
+```
+
+**Windows (PowerShell):**
+```powershell
+$env:HTTPS_PROXY = "http://your-proxy-server:port"
+openbuff
+```
+
+**Windows (CMD):**
+```cmd
+set HTTPS_PROXY=http://your-proxy-server:port
+openbuff
+```
+
+To make it permanent, add the `export` or `set` line to your shell profile (e.g. `~/.bashrc`, `~/.zshrc`, or Windows System Environment Variables).
+
+**Supported environment variables:**
+
+| Variable | Purpose |
+|---|---|
+| `HTTPS_PROXY` / `https_proxy` | Proxy for HTTPS requests (recommended) |
+| `HTTP_PROXY` / `http_proxy` | Fallback proxy for HTTP requests |
+| `NO_PROXY` / `no_proxy` | Comma-separated list of hostnames to bypass the proxy (port suffixes are ignored) |
+
+Both `http://` and `https://` proxy URLs are supported. Proxy authentication is supported via URL credentials (e.g. `http://user:password@proxy:port`).
+
+## Feedback
+
+We value your input! Please open a GitHub issue with your feedback. Thank you for using Openbuff!

package/http.js

@@ -0,0 +1,176 @@
+const http = require('http')
+const https = require('https')
+const tls = require('tls')
+
+function createReleaseHttpClient({
+  env = process.env,
+  userAgent,
+  requestTimeout,
+  httpModule = http,
+  httpsModule = https,
+  tlsModule = tls,
+}) {
+  function getProxyUrl() {
+    return (
+      env.HTTPS_PROXY ||
+      env.https_proxy ||
+      env.HTTP_PROXY ||
+      env.http_proxy ||
+      null
+    )
+  }
+
+  function shouldBypassProxy(hostname) {
+    const noProxy = env.NO_PROXY || env.no_proxy || ''
+    if (!noProxy) return false
+
+    const domains = noProxy
+      .split(',')
+      .map((domain) => domain.trim().toLowerCase().replace(/:\d+$/, ''))
+    const host = hostname.toLowerCase()
+
+    return domains.some((domain) => {
+      if (domain === '*') return true
+      if (domain.startsWith('.')) {
+        return host.endsWith(domain) || host === domain.slice(1)
+      }
+      return host === domain || host.endsWith(`.${domain}`)
+    })
+  }
+
+  function connectThroughProxy(proxyUrl, targetHost, targetPort) {
+    return new Promise((resolve, reject) => {
+      const proxy = new URL(proxyUrl)
+      const isHttpsProxy = proxy.protocol === 'https:'
+      const connectOptions = {
+        hostname: proxy.hostname,
+        port: proxy.port || (isHttpsProxy ? 443 : 80),
+        method: 'CONNECT',
+        path: `${targetHost}:${targetPort}`,
+        headers: {
+          Host: `${targetHost}:${targetPort}`,
+        },
+      }
+
+      if (proxy.username || proxy.password) {
+        const auth = Buffer.from(
+          `${decodeURIComponent(proxy.username || '')}:${decodeURIComponent(
+            proxy.password || '',
+          )}`,
+        ).toString('base64')
+        connectOptions.headers['Proxy-Authorization'] = `Basic ${auth}`
+      }
+
+      const transport = isHttpsProxy ? httpsModule : httpModule
+      const req = transport.request(connectOptions)
+
+      req.on('connect', (res, socket) => {
+        if (res.statusCode === 200) {
+          resolve(socket)
+          return
+        }
+
+        socket.destroy()
+        reject(new Error(`Proxy CONNECT failed with status ${res.statusCode}`))
+      })
+
+      req.on('error', (error) => {
+        reject(new Error(`Proxy connection failed: ${error.message}`))
+      })
+
+      req.setTimeout(requestTimeout, () => {
+        req.destroy()
+        reject(new Error('Proxy connection timeout.'))
+      })
+
+      req.end()
+    })
+  }
+
+  async function buildRequestOptions(url, options = {}) {
+    const parsedUrl = new URL(url)
+    const reqOptions = {
+      hostname: parsedUrl.hostname,
+      port: parsedUrl.port || 443,
+      path: parsedUrl.pathname + parsedUrl.search,
+      headers: {
+        'User-Agent': userAgent,
+        ...options.headers,
+      },
+    }
+
+    const proxyUrl = getProxyUrl()
+    if (!proxyUrl || shouldBypassProxy(parsedUrl.hostname)) {
+      return reqOptions
+    }
+
+    const tunnelSocket = await connectThroughProxy(
+      proxyUrl,
+      parsedUrl.hostname,
+      parsedUrl.port || 443,
+    )
+
+    class TunnelAgent extends httpsModule.Agent {
+      createConnection(_options, callback) {
+        const secureSocket = tlsModule.connect({
+          socket: tunnelSocket,
+          servername: parsedUrl.hostname,
+        })
+
+        if (typeof callback === 'function') {
+          if (typeof secureSocket.once === 'function') {
+            let settled = false
+            const finish = (error) => {
+              if (settled) return
+              settled = true
+              callback(error || null, error ? undefined : secureSocket)
+            }
+
+            secureSocket.once('secureConnect', () => finish(null))
+            secureSocket.once('error', (error) => finish(error))
+          } else {
+            callback(null, secureSocket)
+          }
+        }
+
+        return secureSocket
+      }
+    }
+
+    reqOptions.agent = new TunnelAgent({ keepAlive: false })
+    return reqOptions
+  }
+
+  async function httpGet(url, options = {}) {
+    const reqOptions = await buildRequestOptions(url, options)
+
+    return new Promise((resolve, reject) => {
+      const req = httpsModule.get(reqOptions, (res) => {
+        if (res.statusCode === 301 || res.statusCode === 302) {
+          res.resume()
+          httpGet(new URL(res.headers.location, url).href, options)
+            .then(resolve)
+            .catch(reject)
+          return
+        }
+
+        resolve(res)
+      })
+
+      req.on('error', reject)
+      req.setTimeout(options.timeout || requestTimeout, () => {
+        req.destroy()
+        reject(new Error('Request timeout.'))
+      })
+    })
+  }
+
+  return {
+    getProxyUrl,
+    httpGet,
+  }
+}
+
+module.exports = {
+  createReleaseHttpClient,
+}

package/index.js

@@ -0,0 +1,603 @@
+#!/usr/bin/env node
+
+const { spawn } = require('child_process')
+const fs = require('fs')
+const http = require('http')
+const https = require('https')
+const os = require('os')
+const path = require('path')
+const zlib = require('zlib')
+
+const tar = require('tar')
+const { createReleaseHttpClient } = require('./http')
+
+// npm package name — used for registry version checks (auto-update).
+// Distinct from binaryName below: the npm package is scoped (@openbuff/cli)
+// but the compiled binary and command users type is still `openbuff`.
+const npmPackageName = '@openbuff/cli'
+const binaryName = 'openbuff'
+
+/**
+ * Terminal escape sequences to reset terminal state after the child process exits.
+ * When the binary is SIGKILL'd, it can't clean up its own terminal state.
+ * The wrapper (this process) survives and must reset these modes.
+ *
+ * Keep in sync with TERMINAL_RESET_SEQUENCES in cli/src/utils/renderer-cleanup.ts
+ */
+const TERMINAL_RESET_SEQUENCES =
+  '\x1b[?1049l' + // Exit alternate screen buffer
+  '\x1b[?1000l' + // Disable X10 mouse mode
+  '\x1b[?1002l' + // Disable button event mouse mode
+  '\x1b[?1003l' + // Disable any-event mouse mode (all motion)
+  '\x1b[?1006l' + // Disable SGR extended mouse mode
+  '\x1b[?1004l' + // Disable focus reporting
+  '\x1b[?2004l' + // Disable bracketed paste mode
+  '\x1b[?25h' // Show cursor
+
+function resetTerminal() {
+  try {
+    if (process.stdin.isTTY && process.stdin.setRawMode) {
+      process.stdin.setRawMode(false)
+    }
+  } catch {
+    // stdin may be closed
+  }
+  try {
+    if (process.stdout.isTTY) {
+      process.stdout.write(TERMINAL_RESET_SEQUENCES)
+    }
+  } catch {
+    // stdout may be closed
+  }
+}
+
+function createConfig(binName) {
+  const homeDir = os.homedir()
+  const configDir = path.join(homeDir, '.config', 'openbuff')
+  const resolvedBinaryName =
+    process.platform === 'win32' ? `${binName}.exe` : binName
+
+  return {
+    homeDir,
+    configDir,
+    binaryName: resolvedBinaryName,
+    binaryPath: path.join(configDir, resolvedBinaryName),
+    metadataPath: path.join(configDir, 'openbuff-metadata.json'),
+    tempDownloadDir: path.join(configDir, '.download-temp'),
+    userAgent: `${binName}-cli`,
+    requestTimeout: 20000,
+  }
+}
+
+const CONFIG = createConfig(binaryName)
+const { getProxyUrl, httpGet } = createReleaseHttpClient({
+  env: process.env,
+  userAgent: CONFIG.userAgent,
+  requestTimeout: CONFIG.requestTimeout,
+})
+
+function getPostHogConfig() {
+  const apiKey =
+    process.env.CODEBUFF_POSTHOG_API_KEY ||
+    process.env.NEXT_PUBLIC_POSTHOG_API_KEY
+  const host =
+    process.env.CODEBUFF_POSTHOG_HOST ||
+    process.env.NEXT_PUBLIC_POSTHOG_HOST_URL
+
+  if (!apiKey || !host) {
+    return null
+  }
+
+  return { apiKey, host }
+}
+
+/**
+ * Track update failure event to PostHog.
+ * Fire-and-forget - errors are silently ignored.
+ */
+function trackUpdateFailed(errorMessage, version, context = {}) {
+  try {
+    const posthogConfig = getPostHogConfig()
+    if (!posthogConfig) {
+      return
+    }
+
+    const payload = JSON.stringify({
+      api_key: posthogConfig.apiKey,
+      event: 'cli.update_openbuff_failed',
+      properties: {
+        distinct_id: `anonymous-${CONFIG.homeDir}`,
+        error: errorMessage,
+        version: version || 'unknown',
+        platform: process.platform,
+        arch: process.arch,
+        ...context,
+      },
+      timestamp: new Date().toISOString(),
+    })
+
+    const parsedUrl = new URL(`${posthogConfig.host}/capture/`)
+    const isHttps = parsedUrl.protocol === 'https:'
+    const options = {
+      hostname: parsedUrl.hostname,
+      port: parsedUrl.port || (isHttps ? 443 : 80),
+      path: parsedUrl.pathname + parsedUrl.search,
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(payload),
+      },
+    }
+
+    const transport = isHttps ? https : http
+    const req = transport.request(options)
+    req.on('error', () => {}) // Silently ignore errors
+    req.write(payload)
+    req.end()
+  } catch (e) {
+    // Silently ignore any tracking errors
+  }
+}
+
+// Binary tarball asset filenames on the GitHub Release. The binary is named
+// `openbuff` (see binaryName above) regardless of the scoped npm package name.
+const PLATFORM_TARGETS = {
+  'linux-x64': `${binaryName}-linux-x64.tar.gz`,
+  'linux-arm64': `${binaryName}-linux-arm64.tar.gz`,
+  'darwin-x64': `${binaryName}-darwin-x64.tar.gz`,
+  'darwin-arm64': `${binaryName}-darwin-arm64.tar.gz`,
+  'win32-x64': `${binaryName}-win32-x64.tar.gz`,
+}
+
+const term = {
+  clearLine: () => {
+    if (process.stderr.isTTY) {
+      process.stderr.write('\r\x1b[K')
+    }
+  },
+  write: (text) => {
+    term.clearLine()
+    process.stderr.write(text)
+  },
+  writeLine: (text) => {
+    term.clearLine()
+    process.stderr.write(text + '\n')
+  },
+}
+
+async function getLatestVersion() {
+  try {
+    const res = await httpGet(
+      `https://registry.npmjs.org/${npmPackageName}/latest`,
+    )
+
+    if (res.statusCode !== 200) return null
+
+    const body = await streamToString(res)
+    const packageData = JSON.parse(body)
+
+    return packageData.version || null
+  } catch (error) {
+    return null
+  }
+}
+
+function streamToString(stream) {
+  return new Promise((resolve, reject) => {
+    let data = ''
+    stream.on('data', (chunk) => (data += chunk))
+    stream.on('end', () => resolve(data))
+    stream.on('error', reject)
+  })
+}
+
+function getCurrentVersion() {
+  try {
+    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
+  }
+}
+
+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)
+    const prereleaseParts = parts[1] ? parts[1].split('.') : []
+    return { main: mainParts, prerelease: prereleaseParts }
+  }
+
+  const p1 = parseVersion(v1)
+  const p2 = parseVersion(v2)
+
+  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
+
+    if (n1 < n2) return -1
+    if (n1 > n2) return 1
+  }
+
+  if (p1.prerelease.length === 0 && p2.prerelease.length === 0) {
+    return 0
+  } else if (p1.prerelease.length === 0) {
+    return 1
+  } else if (p2.prerelease.length === 0) {
+    return -1
+  } else {
+    for (
+      let i = 0;
+      i < Math.max(p1.prerelease.length, p2.prerelease.length);
+      i++
+    ) {
+      const pr1 = p1.prerelease[i] || ''
+      const pr2 = p2.prerelease[i] || ''
+
+      const isNum1 = !isNaN(parseInt(pr1))
+      const isNum2 = !isNaN(parseInt(pr2))
+
+      if (isNum1 && isNum2) {
+        const num1 = parseInt(pr1)
+        const num2 = parseInt(pr2)
+        if (num1 < num2) return -1
+        if (num1 > num2) return 1
+      } else if (isNum1 && !isNum2) {
+        return 1
+      } else if (!isNum1 && isNum2) {
+        return -1
+      } else if (pr1 < pr2) {
+        return -1
+      } else if (pr1 > pr2) {
+        return 1
+      }
+    }
+    return 0
+  }
+}
+
+function formatBytes(bytes) {
+  if (bytes === 0) return '0 B'
+  const k = 1024
+  const sizes = ['B', 'KB', 'MB', 'GB']
+  const i = Math.floor(Math.log(bytes) / Math.log(k))
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(1)) + ' ' + sizes[i]
+}
+
+function createProgressBar(percentage, width = 30) {
+  const filled = Math.round((width * percentage) / 100)
+  const empty = width - filled
+  return '[' + '█'.repeat(filled) + '░'.repeat(empty) + ']'
+}
+
+async function downloadBinary(version) {
+  const platformKey = `${process.platform}-${process.arch}`
+  const fileName = PLATFORM_TARGETS[platformKey]
+
+  if (!fileName) {
+    const error = new Error(`Unsupported platform: ${process.platform} ${process.arch}`)
+    trackUpdateFailed(error.message, version, { stage: 'platform_check' })
+    throw error
+  }
+
+  // Binaries are hosted as GitHub Release assets on the public repo.
+  // Public repo → unauthenticated downloads; GitHub 302-redirects to a CDN,
+  // and the http.js client follows redirects. OPENBUFF_DOWNLOAD_BASE may
+  // override the base (e.g. for staging mirrors).
+  const downloadUrl = `${
+    process.env.OPENBUFF_DOWNLOAD_BASE ||
+    'https://github.com/AnzoBenjamin/openbuff/releases/download'
+  }/v${version}/${fileName}`
+
+  // Ensure config directory exists
+  fs.mkdirSync(CONFIG.configDir, { recursive: true })
+
+  // 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 })
+    const error = new Error(`Download failed: HTTP ${res.statusCode}`)
+    trackUpdateFailed(error.message, version, { stage: 'http_download', statusCode: res.statusCode })
+    throw error
+  }
+
+  const totalSize = parseInt(res.headers['content-length'] || '0', 10)
+  let downloadedSize = 0
+  let lastProgressTime = Date.now()
+
+  res.on('data', (chunk) => {
+    downloadedSize += chunk.length
+    const now = Date.now()
+    if (now - lastProgressTime >= 100 || downloadedSize === totalSize) {
+      lastProgressTime = now
+      if (totalSize > 0) {
+        const pct = Math.round((downloadedSize / totalSize) * 100)
+        term.write(
+          `Downloading... ${createProgressBar(pct)} ${pct}% of ${formatBytes(
+            totalSize,
+          )}`,
+        )
+      } else {
+        term.write(`Downloading... ${formatBytes(downloadedSize)}`)
+      }
+    }
+  })
+
+  // Extract to temp directory
+  await new Promise((resolve, reject) => {
+    res
+      .pipe(zlib.createGunzip())
+      .pipe(tar.x({ cwd: CONFIG.tempDownloadDir }))
+      .on('finish', resolve)
+      .on('error', reject)
+  })
+
+  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 })
+    const error = new Error(
+      `Binary not found after extraction. Expected: ${CONFIG.binaryName}, Available files: ${files.join(', ')}`,
+    )
+    trackUpdateFailed(error.message, version, { stage: 'extraction' })
+    throw error
+  }
+
+  // Set executable permissions
+  if (process.platform !== 'win32') {
+    fs.chmodSync(tempBinaryPath, 0o755)
+  }
+
+  // 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}`,
+          )
+        }
+      }
+    }
+    fs.renameSync(tempBinaryPath, CONFIG.binaryPath)
+
+    // Move tree-sitter.wasm next to the binary if the tarball included
+    // it. The CLI binary loads this at startup; embedding it inside the
+    // binary itself was unreliable on Windows (bun --compile asset
+    // bundling silently dropped or unbound it across several attempts),
+    // so we ship it as a sibling file instead. Older artifacts that
+    // pre-date this change won't have the wasm and will still install —
+    // they'll just hit the same crash they had before, which is fine.
+    const tempWasmPath = path.join(CONFIG.tempDownloadDir, 'tree-sitter.wasm')
+    if (fs.existsSync(tempWasmPath)) {
+      const targetWasmPath = path.join(
+        path.dirname(CONFIG.binaryPath),
+        'tree-sitter.wasm',
+      )
+      try {
+        if (fs.existsSync(targetWasmPath)) fs.unlinkSync(targetWasmPath)
+      } catch {
+        // best effort; rename below will surface the real error if it matters
+      }
+      fs.renameSync(tempWasmPath, targetWasmPath)
+    }
+
+    // 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()
+  console.log('Download complete! Starting Openbuff...')
+}
+
+async function ensureBinaryExists() {
+  const currentVersion = getCurrentVersion()
+  if (currentVersion !== null) {
+    return
+  }
+
+  const version = await getLatestVersion()
+  if (!version) {
+    console.error('❌ Failed to determine latest version')
+    console.error('Please check your internet connection and try again')
+    if (!getProxyUrl()) {
+      console.error(
+        'If you are behind a proxy, set the HTTPS_PROXY environment variable',
+      )
+    }
+    process.exit(1)
+  }
+
+  try {
+    await downloadBinary(version)
+  } catch (error) {
+    term.clearLine()
+    console.error('❌ Failed to download openbuff:', error.message)
+    console.error('Please check your internet connection and try again')
+    if (!getProxyUrl()) {
+      console.error(
+        'If you are behind a proxy, set the HTTPS_PROXY environment variable',
+      )
+    }
+    process.exit(1)
+  }
+}
+
+async function checkForUpdates(runningProcess, exitListener) {
+  try {
+    const currentVersion = getCurrentVersion()
+
+    const latestVersion = await getLatestVersion()
+    if (!latestVersion) return
+
+    if (
+      // Download new version if current version is unknown or outdated.
+      currentVersion === null ||
+      compareVersions(currentVersion, latestVersion) < 0
+    ) {
+      term.clearLine()
+
+      runningProcess.removeListener('exit', exitListener)
+
+      await new Promise((resolve) => {
+        let exited = false
+        runningProcess.once('exit', () => {
+          exited = true
+          resolve()
+        })
+        runningProcess.kill('SIGTERM')
+        setTimeout(() => {
+          if (!exited) {
+            runningProcess.kill('SIGKILL')
+            // Safety: resolve after giving SIGKILL time to take effect
+            setTimeout(() => resolve(), 1000)
+          }
+        }, 5000)
+      })
+
+      resetTerminal()
+      console.log(`Update available: ${currentVersion} → ${latestVersion}`)
+
+      await downloadBinary(latestVersion)
+
+      const newChild = spawn(CONFIG.binaryPath, process.argv.slice(2), {
+        stdio: 'inherit',
+        detached: false,
+      })
+
+      newChild.on('exit', (code, signal) => {
+        resetTerminal()
+        printCrashDiagnostics(code, signal)
+        process.exit(signal ? 1 : (code || 0))
+      })
+
+      newChild.on('error', (err) => {
+        console.error('Failed to start openbuff:', err.message)
+        process.exit(1)
+      })
+
+      return new Promise(() => {})
+    }
+  } catch (error) {
+    // Ignore update failures
+  }
+}
+
+function printCrashDiagnostics(code, signal) {
+  // Windows NTSTATUS codes (unsigned DWORD)
+  const unsignedCode = code != null && code < 0 ? (code >>> 0) : code
+  const isIllegalInstruction =
+    signal === 'SIGILL' ||
+    (process.platform === 'win32' && unsignedCode === 0xC000001D)
+  const isAccessViolation =
+    signal === 'SIGSEGV' ||
+    (process.platform === 'win32' && unsignedCode === 0xC0000005)
+  const isBusError = signal === 'SIGBUS'
+  const isAbort =
+    signal === 'SIGABRT' ||
+    (process.platform === 'win32' && unsignedCode === 0xC0000409)
+
+  if (!isIllegalInstruction && !isAccessViolation && !isBusError && !isAbort) return
+
+  const exitInfo = signal ? `signal ${signal}` : `code ${code}`
+  console.error('')
+  console.error(`❌ ${binaryName} exited immediately (${exitInfo})`)
+  console.error('')
+
+  if (isIllegalInstruction) {
+    console.error('Your CPU may not support the required instruction set (AVX2).')
+    console.error('This typically affects CPUs from before 2013.')
+    console.error('Unfortunately, this binary is not compatible with your system.')
+    console.error('')
+  } else if (isAccessViolation) {
+    console.error('The binary crashed with an access violation.')
+    console.error('')
+  } else if (isBusError) {
+    console.error('The binary crashed with a bus error.')
+    console.error('This may indicate a platform compatibility issue.')
+    console.error('')
+  } else if (isAbort) {
+    console.error('The binary crashed with an abort signal.')
+    console.error('')
+  }
+
+  console.error('System info:')
+  console.error(`  Platform: ${process.platform} ${process.arch}`)
+  console.error(`  Node:     ${process.version}`)
+  console.error(`  Binary:   ${CONFIG.binaryPath}`)
+  console.error('')
+  console.error('Please report this issue at:')
+  console.error('  https://github.com/AnzoBenjamin/openbuff/issues')
+  console.error('')
+}
+
+async function main() {
+  await ensureBinaryExists()
+
+  const child = spawn(CONFIG.binaryPath, process.argv.slice(2), {
+    stdio: 'inherit',
+  })
+
+  const exitListener = (code, signal) => {
+    resetTerminal()
+    printCrashDiagnostics(code, signal)
+    process.exit(signal ? 1 : (code || 0))
+  }
+
+  child.on('exit', exitListener)
+
+  child.on('error', (err) => {
+    console.error('Failed to start openbuff:', err.message)
+    process.exit(1)
+  })
+
+  setTimeout(() => {
+    checkForUpdates(child, exitListener)
+  }, 100)
+}
+
+main().catch((error) => {
+  console.error('❌ Unexpected error:', error.message)
+  process.exit(1)
+})

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@openbuff/cli",
+  "version": "0.1.0",
+  "description": "AI coding agent",
+  "license": "MIT",
+  "bin": {
+    "openbuff": "index.js",
+    "cb": "index.js"
+  },
+  "scripts": {
+    "postinstall": "node postinstall.js",
+    "preuninstall": "node -e \"const fs = require('fs'); const path = require('path'); const os = require('os'); const configDir = path.join(os.homedir(), '.config', 'openbuff'); for (const name of (process.platform === 'win32' ? ['openbuff.exe'] : ['openbuff'])) { try { fs.unlinkSync(path.join(configDir, name)) } catch (e) { /* ignore if file doesn't exist */ } }\""
+  },
+  "files": [
+    "index.js",
+    "http.js",
+    "postinstall.js",
+    "README.md"
+  ],
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "arm64"
+  ],
+  "engines": {
+    "node": ">=16"
+  },
+  "dependencies": {
+    "tar": "^7.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/AnzoBenjamin/openbuff.git"
+  },
+  "homepage": "https://github.com/AnzoBenjamin/openbuff",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/postinstall.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+// Clean up managed binaries so the wrapper downloads a fresh copy.
+const configDir = path.join(os.homedir(), '.config', 'openbuff');
+const binaryNames = process.platform === 'win32'
+  ? ['openbuff.exe']
+  : ['openbuff'];
+
+for (const binaryName of binaryNames) {
+  try {
+    fs.unlinkSync(path.join(configDir, binaryName));
+  } catch (e) {
+    /* ignore if file doesn't exist */
+  }
+}
+
+// Print welcome message
+console.log('\n');
+console.log('🎉 Welcome to Openbuff!');
+console.log('\n');
+console.log('To get started:');
+console.log('  1. cd to your project directory');
+console.log('  2. Run: openbuff');
+console.log('\n');
+console.log('Example:');
+console.log('  $ cd ~/my-project');
+console.log('  $ openbuff');
+console.log('\n');
+console.log('For more information, visit: https://github.com/AnzoBenjamin/openbuff');
+console.log('\n');