gitarsenal-cli 1.8.3 → 1.8.5

package/test_modalSandboxScript.py

@@ -16,6 +16,13 @@ import signal
 from pathlib import Path
 import modal
 
+# Import authentication manager
+try:
+    from auth_manager import AuthManager
+except ImportError:
+    print("❌ Authentication module not found. Please ensure auth_manager.py is in the same directory.")
+    sys.exit(1)
+
 # Parse command-line arguments
 parser = argparse.ArgumentParser()
 parser.add_argument('--proxy-url', help='URL of the proxy server')
@@ -1616,7 +1623,6 @@ Consider the current directory, system information, directory contents, and avai
 IMPORTANT GUIDELINES:
 1. For any commands that might ask for yes/no confirmation, use the appropriate non-interactive flag:
    - For apt/apt-get: use -y or --yes
-   - For pip: use --no-input
    - For rm: use -f or --force
 
 2. If the error indicates a file is not found:
@@ -3326,6 +3332,18 @@ def show_usage_examples():
     """Display usage examples for the script."""
     print("Usage Examples\n")
     
+    print("🔐 Authentication Commands")
+    print("┌────────────────────────────────────────────────────────────────────────────────────┐")
+    print("│ gitarsenal --register                    # Register new account                  │")
+    print("│ gitarsenal --login                        # Login to existing account            │")
+    print("│ gitarsenal --logout                       # Logout from account                  │")
+    print("│ gitarsenal --user-info                    # Show current user information       │")
+    print("│ gitarsenal --change-password              # Change password                     │")
+    print("│ gitarsenal --delete-account               # Delete account                      │")
+    print("│ gitarsenal --store-api-key openai        # Store OpenAI API key                │")
+    print("│ gitarsenal --auth                         # Interactive auth management         │")
+    print("└────────────────────────────────────────────────────────────────────────────────────┘\n")
+    
     print("Basic Container Creation")
     print("┌────────────────────────────────────────────────────────────────────────┐")
     print("│ gitarsenal --gpu A10G --repo-url https://github.com/username/repo.git  │")
@@ -3360,19 +3378,32 @@ def show_usage_examples():
     print("│   --use-api                                                      │")
     print("└────────────────────────────────────────────────────────────────────────────────────┘\n")
     
+    print("Development Mode (Skip Authentication)")
+    print("┌────────────────────────────────────────────────────────────────────────────────────┐")
+    print("│ gitarsenal --skip-auth --gpu A10G --repo-url https://github.com/username/repo.git │")
+    print("└────────────────────────────────────────────────────────────────────────────────────┘\n")
+    
     print("Available GPU Options:")
     print("  T4, L4, A10G, A100-40GB, A100-80GB, L40S, H100, H200, B200")
     print()
+    print("Authentication Behavior:")
+    print("  • First time: Interactive registration/login required")
+    print("  • Subsequent runs: Automatic login with stored session")
+    print("  • Use --skip-auth for development (bypasses auth)")
+    print()
     print("GPU Selection Behavior:")
     print("  • With --gpu: Uses specified GPU without prompting")
     print("  • Without --gpu: Shows interactive GPU selection menu")
     print()
     print("Examples:")
-    print("  # Uses A10G without prompting:")
+    print("  # First time setup (will prompt for registration):")
     print("  gitarsenal --gpu A10G --repo-url https://github.com/username/repo.git")
     print()
-    print("  # Shows interactive GPU selection menu:")
+    print("  # Subsequent runs (automatic login):")
     print("  gitarsenal --repo-url https://github.com/username/repo.git")
+    print()
+    print("  # Development mode (skip authentication):")
+    print("  gitarsenal --skip-auth --repo-url https://github.com/username/repo.git")
 
 def make_api_request_with_retry(url, payload, max_retries=2, timeout=180):
     """Make an API request with retry mechanism."""
@@ -3860,6 +3891,304 @@ def prompt_for_gpu():
                 print("✅ Using default GPU: A10G")
                 return "A10G"
 
