@_xtribe/cli 1.0.0-beta.9 → 1.0.0

package/install-tribe.js

@@ -8,12 +8,17 @@ const { execSync, spawn } = require('child_process');
 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 platform = os.platform();
-const arch = os.arch();
+// 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 binDir = path.join(homeDir, 'bin');
 const tribeDir = path.join(homeDir, '.tribe');
+const tribeBinDir = path.join(tribeDir, 'bin');
 
 // Ensure local bin directory exists
 if (!fs.existsSync(binDir)) {
@@ -25,6 +30,11 @@ if (!fs.existsSync(tribeDir)) {
     fs.mkdirSync(tribeDir, { recursive: true });
 }
 
+// Ensure TRIBE bin directory exists
+if (!fs.existsSync(tribeBinDir)) {
+    fs.mkdirSync(tribeBinDir, { recursive: true });
+}
+
 const log = {
     success: (msg) => console.log(chalk.green('✓'), msg),
     error: (msg) => console.log(chalk.red('✗'), msg),
@@ -42,6 +52,34 @@ async function checkCommand(cmd) {
     }
 }
 
+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
+    ];
+    
+    // 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);
+                return cmdPath;
+            } catch {
+                // Continue searching
+            }
+        }
+    }
+    
+    return null;
+}
+
 async function downloadFile(url, dest) {
     return new Promise((resolve, reject) => {
         const file = fs.createWriteStream(dest);
@@ -55,59 +93,119 @@ async function downloadFile(url, dest) {
                 return;
             }
             response.pipe(file);
-            file.on('finish', () => {
+            file.on('finish', async () => {
                 file.close();
+                
+                // Check if this might be a pointer file
+                const stats = fs.statSync(dest);
+                if (stats.size < 100) {
+                    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('/')) {
+                        console.log(`📎 Following pointer to: ${content}`);
+                        const baseUrl = url.substring(0, url.lastIndexOf('/'));
+                        const actualBinaryUrl = `${baseUrl}/${content}`;
+                        
+                        // Download the actual binary
+                        fs.unlinkSync(dest); // Remove pointer file
+                        await downloadFile(actualBinaryUrl, dest);
+                    }
+                }
+                
                 resolve();
             });
         }).on('error', reject);
     });
 }
 
-async function installDocker() {
-    if (await checkCommand('docker')) {
-        // Check if Docker daemon is running
+// 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('docker info', { stdio: 'ignore' });
-            log.success('Docker is already working');
+            execSync('which k3s', { stdio: 'ignore' });
+            spinner.succeed('K3s already installed');
             return true;
         } catch {
-            log.warning('Docker CLI found but daemon not running');
+            // Not installed, continue
         }
-    }
-
-    const spinner = ora('Installing Docker CLI...').start();
-    
-    try {
-        let dockerUrl;
-        if (platform === 'darwin') {
-            // Docker uses aarch64 instead of arm64 for macOS
-            const dockerArch = arch === 'arm64' ? 'aarch64' : 'x86_64';
-            dockerUrl = `https://download.docker.com/mac/static/stable/${dockerArch}/docker-24.0.7.tgz`;
-        } else if (platform === 'linux') {
-            dockerUrl = `https://download.docker.com/linux/static/stable/${arch}/docker-24.0.7.tgz`;
-        } else {
-            throw new Error(`Unsupported platform: ${platform}`);
+        
+        // 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 KIND or external cluster');
+            return true; // Don't fail in containers
         }
-
-        const tempFile = path.join(os.tmpdir(), 'docker.tgz');
-        await downloadFile(dockerUrl, tempFile);
         
-        // Extract Docker CLI
-        execSync(`tar -xzf ${tempFile} -C ${os.tmpdir()}`);
-        const dockerBinary = path.join(os.tmpdir(), 'docker', 'docker');
-        const dockerDest = path.join(binDir, 'docker');
+        // Download and install K3s
+        spinner.text = 'Downloading K3s installer...';
         
-        fs.copyFileSync(dockerBinary, dockerDest);
-        fs.chmodSync(dockerDest, '755');
+        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';
         
-        // Cleanup
-        fs.rmSync(tempFile);
-        fs.rmSync(path.join(os.tmpdir(), 'docker'), { recursive: true });
+        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;
+        }
         
