vesper-code 1.0.0 → 1.0.1

package/index.js

@@ -2,484 +2,116 @@
 
 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 packageName = 'vesper-code'
-const binaryBaseName = 'vesper'
-
-function createConfig() {
-  const homeDir = os.homedir()
-  const configDir = path.join(homeDir, '.config', 'vesper-code')
-  const binaryName =
-    process.platform === 'win32' ? `${binaryBaseName}.exe` : binaryBaseName
-
-  return {
-    homeDir,
-    configDir,
-    binaryName,
-    binaryPath: path.join(configDir, binaryName),
-    metadataPath: path.join(configDir, 'vesper-metadata.json'),
-    tempDownloadDir: path.join(configDir, '.download-temp'),
-    userAgent: `${packageName}-cli`,
-    requestTimeout: 20000,
-  }
-}
-
-const CONFIG = createConfig()
-
-function getPostHogConfig() {
-  const apiKey =
-    process.env.VESPER_POSTHOG_API_KEY ||
-    process.env.NEXT_PUBLIC_POSTHOG_API_KEY
-  const host =
-    process.env.VESPER_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_vesper_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
-  }
-}
-
-const PLATFORM_TARGETS = {
-  'linux-x64': `${binaryBaseName}-linux-x64.tar.gz`,
-  'linux-arm64': `${binaryBaseName}-linux-arm64.tar.gz`,
-  'darwin-x64': `${binaryBaseName}-darwin-x64.tar.gz`,
-  'darwin-arm64': `${binaryBaseName}-darwin-arm64.tar.gz`,
-  'win32-x64': `${binaryBaseName}-win32-x64.tar.gz`,
-}
-
-const term = {
-  clearLine: () => {
-    if (process.stderr.isTTY) {
-      process.stderr.write('\r\x1b[K')
-    }
+const TARGET_PACKAGES = {
+  'darwin-arm64': {
+    packageName: 'vesper-code-darwin-arm64',
+    binaryName: 'vesper',
+  },
+  'darwin-x64': {
+    packageName: 'vesper-code-darwin-x64',
+    binaryName: 'vesper',
+  },
+  'linux-x64': {
+    packageName: 'vesper-code-linux-x64',
+    binaryName: 'vesper',
   },
-  write: (text) => {
-    term.clearLine()
-    process.stderr.write(text)
+  'linux-arm64': {
+    packageName: 'vesper-code-linux-arm64',
+    binaryName: 'vesper',
   },
-  writeLine: (text) => {
-    term.clearLine()
-    process.stderr.write(text + '\n')
+  'win32-x64': {
+    packageName: 'vesper-code-windows-x64',
+    binaryName: 'vesper.exe',
   },
 }
 
-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,
-      },
-    }
-
-    const req = https.get(reqOptions, (res) => {
-      if (res.statusCode === 302 || res.statusCode === 301) {
-        return httpGet(new URL(res.headers.location, url).href, 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.'))
-    })
-  })
+function getTarget() {
+  return `${process.platform}-${process.arch}`
 }
 
-async function getLatestVersion() {
-  try {
-    const res = await httpGet(
-      `https://registry.npmjs.org/${packageName}/latest`,
-    )
-
-    if (res.statusCode !== 200) return null
-
-    const body = await streamToString(res)
-    const packageData = JSON.parse(body)
+function getPlatformPackage() {
+  const target = getTarget()
+  const platformPackage = TARGET_PACKAGES[target]
 
-    return packageData.version || null
-  } catch (error) {
-    return null
+  if (!platformPackage) {
+    throw new Error(
+      `Unsupported platform: ${process.platform} ${process.arch}. ` +
+        'Supported targets: darwin-arm64, darwin-x64, linux-x64, linux-arm64, win32-x64.',
+    )
   }
-}
 
-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)
-  })
+  return platformPackage
 }
 
