gitarsenal-cli 1.8.3 → 1.8.5

package/activate_venv.sh

@@ -0,0 +1,4 @@
+#!/bin/bash
+cd "$(dirname "$0")"
+source "/Users/rohansharma/RepoStarter/gitarsenal-cli/venv/bin/activate"
+exec "$@"

package/package.json

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

package/python/auth_manager.py

@@ -0,0 +1,485 @@
+#!/usr/bin/env python3
+"""
+GitArsenal Authentication Manager
+
+Handles user registration, login, and session management for the CLI.
+"""
+
+import os
+import json
+import hashlib
+import secrets
+import getpass
+import time
+import requests
+from pathlib import Path
+from datetime import datetime, timedelta
+from typing import Optional, Dict, Any
+
+class AuthManager:
+    """
+    Manages user authentication for GitArsenal CLI.
+    Handles registration, login, session management, and API key storage.
+    """
+    
+    def __init__(self, config_dir=None):
+        """Initialize the authentication manager"""
+        if config_dir:
+            self.config_dir = Path(config_dir)
+        else:
+            self.config_dir = Path.home() / ".gitarsenal"
+            
+        self.auth_file = self.config_dir / "auth.json"
+        self.session_file = self.config_dir / "session.json"
+        self.ensure_config_dir()
+        
+        # API endpoints for authentication (can be configured)
+        self.auth_api_url = os.getenv("GITARSENAL_AUTH_API", "https://api.gitarsenal.com/auth")
+        
+    def ensure_config_dir(self):
+        """Ensure the configuration directory exists with proper permissions"""
+        if not self.config_dir.exists():
+            self.config_dir.mkdir(parents=True)
+            # Set restrictive permissions on Unix-like systems
+            if os.name == 'posix':
+                self.config_dir.chmod(0o700)  # Only owner can read/write/execute
+    
+    def hash_password(self, password: str) -> str:
+        """Hash a password using SHA-256 with salt"""
+        salt = secrets.token_hex(16)
+        hash_obj = hashlib.sha256()
+        hash_obj.update((password + salt).encode('utf-8'))
+        return f"{salt}${hash_obj.hexdigest()}"
+    
+    def verify_password(self, password: str, hashed_password: str) -> bool:
+        """Verify a password against its hash"""
+        try:
+            salt, hash_value = hashed_password.split('$', 1)
+            hash_obj = hashlib.sha256()
+            hash_obj.update((password + salt).encode('utf-8'))
+            return hash_obj.hexdigest() == hash_value
+        except ValueError:
+            return False
+    
+    def generate_session_token(self) -> str:
+        """Generate a secure session token"""
+        return secrets.token_urlsafe(32)
+    
+    def load_auth_data(self) -> Dict[str, Any]:
+        """Load authentication data from file"""
+        if not self.auth_file.exists():
+            return {}
+            
+        try:
+            with open(self.auth_file, 'r') as f:
+                return json.load(f)
+        except (json.JSONDecodeError, IOError):
+            print("⚠️ Error reading auth file. Starting fresh.")
+            return {}
+    
+    def save_auth_data(self, data: Dict[str, Any]) -> bool:
+        """Save authentication data to file"""
+        try:
+            with open(self.auth_file, 'w') as f:
+                json.dump(data, f, indent=2)
+                
+            # Set restrictive permissions on Unix-like systems
+            if os.name == 'posix':
+                self.auth_file.chmod(0o600)  # Only owner can read/write
+                
+            return True
+        except IOError as e:
+            print(f"❌ Error saving auth data: {e}")
+            return False
+    
+    def load_session(self) -> Dict[str, Any]:
+        """Load session data from file"""
+        if not self.session_file.exists():
+            return {}
+            
+        try:
+            with open(self.session_file, 'r') as f:
+                session_data = json.load(f)
+                
+            # Check if session is still valid
+            if session_data.get('expires_at'):
+                expires_at = datetime.fromisoformat(session_data['expires_at'])
+                if datetime.now() > expires_at:
+                    print("⚠️ Session expired. Please login again.")
+                    return {}
+                    
+            return session_data
+        except (json.JSONDecodeError, IOError):
+            return {}
+    
+    def save_session(self, session_data: Dict[str, Any]) -> bool:
+        """Save session data to file"""
+        try:
+            with open(self.session_file, 'w') as f:
+                json.dump(session_data, f, indent=2)
+                
+            # Set restrictive permissions on Unix-like systems
+            if os.name == 'posix':
+                self.session_file.chmod(0o600)  # Only owner can read/write
+                
+            return True
+        except IOError as e:
+            print(f"❌ Error saving session: {e}")
+            return False
+    
+    def clear_session(self):
+        """Clear the current session"""
+        if self.session_file.exists():
+            self.session_file.unlink()
+    
+    def is_authenticated(self) -> bool:
+        """Check if user is currently authenticated"""
+        session = self.load_session()
+        return bool(session.get('user_id') and session.get('token'))
+    
+    def get_current_user(self) -> Optional[Dict[str, Any]]:
+        """Get current user information"""
+        session = self.load_session()
+        if not session.get('user_id'):
+            return None
+            
+        auth_data = self.load_auth_data()
+        return auth_data.get('users', {}).get(session['user_id'])
+    
+    def register_user(self, username: str, email: str, password: str) -> bool:
+        """Register a new user"""
+        print("\n" + "="*60)
+        print("🔐 USER REGISTRATION")
+        print("="*60)
+        
+        # Validate input
+        if not username or len(username) < 3:
+            print("❌ Username must be at least 3 characters long.")
+            return False
+            
+        if not email or '@' not in email:
+            print("❌ Please provide a valid email address.")
+            return False
+            
+        if not password or len(password) < 8:
+            print("❌ Password must be at least 8 characters long.")
+            return False
+        
+        auth_data = self.load_auth_data()
+        users = auth_data.get('users', {})
+        
+        # Check if username already exists
+        for user_id, user_data in users.items():
+            if user_data.get('username') == username:
+                print("❌ Username already exists. Please choose a different username.")
+                return False
+            if user_data.get('email') == email:
+                print("❌ Email already registered. Please use a different email.")
+                return False
+        
+        # Create new user
+        user_id = secrets.token_hex(16)
+        hashed_password = self.hash_password(password)
+        
+        new_user = {
+            'user_id': user_id,
+            'username': username,
+            'email': email,
+            'password_hash': hashed_password,
+            'created_at': datetime.now().isoformat(),
+            'api_keys': {},
+            'settings': {
+                'default_gpu': 'A10G',
+                'timeout_minutes': 60,
+                'interactive_mode': False
+            }
+        }
+        
+        users[user_id] = new_user
+        auth_data['users'] = users
+        
+        if self.save_auth_data(auth_data):
+            print("✅ Registration successful!")
+            print(f"Username: {username}")
+            print(f"Email: {email}")
+            print("\nYou can now login with your credentials.")
+            return True
+        else:
+            print("❌ Failed to save registration data.")
+            return False
+    
+    def login_user(self, username: str, password: str) -> bool:
+        """Login a user"""
+        print("\n" + "="*60)
+        print("🔐 USER LOGIN")
+        print("="*60)
+        
+        auth_data = self.load_auth_data()
+        users = auth_data.get('users', {})
+        
+        # Find user by username
+        user_id = None
+        user_data = None
+        
+        for uid, user in users.items():
+            if user.get('username') == username:
+                user_id = uid
+                user_data = user
+                break
+        
+        if not user_data:
+            print("❌ Username not found. Please register first.")
+            return False
+        
+        # Verify password
+        if not self.verify_password(password, user_data['password_hash']):
+            print("❌ Invalid password.")
+            return False
+        
+        # Create session
+        session_token = self.generate_session_token()
+        session_data = {
+            'user_id': user_id,
+            'token': session_token,
+            'username': username,
+            'created_at': datetime.now().isoformat(),
+            'expires_at': (datetime.now() + timedelta(days=30)).isoformat()
+        }
+        
+        if self.save_session(session_data):
+            print("✅ Login successful!")
+            print(f"Welcome back, {username}!")
+            return True
+        else:
+            print("❌ Failed to create session.")
+            return False
+    
+    def logout_user(self):
+        """Logout the current user"""
+        self.clear_session()
+        print("✅ Logged out successfully.")
+    
+    def change_password(self, current_password: str, new_password: str) -> bool:
+        """Change user password"""
+        user = self.get_current_user()
+        if not user:
+            print("❌ Not logged in. Please login first.")
+            return False
+        
+        # Verify current password
+        if not self.verify_password(current_password, user['password_hash']):
+            print("❌ Current password is incorrect.")
+            return False
+        
+        # Validate new password
+        if not new_password or len(new_password) < 8:
+            print("❌ New password must be at least 8 characters long.")
+            return False
+        
+        # Update password
+        auth_data = self.load_auth_data()
+        user_id = user['user_id']
+        auth_data['users'][user_id]['password_hash'] = self.hash_password(new_password)
+        
+        if self.save_auth_data(auth_data):
+            print("✅ Password changed successfully!")
+            return True
+        else:
+            print("❌ Failed to update password.")
+            return False
+    
+    def store_api_key(self, service: str, api_key: str) -> bool:
+        """Store an API key for the current user"""
+        user = self.get_current_user()
+        if not user:
+            print("❌ Not logged in. Please login first.")
+            return False
+        
+        auth_data = self.load_auth_data()
+        user_id = user['user_id']
+        
+        if 'api_keys' not in auth_data['users'][user_id]:
+            auth_data['users'][user_id]['api_keys'] = {}
+        
+        auth_data['users'][user_id]['api_keys'][service] = api_key
+        
+        if self.save_auth_data(auth_data):
+            print(f"✅ {service} API key stored successfully!")
+            return True
+        else:
+            print(f"❌ Failed to store {service} API key.")
+            return False
+    
+    def get_api_key(self, service: str) -> Optional[str]:
+        """Get an API key for the current user"""
+        user = self.get_current_user()
+        if not user:
+            return None
+        
+        return user.get('api_keys', {}).get(service)
+    
+    def update_user_settings(self, settings: Dict[str, Any]) -> bool:
+        """Update user settings"""
+        user = self.get_current_user()
+        if not user:
+            print("❌ Not logged in. Please login first.")
+            return False
+        
+        auth_data = self.load_auth_data()
+        user_id = user['user_id']
+        
+        if 'settings' not in auth_data['users'][user_id]:
+            auth_data['users'][user_id]['settings'] = {}
+        
+        auth_data['users'][user_id]['settings'].update(settings)
+        
+        if self.save_auth_data(auth_data):
+            print("✅ Settings updated successfully!")
+            return True
+        else:
+            print("❌ Failed to update settings.")
+            return False
+    
+    def get_user_settings(self) -> Dict[str, Any]:
+        """Get current user settings"""
+        user = self.get_current_user()
+        if not user:
+            return {}
+        
+        return user.get('settings', {})
+    
+    def delete_account(self, password: str) -> bool:
+        """Delete user account"""
+        user = self.get_current_user()
+        if not user:
+            print("❌ Not logged in. Please login first.")
+            return False
+        
+        # Verify password
+        if not self.verify_password(password, user['password_hash']):
+            print("❌ Password is incorrect.")
+            return False
+        
+        # Confirm deletion
+        print("\n⚠️ WARNING: This action cannot be undone!")
+        print("All your data, including API keys and settings, will be permanently deleted.")
+        confirm = input("Type 'DELETE' to confirm: ").strip()
+        
+        if confirm != 'DELETE':
+            print("❌ Account deletion cancelled.")
+            return False
+        
+        # Delete user data
+        auth_data = self.load_auth_data()
+        user_id = user['user_id']
+        
+        if user_id in auth_data.get('users', {}):
+            del auth_data['users'][user_id]
+            
+            if self.save_auth_data(auth_data):
+                self.clear_session()
+                print("✅ Account deleted successfully.")
+                return True
+            else:
+                print("❌ Failed to delete account.")
+                return False
+        else:
+            print("❌ User data not found.")
+            return False
+    
+    def show_user_info(self):
+        """Display current user information"""
+        user = self.get_current_user()
+        if not user:
+            print("❌ Not logged in. Please login first.")
+            return
+        
+        print("\n" + "="*60)
+        print("👤 USER INFORMATION")
+        print("="*60)
+        print(f"Username: {user['username']}")
+        print(f"Email: {user['email']}")
+        print(f"Member since: {user['created_at'][:10]}")
+        
+        # Show API keys (masked)
+        api_keys = user.get('api_keys', {})
+        if api_keys:
+            print("\n🔑 API Keys:")
+            for service, key in api_keys.items():
+                masked_key = key[:8] + "..." + key[-4:] if len(key) > 12 else "***"
+                print(f"  {service}: {masked_key}")
+        else:
+            print("\n🔑 API Keys: None configured")
+        
+        # Show settings
+        settings = user.get('settings', {})
+        if settings:
+            print("\n⚙️ Settings:")
+            for key, value in settings.items():
+                print(f"  {key}: {value}")
+        
+        print("="*60)
+    
+    def interactive_auth_flow(self) -> bool:
+        """Interactive authentication flow"""
+        if self.is_authenticated():
+            user = self.get_current_user()
+            print(f"✅ Already logged in as: {user['username']}")
+            return True
+        
+        print("\n" + "="*60)
+        print("🔐 GITARSENAL AUTHENTICATION")
+        print("="*60)
+        print("Welcome to GitArsenal CLI!")
+        print("You need to create an account or login to continue.")
+        print("="*60)
+        
+        while True:
+            print("\nOptions:")
+            print("1. Login")
+            print("2. Register")
+            print("3. Exit")
+            
+            choice = input("\nSelect an option (1-3): ").strip()
+            
+            if choice == "1":
+                return self._login_flow()
+            elif choice == "2":
+                return self._register_flow()
+            elif choice == "3":
+                print("👋 Goodbye!")
+                return False
+            else:
+                print("❌ Invalid option. Please try again.")
+    
+    def _login_flow(self) -> bool:
+        """Interactive login flow"""
+        print("\n--- LOGIN ---")
+        username = input("Username: ").strip()
+        password = getpass.getpass("Password: ").strip()
+        
+        if self.login_user(username, password):
+            return True
+        else:
+            retry = input("\nTry again? (y/n): ").strip().lower()
+            return retry == 'y' and self._login_flow()
+    
+    def _register_flow(self) -> bool:
+        """Interactive registration flow"""
+        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.")
+            retry = input("\nTry again? (y/n): ").strip().lower()
+            return retry == 'y' and self._register_flow()
+        
+        if self.register_user(username, email, password):
+            # Auto-login after registration
+            return self.login_user(username, password)
+        else:
+            retry = input("\nTry again? (y/n): ").strip().lower()
+            return retry == 'y' and self._register_flow() 