+
+
+def preprocess_commands_with_llm(setup_commands, stored_credentials, api_key=None):
+    """
+    Use LLM to preprocess setup commands and inject available credentials.
+    
+    Args:
+        setup_commands: List of setup commands
+        stored_credentials: Dictionary of stored credentials
+        api_key: OpenAI API key for LLM calls
+        
+    Returns:
+        List of processed commands with credentials injected
+    """
+    if not setup_commands or not stored_credentials:
+        return setup_commands
+    
+    try:
+        # Create context for the LLM
+        credentials_info = "\n".join([f"- {key}: {value[:8]}..." for key, value in stored_credentials.items()])
+        
+        prompt = f"""
+You are a command preprocessing assistant. Your task is to modify setup commands to use available credentials and make them non-interactive.
+
+AVAILABLE CREDENTIALS:
+{credentials_info}
+
+ORIGINAL COMMANDS:
+{chr(10).join([f"{i+1}. {cmd}" for i, cmd in enumerate(setup_commands)])}
+
+INSTRUCTIONS:
+1. Replace any authentication commands with token-based versions using available credentials
+2. Make all commands non-interactive (add --yes, --no-input, -y flags where needed)
+3. Use environment variables or direct token injection where appropriate
+4. Skip commands that cannot be made non-interactive due to missing credentials
+5. Add any necessary environment variable exports
+
+Return the modified commands as a JSON array of strings. If a command should be skipped, prefix it with "# SKIPPED: ".
+
+Example transformations:
+- "huggingface-cli login" → "huggingface-cli login --token $HUGGINGFACE_TOKEN"
+- "npm install" → "npm install --yes"
+
+Return only the JSON array, no other text.
+"""
+        
+        if not api_key:
+            print("⚠️ No OpenAI API key available for command preprocessing")
+            return setup_commands
+        
+        # Call OpenAI API
+        import openai
+        client = openai.OpenAI(api_key=api_key)
+        
+        response = client.chat.completions.create(
+            model="gpt-3.5-turbo",
+            messages=[
+                {"role": "system", "content": "You are a command preprocessing assistant that modifies setup commands to use available credentials and make them non-interactive."},
+                {"role": "user", "content": prompt}
+            ],
+            temperature=0.1,
+            max_tokens=2000
+        )
+        
+        result = response.choices[0].message.content.strip()
+        
+        # Debug: Print the raw response
+        print(f"🔍 LLM Response: {result[:200]}...")
+        
+        # Parse the JSON response
+        import json
+        try:
+            processed_commands = json.loads(result)
+            if isinstance(processed_commands, list):
+                print(f"🔧 LLM preprocessed {len(processed_commands)} commands")
+                for i, cmd in enumerate(processed_commands):
+                    if cmd != setup_commands[i]:
+                        print(f"  {i+1}. {setup_commands[i]} → {cmd}")
+                return processed_commands
+            else:
+                print("⚠️ LLM returned invalid format, using fallback preprocessing")
+                return fallback_preprocess_commands(setup_commands, stored_credentials)
+        except json.JSONDecodeError as e:
+            print(f"⚠️ Failed to parse LLM response: {e}")
+            print("🔄 Using fallback preprocessing...")
+            return fallback_preprocess_commands(setup_commands, stored_credentials)
+            
+    except Exception as e:
+        print(f"⚠️ LLM preprocessing failed: {e}")
+        print("🔄 Using fallback preprocessing...")
+        return fallback_preprocess_commands(setup_commands, stored_credentials)
+
+def fallback_preprocess_commands(setup_commands, stored_credentials):
+    """
+    Fallback preprocessing function that manually handles common credential injection patterns.
+    
+    Args:
+        setup_commands: List of setup commands
+        stored_credentials: Dictionary of stored credentials
+        
+    Returns:
+        List of processed commands with credentials injected
+    """
+    if not setup_commands or not stored_credentials:
+        return setup_commands
+    
+    processed_commands = []
+    
+    for i, command in enumerate(setup_commands):
+        processed_command = command
+        
+        # Handle Hugging Face login
+        if 'huggingface-cli login' in command and '--token' not in command:
+            if 'HUGGINGFACE_TOKEN' in stored_credentials:
+                processed_command = f"huggingface-cli login --token $HUGGINGFACE_TOKEN"
+                print(f"🔧 Fallback: Injected HF token into command {i+1}")
+            else:
+                processed_command = f"# SKIPPED: {command} (no HF token available)"
+                print(f"🔧 Fallback: Skipped command {i+1} (no HF token)")
+        
+        # Handle OpenAI API key
+        elif 'openai' in command.lower() and 'api_key' not in command.lower():
+            if 'OPENAI_API_KEY' in stored_credentials:
+                processed_command = f"export OPENAI_API_KEY=$OPENAI_API_KEY && {command}"
+                print(f"🔧 Fallback: Added OpenAI API key export to command {i+1}")
+        
+        # Handle npm install
+        elif 'npm install' in command and '--yes' not in command and '--no-interactive' not in command:
+            processed_command = command.replace('npm install', 'npm install --yes')
+            print(f"🔧 Fallback: Made npm install non-interactive in command {i+1}")
+        
+        # Handle git clone
+        elif command.strip().startswith('git clone') and '--depth 1' not in command:
+            processed_command = command.replace('git clone', 'git clone --depth 1')
+            print(f"🔧 Fallback: Made git clone non-interactive in command {i+1}")
+        
+        # Handle apt-get install
+        elif 'apt-get install' in command and '-y' not in command:
+            processed_command = command.replace('apt-get install', 'apt-get install -y')
+            print(f"🔧 Fallback: Made apt-get install non-interactive in command {i+1}")
+        
+        processed_commands.append(processed_command)
+    
+    print(f"🔧 Fallback preprocessing completed: {len(processed_commands)} commands")
+    return processed_commands
+
+def _check_authentication(auth_manager):
+    """Check if user is authenticated, prompt for login if not"""
+    if auth_manager.is_authenticated():
+        user = auth_manager.get_current_user()
+        print(f"✅ Authenticated as: {user['username']}")
+        return True
+    
+    print("\n🔐 Authentication required")
+    return auth_manager.interactive_auth_flow()
+
+def _handle_auth_commands(auth_manager, args):
+    """Handle authentication-related commands"""
+    if args.login:
+        print("\n🔐 LOGIN")
+        username = input("Username: ").strip()
+        password = getpass.getpass("Password: ").strip()
+        if auth_manager.login_user(username, password):
+            print("✅ Login successful!")
+        else:
+            print("❌ Login failed.")
+    
+    elif args.register:
+        print("\n🔐 REGISTRATION")
+        username = input("Username (min 3 characters): ").strip()
+        email = input("Email: ").strip()
+        password = getpass.getpass("Password (min 8 characters): ").strip()
+        confirm_password = getpass.getpass("Confirm password: ").strip()
+        
+        if password != confirm_password:
+            print("❌ Passwords do not match.")
+            return
+        
+        if auth_manager.register_user(username, email, password):
+            print("✅ Registration successful!")
+            # Auto-login after registration
+            if auth_manager.login_user(username, password):
+                print("✅ Auto-login successful!")
+        else:
+            print("❌ Registration failed.")
+    
+    elif args.logout:
+        auth_manager.logout_user()
+    
+    elif args.user_info:
+        auth_manager.show_user_info()
+    
+    elif args.change_password:
+        if not auth_manager.is_authenticated():
+            print("❌ Not logged in. Please login first.")
+            return
+        
+        current_password = getpass.getpass("Current password: ").strip()
+        new_password = getpass.getpass("New password (min 8 characters): ").strip()
+        confirm_password = getpass.getpass("Confirm new password: ").strip()
+        
+        if new_password != confirm_password:
+            print("❌ New passwords do not match.")
+            return
+        
+        if auth_manager.change_password(current_password, new_password):
+            print("✅ Password changed successfully!")
+        else:
+            print("❌ Failed to change password.")
+    
+    elif args.delete_account:
+        if not auth_manager.is_authenticated():
+            print("❌ Not logged in. Please login first.")
+            return
+        
+        password = getpass.getpass("Enter your password to confirm deletion: ").strip()
+        if auth_manager.delete_account(password):
+            print("✅ Account deleted successfully!")
+        else:
+            print("❌ Failed to delete account.")
+    
+    elif args.store_api_key:
+        if not auth_manager.is_authenticated():
+            print("❌ Not logged in. Please login first.")
+            return
+        
+        service = args.store_api_key
+        api_key = getpass.getpass(f"Enter {service} API key: ").strip()
+        
+        if auth_manager.store_api_key(service, api_key):
+            print(f"✅ {service} API key stored successfully!")
+        else:
+            print(f"❌ Failed to store {service} API key.")
+    
+    elif args.auth:
+        # Interactive authentication management
+        while True:
+            print("\n" + "="*60)
+            print("🔐 AUTHENTICATION MANAGEMENT")
+            print("="*60)
+            print("1. Login")
+            print("2. Register")
+            print("3. Show user info")
+            print("4. Change password")
+            print("5. Store API key")
+            print("6. Delete account")
+            print("7. Logout")
+            print("8. Exit")
+            
+            choice = input("\nSelect an option (1-8): ").strip()
+            
+            if choice == "1":
+                username = input("Username: ").strip()
+                password = getpass.getpass("Password: ").strip()
+                auth_manager.login_user(username, password)
+            elif choice == "2":
+                username = input("Username (min 3 characters): ").strip()
+                email = input("Email: ").strip()
+                password = getpass.getpass("Password (min 8 characters): ").strip()
+                confirm_password = getpass.getpass("Confirm password: ").strip()
+                if password == confirm_password:
+                    auth_manager.register_user(username, email, password)
+                else:
+                    print("❌ Passwords do not match.")
+            elif choice == "3":
+                auth_manager.show_user_info()
+            elif choice == "4":
+                if auth_manager.is_authenticated():
+                    current_password = getpass.getpass("Current password: ").strip()
+                    new_password = getpass.getpass("New password (min 8 characters): ").strip()
+                    confirm_password = getpass.getpass("Confirm new password: ").strip()
+                    if new_password == confirm_password:
+                        auth_manager.change_password(current_password, new_password)
+                    else:
+                        print("❌ New passwords do not match.")
+                else:
+                    print("❌ Not logged in.")
+            elif choice == "5":
+                if auth_manager.is_authenticated():
+                    service = input("Service name (e.g., openai, modal): ").strip()
+                    api_key = getpass.getpass(f"Enter {service} API key: ").strip()
+                    auth_manager.store_api_key(service, api_key)
+                else:
+                    print("❌ Not logged in.")
+            elif choice == "6":
+                if auth_manager.is_authenticated():
+                    password = getpass.getpass("Enter your password to confirm deletion: ").strip()
+                    auth_manager.delete_account(password)
+                else:
+                    print("❌ Not logged in.")
+            elif choice == "7":
+                auth_manager.logout_user()
+            elif choice == "8":
+                print("👋 Goodbye!")
+                break
+            else:
+                print("❌ Invalid option. Please try again.")
+
 # Replace the existing GPU argument parsing in the main section
 if __name__ == "__main__":
     # Parse command line arguments when script is run directly
