@_xtribe/cli 1.0.9 → 1.0.11

package/install-tribe.js

@@ -5,6 +5,7 @@ const fs = require('fs');
 const path = require('path');
 const https = require('https');
 const { execSync, spawn } = require('child_process');
+const readline = require('readline');
 const chalk = require('chalk');
 const ora = require('ora');
 const which = require('which');
@@ -46,6 +47,32 @@ async function checkCommand(cmd) {
         await which(cmd);
         return true;
     } catch {
+        // If not in PATH, check our install locations
+        if (cmd === 'tribe') {
+            const tribePath = path.join(tribeBinDir, 'tribe');
+            try {
+                await fs.promises.access(tribePath, fs.constants.X_OK);
+                return true;
+            } catch {
+                return false;
+            }
+        } else if (cmd === 'kubectl') {
+            const kubectlPath = path.join(binDir, 'kubectl');
+            try {
+                await fs.promises.access(kubectlPath, fs.constants.X_OK);
+                return true;
+            } catch {
+                return false;
+            }
+        } else if (cmd === 'colima') {
+            const colimaPath = path.join(binDir, 'colima');
+            try {
+                await fs.promises.access(colimaPath, fs.constants.X_OK);
+                return true;
+            } catch {
+                return false;
+            }
+        }
         return false;
     }
 }
@@ -156,7 +183,7 @@ async function installK3s() {
         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');
+            log.info('For containers, consider using an external cluster');
             return true; // Don't fail in containers
         }
         
