gitarsenal-cli 1.4.3 → 1.4.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitarsenal-cli",
-  "version": "1.4.3",
+  "version": "1.4.5",
   "description": "CLI tool for creating Modal sandboxes with GitHub repositories",
   "main": "index.js",
   "bin": {

package/python/fetch_modal_tokens.py

@@ -2,7 +2,7 @@
 """
 Fetch Modal Tokens
 
-This script fetches Modal tokens from the GitArsenal API.
+This script fetches Modal tokens from the proxy server.
 """
 
 import os
@@ -12,108 +12,144 @@ import requests
 import subprocess
 from pathlib import Path
 
-# Default tokens to use if we can't fetch from the server
-# DEFAULT_TOKEN_ID = "ak-sLhYqCjkvixiYcb9LAuCHp"
-# DEFAULT_TOKEN_SECRET = "as-fPzD0Zm0dl6IFAEkhaH9pq"
+def fetch_default_tokens_from_gitarsenal():
+    """
+    Fetch default Modal tokens from gitarsenal.dev API.
+    
+    Returns:
+        tuple: (token_id, token_secret) if successful, (None, None) otherwise
+    """
+    endpoint = "https://gitarsenal.dev/api/credentials"
+    
+    try:
+        headers = {
+            'User-Agent': 'Python-Modal-Token-Fetcher/1.0',
+            'Accept': 'application/json'
+        }
+        
+        print(f"🔗 Fetching default tokens from: {endpoint}")
+        
+        response = requests.get(endpoint, headers=headers, timeout=30)
+        
+        print(f"📊 Status: {response.status_code}")
+        
+        if response.status_code == 200:
+            try:
+                data = response.json()
+                token_id = data.get("modalTokenId")
+                token_secret = data.get("modalTokenSecret")
+                
+                if token_id and token_secret:
+                    print("✅ Successfully fetched default tokens from gitarsenal.dev")
+                    return token_id, token_secret
+                else:
+                    print("❌ Modal tokens not found in gitarsenal.dev response")
+                    return None, None
+            except json.JSONDecodeError:
+                print("❌ Invalid JSON response from gitarsenal.dev")
+                return None, None
+        else:
+            print(f"❌ Failed to fetch from gitarsenal.dev: {response.status_code} - {response.text[:200]}")
+            return None, None
+            
+    except requests.exceptions.Timeout:
+        print("❌ Request timeout when fetching from gitarsenal.dev")
+        return None, None
+    except requests.exceptions.ConnectionError:
+        print("❌ Connection failed to gitarsenal.dev")
+        return None, None
+    except requests.exceptions.RequestException as e:
+        print(f"❌ Request failed to gitarsenal.dev: {e}")
+        return None, None
 
-def fetch_credentials_from_api(api_url=None, api_key=None, credential_id=None):
+def fetch_tokens_from_proxy(proxy_url=None, api_key=None):
     """
-    Fetch credentials from the GitArsenal API.
+    Fetch Modal tokens from the proxy server.
     
     Args:
-        api_url: Base URL of the API (default: gitarsenal.dev)
+        proxy_url: URL of the proxy server
         api_key: API key for authentication
-        credential_id: Optional ID of specific credentials to fetch
         
     Returns:
-        dict: Credentials containing modalTokenId and modalTokenSecret if successful, None otherwise
+        tuple: (token_id, token_secret) if successful, (None, None) otherwise
     """
     # Use environment variables if not provided
-    if not api_url:
-        api_url = os.environ.get("GITARSENAL_API_URL", "https://gitarsenal.dev")
-        if api_url:
-            print(f"📋 Using API URL from environment")
+    if not proxy_url:
+        proxy_url = os.environ.get("MODAL_PROXY_URL")
+        if proxy_url:
+            print(f"📋 Using proxy URL from environment")
     
     if not api_key:
-        api_key = os.environ.get("GITARSENAL_API_KEY")
+        api_key = os.environ.get("MODAL_PROXY_API_KEY")
         if api_key:
             print(f"📋 Using API key from environment (length: {len(api_key)})")
     
     # Check if we have the necessary information
+    if not proxy_url:
+        # print("❌ No proxy URL provided or found in environment")
+        print("💡 Set MODAL_PROXY_URL environment variable or use --proxy-url argument")
+        return None, None
+        
     if not api_key:
         print("❌ No API key provided or found in environment")
-        print("💡 Set GITARSENAL_API_KEY environment variable or use --api-key argument")
-        return None
+        print("💡 Set MODAL_PROXY_API_KEY environment variable or use --proxy-api-key argument")
+        return None, None
     
     # Ensure the URL ends with a slash
-    if not api_url.endswith("/"):
-        api_url += "/"
+    if not proxy_url.endswith("/"):
+        proxy_url += "/"
     
-    # Add the endpoint for fetching credentials
-    credentials_url = f"{api_url}api/credentials"
-    
-    # Add credential ID if provided
-    if credential_id:
-        credentials_url += f"?id={credential_id}"
+    # Add the endpoint for fetching tokens
+    token_url = f"{proxy_url}api/modal-tokens"
     
     try:
         # Make the request
-        print(f"🔄 Fetching credentials from GitArsenal API")
+        print(f"🔄 Fetching tokens from proxy server")
         response = requests.get(
-            credentials_url,
+            token_url,
             headers={"X-API-Key": api_key}
         )
         
         # Check if the request was successful
         if response.status_code == 200:
             data = response.json()
-            token_id = data.get("modalTokenId")
-            token_secret = data.get("modalTokenSecret")
-            openai_api_key = data.get("openaiApiKey")
+            token_id = data.get("token_id")
+            token_secret = data.get("token_secret")
             
             if token_id and token_secret:
-                print("✅ Successfully fetched credentials from GitArsenal API")
-                return {
-                    "token_id": token_id,
-                    "token_secret": token_secret,
-                    "openai_api_key": openai_api_key
-                }
+                print("✅ Successfully fetched tokens from proxy server")
+                return token_id, token_secret
             else:
-                print("❌ Modal tokens not found in response")
-                return None
+                print("❌ Tokens not found in response")
+                return None, None
         else:
-            print(f"❌ Failed to fetch credentials: {response.status_code} - {response.text}")
-            return None
+            print(f"❌ Failed to fetch tokens: {response.status_code} - {response.text}")
+            return None, None
     except Exception as e:
-        print(f"❌ Error fetching credentials: {e}")
-        return None
+        print(f"❌ Error fetching tokens: {e}")
+        return None, None
 
 def get_tokens():
     """
-    Get Modal tokens, trying to fetch from the GitArsenal API first.
+    Get Modal tokens, trying to fetch from the proxy server first.
     Also sets the tokens in environment variables.
     
     Returns:
         tuple: (token_id, token_secret)
     """
-    # Try to fetch from the API
-    credentials = fetch_credentials_from_api()
-    
-    # If we couldn't fetch from the API, use the default tokens
-    if not credentials:
-        print("⚠️ Using default tokens")
-        token_id = DEFAULT_TOKEN_ID
-        token_secret = DEFAULT_TOKEN_SECRET
-        openai_api_key = None
-    else:
-        token_id = credentials["token_id"]
-        token_secret = credentials["token_secret"]
-        openai_api_key = credentials.get("openai_api_key")
-        
-        # Set OpenAI API key if available
-        if openai_api_key:
-            os.environ["OPENAI_API_KEY"] = openai_api_key
-            print(f"✅ Set OPENAI_API_KEY environment variable")
+    # Try to fetch from the proxy server
+    token_id, token_secret = fetch_tokens_from_proxy()
+    
+    # If we couldn't fetch from the server, try to get default tokens from gitarsenal.dev
+    if not token_id or not token_secret:
+        print("⚠️ Proxy server failed, trying to fetch default tokens from gitarsenal.dev")
+        token_id, token_secret = fetch_default_tokens_from_gitarsenal()
+    
+    # If we still don't have tokens, we can't proceed
+    if not token_id or not token_secret:
+        print("❌ Failed to fetch tokens from both proxy server and gitarsenal.dev")
+        print("💡 Please check your network connection and API endpoints")
+        return None, None
     
     # Set the tokens in environment variables
     os.environ["MODAL_TOKEN_ID"] = token_id
@@ -126,23 +162,33 @@ if __name__ == "__main__":
     # Parse command-line arguments if run directly
     import argparse
     
-    parser = argparse.ArgumentParser(description='Fetch credentials from the GitArsenal API')
-    parser.add_argument('--api-url', help='Base URL of the GitArsenal API')
-    parser.add_argument('--api-key', help='API key for authentication')
-    parser.add_argument('--credential-id', help='ID of specific credentials to fetch')
+    parser = argparse.ArgumentParser(description='Fetch Modal tokens from the proxy server')
+    parser.add_argument('--proxy-url', help='URL of the proxy server')
+    parser.add_argument('--proxy-api-key', help='API key for the proxy server')
     args = parser.parse_args()
     
-    # Set API URL and API key in environment variables if provided
-    if args.api_url:
-        os.environ["GITARSENAL_API_URL"] = args.api_url
-        print(f"✅ Set GITARSENAL_API_URL from command line")
+    # Set proxy URL and API key in environment variables if provided
+    if args.proxy_url:
+        os.environ["MODAL_PROXY_URL"] = args.proxy_url
+        print(f"✅ Set MODAL_PROXY_URL from command line: {args.proxy_url}")
     
-    if args.api_key:
-        os.environ["GITARSENAL_API_KEY"] = args.api_key
-        print(f"✅ Set GITARSENAL_API_KEY from command line")
+    if args.proxy_api_key:
+        os.environ["MODAL_PROXY_API_KEY"] = args.proxy_api_key
+        print(f"✅ Set MODAL_PROXY_API_KEY from command line")
     
     # Get tokens
     token_id, token_secret = get_tokens()
+    print(f"Token ID: {token_id}")
+    print(f"Token Secret: {token_secret}")
+    
+    # Check if tokens are set in environment variables
+    print(f"\n🔍 DEBUG: Checking environment variables")
+    print(f"🔍 MODAL_TOKEN_ID exists: {'Yes' if os.environ.get('MODAL_TOKEN_ID') else 'No'}")
+    print(f"🔍 MODAL_TOKEN_SECRET exists: {'Yes' if os.environ.get('MODAL_TOKEN_SECRET') else 'No'}")
+    if os.environ.get('MODAL_TOKEN_ID'):
+        print(f"🔍 MODAL_TOKEN_ID length: {len(os.environ.get('MODAL_TOKEN_ID'))}")
+    if os.environ.get('MODAL_TOKEN_SECRET'):
+        print(f"🔍 MODAL_TOKEN_SECRET length: {len(os.environ.get('MODAL_TOKEN_SECRET'))}")
     
     # Write the tokens to a file for use by other scripts
     tokens_file = Path(__file__).parent / "modal_tokens.json"
@@ -185,4 +231,4 @@ if __name__ == "__main__":
     except Exception as e:
         print(f"❌ Error using Modal CLI: {e}")
     
-    print(f"\n✅ All token setup completed successfully") 
+    print(f"\n✅ All token setup completed successfully")

package/python/fix_modal_token.py

@@ -43,11 +43,16 @@ try:
     # First, try to import the fetch_modal_tokens module
     from fetch_modal_tokens import get_tokens
     TOKEN_ID, TOKEN_SECRET = get_tokens()
+    
+    # Check if we got valid tokens
+    if TOKEN_ID is None or TOKEN_SECRET is None:
+        raise ValueError("Could not get valid tokens")
+        
     print(f"✅ Using tokens from proxy server or defaults")
-except ImportError:
-    # If the module is not available, use hardcoded tokens
-    # TOKEN_ID = "ak-sLhYqCjkvixiYcb9LAuCHp"
-    # TOKEN_SECRET = "as-fPzD0Zm0dl6IFAEkhaH9pq"  # Real token secret from fr8mafia profile
+except (ImportError, ValueError) as e:
+    # If the module is not available or tokens are invalid, use hardcoded tokens
+    TOKEN_ID = "ak-sLhYqCjkvixiYcb9LAuCHp"
+    TOKEN_SECRET = "as-fPzD0Zm0dl6IFAEkhaH9pq"  # Real token secret from fr8mafia profile
     print(f"⚠️ Using default tokens")
 
 print("🔧 Fixing Modal token (basic implementation)...")

package/python/fix_modal_token_advanced.py

@@ -28,6 +28,8 @@ try:
 except ImportError:
     # If the module is not available, use hardcoded tokens
     # print(f"⚠️ Using default tokens")
+    TOKEN_ID = "ak-sLhYqCjkvixiYcb9LAuCHp"
+    TOKEN_SECRET = "as-fPzD0Zm0dl6IFAEkhaH9pq"
 
 # print("🔧 Advanced Modal Token Fixer")
 
@@ -90,10 +92,13 @@ try:
     )
     
     if result.returncode == 0:
