@_xtribe/cli 2.0.3 → 2.0.4

package/index.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+
+/**
+ * Default entry point for npx @_xtribe/cli
+ * This runs the full installation process
+ */
+
+// Execute the installer in a way that preserves require.main
+const { spawn } = require('child_process');
+const path = require('path');
+
+const installerPath = path.join(__dirname, 'install-tribe.js');
+const child = spawn(process.execPath, [installerPath, ...process.argv.slice(2)], {
+    stdio: 'inherit',
+    env: process.env
+});
+
+child.on('exit', (code) => {
+    process.exit(code || 0);
+});

package/install-tribe-autolaunch.js

@@ -0,0 +1,272 @@
+#!/usr/bin/env node
+
+const os = require('os');
+const fs = require('fs');
+const path = require('path');
+const { spawn, execSync } = require('child_process');
+
+// Import the existing installer
+const originalInstaller = require('./install-tribe.js');
+
+// Auto-launch specific functionality
+const platform = os.platform();
+const homeDir = os.homedir();
+const tribeDir = path.join(homeDir, '.tribe');
+const firstTimeMarker = path.join(tribeDir, '.first-install-complete');
+
+// Color codes for output
+const colors = {
+    reset: '\x1b[0m',
+    bright: '\x1b[1m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    cyan: '\x1b[36m'
+};
+
+function log(message, color = '') {
+    console.log(color + message + colors.reset);
+}
+
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+/**
+ * Check if we should auto-launch the interactive UI
+ */
+function shouldAutoLaunch() {
+    // Check for command line flags
+    const args = process.argv.slice(2);
+    const noLaunchFlag = args.includes('--no-launch') || args.includes('--no-auto');
+    const launchFlag = args.includes('--launch') || args.includes('--auto');
+    const simpleFlag = args.includes('--simple');
+    
+    if (noLaunchFlag || simpleFlag) {
+        return false;
+    }
+    
+    if (launchFlag) {
+        return true;
+    }
+    
+    // Auto-launch conditions:
+    // 1. Interactive terminal (TTY)
+    const isTTY = process.stdout.isTTY && process.stdin.isTTY;
+    if (!isTTY) {
+        return false;
+    }
+    
+    // 2. Not in CI environment
+    const isCI = process.env.CI === 'true' || 
+                 process.env.CONTINUOUS_INTEGRATION === 'true' ||
+                 process.env.GITHUB_ACTIONS === 'true';
+    if (isCI) {
+        return false;
+    }
+    
+    // 3. First time install (no marker file exists)
+    const isFirstTime = !fs.existsSync(firstTimeMarker);
+    
+    return isFirstTime;
+}
+
+/**
+ * Get the path to the tribe binary
+ */
+function getTribeBinaryPath() {
+    const tribeBinDir = path.join(homeDir, '.tribe', 'bin');
+    const tribePath = path.join(tribeBinDir, 'tribe');
+    
+    if (fs.existsSync(tribePath)) {
+        return tribePath;
+    }
+    
+    // Try global install
+    try {
+        return execSync('which tribe', { encoding: 'utf8' }).trim();
+    } catch {
+        throw new Error('Tribe binary not found');
+    }
+}
+
+/**
+ * Check if the Tribe cluster is running
+ */
+async function isClusterRunning() {
+    try {
+        const tribePath = getTribeBinaryPath();
+        const result = execSync(`${tribePath} --simple status`, { encoding: 'utf8' });
+        return result.includes('Cluster is running');
+    } catch {
+        return false;
+    }
+}
+
+/**
+ * Start the Tribe cluster
+ */
+async function startCluster() {
+    const tribePath = getTribeBinaryPath();
+    log('\nStarting Tribe cluster...', colors.cyan);
+    
+    try {
+        execSync(`${tribePath} --simple start`, { stdio: 'inherit' });
+        
+        // Wait for cluster to be ready
+        log('Waiting for services to be ready...', colors.yellow);
+        let attempts = 0;
+        while (attempts < 30) {
+            await sleep(2000);
+            if (await isClusterRunning()) {
+                log('✅ Cluster is ready!', colors.green);
+                return true;
+            }
+            attempts++;
+        }
+        
+        throw new Error('Cluster failed to start in time');
+    } catch (error) {
+        log('Failed to start cluster: ' + error.message, colors.reset);
+        return false;
+    }
+}
+
+/**
+ * Display the first-time welcome experience
+ */
+async function showFirstTimeWelcome() {
+    console.log('\n' + colors.bright + colors.cyan + '🎉 Welcome to TRIBE!' + colors.reset);
+    console.log('\nYour AI development team is ready to help you build amazing software!\n');
+    
+    console.log('Meet your AI agents:');
+    console.log('  🎨 ' + colors.bright + 'Pixel' + colors.reset + ' - Creative Design & UI/UX');
+    console.log('  ⚡ ' + colors.bright + 'Spark' + colors.reset + ' - Implementation & Performance');
+    console.log('  🌟 ' + colors.bright + 'Nova' + colors.reset + ' - Architecture & Strategy');
+    console.log('  🧘 ' + colors.bright + 'Zen' + colors.reset + ' - Testing & Quality');
+    console.log('  🔥 ' + colors.bright + 'Blaze' + colors.reset + ' - DevOps & Infrastructure');
+    console.log('  🌌 ' + colors.bright + 'Cosmos' + colors.reset + ' - Data & Analytics');
+    console.log('  🔊 ' + colors.bright + 'Echo' + colors.reset + ' - API & Integration');
+    console.log('  ⚛️ ' + colors.bright + 'Quantum' + colors.reset + ' - Security & Cryptography');
+    
+    console.log('\n' + colors.yellow + 'Launching interactive mode...' + colors.reset);
+    await sleep(2000);
+}
+
+/**
+ * Launch the Tribe interactive UI
+ */
+async function launchTribeInteractive() {
+    const tribePath = getTribeBinaryPath();
+    
+    // Clear the screen for a clean start
+    if (platform !== 'win32') {
+        process.stdout.write('\x1Bc');
+    }
+    
+    // Launch tribe in interactive mode (default when no args)
+    const child = spawn(tribePath, [], {
+        stdio: 'inherit',
+        env: { 
+            ...process.env,
+            TERM: process.env.TERM || 'xterm-256color'
+        }
+    });
+    
+    // Handle child process exit
+    child.on('exit', (code) => {
+        if (code !== 0) {
+            console.error(`\nTribe exited with code ${code}`);
+        }
+        process.exit(code || 0);
+    });
+    
+    // Handle errors
+    child.on('error', (err) => {
+        console.error('Failed to launch Tribe:', err.message);
+        showManualInstructions();
+        process.exit(1);
+    });
+}
+
+/**
+ * Show manual launch instructions
+ */
+function showManualInstructions() {
+    console.log('\n' + colors.yellow + 'To start Tribe manually:' + colors.reset);
+    console.log('  ' + colors.green + 'tribe' + colors.reset + '              # Interactive mode');
+    console.log('  ' + colors.green + 'tribe --simple' + colors.reset + '     # Simple CLI mode');
+    console.log('  ' + colors.green + 'tribe --help' + colors.reset + '       # Show all options\n');
+}
+
+/**
+ * Mark first install as complete
+ */
+function markFirstInstallComplete() {
+    if (!fs.existsSync(tribeDir)) {
+        fs.mkdirSync(tribeDir, { recursive: true });
+    }
+    fs.writeFileSync(firstTimeMarker, new Date().toISOString());
+}
+
+/**
+ * Main auto-launch handler
+ */
+async function handleAutoLaunch() {
+    // Only proceed if we should auto-launch
+    if (!shouldAutoLaunch()) {
+        showManualInstructions();
+        return;
+    }
+    
+    try {
+        // Check if this is first time
+        const isFirstTime = !fs.existsSync(firstTimeMarker);
+        
+        // Show welcome for first-time users
+        if (isFirstTime) {
+            await showFirstTimeWelcome();
+        } else {
+            log('\nLaunching TRIBE interactive mode...', colors.cyan);
+            await sleep(1000);
+        }
+        
+        // Check and start cluster if needed (skip if --no-start was used)
+        const args = process.argv.slice(2);
+        const skipCluster = args.includes('--skip-cluster') || args.includes('--no-start');
+        
+        if (!skipCluster && !await isClusterRunning()) {
+            const started = await startCluster();
+            if (!started) {
+                showManualInstructions();
+                return;
+            }
+        }
+        
+        // Mark first install complete before launching
+        if (isFirstTime) {
+            markFirstInstallComplete();
+        }
+        
+        // Launch the interactive UI
+        await launchTribeInteractive();
+        
+    } catch (error) {
+        console.error('\n' + colors.reset + 'Could not launch Tribe automatically.');
+        console.error('Error:', error.message);
+        showManualInstructions();
+    }
+}
+
+// Export for use in main installer
+module.exports = {
+    shouldAutoLaunch,
+    handleAutoLaunch,
+    showManualInstructions,
+    markFirstInstallComplete
+};
+
+// If run directly (for testing)
+if (require.main === module) {
+    handleAutoLaunch();
+}

package/install-tribe-minimal.js

@@ -0,0 +1,171 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+const https = require('https');
+const http = require('http');
+
+const platform = os.platform();
+const arch = process.arch === 'x64' ? 'amd64' : process.arch;
+const homeDir = os.homedir();
+const tribeDir = path.join(homeDir, '.tribe');
+const binDir = path.join(tribeDir, 'bin');
+
+console.log(`TRIBE Minimal Installer - Linux MVP`);
+console.log(`Platform: ${platform} (${arch})`);
+console.log(`Installing to: ${binDir}`);
+
+// Create bin directory
+if (!fs.existsSync(binDir)) {
+    fs.mkdirSync(binDir, { recursive: true });
+}
+
+// Download function
+async function downloadFile(url, dest) {
+    return new Promise((resolve, reject) => {
+        const file = fs.createWriteStream(dest);
+        const protocol = url.startsWith('https') ? https : http;
+        
+        console.log(`Downloading from: ${url}`);
+        
+        const request = protocol.get(url, (response) => {
+            if (response.statusCode === 302 || response.statusCode === 301) {
+                file.close();
+                fs.unlinkSync(dest);
+                return downloadFile(response.headers.location, dest).then(resolve).catch(reject);
+            }
+            
+            if (response.statusCode !== 200) {
+                file.close();
+                fs.unlinkSync(dest);
+                reject(new Error(`HTTP ${response.statusCode}: ${response.statusMessage}`));
+                return;
+            }
+            
+            response.pipe(file);
+            
+            file.on('finish', () => {
+                file.close();
+                resolve();
+            });
+        }).on('error', (err) => {
+            fs.unlinkSync(dest);
+            reject(err);
+        });
+    });
+}
+
+async function installTribe() {
+    const tribeDest = path.join(binDir, 'tribe');
+    
+    // If TRIBE_TEST_BINARY is set, copy it instead of downloading
+    if (process.env.TRIBE_TEST_BINARY && fs.existsSync(process.env.TRIBE_TEST_BINARY)) {
+        console.log('Using test binary from:', process.env.TRIBE_TEST_BINARY);
+        fs.copyFileSync(process.env.TRIBE_TEST_BINARY, tribeDest);
+        fs.chmodSync(tribeDest, '755');
+        console.log('✓ TRIBE CLI installed from test binary');
+        return true;
+    }
+    
+    // Download from GitHub releases
+    const url = `https://github.com/TRIBE-INC/releases/releases/latest/download/tribe-${platform}-${arch}`;
+    
+    try {
+        await downloadFile(url, tribeDest);
+        
+        const stats = fs.statSync(tribeDest);
+        console.log(`Downloaded file size: ${stats.size} bytes`);
+        
+        if (stats.size < 1000000) { // Less than 1MB is suspiciously small
+            throw new Error('Downloaded file is too small, likely not a valid binary');
+        }
+        
+        fs.chmodSync(tribeDest, '755');
+        
+        // Try to run version
+        try {
+            const version = execSync(`${tribeDest} version`, { encoding: 'utf8' });
+            console.log(`✓ TRIBE CLI installed successfully: ${version.trim()}`);
+        } catch (e) {
+            console.log('✓ TRIBE CLI installed (version check failed - may need different architecture)');
+        }
+        
+        return true;
+    } catch (error) {
+        console.error(`✗ Failed to install TRIBE CLI: ${error.message}`);
+        if (fs.existsSync(tribeDest)) {
+            fs.unlinkSync(tribeDest);
+        }
+        return false;
+    }
+}
+
+// Update PATH
+function updatePath() {
+    // Create tribe-env.sh script
+    const tribeEnvPath = path.join(tribeDir, 'tribe-env.sh');
+    const envScriptContent = `#!/bin/bash
+# TRIBE CLI Environment Setup
+# Auto-generated by TRIBE installer
+
+# 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
+`;
+
+    try {
+        fs.writeFileSync(tribeEnvPath, envScriptContent);
+        fs.chmodSync(tribeEnvPath, '755');
+        console.log('✓ Created tribe-env.sh environment script');
+    } catch (error) {
+        console.log(`⚠ Failed to create tribe-env.sh: ${error.message}`);
+        return;
+    }
+
+    // Update shell config
+    const shell = process.env.SHELL || '/bin/bash';
+    const rcFile = shell.includes('zsh') ? '.zshrc' : '.bashrc';
+    const rcPath = path.join(homeDir, rcFile);
+    const sourceCommand = 'source ~/.tribe/tribe-env.sh';
+
+    try {
+        const rcContent = fs.existsSync(rcPath) ? fs.readFileSync(rcPath, 'utf8') : '';
+        if (!rcContent.includes(sourceCommand)) {
+            fs.appendFileSync(rcPath, `\n# TRIBE CLI\n${sourceCommand}\n`);
+            console.log(`✓ Updated ${rcFile} to source tribe-env.sh`);
+        } else {
+            console.log(`✓ ${rcFile} already configured`);
+        }
+    } catch (error) {
+        console.log(`⚠ Failed to update ${rcFile}: ${error.message}`);
+        console.log('Please manually add this line to your shell config:');
+        console.log(`  ${sourceCommand}`);
+    }
+}
+
+// Main
+async function main() {
+    updatePath();
+    const success = await installTribe();
+    
+    if (success) {
+        console.log('\n✓ Installation complete!');
+        console.log(`\nNext steps:`);
+        console.log(`1. Run: source ~/.${process.env.SHELL?.includes('zsh') ? 'zshrc' : 'bashrc'}`);
+        console.log(`2. Run: tribe version`);
+        process.exit(0);
+    } else {
+        console.error('\n✗ Installation failed');
+        process.exit(1);
+    }
+}
+
+main().catch(err => {
+    console.error('Installation error:', err);
+    process.exit(1);
+});