@@ -3885,8 +4214,27 @@ if __name__ == "__main__":
     parser.add_argument('--list-gpus', action='store_true', help='List available GPU types with their specifications')
     parser.add_argument('--interactive', action='store_true', help='Run in interactive mode with prompts')
     
+    # Authentication-related arguments
+    parser.add_argument('--auth', action='store_true', help='Manage authentication (login, register, logout)')
+    parser.add_argument('--login', action='store_true', help='Login to GitArsenal')
+    parser.add_argument('--register', action='store_true', help='Register new account')
+    parser.add_argument('--logout', action='store_true', help='Logout from GitArsenal')
+    parser.add_argument('--user-info', action='store_true', help='Show current user information')
+    parser.add_argument('--change-password', action='store_true', help='Change password')
+    parser.add_argument('--delete-account', action='store_true', help='Delete account')
+    parser.add_argument('--store-api-key', type=str, help='Store API key for a service (e.g., openai, modal)')
+    parser.add_argument('--skip-auth', action='store_true', help='Skip authentication check (for development)')
+    
     args = parser.parse_args()
     
+    # Initialize authentication manager
+    auth_manager = AuthManager()
+    
+    # Handle authentication-related commands
+    if args.auth or args.login or args.register or args.logout or args.user_info or args.change_password or args.delete_account or args.store_api_key:
+        _handle_auth_commands(auth_manager, args)
+        sys.exit(0)
+    
     # If --list-gpus is specified, just show GPU options and exit
     if args.list_gpus:
         prompt_for_gpu()