-function getCurrentVersion() {
+function resolveBinaryPath() {
+  const platformPackage = getPlatformPackage()
+
+  let packageJsonPath
   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
+    packageJsonPath = require.resolve(`${platformPackage.packageName}/package.json`)
   } 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
-  }
-
-  const downloadUrl = `${
-    process.env.NEXT_PUBLIC_VESPER_APP_URL || 'https://vesper-code-production.up.railway.app'
-  }/api/releases/download/${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
+    throw new Error(
+      `Missing platform package ${platformPackage.packageName}. ` +
+        'Reinstall Vesper with optional dependencies enabled: npm install -g vesper-code',
+    )
   }
 
-  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(', ')}`,
+  const binaryPath = path.join(path.dirname(packageJsonPath), platformPackage.binaryName)
+  if (!fs.existsSync(binaryPath)) {
+    throw new Error(
+      `Platform package ${platformPackage.packageName} is installed, ` +
+        `but ${platformPackage.binaryName} is missing.`,
     )
-    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)
-
-    // 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 })
+    try {
+      fs.chmodSync(binaryPath, 0o755)
+    } catch {
+      // Best effort. Spawn will surface a real permission error if this fails.
     }
   }
 
-  term.clearLine()
-  console.log('Download complete! Starting Vesper Code...')
+  return binaryPath
 }
 
-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')
-    process.exit(1)
-  }
-
+function main() {
+  let binaryPath
   try {
-    await downloadBinary(version)
+    binaryPath = resolveBinaryPath()
   } catch (error) {
-    term.clearLine()
-    console.error('❌ Failed to download vesper:', error.message)
-    console.error('Please check your internet connection and try again')
+    console.error('Failed to start Vesper Code.')
+    console.error(error instanceof Error ? error.message : String(error))
+    console.error('')
+    console.error('Debug info:')
+    console.error(`  platform: ${process.platform}`)
+    console.error(`  arch: ${process.arch}`)
+    console.error(`  node: ${process.version}`)
+    console.error(`  home: ${os.homedir()}`)
     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)
-      runningProcess.kill('SIGTERM')
-
-      await new Promise((resolve) => {
-        runningProcess.on('exit', resolve)
-        setTimeout(() => {
-          if (!runningProcess.killed) {
-            runningProcess.kill('SIGKILL')
-          }
-          resolve()
-        }, 5000)
-      })
-
-      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) => {
-        process.exit(code || 0)
-      })
-
-      return new Promise(() => {})
-    }
-  } catch (error) {
-    // Ignore update failures
-  }
-}
-
-async function main() {
-  await ensureBinaryExists()
-
-  const child = spawn(CONFIG.binaryPath, process.argv.slice(2), {
+  const child = spawn(binaryPath, process.argv.slice(2), {
     stdio: 'inherit',
+    env: process.env,
   })
 
-  const exitListener = (code) => {
-    process.exit(code || 0)
-  }
-
-  child.on('exit', exitListener)
+  child.on('error', (error) => {
+    console.error('Failed to start Vesper Code.')
+    console.error(error.message)
+    process.exit(1)
+  })
 
-  setTimeout(() => {
-    checkForUpdates(child, exitListener)
-  }, 100)
+  child.on('exit', (code, signal) => {
+    if (signal) {
+      process.kill(process.pid, signal)
+      return
+    }
+    process.exit(code || 0)
+  })
 }
 
-main().catch((error) => {
-  console.error('❌ Unexpected error:', error.message)
-  process.exit(1)
-})
+main()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vesper-code",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Vesper Code — AI coding agent",
   "license": "MIT",
   "bin": {
@@ -28,14 +28,18 @@
   "engines": {
     "node": ">=16"
   },
-  "dependencies": {
-    "tar": "^7.0.0"
+  "optionalDependencies": {
+    "vesper-code-darwin-arm64": "1.0.1",
+    "vesper-code-darwin-x64": "1.0.1",
+    "vesper-code-linux-arm64": "1.0.1",
+    "vesper-code-linux-x64": "1.0.1",
+    "vesper-code-windows-x64": "1.0.1"
   },
   "repository": {
     "type": "git",
     "url": "https://github.com/andreygoldman13/vesper-code.git"
   },
-  "homepage": "https://vesper-code-production.up.railway.app",
+  "homepage": "https://vespercode.com",
   "publishConfig": {
     "access": "public"
   }

package/postinstall.js

@@ -20,7 +20,7 @@ try {
 
 // Print welcome message
 console.log('\n');
-console.log('🎉 Welcome to Vesper Code!');
+console.log('Welcome to Vesper Code.');
 console.log('\n');
 console.log('To get started:');
 console.log('  1. cd to your project directory');