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

package/install-tribe.js

@@ -18,6 +18,7 @@ const arch = nodeArch === 'x64' ? 'amd64' : (nodeArch === '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)) {
@@ -29,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),
@@ -302,21 +308,160 @@ 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
             }
         }
         
@@ -584,114 +729,11 @@ 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() { ... }
 
-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`);
-    }
-}
+// Shell config updates no longer needed - using npm global installation
+// async function updateShellConfig() { ... }
 
 async function verifyInstallation() {
     const spinner = ora('Verifying installation...').start();
@@ -902,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 = {
@@ -1097,6 +1139,111 @@ async function cleanupOldInstallations() {
     });
 }
 
+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'));
     
@@ -1168,13 +1315,9 @@ async function main() {
     await cleanupOldInstallations();
     
     log.info(`Detected: ${platform} (${arch})`);
-    log.info(`Installing to: ${binDir}`);
-    
-    // Update PATH first
-    await updatePath();
+    log.info(`Installing to: ${tribeBinDir}`);
     
-    // Update shell configuration files
-    await updateShellConfig();
+    // No longer updating PATH - will use npm global install instead
     
     const tasks = [];
     
@@ -1188,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;
@@ -1235,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 {
@@ -1265,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:'));
@@ -1332,6 +1468,7 @@ if (require.main === module) {
         console.log('  --verify       Only verify existing installation');
         console.log('  --dry-run      Show what would be installed');
         console.log('  --skip-cluster Skip cluster deployment (for testing)');
+        console.log('  --force        Force clean installation (removes existing installations)');
         console.log('\nThis installer sets up the complete TRIBE development environment:');
         
         if (platform === 'darwin') {
@@ -1374,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.25",
+  "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"
   },