bvm-core 1.1.13 → 1.1.15

package/scripts/postinstall.js

@@ -2,79 +2,83 @@
 
 /**
  * BVM Post-install Script
- * This script handles persistence and environment setup after npm install -g.
+ * Standardized Installation Workflow:
+ * 1. Init & Deploy Assets
+ * 2. Detect System Bun
+ * 3. Smoke Test System Bun
+ * 4. Configure Runtime (Reuse or Download)
+ * 5. Setup Shell Environment
  */
 
 const fs = require('fs');
 const path = require('path');
 const { spawnSync } = require('child_process');
+const os = require('os');
 
+// --- Constants & Config ---
+const ASCII_LOGO = `
+\x1b[36m
+__________              
+\______   \__  _______  
+ |    |  _|  \/ /     \ 
+ |    |   \\   /  Y Y  \ 
+ |______  / \_/|__|_|  / 
+        \/           \/ 
+\x1b[0m`;
+
+const HOME = process.env.HOME || os.homedir();
+const BVM_DIR = process.env.BVM_DIR || path.join(HOME, '.bvm');
+const BVM_SRC_DIR = path.join(BVM_DIR, 'src');
+const BVM_BIN_DIR = path.join(BVM_DIR, 'bin');
+const PKG_ROOT = path.resolve(__dirname, '..');
+const DIST_DIR = path.join(PKG_ROOT, 'dist');
+const LOG_FILE = path.join(os.tmpdir(), 'bvm-install.log');
+
+// --- Helpers ---
 function log(msg) {
-    console.log(`[bvm] ${msg}`);
+    const line = `[bvm] ${msg}`;
+    process.stdout.write(line + '\n');
+    try { fs.appendFileSync(LOG_FILE, line + '\n'); } catch(e) {}
 }
 
 function error(msg) {
-    console.error(`[bvm] ERROR: ${msg}`);
+    const line = `[bvm] ERROR: ${msg}`;
+    process.stderr.write(`\x1b[31m${line}\x1b[0m\n`);
+    try { fs.appendFileSync(LOG_FILE, line + '\n'); } catch(e) {}
 }
 
