@in-the-loop-labs/pair-review 3.7.2 → 3.9.0

package/src/ai/codex-provider.js

@@ -763,9 +763,10 @@ class CodexProvider extends AIProvider {
    * Test if Codex CLI is available
    * Uses fast `--version` check instead of running a prompt.
    * Uses the command configured in the instance (respects ENV > config > default precedence)
+   * @param {number} [timeoutMs=10000] - Timeout in milliseconds for the probe
    * @returns {Promise<boolean>}
    */
-  async testAvailability() {
+  async testAvailability(timeoutMs = 10000) {
     return new Promise((resolve) => {
       // For availability test, we just need to check --version
       // Use the already-resolved command from the constructor (this.codexCmd)
@@ -794,10 +795,10 @@ class CodexProvider extends AIProvider {
       const availabilityTimeout = setTimeout(() => {
         if (settled) return;
         settled = true;
-        logger.warn('Codex CLI availability check timed out after 10s');
+        logger.warn(`Codex CLI availability check timed out after ${Math.round(timeoutMs / 1000)}s`);
         try { codex.kill(); } catch { /* ignore */ }
         resolve(false);
-      }, 10000);
+      }, timeoutMs);
 
       codex.stdout.on('data', (data) => {
         stdout += data.toString();

package/src/ai/copilot-provider.js

@@ -439,9 +439,11 @@ class CopilotProvider extends AIProvider {
   /**
    * Test if Copilot CLI is available
    * Uses the command configured in the instance (respects ENV > config > default precedence)
+   * @param {number} [timeoutMs=10000] - Timeout in milliseconds for the probe.
+   *   Production passes the per-provider resolved value; the default is only hit by tests.
    * @returns {Promise<boolean>}
    */
-  async testAvailability() {
+  async testAvailability(timeoutMs = 10000) {
     return new Promise((resolve) => {
       // For availability test, check --version
       // Use the already-resolved command from the constructor (this.copilotCmd)
@@ -465,6 +467,16 @@ class CopilotProvider extends AIProvider {
       let stdout = '';
       let settled = false;
 
+      // Timeout guard: if the CLI hangs, kill it and resolve false so the probe
+      // does not leak a child process.
+      const availabilityTimeout = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        logger.warn(`Copilot CLI availability check timed out after ${Math.round(timeoutMs / 1000)}s`);
+        try { copilot.kill(); } catch { /* ignore */ }
+        resolve(false);
+      }, timeoutMs);
+
       copilot.stdout.on('data', (data) => {
         stdout += data.toString();
       });
@@ -472,6 +484,7 @@ class CopilotProvider extends AIProvider {
       copilot.on('close', (code) => {
         if (settled) return;
         settled = true;
+        clearTimeout(availabilityTimeout);
         // Copilot CLI typically outputs version info on success
         if (code === 0) {
           logger.info(`Copilot CLI available: ${stdout.trim()}`);
@@ -485,6 +498,7 @@ class CopilotProvider extends AIProvider {
       copilot.on('error', (error) => {
         if (settled) return;
         settled = true;
+        clearTimeout(availabilityTimeout);
         logger.warn(`Copilot CLI not available: ${error.message}`);
         resolve(false);
       });

package/src/ai/cursor-agent-provider.js

@@ -783,9 +783,10 @@ class CursorAgentProvider extends AIProvider {
   /**
    * Test if Cursor Agent CLI is available
    * Uses the command configured in the instance (respects ENV > config > default precedence)
+   * @param {number} [timeoutMs=10000] - Timeout in milliseconds for the probe
    * @returns {Promise<boolean>}
    */
-  async testAvailability() {
+  async testAvailability(timeoutMs = 10000) {
     return new Promise((resolve) => {
       // For availability test, we just need to check --version
       // Use the already-resolved command from the constructor (this.agentCmd)
@@ -813,10 +814,10 @@ class CursorAgentProvider extends AIProvider {
       const availabilityTimeout = setTimeout(() => {
         if (settled) return;
         settled = true;
-        logger.warn('Cursor Agent CLI availability check timed out after 10s');
+        logger.warn(`Cursor Agent CLI availability check timed out after ${Math.round(timeoutMs / 1000)}s`);
         try { agent.kill(); } catch { /* ignore */ }
         resolve(false);
-      }, 10000);
+      }, timeoutMs);
 
       agent.stdout.on('data', (data) => {
         stdout += data.toString();

package/src/ai/executable-provider.js

@@ -12,7 +12,7 @@
  */
 
 const providerModule = require('./provider');
-const { AIProvider, resolveDefaultModel, inferModelDefaults } = providerModule;
+const { AIProvider, resolveDefaultModel, inferModelDefaults, secondsToTimeoutMs } = providerModule;
 const { spawn } = require('child_process');
 const { glob } = require('glob');
 const fs = require('fs').promises;
@@ -136,6 +136,10 @@ function createExecutableProviderClass(id, config) {
       this.mappingInstructions = config.mapping_instructions || '';
       this.timeout = config.timeout || 600000; // Default 10 minutes
       this.availabilityCommand = config.availability_command || 'true';
+      // Availability-probe timeout. Configured in seconds (mirrors
+      // checkout_timeout_seconds); falls back to the shared default when
+      // unset/invalid.
+      this.availabilityTimeoutMs = secondsToTimeoutMs(config.availability_timeout_seconds);
       this.extraEnv = {
         ...(config.env || {}),
         ...(configOverrides.env || {}),
@@ -454,9 +458,13 @@ function createExecutableProviderClass(id, config) {
      * Test if the external tool is available.
      * Runs the configured availability_command (defaults to 'true', i.e. always available).
      *
+     * @param {number} [timeoutMs] - Timeout in milliseconds for the probe.
+     *   Defaults to the provider's configured availability_timeout_seconds
+     *   (or 10s). Tools with slow build-based availability commands can raise
+     *   this via `availability_timeout_seconds` in their provider config.
      * @returns {Promise<boolean>}
      */
-    async testAvailability() {
+    async testAvailability(timeoutMs = this.availabilityTimeoutMs) {
       return new Promise((resolve) => {
         const command = this.availabilityCommand;
         logger.debug(`${id} availability check: ${command}`);
@@ -471,10 +479,10 @@ function createExecutableProviderClass(id, config) {
         const availabilityTimeout = setTimeout(() => {
           if (settled) return;
           settled = true;
-          logger.warn(`${id} availability check timed out after 10s`);
+          logger.warn(`${id} availability check timed out after ${Math.round(timeoutMs / 1000)}s`);
           try { child.kill(); } catch { /* ignore */ }
           resolve(false);
-        }, 10000);
+        }, timeoutMs);
 
         child.on('close', (code) => {
           if (settled) return;

package/src/ai/gemini-provider.js

@@ -659,9 +659,11 @@ class GeminiProvider extends AIProvider {
   /**
    * Test if Gemini CLI is available
    * Uses the command configured in the instance (respects ENV > config > default precedence)
+   * @param {number} [timeoutMs=10000] - Timeout in milliseconds for the probe.
+   *   Production passes the per-provider resolved value; the default is only hit by tests.
    * @returns {Promise<boolean>}
    */
-  async testAvailability() {
+  async testAvailability(timeoutMs = 10000) {
     return new Promise((resolve) => {
       // For availability test, we just need to check --version
       // Use the already-resolved command from the constructor (this.geminiCmd)
@@ -685,6 +687,16 @@ class GeminiProvider extends AIProvider {
       let stdout = '';
       let settled = false;
 
+      // Timeout guard: if the CLI hangs, kill it and resolve false so the probe
+      // does not leak a child process.
+      const availabilityTimeout = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        logger.warn(`Gemini CLI availability check timed out after ${Math.round(timeoutMs / 1000)}s`);
+        try { gemini.kill(); } catch { /* ignore */ }
+        resolve(false);
+      }, timeoutMs);
+
       gemini.stdout.on('data', (data) => {
         stdout += data.toString();
       });
@@ -692,6 +704,7 @@ class GeminiProvider extends AIProvider {
       gemini.on('close', (code) => {
         if (settled) return;
         settled = true;
+        clearTimeout(availabilityTimeout);
         if (code === 0 && stdout.includes('.')) {
           logger.info(`Gemini CLI available: ${stdout.trim()}`);
           resolve(true);
@@ -704,6 +717,7 @@ class GeminiProvider extends AIProvider {
       gemini.on('error', (error) => {
         if (settled) return;
         settled = true;
+        clearTimeout(availabilityTimeout);
         logger.warn(`Gemini CLI not available: ${error.message}`);
         resolve(false);
       });

package/src/ai/index.js

@@ -17,10 +17,17 @@ const {
   getAllProvidersInfo,
   createProvider,
   testProviderAvailability,
+  resolveAvailabilityTimeoutMs,
+  secondsToTimeoutMs,
+  DEFAULT_AVAILABILITY_TIMEOUT_MS,
   applyConfigOverrides,
   getProviderConfigOverrides,
   inferModelDefaults,
   resolveDefaultModel,
+  modelMatches,
+  mergeModels,
+  applyModelOverrides,
+  normalizeDisabledModels,
   prettifyModelId,
   createAliasedProviderClass,
   getTierForModel
@@ -69,12 +76,19 @@ module.exports = {
 
   // Utilities
   testProviderAvailability,
+  resolveAvailabilityTimeoutMs,
+  secondsToTimeoutMs,
+  DEFAULT_AVAILABILITY_TIMEOUT_MS,
 
   // Config override support
   applyConfigOverrides,
   getProviderConfigOverrides,
   inferModelDefaults,
   resolveDefaultModel,
+  modelMatches,
+  mergeModels,
+  applyModelOverrides,
+  normalizeDisabledModels,
   prettifyModelId,
   getTierForModel,
 

package/src/ai/opencode-provider.js

@@ -587,9 +587,11 @@ class OpenCodeProvider extends AIProvider {
   /**
    * Test if OpenCode CLI is available
    * Uses the command configured in the instance (respects ENV > config > default precedence)
+   * @param {number} [timeoutMs=10000] - Timeout in milliseconds for the probe.
+   *   Production passes the per-provider resolved value; the default is only hit by tests.
    * @returns {Promise<boolean>}
    */
-  async testAvailability() {
+  async testAvailability(timeoutMs = 10000) {
     return new Promise((resolve) => {
       // For availability test, we just need to check --version
       // Use the already-resolved command from the constructor (this.opencodeCmd)
@@ -613,6 +615,16 @@ class OpenCodeProvider extends AIProvider {
       let stdout = '';
       let settled = false;
 
+      // Timeout guard: if the CLI hangs, kill it and resolve false so the probe
+      // does not leak a child process.
+      const availabilityTimeout = setTimeout(() => {
+        if (settled) return;
+        settled = true;
+        logger.warn(`OpenCode CLI availability check timed out after ${Math.round(timeoutMs / 1000)}s`);
+        try { opencode.kill(); } catch { /* ignore */ }
+        resolve(false);
+      }, timeoutMs);
+
       opencode.stdout.on('data', (data) => {
         stdout += data.toString();
       });
@@ -620,6 +632,7 @@ class OpenCodeProvider extends AIProvider {
       opencode.on('close', (code) => {
         if (settled) return;
         settled = true;
+        clearTimeout(availabilityTimeout);
         if (code === 0) {
           logger.info(`OpenCode CLI available: ${stdout.trim()}`);
           resolve(true);
@@ -632,6 +645,7 @@ class OpenCodeProvider extends AIProvider {
       opencode.on('error', (error) => {
         if (settled) return;
         settled = true;
+        clearTimeout(availabilityTimeout);
         logger.warn(`OpenCode CLI not available: ${error.message}`);
         resolve(false);
       });

package/src/ai/pi-provider.js

@@ -1103,9 +1103,10 @@ class PiProvider extends AIProvider {
   /**
    * Test if Pi CLI is available
    * Uses the command configured in the instance (respects ENV > config > default precedence)
+   * @param {number} [timeoutMs=10000] - Timeout in milliseconds for the probe
    * @returns {Promise<boolean>}
    */
-  async testAvailability() {
+  async testAvailability(timeoutMs = 10000) {
     return new Promise((resolve) => {
       // For availability test, we just need to check --version
       // Use the already-resolved command from the constructor (this.piCmd)
@@ -1135,10 +1136,10 @@ class PiProvider extends AIProvider {
       const availabilityTimeout = setTimeout(() => {
         if (settled) return;
         settled = true;
-        logger.warn(`${name} CLI availability check timed out after 10s`);
+        logger.warn(`${name} CLI availability check timed out after ${Math.round(timeoutMs / 1000)}s`);
         try { pi.kill(); } catch { /* ignore */ }
         resolve(false);
-      }, 10000);
+      }, timeoutMs);
 
       pi.stdout.on('data', (data) => {
         stdout += data.toString();