vibecodingmachine-cli 2026.2.20-438 → 2026.2.26-1739

package/src/utils/provider-checker.js

@@ -1,410 +1,15 @@
 'use strict';
 
-const { spawn, execSync } = require('child_process');
-const fs = require('fs');
-const path = require('path');
-const chokidar = require('chokidar');
-
-const CLI_ENTRY_POINT = path.join(__dirname, '../../bin/vibecodingmachine.js');
-
-// Timeout for direct LLM round-trips via auto:direct (ms)
-const DIRECT_TIMEOUT_MS = 60000;
-// Timeout for IDE automation round-trips via auto:start (ms)
-const IDE_TIMEOUT_MS = 90000;
-
-// Direct CLI providers that can be auto-installed via npm
-const CLI_AUTO_INSTALL = {
-  'cline': { cmd: 'cline', pkg: '@cline/cli' },
-};
-
-/**
- * Check if a CLI command is available in PATH.
- */
-function isCLIAvailable(cmd) {
-  try {
-    execSync(`which "${cmd}"`, { stdio: 'ignore' });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Install a CLI tool globally via npm and wait for it to complete.
- * Returns { installed: bool, note: string }.
- */
-async function installCLI(pkg, cmd) {
-  return new Promise((resolve) => {
-    const proc = spawn('npm', ['install', '-g', pkg], { stdio: ['ignore', 'pipe', 'pipe'] });
-    let out = '';
-    proc.stdout.on('data', d => { out += d.toString(); });
-    proc.stderr.on('data', d => { out += d.toString(); });
-    proc.on('error', () => resolve({ installed: false, note: `Failed to run npm install -g ${pkg}` }));
-    proc.on('close', (code) => {
-      if (code === 0 && isCLIAvailable(cmd)) {
-        resolve({ installed: true, note: `Installed ${pkg} via npm` });
-      } else {
-        resolve({ installed: false, note: `npm install -g ${pkg} exited (${code})` });
-      }
-    });
-  });
-}
-
-// Map provider id → { process: macOS process name, app: macOS app name for `open -a` }
-const IDE_INFO = {
-  windsurf:       { process: 'Windsurf',            app: 'Windsurf' },
-  cursor:         { process: 'Cursor',              app: 'Cursor' },
-  antigravity:    { process: 'Antigravity',         app: 'Antigravity' },
-  kiro:           { process: 'Code',                app: 'Kiro' },
-  'github-copilot': { process: 'Code',              app: 'Visual Studio Code' },
-  'amazon-q':     { process: 'Code',                app: 'Visual Studio Code' },
-  cline:          { process: 'Code',                app: 'Visual Studio Code' },
-  vscode:         { process: 'Code',                app: 'Visual Studio Code' },
-  replit:         { process: null,                  app: null },   // web-based
+// Import all provider checker modules
+const { checkProvider, checkAllProviders } = require('./provider-checker/provider-validator');
+const { formatCheckedAt } = require('./provider-checker/time-formatter');
+const { DIRECT_TIMEOUT_MS, IDE_TIMEOUT_MS } = require('./provider-checker/agent-runner');
+
+// Re-export the main API
+module.exports = { 
+  checkProvider, 
+  checkAllProviders, 
+  formatCheckedAt, 
+  DIRECT_TIMEOUT_MS, 
+  IDE_TIMEOUT_MS 
 };
-
-/**
- * Returns true if the IDE process is currently running.
- */
-function isIDERunning(processName) {
-  if (!processName || process.platform !== 'darwin') return true; // assume running on non-mac
-  try {
-    execSync(`pgrep -x "${processName}"`, { stdio: 'ignore' });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Open the IDE using `open -a <app> <repoPath>` (macOS).
- * Returns true when the launch command was sent.
- */
-async function openIDEApp(appName, repoPath) {
-  if (!appName || process.platform !== 'darwin') return false;
-  try {
-    const safeRepo = repoPath ? ` "${repoPath.replace(/"/g, '\\"')}"` : '';
-    execSync(`open -a "${appName}"${safeRepo}`, { stdio: 'ignore' });
-    // Give it a few seconds to start before the automation begins
-    await new Promise(r => setTimeout(r, 5000));
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-const TEST_REQ_TITLE = 'VCM agent connectivity check';
-const PENDING_HEADER = '## ⏳ Requirements not yet completed';
-const VERIFIED_HEADER = '## ✅ Verified by AI';
-
-/**
- * Return the absolute path to the result file used by the check.
- */
-function getResultFilePath(repoPath) {
-  return path.join(repoPath, '.vibecodingmachine', 'temp', 'TEMP_agent_check.txt');
-}
-
-/**
- * Add the test requirement at the TOP of the pending section.
- * Idempotent — if it's already there, do nothing.
- */
-function addTestRequirement(reqPath, resultFile) {
-  let content = '';
-  try { content = fs.readFileSync(reqPath, 'utf8'); } catch {}
-
-  // Already present?
-  if (content.includes(TEST_REQ_TITLE)) return;
-
-  const testBlock = `### 1. ${TEST_REQ_TITLE}
-🚦 Current Status: PREPARE
-Create a new file at the following absolute path: ${resultFile}
-The file must contain exactly this text on the first line: VCM_CHECK_OK
-Do not modify any other files. This is an automated connectivity test.
-
-`;
-
-  const idx = content.indexOf(PENDING_HEADER);
-  if (idx !== -1) {
-    const afterHeader = idx + PENDING_HEADER.length;
-    // Insert after the header, then existing content follows
-    const before = content.slice(0, afterHeader);
-    const after = content.slice(afterHeader).replace(/^\n+/, '');
-    content = before + '\n\n' + testBlock + after;
-  } else {
-    // No pending section — prepend one
-    content = PENDING_HEADER + '\n\n' + testBlock + '\n' + (content || VERIFIED_HEADER + '\n');
-  }
-
-  fs.writeFileSync(reqPath, content, 'utf8');
-}
-
-/**
- * Remove the test requirement from REQUIREMENTS.md regardless of which section it's in.
- * Also cleans up triple-blank lines left behind.
- */
-function removeTestRequirement(reqPath) {
-  let content = '';
-  try { content = fs.readFileSync(reqPath, 'utf8'); } catch { return; }
-
-  if (!content.includes(TEST_REQ_TITLE)) return;
-
-  const lines = content.split('\n');
-
-  // Find the ### header line for this requirement
-  let blockStart = -1;
-  for (let i = 0; i < lines.length; i++) {
-    if (lines[i].includes(TEST_REQ_TITLE) || (lines[i].startsWith('###') && i + 1 < lines.length && lines[i + 1].includes(TEST_REQ_TITLE))) {
-      // Walk back to find the ### line
-      blockStart = lines[i].startsWith('###') ? i : i - 1;
-      if (blockStart < 0) blockStart = i;
-      break;
-    }
-  }
-
-  if (blockStart === -1) return;
-
-  // Find end of block (next ### or ##, or EOF)
-  let blockEnd = blockStart + 1;
-  while (blockEnd < lines.length && !lines[blockEnd].startsWith('###') && !lines[blockEnd].startsWith('## ')) {
-    blockEnd++;
-  }
-
-  lines.splice(blockStart, blockEnd - blockStart);
-  const cleaned = lines.join('\n').replace(/\n{3,}/g, '\n\n').trimEnd() + '\n';
-  fs.writeFileSync(reqPath, cleaned, 'utf8');
-}
-
-/**
- * Spawn a process and wait for it to exit. Returns { code, output }.
- */
-function spawnAndWait(cmd, args, opts = {}) {
-  return new Promise((resolve) => {
-    let output = '';
-    const child = spawn(cmd, args, { stdio: ['ignore', 'pipe', 'pipe'], ...opts });
-    child.stdout && child.stdout.on('data', d => { output += d.toString(); });
-    child.stderr && child.stderr.on('data', d => { output += d.toString(); });
-    child.on('error', () => resolve({ code: -1, output }));
-    child.on('exit', (code) => resolve({ code, output }));
-    return child;
-  });
-}
-
-/**
- * Run an agent for 1 iteration and watch for the result file to be written.
- * For IDE providers: ensure the IDE is open first, launching it if needed.
- * Returns { status, message, checkedAt }.
- */
-async function runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, signal = null) {
-  const checkedAt = new Date().toISOString();
-
-  // Ensure temp dir exists
-  fs.mkdirSync(path.dirname(resultFile), { recursive: true });
-  // Remove stale result file so we detect a fresh write
-  try { fs.unlinkSync(resultFile); } catch {}
-
-  // For IDE providers: verify the IDE is running, open it if not
-  let ideLaunchNote = '';
-  if (def.type === 'ide') {
-    const info = IDE_INFO[providerId] || IDE_INFO[def.ide] || null;
-    if (info && info.process) {
-      if (!isIDERunning(info.process)) {
-        if (info.app) {
-          await openIDEApp(info.app, repoPath);
-          ideLaunchNote = ` (VCM launched ${info.app})`;
-        }
-      }
-    }
-  }
-
-  return new Promise((resolve) => {
-    let resolved = false;
-    let child = null;
-
-    function done(result) {
-      if (resolved) return;
-      resolved = true;
-      try { 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(() => {
-      // Diagnose: is the IDE process still running?
-      let diagnosis = '';
-      if (def.type === 'ide') {
-        const info = IDE_INFO[providerId] || IDE_INFO[def.ide] || null;
-        if (info && info.process) {
-          diagnosis = isIDERunning(info.process)
-            ? ` — ${info.app || info.process} is running but did not respond`
-            : ` — ${info.app || info.process} is not running`;
-        }
-      }
-      done({ status: 'error', message: `No response within ${timeoutMs / 1000}s${ideLaunchNote}${diagnosis}`, checkedAt });
-    }, timeoutMs);
-
-    // Periodically check for cancellation signal
-    const cancelCheckInterval = setInterval(() => {
-      if (signal && signal.cancelled) {
-        done({ status: 'error', message: 'Check cancelled by user', checkedAt });
-      }
-    }, 1000); // Check every second
-
-    let args;
-    if (def.type === 'ide') {
-      args = [CLI_ENTRY_POINT, 'auto:start', '--ide', def.ide || providerId, '--max-chats', '1'];
-      if (def.defaultModel) args.push('--ide-model', String(def.defaultModel));
-      if (def.extension) args.push('--extension', String(def.extension));
-    } else {
-      // Direct LLM: use auto:direct --provider to force this specific provider
-      args = [CLI_ENTRY_POINT, 'auto:direct', '--provider', providerId, '--max-chats', '1'];
-    }
-
-    child = spawn(process.execPath, args, {
-      cwd: repoPath,
-      env: process.env,
-      stdio: ['ignore', 'pipe', 'pipe']
-    });
-
-    let output = '';
-    child.stdout.on('data', d => { output += d.toString(); });
-    child.stderr.on('data', d => { output += d.toString(); });
-
-    child.on('error', (err) => {
-      done({ status: 'error', message: `Failed to start automation: ${err.message}`, checkedAt });
-    });
-
-    child.on('exit', (code) => {
-      if (resolved) return;
-      // Check one more time after process exits
-      checkResult();
-      if (!resolved) {
-        const tail = output.slice(-300).trim().replace(/\n/g, ' ');
-        done({ status: 'error', message: `Automation exited (code ${code})${tail ? ': ' + tail : ''}`, checkedAt });
-      }
-    });
-  });
-}
-
-/**
- * Check a single provider end-to-end using the actual REQUIREMENTS.md.
- *
- * Flow:
- *   1. Add test requirement to top of REQUIREMENTS.md
- *   2. Run the agent for 1 iteration
- *   3. On success, requirement is auto-moved to Verified by the agent; remove it
- *   4. On failure, leave requirement in pending for the NEXT agent (caller handles cleanup)
- *
- * Returns { status, message, checkedAt, requirementLeftPending }
- */
-async function checkProvider(providerId, config = {}, repoPath, onProgress = null, signal = null) {
-  const { getProviderDefinition } = require('./provider-registry');
-  const def = getProviderDefinition(providerId);
-  if (!def) {
-    return { status: 'error', message: `Unknown provider: ${providerId}`, checkedAt: new Date().toISOString(), requirementLeftPending: false };
-  }
-
-  if (!repoPath) {
-    return { status: 'error', message: 'No repository path available', checkedAt: new Date().toISOString(), requirementLeftPending: false };
-  }
-
-  const { getRequirementsPath } = require('vibecodingmachine-core');
-  let reqPath;
-  try {
-    reqPath = await getRequirementsPath(repoPath);
-  } catch {
-    reqPath = path.join(repoPath, '.vibecodingmachine', 'REQUIREMENTS.md');
-  }
-
-  const resultFile = getResultFilePath(repoPath);
-
-  // For direct CLI providers: auto-install if missing
-  const cliInfo = CLI_AUTO_INSTALL[providerId];
-  if (cliInfo && !isCLIAvailable(cliInfo.cmd)) {
-    if (onProgress) onProgress(providerId, 'installing');
-    const { installed, note } = await installCLI(cliInfo.pkg, cliInfo.cmd);
-    if (!installed) {
-      return { status: 'error', message: `${def.name} not installed and auto-install failed: ${note}`, checkedAt: new Date().toISOString(), requirementLeftPending: false };
-    }
-  }
-
-  // Add test requirement (idempotent — safe to call even if already present from a prior failed agent)
-  try { addTestRequirement(reqPath, resultFile); } catch (err) {
-    return { status: 'error', message: `Could not write to REQUIREMENTS.md: ${err.message}`, checkedAt: new Date().toISOString(), requirementLeftPending: false };
-  }
-
-  const timeoutMs = def.type === 'ide' ? IDE_TIMEOUT_MS : DIRECT_TIMEOUT_MS;
-  const result = await runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, signal);
-
-  if (result.status === 'success') {
-    // Agent completed — requirement has been moved to Verified; remove it and the result file
-    try { removeTestRequirement(reqPath); } catch {}
-    try { fs.unlinkSync(resultFile); } catch {}
-    return { ...result, requirementLeftPending: false };
-  }
-
-  // Agent failed — leave the requirement in pending for the next agent
-  return { ...result, requirementLeftPending: true };
-}
-
-/**
- * Check all providers sequentially.
- * The test requirement is shared: it stays pending between agents until one
- * succeeds, then it's removed. If all fail, it's removed at the end.
- *
- * Returns { [providerId]: checkResult }
- */
-async function checkAllProviders(providerIds, config = {}, repoPath, onProgress = null, signal = null) {
-  const results = {};
-
-  for (const id of providerIds) {
-    if (signal && signal.cancelled) break;
-    if (onProgress) onProgress(id, 'checking');
-    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, DIRECT_TIMEOUT_MS, IDE_TIMEOUT_MS };

package/src/utils/provider-checkers/ide-manager.js

@@ -0,0 +1,128 @@
+'use strict';
+
+const { spawn, execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * IDE information and management
+ */
+const IDE_INFO = {
+  'cursor': {
+    app: 'Cursor',
+    binaryName: 'Cursor',
+    processName: 'Cursor',
+    bundleId: 'com.cursor.Cursor',
+    paths: {
+      darwin: ['/Applications/Cursor.app'],
+      win32: ['C:\\Program Files\\Cursor\\Cursor.exe', 'C:\\Program Files (x86)\\Cursor\\Cursor.exe'],
+      linux: ['/usr/bin/cursor', '/usr/local/bin/cursor']
+    }
+  },
+  'windsurf': {
+    app: 'Windsurf',
+    binaryName: 'windsurf',
+    processName: 'windsurf',
+    bundleId: 'com.windsurf.Windsurf',
+    paths: {
+      darwin: ['/Applications/Windsurf.app'],
+      win32: ['C:\\Program Files\\Windsurf\\Windsurf.exe', 'C:\\Program Files (x86)\\Windsurf\\Windsurf.exe'],
+      linux: ['/usr/bin/windsurf', '/usr/local/bin/windsurf']
+    }
+  },
+  'vscode': {
+    app: 'VS Code',
+    binaryName: 'code',
+    processName: 'Code',
+    bundleId: 'com.microsoft.VSCode',
+    paths: {
+      darwin: ['/Applications/Visual Studio Code.app'],
+      win32: ['C:\\Program Files\\Microsoft VS Code\\Code.exe', 'C:\\Program Files (x86)\\Microsoft VS Code\\Code.exe'],
+      linux: ['/usr/bin/code', '/usr/local/bin/code']
+    }
+  }
+};
+
+/**
+ * Check if IDE is installed
+ */
+function isIdeInstalled(providerId) {
+  const info = IDE_INFO[providerId];
+  if (!info) return false;
+
+  const platform = process.platform;
+  const paths = info.paths[platform] || [];
+
+  return paths.some(p => {
+    try {
+      return fs.existsSync(p);
+    } catch {
+      return false;
+    }
+  });
+}
+
+/**
+ * Get running IDE process
+ */
+function getIdeProcess(providerId) {
+  const info = IDE_INFO[providerId];
+  if (!info) return null;
+
+  try {
+    const cmd = process.platform === 'win32' 
+      ? `tasklist /FI "IMAGENAME eq ${info.binaryName}.exe"`
+      : `ps aux | grep -i "${info.processName}" | grep -v grep`;
+    
+    const result = execSync(cmd, { encoding: 'utf8' });
+    return result.trim().length > 0 ? result.trim() : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Launch IDE if not running
+ */
+async function launchIde(providerId) {
+  const info = IDE_INFO[providerId];
+  if (!info) return false;
+
+  const platform = process.platform;
+  const paths = info.paths[platform] || [];
+  const idePath = paths.find(p => fs.existsSync(p));
+
+  if (!idePath) return false;
+
+  try {
+    if (platform === 'darwin') {
+      // macOS: use open command
+      spawn('open', ['-a', info.app], { 
+        stdio: 'ignore',
+        detached: true
+      }).unref();
+    } else if (platform === 'win32') {
+      // Windows: spawn the executable
+      spawn(idePath, [], { 
+        stdio: 'ignore',
+        detached: true
+      }).unref();
+    } else {
+      // Linux: spawn the binary
+      spawn(info.binaryName, [], { 
+        stdio: 'ignore',
+        detached: true
+      }).unref();
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+module.exports = {
+  IDE_INFO,
+  isIdeInstalled,
+  getIdeProcess,
+  launchIde
+};

package/src/utils/provider-checkers/node-executable-finder.js

@@ -0,0 +1,51 @@
+'use strict';
+
+const { execSync } = require('child_process');
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * 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;
+}
+
+module.exports = { getNodeExecutable };