vibecodingmachine-cli 2026.3.14-1537 → 2026.6.17-1956

package/src/utils/provider-checker/agents-file-lock.js

@@ -0,0 +1,134 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/**
+ * File locking mechanism for agents.json to prevent race conditions
+ * Uses atomic file operations and retry logic with exponential backoff
+ */
+
+class AgentsFileLock {
+  constructor() {
+    this.lockDir = path.join(os.homedir(), '.vibecodingmachine', 'locks');
+    this.lockFile = path.join(this.lockDir, 'agents.json.lock');
+    this.maxRetries = 5;
+    this.baseDelay = 50; // ms
+    this.maxDelay = 1000; // ms
+  }
+
+  /**
+   * Ensure lock directory exists
+   */
+  ensureLockDir() {
+    try {
+      if (!fs.existsSync(this.lockDir)) {
+        fs.mkdirSync(this.lockDir, { recursive: true });
+      }
+    } catch (err) {
+      console.warn(`[FILE LOCK] Could not create lock directory: ${err.message}`);
+    }
+  }
+
+  /**
+   * Acquire file lock with retry logic
+   * @param {number} retryCount - Current retry attempt
+   * @returns {Promise<boolean>} - True if lock acquired
+   */
+  async acquireLock(retryCount = 0) {
+    this.ensureLockDir();
+
+    try {
+      // Try to create lock file atomically
+      const lockInfo = {
+        pid: process.pid,
+        timestamp: Date.now(),
+        hostname: os.hostname(),
+        retryCount
+      };
+
+      fs.writeFileSync(this.lockFile, JSON.stringify(lockInfo, null, 2), { flag: 'wx' });
+      return true;
+    } catch (err) {
+      if (err.code === 'EEXIST') {
+        // Lock file exists, check if it's stale
+        if (this.isLockStale()) {
+          try {
+            fs.unlinkSync(this.lockFile);
+            console.log(`[FILE LOCK] Removed stale lock file`);
+            return this.acquireLock(retryCount);
+          } catch (unlinkErr) {
+            console.warn(`[FILE LOCK] Could not remove stale lock: ${unlinkErr.message}`);
+          }
+        }
+
+        // Lock is active, retry with exponential backoff
+        if (retryCount < this.maxRetries) {
+          const delay = Math.min(this.baseDelay * Math.pow(2, retryCount), this.maxDelay);
+          console.log(`[FILE LOCK] Lock busy, retry ${retryCount + 1}/${this.maxRetries} in ${delay}ms`);
+          await new Promise(resolve => setTimeout(resolve, delay));
+          return this.acquireLock(retryCount + 1);
+        }
+
+        console.warn(`[FILE LOCK] Could not acquire lock after ${this.maxRetries} retries`);
+        return false;
+      }
+
+      console.error(`[FILE LOCK] Error acquiring lock: ${err.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Release file lock
+   */
+  releaseLock() {
+    try {
+      if (fs.existsSync(this.lockFile)) {
+        fs.unlinkSync(this.lockFile);
+        console.log(`[FILE LOCK] Released lock`);
+      }
+    } catch (err) {
+      console.warn(`[FILE LOCK] Error releasing lock: ${err.message}`);
+    }
+  }
+
+  /**
+   * Check if lock file is stale (older than 30 seconds)
+   * @returns {boolean} - True if lock is stale
+   */
+  isLockStale() {
+    try {
+      if (!fs.existsSync(this.lockFile)) {
+        return true;
+      }
+
+      const stats = fs.statSync(this.lockFile);
+      const age = Date.now() - stats.mtime.getTime();
+      return age > 30000; // 30 seconds
+    } catch (err) {
+      return true; // If we can't check, assume it's stale
+    }
+  }
+
+  /**
+   * Execute operation with file lock
+   * @param {Function} operation - Function to execute while holding lock
+   * @returns {Promise<any>} - Result of operation
+   */
+  async withLock(operation) {
+    const lockAcquired = await this.acquireLock();
+    if (!lockAcquired) {
+      throw new Error('Could not acquire file lock for agents.json');
+    }
+
+    try {
+      return await operation();
+    } finally {
+      this.releaseLock();
+    }
+  }
+}
+
+module.exports = AgentsFileLock;

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

@@ -3,6 +3,7 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
+const AgentsFileLock = require('./agents-file-lock');
 
 /**
  * Parse relative time string (e.g., "5h 30m", "2h", "45m") to absolute Date
@@ -77,27 +78,180 @@ function readAgentsFile() {
 }
 
 /**
- * Write the agents.json file
+ * Write the agents.json file atomically with conflict detection
+ * @param {object} agentsData - Data to write
+ * @param {number} retryCount - Current retry attempt
+ * @returns {boolean} - True if successful
  */
-function writeAgentsFile(agentsData) {
+function writeAgentsFile(agentsData, retryCount = 0) {
   const agentsPath = getAgentsFilePath();
+  const fileLock = new AgentsFileLock();
+
+  // Helper function to perform the actual write operation
+  const performWrite = () => {
+    try {
+      // Read current file content to detect conflicts
+      let currentData = null;
+      let currentMtime = null;
+
+      if (fs.existsSync(agentsPath)) {
+        const content = fs.readFileSync(agentsPath, 'utf8');
+        currentData = JSON.parse(content);
+        currentMtime = fs.statSync(agentsPath).mtime.getTime();
+      }
+
+      // Create temporary file for atomic write
+      const tempPath = `${agentsPath}.tmp.${process.pid}.${Date.now()}`;
+
+      // Write to temporary file first
+      fs.writeFileSync(tempPath, JSON.stringify(agentsData, null, 2), 'utf8');
+
+      // Check for conflicts before moving temp file
+      if (currentData && fs.existsSync(agentsPath)) {
+        const newMtime = fs.statSync(agentsPath).mtime.getTime();
+        if (newMtime !== currentMtime) {
+          // File was modified since we read it - check for conflicts
+          const newContent = fs.readFileSync(agentsPath, 'utf8');
+          const newData = JSON.parse(newContent);
+
+          // Merge strategy: preserve newer timestamps and operational status
+          const mergedData = mergeAgentData(currentData, newData, agentsData);
+
+          // Update temp file with merged data
+          fs.writeFileSync(tempPath, JSON.stringify(mergedData, null, 2), 'utf8');
+          console.log(`[AGENTS] Detected conflict, merged changes gracefully`);
+        }
+      }
+
+      // Atomic move from temp to final file
+      fs.renameSync(tempPath, agentsPath);
+
+      console.log(`[AGENTS] Successfully wrote agents file`);
+      return true;
+    } catch (err) {
+      // Clean up temp file if it exists
+      const tempPath = `${agentsPath}.tmp.${process.pid}.${Date.now()}`;
+      if (fs.existsSync(tempPath)) {
+        try { fs.unlinkSync(tempPath); } catch { }
+      }
+      throw err;
+    }
+  };
 
   try {
-    fs.writeFileSync(agentsPath, JSON.stringify(agentsData, null, 2), 'utf8');
-    return true;
+    return fileLock.withLock(performWrite);
   } catch (err) {
     console.error(`[AGENTS] Error writing agents file: ${err.message}`);
+
+    // Retry logic for transient errors
+    if (retryCount < 3 && (err.code === 'EAGAIN' || err.code === 'EBUSY' || err.message.includes('lock'))) {
+      const delay = 100 * Math.pow(2, retryCount);
+      console.log(`[AGENTS] Retrying write in ${delay}ms (attempt ${retryCount + 1}/3)`);
+      setTimeout(() => {
+        return writeAgentsFile(agentsData, retryCount + 1);
+      }, delay);
+      return false;
+    }
+
     return false;
   }
 }
 
 /**
- * Update agent status
- * @param {string} agentId - Agent ID (e.g., 'windsurf', 'cursor', 'antigravity')
+ * Merge agent data to resolve conflicts
+ * Prioritizes: operational status > checking status > error status
+ * Preserves newest timestamps and rate limit info
+ */
+function mergeAgentData(oldData, currentFileData, newData) {
+  const merged = { agents: {} };
+
+  // Get all agent IDs from all sources
+  const allAgentIds = new Set([
+    ...Object.keys(oldData.agents || {}),
+    ...Object.keys(currentFileData.agents || {}),
+    ...Object.keys(newData.agents || {})
+  ]);
+
+  for (const agentId of allAgentIds) {
+    const oldAgent = oldData.agents?.[agentId] || {};
+    const currentAgent = currentFileData.agents?.[agentId] || {};
+    const newAgent = newData.agents?.[agentId] || {};
+
+    // Start with new data as base
+    merged.agents[agentId] = { ...newAgent };
+
+    // Preserve ID if missing
+    if (!merged.agents[agentId].id) {
+      merged.agents[agentId].id = agentId;
+    }
+
+    // Status priority: operational > checking > error > unknown
+    const statuses = [newAgent.status, currentAgent.status, oldAgent.status].filter(Boolean);
+    const statusPriority = {
+      'operational': 3,
+      'checking': 2,
+      'rate_limited': 2,
+      'error': 1,
+      'unknown': 0
+    };
+
+    let bestStatus = 'unknown';
+    let bestPriority = -1;
+    for (const status of statuses) {
+      if (statusPriority[status] > bestPriority) {
+        bestStatus = status;
+        bestPriority = statusPriority[status];
+      }
+    }
+    merged.agents[agentId].status = bestStatus;
+
+    // Preserve newest timestamp
+    const timestamps = [
+      newAgent.lastChecked && new Date(newAgent.lastChecked).getTime(),
+      currentAgent.lastChecked && new Date(currentAgent.lastChecked).getTime(),
+      oldAgent.lastChecked && new Date(oldAgent.lastChecked).getTime()
+    ].filter(Boolean);
+
+    if (timestamps.length > 0) {
+      const newestTimestamp = Math.max(...timestamps);
+      merged.agents[agentId].lastChecked = new Date(newestTimestamp).toISOString();
+    }
+
+    // Preserve rate limit info from any source
+    const rateLimitInfo = [newAgent, currentAgent, oldAgent].find(agent =>
+      agent.rateLimitResume || agent.rateLimitResumeAt
+    );
+    if (rateLimitInfo) {
+      if (rateLimitInfo.rateLimitResume) {
+        merged.agents[agentId].rateLimitResume = rateLimitInfo.rateLimitResume;
+      }
+      if (rateLimitInfo.rateLimitResumeAt) {
+        merged.agents[agentId].rateLimitResumeAt = rateLimitInfo.rateLimitResumeAt;
+      }
+    }
+
+    // Preserve error info if status is error
+    if (bestStatus === 'error') {
+      const errorInfo = [newAgent, currentAgent, oldAgent].find(agent =>
+        agent.error && agent.status === 'error'
+      );
+      if (errorInfo) {
+        merged.agents[agentId].error = errorInfo.error;
+      }
+    }
+  }
+
+  return merged;
+}
+
+/**
+ * Update agent status with improved conflict handling
+ * @param {string} agentId - Agent ID (e.g., 'devin', 'cursor', 'antigravity')
  * @param {string} status - Status: 'unknown', 'checking', 'operational', 'rate_limited', 'error'
  * @param {object} metadata - Optional metadata (e.g., { rateLimitResume: '5m30s', error: 'message' })
+ * @returns {Promise<object>} - Updated agent data
  */
-function updateAgentStatus(agentId, status, metadata = {}) {
+async function updateAgentStatus(agentId, status, metadata = {}) {
   const agentsData = readAgentsFile();
 
   // Ensure agents object exists
@@ -119,28 +273,46 @@ function updateAgentStatus(agentId, status, metadata = {}) {
 
   // 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
+    agentsData.agents[agentId].rateLimitResume = metadata.rateLimitResume;
+  }
+  if (status === 'rate_limited' && metadata.rateLimitResumeAt) {
+    agentsData.agents[agentId].rateLimitResumeAt = metadata.rateLimitResumeAt;
   }
 
   if (status === 'error' && metadata.error) {
     agentsData.agents[agentId].error = metadata.error;
   }
 
+  if (metadata.failureReason) {
+    agentsData.agents[agentId].failureReason = metadata.failureReason;
+  } else if (status !== 'error' && status !== 'rate_limited') {
+    delete agentsData.agents[agentId].failureReason;
+  }
+
+  if (metadata.userAction) {
+    agentsData.agents[agentId].userAction = metadata.userAction;
+  } else if (status !== 'error' && status !== 'rate_limited') {
+    delete agentsData.agents[agentId].userAction;
+  }
+
   // 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);
+  // Write file with conflict resolution
+  const success = writeAgentsFile(agentsData);
 
-  console.log(`[AGENTS] Updated ${agentId} status to: ${status}`);
-
-  return agentsData.agents[agentId];
+  if (success) {
+    console.log(`[AGENTS] Updated ${agentId} status to: ${status}`);
+    return agentsData.agents[agentId];
+  } else {
+    console.error(`[AGENTS] Failed to update ${agentId} status`);
+    throw new Error(`Failed to update agent status for ${agentId}`);
+  }
 }
 
 /**
@@ -172,30 +344,45 @@ function getAllAgents() {
 
 /**
  * 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')
+ * @param {string} agentName - Human-readable agent name (e.g., 'Devin', 'Cursor')
+ * @param {string} agentId - Agent ID (e.g., 'devin', 'cursor')
+ * @param {string} repoPath - Optional repo path for project-relative messages
  * @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"
+function generateConnectivityTestMessage(agentName, agentId, repoPath = null) {
+  // Use absolute path so IDEs with different working directories write to the correct location.
+  const resultPath = repoPath
+    ? getResultFilePath(repoPath)
+    : path.join(os.homedir(), '.vibecodingmachine', 'temp', 'TEMP_agent_check.txt');
+  // Include timestamp so each test run is treated as a unique request by IDEs with conversation history.
+  const ts = new Date().toISOString().replace(/[:.]/g, '-');
+  const dir = path.dirname(resultPath);
+  // Kiro: send a shell command that runs in Kiro's built-in terminal (Ctrl+backtick).
+  // Kiro's AI chat refuses file-write requests from automated systems, but the terminal works.
+  if (agentId === 'kiro') {
+    return `mkdir -p '${dir}' && echo 'VCM_CHECK_OK' > '${resultPath}' && echo done`;
+  }
+  // Explicit shell command avoids ambiguity (Amazon Q/other IDEs otherwise simulate Python instead of writing files)
+  return `VCM connectivity check ${ts}: Run this exact shell command: mkdir -p '${dir}' && echo 'VCM_CHECK_OK' > '${resultPath}' && echo done`;
+}
 
-VCM will detect the change within seconds and complete the test.`;
+/**
+ * Format a rate limit resume timestamp as a human-readable string.
+ * Returns "will reset at 2:34 PM MST" (future) or "reset at 2:10 PM MST" (past).
+ * @param {string|null} rateLimitResumeAt - ISO timestamp
+ * @returns {string|null}
+ */
+function formatRateLimitTime(rateLimitResumeAt) {
+  if (!rateLimitResumeAt) return null;
+  try {
+    const resumeDate = new Date(rateLimitResumeAt);
+    if (isNaN(resumeDate.getTime())) return null;
+    const now = new Date();
+    const timeStr = resumeDate.toLocaleTimeString([], { hour: 'numeric', minute: '2-digit', timeZoneName: 'short' });
+    return resumeDate > now ? `Rate limit will reset at ${timeStr}` : `Rate limited — reset at ${timeStr}`;
+  } catch {
+    return null;
+  }
 }
 
 module.exports = {
@@ -206,5 +393,6 @@ module.exports = {
   updateAgentStatus,
   getAgentStatus,
   getAllAgents,
-  generateConnectivityTestMessage
+  generateConnectivityTestMessage,
+  formatRateLimitTime
 };

package/src/utils/provider-checker/cli-installer.js

@@ -91,7 +91,7 @@ function isCLIAvailable(cmd, providerId) {
  */
 async function installCLI(providerId) {
   console.log(`[CLI INSTALLER] Starting installation for provider: ${providerId}`);
-  
+
   const config = CLI_AUTO_INSTALL[providerId];
   if (!config) {
     console.log(`[CLI INSTALLER] No auto-install config found for ${providerId}`);
@@ -121,11 +121,11 @@ async function installCLI(providerId) {
       let out = '';
       let hasStartedDownload = false;
       let hasStartedInstall = false;
-      
-      proc.stdout.on('data', d => { 
-        out += d.toString(); 
+
+      proc.stdout.on('data', d => {
+        out += d.toString();
         console.log(`[CLI INSTALLER] STDOUT: ${d.toString().trim()}`);
-        
+
         // Detect actual progress from output
         const output = d.toString().toLowerCase();
         if (output.includes('download') || output.includes('fetch')) {
@@ -137,17 +137,17 @@ async function installCLI(providerId) {
           // We could emit a progress event here if we had access to onProgress
         }
       });
-      
-      proc.stderr.on('data', d => { 
-        out += d.toString(); 
+
+      proc.stderr.on('data', d => {
+        out += d.toString();
         console.log(`[CLI INSTALLER] STDERR: ${d.toString().trim()}`);
       });
-      
+
       proc.on('error', (err) => {
         console.log(`[CLI INSTALLER] Process error for ${providerId}: ${err.message}`);
         resolve({ installed: false, note: `Failed to run install script for ${providerId}` });
       });
-      
+
       proc.on('close', (code) => {
         console.log(`[CLI INSTALLER] Install script for ${providerId} exited with code: ${code}`);
         console.log(`[CLI INSTALLER] Checking if ${providerId} is now available...`);
@@ -166,11 +166,11 @@ async function installCLI(providerId) {
       let out = '';
       let hasStartedDownload = false;
       let hasStartedInstall = false;
-      
-      proc.stdout.on('data', d => { 
-        out += d.toString(); 
+
+      proc.stdout.on('data', d => {
+        out += d.toString();
         console.log(`[CLI INSTALLER] STDOUT: ${d.toString().trim()}`);
-        
+
         // Detect actual progress from output
         const output = d.toString().toLowerCase();
         if (output.includes('download') || output.includes('fetch')) {
@@ -180,17 +180,17 @@ async function installCLI(providerId) {
           hasStartedInstall = true;
         }
       });
-      
-      proc.stderr.on('data', d => { 
-        out += d.toString(); 
+
+      proc.stderr.on('data', d => {
+        out += d.toString();
         console.log(`[CLI INSTALLER] STDERR: ${d.toString().trim()}`);
       });
-      
+
       proc.on('error', (err) => {
         console.log(`[CLI INSTALLER] Process error for ${providerId}: ${err.message}`);
         resolve({ installed: false, note: `Failed to run homebrew install for ${providerId}` });
       });
-      
+
       proc.on('close', (code) => {
         console.log(`[CLI INSTALLER] Homebrew install for ${providerId} exited with code: ${code}`);
         console.log(`[CLI INSTALLER] Checking if ${providerId} is now available...`);
@@ -215,11 +215,11 @@ async function installCLI(providerId) {
       let out = '';
       let hasStartedDownload = false;
       let hasStartedInstall = false;
-      
-      proc.stdout.on('data', d => { 
-        out += d.toString(); 
+
+      proc.stdout.on('data', d => {
+        out += d.toString();
         console.log(`[CLI INSTALLER] STDOUT: ${d.toString().trim()}`);
-        
+
         // Detect actual progress from output
         const output = d.toString().toLowerCase();
         if (output.includes('download') || output.includes('fetch')) {
@@ -229,17 +229,17 @@ async function installCLI(providerId) {
           hasStartedInstall = true;
         }
       });
-      
-      proc.stderr.on('data', d => { 
-        out += d.toString(); 
+
+      proc.stderr.on('data', d => {
+        out += d.toString();
         console.log(`[CLI INSTALLER] STDERR: ${d.toString().trim()}`);
       });
-      
+
       proc.on('error', (err) => {
         console.log(`[CLI INSTALLER] Process error for ${providerId}: ${err.message}`);
         resolve({ installed: false, note: `Failed to run npm install -g ${config.pkg}` });
       });
-      
+
       proc.on('close', (code) => {
         console.log(`[CLI INSTALLER] npm install for ${providerId} exited with code: ${code}`);
         console.log(`[CLI INSTALLER] Checking if ${providerId} is now available...`);

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

@@ -1,8 +1,8 @@
 /**
  * CLI Utilities Module
- * 
+ *
  * Contains CLI command availability and installation utilities.
- * 
+ *
  * NOTE: This module re-exports from cli-installer.js to avoid duplication.
  */