vibecodingmachine-cli 2026.2.20-438 → 2026.2.26-1739

package/src/utils/provider-checkers/provider-checker-core.js

@@ -0,0 +1,172 @@
+'use strict';
+
+const { spawn } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+const chokidar = require('chokidar');
+const { getNodeExecutable } = require('./node-executable-finder');
+const { isIdeInstalled, getIdeProcess, launchIde, IDE_INFO } = require('./ide-manager');
+
+const CLI_ENTRY_POINT = path.resolve(path.join(__dirname, '../../../bin/vibecodingmachine.js'));
+
+// Timeout constants
+const DIRECT_TIMEOUT_MS = 60000; // 1 minute for direct providers
+const IDE_TIMEOUT_MS = 300000; // 5 minutes for IDE providers
+
+/**
+ * Get result file path for provider check
+ */
+function getResultFilePath(repoPath) {
+  return path.join(repoPath, '.vibecodingmachine', 'agent-check-result.txt');
+}
+
+/**
+ * Remove test requirement file
+ */
+function removeTestRequirement(reqPath) {
+  if (fs.existsSync(reqPath)) {
+    let content = fs.readFileSync(reqPath, 'utf8');
+    // Remove the test requirement if it exists
+    content = content.replace(/^## 🚦 Current Status\n\nAGENT_CHECK[^\n]*\n\n?/gm, '');
+    fs.writeFileSync(reqPath, content);
+  }
+}
+
+/**
+ * Check if provider is reachable
+ */
+async function checkProviderReachable(providerId, config, repoPath) {
+  const def = config.providers[providerId];
+  if (!def) {
+    return { status: 'error', message: `Provider ${providerId} not found in config` };
+  }
+
+  const checkedAt = new Date().toISOString();
+  const resultFile = getResultFilePath(repoPath);
+
+  // For IDE providers, check if IDE is installed and running
+  if (def.type === 'ide') {
+    if (!isIdeInstalled(providerId)) {
+      return { status: 'error', message: `${IDE_INFO[providerId]?.app || providerId} is not installed`, checkedAt };
+    }
+
+    const processInfo = getIdeProcess(providerId);
+    if (!processInfo) {
+      // Try to launch the IDE
+      const launched = await launchIde(providerId);
+      if (!launched) {
+        return { status: 'error', message: `${IDE_INFO[providerId]?.app || providerId} is not running and could not be launched`, checkedAt };
+      }
+      // Give IDE time to start
+      await new Promise(r => setTimeout(r, 5000));
+    }
+  }
+
+  return new Promise((resolve) => {
+    let resolved = false;
+    let child = null;
+
+    async function done(result) {
+      if (resolved) return;
+      resolved = true;
+      try { 
+        if (watcher) watcher.close(); 
+      } catch {}
+      clearTimeout(timeout);
+      clearInterval(cancelCheckInterval);
+      try { 
+        if (child) child.kill(); 
+      } catch {}
+      resolve(result);
+    }
+
+    function checkResult() {
+      if (!resolved && fs.existsSync(resultFile)) {
+        try {
+          const content = fs.readFileSync(resultFile, 'utf8');
+          if (content.includes('VCM_CHECK_OK')) {
+            done({ status: 'success', message: 'End-to-end check passed', checkedAt });
+          }
+        } catch {}
+      }
+    }
+
+    const watcher = chokidar.watch(resultFile, { persistent: true, ignoreInitial: false, disableGlobbing: true });
+    watcher.on('add', checkResult);
+    watcher.on('change', checkResult);
+
+    const timeout = setTimeout(() => {
+      let diagnosis = '';
+      if (def.type === 'ide') {
+        const info = IDE_INFO[providerId] || IDE_INFO[def.ide] || null;
+        const processInfo = getIdeProcess(providerId);
+        diagnosis = processInfo ? 'IDE is running but check timed out' : 'IDE process not found';
+      } else {
+        diagnosis = 'Provider check timed out';
+      }
+      done({ status: 'timeout', message: `Check timed out (${def.type === 'ide' ? '5min' : '1min'}). ${diagnosis}`, checkedAt });
+    }, def.type === 'ide' ? IDE_TIMEOUT_MS : DIRECT_TIMEOUT_MS);
+
+    const cancelCheckInterval = setInterval(() => {
+      if (resolved) return;
+      // Additional periodic checks can be added here
+    }, 10000);
+
+    // Prepare environment
+    const env = { ...process.env };
+    env.NODE_BINARY_PATH = getNodeExecutable();
+    if (repoPath) {
+      env.VCM_CHECK_REPO = repoPath;
+    }
+
+    // Run the check
+    try {
+      const nodePath = getNodeExecutable();
+      const args = [CLI_ENTRY_POINT, 'check-provider', providerId];
+      
+      child = spawn(nodePath, args, {
+        stdio: 'ignore',
+        env,
+        cwd: repoPath || process.cwd(),
+        detached: true
+      });
+
+      child.on('error', (error) => {
+        done({ status: 'error', message: `Failed to start check: ${error.message}`, checkedAt });
+      });
+
+      child.on('exit', (code, signal) => {
+        if (!resolved) {
+          if (signal === 'SIGTERM' || signal === 'SIGKILL') {
+            // Expected termination
+            return;
+          }
+          if (code === 0) {
+            // Success, but we should have gotten the result via file
+            setTimeout(() => {
+              if (!resolved) {
+                checkResult();
+                if (!resolved) {
+                  done({ status: 'partial', message: 'Check completed but no result file found', checkedAt });
+                }
+              }
+            }, 2000);
+          } else {
+            done({ status: 'error', message: `Check failed with exit code ${code}`, checkedAt });
+          }
+        }
+      });
+
+    } catch (error) {
+      done({ status: 'error', message: `Failed to execute check: ${error.message}`, checkedAt });
+    }
+  });
+}
+
+module.exports = {
+  checkProviderReachable,
+  getResultFilePath,
+  removeTestRequirement,
+  DIRECT_TIMEOUT_MS,
+  IDE_TIMEOUT_MS
+};

package/src/utils/provider-checkers/provider-checker-main.js

@@ -0,0 +1,107 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { checkProviderReachable, getResultFilePath, removeTestRequirement } = require('./provider-checker-core');
+
+/**
+ * Check a single provider
+ */
+async function checkProvider(providerId, config, repoPath, onProgress, signal) {
+  if (signal?.aborted) {
+    return { status: 'skipped', message: 'Check aborted' };
+  }
+
+  try {
+    // Ensure .vibecodingmachine directory exists
+    if (repoPath) {
+      const vcmDir = path.join(repoPath, '.vibecodingmachine');
+      if (!fs.existsSync(vcmDir)) {
+        fs.mkdirSync(vcmDir, { recursive: true });
+      }
+    }
+
+    // Add test requirement
+    if (repoPath) {
+      const { getRequirementsPath } = require('vibecodingmachine-core');
+      let reqPath;
+      try { 
+        reqPath = await getRequirementsPath(repoPath); 
+      } catch {
+        reqPath = path.join(repoPath, '.vibecodingmachine', 'REQUIREMENTS.md');
+      }
+      
+      if (fs.existsSync(reqPath)) {
+        const content = fs.readFileSync(reqPath, 'utf8');
+        if (!content.includes('AGENT_CHECK')) {
+          fs.appendFileSync(reqPath, '\n## 🚦 Current Status\n\nAGENT_CHECK - Provider connectivity check\n\n');
+        }
+      }
+    }
+
+    // Perform the check
+    const result = await checkProviderReachable(providerId, config, repoPath);
+    return result;
+
+  } catch (error) {
+    return { 
+      status: 'error', 
+      message: `Check failed: ${error.message}`,
+      error: error.stack 
+    };
+  }
+}
+
+/**
+ * Check all providers
+ */
+async function checkAllProviders(config, repoPath, onProgress, signal) {
+  const results = {};
+  const providerIds = Object.keys(config.providers || {});
+
+  for (const id of providerIds) {
+    if (signal?.aborted) break;
+    
+    if (onProgress) onProgress(id, 'starting');
+    results[id] = await checkProvider(id, config, repoPath, onProgress, signal);
+    if (onProgress) onProgress(id, 'done', results[id]);
+  }
+
+  // Final cleanup — remove requirement if still pending (all agents failed or skipped)
+  if (repoPath) {
+    const { getRequirementsPath } = require('vibecodingmachine-core');
+    let reqPath;
+    try { 
+      reqPath = await getRequirementsPath(repoPath); 
+    } catch {
+      reqPath = path.join(repoPath, '.vibecodingmachine', 'REQUIREMENTS.md');
+    }
+    try { 
+      removeTestRequirement(reqPath); 
+    } catch {}
+    try { 
+      fs.unlinkSync(getResultFilePath(repoPath)); 
+    } catch {}
+  }
+
+  return results;
+}
+
+/**
+ * Format a checkedAt ISO timestamp for display.
+ * e.g. "April 12, 2025 at 4:23 pm"
+ */
+function formatCheckedAt(checkedAt) {
+  if (!checkedAt) return '';
+  const d = new Date(checkedAt);
+  if (isNaN(d.getTime())) return checkedAt;
+  const months = ['January','February','March','April','May','June','July','August','September','October','November','December'];
+  const timePart = d.toLocaleTimeString('en-US', { hour: 'numeric', minute: '2-digit', hour12: true }).toLowerCase();
+  return `${months[d.getMonth()]} ${d.getDate()}, ${d.getFullYear()} at ${timePart}`;
+}
+
+module.exports = { 
+  checkProvider, 
+  checkAllProviders, 
+  formatCheckedAt 
+};

package/src/utils/provider-manager.js

@@ -1,7 +1,7 @@
 const chalk = require('chalk');
 const readline = require('readline');
 const { t } = require('vibecodingmachine-core');
-const { getProviderDefinitions, getProviderPreferences, saveProviderPreferences, getProviderCache, setProviderCache } = require('../utils/provider-registry');
+const { getProviderDefinitions, getProviderPreferences, saveProviderPreferences, getProviderCache, setProviderCache, getDefaultProviderOrder } = require('../utils/provider-registry');
 const { checkVSCodeExtension, checkAppOrBinary } = require('./ide-detection');
 const { formatIDEName, getAgentDisplayName } = require('./display-formatters');
 const { IDEHealthTracker } = require('vibecodingmachine-core');
@@ -19,7 +19,7 @@ async function showProviderManagerMenu() {
   const definitions = getProviderDefinitions();
   const defMap = new Map(definitions.map(def => [def.id, def]));
   const prefs = await getProviderPreferences();
-  let order = prefs.order.slice();
+  let order = Array.isArray(prefs.order) ? prefs.order.slice() : getDefaultProviderOrder();
   let enabled = { ...prefs.enabled };
   let selectedIndex = 0;
   let dirty = false;
@@ -104,7 +104,7 @@ async function showProviderManagerMenu() {
     console.log(chalk.bold.cyan('⚙ ' + t('provider.title') + '\n'));
 
     // Header
-    console.log(chalk.gray('Use ↑↓ to move, Space to toggle, → to configure, X/ESC to exit\n'));
+    console.log(chalk.gray('Use ↑↓ to move, Space to toggle, </> to reorder (< down, > up), → to configure, !/1 to check agents, X/ESC to exit\n'));
 
     // Display providers
     order.forEach((id, index) => {
@@ -123,6 +123,17 @@ async function showProviderManagerMenu() {
         statusIcon = isEnabled ? '🟢' : '🔴';
         statusColor = isEnabled ? chalk.green : chalk.red;
         statusText = isEnabled ? 'Enabled' : 'Disabled';
+      } else {
+        // Show enabled/disabled state even for uninstalled agents
+        if (isEnabled) {
+          statusIcon = '🟡';
+          statusColor = chalk.yellow;
+          statusText = 'Enabled (not installed)';
+        } else {
+          statusIcon = '⚪';
+          statusColor = chalk.gray;
+          statusText = 'Disabled (not installed)';
+        }
       }
 
       const prefix = isSelected ? chalk.cyan('❯ ') : '  ';
@@ -174,6 +185,27 @@ async function showProviderManagerMenu() {
     }
 
     switch (key.name) {
+      case '!':
+      case '1':
+        // Run agents check command
+        isMenuActive = false;
+        if (dirty) {
+          await saveProviderPreferences({ order, enabled });
+          await setProviderCache(Object.fromEntries(installationStatus));
+        }
+        // Trigger agents check after returning
+        setTimeout(() => {
+          console.clear();
+          console.log(chalk.bold.cyan('🔍 Checking agents...\n'));
+          require('../commands/agents-check')().then(() => {
+            process.exit(0);
+          }).catch((err) => {
+            console.log(chalk.red('Agents check error: ' + err.message));
+            process.exit(1);
+          });
+        }, 100);
+        return;
+
       case 'escape':
       case 'x':
         isMenuActive = false;
@@ -191,6 +223,30 @@ async function showProviderManagerMenu() {
         selectedIndex = Math.min(order.length - 1, selectedIndex + 1);
         break;
 
+      case 'left':
+      case '<':
+        // Move selected provider down in order
+        if (selectedIndex < order.length - 1) {
+          const temp = order[selectedIndex];
+          order[selectedIndex] = order[selectedIndex + 1];
+          order[selectedIndex + 1] = temp;
+          selectedIndex++;
+          dirty = true;
+        }
+        break;
+
+      case 'right':
+      case '>':
+        // Move selected provider up in order
+        if (selectedIndex > 0) {
+          const temp = order[selectedIndex];
+          order[selectedIndex] = order[selectedIndex - 1];
+          order[selectedIndex - 1] = temp;
+          selectedIndex--;
+          dirty = true;
+        }
+        break;
+
       case 'space':
       case 'return':
         const currentId = order[selectedIndex];
@@ -198,7 +254,7 @@ async function showProviderManagerMenu() {
         dirty = true;
         break;
 
-      case 'right':
+      case 'c':
         // Configure selected provider
         const selectedId = order[selectedIndex];
         const def = defMap.get(selectedId);

package/src/utils/provider-registry.js

@@ -110,6 +110,14 @@ const PROVIDER_DEFINITIONS = [
     defaultModel: 'cline-cli',
     estimatedSpeed: 55000
   },
+  {
+    id: 'opencode',
+    name: 'OpenCode CLI',
+    type: 'direct',
+    category: 'llm',
+    defaultModel: 'opencode-cli',
+    estimatedSpeed: 40000
+  },
   {
     id: 'replit',
     name: 'Replit Agent',
@@ -157,6 +165,7 @@ function getProviderDisplayName(id) {
     'vscode': 'ide.agent.vscode',
     'cline': 'ide.agent.cline',
     'claude-code': 'ide.agent.claude.code',
+    'opencode': 'ide.agent.opencode',
     'antigravity': 'ide.agent.antigravity',
     'github-copilot': 'ide.agent.github.copilot',
     'amazon-q': 'ide.agent.amazon.q',
@@ -185,12 +194,13 @@ function mergeProviderPreferences(autoConfig) {
 
   const defaultOrder = getDefaultProviderOrder();
   const cleanedOrder = order.filter(id => getProviderDefinition(id));
-  defaultOrder.forEach(id => {
+  defaultOrder.forEach((id, index) => {
     if (!cleanedOrder.includes(id)) {
       cleanedOrder.push(id);
     }
     if (enabled[id] === undefined) {
-      enabled[id] = false;
+      // Enable the first provider by default (antigravity)
+      enabled[id] = index === 0;
     }
   });
 
@@ -205,12 +215,23 @@ async function getProviderPreferences() {
 async function saveProviderPreferences(order, enabled) {
   await setAutoConfig({
     providerPreferences: {
-      order: order.slice(),
+      order: Array.isArray(order) ? order.slice() : [],
       enabled: { ...enabled }
     }
   });
 }
 
+async function getProviderCache() {
+  const autoConfig = await getAutoConfig();
+  return autoConfig.providerCache || {};
+}
+
+async function setProviderCache(cache) {
+  await setAutoConfig({
+    providerCache: { ...cache }
+  });
+}
+
 module.exports = {
   getProviderDefinitions,
   getProviderDefinition,
@@ -219,6 +240,8 @@ module.exports = {
   mergeProviderPreferences,
   getProviderPreferences,
   saveProviderPreferences,
+  getProviderCache,
+  setProviderCache,
   PROVIDER_DEFINITIONS
 };
 

package/src/utils/provider-utils.js

@@ -0,0 +1,173 @@
+/**
+ * Provider Utils Module
+ * 
+ * Contains utility functions for provider checking.
+ */
+
+const { spawn, execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+const CLI_ENTRY_POINT = path.resolve(path.join(__dirname, '../../bin/vibecodingmachine.js'));
+
+/**
+ * Get the Node.js executable path
+ * When running in Electron, process.execPath points to electron executable, not node
+ */
+function getNodeExecutable() {
+  // First try to get the actual node executable from process.env
+  if (process.env.NODE_BINARY_PATH) {
+    return process.env.NODE_BINARY_PATH;
+  }
+  
+  // Try to find node in PATH
+  try {
+    const nodeCmd = process.platform === 'win32' ? 'where node' : 'which node';
+    const nodePath = execSync(nodeCmd, { encoding: 'utf8' }).trim().split('\n')[0];
+    if (nodePath && fs.existsSync(nodePath)) {
+      return nodePath;
+    }
+  } catch (_) {}
+  
+  // Fallback: try common node installation paths
+  const commonPaths = process.platform === 'win32'
+    ? [
+        'C:\\Program Files\\nodejs\\node.exe',
+        'C:\\Program Files (x86)\\nodejs\\node.exe',
+        path.join(process.env.PROGRAMFILES || '', 'nodejs', 'node.exe'),
+        path.join(process.env['PROGRAMFILES(X86)'] || '', 'nodejs', 'node.exe')
+      ]
+    : [
+        '/usr/bin/node',
+        '/usr/local/bin/node',
+        '/opt/homebrew/bin/node'
+      ];
+  
+  for (const nodePath of commonPaths) {
+    if (nodePath && fs.existsSync(nodePath)) {
+      return nodePath;
+    }
+  }
+  
+  // Last resort: use process.execPath (might be electron but worth trying)
+  console.warn('[AGENT CHECK] Could not find node executable, falling back to process.execPath');
+  return process.execPath;
+}
+
+/**
+ * Get result file path for provider check
+ */
+function getResultFilePath(repoPath) {
+  return path.join(repoPath, '.vibecodingmachine', 'agent-check-results.json');
+}
+
+/**
+ * Remove test requirement from requirements file
+ */
+function removeTestRequirement(reqPath) {
+  if (!fs.existsSync(reqPath)) return;
+  
+  const content = fs.readFileSync(reqPath, 'utf8');
+  const lines = content.split('\n');
+  
+  // Find and remove the test requirement
+  const startIdx = lines.findIndex(line => line.includes('### AGENT CHECK TEST'));
+  if (startIdx !== -1) {
+    let endIdx = startIdx + 1;
+    while (endIdx < lines.length && !lines[endIdx].startsWith('###') && !lines[endIdx].startsWith('##')) {
+      endIdx++;
+    }
+    lines.splice(startIdx, endIdx - startIdx);
+    fs.writeFileSync(reqPath, lines.join('\n'));
+  }
+}
+
+/**
+ * Format a checkedAt ISO timestamp for display.
+ * e.g. "April 12, 2025 at 4:23 pm"
+ */
+function formatCheckedAt(checkedAt) {
+  if (!checkedAt) return '';
+  const d = new Date(checkedAt);
+  if (isNaN(d.getTime())) return checkedAt;
+  const months = ['January','February','March','April','May','June','July','August','September','October','November','December'];
+  const timePart = d.toLocaleTimeString('en-US', { hour: 'numeric', minute: '2-digit', hour12: true }).toLowerCase();
+  return `${months[d.getMonth()]} ${d.getDate()}, ${d.getFullYear()} at ${timePart}`;
+}
+
+/**
+ * Create a test requirement for checking
+ */
+function createTestRequirement(reqPath) {
+  const testReq = `### AGENT CHECK TEST
+
+**Status:** NOT WORKING
+**Response from last chat:** Testing provider connectivity...
+
+---
+
+This is a temporary test requirement used to verify agent providers are working.
+It will be automatically removed after the check completes.
+`;
+
+  try {
+    // Ensure directory exists
+    fs.mkdirSync(path.dirname(reqPath), { recursive: true });
+    
+    // Read existing content
+    let content = '';
+    if (fs.existsSync(reqPath)) {
+      content = fs.readFileSync(reqPath, 'utf8');
+    } else {
+      content = '# Requirements\n\n';
+    }
+    
+    // Add test requirement
+    if (!content.includes('### AGENT CHECK TEST')) {
+      content += '\n' + testReq;
+      fs.writeFileSync(reqPath, content);
+    }
+  } catch (error) {
+    console.warn('[AGENT CHECK] Could not create test requirement:', error.message);
+  }
+}
+
+/**
+ * Parse provider check result from file
+ */
+function parseResultFile(resultFile) {
+  try {
+    if (!fs.existsSync(resultFile)) {
+      return null;
+    }
+    
+    const content = fs.readFileSync(resultFile, 'utf8');
+    const lines = content.trim().split('\n');
+    
+    // Find the result line (should be the last non-empty line)
+    for (let i = lines.length - 1; i >= 0; i--) {
+      const line = lines[i].trim();
+      if (line && !line.startsWith('[') && !line.startsWith('Agent check')) {
+        try {
+          return JSON.parse(line);
+        } catch {
+          // Not JSON, continue searching
+        }
+      }
+    }
+  } catch (error) {
+    console.warn('[AGENT CHECK] Error parsing result file:', error.message);
+  }
+  
+  return null;
+}
+
+module.exports = {
+  getNodeExecutable,
+  getResultFilePath,
+  removeTestRequirement,
+  formatCheckedAt,
+  createTestRequirement,
+  parseResultFile,
+  CLI_ENTRY_POINT
+};