@@ -274,7 +301,6 @@ async function installColima() {
 
 // Lima installation removed - Colima handles virtualization
 
-// KIND installation removed - using Colima's built-in Kubernetes
 
 async function installKubectl() {
     // Linux with K3s already has kubectl
@@ -319,6 +345,53 @@ async function installKubectl() {
     }
 }
 
+async function setupPathEnvironment() {
+    const spinner = ora('Setting up PATH environment...').start();
+    
+    try {
+        // Copy the tribe-env.sh script to ~/.tribe/
+        const envScriptSource = path.join(__dirname, 'tribe-env.sh');
+        const envScriptDest = path.join(tribeBinDir, '..', 'tribe-env.sh');
+        
+        // Create the environment script content
+        const envScriptContent = `#!/bin/bash
+# TRIBE CLI Environment Setup
+# 
+# To use this, add the following line to your shell config:
+#   source ~/.tribe/tribe-env.sh
+#
+# Or run it manually in your current session:
+#   source ~/.tribe/tribe-env.sh
+
+# Add TRIBE bin directory to PATH if not already present
+TRIBE_BIN_DIR="$HOME/.tribe/bin"
+
+if [[ -d "$TRIBE_BIN_DIR" ]] && [[ ":$PATH:" != *":$TRIBE_BIN_DIR:"* ]]; then
+    export PATH="$TRIBE_BIN_DIR:$PATH"
+fi
+
+# Optional: Add helpful aliases
+alias tribe-logs="$TRIBE_BIN_DIR/tribe-logs" 2>/dev/null || true
+
+# Verify tribe is available (silent check)
+command -v tribe &> /dev/null || true
+`;
+        
+        fs.writeFileSync(envScriptDest, envScriptContent);
+        fs.chmodSync(envScriptDest, '755');
+        
+        spinner.succeed('PATH environment script created');
+        
+        // Store that we created the env script
+        global.envScriptCreated = true;
+        
+        return true;
+    } catch (error) {
+        spinner.fail(`Failed to create PATH environment script: ${error.message}`);
+        return false;
+    }
+}
+
 async function setupGlobalNpmCommand() {
     const spinner = ora('Setting up global tribe command...').start();
     
@@ -546,7 +619,7 @@ async function installTribeCLI() {
         // 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';
+        const githubRepo = process.env.TRIBE_INSTALLER_REPO || 'TRIBE-INC/0zen';
         
         let downloadUrl = '';
 
@@ -583,6 +656,10 @@ async function installTribeCLI() {
             downloadUrl,
             // GitHub releases direct download (fallback if API fails)
             `https://github.com/${githubRepo}/releases/latest/download/tribe-${platform}-${arch}`,
+            // GitHub raw content as emergency fallback
+            `https://raw.githubusercontent.com/${githubRepo}/main/releases/tribe-${platform}-${arch}`,
+            // jsdelivr CDN (mirrors GitHub)
+            `https://cdn.jsdelivr.net/gh/${githubRepo}@latest/releases/tribe-${platform}-${arch}`,
             // Local build if available
             ...(hasLocalBuild ? [`file://${localBuildPath}`] : [])
         ].filter(Boolean); // Filter out empty downloadUrl if API failed
@@ -642,6 +719,16 @@ async function installTribeCLI() {
                 
                 fs.chmodSync(tribeDest, '755');
                 
+                // Remove macOS quarantine attribute
+                if (platform === 'darwin') {
+                    try {
+                        execSync(`xattr -d com.apple.quarantine "${tribeDest}" 2>/dev/null`, { stdio: 'ignore' });
+                        log.info('Removed macOS quarantine attribute');
+                    } catch {
+                        // Not critical if this fails
+                    }
+                }
+                
                 // Verify the binary works
                 try {
                     // Try version command first
@@ -724,58 +811,22 @@ async function startContainerRuntime() {
                 // Colima not running, need to start it
             }
             
-            // Try to start Colima
+            // Don't try to start Colima automatically - it takes too long
             if (await checkCommand('colima')) {
-                const spinner = ora('Starting Colima container runtime...').start();
-                
-                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
-                    });
-                    
-                    spinner.succeed('Colima started successfully');
-                    return true;
-                    
-                } 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;
-                    }
-                }
+                spinner.stop(); // Stop the spinner before showing info
+                console.log('');
+                console.log(chalk.yellow('  ⚠️  Colima needs to be started before using TRIBE'));
+                console.log(chalk.gray('  To start Colima with Kubernetes:'));
+                console.log(chalk.cyan('    colima start --kubernetes'));
+                console.log(chalk.gray('  This may take 2-5 minutes on first run'));
+                console.log('');
+                return true; // Return true since it's installed
+            } else {
+                spinner.warn('Colima not found');
+                return false;
             }
         } else if (platform === 'linux') {
-            // Linux - K3s should already be running
+            // Linux - Check K3s status but don't try to start it
             spinner.text = 'Checking K3s status...';
             
             // Check if we're in a container (no systemd)
@@ -783,27 +834,23 @@ async function startContainerRuntime() {
             
             if (isContainer) {
                 spinner.info('Running in container - K3s requires systemd');
-                log.info('For containers, use KIND or connect to external cluster');
+                log.info('For containers, connect to an external cluster');
                 return true; // Don't fail
             }
             
             try {
-                execSync('sudo systemctl is-active --quiet k3s', { stdio: 'ignore' });
+                execSync('sudo systemctl is-active --quiet k3s', { stdio: 'ignore', timeout: 5000 });
                 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
-                }
+                // Don't try to start K3s - just inform the user
+                spinner.info('K3s is not running');
+                console.log('');
+                console.log(chalk.yellow('  ⚠️  K3s needs to be started'));
+                console.log(chalk.gray('  To start K3s:'));
+                console.log(chalk.cyan('    sudo systemctl start k3s'));
+                console.log('');
+                return true; // Don't fail
             }
         } else if (platform === 'win32') {
             spinner.fail('Windows support coming soon!');
@@ -863,10 +910,26 @@ async function verifyInstallation() {
     spinner.stop();
     
     console.log('\n' + chalk.bold('Installation Summary:'));
-    tools.forEach(tool => {
+    for (const tool of tools) {
         const status = results[tool] ? chalk.green('✓') : chalk.red('✗');
-        console.log(`${status} ${tool}`);
-    });
+        let message = `${status} ${tool}`;
+        
+        // Add additional info for tribe if it's installed but not in PATH
+        if (tool === 'tribe' && results[tool]) {
+            try {
+                await which('tribe');
+                // It's in PATH, no extra message needed
+            } catch {
+                // It's installed but not in PATH
+                message += chalk.gray(' (installed at ~/.tribe/bin/tribe)');
+                if (global.envScriptCreated) {
+                    message += chalk.yellow('\n    Run: source ~/.tribe/tribe-env.sh');
+                }
+            }
+        }
+        
+        console.log(message);
+    }
     
     const extraStatus = containerWorking ? chalk.green('✓') : chalk.yellow('⚠');
     console.log(`${extraStatus} Container runtime`);
@@ -1174,6 +1237,21 @@ async function deployTribeCluster() {
     }
 }
 
+async function promptForPathSetup() {
+    return new Promise((resolve) => {
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+        
+        console.log('');
+        rl.question(chalk.yellow('Would you like to add "tribe" to your PATH? (y/n) '), (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
+        });
+    });
+}
+
 async function promptForClusterSetup() {
     // Check for auto-approve in CI environments
     if (process.env.CI === 'true' || process.env.TRIBE_AUTO_APPROVE === 'true') {
@@ -1378,7 +1456,7 @@ async function main() {
     
     // 4. Check for existing Kubernetes installations
     const k8sTools = [];
-    const checkTools = ['minikube', 'microk8s', 'kind', 'k3d', 'kubectl'];
+    const checkTools = ['minikube', 'microk8s', 'k3d', 'kubectl'];
     for (const tool of checkTools) {
         try {
             execSync(`which ${tool}`, { stdio: 'ignore' });
@@ -1422,7 +1500,8 @@ async function main() {
     tasks.push(
         { name: 'kubectl', fn: installKubectl },
         { name: 'TRIBE CLI', fn: installTribeCLI },
-        { name: 'Global tribe command', fn: setupGlobalNpmCommand }
+        { name: 'PATH environment', fn: setupPathEnvironment }
+        // We'll try npm global as a fallback, but not as primary method
     );
     
     let allSuccess = true;
@@ -1430,15 +1509,20 @@ async function main() {
     for (const task of tasks) {
         log.step(`Installing ${task.name}...`);
         const success = await task.fn();
-        if (!success) allSuccess = false;
+        if (!success) {
+            allSuccess = false;
+            if (task.name === 'PATH environment') {
+                global.envScriptCreated = false;
+            }
+        }
     }
     
-    // Try to start container runtime
-    await startContainerRuntime();
-    
-    // Verify everything
+    // Verify everything first
     const verified = await verifyInstallation();
     
+    // Try to start container runtime (after showing results)
+    await startContainerRuntime();
+    
     if (verified) {
         // Check if cluster already exists
         const clusterExists = await checkClusterExists();
@@ -1468,11 +1552,47 @@ async function main() {
                     console.log('\n' + chalk.bold.green('✨ TRIBE is ready!'));
                     console.log('');
                     
+                    // Offer to set up PATH
+                    if (global.envScriptCreated && !process.env.CI && !process.env.TRIBE_SKIP_PATH_PROMPT) {
+                        const shouldSetupPath = await promptForPathSetup();
+                        if (shouldSetupPath) {
+                            // Run the setup-path logic inline
+                            try {
+                                const setupPath = require('./setup-path.js');
+                                setupPath();
+                                console.log('');
+                                // PATH is now set up, update instructions
+                                global.pathSetupComplete = true;
+                            } catch (error) {
+                                log.warning('Could not automatically set up PATH');
+                            }
+                        }
+                    }
+                    
                     // Provide immediate access to tribe command
-                    log.info('TRIBE command is now available globally!');
-                    console.log(chalk.green('  tribe              # Run from anywhere'));
-                    console.log(chalk.gray('  tribe --help       # View available commands'));
-                    console.log(chalk.gray('  tribe status       # Check cluster status'));
+                    if (global.pathSetupComplete) {
+                        log.info('TRIBE is now in your PATH!');
+                        console.log('');
+                        console.log(chalk.bold('To start using tribe:'));
+                        console.log(chalk.green('  source ~/.tribe/tribe-env.sh  # For current session'));
+                        console.log(chalk.green('  tribe                         # In new terminal'));
+                    } else if (global.envScriptCreated) {
+                        log.info('TRIBE command is installed!');
+                        console.log('');
+                        console.log(chalk.bold('To add "tribe" to your PATH:'));
+                        console.log(chalk.green('  npx @_xtribe/cli setup-path'));
+                        console.log('');
+                        console.log(chalk.bold('Or for this session only:'));
+                        console.log(chalk.green('  source ~/.tribe/tribe-env.sh'));
+                        console.log('');
+                        console.log(chalk.bold('Or use the full path:'));
+                        console.log(chalk.green('  ~/.tribe/bin/tribe'));
+                    } else {
+                        log.info('TRIBE command is installed!');
+                        console.log(chalk.green('  ~/.tribe/bin/tribe              # Run TRIBE'));
+                        console.log(chalk.gray('  ~/.tribe/bin/tribe --help       # View available commands'));
+                        console.log(chalk.gray('  ~/.tribe/bin/tribe status       # Check cluster status'));
+                    }
                     console.log('');
                     
                     log.info('Quick start:');
@@ -1496,8 +1616,18 @@ async function main() {
             console.log('');
             
             // Provide immediate access to tribe command
-            log.info('TRIBE command is now available globally!');
-            console.log(chalk.green('  tribe              # Run from anywhere'));
+            if (global.envScriptCreated) {
+                log.info('TRIBE command is installed!');
+                console.log('');
+                console.log(chalk.bold('To use "tribe" command from anywhere:'));
+                console.log(chalk.green('  source ~/.tribe/tribe-env.sh'));
+                console.log('');
+                console.log(chalk.bold('Or you can use the full path:'));
+                console.log(chalk.green('  ~/.tribe/bin/tribe              # Run TRIBE'));
+            } else {
+                log.info('TRIBE command is installed!');
+                console.log(chalk.green('  ~/.tribe/bin/tribe              # Run TRIBE'));
+            }
             console.log('');
             
             log.info('Commands:');

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@_xtribe/cli",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "description": "TRIBE multi-agent development system - Zero to productive with one command",
   "main": "install-tribe.js",
   "bin": {
-    "install-tribe": "./install-tribe.js"
+    "install-tribe": "./install-tribe.js",
+    "setup-path": "./setup-path.js"
   },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
@@ -35,6 +36,7 @@
   },
   "files": [
     "install-tribe.js",
+    "setup-path.js",
     "README.md",
     "package.json"
   ],

package/setup-path.js

@@ -0,0 +1,105 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const chalk = require('chalk');
+
+const homeDir = os.homedir();
+const tribeEnvPath = path.join(homeDir, '.tribe', 'tribe-env.sh');
+
+// Detect user's shell
+function detectShell() {
+    const shell = process.env.SHELL || '';
+    if (shell.includes('zsh')) return 'zsh';
+    if (shell.includes('bash')) return 'bash';
+    if (shell.includes('fish')) return 'fish';
+    return 'unknown';
+}
+
+// Get shell config file
+function getShellConfigFile() {
+    const shell = detectShell();
+    const configFiles = {
+        'zsh': ['.zshrc', '.zprofile'],
+        'bash': ['.bashrc', '.bash_profile', '.profile'],
+        'fish': ['.config/fish/config.fish']
+    };
+    
+    const candidates = configFiles[shell] || [];
+    
+    // Check which config file exists
+    for (const file of candidates) {
+        const fullPath = path.join(homeDir, file);
+        if (fs.existsSync(fullPath)) {
+            return fullPath;
+        }
+    }
+    
+    // If none exist, use the first candidate
+    if (candidates.length > 0) {
+        return path.join(homeDir, candidates[0]);
+    }
+    
+    return null;
+}
+
+function setupPath() {
+    console.log(chalk.bold('🔧 TRIBE PATH Setup\n'));
+    
+    // Check if tribe-env.sh exists
+    if (!fs.existsSync(tribeEnvPath)) {
+        console.log(chalk.red('Error: TRIBE environment script not found.'));
+        console.log('Please run the installer first: npx @_xtribe/cli');
+        process.exit(1);
+    }
+    
+    const shellConfig = getShellConfigFile();
+    const shell = detectShell();
+    
+    if (!shellConfig) {
+        console.log(chalk.yellow('Could not detect shell configuration file.'));
+        console.log('\nPlease manually add this line to your shell config:');
+        console.log(chalk.green(`  source ~/.tribe/tribe-env.sh`));
+        return;
+    }
+    
+    // Check if already added
+    try {
+        const content = fs.readFileSync(shellConfig, 'utf8');
+        if (content.includes('source ~/.tribe/tribe-env.sh') || 
+            content.includes('source $HOME/.tribe/tribe-env.sh') ||
+            content.includes('. ~/.tribe/tribe-env.sh')) {
+            console.log(chalk.green('✓ PATH already configured!'));
+            console.log('\nTo use tribe in your current session:');
+            console.log(chalk.green(`  source ~/.tribe/tribe-env.sh`));
+            return;
+        }
+    } catch (e) {
+        // File doesn't exist yet, that's ok
+    }
+    
+    // Add to shell config
+    const sourceCommand = '\n# TRIBE CLI\nsource ~/.tribe/tribe-env.sh\n';
+    
+    try {
+        fs.appendFileSync(shellConfig, sourceCommand);
+        console.log(chalk.green(`✓ Added TRIBE to your ${shell} configuration!`));
+        console.log(`  Configuration file: ${shellConfig}`);
+        console.log('\nTo use tribe in your current session:');
+        console.log(chalk.green(`  source ~/.tribe/tribe-env.sh`));
+        console.log('\nOr open a new terminal window.');
+    } catch (error) {
+        console.log(chalk.red(`Error updating ${shellConfig}: ${error.message}`));
+        console.log('\nPlease manually add this line to your shell config:');
+        console.log(chalk.green(`  source ~/.tribe/tribe-env.sh`));
+    }
+}
+
+// Export for use by other modules
+module.exports = setupPath;
+
+// Add to package.json bin entry
+if (require.main === module) {
+    setupPath();
+}