-        spinner.succeed('Docker CLI installed');
-        return true;
     } catch (error) {
-        spinner.fail(`Docker CLI installation failed: ${error.message}`);
+        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;
     }
 }
@@ -118,8 +216,9 @@ async function installColima() {
         return true;
     }
 
-    if (await checkCommand('colima')) {
-        log.success('Colima already installed');
+    const existingColima = await findCommand('colima');
+    if (existingColima) {
+        log.success(`Colima already installed at: ${existingColima}`);
         return true;
     }
 
@@ -162,212 +261,28 @@ async function installColima() {
     }
 }
 
-async function installLima() {
-    if (platform !== 'darwin') {
-        return true; // Lima only needed on macOS
-    }
+// Lima installation removed - Colima handles virtualization
 
-    if (await checkCommand('limactl')) {
-        log.success('Lima already installed');
-        return true;
-    }
+// KIND installation removed - using Colima's built-in Kubernetes
 
-    const spinner = ora('Installing Lima...').start();
-    
-    try {
-        // Strategy 1: Try Homebrew if available (better signing)
-        try {
-            execSync('brew --version', { stdio: 'ignore' });
-            spinner.text = 'Installing Lima via Homebrew...';
-            execSync('brew install lima', { stdio: 'ignore' });
-            spinner.succeed('Lima installed via Homebrew');
-            return true;
-        } catch (brewError) {
-            // Homebrew not available, continue with direct download
-            spinner.text = 'Installing Lima (direct download)...';
-        }
-        
-        // Strategy 2: Direct download
-        // Get latest Lima release
-        const response = await fetch('https://api.github.com/repos/lima-vm/lima/releases/latest');
-        const release = await response.json();
-        const version = release.tag_name;
-        
-        const archName = arch === 'arm64' ? 'arm64' : 'x86_64';
-        const limaUrl = `https://github.com/lima-vm/lima/releases/download/${version}/lima-${version.replace('v', '')}-Darwin-${archName}.tar.gz`;
-        
-        const tempFile = path.join(os.tmpdir(), 'lima.tar.gz');
-        await downloadFile(limaUrl, tempFile);
-        
-        // Extract Lima
-        const extractDir = path.join(os.tmpdir(), 'lima-extract');
-        fs.mkdirSync(extractDir, { recursive: true });
-        execSync(`tar -xzf ${tempFile} -C ${extractDir}`);
-        
-        // Lima tarball extracts directly to bin/ directory
-        const limaBinDir = path.join(extractDir, 'bin');
-        if (fs.existsSync(limaBinDir)) {
-            // Copy all Lima binaries
-            const binaries = fs.readdirSync(limaBinDir);
-            binaries.forEach(binary => {
-                const src = path.join(limaBinDir, binary);
-                const dest = path.join(binDir, binary);
-                fs.copyFileSync(src, dest);
-                fs.chmodSync(dest, '755');
-                
-                // Remove quarantine attribute
-                try {
-                    execSync(`xattr -d com.apple.quarantine ${dest}`, { stdio: 'ignore' });
-                } catch (error) {
-                    // Quarantine attribute may not exist, which is fine
-                }
-            });
-        } else {
-            throw new Error('Lima binaries not found in expected location');
-        }
-        
-        // Copy share directory (required for guest agents)
-        const limaShareDir = path.join(extractDir, 'share');
-        const destShareDir = path.join(homeDir, 'share');
-        if (fs.existsSync(limaShareDir)) {
-            if (!fs.existsSync(destShareDir)) {
-                fs.mkdirSync(destShareDir, { recursive: true });
-            }
-            
-            try {
-                // Create lima directory in share
-                const limaDir = path.join(destShareDir, 'lima');
-                if (!fs.existsSync(limaDir)) {
-                    fs.mkdirSync(limaDir, { recursive: true });
-                }
-                
-                // Strategy 1: Try bundled guest agent (packaged with NPX)
-                const bundledGuestAgent = path.join(__dirname, 'lima-guestagent.Linux-aarch64.gz');
-                if (fs.existsSync(bundledGuestAgent)) {
-                    log.info('Using bundled Lima guest agent');
-                    const guestAgentDest = path.join(limaDir, 'lima-guestagent.Linux-aarch64.gz');
-                    fs.copyFileSync(bundledGuestAgent, guestAgentDest);
-                    
-                    // Extract the guest agent (Colima needs it uncompressed)
+async function installKubectl() {
+    // Linux with K3s already has kubectl
+    if (platform === 'linux') {
                     try {
-                        execSync(`gunzip -f "${guestAgentDest}"`);
-                    } catch (gunzipError) {
-                        // If gunzip fails, try manual extraction
-                        const zlib = require('zlib');
-                        const compressed = fs.readFileSync(guestAgentDest);
-                        const decompressed = zlib.gunzipSync(compressed);
-                        const extractedPath = guestAgentDest.replace('.gz', '');
-                        fs.writeFileSync(extractedPath, decompressed);
-                        fs.unlinkSync(guestAgentDest); // Remove compressed version
-                    }
-                    
-                    // Create basic default template for Colima
-                    const templatesDir = path.join(limaDir, 'templates');
-                    if (!fs.existsSync(templatesDir)) {
-                        fs.mkdirSync(templatesDir, { recursive: true });
-                    }
-                    
-                    const defaultTemplate = `# Basic default template for Colima
-images:
-- location: "https://cloud-images.ubuntu.com/releases/24.04/release/ubuntu-24.04-server-cloudimg-amd64.img"
-  arch: "x86_64"
-- location: "https://cloud-images.ubuntu.com/releases/24.04/release/ubuntu-24.04-server-cloudimg-arm64.img"  
-  arch: "aarch64"
-
-mounts:
-- location: "~"
-  writable: false
-- location: "/tmp/lima"
-  writable: true
-
-containerd:
-  system: false
-  user: false
-`;
-                    
-                    fs.writeFileSync(path.join(templatesDir, 'default.yaml'), defaultTemplate);
-                    log.info('Created basic Lima template');
-                    
-                } else {
-                    // Strategy 2: Try from tarball (fallback)
-                    const guestAgentSrc = path.join(limaShareDir, 'lima-guestagent.Linux-aarch64.gz');
-                    const templatesSrc = path.join(limaShareDir, 'templates');
-                    
-                    if (fs.existsSync(guestAgentSrc)) {
-                        // Copy and extract guest agent
-                        const guestAgentDest = path.join(limaDir, 'lima-guestagent.Linux-aarch64.gz');
-                        fs.copyFileSync(guestAgentSrc, guestAgentDest);
-                        
-                        // Extract the guest agent (Colima needs it uncompressed)
+            execSync('k3s kubectl version --client', { stdio: 'ignore' });
+            log.success('kubectl available via k3s');
+            // Create a symlink for convenience
                         try {
-                            execSync(`gunzip -f "${guestAgentDest}"`);
-                        } catch (gunzipError) {
-                            // If gunzip fails, try manual extraction
-                            const zlib = require('zlib');
-                            const compressed = fs.readFileSync(guestAgentDest);
-                            const decompressed = zlib.gunzipSync(compressed);
-                            const extractedPath = guestAgentDest.replace('.gz', '');
-                            fs.writeFileSync(extractedPath, decompressed);
-                            fs.unlinkSync(guestAgentDest); // Remove compressed version
-                        }
-                    } else {
-                        throw new Error('Lima guest agent not found in tarball or bundled');
-                    }
-                    
-                    if (fs.existsSync(templatesSrc)) {
-                        // Copy templates directory
-                        execSync(`cp -R "${templatesSrc}" "${limaDir}/templates"`);
-                    } else {
-                        // Create minimal template as fallback
-                        const templatesDir = path.join(limaDir, 'templates');
-                        fs.mkdirSync(templatesDir, { recursive: true });
-                        fs.writeFileSync(path.join(templatesDir, 'default.yaml'), defaultTemplate);
-                    }
-                }
-                
-            } catch (error) {
-                log.warning(`Lima share installation failed: ${error.message}`);
-                log.warning('You may need to install Lima manually: brew install lima');
+                execSync('sudo ln -sf /usr/local/bin/k3s /usr/local/bin/kubectl', { stdio: 'ignore' });
+            } catch {
+                // Link might already exist
             }
-        }
-        
-        // Cleanup
-        fs.rmSync(tempFile);
-        fs.rmSync(extractDir, { recursive: true });
-        
-        spinner.succeed('Lima installed');
         return true;
-    } catch (error) {
-        spinner.fail(`Lima installation failed: ${error.message}`);
-        log.warning('You may need to install Lima manually: brew install lima');
-        return false;
-    }
-}
-
-async function installKind() {
-    if (await checkCommand('kind')) {
-        log.success('KIND already installed');
-        return true;
-    }
-
-    const spinner = ora('Installing KIND...').start();
-    
-    try {
-        const kindUrl = `https://kind.sigs.k8s.io/dl/v0.20.0/kind-${platform}-${arch}`;
-        const kindDest = path.join(binDir, 'kind');
-        
-        await downloadFile(kindUrl, kindDest);
-        fs.chmodSync(kindDest, '755');
-        
-        spinner.succeed('KIND installed');
-        return true;
-    } catch (error) {
-        spinner.fail(`KIND installation failed: ${error.message}`);
-        return false;
+        } catch {
+            // Continue with regular kubectl installation
     }
 }
 
-async function installKubectl() {
     if (await checkCommand('kubectl')) {
         log.success('kubectl already installed');
         return true;
@@ -393,167 +308,495 @@ async function installKubectl() {
     }
 }
 
-async function installTribeCli() {
+async function setupGlobalNpmCommand() {
+    const spinner = ora('Setting up global tribe command...').start();
+    
+    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'
+            },
+            files: ['tribe-wrapper.js', 'tribe-logs-wrapper.js'],
+            private: true
+        };
+        
+        fs.writeFileSync(
+            path.join(tempDir, 'package.json'),
+            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');
+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');
+    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');
+    process.exit(1);
+}
+
+// Forward all arguments to the actual tribe binary
+const child = spawn(tribeBinaryPath, process.argv.slice(2), {
+    stdio: 'inherit',
+    env: process.env
+});
+
+child.on('exit', (code) => {
+    process.exit(code || 0);
+});
+
+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');
+    } else {
+        console.error('Failed to execute tribe:', err.message);
+    }
+    process.exit(1);
+});`;
+        
+        const wrapperPath = path.join(tempDir, 'tribe-wrapper.js');
+        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');
+                }
+            } else {
+                throw error;
+            }
+        }
+        
+        // Clean up temp directory
+        try {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+        } catch (cleanupError) {
+            // 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');
+        return false;
+    }
+}
+
+async function installTribeLogViewer() {
+    try {
+        // Install the log viewer script
+        const logViewerSource = path.join(__dirname, 'tribe-logs.sh');
+        const logViewerDest = path.join(tribeBinDir, 'tribe-logs');
+        
+        if (fs.existsSync(logViewerSource)) {
+            fs.copyFileSync(logViewerSource, logViewerDest);
+            fs.chmodSync(logViewerDest, '755');
+            log.success('Installed tribe-logs command for viewing debug logs');
+        }
+    } catch (error) {
+        log.warning(`Could not install log viewer: ${error.message}`);
+    }
+}
+
+async function installTribeCLI() {
     const spinner = ora('Installing TRIBE CLI...').start();
     
     try {
-        const tribeDest = path.join(binDir, 'tribe');
-        
-        // First check if we have a bundled binary
-        const bundledBinary = path.join(__dirname, 'tribe');
-        if (fs.existsSync(bundledBinary)) {
-            fs.copyFileSync(bundledBinary, tribeDest);
-            fs.chmodSync(tribeDest, '755');
-            spinner.succeed('TRIBE CLI installed from bundled binary');
-            return true;
+        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
         }
         
-        // Check if we have local source
-        const sourceFile = path.join(__dirname, 'cluster-cli.go');
-        if (fs.existsSync(sourceFile)) {
-            // Build from source
+        // Also remove old location if exists
+        const oldTribeDest = path.join(binDir, 'tribe');
+        if (fs.existsSync(oldTribeDest)) {
             try {
-                execSync('go version', { stdio: 'ignore' });
-                execSync(`cd ${__dirname} && go build -o tribe cluster-cli.go client.go`);
-                fs.copyFileSync(path.join(__dirname, 'tribe'), tribeDest);
-                fs.chmodSync(tribeDest, '755');
-                spinner.succeed('TRIBE CLI built from source');
-                return true;
-            } catch {
-                spinner.warn('Go not available, trying pre-built binary...');
+                fs.unlinkSync(oldTribeDest);
+                log.info('Removed old tribe binary from ~/bin');
+            } catch (e) {
+                // Ignore errors
             }
         }
         
-        // Try pre-built binary from GitHub
-        const tribeUrl = `https://github.com/0zen/0zen/releases/latest/download/tribe-${platform}-${arch}`;
+        // 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 githubRepo = process.env.TRIBE_INSTALLER_REPO || 'TRIBE-INC/releases';
         
