vibecodingmachine-cli 2026.1.29-713 → 2026.2.20-423

package/src/utils/provider-checker.js

@@ -0,0 +1,410 @@
+'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
+};
+
+/**
+ * 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-manager.js

@@ -0,0 +1,251 @@
+const chalk = require('chalk');
+const readline = require('readline');
+const { t } = require('vibecodingmachine-core');
+const { getProviderDefinitions, getProviderPreferences, saveProviderPreferences, getProviderCache, setProviderCache } = require('../utils/provider-registry');
+const { checkVSCodeExtension, checkAppOrBinary } = require('./ide-detection');
+const { formatIDEName, getAgentDisplayName } = require('./display-formatters');
+const { IDEHealthTracker } = require('vibecodingmachine-core');
+
+/**
+ * Show provider manager menu for IDE and AI provider configuration
+ */
+async function showProviderManagerMenu() {
+  if (process.env.VCM_DEBUG_MENU === '1') {
+    const msg = `[DEBUG-MENU ${new Date().toISOString()}] showProviderManagerMenu() called\n` + new Error().stack.split('\n').slice(1, 6).join('\n') + '\n';
+    console.log(msg);
+    try { require('fs').appendFileSync('/tmp/vcm-menu-debug.log', msg); } catch (e) { }
+  }
+
+  const definitions = getProviderDefinitions();
+  const defMap = new Map(definitions.map(def => [def.id, def]));
+  const prefs = await getProviderPreferences();
+  let order = prefs.order.slice();
+  let enabled = { ...prefs.enabled };
+  let selectedIndex = 0;
+  let dirty = false;
+
+  const { fetchQuotaForAgent } = require('vibecodingmachine-core/src/quota-management');
+  const ProviderManager = require('vibecodingmachine-core/src/ide-integration/provider-manager.cjs');
+  const providerManager = new ProviderManager();
+
+  const debugQuota = process.env.VCM_DEBUG_QUOTA === '1' || process.env.VCM_DEBUG_QUOTA === 'true';
+
+  const formatDuration = (ms) => {
+    if (!ms || ms <= 0) return 'now';
+    const totalSeconds = Math.ceil(ms / 1000);
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const seconds = totalSeconds % 60;
+
+    if (hours > 0) return `${hours}h ${minutes}m`;
+    if (minutes > 0) return `${minutes}m ${seconds}s`;
+    return `${seconds}s`;
+  };
+
+  const formatTimeAmPm = (date) => {
+    const hours24 = date.getHours();
+    const minutes = String(date.getMinutes()).padStart(2, '0');
+    const ampm = hours24 >= 12 ? 'pm' : 'am';
+    const hours12 = (hours24 % 12) || 12;
+    return `${hours12}:${minutes} ${ampm}`;
+  };
+
+  // Pre-fetch data to avoid lag in render loop
+  const sharedAuth = require('vibecodingmachine-core/src/auth/shared-auth-storage');
+
+  // Initialize caches from persistent storage
+  const savedCache = await getProviderCache();
+
+  // Hydrate local maps from saved cache
+  const installationStatus = new Map();
+  const agentQuotas = new Map();
+
+  Object.keys(savedCache).forEach(id => {
+    if (savedCache[id].installed !== undefined) {
+      installationStatus.set(id, savedCache[id].installed);
+    }
+    if (savedCache[id].quota) {
+      agentQuotas.set(id, savedCache[id].quota);
+    }
+  });
+
+  // Also prefill agent quotas from the ProviderManager rate-limit file
+  try {
+    const { getProviderRateLimitedQuotas } = require('./provider-rate-cache');
+    const prefetched = getProviderRateLimitedQuotas(definitions);
+    for (const [id, q] of prefetched) {
+      const existing = agentQuotas.get(id);
+      if (!existing || existing.type !== 'rate-limit') {
+        agentQuotas.set(id, q);
+      }
+    }
+  } catch (e) {
+    // Ignore — this is a non-critical optimization
+  }
+
+  // Default values while loading
+  let quotaInfo = { maxIterations: 10, todayUsage: 0 };
+  let autoConfig = {};
+  let isMenuActive = true;
+
+  // Load health metrics for all IDEs
+  let healthMetricsMap = new Map();
+  try {
+    const healthTracker = new IDEHealthTracker();
+    await healthTracker.load();
+    healthMetricsMap = await healthTracker.getAllHealthMetrics();
+  } catch (error) {
+    // Silently ignore health loading errors
+  }
+
+  const render = async () => {
+    if (!isMenuActive) return;
+    process.stdout.write('\x1Bc');
+    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'));
+
+    // Display providers
+    order.forEach((id, index) => {
+      const def = defMap.get(id);
+      if (!def) return;
+
+      const isSelected = index === selectedIndex;
+      const isEnabled = enabled[id];
+      const isInstalled = installationStatus.get(id) || false;
+
+      let statusIcon = '⚪';
+      let statusColor = chalk.gray;
+      let statusText = 'Not installed';
+
+      if (isInstalled) {
+        statusIcon = isEnabled ? '🟢' : '🔴';
+        statusColor = isEnabled ? chalk.green : chalk.red;
+        statusText = isEnabled ? 'Enabled' : 'Disabled';
+      }
+
+      const prefix = isSelected ? chalk.cyan('❯ ') : '  ';
+      const name = getAgentDisplayName(id);
+      const line = `${prefix}${statusIcon} ${statusColor(name)} ${chalk.gray(`- ${statusText}`)}`;
+
+      console.log(line);
+
+      if (isSelected && def) {
+        // Show details for selected provider
+        console.log(chalk.gray(`\n  ${def.description || 'No description available'}`));
+
+        // Show quota information
+        const quota = agentQuotas.get(id);
+        if (quota) {
+          console.log(chalk.gray(`  Quota: ${quota.type === 'rate-limit' ? 'Rate limited' : `${quota.used || 0}/${quota.max || 'unlimited'}`}`));
+          if (quota.type === 'rate-limit' && quota.resetAt) {
+            const resetTime = new Date(quota.resetAt);
+            console.log(chalk.gray(`  Resets at: ${formatTimeAmPm(resetTime)} (${formatDuration(resetTime - Date.now())})`));
+          }
+        }
+
+        // Show health metrics if available
+        const health = healthMetricsMap.get(id);
+        if (health) {
+          const healthColor = health.score >= 80 ? chalk.green : health.score >= 50 ? chalk.yellow : chalk.red;
+          console.log(chalk.gray(`  Health: ${healthColor(health.score + '%')}`));
+        }
+
+        // Show configuration options
+        if (def.configOptions && def.configOptions.length > 0) {
+          console.log(chalk.gray(`\n  Configuration options:`));
+          def.configOptions.forEach(option => {
+            console.log(chalk.gray(`    • ${option.name}: ${option.description || 'No description'}`));
+          });
+        }
+      }
+    });
+
+    console.log();
+  };
+
+  const handleKeypress = async (str, key) => {
+    if (!isMenuActive) return;
+
+    if (key.ctrl && key.name === 'c') {
+      process.exit(0);
+      return;
+    }
+
+    switch (key.name) {
+      case 'escape':
+      case 'x':
+        isMenuActive = false;
+        if (dirty) {
+          await saveProviderPreferences({ order, enabled });
+          await setProviderCache(Object.fromEntries(installationStatus));
+        }
+        return;
+
+      case 'up':
+        selectedIndex = Math.max(0, selectedIndex - 1);
+        break;
+
+      case 'down':
+        selectedIndex = Math.min(order.length - 1, selectedIndex + 1);
+        break;
+
+      case 'space':
+      case 'return':
+        const currentId = order[selectedIndex];
+        enabled[currentId] = !enabled[currentId];
+        dirty = true;
+        break;
+
+      case 'right':
+        // Configure selected provider
+        const selectedId = order[selectedIndex];
+        const def = defMap.get(selectedId);
+        if (def && def.configOptions && def.configOptions.length > 0) {
+          console.log(chalk.cyan(`\nConfiguring ${getAgentDisplayName(selectedId)}...\n`));
+          // Here you would implement configuration logic
+          console.log(chalk.gray('Configuration not yet implemented in CLI'));
+          await new Promise(resolve => {
+            process.stdin.once('keypress', () => resolve());
+          });
+        }
+        break;
+
+      default:
+        return;
+    }
+
+    await render();
+  };
+
+  // Initial render
+  await render();
+
+  // Set up keypress handling
+  readline.emitKeypressEvents(process.stdin);
+  if (process.stdin.isTTY) {
+    process.stdin.setRawMode(true);
+  }
+
+  process.stdin.on('keypress', handleKeypress);
+  process.stdin.resume();
+
+  // Wait for menu to close
+  return new Promise((resolve) => {
+    const checkInterval = setInterval(() => {
+      if (!isMenuActive) {
+        clearInterval(checkInterval);
+        process.stdin.removeListener('keypress', handleKeypress);
+        if (process.stdin.isTTY) {
+          process.stdin.setRawMode(false);
+        }
+        resolve();
+      }
+    }, 100);
+  });
+}
+
+module.exports = {
+  showProviderManagerMenu
+};