-async function main() {
-    log('Running post-install setup...');
+function ensureDir(dir) {
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
 
-    const isTTY = process.stdin.isTTY || process.stdout.isTTY;
-    const isCI = process.env.CI === 'true';
-    
-    // Improved Bun detection
-    const isBun = (process.env.npm_config_user_agent && process.env.npm_config_user_agent.includes('bun/')) || 
-                  (process.versions && process.versions.bun) ||
-                  process.isBun;
-
-    log(`Environment: TTY=${!!isTTY}, CI=${isCI}, isBun=${!!isBun}`);
-    if (isBun) {
-        log('Detected Bun installation. Optimizing setup...');
-    }
+function ensureVersionPrefix(version) {
+    if (!version) return 'v0.0.0';
+    return version.startsWith('v') ? version : `v${version}`;
+}
 
-    // --- Configuration ---
-    const HOME = process.env.HOME || require('os').homedir();
-    const BVM_DIR = process.env.BVM_DIR || path.join(HOME, '.bvm');
-    const BVM_SRC_DIR = path.join(BVM_DIR, 'src');
-    const BVM_BIN_DIR = path.join(BVM_DIR, 'bin');
-    
-    const PKG_ROOT = path.resolve(__dirname, '..');
-    const DIST_DIR = path.join(PKG_ROOT, 'dist');
-    const BVM_EXEC = path.join(BVM_BIN_DIR, 'bvm');
+// --- Core Logic ---
 
-    // --- 1. Conflict Detection ---
-    let forceInstall = process.env.BVM_FORCE_INSTALL === 'true';
+function main() {
+    // Force a leading newline to break from npm's output
+    process.stdout.write('\n' + ASCII_LOGO + '\n');
+    log('Starting BVM post-install setup...');
 
-    if (fs.existsSync(BVM_EXEC)) {
-        // Check if existing installation is from npm
-        let isNpmInstall = false;
+    // 1. Conflict Detection
+    const BVM_EXEC = path.join(BVM_BIN_DIR, 'bvm');
+    if (fs.existsSync(BVM_EXEC) && !process.env.BVM_FORCE_INSTALL) {
         try {
             const content = fs.readFileSync(BVM_EXEC, 'utf-8');
-            if (content.includes('export BVM_INSTALL_SOURCE="npm"')) {
-                isNpmInstall = true;
+            if (!content.includes('BVM_INSTALL_SOURCE="npm"')) {
+                log('Native BVM installation detected. Proceeding to update assets...');
             }
         } catch (e) {}
-
-        if (isNpmInstall) {
-            log('Detected existing npm installation. Proceeding with update...');
-            forceInstall = true;
-        } else if (!forceInstall) {
-            error(`Conflict detected: ${BVM_EXEC} already exists (Native installation).`);
-            error('Please run "bvm upgrade" to update your native BVM installation.');
-            error('To force overwrite, run with BVM_FORCE_INSTALL=true');
-            process.exit(1);
-        } else {
-            log('BVM_FORCE_INSTALL set. Overwriting existing installation.');
-        }
     }
 
-    // --- 2. Prepare Directories ---
+    // 2. Deploy Assets
     log(`Deploying to ${BVM_DIR}...`);
-    fs.mkdirSync(BVM_SRC_DIR, { recursive: true });
-    fs.mkdirSync(BVM_BIN_DIR, { recursive: true });
+    ensureDir(BVM_SRC_DIR);
+    ensureDir(BVM_BIN_DIR);
 
-    // --- 3. Copy Files ---
     const filesToCopy = [
         { src: 'index.js', destDir: BVM_SRC_DIR, name: 'index.js' },
         { src: 'bvm-shim.sh', destDir: BVM_BIN_DIR, name: 'bvm-shim.sh', mode: 0o755 },
@@ -86,119 +90,210 @@ async function main() {
         const destPath = path.join(file.destDir, file.name);
 
         if (fs.existsSync(srcPath)) {
-            log(`Copying ${file.src} -> ${destPath}`);
             fs.copyFileSync(srcPath, destPath);
-            if (file.mode) {
-                fs.chmodSync(destPath, file.mode);
-            }
+            if (file.mode) fs.chmodSync(destPath, file.mode);
         } else {
             error(`Source file not found: ${srcPath}`);
         }
     }
-    
-    // --- 4. Runtime Bootstrapping (Scenario 2) ---
-    const currentRuntime = path.join(BVM_DIR, 'current');
-    
-    const wrapperContent = `#!/bin/bash
-export BVM_DIR="${BVM_DIR}"
-export BVM_INSTALL_SOURCE="npm"
-# 1. Try internal runtime
-if [ -x "\${BVM_DIR}/current/bin/bun" ]; then
-  exec "\${BVM_DIR}/current/bin/bun" "\${BVM_DIR}/src/index.js" "$@"
-# 2. Try global/system bun
-elif command -v bun >/dev/null 2>&1; then
-  exec bun "\${BVM_DIR}/src/index.js" "$@"
-else
-  echo "Error: BVM requires Bun. Please install Bun or ensure it is in your PATH."
-  exit 1
-fi
-`;
 
-    if (!fs.existsSync(currentRuntime)) {
-        log('Current runtime missing. Attempting to bootstrap...');
-        try {
-            // A. Find a Bun binary to use for bootstrapping
-            let sysBun = null;
-            let hostVer = null;
-            
-            // Check if current process is Bun
-            if (process.versions && process.versions.bun) {
-                sysBun = process.execPath;
-                hostVer = process.versions.bun;
-            } else {
-                // Try PATH
-                const whichBun = spawnSync('which', ['bun'], { encoding: 'utf-8' });
-                if (whichBun.status === 0 && whichBun.stdout) {
-                    sysBun = whichBun.stdout.trim();
-                    const verOut = spawnSync(sysBun, ['--version'], { encoding: 'utf-8' });
-                    if (verOut.status === 0) {
-                        hostVer = verOut.stdout.trim().replace(/^v/, '');
-                    }
-                }
-            }
+    // 3. Detect & Configure Runtime
+    let activeRuntimePath = null;
+    let activeVersion = null;
+
+    const systemBun = detectSystemBun();
+    let systemBunCompatible = false;
 
-            if (sysBun && fs.existsSync(sysBun)) {
-                log(`Bootstrapping using system Bun v${hostVer}...`);
-                const hostVerDir = path.join(BVM_DIR, 'versions', hostVer);
-                const hostVerBinDir = path.join(hostVerDir, 'bin');
-                
-                if (!fs.existsSync(hostVerBinDir)) {
-                    fs.mkdirSync(hostVerBinDir, { recursive: true });
-                    fs.copyFileSync(sysBun, path.join(hostVerBinDir, 'bun'));
-                    fs.chmodSync(path.join(hostVerBinDir, 'bun'), 0o755);
-                }
-
-                // Always set as fallback first
-                try { fs.unlinkSync(currentRuntime); } catch(e) {}
-                fs.symlinkSync(hostVerDir, currentRuntime, 'dir');
-
-                // B. Try to Setup Latest (Upgrading to newest)
-                log('Attempting to install latest Bun version for BVM...');
-                const installCmd = spawnSync(sysBun, [path.join(BVM_SRC_DIR, 'index.js'), 'install', 'latest'], {
-                    env: Object.assign({}, process.env, { BVM_DIR }),
-                    stdio: 'inherit'
-                });
-
-                if (installCmd.status === 0) {
-                    const useCmd = spawnSync(sysBun, [path.join(BVM_SRC_DIR, 'index.js'), 'use', 'latest', '--silent'], {
-                        env: Object.assign({}, process.env, { BVM_DIR })
-                    });
-                    
-                    if (useCmd.status === 0) {
-                        const target = fs.readlinkSync(currentRuntime);
-                        const usedVersion = path.basename(target);
-                        log(`Setup complete. Using Bun v${usedVersion} as default.`);
-                    }
-                } else {
-                    log(`Warning: Failed to install latest. Stayed with Bun v${hostVer}.`);
-                }
+    if (systemBun) {
+        log(`Found system Bun at ${systemBun.path} (v${systemBun.version})`);
+        if (runSmokeTest(systemBun.path)) {
+            log('Smoke Test passed: System Bun is compatible.');
+            systemBunCompatible = true;
+            activeVersion = ensureVersionPrefix(systemBun.version);
+            const versionDir = path.join(BVM_DIR, 'versions', activeVersion);
+            registerBunVersion(systemBun.path, versionDir);
+            activeRuntimePath = versionDir;
+        } else {
+            log('Smoke Test failed: System Bun cannot run BVM core.');
+            const versionDir = path.join(BVM_DIR, 'versions', ensureVersionPrefix(systemBun.version));
+            registerBunVersion(systemBun.path, versionDir);
+        }
+    } else {
+        log('No system Bun detected.');
+    }
+
+    if (!systemBunCompatible) {
+        log('Downloading compatible Bun runtime...');
+        try {
+            const installedVersion = downloadAndInstallRuntime(BVM_DIR);
+            if (installedVersion) {
+                activeVersion = installedVersion;
+                activeRuntimePath = path.join(BVM_DIR, 'versions', activeVersion);
             } else {
-                log('Warning: Skipping bootstrap - No system Bun found.');
+                throw new Error('Download failed');
             }
         } catch (e) {
-            log(`Warning: Bootstrap failed: \${e.message}`);
+            error(`Failed to download runtime: ${e.message}`);
         }
     }
 
-    // --- 5. Create Wrapper ---
-    fs.writeFileSync(BVM_EXEC, wrapperContent);
-    try { fs.chmodSync(BVM_EXEC, 0o755); } catch (e) {}
+    // 4. Link Runtime & Default Alias
+    if (activeRuntimePath && activeVersion) {
+        const legacyCurrentLink = path.join(BVM_DIR, 'current');
+        const privateRuntimeLink = path.join(BVM_DIR, 'runtime', 'current');
+        ensureDir(path.join(BVM_DIR, 'runtime'));
+
+        try { if (fs.existsSync(privateRuntimeLink)) fs.unlinkSync(privateRuntimeLink); } catch(e) {}
+        try { fs.symlinkSync(activeRuntimePath, privateRuntimeLink, 'dir'); } catch(e) {}
 
-    // --- 6. Trigger Setup ---
-    log('Configuring environment...');
-    const setupResult = spawnSync(BVM_EXEC, ['setup', '--silent'], {
+        try { if (fs.existsSync(legacyCurrentLink)) fs.unlinkSync(legacyCurrentLink); } catch(e) {}
+        try { fs.symlinkSync(activeRuntimePath, legacyCurrentLink, 'dir'); } catch(e) {}
+
+        const aliasDir = path.join(BVM_DIR, 'aliases');
+        ensureDir(aliasDir);
+        fs.writeFileSync(path.join(aliasDir, 'default'), activeVersion);
+        log(`Active runtime set to ${activeVersion}`);
+    }
+
+    // 5. Create BVM Wrapper
+    createBvmWrapper();
+
+    // 6. Configure Shell (bvm setup)
+    log('Configuring shell environment...');
+    spawnSync(path.join(BVM_BIN_DIR, 'bvm'), ['setup', '--silent'], {
         stdio: 'inherit',
         env: Object.assign({}, process.env, { BVM_DIR })
     });
 
-    if (setupResult.status !== 0) {
-        log('Warning: "bvm setup" failed.');
+    // 7. Final Success Message
+    printSuccessMessage(!!systemBun);
+}
+
+// --- Implementation Details ---
+
+function detectSystemBun() {
+    const which = spawnSync('which', ['bun'], { encoding: 'utf-8' });
+    if (which.status === 0 && which.stdout) {
+        const binPath = which.stdout.trim();
+        const ver = getBunVersion(binPath);
+        if (ver) return { path: binPath, version: ver };
+    }
+    return null;
+}
+
+function getBunVersion(binPath) {
+    try {
+        const proc = spawnSync(binPath, ['--version'], { encoding: 'utf-8' });
+        if (proc.status === 0) return proc.stdout.trim().replace(/^v/, '');
+    } catch (e) {}
+    return null;
+}
+
+function runSmokeTest(binPath) {
+    try {
+        const indexJs = path.join(BVM_SRC_DIR, 'index.js');
+        const proc = spawnSync(binPath, [indexJs, '--version'], { 
+            encoding: 'utf-8',
+            env: Object.assign({}, process.env, { BVM_DIR })
+        });
+        return proc.status === 0;
+    } catch (e) {
+        return false;
+    }
+}
+
+function registerBunVersion(sourceBin, targetDir) {
+    const targetBinDir = path.join(targetDir, 'bin');
+    ensureDir(targetBinDir);
+    const targetBin = path.join(targetBinDir, 'bun');
+    if (!fs.existsSync(targetBin)) {
+        fs.copyFileSync(sourceBin, targetBin);
+        fs.chmodSync(targetBin, 0o755);
+    }
+}
+
+function downloadAndInstallRuntime(bvmDir) {
+    const platform = process.platform;
+    const arch = process.arch;
+    
+    let pkgPlatform = '';
+    if (platform === 'darwin') pkgPlatform = 'darwin';
+    else if (platform === 'linux') pkgPlatform = 'linux';
+    else if (platform === 'win32') pkgPlatform = 'windows';
+    else return null;
+
+    const pkgArch = arch === 'arm64' ? 'aarch64' : 'x64';
+    const bunVer = '1.1.13'; 
+    const vBunVer = ensureVersionPrefix(bunVer);
+    const registry = 'https://registry.npmmirror.com'; 
+    const pkgName = `@oven/bun-${pkgPlatform}-${pkgArch}`;
+    const url = `${registry}/${pkgName}/-/${pkgName.split('/').pop()}-${bunVer}.tgz`;
+
+    const tempTgz = path.join(os.tmpdir(), `bun-${Date.now()}.tgz`);
+    const extractDir = path.join(os.tmpdir(), `bun-ext-${Date.now()}`);
+
+    try {
+        log(`Downloading Bun ${bunVer}...`);
+        spawnSync('curl', ['-L', '-s', '-o', tempTgz, url]);
+        ensureDir(extractDir);
+        spawnSync('tar', ['-xzf', tempTgz, '-C', extractDir]);
+        const exeName = platform === 'win32' ? 'bun.exe' : 'bun';
+        const foundBinProc = spawnSync('find', [extractDir, '-name', exeName], { encoding: 'utf-8' });
+        const binPath = foundBinProc.stdout ? foundBinProc.stdout.trim().split('\n')[0] : null;
+        if (binPath && fs.existsSync(binPath)) {
+            const versionDir = path.join(bvmDir, 'versions', vBunVer);
+            registerBunVersion(binPath, versionDir);
+            return vBunVer;
+        }
+    } catch (e) {
+        error(`Download failed: ${e.message}`);
+    } finally {
+        try { 
+            if (fs.existsSync(tempTgz)) fs.unlinkSync(tempTgz);
+            if (fs.existsSync(extractDir)) fs.rmSync(extractDir, { recursive: true });
+        } catch(e) {}
+    }
+    return null;
+}
+
+function createBvmWrapper() {
+    const wrapperContent = `#!/bin/bash
+export BVM_DIR="${BVM_DIR}"
+export BVM_INSTALL_SOURCE="npm"
+if [ -x "\${BVM_DIR}/runtime/current/bin/bun" ]; then
+  exec "\${BVM_DIR}/runtime/current/bin/bun" "\${BVM_DIR}/src/index.js" "$@"
+elif command -v bun >/dev/null 2>&1; then
+  exec bun "\${BVM_DIR}/src/index.js" "$@"
+else
+  echo "Error: BVM requires Bun. Please ensure setup completed correctly."
+  exit 1
+fi
+`;
+    const bvmExec = path.join(BVM_BIN_DIR, 'bvm');
+    fs.writeFileSync(bvmExec, wrapperContent);
+    fs.chmodSync(bvmExec, 0o755);
+}
+
+function printSuccessMessage(hasSystemBun) {
+    const shell = process.env.SHELL || '';
+    let configFile = '~/.zshrc';
+    if (shell.includes('bash')) configFile = '~/.bashrc';
+    else if (shell.includes('fish')) configFile = '~/.config/fish/config.fish';
+
+    process.stdout.write('\n\x1b[32m\x1b[1m🎉 BVM (Bun Version Manager) installed successfully!\x1b[0m\n');
+    if (hasSystemBun) {
+        process.stdout.write('\x1b[33mBVM has been added to the END of your PATH configuration to ensure priority.\x1b[0m\n');
+        process.stdout.write('\x1b[33mYour existing Bun installations were NOT deleted and will coexist.\x1b[0m\n');
     } else {
-        log('BVM installed successfully.');
+        process.stdout.write('\x1b[33mBVM has installed a compatible Bun runtime for you.\x1b[0m\n');
     }
+    process.stdout.write('\n\x1b[1mTo finalize the setup, please restart your terminal or run:\x1b[0m\n');
+    process.stdout.write(`  source ${configFile}\n\n`);
 }
 
-main().catch(err => {
-    error(err.message);
-    process.exit(1);
-});
+// Execute
+try {
+    main();
+} catch (e) {
+    error(e.message);
+}