+        let downloadUrl = '';
+
         try {
-            await downloadFile(tribeUrl, tribeDest);
-            fs.chmodSync(tribeDest, '755');
-            spinner.succeed('TRIBE CLI installed');
-            return true;
-        } catch {
-            // Fallback: look for any existing tribe binary
-            const possiblePaths = [
-                path.join(__dirname, '..', 'tribe-cli'),
-                path.join(__dirname, '..', 'tribe'),
-                './tribe-cli',
-                './tribe'
-            ];
-            
-            for (const possiblePath of possiblePaths) {
-                if (fs.existsSync(possiblePath)) {
-                    fs.copyFileSync(possiblePath, tribeDest);
-                    fs.chmodSync(tribeDest, '755');
-                    spinner.succeed('TRIBE CLI installed from local binary');
-                    return true;
+            spinner.text = 'Fetching latest release information from GitHub...';
+            const response = await fetch(`https://api.github.com/repos/${githubRepo}/releases`);
+            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');
+            }
+            const latestRelease = releases[0];
+            const assetName = `tribe-${platform}-${arch}`;
+            const asset = latestRelease.assets.find(a => a.name === assetName);
+
+            if (!asset) {
+                throw new Error(`No binary found for ${platform}-${arch} in release ${latestRelease.tag_name}`);
+            }
+
+            downloadUrl = asset.browser_download_url;
+            spinner.text = `Found latest release: ${latestRelease.tag_name}`;
+        } catch (error) {
+            spinner.fail(`Failed to get release info: ${error.message}`);
+            // Fallback to other methods if the API fails
+        }
+
+        const sources = isTestEnv ? [isTestEnv] : [
+            downloadUrl,
+            // Public releases repository (primary source)
+            `https://raw.githubusercontent.com/${githubRepo}/main/cli/latest-tribe-${platform}-${arch}`,
+            // GitHub releases (fallback)
+            `https://github.com/${githubRepo}/releases/latest/download/tribe-${platform}-${arch}`,
+            // Try jsDelivr CDN (for better availability)
+            `https://cdn.jsdelivr.net/gh/${githubRepo}@main/cli/latest-tribe-${platform}-${arch}`,
+        ].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}`;
                 }
+                
+                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');
+                
+                // Verify the binary works
+                try {
+                    execSync(`${tribeDest} version`, { stdio: 'ignore' });
+                } catch (versionError) {
+                    // If version fails, still consider it downloaded if file is valid
+                    log.warning('Binary downloaded but version check 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...`);
             }
