bunosh 0.4.1 → 0.4.6

package/src/upgrade.js

@@ -1,255 +1,335 @@
-import fs from 'fs';
-import path from 'path';
-import os from 'os';
-import { execSync } from 'child_process';
+import { exec, execSync } from 'child_process';
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { platform } from 'os';
+import { homedir } from 'os';
+import { join } from 'path';
+import { mkdir, chmod } from 'fs/promises';
+import color from 'chalk';
 
-/**
- * Detects if bunosh is running as a single executable or npm package
- */
-export function isExecutable() {
+export async function upgradeCommand(options = {}) {
+  const { force = false, check = false } = options;
+  
   try {
-    // Check if we're running from a compiled executable
-    // In Bun compiled binaries, process.execPath points to the executable
-    const execPath = process.execPath;
-    const isCompiledBinary = !execPath.includes('node_modules') && 
-                            !execPath.includes('.bun') &&
-                            (execPath.includes('bunosh') || path.basename(execPath).startsWith('bunosh'));
+    const installMethod = detectInstallMethod();
+    console.log(`Bunosh is installed via: ${color.bold(installMethod)}`);
     
-    return isCompiledBinary;
+    if (installMethod === 'bun') {
+      if (!check) {
+        await upgradeWithBun();
+      } else {
+        console.log('Will upgrade with: ' + color.bold('bun add -g bunosh'));
+      }
+    } else if (installMethod === 'npm') {
+      if (!check) {
+        await upgradeWithNpm();
+      } else {
+        console.log('Will upgrade with: ' + color.bold('npm update -g bunosh'));
+      }
+    } else if (installMethod === 'executable') {
+      await upgradeExecutable({ force, check });
+    } else {
+      console.error('Unknown installation method');
+      process.exit(1);
+    }
   } catch (error) {
-    return false;
+    console.error(`Upgrade failed: ${error.message}`);
+    process.exit(1);
   }
 }
 
-/**
- * Gets the current executable path
- */
-export function getExecutablePath() {
-  if (!isExecutable()) {
-    throw new Error('Not running as executable');
-  }
-  return process.execPath;
-}
-
-/**
- * Detects the platform and architecture for download
- */
-export function getPlatformInfo() {
-  const platform = process.platform;
-  const arch = process.arch;
-  
-  // Map to GitHub release asset names
-  switch (platform) {
-    case 'linux':
-      if (arch === 'x64' || arch === 'x86_64') {
-        return { platform: 'linux', arch: 'x64', asset: 'bunosh-linux-x64.tar.gz' };
-      }
-      break;
-    case 'darwin':
-      if (arch === 'arm64') {
-        return { platform: 'darwin', arch: 'arm64', asset: 'bunosh-darwin-arm64.tar.gz' };
-      }
-      if (arch === 'x64' || arch === 'x86_64') {
-        return { platform: 'darwin', arch: 'x64', asset: 'bunosh-darwin-x64.tar.gz' };
+function detectInstallMethod() {
+  if (process.env.BUNOSH_EXECUTABLE === 'true') {
+    return 'executable';
+  }
+  
+  const executablePath = process.argv[0];
+  
+  if (executablePath.endsWith('bunosh')) {
+    try {
+      const buffer = readFileSync(executablePath);
+      const header = buffer.subarray(0, 4).toString('hex');
+      const binarySignatures = ['7f454c46', 'feedface', 'feedfacf', '4d5a9000'];
+      
+      if (binarySignatures.includes(header)) {
+        return 'executable';
       }
-      break;
-    case 'win32':
-      if (arch === 'x64' || arch === 'x86_64') {
-        return { platform: 'windows', arch: 'x64', asset: 'bunosh-windows-x64.exe.zip' };
+      
+      const textContent = buffer.toString('utf8');
+      if (!textContent.startsWith('#!') && !textContent.includes('node_modules')) {
+        return 'executable';
       }
-      break;
+    } catch (e) {
+      return 'executable';
+    }
   }
   
-  throw new Error(`Unsupported platform: ${platform} ${arch}`);
-}
-
-/**
- * Fetches the latest release info from GitHub
- */
-export async function getLatestRelease() {
-  try {
-    const response = await fetch('https://api.github.com/repos/davertmik/bunosh/releases/latest');
-    if (!response.ok) {
-      throw new Error(`GitHub API error: ${response.status}`);
+  const invokedVia = process.argv[0];
+  
+  if (invokedVia.endsWith('node') || invokedVia.includes('node.exe')) {
+    return 'npm';
+  }
+  
+  if (invokedVia.endsWith('bun') || invokedVia.includes('bun.exe')) {
+    try {
+      const bunGlobalPath = execSync('bun pm -g bin', { encoding: 'utf8' }).trim();
+      const bunoshPath = join(bunGlobalPath, 'bunosh');
+      
+      if (existsSync(bunoshPath)) {
+        return 'bun';
+      }
+    } catch (e) {
     }
-    return await response.json();
-  } catch (error) {
-    throw new Error(`Failed to fetch release info: ${error.message}`);
   }
-}
-
-/**
- * Gets current version from package.json or executable
- */
-export function getCurrentVersion() {
+  
   try {
-    // Try to read from package.json first
-    const packagePath = path.join(process.cwd(), 'package.json');
-    if (fs.existsSync(packagePath)) {
-      const pkg = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
-      if (pkg.name === 'bunosh') {
-        return pkg.version;
-      }
+    const npmListOutput = execSync('npm list -g bunosh --depth=0 2>/dev/null || echo "not found"', { encoding: 'utf8' });
+    if (npmListOutput.includes('bunosh@') && !npmListOutput.includes('not found')) {
+      return 'npm';
     }
     
-    // For executable, version might be embedded or we can try --version
-    try {
-      const version = execSync('bunosh --version', { encoding: 'utf8', stdio: 'pipe' }).trim();
-      return version;
-    } catch (error) {
-      // Fallback to unknown
-      return 'unknown';
+    const bunListOutput = execSync('bun pm -g ls 2>/dev/null | grep bunosh || echo "not found"', { encoding: 'utf8' });
+    if (bunListOutput.includes('bunosh') && !bunListOutput.includes('not found')) {
+      return 'bun';
     }
-  } catch (error) {
-    return 'unknown';
+  } catch (e) {
   }
-}
-
-/**
- * Compares version strings (simple semantic version comparison)
- */
-export function isNewerVersion(latest, current) {
-  if (current === 'unknown') return true;
-  
-  // Remove 'v' prefix if present
-  const latestClean = latest.replace(/^v/, '');
-  const currentClean = current.replace(/^v/, '');
-  
-  const latestParts = latestClean.split('.').map(n => parseInt(n) || 0);
-  const currentParts = currentClean.split('.').map(n => parseInt(n) || 0);
-  
-  // Pad arrays to same length
-  const maxLength = Math.max(latestParts.length, currentParts.length);
-  while (latestParts.length < maxLength) latestParts.push(0);
-  while (currentParts.length < maxLength) currentParts.push(0);
   
-  // Compare each part
-  for (let i = 0; i < maxLength; i++) {
-    if (latestParts[i] > currentParts[i]) return true;
-    if (latestParts[i] < currentParts[i]) return false;
+  if (process.argv[0].endsWith('bunosh')) {
+    return 'executable';
   }
   
-  return false; // Versions are equal
+  return 'unknown';
 }
 
-/**
- * Downloads and extracts the new binary
- */
-export async function downloadAndInstall(release, platformInfo, executablePath, onProgress) {
-  const asset = release.assets.find(a => a.name === platformInfo.asset);
-  if (!asset) {
-    throw new Error(`No asset found for platform: ${platformInfo.asset}`);
-  }
-
-  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'bunosh-upgrade-'));
-  const downloadPath = path.join(tempDir, asset.name);
+async function upgradeWithBun() {
+  console.log('Upgrading with Bun...');
   
-  try {
-    // Download with progress
-    onProgress?.('Downloading latest release...');
-    const response = await fetch(asset.browser_download_url);
-    if (!response.ok) {
-      throw new Error(`Download failed: ${response.status}`);
-    }
-
-    const buffer = await response.arrayBuffer();
-    fs.writeFileSync(downloadPath, Buffer.from(buffer));
-    onProgress?.('Download complete');
+  return new Promise((resolve, reject) => {
+    exec('bun add -g bunosh', (error, stdout, stderr) => {
+      if (error) {
+        reject(new Error(`Bun upgrade failed: ${stderr || error.message}`));
+        return;
+      }
+      console.log(stdout);
+      console.log(color.green('Upgrade successful!'));
+      resolve();
+    });
+  });
+}
 
-    // Extract and replace
-    onProgress?.('Extracting and installing...');
-    
-    // Create backup of current executable
-    const backupPath = executablePath + '.backup';
-    fs.copyFileSync(executablePath, backupPath);
+async function upgradeWithNpm() {
+  console.log('Upgrading with npm...');
+  
+  return new Promise((resolve, reject) => {
+    exec('npm update -g bunosh', (error, stdout, stderr) => {
+      if (error) {
+        reject(new Error(`npm upgrade failed: ${stderr || error.message}`));
+        return;
+      }
+      console.log(stdout);
+      console.log(color.green('Upgrade successful!'));
+      resolve();
+    });
+  });
+}
 
-    if (platformInfo.platform === 'windows') {
-      // Handle ZIP extraction for Windows
-      execSync(`powershell -command "Expand-Archive -Path '${downloadPath}' -DestinationPath '${tempDir}' -Force"`);
-      const extractedExe = path.join(tempDir, 'bunosh-windows-x64.exe');
-      fs.copyFileSync(extractedExe, executablePath);
-    } else {
-      // Handle tar.gz extraction for Unix
-      const extractDir = path.join(tempDir, 'extracted');
-      fs.mkdirSync(extractDir);
-      
-      execSync(`tar -xzf "${downloadPath}" -C "${extractDir}"`);
+export async function upgradeExecutable(options = {}) {
+  const { force = false, check = false } = options;
+  
+  const currentVersion = getCurrentVersion();
+  console.log(`Current version: ${color.bold(currentVersion)}`);
+  
+  if (check) {
+    console.log('Checking for updates...');
+    try {
+      const release = await getLatestRelease();
+      const latestVersion = release.tag_name;
       
-      // Find the executable in extracted files
-      const extractedFiles = fs.readdirSync(extractDir);
-      const executableName = extractedFiles.find(f => f.startsWith('bunosh-'));
+      console.log(`Latest version: ${color.bold(latestVersion)}`);
       
-      if (!executableName) {
-        throw new Error('Could not find executable in downloaded archive');
+      if (isNewerVersion(latestVersion, currentVersion)) {
+        console.log(`${color.green('Update available!')} ${currentVersion} → ${latestVersion}`);
+        console.log('Run ' + color.bold('bunosh upgrade') + ' to update.');
+      } else {
+        console.log(`${color.green('You are on the latest version!')}`);
       }
-      
-      const extractedPath = path.join(extractDir, executableName);
-      fs.copyFileSync(extractedPath, executablePath);
-      fs.chmodSync(executablePath, 0o755);
+    } catch (error) {
+      console.error(`Failed to check for updates: ${error.message}`);
+      process.exit(1);
     }
-
-    onProgress?.('Installation complete');
-    
-    // Clean up
-    fs.rmSync(tempDir, { recursive: true, force: true });
-    fs.unlinkSync(backupPath);
-    
-    return true;
-  } catch (error) {
-    // Restore backup if something went wrong
-    const backupPath = executablePath + '.backup';
-    if (fs.existsSync(backupPath)) {
-      try {
-        fs.copyFileSync(backupPath, executablePath);
-        fs.unlinkSync(backupPath);
-      } catch (restoreError) {
-        console.error('Failed to restore backup:', restoreError.message);
+    return;
+  }
+  
+  console.log('Starting upgrade process...');
+  console.log();
+  
+  let lastMessage = '';
+  const result = await performUpgradeExecutable({
+    force,
+    onProgress: (message) => {
+      if (message !== lastMessage) {
+        console.log(`   ${message}`);
+        lastMessage = message;
       }
     }
-    
-    // Clean up temp directory
-    if (fs.existsSync(tempDir)) {
-      fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+  
+  console.log();
+  if (result.updated) {
+    console.log(`${color.green('Upgrade successful!')}`);
+    console.log(`   ${result.currentVersion} → ${color.bold(result.latestVersion)}`);
+    console.log();
+    console.log(`Run ${color.bold('bunosh --version')} to verify the new version.`);
+  } else {
+    console.log(`${color.green(result.message)}`);
+    if (!force) {
+      console.log(`   Use ${color.bold('--force')} to reinstall the current version.`);
     }
-    
-    throw error;
   }
 }
 
-/**
- * Main upgrade function
- */
-export async function upgradeExecutable(options = {}) {
-  const { force = false, onProgress } = options;
+function getCurrentVersion() {
+  try {
+    const pkgPath = new URL('../package.json', import.meta.url);
+    const pkg = JSON.parse(readFileSync(pkgPath, 'utf8'));
+    return pkg.version;
+  } catch (e) {
+    return 'unknown';
+  }
+}
+
+async function getLatestRelease() {
+  const response = await fetch('https://api.github.com/repos/davertmik/bunosh/releases/latest', {
+    headers: {
+      'User-Agent': 'bunosh'
+    }
+  });
   
-  if (!isExecutable()) {
-    throw new Error('Upgrade is only available for single executable installations. Use "npm update -g bunosh" for npm installations.');
+  if (!response.ok) {
+    throw new Error(`GitHub API error: ${response.status}`);
   }
+  
+  return await response.json();
+}
 
-  onProgress?.('Checking for updates...');
+function isNewerVersion(latest, current) {
+  const latestParts = latest.replace(/^v/, '').split('.').map(Number);
+  const currentParts = current.replace(/^v/, '').split('.').map(Number);
+  
+  for (let i = 0; i < Math.max(latestParts.length, currentParts.length); i++) {
+    const latestPart = latestParts[i] || 0;
+    const currentPart = currentParts[i] || 0;
+    
+    if (latestPart > currentPart) return true;
+    if (latestPart < currentPart) return false;
+  }
+  
+  return false;
+}
+
+async function performUpgradeExecutable(options = {}) {
+  const { force = false, onProgress = () => {} } = options;
   
-  const currentVersion = getCurrentVersion();
   const release = await getLatestRelease();
   const latestVersion = release.tag_name;
+  const currentVersion = getCurrentVersion();
   
   if (!force && !isNewerVersion(latestVersion, currentVersion)) {
     return {
       updated: false,
+      message: 'Already on latest version',
       currentVersion,
-      latestVersion,
-      message: `Already on latest version: ${currentVersion}`
+      latestVersion
     };
   }
-
-  const platformInfo = getPlatformInfo();
-  const executablePath = getExecutablePath();
   
-  await downloadAndInstall(release, platformInfo, executablePath, onProgress);
+  const platformName = getPlatformName();
+  const asset = release.assets.find(a => a.name.includes(platformName));
+  
+  if (!asset) {
+    throw new Error(`Unsupported platform: ${platformName}`);
+  }
+  
+  onProgress('Downloading update...');
+  
+  const downloadDir = join(homedir(), '.bunosh', 'updates');
+  await mkdir(downloadDir, { recursive: true });
+  
+  const downloadPath = join(downloadDir, asset.name);
+  
+  await downloadFile(asset.browser_download_url, downloadPath, onProgress);
+  
+  onProgress('Installing update...');
+  
+  const currentPath = process.argv[0];
+  const backupPath = `${currentPath}.backup`;
+  if (existsSync(currentPath)) {
+    writeFileSync(backupPath, readFileSync(currentPath));
+  }
+  
+  writeFileSync(currentPath, readFileSync(downloadPath));
+  await chmod(currentPath, '755');
   
   return {
     updated: true,
     currentVersion,
-    latestVersion,
-    message: `Successfully upgraded from ${currentVersion} to ${latestVersion}`
+    latestVersion
   };
+}
+
+function getPlatformName() {
+  const arch = platform().arch();
+  const sysPlatform = platform().toLowerCase();
+  
+  if (sysPlatform === 'darwin' && arch === 'arm64') {
+    return 'darwin-arm64';
+  }
+  
+  if (sysPlatform === 'darwin' && arch === 'x64') {
+    return 'darwin-x64';
+  }
+  
+  if (sysPlatform === 'linux' && arch === 'x64') {
+    return 'linux-x64';
+  }
+  
+  if (sysPlatform === 'win32' && arch === 'x64') {
+    return 'windows-x64.exe';
+  }
+  
+  throw new Error(`Unsupported platform: ${sysPlatform} ${arch}`);
+}
+
+async function downloadFile(url, filePath, onProgress = () => {}) {
+  const response = await fetch(url);
+  
+  if (!response.ok) {
+    throw new Error(`Download failed: ${response.status}`);
+  }
+  
+  const reader = response.body.getReader();
+  const contentLength = +response.headers.get('Content-Length');
+  let receivedLength = 0;
+  
+  const chunks = [];
+  while (true) {
+    const { done, value } = await reader.read();
+    
+    if (done) break;
+    
+    chunks.push(value);
+    receivedLength += value.length;
+    
+    const progress = Math.round((receivedLength / contentLength) * 100);
+    onProgress(`Downloading... ${progress}%`);
+  }
+  
+  const chunksAll = new Uint8Array(receivedLength);
+  let position = 0;
+  for (let chunk of chunks) {
+    chunksAll.set(chunk, position);
+    position += chunk.length;
+  }
+  
+  writeFileSync(filePath, chunksAll);
 }