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

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,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),
@@ -83,8 +93,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 +121,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 +268,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;
@@ -245,142 +308,395 @@ async function installKubectl() {
     }
 }
 
+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'
+            },
+            files: ['tribe-wrapper.js'],
+            private: true
+        };
+        
+        fs.writeFileSync(
+            path.join(tempDir, 'package.json'),
+            JSON.stringify(packageJson, null, 2)
+        );
+        
+        // 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 installTribeCLI() {
     const spinner = ora('Installing TRIBE CLI...').start();
     
     try {
-        const tribeDest = path.join(binDir, 'tribe');
+        const tribeDest = path.join(tribeBinDir, 'tribe');
         
-        // Skip if already installed and working
+        // Unconditionally remove existing binary to ensure a clean install
         if (fs.existsSync(tribeDest)) {
+            spinner.text = 'Removing existing TRIBE CLI installation...';
+            fs.unlinkSync(tribeDest);
+            log.success('Removed existing TRIBE CLI');
+            spinner.text = 'Installing TRIBE CLI...'; // Reset spinner text
+        }
+        
+        // Also remove old location if exists
+        const oldTribeDest = path.join(binDir, 'tribe');
+        if (fs.existsSync(oldTribeDest)) {
             try {
-                execSync(`${tribeDest} version`, { stdio: 'ignore' });
-                spinner.succeed('TRIBE CLI already installed');
-                return true;
-            } catch {
-                // Binary exists but doesn't work, remove it
-                fs.unlinkSync(tribeDest);
+                fs.unlinkSync(oldTribeDest);
+                log.info('Removed old tribe binary from ~/bin');
+            } catch (e) {
+                // Ignore errors
             }
         }
         
         // 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 +710,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 +721,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}`);
@@ -413,31 +729,16 @@ async function startContainerRuntime() {
     }
 }
 
-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}`);
-    }
-    
-    // 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) {
@@ -446,11 +747,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 +831,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...';
                 
@@ -620,7 +944,7 @@ async function deployTribeCluster() {
         
         // 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 = {
@@ -754,19 +1078,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 +1114,142 @@ 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 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,11 +1261,63 @@ 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}`);
+    log.info(`Installing to: ${tribeBinDir}`);
     
-    // Update PATH first
-    await updatePath();
+    // No longer updating PATH - will use npm global install instead
     
     const tasks = [];
     
@@ -818,7 +1331,8 @@ async function main() {
     // 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;
@@ -865,19 +1379,16 @@ async function main() {
                     console.log('');
                     
                     // Provide immediate access to tribe command
-                    const tribePath = path.join(binDir, 'tribe');
-                    
-                    log.info('To use tribe commands:');
-                    console.log(chalk.green(`  ${tribePath}              # Use full path now`));
-                    console.log(chalk.yellow(`  source ~/.${process.env.SHELL?.includes('zsh') ? 'zshrc' : 'bashrc'}  # Or update PATH`));
-                    console.log(chalk.cyan(`  alias tribe="${tribePath}"        # Or create temporary alias`));
-                    console.log('  ' + chalk.gray('or restart your terminal'));
+                    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(`  ${tribePath}              # Launch interactive CLI`);
-                    console.log(`  ${tribePath} status       # Check cluster status`);
-                    console.log(`  ${tribePath} create-task  # Create a new task`);
+                    console.log('  tribe              # Launch interactive CLI');
+                    console.log('  tribe status       # Check cluster status');
+                    console.log('  tribe create-task  # Create a new task');
                     console.log('');
                     log.info('First time? The CLI will guide you through creating your first project!');
                 } else {
@@ -895,19 +1406,14 @@ async function main() {
             console.log('');
             
             // Provide immediate access to tribe command
-            const tribePath = path.join(binDir, 'tribe');
-            
-            log.info('To use tribe commands:');
-            console.log(chalk.green(`  ${tribePath}              # Use full path now`));
-            console.log(chalk.yellow(`  source ~/.${process.env.SHELL?.includes('zsh') ? 'zshrc' : 'bashrc'}  # Or update PATH`));
-            console.log(chalk.cyan(`  alias tribe="${tribePath}"        # Or create temporary alias`));
-            console.log('  ' + chalk.gray('or restart your terminal'));
+            log.info('TRIBE command is now available globally!');
+            console.log(chalk.green('  tribe              # Run from anywhere'));
             console.log('');
             
             log.info('Commands:');
-            console.log(`  ${tribePath}              # Launch interactive CLI`);
-            console.log(`  ${tribePath} status       # Check status`);
-            console.log(`  ${tribePath} create-task  # Create a new task`);
+            console.log('  tribe              # Launch interactive CLI');
+            console.log('  tribe status       # Check status');
+            console.log('  tribe create-task  # Create a new task');
         }
     } else {
         console.log('\n' + chalk.bold('Next Steps:'));
@@ -915,17 +1421,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 +1468,8 @@ 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('  --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)');
@@ -991,10 +1511,23 @@ if (require.main === module) {
     // Store skip-cluster flag
     global.skipCluster = args.includes('--skip-cluster');
     
-    main().catch(error => {
-        console.error(chalk.red('Installation failed:'), error.message);
-        process.exit(1);
-    });
+    // 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 };

package/package.json

@@ -1,11 +1,8 @@
 {
   "name": "@_xtribe/cli",
-  "version": "1.0.0-beta.22",
+  "version": "1.0.0-beta.26",
   "description": "TRIBE multi-agent development system - Zero to productive with one command",
   "main": "install-tribe.js",
-  "bin": {
-    "tribe": "install-tribe.js"
-  },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
@@ -43,7 +40,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",