+        }
             
-            throw new Error('No TRIBE CLI binary available');
+        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() {
-    if (platform !== 'darwin') {
-        return true; // Linux uses Docker daemon directly
-    }
+    const spinner = ora('Starting container runtime...').start();
 
-    // Check if container runtime is already working
     try {
-        execSync('docker info', { stdio: 'ignore' });
-        log.success('Container runtime is already working');
-        return true;
-    } catch {
-        // Try to start Colima with different approaches
-        if (await checkCommand('colima')) {
-            const spinner = ora('Starting Colima container runtime...').start();
-            
+        // Platform-specific container runtime handling
+        if (platform === 'darwin') {
+            // macOS - Check if Colima is running
             try {
-                // Strategy 1: Quick start with minimal resources and Kubernetes
-                spinner.text = 'Starting Colima with Kubernetes...';
-                const colimaPath = path.join(binDir, 'colima');
-                execSync(`${colimaPath} start --cpu 2 --memory 4 --disk 10 --kubernetes --vm-type=vz`, { 
-                    stdio: 'pipe',
-                    timeout: 60000 // 60 second timeout for K8s
-                });
-                
-                // Test if it worked
-                execSync('docker info', { stdio: 'ignore' });
-                spinner.succeed('Colima started successfully');
-                return true;
+                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
+            }
+            
+            // Try to start Colima
+            if (await checkCommand('colima')) {
+                const spinner = ora('Starting Colima container runtime...').start();
                 
-            } catch (error) {
-                // Strategy 2: Start in background with Kubernetes
                 try {
-                    spinner.text = 'Starting Colima with Kubernetes in background...';
-                    const child = spawn(path.join(binDir, 'colima'), ['start', '--cpu', '2', '--memory', '4', '--disk', '10', '--kubernetes'], {
-                        detached: true,
-                        stdio: 'ignore',
-                        env: { ...process.env, PATH: `${binDir}:${process.env.PATH}` }
+                    // Strategy 1: Quick start with minimal resources and Kubernetes
+                    spinner.text = 'Starting Colima with Kubernetes...';
+                    const colimaPath = await findCommand('colima') || path.join(binDir, 'colima');
+                    execSync(`${colimaPath} start --cpu 2 --memory 4 --disk 10 --kubernetes --vm-type=vz`, { 
+                        stdio: 'pipe',
+                        timeout: 60000 // 60 second timeout for K8s
                     });
-                    child.unref(); // Don't wait for completion
                     
-                    spinner.succeed('Colima startup initiated (background)');
-                    log.info('Colima is starting in the background');
-                    log.info('Run "colima status" to check progress');
-                    log.info('Run "docker info" to test when ready');
+                    spinner.succeed('Colima started successfully');
                     return true;
                     
-                } catch (bgError) {
-                    spinner.fail('Failed to start Colima');
-                    log.warning('Container runtime startup failed (likely due to macOS system restrictions)');
-                    log.info('Options to fix:');
-                    log.info('');
-                    log.info('Option 1 - Manual Colima start:');
-                    log.info('  colima start --cpu 2 --memory 4  # Start container runtime');
-                    log.info('  # This downloads a 344MB disk image (may take time)');
-                    log.info('');
-                    log.info('Option 2 - Use Docker Desktop (easier):');
-                    log.info('  Download from: https://docs.docker.com/desktop/install/mac-install/');
-                    log.info('  # Docker Desktop handles all container runtime setup');
-                    log.info('');
-                    log.info('Option 3 - Use Homebrew (recommended):');
-                    log.info('  brew install colima docker');
-                    log.info('  colima start');
-                    log.info('');
-                    return false;
+                } catch (error) {
+                    // Strategy 2: Start in background with Kubernetes
+                    try {
+                        spinner.text = 'Starting Colima with Kubernetes in background...';
+                        const colimaPath = await findCommand('colima') || path.join(binDir, 'colima');
+                        const child = spawn(colimaPath, ['start', '--cpu', '2', '--memory', '4', '--disk', '10', '--kubernetes'], {
+                            detached: true,
+                            stdio: 'ignore',
+                            env: { ...process.env, PATH: `${binDir}:${process.env.PATH}` }
+                        });
+                        child.unref(); // Don't wait for completion
+                        
+                        spinner.succeed('Colima startup initiated (background)');
+                        log.info('Colima is starting in the background');
+                        log.info('Run "colima status" to check progress');
+                        return true;
+                        
+                    } catch (bgError) {
+                        spinner.fail('Failed to start Colima');
+                        log.warning('Container runtime startup failed (likely due to macOS system restrictions)');
+                        log.info('Options to fix:');
+                        log.info('');
+                        log.info('Option 1 - Manual Colima start:');
+                        log.info('  colima start --cpu 2 --memory 4 --kubernetes');
+                        log.info('  # This downloads a 344MB disk image (may take time)');
+                        log.info('');
+                        log.info('Option 2 - Use Homebrew (recommended):');
+                        log.info('  brew install colima');
+                        log.info('  colima start --kubernetes');
+                        log.info('');
+                        return false;
+                    }
                 }
             }
-        }
-    }
+        } else if (platform === 'linux') {
+            // Linux - K3s should already be running
+            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, use KIND or connect to external cluster');
+                return true; // Don't fail
+            }
+            
+            try {
+                execSync('sudo systemctl is-active --quiet k3s', { stdio: 'ignore' });
+                spinner.succeed('K3s is running');
+                return true;
+            } catch {
+                // Try to start K3s
+                spinner.text = 'Starting K3s...';
+                try {
+                    execSync('sudo systemctl start k3s', { stdio: 'ignore' });
+                    await new Promise(resolve => setTimeout(resolve, 5000));
+                    spinner.succeed('K3s started');
+                    return true;
+                } catch (error) {
+                    spinner.warn('K3s not available - requires systemd');
+                    log.info('K3s requires systemd. Install K3s manually or use KIND/external cluster');
+                    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;
-}
-
-async function updatePath() {
-    const shell = process.env.SHELL || '/bin/zsh';
-    const rcFile = shell.includes('zsh') ? '.zshrc' : '.bashrc';
-    const rcPath = path.join(homeDir, rcFile);
-    
-    const pathExport = `export PATH="${binDir}:$PATH"`;
-    
-    try {
-        const rcContent = fs.existsSync(rcPath) ? fs.readFileSync(rcPath, 'utf8') : '';
-        if (!rcContent.includes(pathExport)) {
-            fs.appendFileSync(rcPath, `\n# Added by TRIBE CLI installer\n${pathExport}\n`);
-            log.success(`Updated ${rcFile} with PATH`);
         }
     } catch (error) {
-        log.warning(`Failed to update ${rcFile}: ${error.message}`);
+        spinner.fail(`Container runtime error: ${error.message}`);
+        return false;
     }
-    
-    // Update current process PATH
-    process.env.PATH = `${binDir}:${process.env.PATH}`;
 }
 
+// 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 = ['docker', 'kubectl', 'tribe', 'colima'];
+    const tools = ['kubectl', 'tribe', 'colima'];
     const results = {};
     
     for (const tool of tools) {
@@ -562,11 +805,27 @@ async function verifyInstallation() {
     
     // Special check for container runtime
     let containerWorking = false;
-    try {
-        execSync('docker info', { stdio: 'ignore' });
-        containerWorking = true;
-    } catch (error) {
-        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();
@@ -602,34 +861,83 @@ async function checkClusterExists() {
 
 async function checkColimaRunning() {
     try {
-                    const colimaPath = path.join(binDir, 'colima');
-            execSync(`${colimaPath} status`, { stdio: 'ignore' });
+        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()) {
-            spinner.succeed('Colima is already running');
+            // 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 = path.join(binDir, 'colima');
-            execSync(`${colimaPath} start --kubernetes --cpu 4 --memory 8 --disk 20`, {
+        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}` }
+            env: { ...process.env, PATH: `${binDir}:${process.env.PATH}` },
+            timeout: 300000 // 5 minute timeout for first start
         });
         
-        // Verify it's working
-        execSync('kubectl version --client', { stdio: 'ignore' });
+        // 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) {
@@ -664,11 +972,37 @@ async function deployTribeCluster() {
         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(binDir, 'tribe');
+        const tribePath = path.join(tribeBinDir, 'tribe');
         
         // Set environment variable for the deployment YAML location
         const env = {
@@ -677,8 +1011,107 @@ async function deployTribeCluster() {
             TRIBE_DEPLOYMENT_YAML: destYaml
         };
         
-        // Execute tribe start without validation (services need time to start)
-        execSync(`${tribePath} start --validate=false`, {
+        // 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
         });
@@ -692,18 +1125,37 @@ async function deployTribeCluster() {
     } 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 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 Colima with Kubernetes');
+        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'));
@@ -720,20 +1172,226 @@ async function promptForClusterSetup() {
     });
 }
 
+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'));
+    
+    // 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
+    }
+    
+    // List of binaries to remove from ~/bin
+    const binariesToRemove = ['tribe', 'kubectl', 'colima'];
+    
+    for (const binary of binariesToRemove) {
+        const binaryPath = path.join(binDir, binary);
+        if (fs.existsSync(binaryPath)) {
+            try {
+                fs.unlinkSync(binaryPath);
+                log.success(`Removed existing ${binary} binary from ~/bin`);
+            } catch (error) {
+                log.warning(`Could not remove ${binary}: ${error.message}`);
+            }
+        }
+    }
+    
+    // Also clean from .tribe/bin
+    const tribeBinariesToRemove = ['tribe'];
+    for (const binary of tribeBinariesToRemove) {
+        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)');
+    }
+    
+    // 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 Complete Installer\n'));
     
+    // Detect and display platform info
+    const displayArch = process.arch === 'x64' ? 'amd64' : process.arch;
+    console.log(chalk.cyan(`Platform: ${platform} (${displayArch})`));
+    console.log(chalk.cyan(`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', 'kind', '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: ${binDir}`);
+    log.info(`Installing to: ${tribeBinDir}`);
+    
+    // No longer updating PATH - will use npm global install instead
     
-    // Update PATH first
-    await updatePath();
+    const tasks = [];
     
-    const tasks = [
-        { name: 'Colima', fn: installColima },
+    // 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: 'TRIBE CLI', fn: installTribeCLI },
+        { name: 'Global tribe command', fn: setupGlobalNpmCommand }
+    );
     
     let allSuccess = true;
     
@@ -753,7 +1411,7 @@ async function main() {
         // Check if cluster already exists
         const clusterExists = await checkClusterExists();
         
-        if (!clusterExists) {
+        if (!clusterExists && !global.skipCluster) {
             // Prompt for cluster setup
             const shouldSetup = await promptForClusterSetup();
             
@@ -778,14 +1436,12 @@ async function main() {
                     console.log('\n' + chalk.bold.green('✨ TRIBE is ready!'));
                     console.log('');
                     
-                    // Check if PATH needs updating
-                    const needsPathUpdate = !process.env.PATH.includes(binDir);
-                    if (needsPathUpdate) {
-                        log.warning('PATH update required for current shell:');
-                        console.log(chalk.yellow(`  source ~/.${process.env.SHELL?.includes('zsh') ? 'zshrc' : 'bashrc'}`));
-                        console.log('  ' + chalk.gray('or restart your terminal'));
-                        console.log('');
-                    }
+                    // Provide immediate access to tribe command
+                    log.info('TRIBE command is now available globally!');
+                    console.log(chalk.green('  tribe              # Run from anywhere'));
+                    console.log(chalk.gray('  tribe --help       # View available commands'));
+                    console.log(chalk.gray('  tribe status       # Check cluster status'));
+                    console.log('');
                     
                     log.info('Quick start:');
                     console.log('  tribe              # Launch interactive CLI');
@@ -806,6 +1462,12 @@ async function main() {
             console.log('\n' + chalk.bold.green('✨ TRIBE is ready!'));
             log.success('Cluster is already running');
             console.log('');
+            
+            // Provide immediate access to tribe command
+            log.info('TRIBE command is now available globally!');
+            console.log(chalk.green('  tribe              # Run from anywhere'));
+            console.log('');
+            
             log.info('Commands:');
             console.log('  tribe              # Launch interactive CLI');
             console.log('  tribe status       # Check status');
@@ -817,17 +1479,30 @@ async function main() {
         console.log('');
         // Check container runtime for guidance
         let runtimeWorking = false;
-        try {
-            execSync('docker info', { stdio: 'ignore' });
-            runtimeWorking = true;
-        } catch {
-            runtimeWorking = false;
-        }
-        
-        if (!runtimeWorking) {
-            log.info('Start container runtime:');
-            console.log('  colima start             # macOS');
-            console.log('  sudo systemctl start docker  # Linux');
+        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');
@@ -845,13 +1520,25 @@ if (require.main === module) {
     
     if (args.includes('--help') || args.includes('-h')) {
         console.log(chalk.bold.blue('TRIBE CLI Installer\n'));
-        console.log('Usage: npx tribe-cli-local [options]\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('\nThis installer sets up the complete TRIBE development environment:');
-        console.log('• Colima (Container runtime with Kubernetes)');
+        console.log('  --skip-cluster Skip cluster deployment (for testing)');
+        console.log('  --force        Force clean installation (removes existing installations)');
+        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:');
@@ -873,19 +1560,32 @@ if (require.main === module) {
         log.info(`Platform: ${platform} (${arch})`);
         log.info(`Install directory: ${binDir}`);
         console.log('\nWould install:');
-        console.log('• Docker CLI (if not present)');
-        console.log('• Colima container runtime (macOS only)');
-        console.log('• Lima virtualization (macOS only)');
-                    console.log('• Colima - Container runtime with Kubernetes');
+        console.log('• Colima - Container runtime with Kubernetes (macOS only)');
         console.log('• kubectl - Kubernetes CLI');
         console.log('• TRIBE CLI - Multi-agent system');
         process.exit(0);
     }
     
-    main().catch(error => {
-        console.error(chalk.red('Installation failed:'), error.message);
-        process.exit(1);
-    });
+    // Store skip-cluster flag
+    global.skipCluster = args.includes('--skip-cluster');
+    
+    // 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);
+        });
+    }
 }
 
 module.exports = { main };