@@ -3897,6 +4245,13 @@ if __name__ == "__main__":
         show_usage_examples()
         sys.exit(0)
     
+    # Check authentication (unless skipped for development)
+    if not args.skip_auth:
+        if not _check_authentication(auth_manager):
+            print("\n❌ Authentication required. Please login or register first.")
+            print("Use --login to login or --register to create an account.")
+            sys.exit(1)
+    
     # Check for dependencies
     print("⠏ Checking dependencies...")
     print("--- Dependency Check ---")
@@ -4145,89 +4500,3 @@ if __name__ == "__main__":
         # print("🧹 Cleaning up resources...")
         cleanup_modal_token()
         sys.exit(1)
-
-def preprocess_commands_with_llm(setup_commands, stored_credentials, api_key=None):
-    """
-    Use LLM to preprocess setup commands and inject available credentials.
-    
-    Args:
-        setup_commands: List of setup commands
-        stored_credentials: Dictionary of stored credentials
-        api_key: OpenAI API key for LLM calls
-        
-    Returns:
-        List of processed commands with credentials injected
-    """
-    if not setup_commands or not stored_credentials:
-        return setup_commands
-    
-    try:
-        # Create context for the LLM
-        credentials_info = "\n".join([f"- {key}: {value[:8]}..." for key, value in stored_credentials.items()])
-        
-        prompt = f"""
-You are a command preprocessing assistant. Your task is to modify setup commands to use available credentials and make them non-interactive.
-
-AVAILABLE CREDENTIALS:
-{credentials_info}
-
-ORIGINAL COMMANDS:
-{chr(10).join([f"{i+1}. {cmd}" for i, cmd in enumerate(setup_commands)])}
-
-INSTRUCTIONS:
-1. Replace any authentication commands with token-based versions using available credentials
-2. Make all commands non-interactive (add --yes, --no-input, -y flags where needed)
-3. Use environment variables or direct token injection where appropriate
-4. Skip commands that cannot be made non-interactive due to missing credentials
-5. Add any necessary environment variable exports
-
-Return the modified commands as a JSON array of strings. If a command should be skipped, prefix it with "# SKIPPED: ".
-
-Example transformations:
-- "huggingface-cli login" → "huggingface-cli login --token $HUGGINGFACE_TOKEN"
-- "npm install" → "npm install --yes"
-- "pip install package" → "pip install package --no-input"
-
-Return only the JSON array, no other text.
-"""
-        
-        if not api_key:
-            print("⚠️ No OpenAI API key available for command preprocessing")
-            return setup_commands
-        
-        # Call OpenAI API
-        import openai
-        client = openai.OpenAI(api_key=api_key)
-        
-        response = client.chat.completions.create(
-            model="gpt-3.5-turbo",
-            messages=[
-                {"role": "system", "content": "You are a command preprocessing assistant that modifies setup commands to use available credentials and make them non-interactive."},
-                {"role": "user", "content": prompt}
-            ],
-            temperature=0.1,
-            max_tokens=2000
-        )
-        
-        result = response.choices[0].message.content.strip()
-        
-        # Parse the JSON response
-        import json
-        try:
-            processed_commands = json.loads(result)
-            if isinstance(processed_commands, list):
-                print(f"🔧 LLM preprocessed {len(processed_commands)} commands")
-                for i, cmd in enumerate(processed_commands):
-                    if cmd != setup_commands[i]:
-                        print(f"  {i+1}. {setup_commands[i]} → {cmd}")
-                return processed_commands
-            else:
-                print("⚠️ LLM returned invalid format, using original commands")
-                return setup_commands
-        except json.JSONDecodeError:
-            print("⚠️ Failed to parse LLM response, using original commands")
-            return setup_commands
-            
-    except Exception as e:
-        print(f"⚠️ LLM preprocessing failed: {e}")
-        return setup_commands