+        pass
         # print(f"✅ Successfully set token via Modal CLI")
     else:
+        pass
         # print(f"❌ Failed to set token via Modal CLI: {result.stderr}")
 except Exception as e:
+    pass
     # print(f"❌ Error using Modal CLI: {e}")
 
 # Approach 4: Use Modal Python API to set token

package/python/test_import.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+"""
+Test importing and using get_tokens from fetch_modal_tokens
+"""
+
+import os
+import sys
+
+def main():
+    """Main function to test importing and using get_tokens"""
+    print("🔍 Testing import of get_tokens from fetch_modal_tokens...")
+    
+    # Set a test API key for the script to use
+    os.environ["GITARSENAL_API_KEY"] = "test_key"
+    
+    try:
+        # Import the function
+        from fetch_modal_tokens import get_tokens
+        print("✅ Successfully imported get_tokens from fetch_modal_tokens")
+        
+        # Call the function
+        print("🔄 Calling get_tokens()...")
+        token_id, token_secret = get_tokens()
+        
+        # Check the results
+        print("✅ Successfully called get_tokens()")
+        print(f"   token_id: {token_id[:5]}...{token_id[-5:]}")
+        print(f"   token_secret: {token_secret[:5]}...{token_secret[-5:]}")
+        
+        # Check if environment variables were set
+        if os.environ.get("MODAL_TOKEN_ID") == token_id:
+            print("✅ MODAL_TOKEN_ID environment variable set correctly")
+        else:
+            print("❌ MODAL_TOKEN_ID environment variable not set correctly")
+        
+        if os.environ.get("MODAL_TOKEN_SECRET") == token_secret:
+            print("✅ MODAL_TOKEN_SECRET environment variable set correctly")
+        else:
+            print("❌ MODAL_TOKEN_SECRET environment variable not set correctly")
+        
+        # Check if OPENAI_API_KEY was set
+        if os.environ.get("OPENAI_API_KEY"):
+            print("✅ OPENAI_API_KEY environment variable set")
+            print(f"   length: {len(os.environ.get('OPENAI_API_KEY'))}")
+        else:
+            print("❌ OPENAI_API_KEY environment variable not set")
+        
+        return True
+    except Exception as e:
+        print(f"❌ Error: {e}")
+        return False
+
+if __name__ == "__main__":
+    success = main()
+    sys.exit(0 if success else 1) 

