polydev-ai 1.4.1 → 1.4.3

package/cliManager.js

@@ -0,0 +1,715 @@
+const { exec, spawn } = require('child_process');
+const { promisify } = require('util');
+const path = require('path');
+const fs = require('fs');
+const os = require('os');
+const which = require('which');
+
+const execAsync = promisify(exec);
+
+class CLIManager {
+  constructor() {
+    this.providers = new Map();
+    this.statusCache = new Map();
+    this.CACHE_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
+    this.initializeProviders();
+  }
+
+  initializeProviders() {
+    const providers = [
+      {
+        id: 'claude_code',
+        name: 'Claude Code',
+        command: process.env.CLAUDE_CODE_PATH || 'claude',
+        subcommands: {
+          chat: [],
+          version: ['--version'],
+          auth_status: ['--print', 'test auth'], // Use --print to test auth
+          test_prompt: ['--print']
+        },
+        install_instructions: 'Install via: npm install -g @anthropic-ai/claude-code',
+        auth_instructions: 'Authenticate with Claude Code'
+      },
+      {
+        id: 'codex_cli',
+        name: 'Codex CLI',
+        command: process.env.CODEX_CLI_PATH || 'codex',
+        subcommands: {
+          chat: ['chat'],
+          version: ['--version'],
+          auth_status: ['login', 'status'], // Correct command: codex login status
+          test_prompt: ['exec'],
+          alternate_test_prompts: [
+            ['prompt'],
+            ['ask']
+          ]
+        },
+        install_instructions: 'Install Codex CLI from OpenAI',
+        auth_instructions: 'Authenticate with: codex login'
+      },
+      {
+        id: 'gemini_cli',
+        name: 'Gemini CLI',
+        command: process.env.GEMINI_CLI_PATH || 'gemini',
+        subcommands: {
+          chat: ['chat'],
+          version: ['--version'],
+          auth_status: ['auth-status'] // gemini-mcp auth-status command
+        },
+        install_instructions: 'Install Gemini CLI from Google',
+        auth_instructions: 'Authenticate with: gemini (then /auth login)'
+      }
+    ];
+
+    providers.forEach(provider => {
+      this.providers.set(provider.id, provider);
+    });
+  }
+
+  async forceCliDetection(specificProvider) {
+    const results = {};
+    const providersToCheck = specificProvider 
+      ? [this.providers.get(specificProvider)].filter(Boolean) 
+      : Array.from(this.providers.values());
+
+    // Log system environment for debugging
+    console.log(`[Polydev CLI] Detecting CLI providers - Node.js ${process.version}, Platform: ${process.platform}`);
+
+    for (const provider of providersToCheck) {
+      if (provider) {
+        try {
+          results[provider.id] = await this.detectCliProvider(provider);
+          this.statusCache.set(provider.id, results[provider.id]);
+          
+          // Log compatibility issues for user awareness
+          if (results[provider.id].error && results[provider.id].error.includes('Compatibility Issue')) {
+            console.warn(`[Polydev CLI] ⚠️  ${provider.name} compatibility issue detected. See error details for solutions.`);
+          }
+        } catch (error) {
+          results[provider.id] = {
+            available: false,
+            authenticated: false,
+            error: `Detection failed: ${error.message}`,
+            last_checked: new Date()
+          };
+        }
+      }
+    }
+
+    return results;
+  }
+
+  async getCliStatus(specificProvider) {
+    const results = {};
+    const providersToCheck = specificProvider 
+      ? [this.providers.get(specificProvider)].filter(Boolean) 
+      : Array.from(this.providers.values());
+
+    for (const provider of providersToCheck) {
+      if (provider) {
+        const cached = this.statusCache.get(provider.id);
+        if (cached && this.isCacheValid(cached)) {
+          results[provider.id] = cached;
+        } else {
+          const detection = await this.forceCliDetection(provider.id);
+          results[provider.id] = detection[provider.id];
+        }
+      }
+    }
+
+    return results;
+  }
+
+  isCacheValid(status) {
+    if (!status.last_checked) return false;
+    const now = new Date().getTime();
+    const checked = new Date(status.last_checked).getTime();
+    return (now - checked) < this.CACHE_TIMEOUT_MS;
+  }
+
+  async detectCliProvider(provider) {
+    try {
+      const cliPath = await this.findCliPath(provider.command);
+      if (!cliPath) {
+        return {
+          available: false,
+          authenticated: false,
+          error: `${provider.name} not found in PATH. ${provider.install_instructions}`,
+          last_checked: new Date()
+        };
+      }
+
+      let version;
+      try {
+        const versionResult = await this.executeCliCommand(
+          provider.command, 
+          provider.subcommands.version,
+          'args',
+          5000
+        );
+        version = versionResult.stdout?.trim();
+      } catch (versionError) {
+        if (process.env.POLYDEV_CLI_DEBUG) {
+          console.log(`[CLI Debug] Version check failed for ${provider.id}:`, versionError);
+        }
+      }
+
+      let authenticated = false;
+      
+      // For Claude Code, skip command-based auth check and use file-based detection directly
+      // This avoids the recursion issue when running from within Claude Code
+      if (provider.id === 'claude_code') {
+        authenticated = await this.checkAuthenticationByFiles(provider.id);
+        
+        if (process.env.POLYDEV_CLI_DEBUG) {
+          console.log(`[CLI Debug] File-based auth check for ${provider.id}:`, authenticated);
+        }
+      } else {
+        // For other providers, try command-based auth check first
+        try {
+          const authResult = await this.executeCliCommand(
+            provider.command,
+            provider.subcommands.auth_status,
+            'args',
+            5000 // Reduced timeout to 5 seconds
+          );
+          
+          // If command succeeds, check output for authentication indicators
+          const authOutput = (authResult.stdout + ' ' + authResult.stderr).toLowerCase();
+          
+          if (process.env.POLYDEV_CLI_DEBUG) {
+            console.log(`[CLI Debug] Auth output for ${provider.id}: "${authOutput}"`);
+          }
+          
+          authenticated = this.parseAuthenticationStatus(provider.id, authOutput);
+          
+        } catch (authError) {
+          if (process.env.POLYDEV_CLI_DEBUG) {
+            console.log(`[CLI Debug] Auth check failed for ${provider.id}:`, authError);
+          }
+          
+          // Fallback to file-based authentication detection
+          authenticated = await this.checkAuthenticationByFiles(provider.id);
+          
+          if (process.env.POLYDEV_CLI_DEBUG) {
+            console.log(`[CLI Debug] File-based auth check for ${provider.id}:`, authenticated);
+          }
+        }
+      }
+
+      // Special handling for Gemini CLI Node.js compatibility issues
+      let errorMessage = undefined;
+      if (!authenticated) {
+        if (provider.id === 'gemini_cli') {
+          // Check if the issue is Node.js compatibility
+          try {
+            const authResult = await this.executeCliCommand(
+              provider.command,
+              ['--help'],
+              'args',
+              2000
+            );
+            const testOutput = (authResult.stdout + ' ' + authResult.stderr).toLowerCase();
+            if (testOutput.includes('referenceerror: file is not defined') ||
+                testOutput.includes('undici/lib/web/webidl')) {
+              errorMessage = `⚠️  Gemini CLI Compatibility Issue: Node.js v${process.version} doesn't support the 'File' global that Gemini CLI requires. 
+
+Solutions:
+• Update to Node.js v20+ (recommended): nvm install 20 && nvm use 20
+• Reinstall Gemini CLI: npm uninstall -g @google/gemini-cli && npm install -g @google/gemini-cli@latest
+• Alternative: Use Google AI Studio directly or switch to Claude/OpenAI providers
+
+This is a known issue with @google/gemini-cli@0.3.4 and older Node.js versions.`;
+            } else {
+              errorMessage = `Not authenticated. ${provider.auth_instructions}`;
+            }
+          } catch {
+            errorMessage = `Not authenticated. ${provider.auth_instructions}`;
+          }
+        } else {
+          errorMessage = `Not authenticated. ${provider.auth_instructions}`;
+        }
+      }
+
+      return {
+        available: true,
+        authenticated,
+        version,
+        path: cliPath,
+        last_checked: new Date(),
+        error: errorMessage
+      };
+
+    } catch (error) {
+      return {
+        available: false,
+        authenticated: false,
+        error: `Detection failed: ${error.message}`,
+        last_checked: new Date()
+      };
+    }
+  }
+
+  async findCliPath(command) {
+    try {
+      return await which(command);
+    } catch (error) {
+      return null;
+    }
+  }
+
+  async checkAuthenticationByFiles(providerId) {
+    const os = require('os');
+    
+    try {
+      switch (providerId) {
+        case 'claude_code':
+          // Check for Claude Code session files
+          const claudeConfigPath = path.join(os.homedir(), '.claude.json');
+          if (fs.existsSync(claudeConfigPath)) {
+            const configContent = fs.readFileSync(claudeConfigPath, 'utf8');
+            // Look for session or auth tokens in the config
+            return configContent.length > 100 && 
+                   (configContent.includes('session') || 
+                    configContent.includes('token') || 
+                    configContent.includes('auth'));
+          }
+          return false;
+        
+        case 'codex_cli':
+          // Check for Codex auth files
+          const codexAuthPath = path.join(os.homedir(), '.codex', 'auth.json');
+          if (fs.existsSync(codexAuthPath)) {
+            const authContent = fs.readFileSync(codexAuthPath, 'utf8');
+            try {
+              const authData = JSON.parse(authContent);
+              return authData && (authData.token || authData.access_token || authData.authenticated);
+            } catch {
+              return authContent.length > 10; // Has some auth content
+            }
+          }
+          return false;
+        
+        case 'gemini_cli':
+          // Check for Gemini CLI auth files (if any)
+          const geminiConfigPath = path.join(os.homedir(), '.config', 'gemini-cli', 'config.json');
+          if (fs.existsSync(geminiConfigPath)) {
+            const configContent = fs.readFileSync(geminiConfigPath, 'utf8');
+            return configContent.includes('auth') || configContent.includes('token');
+          }
+          return false;
+        
+        default:
+          return false;
+      }
+    } catch (error) {
+      if (process.env.POLYDEV_CLI_DEBUG) {
+        console.log(`[CLI Debug] File-based auth check error for ${providerId}:`, error.message);
+      }
+      return false;
+    }
+  }
+
+  parseAuthenticationStatus(providerId, authOutput) {
+    
+    switch (providerId) {
+      case 'claude_code':
+        // If --print "test auth" works without error, Claude Code is authenticated
+        // Look for actual response content (not authentication errors)
+        const claudeAuth = !authOutput.includes('not authenticated') && 
+               !authOutput.includes('please log in') &&
+               !authOutput.includes('authentication required') &&
+               !authOutput.includes('login required') &&
+               authOutput.length > 10; // Has actual content response
+        
+        return claudeAuth;
+      
+      case 'codex_cli':
+        // Look for specific codex login status responses
+        const hasLoggedIn = authOutput.includes('logged in using');
+        const hasAuthenticated = authOutput.includes('authenticated');
+        const hasChatGpt = authOutput.includes('chatgpt') && !authOutput.includes('not logged in');
+        
+        
+        return hasLoggedIn || hasAuthenticated || hasChatGpt;
+      
+      case 'gemini_cli':
+        // Check for Node.js compatibility issues first
+        if (authOutput.includes('referenceerror: file is not defined') || 
+            authOutput.includes('undici/lib/web/webidl') ||
+            authOutput.includes('file is not defined')) {
+          return false; // CLI is broken due to Node.js compatibility
+        }
+        
+        return !authOutput.includes('not authenticated') && 
+               !authOutput.includes('please login') &&
+               (authOutput.includes('authenticated') || authOutput.includes('logged in'));
+      
+      default:
+        return authOutput.includes('authenticated') || authOutput.includes('logged in');
+    }
+  }
+
+  async sendCliPrompt(providerId, prompt, mode = 'args', timeoutMs = null) {
+    // Set provider-specific default timeouts
+    if (timeoutMs === null) {
+      timeoutMs = providerId === 'claude_code' ? 60000 : 30000; // 60s for Claude Code, 30s for others
+    }
+    if (providerId === 'codex_cli' && timeoutMs < 90000) {
+      timeoutMs = 90000;
+    }
+    
+    // Ensure timeoutMs is valid (not undefined, null, Infinity, or negative)
+    if (!timeoutMs || timeoutMs === Infinity || timeoutMs < 1 || timeoutMs > 300000) {
+      timeoutMs = 30000 // Default to 30 seconds
+    }
+    
+    const startTime = Date.now();
+
+    try {
+      const provider = this.providers.get(providerId);
+      if (!provider) {
+        return {
+          success: false,
+          error: `Unknown provider: ${providerId}`,
+          latency_ms: Date.now() - startTime,
+          timestamp: new Date()
+        };
+      }
+
+      const status = await this.getCliStatus(providerId);
+      const providerStatus = status[providerId];
+      
+      if (!providerStatus?.available) {
+        return {
+          success: false,
+          error: `${provider.name} is not available. ${provider.install_instructions}`,
+          latency_ms: Date.now() - startTime,
+          timestamp: new Date()
+        };
+      }
+
+      if (!providerStatus.authenticated) {
+        return {
+          success: false,
+          error: `${provider.name} is not authenticated. ${provider.auth_instructions}`,
+          latency_ms: Date.now() - startTime,
+          timestamp: new Date()
+        };
+      }
+
+      const promptVariants = [
+        provider.subcommands?.test_prompt ? [...provider.subcommands.test_prompt] : []
+      ];
+
+      if (Array.isArray(provider?.subcommands?.alternate_test_prompts)) {
+        for (const altArgs of provider.subcommands.alternate_test_prompts) {
+          promptVariants.push(Array.isArray(altArgs) ? [...altArgs] : []);
+        }
+      }
+
+      if (providerId === 'codex_cli') {
+        const execArgs = promptVariants.find(args => args.includes('exec')) || promptVariants[0];
+        try {
+          const content = await this.executeCodexExec(provider.command, execArgs, prompt, timeoutMs);
+          return {
+            success: true,
+            content,
+            tokens_used: this.estimateTokens(prompt + content),
+            latency_ms: Date.now() - startTime,
+            provider: providerId,
+            mode: 'args',
+            timestamp: new Date()
+          };
+        } catch (error) {
+          return {
+            success: false,
+            error: `CLI execution failed: ${error instanceof Error ? error.message : String(error)}`,
+            latency_ms: Date.now() - startTime,
+            provider: providerId,
+            mode,
+            timestamp: new Date()
+          };
+        }
+      }
+
+      let lastErrorMessage = null;
+
+      for (const promptArgs of promptVariants) {
+        const args = Array.isArray(promptArgs) ? [...promptArgs, prompt] : [prompt];
+        try {
+          const result = await this.executeCliCommand(
+            provider.command,
+            args,
+            'args',
+            timeoutMs,
+            undefined
+          );
+
+          if (!result.error) {
+            const content = this.cleanCliResponse(result.stdout || '');
+            return {
+              success: true,
+              content,
+              tokens_used: this.estimateTokens(prompt + content),
+              latency_ms: Date.now() - startTime,
+              provider: providerId,
+              mode: 'args',
+              timestamp: new Date()
+            };
+          }
+
+          lastErrorMessage = result.error;
+        } catch (error) {
+          lastErrorMessage = error instanceof Error ? error.message : String(error);
+        }
+      }
+
+      return {
+        success: false,
+        error: `CLI command failed: ${lastErrorMessage || 'Unknown error'}`,
+        latency_ms: Date.now() - startTime,
+        provider: providerId,
+        mode: 'args',
+        timestamp: new Date()
+      };
+
+    } catch (error) {
+      return {
+        success: false,
+        error: `CLI execution failed: ${error.message}`,
+        latency_ms: Date.now() - startTime,
+        provider: providerId,
+        mode,
+        timestamp: new Date()
+      };
+    }
+  }
+
+  async executeCliCommand(command, args, mode = 'args', timeoutMs = 30000, stdinInput) {
+    // Ensure timeoutMs is valid (not undefined, null, Infinity, or negative)
+    if (!timeoutMs || timeoutMs === Infinity || timeoutMs < 1 || timeoutMs > 300000) {
+      timeoutMs = 30000 // Default to 30 seconds
+    }
+    
+    return new Promise((resolve, reject) => {
+      if (process.env.POLYDEV_CLI_DEBUG) {
+        console.log(`[CLI Debug] Executing: ${command} ${args.join(' ')} (mode: ${mode})`);
+      }
+
+      const child = spawn(command, args, {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        shell: process.platform === 'win32',
+        timeout: timeoutMs
+      });
+
+      if (child.stdin) {
+        child.stdin.end();
+      }
+
+      let stdout = '';
+      let stderr = '';
+
+      child.stdout?.on('data', (data) => {
+        stdout += data.toString();
+      });
+
+      child.stderr?.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      if (mode === 'stdin' && stdinInput && child.stdin) {
+        child.stdin.write(`${stdinInput}\n`);
+        child.stdin.end();
+      }
+
+      child.on('close', (code) => {
+        if (process.env.POLYDEV_CLI_DEBUG) {
+          console.log(`[CLI Debug] Command finished with code ${code}`);
+        }
+
+        if (code === 0) {
+          resolve({ stdout, stderr });
+        } else {
+          const trimmedStdErr = stderr.trim();
+          const trimmedStdOut = stdout.trim();
+          const errorMessage = trimmedStdErr || trimmedStdOut || `Command exited with code ${code}`;
+          resolve({ 
+            stdout, 
+            stderr, 
+            error: errorMessage,
+            exit_code: code
+          });
+        }
+      });
+
+      child.on('error', (error) => {
+        if (process.env.POLYDEV_CLI_DEBUG) {
+          console.log(`[CLI Debug] Command error:`, error);
+        }
+        reject(error);
+      });
+
+      let timeoutId;
+      const cleanup = () => {
+        if (timeoutId) {
+          clearTimeout(timeoutId);
+          timeoutId = null;
+        }
+      };
+
+      timeoutId = setTimeout(() => {
+        cleanup();
+        if (!child.killed) {
+          child.kill('SIGTERM');
+          // Force kill after 2 seconds if still running
+          setTimeout(() => {
+            if (!child.killed) {
+              child.kill('SIGKILL');
+            }
+          }, 2000);
+        }
+        reject(new Error(`Command timeout after ${timeoutMs}ms`));
+      }, timeoutMs);
+
+      child.on('close', () => {
+        cleanup();
+      });
+
+      child.on('exit', () => {
+        cleanup();
+      });
+    });
+  }
+
+  async executeCodexExec(executable, commandArgs, prompt, timeoutMs) {
+    if (!executable) {
+      throw new Error('Missing Codex executable');
+    }
+
+    if (!commandArgs || commandArgs.length === 0) {
+      throw new Error('Invalid Codex command configuration');
+    }
+
+    const workingDir = process.cwd();
+    const args = [
+      ...commandArgs,
+      '--sandbox',
+      'workspace-write',
+      '--skip-git-repo-check',
+      '--cd',
+      workingDir,
+      prompt
+    ];
+
+    return new Promise((resolve, reject) => {
+      const baseTmp = process.env.POLYDEV_CLI_TMPDIR || process.env.TMPDIR || os.tmpdir();
+      const tmpDir = path.join(baseTmp, 'polydev-codex');
+      try {
+        fs.mkdirSync(tmpDir, { recursive: true });
+      } catch (error) {
+        console.warn('[CLI Debug] Failed to create Codex temp dir:', error);
+      }
+
+      const child = spawn(executable, args, {
+        stdio: ['pipe', 'pipe', 'pipe'],
+        shell: process.platform === 'win32',
+        env: {
+          ...process.env,
+          TMPDIR: tmpDir,
+          TEMP: tmpDir,
+          TMP: tmpDir
+        }
+      });
+
+      console.log(`[CLI Debug] Spawning Codex process: ${executable} ${args.join(' ')}`);
+
+      if (child.stdin) {
+        child.stdin.end();
+      }
+
+      let stdout = '';
+      let stderr = '';
+      let resolved = false;
+
+      const stop = (handler) => {
+        if (!resolved) {
+          resolved = true;
+          try { child.kill('SIGTERM'); } catch (_) {}
+          handler();
+        }
+      };
+
+      const timeoutHandle = setTimeout(() => {
+        stop(() => reject(new Error(`Codex exec timeout after ${timeoutMs}ms`)));
+      }, timeoutMs);
+
+      const flushIfComplete = () => {
+        const match = stdout.match(/•\s*(.+)/);
+        if (match && match[1]) {
+          clearTimeout(timeoutHandle);
+          stop(() => resolve(match[1].trim()));
+        }
+      };
+
+      child.stdout?.on('data', (data) => {
+        stdout += data.toString();
+        flushIfComplete();
+      });
+
+      child.stderr?.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      child.on('close', (code) => {
+        if (resolved) return;
+        resolved = true;
+        clearTimeout(timeoutHandle);
+
+        const trimmedStdout = stdout.trim();
+        const trimmedStderr = stderr.trim();
+
+        if (code === 0 && trimmedStdout) {
+          const match = trimmedStdout.match(/•\s*(.+)/);
+          if (match && match[1]) {
+            resolve(match[1].trim());
+            return;
+          }
+          resolve(trimmedStdout);
+        } else {
+          reject(new Error(trimmedStderr || trimmedStdout || `Codex exited with code ${code}`));
+        }
+      });
+
+      child.on('error', (error) => {
+        if (resolved) return;
+        resolved = true;
+        clearTimeout(timeoutHandle);
+        reject(error);
+      });
+    });
+  }
+
+  cleanCliResponse(response) {
+    const cleanResponse = response.replace(/\x1b\[[0-9;]*m/g, '');
+    
+    return cleanResponse
+      .replace(/^(\s*>\s*|\s*$)/gm, '')
+      .replace(/\n{3,}/g, '\n\n')
+      .trim();
+  }
+
+  estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+  }
+
+  getAvailableProviders() {
+    return Array.from(this.providers.values());
+  }
+
+  getProvider(providerId) {
+    return this.providers.get(providerId);
+  }
+}
+
+module.exports = { CLIManager, default: CLIManager };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "polydev-ai",
-  "version": "1.4.1",
+  "version": "1.4.3",
   "description": "Get diverse AI perspectives from multiple LLMs via MCP - supports Cline, Claude Code, and other MCP clients",
   "main": "stdio-wrapper.js",
   "bin": {
@@ -31,6 +31,7 @@
   },
   "files": [
     "stdio-wrapper.js",
+    "cliManager.js",
     "manifest.json",
     "README.md"
   ],

