@_xtribe/cli 2.0.3 → 2.0.4

package/install-tribe.js

@@ -639,13 +639,30 @@ 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 testBinary = process.env.TRIBE_TEST_BINARY;
         const githubRepo = process.env.TRIBE_INSTALLER_REPO || 'TRIBE-INC/releases';
         
+        // If we have a test binary file, use it directly
+        if (testBinary && fs.existsSync(testBinary)) {
+            spinner.text = 'Using test binary...';
+            fs.copyFileSync(testBinary, tribeDest);
+            fs.chmodSync(tribeDest, '755');
+            spinner.succeed('✓ TRIBE CLI installed from test binary');
+            return true;
+        }
+        
         let downloadUrl = '';
 
         try {
-            spinner.text = 'Fetching latest release information from GitHub...';
-            const response = await fetch(`https://api.github.com/repos/${githubRepo}/releases`);
+            const versionChannel = global.versionChannel || 'latest';
+            spinner.text = `Fetching ${versionChannel} release information from GitHub...`;
+            const response = await fetch(`https://api.github.com/repos/${githubRepo}/releases`, {
+                headers: {
+                    'User-Agent': 'TRIBE-Installer',
+                    // Add token if available in environment
+                    ...(process.env.GITHUB_TOKEN ? { 'Authorization': `token ${process.env.GITHUB_TOKEN}` } : {})
+                }
+            });
             if (!response.ok) {
                 throw new Error(`GitHub API returned ${response.status}`);
             }
@@ -653,23 +670,75 @@ async function installTribeCLI() {
             if (!releases || releases.length === 0) {
                 throw new Error('No releases found');
             }
-            const latestRelease = releases[0];
+            
+            // Filter releases based on version channel
+            let filteredReleases = releases.filter(r => !r.draft);
+            
+            if (versionChannel === 'beta') {
+                // For beta, look for releases with 'beta' in tag name
+                filteredReleases = filteredReleases.filter(r => r.tag_name.includes('beta'));
+                spinner.text = 'Looking for beta releases...';
+            } else if (versionChannel === 'latest') {
+                // For latest, exclude beta releases
+                filteredReleases = filteredReleases.filter(r => !r.tag_name.includes('beta'));
+                spinner.text = 'Looking for stable releases...';
+            } else {
+                // For specific version, look for exact match
+                filteredReleases = filteredReleases.filter(r => r.tag_name === versionChannel);
+                spinner.text = `Looking for version ${versionChannel}...`;
+            }
+            
+            if (filteredReleases.length === 0) {
+                throw new Error(`No releases found for channel: ${versionChannel}`);
+            }
+            
+            // Find a release with the binary we need
+            let foundRelease = null;
             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}`);
+            
+            for (const release of filteredReleases) {
+                const asset = release.assets?.find(a => a.name === assetName || a.name === `${assetName}.exe`);
+                if (asset) {
+                    foundRelease = release;
+                    downloadUrl = asset.browser_download_url;
+                    spinner.text = `Found binary in ${versionChannel} release: ${release.tag_name}`;
+                    break;
+                }
+            }
+            
+            if (!foundRelease) {
+                // No release has the binary, try constructing URL from first filtered release
+                const firstRelease = filteredReleases[0];
+                if (firstRelease) {
+                    downloadUrl = `https://github.com/${githubRepo}/releases/download/${firstRelease.tag_name}/tribe-${platform}-${arch}`;
+                    spinner.text = `Trying ${versionChannel} release: ${firstRelease.tag_name}`;
+                } else {
+                    throw new Error(`No suitable release found for channel: ${versionChannel}`);
+                }
             }
-
-            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
+            log.warning(`Failed to get release info: ${error.message}`);
+            // Try to get the latest release tag directly
+            try {
+                const tagResponse = await fetch(`https://api.github.com/repos/${githubRepo}/releases`, {
+                    headers: { 'User-Agent': 'TRIBE-Installer' }
+                });
+                if (tagResponse.ok) {
+                    const releases = await tagResponse.json();
+                    if (releases && releases.length > 0) {
+                        const tag = releases[0].tag_name;
+                        // Construct direct download URL
+                        downloadUrl = `https://github.com/${githubRepo}/releases/download/${tag}/tribe-${platform}-${arch}`;
+                        spinner.text = `Using direct download for release: ${tag}`;
+                    }
+                }
+            } catch (e) {
+                // Ignore and use fallback URLs
+            }
         }
 
