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

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);
@@ -93,6 +114,96 @@ async function downloadFile(url, dest) {
 
 // Docker installation removed - Colima provides Docker runtime
 
+async function installK3s() {
+    const spinner = ora('Installing K3s (lightweight Kubernetes)...').start();
+    
+    try {
+        // Check if K3s is already installed
+        try {
+            execSync('which k3s', { stdio: 'ignore' });
+            spinner.succeed('K3s already installed');
+            return true;
+        } catch {
+            // Not installed, continue
+        }
+        
+        // Check if we have permission to install
+        const needsSudo = process.getuid && process.getuid() !== 0;
+        
+        // Check if we're in a container or CI environment
+        const isContainer = process.env.container === 'docker' || 
+                          fs.existsSync('/.dockerenv') || 
+                          !fs.existsSync('/run/systemd/system') ||
+                          process.env.CI === 'true';
+        
+        if (isContainer) {
+            spinner.warn('Running in container/CI - K3s installation skipped');
+            log.info('K3s requires systemd and privileged access');
+            log.info('For containers, consider using 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';
+        
+        try {
+            execSync(installCommand, { 
+                stdio: 'pipe',
+                env: { ...process.env, INSTALL_K3S_SKIP_START: 'false' }
+            });
+            
+            spinner.succeed('K3s installed successfully');
+            
+            // Wait for K3s to be ready
+            spinner.text = 'Waiting for K3s to start...';
+            await new Promise(resolve => setTimeout(resolve, 10000));
+            
+            // Configure kubectl to use K3s
+            const k3sConfig = '/etc/rancher/k3s/k3s.yaml';
+            const userConfig = path.join(os.homedir(), '.kube', 'config');
+            
+            if (fs.existsSync(k3sConfig)) {
+                fs.mkdirSync(path.dirname(userConfig), { recursive: true });
+                
+                if (needsSudo) {
+                    execSync(`sudo cp ${k3sConfig} ${userConfig} && sudo chown $(id -u):$(id -g) ${userConfig}`, { stdio: 'ignore' });
+                } else {
+                    fs.copyFileSync(k3sConfig, userConfig);
+                }
+                
+                // Update server address to use localhost
+                let configContent = fs.readFileSync(userConfig, 'utf8');
+                configContent = configContent.replace(/server: https:\/\/127\.0\.0\.1:6443/, 'server: https://localhost:6443');
+                fs.writeFileSync(userConfig, configContent);
+                
+                spinner.succeed('K3s configured');
+            }
+            
+            return true;
+        } catch (error) {
+            if (error.message.includes('permission denied') || error.message.includes('sudo')) {
+                spinner.fail('K3s installation requires sudo permission');
+                log.info('Please run the installer with sudo or install K3s manually:');
+                log.info('  curl -sfL https://get.k3s.io | sudo sh -');
+                return false;
+            }
+            throw error;
+        }
+        
+    } catch (error) {
+        spinner.fail('K3s installation failed');
+        log.error(error.message);
+        log.info('Manual K3s installation:');
+        log.info('  curl -sfL https://get.k3s.io | sudo sh -');
+        log.info('  sudo systemctl enable --now k3s');
+        return false;
+    }
+}
+
 async function installColima() {
     if (platform !== 'darwin') {
         log.info('Colima is only needed on macOS - skipping');
@@ -149,6 +260,23 @@ async function installColima() {
 // KIND installation removed - using Colima's built-in Kubernetes
 
 async function installKubectl() {
+    // Linux with K3s already has kubectl
+    if (platform === 'linux') {
+                    try {
+            execSync('k3s kubectl version --client', { stdio: 'ignore' });
+            log.success('kubectl available via k3s');
+            // Create a symlink for convenience
+                        try {
+                execSync('sudo ln -sf /usr/local/bin/k3s /usr/local/bin/kubectl', { stdio: 'ignore' });
+            } catch {
+                // Link might already exist
+            }
+        return true;
+        } catch {
+            // Continue with regular kubectl installation
+    }
+}
+
     if (await checkCommand('kubectl')) {
         log.success('kubectl already installed');
         return true;
@@ -174,141 +302,286 @@ async function installKubectl() {
     }
 }
 
-async function installTribeCli() {
+async function installTribeCLI() {
     const spinner = ora('Installing TRIBE CLI...').start();
     
     try {
         const tribeDest = path.join(binDir, 'tribe');
         
-        // First check if we have a bundled binary
-        const bundledBinary = path.join(__dirname, 'tribe');
-        if (fs.existsSync(bundledBinary)) {
-            fs.copyFileSync(bundledBinary, tribeDest);
-            fs.chmodSync(tribeDest, '755');
-            spinner.succeed('TRIBE CLI installed from bundled binary');
-            return true;
-        }
-        
-        // Check if we have local source
-        const sourceFile = path.join(__dirname, 'cluster-cli.go');
-        if (fs.existsSync(sourceFile)) {
-            // Build from source
+        // Skip if already installed and working
+        if (fs.existsSync(tribeDest)) {
             try {
-                execSync('go version', { stdio: 'ignore' });
-                execSync(`cd ${__dirname} && go build -o tribe cluster-cli.go client.go`);
-                fs.copyFileSync(path.join(__dirname, 'tribe'), tribeDest);
-                fs.chmodSync(tribeDest, '755');
-                spinner.succeed('TRIBE CLI built from source');
+                execSync(`${tribeDest} version`, { stdio: 'ignore' });
+                spinner.succeed('TRIBE CLI already installed');
                 return true;
             } catch {
-                spinner.warn('Go not available, trying pre-built binary...');
+                // Binary exists but doesn't work, remove it
+                fs.unlinkSync(tribeDest);
             }
         }
         
-        // Try pre-built binary from GitHub
-        const tribeUrl = `https://github.com/0zen/0zen/releases/latest/download/tribe-${platform}-${arch}`;
+        // Download pre-built binary from GitHub
+        // Proper architecture detection for all platforms
+        let arch;
+        if (process.arch === 'x64' || process.arch === 'x86_64') {
+            arch = 'amd64';
+        } else if (process.arch === 'arm64' || process.arch === 'aarch64') {
+            arch = 'arm64';
+        } else {
+            arch = process.arch; // fallback
+        }
+        
+        const platform = os.platform();
+        
+        // Multiple sources for reliability
+        // For testing, use a direct URL to our releases folder
+        const isTestEnv = process.env.TRIBE_TEST_BINARY_URL;
+        const githubRepo = process.env.TRIBE_INSTALLER_REPO || 'TRIBE-INC/releases';
         
+        let downloadUrl = '';
+
         try {
-            await downloadFile(tribeUrl, tribeDest);
-            fs.chmodSync(tribeDest, '755');
-            spinner.succeed('TRIBE CLI installed');
-            return true;
-        } catch {
-            // Fallback: look for any existing tribe binary
-            const possiblePaths = [
-                path.join(__dirname, '..', 'tribe-cli'),
-                path.join(__dirname, '..', 'tribe'),
-                './tribe-cli',
-                './tribe'
-            ];
-            
-            for (const possiblePath of possiblePaths) {
-                if (fs.existsSync(possiblePath)) {
-                    fs.copyFileSync(possiblePath, tribeDest);
-                    fs.chmodSync(tribeDest, '755');
-                    spinner.succeed('TRIBE CLI installed from local binary');
-                    return true;
+            spinner.text = 'Fetching latest release information from GitHub...';
+            const response = await fetch(`https://api.github.com/repos/${githubRepo}/releases`);
+            if (!response.ok) {
+                throw new Error(`GitHub API returned ${response.status}`);
+            }
+            const releases = await response.json();
+            if (!releases || releases.length === 0) {
+                throw new Error('No releases found');
+            }
+            const latestRelease = releases[0];
+            const assetName = `tribe-${platform}-${arch}`;
+            const asset = latestRelease.assets.find(a => a.name === assetName);
+
+            if (!asset) {
+                throw new Error(`No binary found for ${platform}-${arch} in release ${latestRelease.tag_name}`);
+            }
+
+            downloadUrl = asset.browser_download_url;
+            spinner.text = `Found latest release: ${latestRelease.tag_name}`;
+        } catch (error) {
+            spinner.fail(`Failed to get release info: ${error.message}`);
+            // Fallback to other methods if the API fails
+        }
+
+        const sources = isTestEnv ? [isTestEnv] : [
+            downloadUrl,
+            // Public releases repository (primary source)
+            `https://raw.githubusercontent.com/${githubRepo}/main/cli/latest-tribe-${platform}-${arch}`,
+            // GitHub releases (fallback)
+            `https://github.com/${githubRepo}/releases/latest/download/tribe-${platform}-${arch}`,
+            // Try jsDelivr CDN (for better availability)
+            `https://cdn.jsdelivr.net/gh/${githubRepo}@main/cli/latest-tribe-${platform}-${arch}`,
+        ].filter(Boolean); // Filter out empty downloadUrl if API failed
+        
+        let downloaded = false;
+        let lastError;
+        
+        for (const url of sources) {
+            try {
+                let downloadUrl = url;
+                
+                // Check if this is the GitHub API endpoint
+                if (url.includes('/api.github.com/')) {
+                    spinner.text = 'Fetching latest release information from GitHub...';
+                    
+                    // Fetch release data
+                    const response = await fetch(url);
+                    if (!response.ok) {
+                        throw new Error(`GitHub API returned ${response.status}`);
+                    }
+                    
+                    const releaseData = await response.json();
+                    
+                    // Handle both single release and array of releases
+                    const release = Array.isArray(releaseData) ? releaseData[0] : releaseData;
+                    
+                    if (!release || !release.assets) {
+                        throw new Error('No release found');
+                    }
+                    
+                    const assetName = `tribe-${platform}-${arch}`;
+                    const asset = release.assets.find(a => a.name === assetName);
+                    
+                    if (!asset) {
+                        throw new Error(`No binary found for ${platform}-${arch}`);
+                    }
+                    
+                    downloadUrl = asset.browser_download_url;
+                    spinner.text = `Found ${release.prerelease ? 'pre-release' : 'release'}: ${release.tag_name}`;
+                }
+                
+                spinner.text = `Downloading TRIBE CLI from ${new URL(downloadUrl).hostname}...`;
+                await downloadFile(downloadUrl, tribeDest);
+                
+                // Check if file is not empty
+                const stats = fs.statSync(tribeDest);
+                if (stats.size === 0) {
+                    throw new Error('Downloaded file is empty');
+                }
+                
+                fs.chmodSync(tribeDest, '755');
+                
+                // Verify the binary works
+                try {
+                    execSync(`${tribeDest} version`, { stdio: 'ignore' });
+                } catch (versionError) {
+                    // If version fails, still consider it downloaded if file is valid
+                    log.warning('Binary downloaded but version check failed - may need different architecture');
                 }
+                
+                spinner.succeed('TRIBE CLI installed successfully');
+                downloaded = true;
+                break;
+            } catch (error) {
+                lastError = error;
+                // Clean up failed download
+                if (fs.existsSync(tribeDest)) {
+                    fs.unlinkSync(tribeDest);
+                }
+                log.warning(`Failed: ${error.message}. Trying next source...`);
             }
+        }
             
-            throw new Error('No TRIBE CLI binary available');
+        if (!downloaded) {
+            throw new Error(`Failed to download TRIBE CLI. Please check your internet connection and try again.
+
+If this persists, the binaries may not be available for your platform (${platform}-${arch}).
+Please visit https://tribecode.ai/support for assistance.`);
         }
+        
+        return true;
     } catch (error) {
         spinner.fail(`TRIBE CLI installation failed: ${error.message}`);
+        
+        // Show helpful support information
+        console.log('');
+        console.log(chalk.yellow('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+        console.log(chalk.yellow('Need help? Visit:'));
+        console.log(chalk.cyan.bold('  https://tribecode.ai/support'));
+        console.log('');
+        console.log(chalk.gray('You can also:'));
+        console.log(chalk.gray('  • Check system requirements'));
+        console.log(chalk.gray('  • View troubleshooting guides'));
+        console.log(chalk.gray('  • Contact our support team'));
+        console.log(chalk.yellow('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━'));
+        console.log('');
+        
         return false;
     }
 }
 
 async function startContainerRuntime() {
-    if (platform !== 'darwin') {
-        return true; // Linux uses Docker daemon directly
-    }
+    const spinner = ora('Starting container runtime...').start();
 
-    // Check if container runtime is already working
     try {
-        execSync('docker info', { stdio: 'ignore' });
-        log.success('Container runtime is already working');
-        return true;
-    } catch {
-        // Try to start Colima with different approaches
-        if (await checkCommand('colima')) {
-            const spinner = ora('Starting Colima container runtime...').start();
-            
+        // Platform-specific container runtime handling
+        if (platform === 'darwin') {
+            // macOS - Check if Colima is running
             try {
-                // Strategy 1: Quick start with minimal resources and Kubernetes
-                spinner.text = 'Starting Colima with Kubernetes...';
-                const colimaPath = 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;
+                const colimaStatus = execSync('colima status 2>&1', { encoding: 'utf8' });
+                if (colimaStatus.includes('is running')) {
+                    spinner.succeed('Colima is already running');
+                    return true;
+                }
+            } catch {
+                // Colima not running, need to start it
+            }
+            
+            // Try to start Colima
+            if (await checkCommand('colima')) {
+                const spinner = ora('Starting Colima container runtime...').start();
                 
-            } catch (error) {
-                // Strategy 2: Start in background with Kubernetes
                 try {
-                    spinner.text = 'Starting Colima with Kubernetes in background...';
+                    // 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');
+                return true;
+            } catch {
+                // Try to start K3s
+                spinner.text = 'Starting K3s...';
+                try {
+                    execSync('sudo systemctl start k3s', { stdio: 'ignore' });
+                    await new Promise(resolve => setTimeout(resolve, 5000));
+                    spinner.succeed('K3s started');
+                    return true;
+                } catch (error) {
+                    spinner.warn('K3s not available - requires systemd');
+                    log.info('K3s requires systemd. Install K3s manually or use KIND/external cluster');
+                    return true; // Don't fail
+                }
+            }
+        } else if (platform === 'win32') {
+            spinner.fail('Windows support coming soon!');
+            log.info('For Windows, please use WSL2 with Ubuntu and run this installer inside WSL2');
+            return false;
+        } else {
+            spinner.fail(`Unsupported platform: ${platform}`);
+    return false;
         }
+    } catch (error) {
+        spinner.fail(`Container runtime error: ${error.message}`);
+        return false;
     }
-    return false;
 }
 
 async function updatePath() {
@@ -332,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) {
@@ -344,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();
@@ -412,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...';
                 
@@ -488,6 +872,32 @@ async function deployTribeCluster() {
         if (fs.existsSync(sourceYaml)) {
             fs.copyFileSync(sourceYaml, destYaml);
             log.info('Copied deployment configuration');
+        } else {
+            // Download deployment YAML if not bundled
+            spinner.text = 'Downloading deployment configuration...';
+            const yamlSources = [
+                // Direct from GitHub (primary)
+                'https://raw.githubusercontent.com/TRIBE-INC/0zen/main/sdk/cmd/cli-gui/package/tribe-deployment.yaml',
+                // jsDelivr CDN as fallback
+                'https://cdn.jsdelivr.net/gh/TRIBE-INC/0zen@main/sdk/cmd/cli-gui/package/tribe-deployment.yaml'
+            ];
+            
+            let yamlDownloaded = false;
+            for (const yamlUrl of yamlSources) {
+                try {
+                    await downloadFile(yamlUrl, destYaml);
+                    log.info('Downloaded deployment configuration');
+                    yamlDownloaded = true;
+                    break;
+                } catch (downloadError) {
+                    // Try next source
+                }
+            }
+            
+            if (!yamlDownloaded) {
+                spinner.fail('Failed to get deployment configuration');
+                throw new Error('Could not download deployment YAML from any source');
+            }
         }
         
         // Run tribe start command with deployment YAML path
@@ -626,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'));
@@ -655,20 +1072,124 @@ 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 displayArch = process.arch === 'x64' ? 'amd64' : process.arch;
+    console.log(chalk.cyan(`Platform: ${platform} (${displayArch})`));
+    console.log(chalk.cyan(`Node: ${process.version}`));
+    console.log('');
+    
+    // Check for unsupported platforms early
+    if (platform === 'win32') {
+        console.log(chalk.yellow('\n⚠️  Windows is not yet supported'));
+        console.log(chalk.yellow('Please use WSL2 with Ubuntu and run this installer inside WSL2'));
+        console.log(chalk.yellow('Instructions: https://docs.microsoft.com/en-us/windows/wsl/install\n'));
+        process.exit(1);
+    }
+    
+    // Edge case detection
+    // 1. Check for unsupported architectures
+    const supportedArchitectures = ['x64', 'x86_64', 'arm64', 'aarch64'];
+    if (!supportedArchitectures.includes(nodeArch)) {
+        console.log(chalk.red('\n❌ Unsupported Architecture'));
+        console.log(chalk.red(`Your system architecture (${nodeArch}) is not supported.`));
+        console.log(chalk.yellow('TRIBE only provides binaries for x64 (AMD64) and ARM64.\n'));
+        process.exit(1);
+    }
+    
+    // 2. WSL2 detection
+    if (fs.existsSync('/proc/sys/fs/binfmt_misc/WSLInterop') || process.env.WSL_DISTRO_NAME) {
+        console.log(chalk.yellow('\n⚠️  WSL2 Environment Detected'));
+        console.log(chalk.yellow('K3s may have networking limitations in WSL2.'));
+        console.log(chalk.yellow('Consider using Docker Desktop with WSL2 backend instead.\n'));
+        // Don't exit, just warn
+    }
+    
+    // 3. Proxy detection
+    const proxyUrl = process.env.HTTPS_PROXY || process.env.https_proxy || process.env.HTTP_PROXY || process.env.http_proxy;
+    if (proxyUrl) {
+        console.log(chalk.blue('ℹ️  Proxy detected: ' + proxyUrl));
+        console.log(chalk.blue('Downloads will use system proxy settings.\n'));
+    }
+    
+    // 4. Check for existing Kubernetes installations
+    const k8sTools = [];
+    const checkTools = ['minikube', 'microk8s', 'kind', 'k3d', 'kubectl'];
+    for (const tool of checkTools) {
+        try {
+            execSync(`which ${tool}`, { stdio: 'ignore' });
+            k8sTools.push(tool);
+        } catch {}
+    }
+    
+    if (k8sTools.length > 0) {
+        console.log(chalk.blue('\n📦 Existing Kubernetes tools detected: ' + k8sTools.join(', ')));
+        console.log(chalk.blue('You can use --skip-cluster to skip K3s installation.\n'));
+    }
+    
+    // 5. Disk space check
+    try {
+        const stats = fs.statfsSync(homeDir);
+        const freeGB = (stats.bavail * stats.bsize) / (1024 ** 3);
+        if (freeGB < 3) {
+            console.log(chalk.yellow(`\n⚠️  Low disk space: ${freeGB.toFixed(1)}GB free`));
+            console.log(chalk.yellow('K3s installation requires at least 3GB of free space.\n'));
+        }
+    } catch {}
+    
+    // Clean up old installations
+    await cleanupOldInstallations();
+    
     log.info(`Detected: ${platform} (${arch})`);
     log.info(`Installing to: ${binDir}`);
     
     // Update PATH first
     await updatePath();
     
-    const tasks = [
-        { name: 'Colima', fn: installColima },
+    // Update shell configuration files
+    await updateShellConfig();
+    
+    const tasks = [];
+    
+    // Platform-specific Kubernetes installation
+    if (platform === 'darwin') {
+        tasks.push({ name: 'Colima', fn: installColima });
+    } else if (platform === 'linux') {
+        tasks.push({ name: 'K3s', fn: installK3s });
+    }
+    
+    // Common tools for all platforms
+    tasks.push(
         { name: 'kubectl', fn: installKubectl },
-        { name: 'TRIBE CLI', fn: installTribeCli }
-    ];
+        { name: 'TRIBE CLI', fn: installTribeCLI }
+    );
     
     let allSuccess = true;
     
@@ -688,7 +1209,7 @@ async function main() {
         // Check if cluster already exists
         const clusterExists = await checkClusterExists();
         
-        if (!clusterExists) {
+        if (!clusterExists && !global.skipCluster) {
             // Prompt for cluster setup
             const shouldSetup = await promptForClusterSetup();
             
@@ -764,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');
@@ -792,13 +1326,24 @@ if (require.main === module) {
     
     if (args.includes('--help') || args.includes('-h')) {
         console.log(chalk.bold.blue('TRIBE CLI Installer\n'));
-        console.log('Usage: npx tribe-cli-local [options]\n');
+        console.log('Usage: npx @_xtribe/cli [options]\n');
         console.log('Options:');
         console.log('  --help, -h     Show this help message');
         console.log('  --verify       Only verify existing installation');
         console.log('  --dry-run      Show what would be installed');
-                console.log('\nThis installer sets up the complete TRIBE development environment:');
-        console.log('• Colima (Container runtime with Kubernetes)');
+        console.log('  --skip-cluster Skip cluster deployment (for testing)');
+        console.log('\nThis installer sets up the complete TRIBE development environment:');
+        
+        if (platform === 'darwin') {
+            console.log('• Colima (Container runtime with Kubernetes)');
+        } else if (platform === 'linux') {
+            console.log('• K3s (Lightweight Kubernetes, one-line install)');
+        } else if (platform === 'win32') {
+            console.log('\n⚠️  Windows support coming soon!');
+            console.log('Please use WSL2 with Ubuntu and run this installer inside WSL2');
+            process.exit(1);
+        }
+        
         console.log('• kubectl (Kubernetes CLI)');
         console.log('• TRIBE CLI (Multi-agent orchestration)');
         console.log('\nAfter installation:');
@@ -826,6 +1371,9 @@ if (require.main === module) {
         process.exit(0);
     }
     
+    // Store skip-cluster flag
+    global.skipCluster = args.includes('--skip-cluster');
+    
     main().catch(error => {
         console.error(chalk.red('Installation failed:'), error.message);
         process.exit(1);