vibecodingmachine-cli 2026.3.10-1812 → 2026.3.14-1528

package/src/utils/prompt-helper.js

@@ -1,64 +1,64 @@
-const inquirer = require('inquirer');
-const chalk = require('chalk');
-
-/**
- * Enhanced inquirer.prompt that shows a helpful hint for questions with defaults
- * @param {Array} questions - Array of inquirer question objects
- * @param {Object} options - Options object
- * @param {boolean} options.showDefaultHint - Whether to show the default hint (default: true)
- * @returns {Promise} - Promise resolving to answers
- */
-async function promptWithDefaults(questions, options = {}) {
-  const { showDefaultHint = true } = options;
-  
-  // Check if any questions have defaults and if we should show the hint
-  const hasDefaults = questions.some(q => q.default !== undefined);
-  
-  if (showDefaultHint && hasDefaults) {
-    // Show the hint in gray before the first question with a default
-    console.log(chalk.gray('(Capital letters are defaults--press return to select the defaults)'));
-  }
-  
-  return await inquirer.prompt(questions);
-}
-
-/**
- * Track whether we've shown the default hint in this session
- * This ensures we only show it once per CLI session
- */
-let hasShownDefaultHint = false;
-
-/**
- * Enhanced inquirer.prompt that shows the default hint only once per session
- * @param {Array} questions - Array of inquirer question objects
- * @param {Object} options - Options object
- * @param {boolean} options.forceShowHint - Force showing the hint even if already shown
- * @returns {Promise} - Promise resolving to answers
- */
-async function promptWithDefaultsOnce(questions, options = {}) {
-  const { forceShowHint = false } = options;
-  
-  // Check if any questions have defaults
-  const hasDefaults = questions.some(q => q.default !== undefined);
-  
-  if (hasDefaults && (!hasShownDefaultHint || forceShowHint)) {
-    // Show the hint in gray before the first question with a default
-    console.log(chalk.gray('(Capital letters are defaults--press return to select the defaults)'));
-    hasShownDefaultHint = true;
-  }
-  
-  return await inquirer.prompt(questions);
-}
-
-/**
- * Reset the hint tracking (useful for testing or new sessions)
- */
-function resetDefaultHint() {
-  hasShownDefaultHint = false;
-}
-
-module.exports = {
-  promptWithDefaults,
-  promptWithDefaultsOnce,
-  resetDefaultHint
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+
+/**
+ * Enhanced inquirer.prompt that shows a helpful hint for questions with defaults
+ * @param {Array} questions - Array of inquirer question objects
+ * @param {Object} options - Options object
+ * @param {boolean} options.showDefaultHint - Whether to show the default hint (default: true)
+ * @returns {Promise} - Promise resolving to answers
+ */
+async function promptWithDefaults(questions, options = {}) {
+  const { showDefaultHint = true } = options;
+  
+  // Check if any questions have defaults and if we should show the hint
+  const hasDefaults = questions.some(q => q.default !== undefined);
+  
+  if (showDefaultHint && hasDefaults) {
+    // Show the hint in gray before the first question with a default
+    console.log(chalk.gray('(Capital letters are defaults--press return to select the defaults)'));
+  }
+  
+  return await inquirer.prompt(questions);
+}
+
+/**
+ * Track whether we've shown the default hint in this session
+ * This ensures we only show it once per CLI session
+ */
+let hasShownDefaultHint = false;
+
+/**
+ * Enhanced inquirer.prompt that shows the default hint only once per session
+ * @param {Array} questions - Array of inquirer question objects
+ * @param {Object} options - Options object
+ * @param {boolean} options.forceShowHint - Force showing the hint even if already shown
+ * @returns {Promise} - Promise resolving to answers
+ */
+async function promptWithDefaultsOnce(questions, options = {}) {
+  const { forceShowHint = false } = options;
+  
+  // Check if any questions have defaults
+  const hasDefaults = questions.some(q => q.default !== undefined);
+  
+  if (hasDefaults && (!hasShownDefaultHint || forceShowHint)) {
+    // Show the hint in gray before the first question with a default
+    console.log(chalk.gray('(Capital letters are defaults--press return to select the defaults)'));
+    hasShownDefaultHint = true;
+  }
+  
+  return await inquirer.prompt(questions);
+}
+
+/**
+ * Reset the hint tracking (useful for testing or new sessions)
+ */
+function resetDefaultHint() {
+  hasShownDefaultHint = false;
+}
+
+module.exports = {
+  promptWithDefaults,
+  promptWithDefaultsOnce,
+  resetDefaultHint
 };

package/src/utils/provider-checker/agent-checker.js

@@ -173,6 +173,7 @@ async function runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, s
  */
 async function checkProvider(providerId, config = {}, repoPath, onProgress = null, signal = null) {
   const { getProviderDefinition } = require('../provider-registry');
+  const { VERIFIED_HEADER } = require('./test-requirements');
   console.log(`[AGENT CHECK] Checking provider: ${providerId} in repo: ${repoPath}`);
 
   const def = getProviderDefinition(providerId);
@@ -191,6 +192,15 @@ async function checkProvider(providerId, config = {}, repoPath, onProgress = nul
   // Add test requirement
   addTestRequirement(reqPath, resultFile);
 
+  // Log initial status (requirement in PENDING section)
+  console.log(`[AGENT CHECK] Initial STATUS: PREPARING - Test requirement added to ${reqPath}`);
+  let initialContent = '';
+  try {
+    initialContent = fs.readFileSync(reqPath, 'utf8');
+  } catch (err) {
+    console.log(`[AGENT CHECK] Warning: Could not read requirements file: ${err.message}`);
+  }
+
   try {
     // Choose timeout based on provider type
     const timeoutMs = def.type === 'cli' ? DIRECT_TIMEOUT_MS : IDE_TIMEOUT_MS;
@@ -205,12 +215,26 @@ async function checkProvider(providerId, config = {}, repoPath, onProgress = nul
       fs.unlinkSync(resultFile);
     }
 
+    // If we reached "DONE" status, the agent is communicating successfully
+    // The automation layer works - text was sent and processed
+    if (result.status === 'success') {
+      console.log(`[AGENT CHECK] ✅ Test PASSED: Agent reached DONE status - communication verified`);
+      return {
+        ...result,
+        requirementLeftPending: false
+      };
+    }
+
+    console.log(`[AGENT CHECK] ❌ Test FAILED: Agent check did not reach DONE status`);
     return {
-      ...result,
+      status: 'error',
+      message: 'Agent check failed: did not reach DONE status',
+      checkedAt: result.checkedAt,
       requirementLeftPending: false
     };
   } catch (error) {
     // Ensure cleanup on error
+    console.log(`[AGENT CHECK] Error during check: ${error.message}`);
     removeTestRequirement(reqPath);
     if (fs.existsSync(resultFile)) {
       fs.unlinkSync(resultFile);

package/src/utils/provider-checker/agent-runner.js

@@ -7,7 +7,7 @@ const chokidar = require('chokidar');
 
 const { NODE_EXECUTABLE } = require('./node-detector');
 const { IDE_INFO, isIDERunning, openIDEApp } = require('./ide-manager');
-const { getResultFilePath, addTestRequirement, removeTestRequirement } = require('./requirements-manager');
+const { getResultFilePath, getAgentsFilePath, updateAgentStatus, getAgentStatus } = require('./agents-manager');
 
 // Timeout for direct LLM round-trips via auto:direct (ms)
 const DIRECT_TIMEOUT_MS = 60000;
@@ -15,7 +15,6 @@ const DIRECT_TIMEOUT_MS = 60000;
 const IDE_TIMEOUT_MS = 90000;
 
 const CLI_ENTRY_POINT = path.resolve(path.join(__dirname, '../../../bin/vibecodingmachine.js'));
-const TEST_REQ_TITLE = 'VCM agent connectivity check';
 
 /**
  * Run an agent for 1 iteration and watch for the result file to be written.
@@ -34,11 +33,6 @@ async function runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, s
   // Remove stale result file so we detect a fresh write
   try { fs.unlinkSync(resultFile); } catch { }
 
-  // Calculate requirements path early so it's available in the Promise scope
-  const os = require('os');
-  const hostname = os.hostname();
-  const requirementsPath = path.join(repoPath, `REQUIREMENTS-${hostname}.md`);
-
   // For IDE providers: verify the IDE is running/installed, install if needed
   let ideLaunchNote = '';
   if (def.type === 'ide') {
@@ -52,7 +46,7 @@ async function runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, s
             ideLaunchNote = ` (VCM launched ${info.app})`;
           } else {
             // Failed to launch on macOS - check if installed
-            const { IDEInstaller } = require('../../../electron-app/src/main/ide-installer');
+            const { IDEInstaller } = require('../../../../electron-app/src/main/ide-installer');
             const installer = new IDEInstaller();
             const ideKey = def.ide || providerId;
             const checkResult = await installer.checkIDEInstallation(ideKey);
@@ -67,7 +61,7 @@ async function runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, s
         }
         // Windows: check if installed, install if possible, launch if installed
         else if (process.platform === 'win32') {
-          const { IDEInstaller } = require('../../../electron-app/src/main/ide-installer');
+          const { IDEInstaller } = require('../../../../electron-app/src/main/ide-installer');
           const installer = new IDEInstaller();
           const ideKey = def.ide || providerId;
           const ideConfig = IDEInstaller.IDE_CONFIG[ideKey];
@@ -147,7 +141,7 @@ async function runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, s
     }
   }
 
-  return new Promise((resolve) => {
+  return new Promise(async (resolve) => {
     let resolved = false;
     let child = null;
     let output = '';
@@ -163,12 +157,32 @@ async function runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, s
       clearInterval(cancelCheckInterval);
       try { if (child) child.kill(); } catch { }
 
-      // Remove test requirement after check completes (pass or fail)
+      // Update agent status based on result
       try {
-        removeTestRequirement(requirementsPath);
-        console.log(`[AGENT CHECK] Removed test requirement from ${requirementsPath}`);
+        if (result.status === 'success') {
+          // Status already set to 'operational' by the IDE agent
+          console.log(`[AGENT CHECK] ${providerId} check passed - status is 'operational'`);
+        } else if (result.rateLimited) {
+          updateAgentStatus(providerId, 'rate_limited', {
+            rateLimitResume: result.rateLimitResume
+          });
+          console.log(`[AGENT CHECK] Set ${providerId} status to 'rate_limited'`);
+        } else {
+          updateAgentStatus(providerId, 'error', {
+            error: result.message
+          });
+          console.log(`[AGENT CHECK] Set ${providerId} status to 'error'`);
+        }
       } catch (err) {
-        console.warn(`[AGENT CHECK] Could not remove test requirement: ${err.message}`);
+        console.warn(`[AGENT CHECK] Could not update agent status: ${err.message}`);
+      }
+
+      // Notify UI that check is done
+      if (onProgress) {
+        const statusMessage = result.status === 'success'
+          ? 'Check completed successfully'
+          : (result.rateLimited ? 'Rate limited' : result.message);
+        onProgress(providerId, 'done', result.status !== 'success' ? result.message : null, statusMessage);
       }
 
       resolve(result);
@@ -191,20 +205,31 @@ async function runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, s
     watcher.on('add', checkResult);
     watcher.on('change', checkResult);
 
-    // Also watch requirements file for status changes to [DONE]
-    requirementsWatcher = chokidar.watch(requirementsPath, { persistent: true, ignoreInitial: true });
+    // Watch agents.json for status changes to 'operational'
+    // Use debouncing to prevent multiple rapid status checks
+    let debounceTimer = null;
+    const agentsFilePath = getAgentsFilePath();
+    requirementsWatcher = chokidar.watch(agentsFilePath, { persistent: true, ignoreInitial: true });
     requirementsWatcher.on('change', () => {
+      // Clear existing debounce timer
+      if (debounceTimer) clearTimeout(debounceTimer);
+
+      // Set new timer (50ms debounce - fast response while avoiding duplicate reads)
+      debounceTimer = setTimeout(() => {
       try {
-        const content = fs.readFileSync(requirementsPath, 'utf8');
-        // Check if test requirement status is [DONE]
-        if (content.includes(TEST_REQ_TITLE) && content.match(/VCM agent connectivity check[\s\S]*?Status:.*?\[DONE\]/)) {
-          console.log(`[AGENT CHECK] Detected [DONE] status in requirements file for ${providerId}`);
-          if (onProgress) onProgress(providerId, 'response_detected', null, 'Status updated to DONE.');
-          done({ status: 'success', message: 'Agent updated status to DONE', checkedAt });
+        const agentStatus = getAgentStatus(providerId);
+        console.log(`[AGENT CHECK] Current status for ${providerId}: ${agentStatus.status}`);
+
+        // Check if agent status is 'operational'
+        if (agentStatus.status === 'operational') {
+          console.log(`[AGENT CHECK] Detected 'operational' status in agents.json for ${providerId}`);
+          if (onProgress) onProgress(providerId, 'response_detected', null, 'Status updated to operational.');
+          done({ status: 'success', message: 'Agent updated status to operational', checkedAt });
         }
       } catch (err) {
-        console.warn(`[AGENT CHECK] Error reading requirements file: ${err.message}`);
+        console.warn(`[AGENT CHECK] Error reading agents.json: ${err.message}`);
       }
+      }, 50); // End of debounce setTimeout - reduced from 300ms to 50ms for faster response
     });
 
     const timeout = setTimeout(() => {
@@ -245,14 +270,68 @@ async function runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, s
       onProgress(providerId, 'awaiting', null, 'Awaiting response...');
     }
 
-    let args;
+    // For IDE providers: send connectivity test directly using Windows automation
+    // Don't spawn auto:start since it expects requirements files (which we removed)
     if (def.type === 'ide') {
-      args = [CLI_ENTRY_POINT, 'auto:start', '--ide', def.ide || providerId, '--max-chats', '5'];
-      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
+      try {
+        const { generateConnectivityTestMessage } = require('./agents-manager');
+        const { WindowsAutomationManager } = require('vibecodingmachine-core');
+
+        console.log(`[AGENT CHECK] Sending connectivity test directly to ${providerId}`);
+
+        // Get the test message
+        const testMessage = generateConnectivityTestMessage(def.name || providerId, providerId);
+
+        // Send directly to IDE using Windows automation
+        const automation = new WindowsAutomationManager();
+
+        // Call the appropriate method based on provider
+        let sendResult;
+        try {
+          switch(providerId.toLowerCase()) {
+            case 'windsurf':
+              sendResult = await automation.sendTextToWindsurf(testMessage);
+              break;
+            case 'cursor':
+              sendResult = await automation.sendTextToCursor(testMessage);
+              break;
+            default:
+              sendResult = { success: false, error: `No automation method for ${providerId}` };
+          }
+        } catch (sendErr) {
+          sendResult = { success: false, error: sendErr.message };
+        }
+
+        if (!sendResult || !sendResult.success) {
+          done({
+            status: 'error',
+            message: `Failed to send text to IDE: ${sendResult?.error || 'Unknown error'}`,
+            checkedAt
+          });
+          return;
+        }
+
+        console.log(`[AGENT CHECK] Successfully sent connectivity test to ${providerId}`);
+        console.log(`[AGENT CHECK] Waiting for IDE to update agents.json status to 'operational'...`);
+
+        // Don't spawn child process - just wait for file watcher to detect status change
+        return;
+
+      } catch (err) {
+        console.error(`[AGENT CHECK] Error sending connectivity test: ${err.message}`);
+        done({ status: 'error', message: `Error sending test: ${err.message}`, checkedAt });
+        return;
+      }
+    }
+
+    // For direct LLM providers: still use auto:direct
+    let args;
+    if (def.type !== 'ide') {
       args = [CLI_ENTRY_POINT, 'auto:direct', '--provider', providerId, '--max-chats', '1'];
+    } else {
+      // IDE handling moved above - this shouldn't be reached
+      done({ status: 'error', message: 'IDE handling logic error', checkedAt });
+      return;
     }
 
     // Verify CLI entry point exists and is readable
@@ -292,15 +371,13 @@ async function runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, s
     console.log(`[AGENT CHECK] CWD: ${repoPath}`);
     console.log(`[AGENT CHECK] Result file: ${resultFile}`);
 
-    // Add test requirement to REQUIREMENTS-<hostname>.md
-    // This tells the IDE agent to respond, and will be deleted after check completes
-    // (requirementsPath already calculated at function start)
-    console.log(`[AGENT CHECK] Using requirements file: ${requirementsPath}`);
+    // Set agent status to 'checking' in agents.json before sending test
+    console.log(`[AGENT CHECK] Setting ${providerId} status to 'checking' in agents.json`);
     try {
-      addTestRequirement(requirementsPath, resultFile);
-      console.log(`[AGENT CHECK] Added test requirement to ${requirementsPath}`);
+      updateAgentStatus(providerId, 'checking');
+      console.log(`[AGENT CHECK] Set ${providerId} status to 'checking'`);
     } catch (err) {
-      console.warn(`[AGENT CHECK] Could not add test requirement: ${err.message}`);
+      console.warn(`[AGENT CHECK] Could not set agent status: ${err.message}`);
     }
 
     // Prepare environment - inherit all process.env and add NODE_PATH if needed
@@ -366,7 +443,8 @@ async function runAgentCheck(providerId, def, repoPath, resultFile, timeoutMs, s
 
       // Check for DONE status in output (indicates successful completion)
       if (code === 0 && output.includes('Status: ✅ DONE') && output.includes('Requirement complete')) {
-        console.log(`[AGENT CHECK] Detected successful completion in output for ${providerId}`);
+        console.log(`[AGENT CHECK] Detected DONE in console output for ${providerId}`);
+        console.log(`[AGENT CHECK] ✅ Test PASSED: Agent reached DONE status - communication verified`);
         if (onProgress) onProgress(providerId, 'response_detected', null, 'Auto mode completed successfully.');
         done({ status: 'success', message: 'Agent completed requirement successfully', checkedAt });
         return;

package/src/utils/provider-checker/agents-manager.js

@@ -0,0 +1,210 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * Parse relative time string (e.g., "5h 30m", "2h", "45m") to absolute Date
+ * @param {string} relativeTime - Time string like "5h 30m"
+ * @returns {Date} Absolute date when the time will occur
+ */
+function parseRelativeTimeToAbsolute(relativeTime) {
+  const now = new Date();
+  let totalMinutes = 0;
+
+  // Parse hours
+  const hoursMatch = relativeTime.match(/(\d+)h/);
+  if (hoursMatch) {
+    totalMinutes += parseInt(hoursMatch[1]) * 60;
+  }
+
+  // Parse minutes
+  const minutesMatch = relativeTime.match(/(\d+)m/);
+  if (minutesMatch) {
+    totalMinutes += parseInt(minutesMatch[1]);
+  }
+
+  // Parse seconds
+  const secondsMatch = relativeTime.match(/(\d+)s/);
+  if (secondsMatch) {
+    totalMinutes += parseInt(secondsMatch[1]) / 60;
+  }
+
+  return new Date(now.getTime() + totalMinutes * 60 * 1000);
+}
+
+/**
+ * Get the path to the result file used by agent checks
+ */
+function getResultFilePath(repoPath) {
+  return path.join(repoPath, '.vibecodingmachine', 'temp', 'TEMP_agent_check.txt');
+}
+
+/**
+ * Get the path to the user's agents.json file in ~/.vibecodingmachine/
+ */
+function getAgentsFilePath() {
+  const homeDir = os.homedir();
+  const vcmDir = path.join(homeDir, '.vibecodingmachine');
+
+  // Ensure directory exists
+  if (!fs.existsSync(vcmDir)) {
+    fs.mkdirSync(vcmDir, { recursive: true });
+  }
+
+  return path.join(vcmDir, 'agents.json');
+}
+
+/**
+ * Read the agents.json file
+ * Returns the agents object or creates a new one if it doesn't exist
+ */
+function readAgentsFile() {
+  const agentsPath = getAgentsFilePath();
+
+  try {
+    if (fs.existsSync(agentsPath)) {
+      const content = fs.readFileSync(agentsPath, 'utf8');
+      return JSON.parse(content);
+    }
+  } catch (err) {
+    console.warn(`[AGENTS] Error reading agents file: ${err.message}`);
+  }
+
+  // Return default structure
+  return { agents: {} };
+}
+
+/**
+ * Write the agents.json file
+ */
+function writeAgentsFile(agentsData) {
+  const agentsPath = getAgentsFilePath();
+
+  try {
+    fs.writeFileSync(agentsPath, JSON.stringify(agentsData, null, 2), 'utf8');
+    return true;
+  } catch (err) {
+    console.error(`[AGENTS] Error writing agents file: ${err.message}`);
+    return false;
+  }
+}
+
+/**
+ * Update agent status
+ * @param {string} agentId - Agent ID (e.g., 'windsurf', 'cursor', 'antigravity')
+ * @param {string} status - Status: 'unknown', 'checking', 'operational', 'rate_limited', 'error'
+ * @param {object} metadata - Optional metadata (e.g., { rateLimitResume: '5m30s', error: 'message' })
+ */
+function updateAgentStatus(agentId, status, metadata = {}) {
+  const agentsData = readAgentsFile();
+
+  // Ensure agents object exists
+  if (!agentsData.agents) {
+    agentsData.agents = {};
+  }
+
+  // Ensure agent entry exists
+  if (!agentsData.agents[agentId]) {
+    agentsData.agents[agentId] = {
+      id: agentId,
+      status: 'unknown'
+    };
+  }
+
+  // Update status
+  agentsData.agents[agentId].status = status;
+  agentsData.agents[agentId].lastChecked = new Date().toISOString();
+
+  // Add metadata
+  if (status === 'rate_limited' && metadata.rateLimitResume) {
+    // Convert relative time (e.g., "5h 30m") to absolute timestamp
+    const resumeTime = parseRelativeTimeToAbsolute(metadata.rateLimitResume);
+    agentsData.agents[agentId].rateLimitResumeAt = resumeTime.toISOString();
+    agentsData.agents[agentId].rateLimitResume = metadata.rateLimitResume; // Keep original for reference
+  }
+
+  if (status === 'error' && metadata.error) {
+    agentsData.agents[agentId].error = metadata.error;
+  }
+
+  // Clear rate limit fields if no longer rate limited
+  if (status !== 'rate_limited') {
+    delete agentsData.agents[agentId].rateLimitResumeAt;
+    delete agentsData.agents[agentId].rateLimitResume;
+  }
+
+  // Write file
+  writeAgentsFile(agentsData);
+
+  console.log(`[AGENTS] Updated ${agentId} status to: ${status}`);
+
+  return agentsData.agents[agentId];
+}
+
+/**
+ * Get agent status
+ * @param {string} agentId - Agent ID
+ * @returns {object} Agent status object
+ */
+function getAgentStatus(agentId) {
+  const agentsData = readAgentsFile();
+
+  if (agentsData.agents && agentsData.agents[agentId]) {
+    return agentsData.agents[agentId];
+  }
+
+  return {
+    id: agentId,
+    status: 'unknown'
+  };
+}
+
+/**
+ * Get all agents with their statuses
+ * @returns {object} All agents
+ */
+function getAllAgents() {
+  const agentsData = readAgentsFile();
+  return agentsData.agents || {};
+}
+
+/**
+ * Generate the connectivity test message for IDE agents
+ * @param {string} agentName - Human-readable agent name (e.g., 'Windsurf', 'Cursor')
+ * @param {string} agentId - Agent ID (e.g., 'windsurf', 'cursor')
+ * @returns {string} Test message to send to IDE
+ */
+function generateConnectivityTestMessage(agentName, agentId) {
+  const agentsPath = getAgentsFilePath();
+  const relativeAgentsPath = agentsPath.replace(os.homedir(), '~');
+
+  return `# VCM Agent Connectivity Check
+
+ACTION REQUIRED - VCM Connectivity Test:
+
+VCM is testing communication with your IDE. To complete this test, please:
+
+1. Open the file at: ${relativeAgentsPath}
+2. Find the "${agentId}" entry
+3. Change the "status" field from "checking" to "operational"
+4. Save the file
+
+Example:
+Before: "status": "checking"
+After:  "status": "operational"
+
+VCM will detect the change within seconds and complete the test.`;
+}
+
+module.exports = {
+  getResultFilePath,
+  getAgentsFilePath,
+  readAgentsFile,
+  writeAgentsFile,
+  updateAgentStatus,
+  getAgentStatus,
+  getAllAgents,
+  generateConnectivityTestMessage
+};