-        // Check if there's a local build available
-        const localBuildPath = path.join(__dirname, '..', '..', '..', 'sdk', 'cmd', 'cli-gui', 'tribe');
+        // Check if there's a local build available (use tribe-new, not cli-gui)
+        const localBuildPath = path.join(__dirname, '..', '..', '..', 'sdk', 'cmd', 'tribe-new', 'tribe');
         const hasLocalBuild = fs.existsSync(localBuildPath);
         
         const sources = isTestEnv ? [isTestEnv] : [
@@ -993,6 +1062,9 @@ async function verifyInstallation() {
         results[tool] = await checkCommand(tool);
     }
     
+    // Store results globally for later use
+    global.installationChecks = results;
+    
     // Special check for container runtime
     let containerWorking = false;
     if (platform === 'darwin') {
@@ -1523,6 +1595,17 @@ async function forceCleanInstallation() {
         log.info('npm cache clean attempted (may have failed, which is okay)');
     }
     
+    // Remove first-install marker to allow auto-launch
+    const firstInstallMarker = path.join(tribeDir, '.first-install-complete');
+    if (fs.existsSync(firstInstallMarker)) {
+        try {
+            fs.unlinkSync(firstInstallMarker);
+            log.success('Removed first-install marker');
+        } catch (error) {
+            log.warning(`Could not remove first-install marker: ${error.message}`);
+        }
+    }
+    
     // Platform-specific cleanup
     if (platform === 'darwin') {
         // Check if Colima is running and stop it
@@ -1554,29 +1637,12 @@ async function forceCleanInstallation() {
 }
 
 async function main() {
-    // Fire-themed ASCII art with modern Unicode design
-    console.log('');
-    console.log(chalk.red(`     ░▒▓█▓▒░      ░▒▓█▓▒░`) + chalk.yellow(`      ░▒▓`) + chalk.red(`      `)              + chalk.yellow(`     ▓▒░         `) + chalk.red(`░▒▓█▓▒░`));
-    console.log(chalk.red(`   ░▒▓█████▓▒░  ░▒▓█████▓▒░`) + chalk.yellow(`  ░▒▓██`) + chalk.red(`    `)            + chalk.yellow(` ▓██▓▒░       `) + chalk.red(`░▒▓█████▓▒░`));
-    console.log(chalk.red(`     ░▒▓█▓▒░    ░▒▓█▓▒░▒▓█▓▒░`) + chalk.yellow(`░▒▓██`) + chalk.red(`  `)          + chalk.yellow(`▓██▓▒░      `) + chalk.red(`░▒▓█▓▒░░▒▓█▓▒░`));
-    console.log(chalk.red(`     ░▒▓█▓▒░    ░▒▓█▓▒░░▒▓█▓▒░`) + chalk.yellow(` ░▒▓██`) + chalk.red(``)        + chalk.yellow(`▓██▓▒░     `) + chalk.red(`░▒▓█▓▒░  ░▒▓█▓▒░`));
-    console.log(chalk.red(`     ░▒▓█▓▒░    ░▒▓█▓▒░ ░▒▓█▓▒░`) + chalk.yellow(`  ░▒▓██`) + chalk.red(``)      + chalk.yellow(`██▓▒░    `) + chalk.red(`░▒▓█▓▒░    ░▒▓█▓▒░`));
-    console.log(chalk.red(`     ░▒▓█▓▒░    ░▒▓█▓▒░  ░▒▓█▓▒░`) + chalk.yellow(`   ░▒▓`) + chalk.red(`██`)  + chalk.yellow(`▓▒░   `) + chalk.red(`░▒▓█▓▒░      ░▒▓█▓▒░`));
-    console.log(chalk.red(`     ░▒▓█▓▒░    ░▒▓█▓▒░   ░▒▓█▓▒░`) + chalk.yellow(`    ░▒`) + chalk.red(`▓`) + chalk.yellow(`▒░  `) + chalk.red(`░▒▓█▓▒░░▒▓█▓▒░░▒▓█▓▒░`));
-    console.log(chalk.red(`     ░▒▓█▓▒░    ░▒▓█▓▒░    ░▒▓█▓▒░`) + chalk.yellow(`     `) + chalk.red(`░`) + chalk.yellow(` `) + chalk.red(`░▒▓█▓▒░  ░▒▓█████▓▒░`));
-    console.log(chalk.red(`     ░▒▓█▓▒░    ░▒▓█▓▒░     ░▒▓█▓▒░`) + chalk.yellow(`    `) + chalk.red(`░▒▓█▓▒░    ░▒▓█▓▒░`));
-    console.log(chalk.red(`     ░▒▓█▓▒░    ░▒▓█▓▒░      ░▒▓█▓▒░`) + chalk.yellow(` `) + chalk.red(`░▒▓█▓▒░      ░▒▓█▓▒░`));
-    console.log(chalk.red(`     ░▒▓█▓▒░    ░▒▓█▓▒░       ░▒▓█▓▒`) + chalk.red(`▓█▓▒░        ░▒▓█▓▒░`));
-    console.log('');
-    console.log(chalk.yellow(`            ╔═══════════════════════════════════╗`));
-    console.log(chalk.yellow(`            ║ `) + chalk.white.bold(`Multi-Agent Orchestration System`) + chalk.yellow(` ║`));
-    console.log(chalk.yellow(`            ╚═══════════════════════════════════╝`));
-    console.log('');
+    console.log(chalk.bold.blue('\n🚀 TRIBE CLI 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(chalk.gray(`Platform: ${platform} (${displayArch})`));
+    console.log(chalk.gray(`Node: ${process.version}`));
     console.log('');
     
     // Check for unsupported platforms early
@@ -1678,6 +1744,16 @@ async function main() {
     // Verify everything first
     const verified = await verifyInstallation();
     
+    // If critical components failed (especially TRIBE CLI), exit with error
+    if (!allSuccess) {
+        // Check specifically if TRIBE CLI installation failed
+        const tribeBinaryExists = fs.existsSync(path.join(tribeBinDir, 'tribe'));
+        if (!tribeBinaryExists) {
+            console.error(chalk.red('\n❌ Installation failed: TRIBE CLI could not be installed'));
+            process.exit(1);
+        }
+    }
+    
     // Try to start container runtime (after showing results)
     const runtimeStarted = await startContainerRuntime();
     
@@ -1824,6 +1900,22 @@ async function main() {
         log.info('Then run: tribe start');
     }
     
+    // Auto-launch handling (only for successful installations)
+    const checks = global.installationChecks || {};
+    if (checks.kubectl && checks.tribe) {
+        try {
+            const autoLaunch = require('./install-tribe-autolaunch.js');
+            if (autoLaunch.shouldAutoLaunch()) {
+                console.log(''); // Spacing before auto-launch
+                await autoLaunch.handleAutoLaunch();
+                // If auto-launch takes over, we won't reach here
+            }
+        } catch (error) {
+            // Silently ignore auto-launch errors to not break the installer
+            // Auto-launch is a nice-to-have feature, not critical
+        }
+    }
+    
     // Exit cleanly
     process.exit(0);
 }
@@ -1836,15 +1928,43 @@ if (!global.fetch) {
 if (require.main === module) {
     const args = process.argv.slice(2);
     
+    // Parse version/channel flags
+    let versionChannel = 'latest'; // default to latest stable
+    const versionArg = args.find(arg => arg.startsWith('--version='));
+    const channelArg = args.find(arg => arg.startsWith('--channel='));
+    
+    if (versionArg) {
+        versionChannel = versionArg.split('=')[1];
+    } else if (channelArg) {
+        versionChannel = channelArg.split('=')[1];
+    } else if (args.includes('--beta')) {
+        versionChannel = 'beta';
+    } else if (args.includes('--latest')) {
+        versionChannel = 'latest';
+    }
+    
+    // Store globally for use in download functions
+    global.versionChannel = versionChannel;
+    
     if (args.includes('--help') || args.includes('-h')) {
         console.log(chalk.bold.blue('TRIBE CLI Installer\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('  --skip-cluster Skip cluster deployment (for testing)');
-        console.log('  --force        Force clean installation (removes existing installations)');
+        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('  --skip-cluster       Skip cluster deployment (for testing)');
+        console.log('  --no-start           Alias for --skip-cluster (for CI environments)');
+        console.log('  --force              Force clean installation (removes existing installations)');
+        console.log('  --latest             Install latest stable release (default)');
+        console.log('  --beta               Install latest beta release');
+        console.log('  --version=TAG        Install specific version tag');
+        console.log('  --channel=CHANNEL    Install from specific channel (latest/beta)');
+        console.log('\nVersion Examples:');
+        console.log('  npx @_xtribe/cli@latest         # Latest stable (equivalent to --latest)');
+        console.log('  npx @_xtribe/cli@beta           # Latest beta');
+        console.log('  npx @_xtribe/cli --beta         # Latest beta (flag version)');
+        console.log('  npx @_xtribe/cli --version=v1.2.3   # Specific version');
         console.log('\nThis installer sets up the complete TRIBE development environment:');
         
         if (platform === 'darwin') {
@@ -1877,6 +1997,7 @@ if (require.main === module) {
         console.log(chalk.bold.blue('🔍 TRIBE CLI Installation Preview\n'));
         log.info(`Platform: ${platform} (${arch})`);
         log.info(`Install directory: ${binDir}`);
+        log.info(`Version channel: ${versionChannel}`);
         console.log('\nWould install:');
         console.log('• Colima - Container runtime with Kubernetes (macOS only)');
         console.log('• kubectl - Kubernetes CLI');
@@ -1884,8 +2005,8 @@ if (require.main === module) {
         process.exit(0);
     }
     
-    // Store skip-cluster flag
-    global.skipCluster = args.includes('--skip-cluster');
+    // Store skip-cluster flag (--no-start is an alias)
+    global.skipCluster = args.includes('--skip-cluster') || args.includes('--no-start');
     
     // Check for force flag
     if (args.includes('--force')) {

package/install.sh

@@ -0,0 +1,52 @@
+#!/bin/bash
+# TRIBE Quick Installer
+# This script provides a one-command installation with immediate PATH access
+
+# Source constants
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/../../../constants.sh" 2>/dev/null || true
+
+# If constants not found, define locally
+if [ -z "$TRIBE_INSTALL_COMMAND" ]; then
+    TRIBE_INSTALL_COMMAND="npx @_xtribe/cli"
+fi
+
+# Colors
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+BLUE='\033[0;34m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+echo -e "${BLUE}🚀 TRIBE Quick Installer${NC}"
+echo ""
+
+# Download and run the installer
+echo "Installing TRIBE components..."
+${TRIBE_INSTALL_COMMAND}@latest "$@"
+
+# Check if installation was successful
+if [ -f ~/.tribe/tribe-env.sh ]; then
+    # Source the environment file
+    source ~/.tribe/tribe-env.sh
+    
+    echo ""
+    echo -e "${GREEN}✅ Installation complete!${NC}"
+    echo -e "${GREEN}✅ PATH configured for this session!${NC}"
+    echo ""
+    
+    # Verify tribe is available
+    if command -v tribe &> /dev/null; then
+        echo -e "${YELLOW}You can now use the 'tribe' command immediately!${NC}"
+        echo ""
+        echo "Try these commands:"
+        echo -e "  ${GREEN}tribe${NC}         - Launch TRIBE"
+        echo -e "  ${GREEN}tribe status${NC}  - Check cluster status"
+    else
+        echo -e "${YELLOW}Run this command to use tribe:${NC}"
+        echo -e "  ${GREEN}source ~/.tribe/tribe-env.sh${NC}"
+    fi
+else
+    echo -e "${RED}❌ Installation may have failed${NC}"
+    exit 1
+fi

package/package.json

@@ -1,35 +1,27 @@
 {
   "name": "@_xtribe/cli",
-  "version": "2.0.3",
-  "description": "Deploy a team of AI agents that write production-ready code. Transform natural language into working software with autonomous Claude-powered developers.",
+  "version": "2.0.4",
+  "description": "TRIBE multi-agent development system - Zero to productive with one command",
   "main": "install-tribe.js",
   "bin": {
-    "tribe": "install-tribe.js"
+    "cli": "./index.js",
+    "install-tribe": "./install-tribe.js",
+    "setup-path": "./setup-path.js"
   },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "keywords": [
-    "ai",
-    "claude",
-    "anthropic",
-    "code-generation",
-    "ai-agents",
-    "multi-agent",
-    "autonomous-development",
-    "ai-developer",
-    "code-assistant",
-    "llm",
     "tribe",
     "cli",
     "kubernetes",
     "docker",
     "colima",
+    "multi-agent",
+    "ai",
     "development",
-    "automation",
-    "devtools",
-    "productivity",
-    "natural-language-programming"
+    "autonomous",
+    "agents"
   ],
   "engines": {
     "node": ">=16.0.0"
@@ -44,25 +36,33 @@
     "registry": "https://registry.npmjs.org/"
   },
   "files": [
+    "index.js",
     "install-tribe.js",
+    "install-tribe-minimal.js",
+    "install-tribe-autolaunch.js",
+    "setup-path.js",
+    "install.sh",
+    "tribe-deployment.yaml",
     "README.md",
+    "AUTOLAUNCH_IMPLEMENTATION.md",
     "package.json"
   ],
   "dependencies": {
+    "adm-zip": "^0.5.9",
     "chalk": "^4.1.2",
-    "ora": "^5.4.1",
     "node-fetch": "^2.6.7",
+    "ora": "^5.4.1",
     "tar": "^6.1.15",
     "which": "^2.0.2"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/0zen/0zen.git"
+    "url": "git+https://github.com/TRIBE-INC/0zen.git"
   },
-  "author": "0zen",
+  "author": "TRIBE-INC",
   "license": "MIT",
-  "homepage": "https://github.com/0zen/0zen",
+  "homepage": "https://github.com/TRIBE-INC/0zen",
   "bugs": {
-    "url": "https://github.com/0zen/0zen/issues"
+    "url": "https://github.com/TRIBE-INC/0zen/issues"
   }
 }

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();
+}