@_xtribe/cli 1.0.0-beta.11 → 1.0.0-beta.14

package/install-tribe.js

@@ -392,14 +392,43 @@ async function checkColimaRunning() {
     }
 }
 
+async function checkColimaHasKubernetes() {
+    try {
+        const colimaPath = await findCommand('colima') || path.join(binDir, 'colima');
+        const status = execSync(`${colimaPath} status`, { encoding: 'utf8' });
+        // Check if kubernetes is mentioned in the status
+        return status.toLowerCase().includes('kubernetes');
+    } catch {
+        return false;
+    }
+}
+
 async function startColimaWithKubernetes() {
     const spinner = ora('Starting Colima with Kubernetes...').start();
     
     try {
         // Check if already running
         if (await checkColimaRunning()) {
-            spinner.succeed('Colima is already running');
-            return true;
+            // Check if it has Kubernetes enabled
+            if (await checkColimaHasKubernetes()) {
+                spinner.succeed('Colima is already running with Kubernetes');
+                return true;
+            } else {
+                spinner.text = 'Colima is running without Kubernetes. Restarting with Kubernetes...';
+                
+                // Stop existing Colima
+                const colimaPath = await findCommand('colima') || path.join(binDir, 'colima');
+                try {
+                    execSync(`${colimaPath} stop`, {
+                        stdio: 'pipe',
+                        timeout: 30000
+                    });
+                    // Wait for it to fully stop
+                    await new Promise(resolve => setTimeout(resolve, 5000));
+                } catch (stopError) {
+                    log.warning('Failed to stop Colima, attempting to start anyway...');
+                }
+            }
         }
         
         // Start Colima with Kubernetes enabled
@@ -407,12 +436,24 @@ async function startColimaWithKubernetes() {
         const colimaPath = await findCommand('colima') || path.join(binDir, 'colima');
         execSync(`${colimaPath} start --kubernetes --cpu 4 --memory 8 --disk 20`, {
             stdio: 'pipe',
-            env: { ...process.env, PATH: `${binDir}:${process.env.PATH}` }
+            env: { ...process.env, PATH: `${binDir}:${process.env.PATH}` },
+            timeout: 300000 // 5 minute timeout for first start
         });
         
-        // Verify it's working
+        // Give Colima a moment to stabilize after starting
+        spinner.text = 'Waiting for Colima to stabilize...';
+        await new Promise(resolve => setTimeout(resolve, 5000));
+        
+        // Verify it's working and set context
         const kubectlPath = await findCommand('kubectl') || 'kubectl';
         execSync(`${kubectlPath} version --client`, { stdio: 'ignore' });
+        
+        // Set kubectl context to colima
+        try {
+            execSync(`${kubectlPath} config use-context colima`, { stdio: 'ignore' });
+        } catch {
+            // Context might not exist yet, that's OK
+        }
         spinner.succeed('Colima started with Kubernetes');
         return true;
     } catch (error) {
@@ -460,6 +501,89 @@ async function deployTribeCluster() {
             TRIBE_DEPLOYMENT_YAML: destYaml
         };
         
+        // Wait for Kubernetes to be fully ready
+        spinner.text = 'Waiting for Kubernetes to be ready...';
+        const kubectlPath = await findCommand('kubectl') || 'kubectl';
+        let apiReady = false;
+        let contextSet = false;
+        
+        // First, wait for the API server to be accessible
+        for (let i = 0; i < 30; i++) {
+            try {
+                // Try to get cluster info - this will work regardless of port
+                const clusterInfo = execSync(`${kubectlPath} cluster-info`, {
+                    encoding: 'utf8',
+                    env: env,
+                    stdio: 'pipe'
+                });
+                
+                // Check if we got valid cluster info
+                if (clusterInfo && clusterInfo.includes('is running at')) {
+                    apiReady = true;
+                    spinner.text = 'Kubernetes API server is ready';
+                    
+                    // Extract the actual API server URL for logging
+                    const urlMatch = clusterInfo.match(/is running at (https?:\/\/[^\s]+)/);
+                    if (urlMatch) {
+                        log.info(`Kubernetes API server: ${urlMatch[1]}`);
+                    }
+                    break;
+                }
+            } catch (error) {
+                spinner.text = `Waiting for Kubernetes API server... (${i+1}/30)`;
+                await new Promise(resolve => setTimeout(resolve, 2000));
+            }
+        }
+        
+        if (!apiReady) {
+            spinner.warn('Kubernetes API server not ready after 60 seconds');
+            log.info('Deployment may fail. You can try running "tribe start" manually later.');
+            return false;
+        }
+        
+        // Set the kubectl context to colima
+        spinner.text = 'Setting kubectl context...';
+        try {
+            execSync(`${kubectlPath} config use-context colima`, {
+                stdio: 'ignore',
+                env: env
+            });
+            contextSet = true;
+        } catch {
+            log.warning('Could not set kubectl context to colima');
+        }
+        
+        // Wait for the node to be ready
+        spinner.text = 'Waiting for Kubernetes node to be ready...';
+        let nodeReady = false;
+        for (let i = 0; i < 20; i++) {
+            try {
+                const nodeStatus = execSync(`${kubectlPath} get nodes -o jsonpath='{.items[0].status.conditions[?(@.type=="Ready")].status}'`, {
+                    encoding: 'utf8',
+                    env: env
+                }).trim();
+                
+                if (nodeStatus === 'True') {
+                    nodeReady = true;
+                    spinner.text = 'Kubernetes node is ready';
+                    break;
+                }
+            } catch {
+                // Node might not be registered yet
+            }
+            spinner.text = `Waiting for Kubernetes node... (${i+1}/20)`;
+            await new Promise(resolve => setTimeout(resolve, 3000));
+        }
+        
+        if (!nodeReady) {
+            spinner.warn('Kubernetes node not ready after 60 seconds');
+            log.info('The cluster may still be initializing. Proceeding with deployment...');
+        }
+        
+        // Small delay to let everything stabilize
+        spinner.text = 'Starting TRIBE deployment...';
+        await new Promise(resolve => setTimeout(resolve, 2000));
+        
         // Execute tribe start
         execSync(`${tribePath} start`, {
             stdio: 'pipe',
@@ -475,7 +599,19 @@ async function deployTribeCluster() {
     } catch (error) {
         spinner.fail('Failed to deploy TRIBE cluster');
         log.error(error.message);
-        log.info('You can manually deploy later with: tribe start');
+        
+        // Check if this is a Kubernetes connectivity issue
+        if (error.message && error.message.includes('connection refused')) {
+            log.warning('\nIt appears Kubernetes is not ready or not enabled.');
+            log.info('Troubleshooting steps:');
+            log.info('1. Check Colima status: colima status');
+            log.info('2. If running without Kubernetes, restart it:');
+            log.info('   colima stop');
+            log.info('   colima start --kubernetes');
+            log.info('3. Then run: tribe start');
+        } else {
+            log.info('You can manually deploy later with: tribe start');
+        }
         return false;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@_xtribe/cli",
-  "version": "1.0.0-beta.11",
+  "version": "1.0.0-beta.14",
   "description": "TRIBE multi-agent development system - Zero to productive with one command",
   "main": "install-tribe.js",
   "bin": {