@_xtribe/cli 2.2.15 → 2.2.16

package/auto-updater.js

@@ -0,0 +1,268 @@
+#!/usr/bin/env node
+
+const os = require('os');
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const { execSync } = require('child_process');
+const chalk = require('chalk');
+
+class TribeAutoUpdater {
+    constructor() {
+        this.homeDir = os.homedir();
+        this.tribeDir = path.join(this.homeDir, '.tribe');
+        this.tribeBinDir = path.join(this.tribeDir, 'bin');
+        this.versionFile = path.join(this.tribeDir, 'version.json');
+        this.platform = os.platform();
+        this.arch = os.arch() === 'x64' ? 'amd64' : (os.arch() === 'arm64' ? 'arm64' : os.arch());
+        this.githubRepo = 'TRIBE-INC/releases';
+    }
+
+    async fetchLatestVersion() {
+        return new Promise((resolve, reject) => {
+            const url = `https://api.github.com/repos/${this.githubRepo}/releases/latest`;
+            https.get(url, {
+                headers: {
+                    'User-Agent': 'TRIBE-CLI-Updater'
+                }
+            }, (response) => {
+                let data = '';
+                response.on('data', chunk => data += chunk);
+                response.on('end', () => {
+                    try {
+                        const release = JSON.parse(data);
+                        resolve({
+                            version: release.tag_name,
+                            publishedAt: release.published_at,
+                            downloadUrl: `https://github.com/${this.githubRepo}/releases/latest/download/tribe-${this.platform}-${this.arch}`
+                        });
+                    } catch (error) {
+                        reject(error);
+                    }
+                });
+            }).on('error', reject);
+        });
+    }
+
+    getCurrentVersion() {
+        try {
+            if (fs.existsSync(this.versionFile)) {
+                const versionData = JSON.parse(fs.readFileSync(this.versionFile, 'utf8'));
+                return versionData;
+            }
+        } catch (error) {
+            // Ignore errors, return null for fresh install
+        }
+        return null;
+    }
+
+    saveVersionInfo(versionInfo) {
+        try {
+            fs.writeFileSync(this.versionFile, JSON.stringify({
+                version: versionInfo.version,
+                publishedAt: versionInfo.publishedAt,
+                lastChecked: new Date().toISOString(),
+                installedAt: new Date().toISOString()
+            }, null, 2));
+        } catch (error) {
+            console.warn(chalk.yellow(`Warning: Could not save version info: ${error.message}`));
+        }
+    }
+
+    shouldCheckForUpdates() {
+        const current = this.getCurrentVersion();
+        if (!current || !current.lastChecked) return true;
+
+        const lastChecked = new Date(current.lastChecked);
+        const now = new Date();
+        const hoursSinceLastCheck = (now - lastChecked) / (1000 * 60 * 60);
+
+        // Check for updates every 24 hours
+        return hoursSinceLastCheck >= 24;
+    }
+
+    isUpdateAvailable(currentVersion, latestVersion) {
+        if (!currentVersion) return true; // No version installed
+
+        // Simple version comparison (assumes semver-like tags)
+        const current = currentVersion.version?.replace('v', '') || '0.0.0';
+        const latest = latestVersion.version?.replace('v', '') || '0.0.0';
+
+        return current !== latest;
+    }
+
+    async downloadFile(url, dest) {
+        return new Promise((resolve, reject) => {
+            const file = fs.createWriteStream(dest);
+            https.get(url, (response) => {
+                if (response.statusCode === 302 || response.statusCode === 301) {
+                    return this.downloadFile(response.headers.location, dest).then(resolve, reject);
+                }
+                if (response.statusCode !== 200) {
+                    reject(new Error(`HTTP ${response.statusCode}`));
+                    return;
+                }
+                response.pipe(file);
+                file.on('finish', () => {
+                    file.close();
+                    resolve();
+                });
+            }).on('error', reject);
+        });
+    }
+
+    async performUpdate(latestVersion, options = {}) {
+        const { silent = false, force = false } = options;
+        const tribeBinary = path.join(this.tribeBinDir, 'tribe');
+
+        if (!silent) {
+            console.log(chalk.blue(`🔄 Updating TRIBE CLI to ${latestVersion.version}...`));
+        }
+
+        try {
+            // Backup existing binary if it exists
+            const backupPath = tribeBinary + '.backup';
+            if (fs.existsSync(tribeBinary)) {
+                fs.copyFileSync(tribeBinary, backupPath);
+            }
+
+            // Download new version
+            await this.downloadFile(latestVersion.downloadUrl, tribeBinary);
+            fs.chmodSync(tribeBinary, '755');
+
+            // Remove macOS quarantine if needed
+            if (this.platform === 'darwin') {
+                try {
+                    execSync(`xattr -d com.apple.quarantine "${tribeBinary}"`, { stdio: 'ignore' });
+                } catch {
+                    // Not critical
+                }
+            }
+
+            // Verify the update worked
+            try {
+                execSync(`"${tribeBinary}" --version`, { stdio: 'ignore', timeout: 5000 });
+
+                // Remove backup on success
+                if (fs.existsSync(backupPath)) {
+                    fs.unlinkSync(backupPath);
+                }
+
+                // Save version info
+                this.saveVersionInfo(latestVersion);
+
+                if (!silent) {
+                    console.log(chalk.green(`✅ Updated to TRIBE CLI ${latestVersion.version}`));
+                }
+                return true;
+            } catch (error) {
+                // Restore backup on verification failure
+                if (fs.existsSync(backupPath)) {
+                    fs.copyFileSync(backupPath, tribeBinary);
+                    fs.unlinkSync(backupPath);
+                }
+                throw new Error(`Update verification failed: ${error.message}`);
+            }
+
+        } catch (error) {
+            if (!silent) {
+                console.error(chalk.red(`❌ Update failed: ${error.message}`));
+            }
+            return false;
+        }
+    }
+
+    async checkForUpdates(options = {}) {
+        const { silent = false, force = false } = options;
+
+        try {
+            if (!force && !this.shouldCheckForUpdates()) {
+                return { hasUpdate: false, reason: 'Recently checked' };
+            }
+
+            const latestVersion = await this.fetchLatestVersion();
+            const currentVersion = this.getCurrentVersion();
+
+            // Update last checked time
+            if (currentVersion) {
+                currentVersion.lastChecked = new Date().toISOString();
+                this.saveVersionInfo(currentVersion);
+            }
+
+            const hasUpdate = this.isUpdateAvailable(currentVersion, latestVersion);
+
+            if (hasUpdate) {
+                if (!silent) {
+                    console.log(chalk.yellow(`📦 New version available: ${latestVersion.version}`));
+                    if (currentVersion?.version) {
+                        console.log(chalk.gray(`   Current: ${currentVersion.version}`));
+                    }
+                }
+                return {
+                    hasUpdate: true,
+                    currentVersion: currentVersion?.version || 'unknown',
+                    latestVersion: latestVersion.version,
+                    latestVersionInfo: latestVersion
+                };
+            } else {
+                if (!silent) {
+                    console.log(chalk.green('✅ TRIBE CLI is up to date'));
+                }
+                return { hasUpdate: false, reason: 'Up to date' };
+            }
+
+        } catch (error) {
+            if (!silent) {
+                console.warn(chalk.yellow(`⚠️  Could not check for updates: ${error.message}`));
+            }
+            return { hasUpdate: false, reason: 'Check failed', error: error.message };
+        }
+    }
+
+    async autoUpdate(options = {}) {
+        const { silent = false, force = false } = options;
+
+        const updateCheck = await this.checkForUpdates({ silent, force });
+
+        if (updateCheck.hasUpdate) {
+            return await this.performUpdate(updateCheck.latestVersionInfo, { silent, force });
+        }
+
+        return false; // No update needed
+    }
+
+    // Check if binary exists and is functional
+    isInstalled() {
+        const tribeBinary = path.join(this.tribeBinDir, 'tribe');
+        if (!fs.existsSync(tribeBinary)) return false;
+
+        try {
+            execSync(`"${tribeBinary}" --version`, { stdio: 'ignore', timeout: 5000 });
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    async promptForUpdate(updateInfo) {
+        const readline = require('readline');
+        const rl = readline.createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
+
+        return new Promise((resolve) => {
+            console.log(chalk.yellow(`\n📦 TRIBE CLI update available!`));
+            console.log(chalk.gray(`   Current: ${updateInfo.currentVersion}`));
+            console.log(chalk.cyan(`   Latest:  ${updateInfo.latestVersion}`));
+
+            rl.question('\nWould you like to update now? (Y/n): ', (answer) => {
+                rl.close();
+                const shouldUpdate = answer.toLowerCase() !== 'n' && answer.toLowerCase() !== 'no';
+                resolve(shouldUpdate);
+            });
+        });
+    }
+}
+
+module.exports = { TribeAutoUpdater };

package/index.js

@@ -2,15 +2,22 @@
 
 /**
  * Default entry point for npx @_xtribe/cli
- * This runs the full installation process
+ * This runs the installation process with optional auto-update support
  */
 
-// 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)], {
+// Check if user wants auto-update features
+const args = process.argv.slice(2);
+const useAutoUpdate = args.includes('--check-updates') || args.includes('--auto-update');
+
+// Choose installer based on features requested
+const installerPath = useAutoUpdate
+    ? path.join(__dirname, 'install-tribe-with-autoupdate.js')
+    : path.join(__dirname, 'install-tribe.js');
+
+const child = spawn(process.execPath, [installerPath, ...args], {
     stdio: 'inherit',
     env: process.env
 });

package/install-tribe-with-autoupdate.js

@@ -0,0 +1,328 @@
+#!/usr/bin/env node
+
+const os = require('os');
+const fs = require('fs');
+const path = require('path');
+const https = require('https');
+const { execSync } = require('child_process');
+const chalk = require('chalk');
+const ora = require('ora');
+const { EnhancedPathSetup } = require('./enhanced-path-setup');
+const { TribeAutoUpdater } = require('./auto-updater');
+
+// ASCII art for TRIBE
+const asciiArt = `
+████████╗██████╗ ██╗██████╗ ███████╗
+╚══██╔══╝██╔══██╗██║██╔══██╗██╔════╝
+   ██║   ██████╔╝██║██████╔╝█████╗
+   ██║   ██╔══██╗██║██╔══██╗██╔══╝
+   ██║   ██║  ██║██║██████╔╝███████╗
+   ╚═╝   ╚═╝  ╚═╝╚═╝╚═════╝ ╚══════╝
+
+Learn AI Engineering • Maximum Impact • It Doesn't Have to Be Hard`;
+
+const platform = os.platform();
+const arch = os.arch() === 'x64' ? 'amd64' : (os.arch() === 'arm64' ? 'arm64' : os.arch());
+const homeDir = os.homedir();
+const tribeDir = path.join(homeDir, '.tribe');
+const tribeBinDir = path.join(tribeDir, 'bin');
+const tutorDir = path.join(tribeDir, 'tutor');
+const logsDir = path.join(tribeDir, 'logs');
+
+// Ensure all directories exist with proper permissions (700)
+const directories = [
+    { path: tribeDir, name: 'base' },
+    { path: tribeBinDir, name: 'bin' },
+    { path: tutorDir, name: 'tutor' },
+    { path: logsDir, name: 'logs' }
+];
+
+directories.forEach(({ path: dirPath, name }) => {
+    if (!fs.existsSync(dirPath)) {
+        fs.mkdirSync(dirPath, { recursive: true, mode: 0o700 });
+    } else {
+        // Fix permissions if directory already exists
+        try {
+            fs.chmodSync(dirPath, 0o700);
+        } catch (err) {
+            // Ignore permission errors on some systems
+        }
+    }
+});
+
+function showWelcome() {
+    console.clear();
+    console.log(chalk.cyan(asciiArt));
+    console.log(chalk.gray('Master AI Engineering Through Practice\n'));
+}
+
+async function downloadFile(url, dest) {
+    return new Promise((resolve, reject) => {
+        const file = fs.createWriteStream(dest);
+        https.get(url, (response) => {
+            if (response.statusCode === 302 || response.statusCode === 301) {
+                return downloadFile(response.headers.location, dest).then(resolve, reject);
+            }
+            if (response.statusCode !== 200) {
+                reject(new Error(`HTTP ${response.statusCode}`));
+                return;
+            }
+            response.pipe(file);
+            file.on('finish', () => {
+                file.close();
+                resolve();
+            });
+        }).on('error', reject);
+    });
+}
+
+async function installOrUpdateTribeCLI() {
+    const updater = new TribeAutoUpdater();
+    const tribeDest = path.join(tribeBinDir, 'tribe');
+
+    // Check if it's an installation or update
+    const isInstalled = updater.isInstalled();
+    const action = isInstalled ? 'Updating' : 'Installing';
+
+    const spinner = ora(`${action} CLI...`).start();
+
+    try {
+        if (isInstalled) {
+            // Use auto-updater for existing installations
+            const updated = await updater.autoUpdate({ silent: true, force: true });
+            if (updated) {
+                spinner.succeed('CLI updated to latest version');
+            } else {
+                spinner.succeed('CLI already up to date');
+            }
+        } else {
+            // Fresh installation - download latest version
+            const latestVersion = await updater.fetchLatestVersion();
+
+            await downloadFile(latestVersion.downloadUrl, tribeDest);
+            fs.chmodSync(tribeDest, '755');
+
+            // Remove macOS quarantine if needed
+            if (platform === 'darwin') {
+                try {
+                    execSync(`xattr -d com.apple.quarantine "${tribeDest}"`, { stdio: 'ignore' });
+                } catch {
+                    // Not critical
+                }
+            }
+
+            // Save version info for future updates
+            updater.saveVersionInfo(latestVersion);
+
+            spinner.succeed('CLI installed successfully');
+        }
+
+        return true;
+    } catch (error) {
+        spinner.fail(`${action} failed: ${error.message}`);
+        return false;
+    }
+}
+
+async function installTutorCollector() {
+    const tutorCollectorDest = path.join(tribeBinDir, 'tutor-collector');
+    const githubRepo = 'TRIBE-INC/releases';
+    const tutorCollectorUrl = `https://github.com/${githubRepo}/releases/latest/download/tutor-collector-${platform}-${arch}`;
+
+    try {
+        await downloadFile(tutorCollectorUrl, tutorCollectorDest);
+        fs.chmodSync(tutorCollectorDest, '755');
+
+        // Remove macOS quarantine if needed
+        if (platform === 'darwin') {
+            try {
+                execSync(`xattr -d com.apple.quarantine "${tutorCollectorDest}"`, { stdio: 'ignore' });
+            } catch {
+                // Not critical
+            }
+        }
+        return true;
+    } catch (tutorError) {
+        // Tutor collector is optional for basic CLI functionality
+        console.warn(chalk.yellow('Warning: Could not download tutor-collector binary'));
+        return false;
+    }
+}
+
+async function setupAutoUpdate() {
+    // Create a simple update script that users can run manually or add to cron
+    const updateScript = `#!/bin/bash
+# TRIBE CLI Auto-Update Script
+# Run this periodically to keep TRIBE CLI up to date
+
+echo "🔍 Checking for TRIBE CLI updates..."
+npx @_xtribe/cli --check-updates --auto-update
+
+# Optional: Add to cron by running:
+# echo "0 12 * * * $HOME/.tribe/update-tribe.sh" | crontab -
+`;
+
+    const updateScriptPath = path.join(tribeDir, 'update-tribe.sh');
+
+    try {
+        fs.writeFileSync(updateScriptPath, updateScript);
+        fs.chmodSync(updateScriptPath, '755');
+        return updateScriptPath;
+    } catch (error) {
+        console.warn(chalk.yellow(`Warning: Could not create update script: ${error.message}`));
+        return null;
+    }
+}
+
+async function setupPath() {
+    const pathSetup = new EnhancedPathSetup();
+    const result = await pathSetup.setup();
+    return result.success;
+}
+
+async function main() {
+    const args = process.argv.slice(2);
+
+    // Handle version check and auto-update
+    if (args.includes('--check-updates') || args.includes('--auto-update')) {
+        const updater = new TribeAutoUpdater();
+
+        if (args.includes('--auto-update')) {
+            console.log(chalk.blue('🔄 Checking for updates...'));
+            const updated = await updater.autoUpdate({ silent: false, force: true });
+            if (updated) {
+                console.log(chalk.green('✅ TRIBE CLI updated successfully'));
+            } else {
+                console.log(chalk.blue('📦 TRIBE CLI is already up to date'));
+            }
+        } else {
+            const updateCheck = await updater.checkForUpdates({ silent: false, force: true });
+            if (updateCheck.hasUpdate) {
+                console.log(chalk.yellow(`\n📦 Update available: ${updateCheck.latestVersion}`));
+                console.log(chalk.gray(`Run 'npx @_xtribe/cli --auto-update' to update`));
+            }
+        }
+        process.exit(0);
+    }
+
+    // Handle help
+    if (args.includes('--help') || args.includes('-h')) {
+        console.log(chalk.bold('TRIBE CLI Installer with Auto-Update\n'));
+        console.log('Empower your AI coding agents and become 10x faster\n');
+        console.log('Usage: npx @_xtribe/cli [options]\n');
+        console.log('Options:');
+        console.log('  --help, -h         Show this help message');
+        console.log('  --version          Show version');
+        console.log('  --check-updates    Check for CLI updates');
+        console.log('  --auto-update      Update CLI to latest version');
+        process.exit(0);
+    }
+
+    // Show welcome
+    showWelcome();
+
+    // Check for updates first (if CLI is already installed)
+    const updater = new TribeAutoUpdater();
+    if (updater.isInstalled()) {
+        console.log(chalk.blue('🔍 Checking for updates...'));
+        const updateCheck = await updater.checkForUpdates({ silent: true });
+
+        if (updateCheck.hasUpdate) {
+            console.log(chalk.yellow(`📦 New version available: ${updateCheck.latestVersion}`));
+
+            // Prompt user for update
+            const shouldUpdate = await updater.promptForUpdate(updateCheck);
+            if (shouldUpdate) {
+                const spinner = ora('Updating TRIBE CLI...').start();
+                const updated = await updater.performUpdate(updateCheck.latestVersionInfo, { silent: true });
+                if (updated) {
+                    spinner.succeed(`Updated to ${updateCheck.latestVersion}`);
+                } else {
+                    spinner.fail('Update failed');
+                }
+            } else {
+                console.log(chalk.gray('Skipping update. You can update later with: npx @_xtribe/cli --auto-update'));
+            }
+        }
+    }
+
+    // Single spinner for entire installation
+    const spinner = ora('Installing...').start();
+
+    try {
+        // Install or update TRIBE CLI
+        spinner.text = 'Installing CLI...';
+        const cliSuccess = await installOrUpdateTribeCLI();
+        if (!cliSuccess) {
+            spinner.fail('Installation failed');
+            console.log(chalk.yellow('Please check your internet connection and try again'));
+            process.exit(1);
+        }
+
+        // Install tutor collector
+        spinner.text = 'Installing tutor collector...';
+        await installTutorCollector();
+
+        // Setup PATH
+        spinner.text = 'Setting up environment...';
+        try {
+            await setupPath();
+        } catch (error) {
+            // PATH setup had issues but continue with installation
+            console.log(chalk.yellow('⚠️  PATH setup had warnings, but installation completed'));
+        }
+
+        // Setup auto-update script
+        spinner.text = 'Setting up auto-update...';
+        const updateScriptPath = await setupAutoUpdate();
+
+        spinner.succeed('Ready!');
+
+        // Test if tribe command works immediately
+        let commandWorks = false;
+        try {
+            execSync('which tribe', { stdio: 'ignore', timeout: 2000 });
+            commandWorks = true;
+        } catch (error) {
+            commandWorks = false;
+        }
+
+        // Show appropriate completion message
+        if (commandWorks) {
+            console.log(chalk.green('\n✅ TRIBE CLI is ready to use!'));
+            console.log('Type ' + chalk.cyan.bold('tribe') + ' to get started');
+        } else {
+            console.log(chalk.yellow('\n⚠️  TRIBE CLI installed successfully!'));
+            console.log(chalk.blue('To use the tribe command, please restart your terminal'));
+            console.log(chalk.gray('or run: ') + chalk.cyan.bold('source ~/.tribe/tribe-env.sh'));
+            console.log(chalk.gray('\nThen type: ') + chalk.cyan.bold('tribe') + chalk.gray(' to get started'));
+        }
+
+        // Show auto-update info
+        console.log(chalk.blue('\n🔄 Auto-Update:'));
+        console.log(chalk.gray('  Check for updates: ') + chalk.cyan('npx @_xtribe/cli --check-updates'));
+        console.log(chalk.gray('  Auto-update:       ') + chalk.cyan('npx @_xtribe/cli --auto-update'));
+
+        if (updateScriptPath) {
+            console.log(chalk.gray('  Update script:     ') + chalk.cyan(updateScriptPath));
+        }
+
+    } catch (error) {
+        spinner.fail('Installation failed');
+        console.error(chalk.red(error.message));
+        process.exit(1);
+    }
+
+    process.exit(0);
+}
+
+// Export for use from index.js
+module.exports = { main };
+
+// Run if executed directly
+if (require.main === module) {
+    main().catch(error => {
+        console.error(chalk.red('Error:'), error.message);
+        process.exit(1);
+    });
+}

package/install-tribe.js

@@ -186,12 +186,18 @@ async function main() {
 
     // Handle help
     if (args.includes('--help') || args.includes('-h')) {
-        console.log(chalk.bold('TRIBE Telemetry Installer\n'));
+        console.log(chalk.bold('TRIBE CLI Installer\n'));
         console.log('Empower your AI coding agents and become 10x faster\n');
         console.log('Usage: npx @_xtribe/cli [options]\n');
         console.log('Options:');
-        console.log('  --help, -h     Show this help message');
-        console.log('  --version      Show version');
+        console.log('  --help, -h         Show this help message');
+        console.log('  --version          Show version');
+        console.log('  --check-updates    Check for CLI updates');
+        console.log('  --auto-update      Update CLI to latest version');
+        console.log('\nAuto-Update Features:');
+        console.log('  The CLI can automatically check for and install updates');
+        console.log('  Use --check-updates to see if a newer version is available');
+        console.log('  Use --auto-update to download and install the latest version');
         process.exit(0);
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@_xtribe/cli",
-  "version": "2.2.15",
+  "version": "2.2.16",
   "description": "TRIBE - Track, measure and optimize your AI coding agents to become 10x faster",
   "main": "install-tribe.js",
   "bin": {
@@ -42,6 +42,8 @@
     "install-tribe.js",
     "install-tribe-minimal.js",
     "install-tribe-autolaunch.js",
+    "install-tribe-with-autoupdate.js",
+    "auto-updater.js",
     "setup-path.js",
     "enhanced-path-setup.js",
     "install.sh",