package/python/debug_delete.py

@@ -0,0 +1,167 @@
+#!/usr/bin/env python3
+"""
+Debug script for GitArsenal Keys delete functionality
+"""
+
+import sys
+import os
+from pathlib import Path
+
+# Add the current directory to the path
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+from credentials_manager import CredentialsManager
+from gitarsenal_keys import handle_delete
+
+def test_delete_functionality():
+    """Test the delete functionality step by step"""
+    print("🔍 Debugging GitArsenal Keys Delete Functionality")
+    print("=" * 60)
+    
+    # Initialize credentials manager
+    credentials_manager = CredentialsManager()
+    
+    print(f"📁 Credentials file: {credentials_manager.credentials_file}")
+    print(f"📁 Config directory: {credentials_manager.config_dir}")
+    
+    # Check if credentials file exists
+    if credentials_manager.credentials_file.exists():
+        print("✅ Credentials file exists")
+    else:
+        print("❌ Credentials file does not exist")
+        return
+    
+    # Load current credentials
+    credentials = credentials_manager.load_credentials()
+    print(f"📋 Current credentials: {list(credentials.keys())}")
+    
+    # Test different service mappings
+    test_services = ['openai', 'wandb', 'huggingface', 'gitarsenal-openai', 'claude']
+    
+    for service in test_services:
+        print(f"\n🔍 Testing service: {service}")
+        
+        # Generate credential key from service name
+        credential_key = f"{service.replace('-', '_')}_api_key"
+        
+        # Special mappings for backward compatibility
+        special_mappings = {
+            'openai': 'openai_api_key',
+            'wandb': 'wandb_api_key',
+            'huggingface': 'huggingface_token',
+            'gitarsenal-openai': 'gitarsenal_openai_api_key'
+        }
+        
+        # Use special mapping if it exists, otherwise use generated key
+        credential_key = special_mappings.get(service, credential_key)
+        
+        print(f"   Service: {service}")
+        print(f"   Generated key: {service.replace('-', '_')}_api_key")
+        print(f"   Final key: {credential_key}")
+        print(f"   Exists in credentials: {credential_key in credentials}")
+        
+        if credential_key in credentials:
+            print(f"   Current value: {credentials[credential_key][:8]}...")
+    
+    # Test the clear_credential method directly
+    print(f"\n🧪 Testing clear_credential method directly")
+    
+    # Try to delete a key that exists
+    existing_keys = list(credentials.keys())
+    if existing_keys:
+        test_key = existing_keys[0]
+        print(f"   Testing deletion of: {test_key}")
+        
+        # Check if key exists before deletion
+        before_delete = test_key in credentials
+        print(f"   Key exists before deletion: {before_delete}")
+        
+        # Delete the key
+        success = credentials_manager.clear_credential(test_key)
+        print(f"   Deletion success: {success}")
+        
+        # Check if key exists after deletion
+        credentials_after = credentials_manager.load_credentials()
+        after_delete = test_key in credentials_after
+        print(f"   Key exists after deletion: {after_delete}")
+        
+        # Restore the key for testing
+        if not after_delete and before_delete:
+            credentials_after[test_key] = credentials[test_key]
+            credentials_manager.save_credentials(credentials_after)
+            print(f"   ✅ Key restored for further testing")
+    
+    # Test with a non-existent key
+    print(f"\n🧪 Testing deletion of non-existent key")
+    fake_key = "fake_api_key_12345"
+    success = credentials_manager.clear_credential(fake_key)
+    print(f"   Deletion of non-existent key success: {success}")
+    
+    print(f"\n✅ Debug test completed!")
+
+def test_delete_command():
+    """Test the delete command with mock arguments"""
+    print(f"\n🔧 Testing delete command with mock arguments")
+    print("=" * 60)
+    
+    from gitarsenal_keys import handle_delete
+    import argparse
+    
+    # Create mock arguments
+    class MockArgs:
+        def __init__(self, service):
+            self.service = service
+    
+    # Test with different services
+    test_services = ['openai', 'wandb', 'huggingface']
+    
+    for service in test_services:
+        print(f"\n🔍 Testing delete command for: {service}")
+        
+        try:
+            args = MockArgs(service)
+            handle_delete(None, args)  # This will fail because we need a real credentials manager
+        except Exception as e:
+            print(f"   Error: {e}")
+    
+    print(f"\n✅ Delete command test completed!")
+
+def show_usage_examples():
+    """Show how to use the delete command"""
+    print(f"\n📋 Usage Examples")
+    print("=" * 60)
+    
+    print("To delete an API key:")
+    print("  python gitarsenal_keys.py delete --service openai")
+    print("  python gitarsenal_keys.py delete --service wandb")
+    print("  python gitarsenal_keys.py delete --service huggingface")
+    print("  python gitarsenal_keys.py delete --service gitarsenal-openai")
+    
+    print("\nTo list all stored keys:")
+    print("  python gitarsenal_keys.py list")
+    
+    print("\nTo view a specific key (masked):")
+    print("  python gitarsenal_keys.py view --service openai")
+    
+    print("\nTo add a new key:")
+    print("  python gitarsenal_keys.py add --service openai --key sk-...")
+    print("  python gitarsenal_keys.py add --service openai  # Interactive mode")
+
+if __name__ == "__main__":
+    print("GitArsenal Keys Delete Debug Tool")
+    print("=" * 60)
+    
+    try:
+        test_delete_functionality()
+        test_delete_command()
+        show_usage_examples()
+        
+        print(f"\n🎉 Debug completed!")
+        print(f"\nTo test the actual delete command:")
+        print(f"  python gitarsenal_keys.py delete --service openai")
+        
+    except Exception as e:
+        print(f"\n❌ Debug failed with error: {e}")
+        import traceback
+        traceback.print_exc()
+        sys.exit(1)