package/stdio-wrapper.js

@@ -4,7 +4,70 @@
 const fs = require('fs');
 const path = require('path');
 const os = require('os');
-const { CLIManager } = require('../lib/cliManager');
+const { CLIManager } = require('./cliManager');
+
+// Simple .env file loader (no external dependencies)
+function loadEnvFile(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) return false;
+
+    const content = fs.readFileSync(filePath, 'utf8');
+    const lines = content.split('\n');
+    let loaded = 0;
+
+    for (const line of lines) {
+      const trimmed = line.trim();
+      // Skip comments and empty lines
+      if (!trimmed || trimmed.startsWith('#')) continue;
+
+      const eqIndex = trimmed.indexOf('=');
+      if (eqIndex === -1) continue;
+
+      const key = trimmed.substring(0, eqIndex).trim();
+      let value = trimmed.substring(eqIndex + 1).trim();
+
+      // Remove surrounding quotes if present
+      if ((value.startsWith('"') && value.endsWith('"')) ||
+          (value.startsWith("'") && value.endsWith("'"))) {
+        value = value.slice(1, -1);
+      }
+
+      // Only set if not already defined (don't override existing env vars)
+      if (!process.env[key]) {
+        process.env[key] = value;
+        loaded++;
+      }
+    }
+
+    return loaded > 0;
+  } catch (error) {
+    return false;
+  }
+}
+
+// Load .env files from multiple locations (in priority order)
+function loadEnvironment() {
+  const envPaths = [
+    path.join(process.cwd(), '.env'),           // Current working directory
+    path.join(process.cwd(), '.env.local'),     // Local overrides
+    path.join(os.homedir(), '.polydev.env'),    // User home directory
+    path.join(os.homedir(), '.env'),            // Home directory fallback
+  ];
+
+  const loaded = [];
+  for (const envPath of envPaths) {
+    if (loadEnvFile(envPath)) {
+      loaded.push(envPath);
+    }
+  }
+
+  if (loaded.length > 0) {
+    console.error(`[Stdio Wrapper] Loaded env from: ${loaded.join(', ')}`);
+  }
+}
+
+// Load environment variables FIRST, before any checks
+loadEnvironment();
 
 function ensureWritableTmpDir() {
   const candidates = [