@_xtribe/cli 2.0.5 → 2.0.7

package/install-tribe.js

@@ -10,26 +10,38 @@ const chalk = require('chalk');
 const ora = require('ora');
 const which = require('which');
 const fetch = require('node-fetch');
-const crypto = require('crypto'); // Added for checksum verification
+const crypto = require('crypto');
+
+// ASCII art for TRIBE
+const asciiArt = `
+╔══════════════════════════════════════════════════════════════════╗
+║                                                                  ║
+║  ████████╗██████╗ ██╗██████╗ ███████╗                          ║
+║  ╚══██╔══╝██╔══██╗██║██╔══██╗██╔════╝                          ║
+║     ██║   ██████╔╝██║██████╔╝█████╗                            ║
+║     ██║   ██╔══██╗██║██╔══██╗██╔══╝                            ║
+║     ██║   ██║  ██║██║██████╔╝███████╗                          ║
+║     ╚═╝   ╚═╝  ╚═╝╚═╝╚═════╝ ╚══════╝                          ║
+║                                                                  ║
+║         AI Development Teams That Make You 10x Faster           ║
+║                                                                  ║
+╚══════════════════════════════════════════════════════════════════╝`;
+
+// Track shown warnings to prevent duplicates
+const shownWarnings = new Set();
 
 const platform = os.platform();
-// Map Node.js arch to standard naming (x64 -> amd64, etc.)
 const nodeArch = os.arch();
 const arch = nodeArch === 'x64' ? 'amd64' : (nodeArch === 'arm64' || nodeArch === 'aarch64' ? 'arm64' : nodeArch);
 const homeDir = os.homedir();
 const tribeDir = path.join(homeDir, '.tribe');
 const tribeBinDir = path.join(tribeDir, 'bin');
-// Use consistent directory for all binaries
 const binDir = tribeBinDir;
 
-// No need to create ~/bin anymore since we're using ~/.tribe/bin
-
-// Ensure TRIBE config directory exists
+// Ensure directories exist
 if (!fs.existsSync(tribeDir)) {
     fs.mkdirSync(tribeDir, { recursive: true });
 }
-
-// Ensure TRIBE bin directory exists
 if (!fs.existsSync(tribeBinDir)) {
     fs.mkdirSync(tribeBinDir, { recursive: true });
 }
