@_xtribe/cli 1.0.0-beta.22 → 1.0.0-beta.25

package/README.md

@@ -8,12 +8,18 @@ TRIBE is an AI-powered multi-agent development system that manages your entire d
 npx @_xtribe/cli
 ```
 
-That's it! This single command will:
-- ✅ Install all required tools (Docker, Kubernetes, kubectl)
-- ✅ Set up Colima container runtime (macOS)
-- ✅ Deploy the complete TRIBE cluster
-- ✅ Configure everything automatically
-- ✅ Guide you through creating your first project
+That's it! This single command works on macOS, Linux, and Windows (WSL2).
+
+**What it does:**
+- ✅ Detects your platform automatically
+- ✅ Installs all required tools (kubectl, TRIBE CLI)
+- ✅ Sets up Kubernetes for your platform:
+  - **macOS**: Colima with Kubernetes
+  - **Linux**: K3s (lightweight Kubernetes)
+  - **Windows**: Guides to WSL2 setup
+- ✅ Deploys the complete TRIBE cluster
+- ✅ Configures your environment
+- ✅ Guides you through creating your first project
 
 ## 🎯 What is TRIBE?
 
@@ -54,7 +60,12 @@ tribe review-task
 
 ## 🛠️ System Requirements
 
-- **macOS** or **Linux**
+### Supported Platforms
+- **macOS** (Intel & Apple Silicon)
+- **Linux** (Ubuntu, Debian, Fedora, etc.)
+- **Windows** - Use WSL2 with Ubuntu
+
+### Hardware Requirements
 - **4GB RAM** minimum (8GB recommended)
 - **20GB disk space**
 - **Node.js 16+**
@@ -90,6 +101,8 @@ For detailed documentation, visit the [TRIBE Flow Guide](https://github.com/0zen
 ## 🆘 Troubleshooting
 
 ### Cluster not starting?
+
+**macOS:**
 ```bash
 # Check if Colima is running
 colima status
@@ -99,6 +112,16 @@ colima start --kubernetes
 tribe start
 ```
 
+**Linux:**
+```bash
+# Check if K3s is running
+sudo systemctl status k3s
+
+# Start manually if needed
+sudo systemctl start k3s
+tribe start
+```
+
 ### Port conflicts?
 ```bash
 # Check what's using ports

package/install-tribe.js

@@ -8,9 +8,13 @@ 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');
@@ -83,8 +87,25 @@ 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);
@@ -94,55 +115,91 @@ async function downloadFile(url, dest) {
 // Docker installation removed - Colima provides Docker runtime
 
 async function installK3s() {
-    if (platform !== 'linux') {
-        return true; // K3s is Linux only
-    }
-    
     const spinner = ora('Installing K3s (lightweight Kubernetes)...').start();
     
     try {
-        // Check if already installed
+        // Check if K3s is already installed
         try {
-            execSync('k3s --version', { stdio: 'ignore' });
+            execSync('which k3s', { stdio: 'ignore' });
             spinner.succeed('K3s already installed');
             return true;
         } catch {
             // Not installed, continue
         }
         
-        // One-line K3s installation
-        spinner.text = 'Installing K3s (this may take a few minutes)...';
-        console.log(chalk.yellow('\n📦 Installing K3s - Lightweight Kubernetes'));
-        console.log(chalk.gray('This is a one-line installation that will:'));
-        console.log(chalk.gray('  • Download and install K3s'));
-        console.log(chalk.gray('  • Configure systemd service'));
-        console.log(chalk.gray('  • Set up kubectl access'));
-        console.log(chalk.gray('  • Disable Traefik (we use our own ingress)\n'));
+        // Check if we have permission to install
+        const needsSudo = process.getuid && process.getuid() !== 0;
         
-        execSync('curl -sfL https://get.k3s.io | sh -s - --disable traefik --write-kubeconfig-mode 644', {
-            stdio: 'inherit',
-            shell: '/bin/bash'
-        });
+        // 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';
         
-        // Wait for K3s to be ready
-        spinner.text = 'Waiting for K3s to be ready...';
-        await new Promise(resolve => setTimeout(resolve, 10000));
+        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
+        }
+        
+        // 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';
         
-        // Make kubectl available
         try {
-            execSync('sudo ln -sf /usr/local/bin/k3s /usr/local/bin/kubectl', { stdio: 'ignore' });
-        } catch {
-            // Link might already exist
+            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;
         }
         
-        // Set KUBECONFIG for current process
-        process.env.KUBECONFIG = '/etc/rancher/k3s/k3s.yaml';
-        
-        spinner.succeed('K3s installed successfully');
-        return true;
     } catch (error) {
-        spinner.fail(`K3s installation failed: ${error.message}`);
-        log.info('You can install K3s manually with: curl -sfL https://get.k3s.io | sh -');
+        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;
     }
 }