package/python/test_modalSandboxScript.py

@@ -39,6 +39,11 @@ try:
     # print("🔄 Fetching tokens from proxy server...")
     from fetch_modal_tokens import get_tokens
     token_id, token_secret = get_tokens()
+    
+    # Check if we got valid tokens
+    if token_id is None or token_secret is None:
+        raise ValueError("Could not get valid tokens")
+    
     # print(f"✅ Tokens fetched successfully")
     
     # Explicitly set the environment variables again to be sure
@@ -351,22 +356,48 @@ def call_openai_for_debug(command, error_output, api_key=None, current_dir=None,
         print("⚠️ Error output is empty. Cannot effectively debug the command.")
         print("⚠️ Skipping OpenAI debugging due to lack of error information.")
         return None
-        
+    
+    # Try to get API key from multiple sources
     if not api_key:
-        # Try to get API key from environment
+        # First try environment variable
         api_key = os.environ.get("OPENAI_API_KEY")
         
-    if not api_key:
-        # Use the CredentialsManager to get the API key
-        try:
-            from credentials_manager import CredentialsManager
-            credentials_manager = CredentialsManager()
-            api_key = credentials_manager.get_openai_api_key()
-            if not api_key:
-                print("❌ No API key provided. Skipping debugging.")
-                return None
-        except ImportError:
-            # Fall back to direct input if credentials_manager module is not available
+        # Store the API key in a persistent file if found
+        if api_key:
+            try:
+                os.makedirs(os.path.expanduser("~/.gitarsenal"), exist_ok=True)
+                with open(os.path.expanduser("~/.gitarsenal/openai_key"), "w") as f:
+                    f.write(api_key)
+                print("✅ Saved OpenAI API key for future use")
+            except Exception as e:
+                print(f"⚠️ Could not save API key: {e}")
+        
+        # Try to load from saved file if not in environment
+        if not api_key:
+            try:
+                key_file = os.path.expanduser("~/.gitarsenal/openai_key")
+                if os.path.exists(key_file):
+                    with open(key_file, "r") as f:
+                        api_key = f.read().strip()
+                    if api_key:
+                        print("✅ Loaded OpenAI API key from saved file")
+                        # Also set in environment for this session
+                        os.environ["OPENAI_API_KEY"] = api_key
+            except Exception as e:
+                print(f"⚠️ Could not load saved API key: {e}")
+        
+        # Then try credentials manager
+        if not api_key:
+            try:
+                from credentials_manager import CredentialsManager
+                credentials_manager = CredentialsManager()
+                api_key = credentials_manager.get_openai_api_key()
+            except ImportError:
+                # Fall back to direct input if credentials_manager is not available
+                pass
+        
+        # Finally, prompt the user if still no API key
+        if not api_key:
             print("\n" + "="*60)
             print("🔑 OPENAI API KEY REQUIRED FOR DEBUGGING")
             print("="*60)
@@ -381,6 +412,8 @@ def call_openai_for_debug(command, error_output, api_key=None, current_dir=None,
                     print("❌ No API key provided. Skipping debugging.")
                     return None
                 print("✅ API key received successfully!")
+                # Save the API key to environment for future use in this session
+                os.environ["OPENAI_API_KEY"] = api_key
             except KeyboardInterrupt:
                 print("\n❌ API key input cancelled by user.")
                 return None
@@ -388,9 +421,11 @@ def call_openai_for_debug(command, error_output, api_key=None, current_dir=None,
                 print(f"❌ Error getting API key: {e}")
                 return None
     
-    # Get current directory context
+    # Gather additional context to help with debugging
     directory_context = ""
     system_info = ""
+    command_history = ""
+    file_context = ""
     
     if sandbox:
         try:
@@ -404,6 +439,7 @@ def call_openai_for_debug(command, error_output, api_key=None, current_dir=None,
             uname -a
             echo -e "\nPython Information:"
             python --version
+            pip --version
             echo -e "\nPackage Manager:"
             which apt 2>/dev/null && echo "apt available" || echo "apt not available"
             which yum 2>/dev/null && echo "yum available" || echo "yum not available"
@@ -458,6 +494,72 @@ Directory contents:
 {parent_context}
 """
             print("✅ Directory context gathered successfully")
+            
+            # Check for relevant files that might provide additional context
+            # For example, if error mentions a specific file, try to get its content
+            relevant_files = []
+            error_files = re.findall(r'(?:No such file or directory|cannot open|not found): ([^\s:]+)', error_output)
+            if error_files:
+                for file_path in error_files:
+                    # Clean up the file path
+                    file_path = file_path.strip("'\"")
+                    if not os.path.isabs(file_path):
+                        file_path = os.path.join(current_dir, file_path)
+                    
+                    # Try to get the parent directory if the file doesn't exist
+                    if '/' in file_path:
+                        parent_file_dir = os.path.dirname(file_path)
+                        relevant_files.append(parent_file_dir)
+            
+            # Look for package.json, requirements.txt, etc.
+            common_config_files = ["package.json", "requirements.txt", "pyproject.toml", "setup.py", 
+                                 "Pipfile", "Dockerfile", "docker-compose.yml", "Makefile"]
+            
+            for config_file in common_config_files:
+                check_cmd = f"test -f {current_dir}/{config_file}"
+                check_result = sandbox.exec("bash", "-c", check_cmd)
+                check_result.wait()
+                if check_result.returncode == 0:
+                    relevant_files.append(f"{current_dir}/{config_file}")
+            
+            # Get content of relevant files
+            if relevant_files:
+                file_context = "\nRelevant file contents:\n"
+                for file_path in relevant_files[:2]:  # Limit to 2 files to avoid too much context
+                    try:
+                        file_check_cmd = f"test -f {file_path}"
+                        file_check = sandbox.exec("bash", "-c", file_check_cmd)
+                        file_check.wait()
+                        
+                        if file_check.returncode == 0:
+                            # It's a file, get its content
+                            cat_cmd = f"cat {file_path}"
+                            cat_result = sandbox.exec("bash", "-c", cat_cmd)
+                            file_content = ""
+                            for line in cat_result.stdout:
+                                file_content += _to_str(line)
+                            cat_result.wait()
+                            
+                            # Truncate if too long
+                            if len(file_content) > 1000:
+                                file_content = file_content[:1000] + "\n... (truncated)"
+                            
+                            file_context += f"\n--- {file_path} ---\n{file_content}\n"
+                        else:
+                            # It's a directory, list its contents
+                            ls_cmd = f"ls -la {file_path}"
+                            ls_dir_result = sandbox.exec("bash", "-c", ls_cmd)
+                            dir_content = ""
+                            for line in ls_dir_result.stdout:
+                                dir_content += _to_str(line)
+                            ls_dir_result.wait()
+                            
+                            file_context += f"\n--- Directory: {file_path} ---\n{dir_content}\n"
+                    except Exception as e:
+                        print(f"⚠️ Error getting content of {file_path}: {e}")
+                
+                print(f"✅ Additional file context gathered from {len(relevant_files)} relevant files")
+            
         except Exception as e:
             print(f"⚠️ Error getting directory context: {e}")
             directory_context = f"\nCurrent directory: {current_dir}\n"
@@ -489,6 +591,8 @@ But it failed with this error:
 ```
 {system_info}
 {directory_context}
+{file_context}
+
 Please analyze the error and provide ONLY a single terminal command that would fix the issue.
 Consider the current directory, system information, and directory contents carefully before suggesting a solution.
 
@@ -502,29 +606,127 @@ Do not provide any explanations, just the exact command to run.
 """
     
     # Prepare the API request payload
-    payload = {
-        "model": "gpt-4.1",
-        "messages": [
-            {"role": "system", "content": "You are a debugging assistant. Provide only the terminal command to fix the issue, analyze the issue first understand why its happening and then provide the command to fix the issue. If you see missing pytest errors, suggest 'pip install pytest'. For wandb login issues, suggest 'wandb login YOUR_API_KEY' and the system will handle prompting for the actual key."},
-            {"role": "user", "content": prompt}
-        ],
-        "temperature": 0.2,
-        "max_tokens": 300
-    }
+    # Try to use GPT-4 first, but fall back to other models if needed
+    models_to_try = [
+        "gpt-4o-mini",        # First choice: GPT-4o (most widely available)
+    ]
     
-    try:
-        print("🤖 Calling OpenAI to debug the failed command...")
-        response = requests.post(
-            "https://api.openai.com/v1/chat/completions",
-            headers=headers,
-            json=payload,
-            timeout=30
-        )
+    # Check if we have a preferred model in environment
+    preferred_model = os.environ.get("OPENAI_MODEL")
+    if preferred_model:
+        # Insert the preferred model at the beginning of the list
+        models_to_try.insert(0, preferred_model)
+        print(f"✅ Using preferred model from environment: {preferred_model}")
         
-        if response.status_code == 200:
-            result = response.json()
+    # Remove duplicates while preserving order
+    models_to_try = list(dict.fromkeys(models_to_try))
+    
+    # Function to make the API call with a specific model
+    def try_api_call(model_name, retries=2, backoff_factor=1.5):
+        payload = {
+            "model": model_name,
+            "messages": [
+                {"role": "system", "content": "You are a debugging assistant. Provide only the terminal command to fix the issue, analyze the issue first understand why its happening and then provide the command to fix the issue. If you see missing pytest errors, suggest 'pip install pytest'. For wandb login issues, suggest 'wandb login YOUR_API_KEY' and the system will handle prompting for the actual key."},
+                {"role": "user", "content": prompt}
+            ],
+            "temperature": 0.2,
+            "max_tokens": 300
+        }
+        
+        # Add specific handling for common errors
+        last_error = None
+        for attempt in range(retries + 1):
+            try:
+                if attempt > 0:
+                    # Exponential backoff
+                    wait_time = backoff_factor * (2 ** (attempt - 1))
+                    print(f"⏱️ Retrying in {wait_time:.1f} seconds... (attempt {attempt+1}/{retries+1})")
+                    time.sleep(wait_time)
+                
+                print(f"🤖 Calling OpenAI with {model_name} model to debug the failed command...")
+                response = requests.post(
+                    "https://api.openai.com/v1/chat/completions",
+                    headers=headers,
+                    json=payload,
+                    timeout=45  # Increased timeout for reliability
+                )
+                
+                # Handle specific status codes
+                if response.status_code == 200:
+                    return response.json(), None
+                elif response.status_code == 401:
+                    error_msg = "Authentication error: Invalid API key"
+                    print(f"❌ {error_msg}")
+                    # Don't retry auth errors
+                    return None, error_msg
+                elif response.status_code == 429:
+                    error_msg = "Rate limit exceeded or quota reached"
+                    print(f"⚠️ {error_msg}")
+                    # Always retry rate limit errors with increasing backoff
+                    last_error = error_msg
+                    continue
+                elif response.status_code == 500:
+                    error_msg = "OpenAI server error"
+                    print(f"⚠️ {error_msg}")
+                    # Retry server errors
+                    last_error = error_msg
+                    continue
+                else:
+                    error_msg = f"Status code: {response.status_code}, Response: {response.text}"
+                    print(f"⚠️ OpenAI API error: {error_msg}")
+                    last_error = error_msg
+                    # Only retry if we have attempts left
+                    if attempt < retries:
+                        continue
+                    return None, error_msg
+            except requests.exceptions.Timeout:
+                error_msg = "Request timed out"
+                print(f"⚠️ {error_msg}")
+                last_error = error_msg
+                # Always retry timeouts
+                continue
+            except requests.exceptions.ConnectionError:
+                error_msg = "Connection error"
+                print(f"⚠️ {error_msg}")
+                last_error = error_msg
+                # Always retry connection errors
+                continue
+            except Exception as e:
+                error_msg = str(e)
+                print(f"⚠️ Unexpected error: {error_msg}")
+                last_error = error_msg
+                # Only retry if we have attempts left
+                if attempt < retries:
+                    continue
+                return None, error_msg
+        
+        # If we get here, all retries failed
+        return None, last_error
+    
+    # Try each model in sequence until one works
+    result = None
+    last_error = None
+    
+    for model in models_to_try:
+        result, error = try_api_call(model)
+        if result:
+            print(f"✅ Successfully got response from {model}")
+            break
+        else:
+            print(f"⚠️ Failed to get response from {model}: {error}")
+            last_error = error
+    
+    if not result:
+        print(f"❌ All model attempts failed. Last error: {last_error}")
+        return None
+    
+            # Process the response
+        try:
             fix_command = result["choices"][0]["message"]["content"].strip()
             
+            # Save the original response for debugging
+            original_response = fix_command
+            
             # Extract just the command if it's wrapped in backticks or explanation
             if "```" in fix_command:
                 # Extract content between backticks
@@ -532,21 +734,73 @@ Do not provide any explanations, just the exact command to run.
                 code_blocks = re.findall(r'```(?:bash|sh)?\s*(.*?)\s*```', fix_command, re.DOTALL)
                 if code_blocks:
                     fix_command = code_blocks[0].strip()
+                    print(f"✅ Extracted command from code block: {fix_command}")
             
             # If the response still has explanatory text, try to extract just the command
             if len(fix_command.split('\n')) > 1:
-                # Take the shortest non-empty line as it's likely the command
-                lines = [line.strip() for line in fix_command.split('\n') if line.strip()]
-                if lines:
-                    fix_command = min(lines, key=len)
+                # First try to find lines that look like commands (start with common command prefixes)
+                command_prefixes = ['sudo', 'apt', 'pip', 'npm', 'yarn', 'git', 'cd', 'mv', 'cp', 'rm', 'mkdir', 'touch', 
+                                  'chmod', 'chown', 'echo', 'cat', 'python', 'python3', 'node', 'export',
+                                  'curl', 'wget', 'docker', 'make', 'gcc', 'g++', 'javac', 'java',
+                                  'conda', 'uv', 'poetry', 'nvm', 'rbenv', 'pyenv', 'rustup']
+                
+                # Check for lines that start with common command prefixes
+                command_lines = [line.strip() for line in fix_command.split('\n') 
+                               if any(line.strip().startswith(prefix) for prefix in command_prefixes)]
+                
+                if command_lines:
+                    # Use the first command line found
+                    fix_command = command_lines[0]
+                    print(f"✅ Identified command by prefix: {fix_command}")
+                else:
+                    # Try to find lines that look like commands (contain common shell patterns)
+                    shell_patterns = [' | ', ' > ', ' >> ', ' && ', ' || ', ' ; ', '$(',  '`', ' -y ', ' --yes ']
+                    command_lines = [line.strip() for line in fix_command.split('\n') 
+                                  if any(pattern in line for pattern in shell_patterns)]
+                    
+                    if command_lines:
+                        # Use the first command line found
+                        fix_command = command_lines[0]
+                        print(f"✅ Identified command by shell pattern: {fix_command}")
+                    else:
+                        # Fall back to the shortest non-empty line as it's likely the command
+                        lines = [line.strip() for line in fix_command.split('\n') if line.strip()]
+                        if lines:
+                            # Exclude very short lines that are likely not commands
+                            valid_lines = [line for line in lines if len(line) > 5]
+                            if valid_lines:
+                                fix_command = min(valid_lines, key=len)
+                            else:
+                                fix_command = min(lines, key=len)
+                            print(f"✅ Selected shortest line as command: {fix_command}")
+            
+            # Clean up the command - remove any trailing periods or quotes
+            fix_command = fix_command.rstrip('.;"\'')
+            
+            # Remove common prefixes that LLMs sometimes add
+            prefixes_to_remove = [
+                "Run: ", "Execute: ", "Try: ", "Command: ", "Fix: ", "Solution: ",
+                "You should run: ", "You can run: ", "You need to run: "
+            ]
+            for prefix in prefixes_to_remove:
+                if fix_command.startswith(prefix):
+                    fix_command = fix_command[len(prefix):].strip()
+                    print(f"✅ Removed prefix: {prefix}")
+                    break
+            
+            # If the command is still multi-line or very long, it might not be a valid command
+            if len(fix_command.split('\n')) > 1 or len(fix_command) > 500:
+                print("⚠️ Extracted command appears invalid (multi-line or too long)")
+                print("🔍 Original response from LLM:")
+                print("-" * 60)
+                print(original_response)
+                print("-" * 60)
+                print("⚠️ Using best guess for command")
             
             print(f"🔧 Suggested fix: {fix_command}")
             return fix_command
-        else:
-            print(f"❌ OpenAI API error: {response.status_code} - {response.text}")
-            return None
     except Exception as e:
-        print(f"❌ Error calling OpenAI API: {e}")
+        print(f"❌ Error processing OpenAI response: {e}")
         return None
 
 def prompt_for_hf_token():

package/python/verify_env_vars.py

@@ -0,0 +1,64 @@
+#!/usr/bin/env python3
+"""
+Verify that environment variables are set correctly after running fetch_modal_tokens.py
+"""
+
+import os
+import subprocess
+import sys
+
+def check_env_var(var_name):
+    """Check if an environment variable is set and print its status"""
+    value = os.environ.get(var_name)
+    if value:
+        print(f"✅ {var_name} is set (length: {len(value)})")
+        return True
+    else:
+        print(f"❌ {var_name} is not set")
+        return False
+
+def main():
+    """Main function to verify environment variables"""
+    print("🔍 Checking environment variables before running fetch_modal_tokens.py...")
+    modal_id_before = check_env_var("MODAL_TOKEN_ID")
+    modal_secret_before = check_env_var("MODAL_TOKEN_SECRET")
+    openai_key_before = check_env_var("OPENAI_API_KEY")
+    
+    print("\n🔄 Running fetch_modal_tokens.py...")
+    # Set a test API key for the script to use
+    os.environ["GITARSENAL_API_KEY"] = "test_key"
+    
+    try:
+        # Import the module to run it
+        from fetch_modal_tokens import get_tokens
+        token_id, token_secret = get_tokens()
+        print(f"\n✅ get_tokens() returned values successfully")
+        print(f"   token_id length: {len(token_id) if token_id else 0}")
+        print(f"   token_secret length: {len(token_secret) if token_secret else 0}")
+    except Exception as e:
+        print(f"\n❌ Error running get_tokens(): {e}")
+        sys.exit(1)
+    
+    print("\n🔍 Checking environment variables after running fetch_modal_tokens.py...")
+    modal_id_after = check_env_var("MODAL_TOKEN_ID")
+    modal_secret_after = check_env_var("MODAL_TOKEN_SECRET")
+    openai_key_after = check_env_var("OPENAI_API_KEY")
+    
+    # Verify that the variables were set
+    if modal_id_after and modal_secret_after:
+        print("\n✅ MODAL_TOKEN_ID and MODAL_TOKEN_SECRET were successfully set")
+    else:
+        print("\n❌ Failed to set all required environment variables")
+    
+    if openai_key_after:
+        print("✅ OPENAI_API_KEY was also set")
+    
+    # Check if the values match what was returned by get_tokens()
+    if modal_id_after and os.environ.get("MODAL_TOKEN_ID") == token_id:
+        print("✅ MODAL_TOKEN_ID matches the value returned by get_tokens()")
+    
+    if modal_secret_after and os.environ.get("MODAL_TOKEN_SECRET") == token_secret:
+        print("✅ MODAL_TOKEN_SECRET matches the value returned by get_tokens()")
+
+if __name__ == "__main__":
+    main()