@@ -37,61 +49,94 @@ if (!fs.existsSync(tribeBinDir)) {
 const log = {
     success: (msg) => console.log(chalk.green('✓'), msg),
     error: (msg) => console.log(chalk.red('✗'), msg),
-    warning: (msg) => console.log(chalk.yellow('⚠'), msg),
+    warning: (msg) => {
+        // Check if we've already shown this warning
+        if (!shownWarnings.has(msg)) {
+            console.log(chalk.yellow('⚠'), msg);
+            shownWarnings.add(msg);
+        }
+    },
     info: (msg) => console.log(chalk.blue('ℹ'), msg),
     step: (msg) => console.log(chalk.cyan('→'), msg)
 };
 
+function showWelcome() {
+    console.clear();
+    console.log(chalk.cyan(asciiArt));
+    console.log(chalk.bold('\n🚀 Welcome to TRIBE\n'));
+    console.log('Transform into a 10x developer with AI-powered development teams.\n');
+    console.log('TRIBE provides you with specialized AI agents that:');
+    console.log('  • Write production-ready code');
+    console.log('  • Review and improve your work');
+    console.log('  • Handle DevOps and infrastructure');
+    console.log('  • Automate testing and quality assurance\n');
+    
+    console.log(chalk.gray(`Platform: ${platform} (${arch})`));
+    console.log(chalk.gray(`Node: ${process.version}\n`));
+}
+
+function showInstallationSummary() {
+    console.log('\n' + '═'.repeat(70));
+    console.log(chalk.green.bold('\n✨ TRIBE Installation Complete!\n'));
+    
+    console.log('📋 Installation Summary:');
+    console.log('  ✓ Runtime: ' + (platform === 'darwin' ? 'Colima' : 'Native') + ' with Kubernetes');
+    console.log('  ✓ CLI: TRIBE command available globally');
+    console.log('  ✓ Config: ~/.tribe directory initialized\n');
+    
+    console.log(chalk.bold('🎯 Your AI Development Team:'));
+    const agents = [
+        { emoji: '🎨', name: 'Pixel', role: 'Creative Design & UI/UX' },
+        { emoji: '⚡', name: 'Spark', role: 'Implementation & Performance' },
+        { emoji: '🌟', name: 'Nova', role: 'Architecture & Strategy' },
+        { emoji: '🧘', name: 'Zen', role: 'Testing & Quality' },
+        { emoji: '🔥', name: 'Blaze', role: 'DevOps & Infrastructure' },
+        { emoji: '🌌', name: 'Cosmos', role: 'Data & Analytics' },
+        { emoji: '🔊', name: 'Echo', role: 'API & Integration' },
+        { emoji: '⚛️', name: 'Quantum', role: 'Security & Cryptography' }
+    ];
+    
+    agents.forEach(agent => {
+        console.log(`  ${agent.emoji} ${chalk.cyan(agent.name)} - ${agent.role}`);
+    });
+    
+    console.log('\n' + chalk.bold('🚀 Quick Start:'));
+    console.log(chalk.cyan('  tribe login') + '    # Authenticate with TRIBE');
+    console.log(chalk.cyan('  tribe enable') + '   # Start telemetry');
+    console.log(chalk.cyan('  tribe status') + '   # Check your setup\n');
+    
+    console.log(chalk.gray('Documentation: https://tribecode.ai/docs'));
+    console.log(chalk.gray('Support: https://tribecode.ai/support'));
+    console.log('\n' + '═'.repeat(70) + '\n');
+}
+
 async function checkCommand(cmd) {
     try {
         await which(cmd);
         return true;
     } catch {
-        // If not in PATH, check our install locations
-        if (cmd === 'tribe') {
-            const tribePath = path.join(tribeBinDir, 'tribe');
-            try {
-                await fs.promises.access(tribePath, fs.constants.X_OK);
-                return true;
-            } catch {
-                return false;
-            }
-        } else if (cmd === 'kubectl') {
-            const kubectlPath = path.join(binDir, 'kubectl');
-            try {
-                await fs.promises.access(kubectlPath, fs.constants.X_OK);
-                return true;
-            } catch {
-                return false;
-            }
-        } else if (cmd === 'colima') {
-            const colimaPath = path.join(binDir, 'colima');
-            try {
-                await fs.promises.access(colimaPath, fs.constants.X_OK);
-                return true;
-            } catch {
-                return false;
-            }
+        const cmdPath = path.join(tribeBinDir, cmd);
+        try {
+            await fs.promises.access(cmdPath, fs.constants.X_OK);
+            return true;
+        } catch {
+            return false;
         }
-        return false;
     }
 }
 
 async function findCommand(cmd) {
-    // Try to find command in various locations
     const possiblePaths = [
-        path.join(binDir, cmd),                    // Our install location
-        path.join('/opt/homebrew/bin', cmd),       // Homebrew on M1 Macs
-        path.join('/usr/local/bin', cmd),          // Homebrew on Intel Macs
-        cmd                                         // In PATH
+        path.join(binDir, cmd),
+        path.join('/opt/homebrew/bin', cmd),
+        path.join('/usr/local/bin', cmd),
+        cmd
     ];
     
-    // First try 'which' command
     try {
         const cmdPath = await which(cmd);
         return cmdPath;
     } catch {
-        // If not in PATH, check known locations
         for (const cmdPath of possiblePaths) {
             try {
                 await fs.promises.access(cmdPath, fs.constants.X_OK);
@@ -110,7 +155,6 @@ async function downloadFile(url, dest) {
         const file = fs.createWriteStream(dest);
         https.get(url, (response) => {
             if (response.statusCode === 302 || response.statusCode === 301) {
-                // Handle redirects
                 return downloadFile(response.headers.location, dest).then(resolve, reject);
             }
             if (response.statusCode !== 200) {
@@ -121,31 +165,24 @@ async function downloadFile(url, dest) {
             file.on('finish', async () => {
                 file.close();
                 
-                // Check if this might be a pointer file
+                // Check for pointer files
                 const stats = fs.statSync(dest);
-                if (stats.size < 500) { // Increased size check - binaries are much larger
+                if (stats.size < 500) {
                     const content = fs.readFileSync(dest, 'utf8').trim();
-                    // Check if content looks like a path (e.g., "main-121/tribe-linux-amd64")
                     if (content.match(/^[\w\-\/]+$/) && !content.includes('<!DOCTYPE') && !content.includes('<html')) {
-                        console.log(`📎 Detected pointer file, following to: ${content}`);
                         let actualBinaryUrl;
                         
-                        // Handle different pointer formats
                         if (content.startsWith('http')) {
-                            // Direct URL
                             actualBinaryUrl = content;
                         } else if (content.includes('/')) {
-                            // Relative path - construct full URL
                             const baseUrl = url.substring(0, url.lastIndexOf('/'));
                             actualBinaryUrl = `${baseUrl}/${content}`;
                         } else {
-                            // Just a filename
                             const baseUrl = url.substring(0, url.lastIndexOf('/'));
                             actualBinaryUrl = `${baseUrl}/${content}`;
                         }
                         
-                        // Download the actual binary
-                        fs.unlinkSync(dest); // Remove pointer file
+                        fs.unlinkSync(dest);
                         await downloadFile(actualBinaryUrl, dest);
                     }
                 }
@@ -156,139 +193,41 @@ async function downloadFile(url, dest) {
     });
 }
 
-// Docker installation removed - Colima provides Docker runtime
-
-async function installK3s() {
-    const spinner = ora('Installing K3s (lightweight Kubernetes)...').start();
-    
-    try {
-        // Check if K3s is already installed
-        try {
-            execSync('which k3s', { stdio: 'ignore' });
-            spinner.succeed('K3s already installed');
-            return true;
-        } catch {
-            // Not installed, continue
-        }
-        
-        // Check if we have permission to install
-        const needsSudo = process.getuid && process.getuid() !== 0;
-        
-        // Check if we're in a container or CI environment
-        const isContainer = process.env.container === 'docker' || 
-                          fs.existsSync('/.dockerenv') || 
-                          !fs.existsSync('/run/systemd/system') ||
-                          process.env.CI === 'true';
-        
-        if (isContainer) {
-            spinner.warn('Running in container/CI - K3s installation skipped');
-            log.info('K3s requires systemd and privileged access');
-            log.info('For containers, consider using an external cluster');
-            return true; // Don't fail in containers
-        }
-        
-        // Download and install K3s
-        spinner.text = 'Downloading K3s installer...';
-        
-        const installCommand = needsSudo ? 
-            'curl -sfL https://get.k3s.io | sudo sh -s - --write-kubeconfig-mode 644' :
-            'curl -sfL https://get.k3s.io | sh -s - --write-kubeconfig-mode 644';
-        
-        try {
-            execSync(installCommand, { 
-                stdio: 'pipe',
-                env: { ...process.env, INSTALL_K3S_SKIP_START: 'false' }
-            });
-            
-            spinner.succeed('K3s installed successfully');
-            
-            // Wait for K3s to be ready
-            spinner.text = 'Waiting for K3s to start...';
-            await new Promise(resolve => setTimeout(resolve, 10000));
-            
-            // Configure kubectl to use K3s
-            const k3sConfig = '/etc/rancher/k3s/k3s.yaml';
-            const userConfig = path.join(os.homedir(), '.kube', 'config');
-            
-            if (fs.existsSync(k3sConfig)) {
-                fs.mkdirSync(path.dirname(userConfig), { recursive: true });
-                
-                if (needsSudo) {
-                    execSync(`sudo cp ${k3sConfig} ${userConfig} && sudo chown $(id -u):$(id -g) ${userConfig}`, { stdio: 'ignore' });
-                } else {
-                    fs.copyFileSync(k3sConfig, userConfig);
-                }
-                
-                // Update server address to use localhost
-                let configContent = fs.readFileSync(userConfig, 'utf8');
-                configContent = configContent.replace(/server: https:\/\/127\.0\.0\.1:6443/, 'server: https://localhost:6443');
-                fs.writeFileSync(userConfig, configContent);
-                
-                spinner.succeed('K3s configured');
-            }
-            
-            return true;
-        } catch (error) {
-            if (error.message.includes('permission denied') || error.message.includes('sudo')) {
-                spinner.fail('K3s installation requires sudo permission');
-                log.info('Please run the installer with sudo or install K3s manually:');
-                log.info('  curl -sfL https://get.k3s.io | sudo sh -');
-                return false;
-            }
-            throw error;
-        }
-        
-    } catch (error) {
-        spinner.fail('K3s installation failed');
-        log.error(error.message);
-        log.info('Manual K3s installation:');
-        log.info('  curl -sfL https://get.k3s.io | sudo sh -');
-        log.info('  sudo systemctl enable --now k3s');
-        return false;
-    }
-}
-
 async function installColima() {
     if (platform !== 'darwin') {
-        log.info('Colima is only needed on macOS - skipping');
         return true;
     }
 
     const existingColima = await findCommand('colima');
     if (existingColima) {
-        log.success(`Colima already installed at: ${existingColima}`);
+        console.log(`🐳 Colima ${chalk.gray('(already installed)')}`);
         return true;
     }
 
-    const spinner = ora('Installing Colima...').start();
+    const spinner = ora('🐳 Installing Colima...').start();
     
     try {
-        // Strategy 1: Try Homebrew if available (better signing)
+        // Try Homebrew first
         try {
             execSync('brew --version', { stdio: 'ignore' });
-            spinner.text = 'Installing Colima via Homebrew...';
             execSync('brew install colima', { stdio: 'ignore' });
-            spinner.succeed('Colima installed via Homebrew');
+            spinner.succeed('Colima installed');
             return true;
-        } catch (brewError) {
-            // Homebrew not available, continue with direct download
-            spinner.text = 'Installing Colima (direct download)...';
+        } catch {
+            // Continue with direct download
         }
         
-        // Strategy 2: Direct download with Gatekeeper approval
+        // Direct download
         const colimaUrl = `https://github.com/abiosoft/colima/releases/latest/download/colima-${platform}-${arch}`;
         const colimaDest = path.join(binDir, 'colima');
         
         await downloadFile(colimaUrl, colimaDest);
         fs.chmodSync(colimaDest, '755');
         
-        // Try to remove quarantine attribute (macOS Sequoia workaround)
         try {
             execSync(`xattr -d com.apple.quarantine ${colimaDest}`, { stdio: 'ignore' });
-            log.info('Removed quarantine attribute from Colima');
-        } catch (error) {
-            // Quarantine attribute may not exist, which is fine
-            log.info('Colima installed (quarantine handling not needed)');
+        } catch {
+            // Quarantine attribute may not exist
         }
         
         spinner.succeed('Colima installed');
@@ -299,36 +238,15 @@ async function installColima() {
     }
 }
 
-// Lima installation removed - Colima handles virtualization
-
-
 async function installKubectl() {
-    // Linux with K3s already has kubectl
-    if (platform === 'linux') {
-                    try {
-            execSync('k3s kubectl version --client', { stdio: 'ignore' });
-            log.success('kubectl available via k3s');
-            // Create a symlink for convenience
-                        try {
-                execSync('sudo ln -sf /usr/local/bin/k3s /usr/local/bin/kubectl', { stdio: 'ignore' });
-            } catch {
-                // Link might already exist
-            }
-        return true;
-        } catch {
-            // Continue with regular kubectl installation
-    }
-}
-
     if (await checkCommand('kubectl')) {
-        log.success('kubectl already installed');
+        console.log(`☸️  kubectl ${chalk.gray('(already installed)')}`);
         return true;
     }
 
-    const spinner = ora('Installing kubectl...').start();
+    const spinner = ora('☸️  Installing kubectl...').start();
     
     try {
-        // Get latest stable version
         const versionResponse = await fetch('https://dl.k8s.io/release/stable.txt');
         const version = await versionResponse.text();
         const kubectlUrl = `https://dl.k8s.io/release/${version.trim()}/bin/${platform}/${arch}/kubectl`;
@@ -345,81 +263,118 @@ async function installKubectl() {
     }
 }
 
-async function setupPathEnvironment() {
-    const spinner = ora('Setting up PATH environment...').start();
+async function installTribeCLI() {
+    const tribeDest = path.join(tribeBinDir, 'tribe');
+    
+    // Check if we need to update
+    const existingTribe = await checkCommand('tribe');
+    const isUpdate = existingTribe;
+    
+    const spinner = ora(isUpdate ? '🚀 Updating TRIBE CLI...' : '🚀 Installing TRIBE CLI...').start();
     
     try {
-        // Copy the tribe-env.sh script to ~/.tribe/
-        const envScriptSource = path.join(__dirname, 'tribe-env.sh');
-        const envScriptDest = path.join(tribeBinDir, '..', 'tribe-env.sh');
-        
-        // Create the environment script content
-        const envScriptContent = `#!/bin/bash
-# TRIBE CLI Environment Setup
-# 
-# To use this, add the following line to your shell config:
-#   source ~/.tribe/tribe-env.sh
-#
-# Or run it manually in your current session:
-#   source ~/.tribe/tribe-env.sh
-
-# Add TRIBE bin directory to PATH if not already present
-TRIBE_BIN_DIR="$HOME/.tribe/bin"
-
-if [[ -d "$TRIBE_BIN_DIR" ]] && [[ ":$PATH:" != *":$TRIBE_BIN_DIR:"* ]]; then
-    export PATH="$TRIBE_BIN_DIR:$PATH"
-fi
-
-# Optional: Add helpful aliases
-alias tribe-logs="$TRIBE_BIN_DIR/tribe-logs" 2>/dev/null || true
-
-# Verify tribe is available (silent check)
-command -v tribe &> /dev/null || true
-`;
+        // Remove existing if present
+        if (fs.existsSync(tribeDest)) {
+            fs.unlinkSync(tribeDest);
+        }
         
-        fs.writeFileSync(envScriptDest, envScriptContent);
-        fs.chmodSync(envScriptDest, '755');
+        // Check for local binary first
+        const localBinary = path.join(__dirname, 'tribe');
+        if (fs.existsSync(localBinary)) {
+            fs.copyFileSync(localBinary, tribeDest);
+            fs.chmodSync(tribeDest, '755');
+            spinner.succeed(isUpdate ? 'TRIBE CLI updated' : 'TRIBE CLI installed');
+            return true;
+        }
         
-        spinner.succeed('PATH environment script created');
+        // Download from GitHub
+        const githubRepo = process.env.TRIBE_INSTALLER_REPO || 'TRIBE-INC/releases';
+        const versionChannel = global.versionChannel || 'latest';
         
-        // Store that we created the env script
-        global.envScriptCreated = true;
+        let downloadUrl = '';
         
-        // Now automatically run setup-path to configure the shell
         try {
-            const setupPath = require('./setup-path.js');
-            setupPath();
-            global.pathSetupComplete = true;
-        } catch (error) {
-            // If setup-path fails, we'll still show manual instructions
-            log.info('Could not automatically configure PATH');
+            const response = await fetch(`https://api.github.com/repos/${githubRepo}/releases`, {
+                headers: {
+                    'User-Agent': 'TRIBE-Installer',
+                    ...(process.env.GITHUB_TOKEN ? { 'Authorization': `token ${process.env.GITHUB_TOKEN}` } : {})
+                }
+            });
+            
+            if (response.ok) {
+                const releases = await response.json();
+                if (releases && releases.length > 0) {
+                    const asset = releases[0].assets?.find(a => 
+                        a.name === `tribe-${platform}-${arch}` || 
+                        a.name === `tribe-${platform}-${arch}.exe`
+                    );
+                    if (asset) {
+                        downloadUrl = asset.browser_download_url;
+                    }
+                }
+            }
+        } catch {
+            // Fallback to direct URL
+        }
+        
+        if (!downloadUrl) {
+            downloadUrl = `https://github.com/${githubRepo}/releases/latest/download/tribe-${platform}-${arch}`;
+        }
+        
+        await downloadFile(downloadUrl, tribeDest);
+        fs.chmodSync(tribeDest, '755');
+        
+        // Remove macOS quarantine
+        if (platform === 'darwin') {
+            try {
+                execSync(`xattr -d com.apple.quarantine "${tribeDest}"`, { stdio: 'ignore' });
+            } catch {
+                // Not critical
+            }
         }
         
+        spinner.succeed(isUpdate ? 'TRIBE CLI updated' : 'TRIBE CLI installed');
         return true;
     } catch (error) {
-        spinner.fail(`Failed to create PATH environment script: ${error.message}`);
+        spinner.fail(`TRIBE CLI installation failed: ${error.message}`);
         return false;
     }
 }
 
-async function setupGlobalNpmCommand() {
-    const spinner = ora('Setting up global tribe command...').start();
+async function setupPathEnvironment() {
+    const envScriptDest = path.join(tribeDir, 'tribe-env.sh');
     
+    const envScriptContent = `#!/bin/bash
+# TRIBE CLI Environment Setup
+
+TRIBE_BIN_DIR="$HOME/.tribe/bin"
+
+if [[ -d "$TRIBE_BIN_DIR" ]] && [[ ":$PATH:" != *":$TRIBE_BIN_DIR:"* ]]; then
+    export PATH="$TRIBE_BIN_DIR:$PATH"
+fi
+
+command -v tribe &> /dev/null || true
+`;
+    
+    fs.writeFileSync(envScriptDest, envScriptContent);
+    fs.chmodSync(envScriptDest, '755');
+    
+    return true;
+}
+
+async function setupGlobalNpmCommand() {
     try {
-        // Create a temporary directory for the global package
         const tempDir = path.join(os.tmpdir(), 'tribe-global-install-' + Date.now());
         fs.mkdirSync(tempDir, { recursive: true });
         
-        // Create package.json for global command
         const packageJson = {
             name: 'tribe-cli-global',
             version: '1.0.0',
             description: 'TRIBE CLI global command',
             bin: {
-                tribe: './tribe-wrapper.js',
-                'tribe-logs': './tribe-logs-wrapper.js'
+                tribe: './tribe-wrapper.js'
             },
-            files: ['tribe-wrapper.js', 'tribe-logs-wrapper.js'],
+            files: ['tribe-wrapper.js'],
             private: true
         };
         
@@ -428,44 +383,6 @@ async function setupGlobalNpmCommand() {
             JSON.stringify(packageJson, null, 2)
         );
         
-        // Create the log viewer wrapper script
-        const logViewerScript = `#!/usr/bin/env node
-
-const { spawn } = require('child_process');
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
-
-// Path to the actual tribe-logs script
-const logsScriptPath = path.join(os.homedir(), '.tribe', 'bin', 'tribe-logs');
-
-// Check if script exists
-if (!fs.existsSync(logsScriptPath)) {
-    console.error('Error: tribe-logs script not found.');
-    console.error('Please reinstall using: npx @_xtribe/cli --force');
-    process.exit(1);
-}
-
-// Forward all arguments
-const child = spawn(logsScriptPath, process.argv.slice(2), {
-    stdio: 'inherit',
-    env: process.env
-});
-
-child.on('exit', (code) => {
-    process.exit(code || 0);
-});
-
-child.on('error', (err) => {
-    console.error('Failed to execute tribe-logs:', err.message);
-    process.exit(1);
-});`;
-
-        const logViewerPath = path.join(tempDir, 'tribe-logs-wrapper.js');
-        fs.writeFileSync(logViewerPath, logViewerScript);
-        fs.chmodSync(logViewerPath, '755');
-
-        // Create the wrapper script
         const wrapperScript = `#!/usr/bin/env node
 
 const { spawn } = require('child_process');
@@ -473,26 +390,22 @@ const fs = require('fs');
 const path = require('path');
 const os = require('os');
 
-// Path to the actual tribe binary installed by the installer
 const tribeBinaryPath = path.join(os.homedir(), '.tribe', 'bin', 'tribe');
 
-// Check if tribe binary exists
 if (!fs.existsSync(tribeBinaryPath)) {
     console.error('Error: TRIBE CLI binary not found.');
-    console.error('Please reinstall using: npx @_xtribe/cli --force');
+    console.error('Please reinstall using: npx @_xtribe/cli@latest');
     process.exit(1);
 }
 
-// Make sure binary is executable
 try {
     fs.accessSync(tribeBinaryPath, fs.constants.X_OK);
 } catch (err) {
     console.error('Error: TRIBE CLI binary is not executable.');
-    console.error('Please reinstall using: npx @_xtribe/cli --force');
+    console.error('Please reinstall using: npx @_xtribe/cli@latest');
     process.exit(1);
 }
 
-// Forward all arguments to the actual tribe binary
 const child = spawn(tribeBinaryPath, process.argv.slice(2), {
     stdio: 'inherit',
     env: process.env
@@ -505,7 +418,7 @@ child.on('exit', (code) => {
 child.on('error', (err) => {
     if (err.code === 'ENOENT') {
         console.error('Error: TRIBE CLI binary not found at expected location.');
-        console.error('Please reinstall using: npx @_xtribe/cli --force');
+        console.error('Please reinstall using: npx @_xtribe/cli@latest');
     } else {
         console.error('Failed to execute tribe:', err.message);
     }
@@ -516,1515 +429,141 @@ child.on('error', (err) => {
         fs.writeFileSync(wrapperPath, wrapperScript);
         fs.chmodSync(wrapperPath, '755');
         
-        // Install globally using npm
-        spinner.text = 'Installing tribe command globally...';
         try {
-            // First try with --force to handle conflicts
             execSync('npm install -g . --force', {
                 cwd: tempDir,
                 stdio: 'pipe'
             });
-            spinner.succeed('Global tribe command installed successfully');
         } catch (error) {
-            // Try with sudo if permission denied
             if (error.message.includes('EACCES') || error.message.includes('permission')) {
-                spinner.warn('Global installation requires sudo permission');
-                log.info('Attempting with sudo...');
                 try {
                     execSync('sudo npm install -g . --force', {
                         cwd: tempDir,
                         stdio: 'inherit'
                     });
-                    spinner.succeed('Global tribe command installed successfully (with sudo)');
-                } catch (sudoError) {
-                    throw new Error('Failed to install globally. You may need to run with sudo or fix npm permissions.');
-                }
-            } else if (error.message.includes('EEXIST')) {
-                // Try to remove existing and retry
-                spinner.text = 'Removing conflicting global command...';
-                try {
-                    execSync('npm uninstall -g tribe-cli-global @_xtribe/cli', { stdio: 'ignore' });
-                    execSync('npm install -g . --force', {
-                        cwd: tempDir,
-                        stdio: 'pipe'
-                    });
-                    spinner.succeed('Global tribe command installed successfully (after cleanup)');
-                } catch (retryError) {
-                    throw new Error('Failed to install globally due to conflicts. Try running: npm uninstall -g @_xtribe/cli');
+                } catch {
+                    // Ignore errors
                 }
-            } else {
-                throw error;
             }
         }
         
-        // Clean up temp directory
         try {
             fs.rmSync(tempDir, { recursive: true, force: true });
-        } catch (cleanupError) {
+        } catch {
             // Ignore cleanup errors
         }
         
         return true;
-    } catch (error) {
-        spinner.fail(`Failed to set up global command: ${error.message}`);
-        log.info('You can still use tribe via the direct path: ~/.tribe/bin/tribe');
+    } catch {
         return false;
     }
 }
 
-async function installTribeLogViewer() {
+async function startColimaWithKubernetes() {
+    const spinner = ora('🌟 Starting container runtime...').start();
+    
     try {
-        // Install the log viewer script
-        const logViewerSource = path.join(__dirname, 'tribe-logs.sh');
-        const logViewerDest = path.join(tribeBinDir, 'tribe-logs');
+        const colimaPath = await findCommand('colima') || path.join(binDir, 'colima');
         
-        if (fs.existsSync(logViewerSource)) {
-            fs.copyFileSync(logViewerSource, logViewerDest);
-            fs.chmodSync(logViewerDest, '755');
-            log.success('Installed tribe-logs command for viewing debug logs');
+        // Check if running
+        try {
+            const status = execSync(`${colimaPath} status 2>&1`, { encoding: 'utf8' });
+            if (status.includes('is running')) {
+                spinner.succeed('Container runtime ready');
+                return true;
+            }
+        } catch {
+            // Not running, start it
         }
+        
+        spinner.text = 'Starting Colima with Kubernetes...';
+        execSync(`${colimaPath} start --kubernetes --cpu 4 --memory 8 --disk 20`, {
+            stdio: 'pipe',
+            env: { ...process.env, PATH: `${binDir}:${process.env.PATH}` },
+            timeout: 300000
+        });
+        
+        spinner.succeed('Container runtime started');
+        return true;
     } catch (error) {
-        log.warning(`Could not install log viewer: ${error.message}`);
+        spinner.fail('Failed to start container runtime');
+        return false;
     }
 }
 
-async function installTribeCLI() {
-    const spinner = ora('Installing TRIBE CLI...').start();
+async function main() {
+    const args = process.argv.slice(2);
     
-    try {
-        const tribeDest = path.join(tribeBinDir, 'tribe');
-        
-        // Unconditionally remove existing binary to ensure a clean install
-        if (fs.existsSync(tribeDest)) {
-            spinner.text = 'Removing existing TRIBE CLI installation...';
-            fs.unlinkSync(tribeDest);
-            log.success('Removed existing TRIBE CLI');
-            spinner.text = 'Installing TRIBE CLI...'; // Reset spinner text
-        }
-        
-        // Also remove old location if exists
-        const oldTribeDest = path.join(binDir, 'tribe');
-        if (fs.existsSync(oldTribeDest)) {
-            try {
-                fs.unlinkSync(oldTribeDest);
-                log.info('Removed old tribe binary from ~/bin');
-            } catch (e) {
-                // Ignore errors
-            }
-        }
-        
-        // Check for local binary first (for development/testing)
-        const localBinary = path.join(__dirname, 'tribe');
-        if (fs.existsSync(localBinary)) {
-            spinner.text = 'Using local TRIBE binary...';
-            fs.copyFileSync(localBinary, tribeDest);
-            fs.chmodSync(tribeDest, '755');
-            spinner.succeed('Installed TRIBE CLI from local binary');
-            return;
-        }
-        
-        // Download pre-built binary from GitHub
-        // Proper architecture detection for all platforms
-        let arch;
-        if (process.arch === 'x64' || process.arch === 'x86_64') {
-            arch = 'amd64';
-        } else if (process.arch === 'arm64' || process.arch === 'aarch64') {
-            arch = 'arm64';
-        } else {
-            arch = process.arch; // fallback
-        }
-        
-        const platform = os.platform();
-        
-        // Multiple sources for reliability
-        // For testing, use a direct URL to our releases folder
-        const isTestEnv = process.env.TRIBE_TEST_BINARY_URL;
-        const testBinary = process.env.TRIBE_TEST_BINARY;
-        const githubRepo = process.env.TRIBE_INSTALLER_REPO || 'TRIBE-INC/releases';
-        
-        // If we have a test binary file, use it directly
-        if (testBinary && fs.existsSync(testBinary)) {
-            spinner.text = 'Using test binary...';
-            fs.copyFileSync(testBinary, tribeDest);
-            fs.chmodSync(tribeDest, '755');
-            spinner.succeed('✓ TRIBE CLI installed from test binary');
-            return true;
-        }
-        
-        let downloadUrl = '';
+    // Handle help
+    if (args.includes('--help') || args.includes('-h')) {
+        console.log(chalk.bold.blue('TRIBE CLI Installer\n'));
+        console.log('Usage: npx @_xtribe/cli [options]\n');
+        console.log('Options:');
+        console.log('  --help, -h           Show this help message');
+        console.log('  --skip-cluster       Skip cluster deployment');
+        console.log('  --dry-run            Show what would be installed');
+        process.exit(0);
+    }
+    
+    // Show welcome
+    showWelcome();
+    
+    // Check existing tools
+    console.log(chalk.bold('🔍 Checking existing installation...\n'));
+    
+    const existingTools = {
+        kubectl: await checkCommand('kubectl'),
+        colima: platform === 'darwin' ? await checkCommand('colima') : true,
+        tribe: await checkCommand('tribe')
+    };
+    
+    const toolsFound = Object.values(existingTools).filter(v => v).length;
+    if (toolsFound > 0) {
+        console.log(chalk.green(`📦 Found ${toolsFound} existing tool${toolsFound > 1 ? 's' : ''}:`));
+        if (existingTools.kubectl) console.log('  ✓ kubectl');
+        if (existingTools.colima && platform === 'darwin') console.log('  ✓ colima');
+        if (existingTools.tribe) console.log('  ✓ tribe');
+        console.log('');
+    }
+    
+    // Installation
+    console.log(chalk.bold('📥 Installing components...\n'));
+    
+    // Install each component
+    if (platform === 'darwin') {
+        await installColima();
+    }
+    await installKubectl();
+    await installTribeCLI();
+    
+    console.log();
+    
+    // Configuration
+    console.log(chalk.bold('🔧 Configuring environment...\n'));
+    const configSpinner = ora('Setting up PATH...').start();
+    await setupPathEnvironment();
+    await setupGlobalNpmCommand();
+    configSpinner.succeed('Environment configured');
+    
+    // Start container runtime if needed
+    if (platform === 'darwin' && !args.includes('--skip-cluster')) {
+        console.log();
+        await startColimaWithKubernetes();
+    }
+    
+    // Show summary
+    showInstallationSummary();
+    
+    process.exit(0);
+}
 
-        try {
-            const versionChannel = global.versionChannel || 'latest';
-            spinner.text = `Fetching ${versionChannel} release information from GitHub...`;
-            const response = await fetch(`https://api.github.com/repos/${githubRepo}/releases`, {
-                headers: {
-                    'User-Agent': 'TRIBE-Installer',
-                    // Add token if available in environment
-                    ...(process.env.GITHUB_TOKEN ? { 'Authorization': `token ${process.env.GITHUB_TOKEN}` } : {})
-                }
-            });
-            if (!response.ok) {
-                throw new Error(`GitHub API returned ${response.status}`);
-            }
-            const releases = await response.json();
-            if (!releases || releases.length === 0) {
-                throw new Error('No releases found');
-            }
-            
-            // Filter releases based on version channel
-            let filteredReleases = releases.filter(r => !r.draft);
-            
-            if (versionChannel === 'beta') {
-                // For beta, look for releases with 'beta' in tag name
-                filteredReleases = filteredReleases.filter(r => r.tag_name.includes('beta'));
-                spinner.text = 'Looking for beta releases...';
-            } else if (versionChannel === 'latest') {
-                // For latest, exclude beta releases
-                filteredReleases = filteredReleases.filter(r => !r.tag_name.includes('beta'));
-                spinner.text = 'Looking for stable releases...';
-            } else {
-                // For specific version, look for exact match
-                filteredReleases = filteredReleases.filter(r => r.tag_name === versionChannel);
-                spinner.text = `Looking for version ${versionChannel}...`;
-            }
-            
-            if (filteredReleases.length === 0) {
-                throw new Error(`No releases found for channel: ${versionChannel}`);
-            }
-            
-            // Find a release with the binary we need
-            let foundRelease = null;
-            const assetName = `tribe-${platform}-${arch}`;
-            
-            for (const release of filteredReleases) {
-                const asset = release.assets?.find(a => a.name === assetName || a.name === `${assetName}.exe`);
-                if (asset) {
-                    foundRelease = release;
-                    downloadUrl = asset.browser_download_url;
-                    spinner.text = `Found binary in ${versionChannel} release: ${release.tag_name}`;
-                    break;
-                }
-            }
-            
-            if (!foundRelease) {
-                // No release has the binary, try constructing URL from first filtered release
-                const firstRelease = filteredReleases[0];
-                if (firstRelease) {
-                    downloadUrl = `https://github.com/${githubRepo}/releases/download/${firstRelease.tag_name}/tribe-${platform}-${arch}`;
-                    spinner.text = `Trying ${versionChannel} release: ${firstRelease.tag_name}`;
-                } else {
-                    throw new Error(`No suitable release found for channel: ${versionChannel}`);
-                }
-            }
-        } catch (error) {
-            log.warning(`Failed to get release info: ${error.message}`);
-            // Try to get the latest release tag directly
-            try {
-                const tagResponse = await fetch(`https://api.github.com/repos/${githubRepo}/releases`, {
-                    headers: { 'User-Agent': 'TRIBE-Installer' }
-                });
-                if (tagResponse.ok) {
-                    const releases = await tagResponse.json();
-                    if (releases && releases.length > 0) {
-                        const tag = releases[0].tag_name;
-                        // Construct direct download URL
-                        downloadUrl = `https://github.com/${githubRepo}/releases/download/${tag}/tribe-${platform}-${arch}`;
-                        spinner.text = `Using direct download for release: ${tag}`;
-                    }
-                }
-            } catch (e) {
-                // Ignore and use fallback URLs
-            }
-        }
-
-        // Check if there's a local build available (use tribe-new, not cli-gui)
-        const localBuildPath = path.join(__dirname, '..', '..', '..', 'sdk', 'cmd', 'tribe-new', 'tribe');
-        const hasLocalBuild = fs.existsSync(localBuildPath);
-        
-        const sources = isTestEnv ? [isTestEnv] : [
-            downloadUrl,
-            // GitHub releases direct download (fallback if API fails)
-            `https://github.com/${githubRepo}/releases/latest/download/tribe-${platform}-${arch}`,
-            // GitHub raw content as emergency fallback
-            `https://raw.githubusercontent.com/${githubRepo}/main/releases/tribe-${platform}-${arch}`,
-            // jsdelivr CDN (mirrors GitHub)
-            `https://cdn.jsdelivr.net/gh/${githubRepo}@latest/releases/tribe-${platform}-${arch}`,
-            // Local build if available
-            ...(hasLocalBuild ? [`file://${localBuildPath}`] : [])
-        ].filter(Boolean); // Filter out empty downloadUrl if API failed
-        
-        let downloaded = false;
-        let lastError;
-        
-        for (const url of sources) {
-            try {
-                let downloadUrl = url;
-                
-                // Check if this is the GitHub API endpoint
-                if (url.includes('/api.github.com/')) {
-                    spinner.text = 'Fetching latest release information from GitHub...';
-                    
-                    // Fetch release data
-                    const response = await fetch(url);
-                    if (!response.ok) {
-                        throw new Error(`GitHub API returned ${response.status}`);
-                    }
-                    
-                    const releaseData = await response.json();
-                    
-                    // Handle both single release and array of releases
-                    const release = Array.isArray(releaseData) ? releaseData[0] : releaseData;
-                    
-                    if (!release || !release.assets) {
-                        throw new Error('No release found');
-                    }
-                    
-                    const assetName = `tribe-${platform}-${arch}`;
-                    const asset = release.assets.find(a => a.name === assetName);
-                    
-                    if (!asset) {
-                        throw new Error(`No binary found for ${platform}-${arch}`);
-                    }
-                    
-                    downloadUrl = asset.browser_download_url;
-                    spinner.text = `Found ${release.prerelease ? 'pre-release' : 'release'}: ${release.tag_name}`;
-                }
-                
-                if (downloadUrl.startsWith('file://')) {
-                    // Handle local file copy
-                    const sourcePath = downloadUrl.replace('file://', '');
-                    spinner.text = `Copying TRIBE CLI from local build...`;
-                    fs.copyFileSync(sourcePath, tribeDest);
-                } else {
-                    spinner.text = `Downloading TRIBE CLI from ${new URL(downloadUrl).hostname}...`;
-                    await downloadFile(downloadUrl, tribeDest);
-                }
-                
-                // Check if file is not empty
-                const stats = fs.statSync(tribeDest);
-                if (stats.size === 0) {
-                    throw new Error('Downloaded file is empty');
-                }
-                
-                fs.chmodSync(tribeDest, '755');
-                
-                // Remove macOS quarantine attribute
-                if (platform === 'darwin') {
-                    try {
-                        execSync(`xattr -d com.apple.quarantine "${tribeDest}" 2>/dev/null`, { stdio: 'ignore' });
-                        log.info('Removed macOS quarantine attribute');
-                    } catch {
-                        // Not critical if this fails
-                    }
-                }
-                
-                // Verify the binary works
-                try {
-                    // Try version command first
-                    execSync(`${tribeDest} version`, { stdio: 'ignore' });
-                } catch (versionError) {
-                    // If version command doesn't exist, try help to see if binary is valid
-                    try {
-                        const helpOutput = execSync(`${tribeDest} help`, { encoding: 'utf8' });
-                        if (helpOutput.includes('TRIBE') || helpOutput.includes('tribe')) {
-                            // Binary works, just doesn't have version command
-                            log.info('Binary validated (version command not available)');
-                        } else {
-                            throw new Error('Binary validation failed');
-                        }
-                    } catch (helpError) {
-                        // Binary might not be valid
-                        log.warning('Binary downloaded but validation failed - may need different architecture');
-                    }
-                }
-                
-                spinner.succeed('TRIBE CLI installed successfully');
-                
-                // Install the log viewer
-                await installTribeLogViewer();
-                
-                downloaded = true;
-                break;
-            } catch (error) {
-                lastError = error;
-                // Clean up failed download
-                if (fs.existsSync(tribeDest)) {
-                    fs.unlinkSync(tribeDest);
-                }
-                log.warning(`Failed: ${error.message}. Trying next source...`);
-            }
-        }
-            
-        if (!downloaded) {
-            throw new Error(`Failed to download TRIBE CLI. Please check your internet connection and try again.
-
-If this persists, the binaries may not be available for your platform (${platform}-${arch}).
-Please visit https://tribecode.ai/support for assistance.`);
-        }
-        
-        return true;
-    } catch (error) {
-        spinner.fail(`TRIBE CLI installation failed: ${error.message}`);
-        
-        // Show helpful support information
-        console.log('');
-        console.log(chalk.yellow('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
-        console.log(chalk.yellow('Need help? Visit:'));
-        console.log(chalk.cyan.bold('  https://tribecode.ai/support'));
-        console.log('');
-        console.log(chalk.gray('You can also:'));
-        console.log(chalk.gray('  • Check system requirements'));
-        console.log(chalk.gray('  • View troubleshooting guides'));
-        console.log(chalk.gray('  • Contact our support team'));
-        console.log(chalk.yellow('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
-        console.log('');
-        
-        return false;
-    }
-}
-
-async function startContainerRuntime() {
-    const spinner = ora('Starting container runtime...').start();
-
-    try {
-        // Platform-specific container runtime handling
-        if (platform === 'darwin') {
-            // macOS - Check if Colima is running
-            try {
-                const colimaStatus = execSync('colima status 2>&1', { encoding: 'utf8' });
-                if (colimaStatus.includes('is running')) {
-                    spinner.succeed('Colima is already running');
-                    return true;
-                }
-            } catch {
-                // Colima not running, need to start it
-            }
-            
-            // Start Colima automatically
-            if (await checkCommand('colima')) {
-                spinner.text = 'Starting Colima with Kubernetes (this may take a few minutes on first run)...';
-                
-                // Start Colima in the background
-                const { spawn } = require('child_process');
-                const colimaProcess = spawn('colima', ['start', '--kubernetes'], {
-                    stdio: ['ignore', 'pipe', 'pipe'],
-                    detached: false
-                });
-                
-                let output = '';
-                let errorOutput = '';
-                let startupComplete = false;
-                
-                // Monitor output
-                colimaProcess.stdout.on('data', (data) => {
-                    output += data.toString();
-                    // Update spinner with progress
-                    const lines = data.toString().split('\n').filter(line => line.trim());
-                    for (const line of lines) {
-                        if (line.includes('starting ...')) {
-                            const contextMatch = line.match(/context=(\w+)/);
-                            if (contextMatch) {
-                                spinner.text = `Starting Colima: ${contextMatch[1]}...`;
-                            }
-                        } else if (line.includes('provisioning ...')) {
-                            const contextMatch = line.match(/context=(\w+)/);
-                            if (contextMatch) {
-                                spinner.text = `Provisioning ${contextMatch[1]}...`;
-                            }
-                        } else if (line.includes('done')) {
-                            startupComplete = true;
-                        }
-                    }
-                });
-                
-                colimaProcess.stderr.on('data', (data) => {
-                    errorOutput += data.toString();
-                    // Colima outputs progress to stderr, not stdout
-                    const lines = data.toString().split('\n').filter(line => line.trim());
-                    for (const line of lines) {
-                        if (line.includes('starting ...')) {
-                            const contextMatch = line.match(/context=(\w+)/);
-                            if (contextMatch) {
-                                spinner.text = `Starting Colima: ${contextMatch[1]}...`;
-                            }
-                        } else if (line.includes('provisioning ...')) {
-                            const contextMatch = line.match(/context=(\w+)/);
-                            if (contextMatch) {
-                                spinner.text = `Provisioning ${contextMatch[1]}...`;
-                            }
-                        } else if (line.includes('done')) {
-                            startupComplete = true;
-                        }
-                    }
-                });
-                
-                // Wait for process to complete
-                const exitCode = await new Promise((resolve) => {
-                    colimaProcess.on('exit', (code) => {
-                        resolve(code);
-                    });
-                });
-                
-                if (exitCode === 0 && startupComplete) {
-                    // Verify Colima is actually running
-                    try {
-                        execSync('colima status', { stdio: 'ignore' });
-                        spinner.succeed('Colima started with Kubernetes');
-                        
-                        // Give k3s a moment to initialize
-                        spinner.text = 'Waiting for Kubernetes to initialize...';
-                        await new Promise(resolve => setTimeout(resolve, 5000));
-                        
-                        return true;
-                    } catch {
-                        spinner.fail('Colima started but is not responding');
-                        return false;
-                    }
-                } else {
-                    spinner.fail('Failed to start Colima');
-                    // Only show actual error messages, not progress
-                    const actualErrors = errorOutput.split('\n')
-                        .filter(line => line.trim() && 
-                               !line.includes('level=info') && 
-                               !line.includes('starting ...') && 
-                               !line.includes('provisioning ...') &&
-                               !line.includes('done'))
-                        .join('\n');
-                    
-                    if (actualErrors.trim()) {
-                        console.log(chalk.red('Error output:'));
-                        console.log(actualErrors);
-                    }
-                    console.log('');
-                    console.log(chalk.yellow('  Please start Colima manually:'));
-                    console.log(chalk.cyan('    colima start --kubernetes'));
-                    console.log('');
-                    return false;
-                }
-            } else {
-                spinner.warn('Colima not found');
-                return false;
-            }
-        } else if (platform === 'linux') {
-            // Linux - Check K3s status but don't try to start it
-            spinner.text = 'Checking K3s status...';
-            
-            // Check if we're in a container (no systemd)
-            const isContainer = process.env.container === 'docker' || fs.existsSync('/.dockerenv') || !fs.existsSync('/run/systemd/system');
-            
-            if (isContainer) {
-                spinner.info('Running in container - K3s requires systemd');
-                log.info('For containers, connect to an external cluster');
-                return true; // Don't fail
-            }
-            
-            try {
-                execSync('sudo systemctl is-active --quiet k3s', { stdio: 'ignore', timeout: 5000 });
-                spinner.succeed('K3s is running');
-                return true;
-            } catch {
-                // Don't try to start K3s - just inform the user
-                spinner.info('K3s is not running');
-                console.log('');
-                console.log(chalk.yellow('  ⚠️  K3s needs to be started'));
-                console.log(chalk.gray('  To start K3s:'));
-                console.log(chalk.cyan('    sudo systemctl start k3s'));
-                console.log('');
-                return true; // Don't fail
-            }
-        } else if (platform === 'win32') {
-            spinner.fail('Windows support coming soon!');
-            log.info('For Windows, please use WSL2 with Ubuntu and run this installer inside WSL2');
-            return false;
-        } else {
-            spinner.fail(`Unsupported platform: ${platform}`);
-    return false;
-        }
-    } catch (error) {
-        spinner.fail(`Container runtime error: ${error.message}`);
-        return false;
-    }
-}
-
-// PATH updates no longer needed - using npm global installation
-// async function updatePath() { ... }
-
-// Shell config updates no longer needed - using npm global installation
-// async function updateShellConfig() { ... }
-
-async function verifyInstallation() {
-    const spinner = ora('Verifying installation...').start();
-    
-    const tools = ['kubectl', 'tribe', 'colima'];
-    const results = {};
-    
-    for (const tool of tools) {
-        results[tool] = await checkCommand(tool);
-    }
-    
-    // Store results globally for later use
-    global.installationChecks = results;
-    
-    // Special check for container runtime
-    let containerWorking = false;
-    if (platform === 'darwin') {
-        try {
-            const colimaStatus = execSync('colima status 2>&1', { encoding: 'utf8' });
-            containerWorking = colimaStatus.includes('is running');
-        } catch {
-            containerWorking = false;
-        }
-    } else if (platform === 'linux') {
-        try {
-            // Check if k3s is running
-            execSync('systemctl is-active k3s', { stdio: 'ignore' });
-            containerWorking = true;
-        } catch {
-            // Fallback to kubectl
-            try {
-                execSync('kubectl cluster-info', { stdio: 'ignore' });
-                containerWorking = true;
-            } catch {
-                containerWorking = false;
-            }
-        }
-    }
-    
-    spinner.stop();
-    
-    console.log('\n' + chalk.bold('Installation Summary:'));
-    for (const tool of tools) {
-        const status = results[tool] ? chalk.green('✓') : chalk.red('✗');
-        let message = `${status} ${tool}`;
-        
-        // Add additional info for tribe if it's installed but not in PATH
-        if (tool === 'tribe' && results[tool]) {
-            try {
-                await which('tribe');
-                // It's in PATH, no extra message needed
-            } catch {
-                // It's installed but not in PATH
-                message += chalk.gray(' (installed at ~/.tribe/bin/tribe)');
-                if (global.envScriptCreated) {
-                    message += chalk.yellow('\n    Run: source ~/.tribe/tribe-env.sh');
-                }
-            }
-        }
-        
-        console.log(message);
-    }
-    
-    const extraStatus = containerWorking ? chalk.green('✓') : chalk.yellow('⚠');
-    console.log(`${extraStatus} Container runtime`);
-    
-    if (platform === 'darwin') {
-        const colimaInstalled = await checkCommand('colima');
-        const limaInstalled = await checkCommand('limactl');
-        console.log(`${colimaInstalled ? chalk.green('✓') : chalk.yellow('⚠')} Colima`);
-        console.log(`${limaInstalled ? chalk.green('✓') : chalk.yellow('⚠')} Lima`);
-    }
-    
-    return Object.values(results).every(r => r) && containerWorking;
-}
-
-async function checkClusterExists() {
-    try {
-        // Check if TRIBE namespace exists
-        execSync('kubectl get namespace tribe-system', { stdio: 'ignore' });
-        
-        // Also check if key TRIBE pods are running
-        const podsOutput = execSync('kubectl get pods -n tribe-system -o json', { 
-            encoding: 'utf8',
-            stdio: 'pipe'
-        });
-        
-        const pods = JSON.parse(podsOutput);
-        if (!pods.items || pods.items.length === 0) {
-            return false; // Namespace exists but no pods
-        }
-        
-        // Check if essential pods exist (gitea, postgres, taskmaster)
-        const essentialPods = ['gitea', 'postgres', 'taskmaster'];
-        const runningPods = pods.items.filter(pod => {
-            const podName = pod.metadata.name;
-            return essentialPods.some(essential => podName.includes(essential));
-        });
-        
-        return runningPods.length >= essentialPods.length;
-    } catch {
-        return false;
-    }
-}
-
-async function checkColimaRunning() {
-    try {
-        const colimaPath = await findCommand('colima') || path.join(binDir, 'colima');
-        execSync(`${colimaPath} status`, { stdio: 'ignore' });
-        return true;
-    } catch {
-        return false;
-    }
-}
-
-async function checkColimaHasKubernetes() {
-    try {
-        const colimaPath = await findCommand('colima') || path.join(binDir, 'colima');
-        const status = execSync(`${colimaPath} status`, { encoding: 'utf8' });
-        // Check if kubernetes is mentioned in the status
-        return status.toLowerCase().includes('kubernetes');
-    } catch {
-        return false;
-    }
-}
-
-async function startColimaWithKubernetes() {
-    const spinner = ora('Starting Colima with Kubernetes...').start();
-    
-    try {
-        // Check if already running
-        if (await checkColimaRunning()) {
-            // Check if it has Kubernetes enabled
-            if (await checkColimaHasKubernetes()) {
-                spinner.succeed('Colima is already running with Kubernetes');
-                
-                // Verify kubectl works
-                try {
-                    execSync('kubectl cluster-info', { stdio: 'ignore' });
-            return true;
-                } catch {
-                    spinner.info('Colima is running but kubectl not connected, continuing...');
-                }
-            } else {
-                spinner.text = 'Colima is running without Kubernetes. Restarting with Kubernetes...';
-                
-                // Stop existing Colima
-                const colimaPath = await findCommand('colima') || path.join(binDir, 'colima');
-                try {
-                    execSync(`${colimaPath} stop`, {
-                        stdio: 'pipe',
-                        timeout: 30000
-                    });
-                    // Wait for it to fully stop
-                    await new Promise(resolve => setTimeout(resolve, 5000));
-                } catch (stopError) {
-                    log.warning('Failed to stop Colima, attempting to start anyway...');
-                }
-            }
-        }
-        
-        // Start Colima with Kubernetes enabled
-        spinner.text = 'Starting Colima (this may take a few minutes on first run)...';
-        const colimaPath = await findCommand('colima') || path.join(binDir, 'colima');
-        execSync(`${colimaPath} start --kubernetes --cpu 4 --memory 8 --disk 20`, {
-            stdio: 'pipe',
-            env: { ...process.env, PATH: `${binDir}:${process.env.PATH}` },
-            timeout: 300000 // 5 minute timeout for first start
-        });
-        
-        // Give Colima a moment to stabilize after starting
-        spinner.text = 'Waiting for Colima to stabilize...';
-        await new Promise(resolve => setTimeout(resolve, 5000));
-        
-        // Verify it's working and set context
-        const kubectlPath = await findCommand('kubectl') || 'kubectl';
-        execSync(`${kubectlPath} version --client`, { stdio: 'ignore' });
-        
-        // Set kubectl context to colima
-        try {
-            execSync(`${kubectlPath} config use-context colima`, { stdio: 'ignore' });
-        } catch {
-            // Context might not exist yet, that's OK
-        }
-        spinner.succeed('Colima started with Kubernetes');
-        return true;
-    } catch (error) {
-        spinner.fail('Failed to start Colima with Kubernetes');
-        log.error(error.message);
-        return false;
-    }
-}
-
-async function deployTribeCluster() {
-    const spinner = ora('Deploying TRIBE cluster...').start();
-    
-    try {
-        // Create a marker file to indicate first-run deployment
-        const deploymentMarker = path.join(tribeDir, '.cluster-deployed');
-        
-        // Check if we've already deployed
-        if (fs.existsSync(deploymentMarker)) {
-            // Check if cluster actually exists
-            if (await checkClusterExists()) {
-                spinner.succeed('TRIBE cluster already deployed');
-                return true;
-            }
-            // Marker exists but cluster doesn't - remove marker and redeploy
-            fs.unlinkSync(deploymentMarker);
-        }
-        
-        // Copy deployment YAML to .tribe directory
-        const sourceYaml = path.join(__dirname, 'tribe-deployment.yaml');
-        const destYaml = path.join(tribeDir, 'tribe-deployment.yaml');
-        
-        if (fs.existsSync(sourceYaml)) {
-            fs.copyFileSync(sourceYaml, destYaml);
-            log.info('Copied deployment configuration');
-        } else {
-            // Download deployment YAML if not bundled
-            spinner.text = 'Downloading deployment configuration...';
-            const yamlSources = [
-                // Direct from GitHub (primary)
-                'https://raw.githubusercontent.com/TRIBE-INC/0zen/main/sdk/cmd/cli-gui/package/tribe-deployment.yaml',
-                // jsDelivr CDN as fallback
-                'https://cdn.jsdelivr.net/gh/TRIBE-INC/0zen@main/sdk/cmd/cli-gui/package/tribe-deployment.yaml'
-            ];
-            
-            let yamlDownloaded = false;
-            for (const yamlUrl of yamlSources) {
-                try {
-                    await downloadFile(yamlUrl, destYaml);
-                    log.info('Downloaded deployment configuration');
-                    yamlDownloaded = true;
-                    break;
-                } catch (downloadError) {
-                    // Try next source
-                }
-            }
-            
-            if (!yamlDownloaded) {
-                spinner.fail('Failed to get deployment configuration');
-                throw new Error('Could not download deployment YAML from any source');
-            }
-        }
-        
-        // Run tribe start command with deployment YAML path
-        spinner.text = 'Running TRIBE cluster deployment...';
-        const tribePath = path.join(tribeBinDir, 'tribe');
-        
-        // Set environment variable for the deployment YAML location
-        const env = {
-            ...process.env,
-            PATH: `${binDir}:${process.env.PATH}`,
-            TRIBE_DEPLOYMENT_YAML: destYaml
-        };
-        
-        // Wait for Kubernetes to be fully ready
-        spinner.text = 'Waiting for Kubernetes to be ready...';
-        const kubectlPath = await findCommand('kubectl') || 'kubectl';
-        let apiReady = false;
-        let contextSet = false;
-        
-        // First, wait for the API server to be accessible
-        for (let i = 0; i < 30; i++) {
-            try {
-                // Try to get cluster info - this will work regardless of port
-                const clusterInfo = execSync(`${kubectlPath} cluster-info`, {
-                    encoding: 'utf8',
-                    env: env,
-                    stdio: 'pipe'
-                });
-                
-                // Check if we got valid cluster info
-                if (clusterInfo && clusterInfo.includes('is running at')) {
-                    apiReady = true;
-                    spinner.text = 'Kubernetes API server is ready';
-                    
-                    // Extract the actual API server URL for logging
-                    const urlMatch = clusterInfo.match(/is running at (https?:\/\/[^\s]+)/);
-                    if (urlMatch) {
-                        log.info(`Kubernetes API server: ${urlMatch[1]}`);
-                    }
-                    break;
-                }
-            } catch (error) {
-                spinner.text = `Waiting for Kubernetes API server... (${i+1}/30)`;
-                await new Promise(resolve => setTimeout(resolve, 2000));
-            }
-        }
-        
-        if (!apiReady) {
-            spinner.warn('Kubernetes API server not ready after 60 seconds');
-            log.info('Deployment may fail. You can try running "tribe start" manually later.');
-            return false;
-        }
-        
-        // Set the kubectl context to colima
-        spinner.text = 'Setting kubectl context...';
-        try {
-            execSync(`${kubectlPath} config use-context colima`, {
-                stdio: 'ignore',
-                env: env
-            });
-            contextSet = true;
-        } catch {
-            log.warning('Could not set kubectl context to colima');
-        }
-        
-        // Wait for the node to be ready
-        spinner.text = 'Waiting for Kubernetes node to be ready...';
-        let nodeReady = false;
-        for (let i = 0; i < 20; i++) {
-            try {
-                // First check if any nodes exist
-                const nodeList = execSync(`${kubectlPath} get nodes -o json`, {
-                    encoding: 'utf8',
-                    env: env,
-                    stdio: 'pipe'
-                });
-                
-                const nodes = JSON.parse(nodeList);
-                if (nodes.items && nodes.items.length > 0) {
-                    // Now check if the node is ready
-                    const nodeStatus = execSync(`${kubectlPath} get nodes -o jsonpath='{.items[0].status.conditions[?(@.type=="Ready")].status}'`, {
-                        encoding: 'utf8',
-                        env: env,
-                        stdio: 'pipe'
-                    }).trim();
-                    
-                    if (nodeStatus === 'True') {
-                        nodeReady = true;
-                        spinner.text = 'Kubernetes node is ready';
-                        break;
-                    }
-                }
-            } catch (error) {
-                // Ignore errors - node might not be registered yet or connection issues
-                if (error.message && error.message.includes('connection reset')) {
-                    spinner.text = `Waiting for Kubernetes node... (${i+1}/20) - reconnecting...`;
-                } else {
-                    spinner.text = `Waiting for Kubernetes node... (${i+1}/20)`;
-                }
-            }
-            await new Promise(resolve => setTimeout(resolve, 3000));
-        }
-        
-        if (!nodeReady) {
-            spinner.warn('Kubernetes node not ready after 60 seconds');
-            log.info('The cluster may still be initializing. Proceeding with deployment...');
-        }
-        
-        // Small delay to let everything stabilize
-        spinner.text = 'Starting TRIBE deployment...';
-        await new Promise(resolve => setTimeout(resolve, 2000));
-        
-        // Execute tribe start
-        execSync(`${tribePath} start`, {
-            stdio: 'pipe',
-            env: env
-        });
-        
-        // Create marker file
-        fs.writeFileSync(deploymentMarker, new Date().toISOString());
-        
-        spinner.succeed('TRIBE cluster deployed successfully');
-        log.info('Services are starting up. Check status with: tribe status');
-        return true;
-    } catch (error) {
-        spinner.fail('Failed to deploy TRIBE cluster');
-        log.error(error.message);
-        
-        // Check if this is a Kubernetes connectivity issue
-        if (error.message && error.message.includes('connection refused')) {
-            log.warning('\nIt appears Kubernetes is not ready or not enabled.');
-            log.info('Troubleshooting steps:');
-            log.info('1. Check Colima status: colima status');
-            log.info('2. If running without Kubernetes, restart it:');
-            log.info('   colima stop');
-            log.info('   colima start --kubernetes');
-            log.info('3. Then run: tribe start');
-        } else {
-        log.info('You can manually deploy later with: tribe start');
-        }
-        return false;
-    }
-}
-
-async function promptForPathSetup() {
-    return new Promise((resolve) => {
-        const rl = readline.createInterface({
-            input: process.stdin,
-            output: process.stdout
-        });
-        
-        console.log('');
-        rl.question(chalk.yellow('Would you like to add "tribe" to your PATH? (y/n) '), (answer) => {
-            rl.close();
-            resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
-        });
-    });
-}
-
-async function promptForClusterSetup() {
-    // Check for auto-approve in CI environments
-    if (process.env.CI === 'true' || process.env.TRIBE_AUTO_APPROVE === 'true') {
-        console.log('\n' + chalk.bold('🚀 TRIBE Cluster Setup'));
-        console.log(chalk.green('Auto-approving cluster setup (CI mode)'));
-        return true;
-    }
-    
-    // Simple prompt without external dependencies
-    return new Promise((resolve) => {
-        console.log('\n' + chalk.bold('🚀 TRIBE Cluster Setup'));
-        console.log('\nWould you like to set up the TRIBE cluster now?');
-        console.log('This will:');
-        console.log('  • Start ' + (platform === 'darwin' ? 'Colima' : 'K3s') + ' with Kubernetes');
-        console.log('  • Deploy all TRIBE services');
-        console.log('  • Set up port forwarding');
-        console.log('\n' + chalk.yellow('Note: This requires ~2GB disk space and may take a few minutes'));
-        
-        process.stdout.write('\nSet up now? [Y/n]: ');
-        
-        process.stdin.resume();
-        process.stdin.setEncoding('utf8');
-        process.stdin.once('data', (data) => {
-            process.stdin.pause();
-            const answer = data.toString().trim().toLowerCase();
-            resolve(answer === '' || answer === 'y' || answer === 'yes');
-        });
-    });
-}
-
-async function cleanupOldInstallations() {
-    // Clean up old aliases
-    const rcFiles = ['.zshrc', '.bashrc'];
-    rcFiles.forEach(file => {
-        const rcPath = path.join(homeDir, file);
-        if (fs.existsSync(rcPath)) {
-            try {
-                let content = fs.readFileSync(rcPath, 'utf8');
-                const originalContent = content;
-                
-                // Remove old tribe-cli aliases
-                content = content.replace(/^alias tribe=['"]tribe-cli['"]\s*$/gm, '# $& # Removed by TRIBE installer');
-                content = content.replace(/^alias t=['"]tribe-cli['"]\s*$/gm, '# $& # Removed by TRIBE installer');
-                
-                if (content !== originalContent) {
-                    fs.writeFileSync(rcPath, content);
-                    log.info(`Cleaned up old aliases in ${file}`);
-                }
-            } catch (error) {
-                log.warning(`Could not clean up ${file}: ${error.message}`);
-            }
-        }
-    });
-}
-
-async function forceCleanInstallation() {
-    console.log(chalk.yellow('\n🧹 Performing force clean installation...\n'));
-    
-    // Clean up Kubernetes resources first (while cluster is running)
-    try {
-        execSync('kubectl delete namespace tribe-system --ignore-not-found=true', {
-            stdio: 'ignore',
-            timeout: 30000
-        });
-        log.success('Removed TRIBE namespace from cluster');
-    } catch (error) {
-        // Cluster might not be running or namespace doesn't exist
-    }
-    
-    // Uninstall global npm package if exists
-    try {
-        execSync('npm uninstall -g tribe-cli-global', {
-            stdio: 'ignore'
-        });
-        log.success('Removed global tribe command');
-    } catch (error) {
-        // It might not be installed, which is fine
-    }
-    
-    // Clean from old ~/bin location
-    const oldBinDir = path.join(homeDir, 'bin');
-    const binariesToRemove = ['tribe', 'kubectl', 'colima'];
-    
-    for (const binary of binariesToRemove) {
-        const oldPath = path.join(oldBinDir, binary);
-        if (fs.existsSync(oldPath)) {
-            try {
-                fs.unlinkSync(oldPath);
-                log.success(`Removed existing ${binary} binary from ~/bin`);
-            } catch (error) {
-                log.warning(`Could not remove ${binary}: ${error.message}`);
-            }
-        }
-    }
-    
-    // Clean from ~/.tribe/bin
-    for (const binary of binariesToRemove) {
-        const binaryPath = path.join(tribeBinDir, binary);
-        if (fs.existsSync(binaryPath)) {
-            try {
-                fs.unlinkSync(binaryPath);
-                log.success(`Removed existing ${binary} binary from ~/.tribe/bin`);
-            } catch (error) {
-                log.warning(`Could not remove ${binary}: ${error.message}`);
-            }
-        }
-    }
-    
-    // Clean up TRIBE configuration directory
-    if (fs.existsSync(tribeDir)) {
-        try {
-            // Keep important configs but remove deployment markers
-            const deploymentMarker = path.join(tribeDir, '.cluster-deployed');
-            if (fs.existsSync(deploymentMarker)) {
-                fs.unlinkSync(deploymentMarker);
-                log.success('Removed cluster deployment marker');
-            }
-            
-            // Remove cached deployment YAML
-            const deploymentYaml = path.join(tribeDir, 'tribe-deployment.yaml');
-            if (fs.existsSync(deploymentYaml)) {
-                fs.unlinkSync(deploymentYaml);
-                log.success('Removed cached deployment configuration');
-            }
-        } catch (error) {
-            log.warning(`Could not clean TRIBE directory: ${error.message}`);
-        }
-    }
-    
-    // Clean up npm cache for @_xtribe/cli
-    try {
-        execSync('npm cache clean --force @_xtribe/cli', { 
-            stdio: 'ignore',
-            timeout: 10000 
-        });
-        log.success('Cleared npm cache for @_xtribe/cli');
-    } catch (error) {
-        // npm cache clean might fail, but that's okay
-        log.info('npm cache clean attempted (may have failed, which is okay)');
-    }
-    
-    // Remove first-install marker to allow auto-launch
-    const firstInstallMarker = path.join(tribeDir, '.first-install-complete');
-    if (fs.existsSync(firstInstallMarker)) {
-        try {
-            fs.unlinkSync(firstInstallMarker);
-            log.success('Removed first-install marker');
-        } catch (error) {
-            log.warning(`Could not remove first-install marker: ${error.message}`);
-        }
-    }
-    
-    // Platform-specific cleanup
-    if (platform === 'darwin') {
-        // Check if Colima is running and stop it
-        try {
-            const colimaPath = await findCommand('colima');
-            if (colimaPath) {
-                const status = execSync(`${colimaPath} status 2>&1`, { encoding: 'utf8' });
-                if (status.includes('is running')) {
-                    log.info('Stopping Colima...');
-                    execSync(`${colimaPath} stop`, { stdio: 'ignore', timeout: 30000 });
-                    log.success('Stopped Colima');
-                }
-            }
-        } catch (error) {
-            // Colima might not be installed or running
-        }
-    } else if (platform === 'linux') {
-        // Note about K3s - requires manual uninstall
-        try {
-            execSync('which k3s', { stdio: 'ignore' });
-            log.warning('K3s detected. To fully remove K3s, run: /usr/local/bin/k3s-uninstall.sh');
-            log.info('The installer will proceed, but K3s will remain installed');
-        } catch {
-            // K3s not installed
-        }
-    }
-    
-    console.log(chalk.green('\n✓ Clean installation preparation complete\n'));
-}
-
-async function main() {
-    console.log(chalk.bold.blue('\n🚀 TRIBE CLI Installer\n'));
-    
-    // Detect and display platform info
-    const displayArch = process.arch === 'x64' ? 'amd64' : process.arch;
-    console.log(chalk.gray(`Platform: ${platform} (${displayArch})`));
-    console.log(chalk.gray(`Node: ${process.version}`));
-    console.log('');
-    
-    // Check for unsupported platforms early
-    if (platform === 'win32') {
-        console.log(chalk.yellow('\n⚠️  Windows is not yet supported'));
-        console.log(chalk.yellow('Please use WSL2 with Ubuntu and run this installer inside WSL2'));
-        console.log(chalk.yellow('Instructions: https://docs.microsoft.com/en-us/windows/wsl/install\n'));
-        process.exit(1);
-    }
-    
-    // Edge case detection
-    // 1. Check for unsupported architectures
-    const supportedArchitectures = ['x64', 'x86_64', 'arm64', 'aarch64'];
-    if (!supportedArchitectures.includes(nodeArch)) {
-        console.log(chalk.red('\n❌ Unsupported Architecture'));
-        console.log(chalk.red(`Your system architecture (${nodeArch}) is not supported.`));
-        console.log(chalk.yellow('TRIBE only provides binaries for x64 (AMD64) and ARM64.\n'));
-        process.exit(1);
-    }
-    
-    // 2. WSL2 detection
-    if (fs.existsSync('/proc/sys/fs/binfmt_misc/WSLInterop') || process.env.WSL_DISTRO_NAME) {
-        console.log(chalk.yellow('\n⚠️  WSL2 Environment Detected'));
-        console.log(chalk.yellow('K3s may have networking limitations in WSL2.'));
-        console.log(chalk.yellow('Consider using Docker Desktop with WSL2 backend instead.\n'));
-        // Don't exit, just warn
-    }
-    
-    // 3. Proxy detection
-    const proxyUrl = process.env.HTTPS_PROXY || process.env.https_proxy || process.env.HTTP_PROXY || process.env.http_proxy;
-    if (proxyUrl) {
-        console.log(chalk.blue('ℹ️  Proxy detected: ' + proxyUrl));
-        console.log(chalk.blue('Downloads will use system proxy settings.\n'));
-    }
-    
-    // 4. Check for existing Kubernetes installations
-    const k8sTools = [];
-    const checkTools = ['minikube', 'microk8s', 'k3d', 'kubectl'];
-    for (const tool of checkTools) {
-        try {
-            execSync(`which ${tool}`, { stdio: 'ignore' });
-            k8sTools.push(tool);
-        } catch {}
-    }
-    
-    if (k8sTools.length > 0) {
-        console.log(chalk.blue('\n📦 Existing Kubernetes tools detected: ' + k8sTools.join(', ')));
-        console.log(chalk.blue('You can use --skip-cluster to skip K3s installation.\n'));
-    }
-    
-    // 5. Disk space check
-    try {
-        const stats = fs.statfsSync(homeDir);
-        const freeGB = (stats.bavail * stats.bsize) / (1024 ** 3);
-        if (freeGB < 3) {
-            console.log(chalk.yellow(`\n⚠️  Low disk space: ${freeGB.toFixed(1)}GB free`));
-            console.log(chalk.yellow('K3s installation requires at least 3GB of free space.\n'));
-        }
-    } catch {}
-    
-    // Clean up old installations
-    await cleanupOldInstallations();
-    
-    log.info(`Detected: ${platform} (${arch})`);
-    log.info(`Installing to: ${tribeBinDir}`);
-    
-    // No longer updating PATH - will use npm global install instead
-    
-    const tasks = [];
-    
-    // Platform-specific Kubernetes installation
-    if (platform === 'darwin') {
-        tasks.push({ name: 'Colima', fn: installColima });
-    } else if (platform === 'linux') {
-        tasks.push({ name: 'K3s', fn: installK3s });
-    }
-    
-    // Common tools for all platforms
-    tasks.push(
-        { name: 'kubectl', fn: installKubectl },
-        { name: 'TRIBE CLI', fn: installTribeCLI },
-        { name: 'PATH environment', fn: setupPathEnvironment }
-        // We'll try npm global as a fallback, but not as primary method
-    );
-    
-    let allSuccess = true;
-    
-    for (const task of tasks) {
-        log.step(`Installing ${task.name}...`);
-        const success = await task.fn();
-        if (!success) {
-            allSuccess = false;
-            if (task.name === 'PATH environment') {
-                global.envScriptCreated = false;
-            }
-        }
-    }
-    
-    // Verify everything first
-    const verified = await verifyInstallation();
-    
-    // If critical components failed (especially TRIBE CLI), exit with error
-    if (!allSuccess) {
-        // Check specifically if TRIBE CLI installation failed
-        const tribeBinaryExists = fs.existsSync(path.join(tribeBinDir, 'tribe'));
-        if (!tribeBinaryExists) {
-            console.error(chalk.red('\n❌ Installation failed: TRIBE CLI could not be installed'));
-            process.exit(1);
-        }
-    }
-    
-    // Try to start container runtime (after showing results)
-    const runtimeStarted = await startContainerRuntime();
-    
-    // If we successfully started the runtime, we should continue with deployment
-    if (verified || runtimeStarted) {
-        // Check if cluster already exists
-        const clusterExists = await checkClusterExists();
-        
-        if (!clusterExists && !global.skipCluster) {
-            // If we just started Colima, automatically deploy the cluster
-            // Don't prompt if we just started the runtime - deploy automatically
-            const shouldSetup = runtimeStarted ? true : await promptForClusterSetup();
-            
-            if (shouldSetup) {
-                console.log('');
-                
-                // Start Colima with Kubernetes if on macOS (skip if we just started it)
-                if (platform === 'darwin' && !runtimeStarted) {
-                    const colimaStarted = await startColimaWithKubernetes();
-                    if (!colimaStarted) {
-                        log.error('Failed to start Colima. Please run manually:');
-                        console.log('  colima start --kubernetes');
-                        console.log('  tribe start');
-                        process.exit(1);
-                    }
-                }
-                
-                // Deploy TRIBE cluster
-                const deployed = await deployTribeCluster();
-                
-                if (deployed) {
-                    console.log('\n' + chalk.bold.green('✨ TRIBE is ready!'));
-                    console.log('');
-                    
-                    // PATH was already set up automatically in setupPathEnvironment
-                    // No need to prompt again
-                    
-                    // Provide immediate access to tribe command
-                    if (global.pathSetupComplete) {
-                        log.info('PATH configuration updated automatically!');
-                        console.log('');
-                        console.log(chalk.bold('✨ TRIBE is ready to use!'));
-                        console.log('');
-                        console.log(chalk.yellow('  Current terminal:  ') + chalk.green('source ~/.tribe/tribe-env.sh'));
-                        console.log(chalk.yellow('  New terminal:      ') + chalk.green('tribe'));
-                    } else if (global.envScriptCreated) {
-                        log.info('TRIBE command is installed!');
-                        console.log('');
-                        console.log(chalk.bold('To add "tribe" to your PATH:'));
-                        console.log(chalk.green('  npx @_xtribe/cli setup-path'));
-                        console.log('');
-                        console.log(chalk.bold('Or for this session only:'));
-                        console.log(chalk.green('  source ~/.tribe/tribe-env.sh'));
-                        console.log('');
-                        console.log(chalk.bold('Or use the full path:'));
-                        console.log(chalk.green('  ~/.tribe/bin/tribe'));
-                    } else {
-                        log.info('TRIBE command is installed!');
-                        console.log(chalk.green('  ~/.tribe/bin/tribe              # Run TRIBE'));
-                        console.log(chalk.gray('  ~/.tribe/bin/tribe --help       # View available commands'));
-                        console.log(chalk.gray('  ~/.tribe/bin/tribe status       # Check cluster status'));
-                    }
-                    console.log('');
-                    
-                    log.info('Quick start:');
-                    console.log('  tribe              # Launch interactive CLI');
-                    console.log('  tribe status       # Check cluster status');
-                    console.log('  tribe create-task  # Create a new task');
-                    console.log('');
-                    log.info('First time? The CLI will guide you through creating your first project!');
-                } else {
-                    log.warning('Cluster deployment failed, but you can try manually:');
-                    console.log('  tribe start');
-                }
-            } else {
-                console.log('\n' + chalk.bold('Setup Complete!'));
-                log.info('You can set up the cluster later with:');
-                console.log('  tribe start');
-            }
-        } else {
-            console.log('\n' + chalk.bold.green('✨ TRIBE is ready!'));
-            log.success('Cluster is already running');
-            console.log('');
-            
-            // Check if PATH was automatically configured
-            if (global.pathSetupComplete) {
-                log.info('PATH configured automatically!');
-                console.log('');
-                console.log(chalk.bold('TRIBE commands are available:'));
-                console.log(chalk.yellow('  Current terminal:  ') + chalk.green('source ~/.tribe/tribe-env.sh'));
-                console.log(chalk.yellow('  New terminals:     ') + chalk.green('tribe (works automatically)'));
-            } else if (global.envScriptCreated) {
-                log.info('TRIBE command is installed!');
-                console.log('');
-                console.log(chalk.bold('To use "tribe" command from anywhere:'));
-                console.log(chalk.green('  source ~/.tribe/tribe-env.sh'));
-                console.log('');
-                console.log(chalk.bold('Or you can use the full path:'));
-                console.log(chalk.green('  ~/.tribe/bin/tribe              # Run TRIBE'));
-            } else {
-                log.info('TRIBE command is installed!');
-                console.log(chalk.green('  ~/.tribe/bin/tribe              # Run TRIBE'));
-            }
-            console.log('');
-            
-            log.info('Commands:');
-            console.log('  tribe              # Launch interactive CLI');
-            console.log('  tribe status       # Check status');
-            console.log('  tribe create-task  # Create a new task');
-        }
-    } else {
-        console.log('\n' + chalk.bold('Next Steps:'));
-        log.warning('Some components need attention:');
-        console.log('');
-        // Check container runtime for guidance
-        let runtimeWorking = false;
-        if (platform === 'darwin') {
-            try {
-                const colimaStatus = execSync('colima status 2>&1', { encoding: 'utf8' });
-                runtimeWorking = colimaStatus.includes('is running');
-            } catch {
-                runtimeWorking = false;
-            }
-            
-            if (!runtimeWorking) {
-                log.info('Start container runtime:');
-                console.log('  colima start --kubernetes    # Start Colima with Kubernetes');
-            }
-        } else if (platform === 'linux') {
-            try {
-                execSync('systemctl is-active k3s', { stdio: 'ignore' });
-                runtimeWorking = true;
-            } catch {
-                runtimeWorking = false;
-            }
-            
-            if (!runtimeWorking) {
-                log.info('Start container runtime:');
-                console.log('  sudo systemctl start k3s     # Start k3s');
-            }
-        }
-        console.log('');
-        log.info('Restart your shell or run: source ~/.zshrc');
-        log.info('Then run: tribe start');
-    }
-    
-    // Auto-launch handling (only for successful installations)
-    const checks = global.installationChecks || {};
-    if (checks.kubectl && checks.tribe) {
-        try {
-            const autoLaunch = require('./install-tribe-autolaunch.js');
-            if (autoLaunch.shouldAutoLaunch()) {
-                console.log(''); // Spacing before auto-launch
-                await autoLaunch.handleAutoLaunch();
-                // If auto-launch takes over, we won't reach here
-            }
-        } catch (error) {
-            // Silently ignore auto-launch errors to not break the installer
-            // Auto-launch is a nice-to-have feature, not critical
-        }
-    }
-    
-    // Exit cleanly
-    process.exit(0);
-}
-
-// Handle fetch polyfill for older Node versions
-if (!global.fetch) {
-    global.fetch = require('node-fetch');
-}
+// Export for use from index.js
+module.exports = { main };
 
+// Run if executed directly
 if (require.main === module) {
-    const args = process.argv.slice(2);
-    
-    // Parse version/channel flags
-    let versionChannel = 'latest'; // default to latest stable
-    const versionArg = args.find(arg => arg.startsWith('--version='));
-    const channelArg = args.find(arg => arg.startsWith('--channel='));
-    
-    if (versionArg) {
-        versionChannel = versionArg.split('=')[1];
-    } else if (channelArg) {
-        versionChannel = channelArg.split('=')[1];
-    } else if (args.includes('--beta')) {
-        versionChannel = 'beta';
-    } else if (args.includes('--latest')) {
-        versionChannel = 'latest';
-    }
-    
-    // Store globally for use in download functions
-    global.versionChannel = versionChannel;
-    
-    if (args.includes('--help') || args.includes('-h')) {
-        console.log(chalk.bold.blue('TRIBE CLI Installer\n'));
-        console.log('Usage: npx @_xtribe/cli [options]\n');
-        console.log('Options:');
-        console.log('  --help, -h           Show this help message');
-        console.log('  --verify             Only verify existing installation');
-        console.log('  --dry-run            Show what would be installed');
-        console.log('  --skip-cluster       Skip cluster deployment (for testing)');
-        console.log('  --no-start           Alias for --skip-cluster (for CI environments)');
-        console.log('  --force              Force clean installation (removes existing installations)');
-        console.log('  --latest             Install latest stable release (default)');
-        console.log('  --beta               Install latest beta release');
-        console.log('  --version=TAG        Install specific version tag');
-        console.log('  --channel=CHANNEL    Install from specific channel (latest/beta)');
-        console.log('\nVersion Examples:');
-        console.log('  npx @_xtribe/cli@latest         # Latest stable (equivalent to --latest)');
-        console.log('  npx @_xtribe/cli@beta           # Latest beta');
-        console.log('  npx @_xtribe/cli --beta         # Latest beta (flag version)');
-        console.log('  npx @_xtribe/cli --version=v1.2.3   # Specific version');
-        console.log('\nThis installer sets up the complete TRIBE development environment:');
-        
-        if (platform === 'darwin') {
-            console.log('• Colima (Container runtime with Kubernetes)');
-        } else if (platform === 'linux') {
-            console.log('• K3s (Lightweight Kubernetes, one-line install)');
-        } else if (platform === 'win32') {
-            console.log('\n⚠️  Windows support coming soon!');
-            console.log('Please use WSL2 with Ubuntu and run this installer inside WSL2');
-            process.exit(1);
-        }
-        
-        console.log('• kubectl (Kubernetes CLI)');
-        console.log('• TRIBE CLI (Multi-agent orchestration)');
-        console.log('\nAfter installation:');
-        console.log('  tribe start    # Start TRIBE cluster');
-        console.log('  tribe status   # Check cluster status');
-        process.exit(0);
-    }
-    
-    if (args.includes('--verify')) {
-        console.log(chalk.bold.blue('🔍 Verifying TRIBE Installation\n'));
-        verifyInstallation().then(success => {
-            process.exit(success ? 0 : 1);
-        });
-        return;
-    }
-    
-    if (args.includes('--dry-run')) {
-        console.log(chalk.bold.blue('🔍 TRIBE CLI Installation Preview\n'));
-        log.info(`Platform: ${platform} (${arch})`);
-        log.info(`Install directory: ${binDir}`);
-        log.info(`Version channel: ${versionChannel}`);
-        console.log('\nWould install:');
-        console.log('• Colima - Container runtime with Kubernetes (macOS only)');
-        console.log('• kubectl - Kubernetes CLI');
-        console.log('• TRIBE CLI - Multi-agent system');
-        process.exit(0);
-    }
-    
-    // Store skip-cluster flag (--no-start is an alias)
-    global.skipCluster = args.includes('--skip-cluster') || args.includes('--no-start');
-    
-    // Check for force flag
-    if (args.includes('--force')) {
-        forceCleanInstallation().then(() => {
-            main().catch(error => {
-                console.error(chalk.red('Installation failed:'), error.message);
-                process.exit(1);
-            });
-        }).catch(error => {
-            console.error(chalk.red('Force clean failed:'), error.message);
-            process.exit(1);
-        });
-    } else {
-        main().catch(error => {
-            console.error(chalk.red('Installation failed:'), error.message);
-            process.exit(1);
-        });
-    }
+    main().catch(error => {
+        console.error(chalk.red('Installation failed:'), error.message);
+        process.exit(1);
+    });
 }
-
-module.exports = { main };