@@ -205,21 +262,21 @@ async function installColima() {
 async function installKubectl() {
     // Linux with K3s already has kubectl
     if (platform === 'linux') {
-        try {
+                    try {
             execSync('k3s kubectl version --client', { stdio: 'ignore' });
             log.success('kubectl available via k3s');
             // Create a symlink for convenience
-            try {
+                        try {
                 execSync('sudo ln -sf /usr/local/bin/k3s /usr/local/bin/kubectl', { stdio: 'ignore' });
             } catch {
                 // Link might already exist
             }
-            return true;
+        return true;
         } catch {
             // Continue with regular kubectl installation
-        }
     }
-    
+}
+
     if (await checkCommand('kubectl')) {
         log.success('kubectl already installed');
         return true;
@@ -264,123 +321,237 @@ async function installTribeCLI() {
         }
         
         // Download pre-built binary from GitHub
-        const arch = process.arch === 'x64' ? 'amd64' : 'arm64';
+        // 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
-        const sources = [
-            // GitHub releases (primary source)
-            `https://github.com/TRIBE-INC/0zen/releases/latest/download/tribe-${platform}-${arch}`,
-            // Try jsDelivr CDN as fallback
-            `https://cdn.jsdelivr.net/gh/TRIBE-INC/0zen@latest/releases/tribe-${platform}-${arch}`,
-            // Direct raw GitHub as last resort
-            `https://raw.githubusercontent.com/TRIBE-INC/0zen/main/releases/tribe-${platform}-${arch}`
-        ];
+        // 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 {
+            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) {
-            spinner.text = `Downloading TRIBE CLI from ${url.includes('jsdelivr') ? 'CDN' : 'GitHub'}...`;
             try {
-                await downloadFile(url, tribeDest);
+                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
-                execSync(`${tribeDest} version`, { stdio: 'ignore' });
+                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');
                 downloaded = true;
                 break;
             } catch (error) {
                 lastError = error;
-                log.warning(`Failed to download from ${url.split('/').slice(2, 3).join('/')}, trying next source...`);
+                // 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: ${lastError?.message || 'All sources failed'}`);
+            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 container runtime is already working via Colima
+            // macOS - Check if Colima is running
             try {
-                execSync('docker info', { stdio: 'ignore' });
-                log.success('Container runtime is already working');
-                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 {
-                // Try to start Colima with different approaches
-        if (await checkCommand('colima')) {
-            const spinner = ora('Starting Colima container runtime...').start();
+                // Colima not running, need to start it
+            }
             
-            try {
-                // 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
-                });
-                
-                // Test if it worked
-                execSync('docker info', { stdio: 'ignore' });
-                spinner.succeed('Colima started successfully');
-                return true;
+            // 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...';
+                    // Strategy 1: Quick start with minimal resources and Kubernetes
+                    spinner.text = 'Starting Colima with Kubernetes...';
                     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}` }
+                    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');
@@ -394,9 +565,9 @@ async function startContainerRuntime() {
                     spinner.succeed('K3s started');
                     return true;
                 } catch (error) {
-                    spinner.fail('Failed to start K3s');
-                    log.error('Please ensure K3s is installed and you have sudo access');
-                    return false;
+                    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') {
@@ -405,7 +576,7 @@ async function startContainerRuntime() {
             return false;
         } else {
             spinner.fail(`Unsupported platform: ${platform}`);
-            return false;
+    return false;
         }
     } catch (error) {
         spinner.fail(`Container runtime error: ${error.message}`);
@@ -434,10 +605,98 @@ async function updatePath() {
     process.env.PATH = `${binDir}:${process.env.PATH}`;
 }
 
+async function updateShellConfig() {
+    const homeDir = os.homedir();
+    const pathExport = `export PATH="$HOME/bin:$PATH"`;
+    
+    // Get current shell
+    const currentShell = process.env.SHELL || '/bin/sh';
+    const shellName = path.basename(currentShell);
+    
+    // Platform-specific shell config files
+    const shellConfigs = {
+        'zsh': ['.zshrc'],
+        'bash': ['.bashrc', '.bash_profile'],
+        'sh': ['.profile'],
+        'fish': ['.config/fish/config.fish'],
+        'ksh': ['.kshrc'],
+        'tcsh': ['.tcshrc', '.cshrc']
+    };
+    
+    // On Linux, also update .profile for login shells
+    if (platform === 'linux') {
+        shellConfigs['bash'].push('.profile');
+    }
+    
+    // Get config files for current shell
+    const configFiles = shellConfigs[shellName] || ['.profile'];
+    
+    let updated = false;
+    
+    for (const configFile of configFiles) {
+        const configPath = path.join(homeDir, configFile);
+        
+        try {
+            // Create config file if it doesn't exist
+            if (!fs.existsSync(configPath)) {
+                // Handle fish shell special syntax
+                if (configFile.includes('fish')) {
+                    fs.mkdirSync(path.dirname(configPath), { recursive: true });
+                    fs.writeFileSync(configPath, `# Created by TRIBE installer\nset -gx PATH $HOME/bin $PATH\n`);
+                } else {
+                    fs.writeFileSync(configPath, `# Created by TRIBE installer\n${pathExport}\n`);
+                }
+                updated = true;
+                continue;
+            }
+            
+            // Check if PATH is already configured
+            const content = fs.readFileSync(configPath, 'utf8');
+            if (content.includes('$HOME/bin') || content.includes('~/bin')) {
+                continue; // Already configured
+            }
+            
+            // Add PATH export
+            if (configFile.includes('fish')) {
+                fs.appendFileSync(configPath, `\n# Added by TRIBE installer\nset -gx PATH $HOME/bin $PATH\n`);
+            } else {
+                fs.appendFileSync(configPath, `\n# Added by TRIBE installer\n${pathExport}\n`);
+            }
+            updated = true;
+        } catch (error) {
+            log.warning(`Could not update ${configFile}: ${error.message}`);
+        }
+    }
+    
+    if (updated) {
+        log.success(`Updated shell configuration`);
+        
+        // Linux-specific: also update /etc/environment if we have permission
+        if (platform === 'linux' && process.getuid && process.getuid() === 0) {
+            try {
+                const envPath = '/etc/environment';
+                if (fs.existsSync(envPath)) {
+                    const envContent = fs.readFileSync(envPath, 'utf8');
+                    if (!envContent.includes('/usr/local/bin')) {
+                        // Update system PATH
+                        const newPath = envContent.replace(/PATH="([^"]*)"/, 'PATH="/usr/local/bin:$1"');
+                        fs.writeFileSync(envPath, newPath);
+                        log.success('Updated system PATH in /etc/environment');
+                    }
+                }
+            } catch (error) {
+                // Ignore permission errors
+            }
+        }
+        
+        log.info(`Run "source ~/${configFiles[0]}" or restart your terminal`);
+    }
+}
+
 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) {
@@ -446,11 +705,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();
@@ -514,7 +789,14 @@ async function startColimaWithKubernetes() {
             // Check if it has Kubernetes enabled
             if (await checkColimaHasKubernetes()) {
                 spinner.succeed('Colima is already running with Kubernetes');
-                return true;
+                
+                // 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...';
                 
@@ -754,19 +1036,26 @@ async function deployTribeCluster() {
             log.info('   colima start --kubernetes');
             log.info('3. Then run: tribe start');
         } else {
-            log.info('You can manually deploy later with: tribe start');
+        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'));
@@ -783,12 +1072,37 @@ 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 main() {
     console.log(chalk.bold.blue('\n🚀 TRIBE CLI Complete Installer\n'));
     
     // Detect and display platform info
-    const arch = process.arch === 'x64' ? 'amd64' : process.arch;
-    console.log(chalk.cyan(`Platform: ${platform} (${arch})`));
+    const displayArch = process.arch === 'x64' ? 'amd64' : process.arch;
+    console.log(chalk.cyan(`Platform: ${platform} (${displayArch})`));
     console.log(chalk.cyan(`Node: ${process.version}`));
     console.log('');
     
@@ -800,12 +1114,68 @@ async function main() {
         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}`);
     
     // Update PATH first
     await updatePath();
     
+    // Update shell configuration files
+    await updateShellConfig();
+    
     const tasks = [];
     
     // Platform-specific Kubernetes installation
@@ -915,17 +1285,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');
@@ -949,7 +1332,7 @@ if (require.main === module) {
         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('\nThis installer sets up the complete TRIBE development environment:');
+        console.log('\nThis installer sets up the complete TRIBE development environment:');
         
         if (platform === 'darwin') {
             console.log('• Colima (Container runtime with Kubernetes)');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@_xtribe/cli",
-  "version": "1.0.0-beta.22",
+  "version": "1.0.0-beta.25",
   "description": "TRIBE multi-agent development system - Zero to productive with one command",
   "main": "install-tribe.js",
   "bin": {
@@ -43,7 +43,8 @@
     "ora": "^5.4.1",
     "node-fetch": "^2.6.7",
     "tar": "^6.1.15",
-    "which": "^2.0.2"
+    "which": "^2.0.2",
+    "adm-zip": "^0.5.9"
   },
   "repository": {
     "type": "git",