gitarsenal-cli 1.5.3 → 1.5.5

package/python/test_modal_auth.py

@@ -1,90 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test Modal Authentication
-
-This script tests different approaches to authenticate with Modal.
-"""
-
-import os
-import sys
-import json
-from pathlib import Path
-import time
-
-# Try to get tokens from the proxy server
-try:
-    # First, try to import the fetch_modal_tokens module
-    from fetch_modal_tokens import get_tokens
-    TOKEN_ID, TOKEN_SECRET = get_tokens()
-    print(f"✅ Using tokens from proxy server or defaults")
-except ImportError:
-    # If the module is not available, use hardcoded tokens
-    print(f"⚠️ Using hardcoded tokens")
-
-# Set tokens directly in environment
-os.environ["MODAL_TOKEN_ID"] = TOKEN_ID
-os.environ["MODAL_TOKEN_SECRET"] = TOKEN_SECRET
-
-# Print environment variables
-print(f"Environment variables:")
-print(f"MODAL_TOKEN_ID = {os.environ.get('MODAL_TOKEN_ID')}")
-print(f"MODAL_TOKEN_SECRET = {os.environ.get('MODAL_TOKEN_SECRET')}")
-
-# Create token file
-modal_dir = Path.home() / ".modal"
-modal_dir.mkdir(exist_ok=True)
-token_file = modal_dir / "token.json"
-with open(token_file, 'w') as f:
-    # Use the correct format with token_id and token_secret
-    token_data = {
-        "token_id": TOKEN_ID,
-        "token_secret": TOKEN_SECRET
-    }
-    json.dump(token_data, f)
-print(f"Created token file at {token_file}")
-print(f"Token file contents: {json.dumps(token_data)}")
-
-# Create .modalconfig file
-modalconfig_file = Path.home() / ".modalconfig"
-with open(modalconfig_file, 'w') as f:
-    f.write(f"token_id = {TOKEN_ID}\n")
-    f.write(f"token_secret = {TOKEN_SECRET}\n")
-print(f"Created .modalconfig file at {modalconfig_file}")
-
-# Try to import Modal
-print("\nTrying to import Modal...")
-try:
-    import modal
-    print("✅ Successfully imported Modal")
-except Exception as e:
-    print(f"❌ Error importing Modal: {e}")
-
-# Try to create a simple Modal app
-print("\nTrying to create a Modal app...")
-try:
-    app = modal.App("test-auth")
-    print("✅ Successfully created Modal app")
-except Exception as e:
-    print(f"❌ Error creating Modal app: {e}")
-
-# Try to create a simple Modal function
-print("\nTrying to create a Modal function...")
-try:
-    @app.function()
-    def hello():
-        return "Hello, world!"
-    
-    print("✅ Successfully created Modal function")
-except Exception as e:
-    print(f"❌ Error creating Modal function: {e}")
-
-# Try to run the function
-print("\nTrying to run the Modal function...")
-try:
-    with app.run():
-        result = hello.remote()
-        print(f"✅ Successfully ran Modal function: {result}")
-except Exception as e:
-    print(f"❌ Error running Modal function: {e}")
-
-print("\nDone testing Modal authentication.") 

package/python/test_token_cleanup.py

@@ -1,256 +0,0 @@
-#!/usr/bin/env python3
-"""
-Test Modal Token Cleanup
-
-This script tests the Modal token cleanup functionality by:
-1. Setting up a Modal token
-2. Verifying the token exists in environment and files
-3. Cleaning up the token
-4. Verifying the token has been removed
-"""
-
-import os
-import sys
-import json
-from pathlib import Path
-import time
-
-# Add the parent directory to the path so we can import our modules
-parent_dir = Path(__file__).parent.absolute()
-sys.path.append(str(parent_dir))
-
-# Import our cleanup function
-from test_modalSandboxScript import cleanup_modal_token
-
-def setup_test_token():
-    """Set up a test Modal token in environment and files"""
-    print("🔧 Setting up test Modal token...")
-    
-    # Set test token in environment variables
-    test_token = "ak-testtoken12345"
-    os.environ["MODAL_TOKEN_ID"] = test_token
-    os.environ["MODAL_TOKEN"] = test_token
-    os.environ["MODAL_TOKEN_SECRET"] = "as-testsecret12345"
-    
-    # Create token files
-    modal_dir = Path.home() / ".modal"
-    modal_dir.mkdir(exist_ok=True)
-    
-    # Create token.json
-    token_file = modal_dir / "token.json"
-    with open(token_file, 'w') as f:
-        token_data = {
-            "token_id": test_token,
-            "token_secret": "as-testsecret12345"
-        }
-        json.dump(token_data, f)
-    
-    # Create token_alt.json
-    token_alt_file = modal_dir / "token_alt.json"
-    with open(token_alt_file, 'w') as f:
-        token_data_alt = {
-            "id": test_token,
-            "secret": "as-testsecret12345"
-        }
-        json.dump(token_data_alt, f)
-    
-    # Create .modalconfig file
-    modalconfig_file = Path.home() / ".modalconfig"
-    with open(modalconfig_file, 'w') as f:
-        f.write(f"token_id = {test_token}\n")
-        f.write(f"token_secret = as-testsecret12345\n")
-    
-    print("✅ Test Modal token set up successfully")
-    return test_token
-
-def verify_token_exists(test_token):
-    """Verify that the test token exists in environment and files"""
-    print("🔍 Verifying test token exists...")
-    
-    # Check environment variables
-    env_token_id = os.environ.get("MODAL_TOKEN_ID")
-    env_token = os.environ.get("MODAL_TOKEN")
-    env_token_secret = os.environ.get("MODAL_TOKEN_SECRET")
-    
-    if env_token_id != test_token:
-        print(f"❌ MODAL_TOKEN_ID mismatch: expected '{test_token}', got '{env_token_id}'")
-        return False
-    
-    if env_token != test_token:
-        print(f"❌ MODAL_TOKEN mismatch: expected '{test_token}', got '{env_token}'")
-        return False
-    
-    if not env_token_secret:
-        print("❌ MODAL_TOKEN_SECRET not set")
-        return False
-    
-    # Check token files
-    modal_dir = Path.home() / ".modal"
-    token_file = modal_dir / "token.json"
-    if not token_file.exists():
-        print(f"❌ Token file not found at {token_file}")
-        return False
-    
-    token_alt_file = modal_dir / "token_alt.json"
-    if not token_alt_file.exists():
-        print(f"❌ Alternative token file not found at {token_alt_file}")
-        return False
-    
-    modalconfig_file = Path.home() / ".modalconfig"
-    if not modalconfig_file.exists():
-        print(f"❌ .modalconfig file not found at {modalconfig_file}")
-        return False
-    
-    print("✅ Test token exists in environment and files")
-    return True
-
-def verify_token_cleaned_up():
-    """Verify that the test token has been cleaned up"""
-    print("🔍 Verifying token cleanup...")
-    
-    # Check that the original token is not in environment variables
-    env_token_id = os.environ.get("MODAL_TOKEN_ID")
-    env_token = os.environ.get("MODAL_TOKEN")
-    env_token_secret = os.environ.get("MODAL_TOKEN_SECRET")
-    
-    # Check that original tokens are removed or replaced with invalid tokens
-    if env_token_id and not ("invalid" in env_token_id or "placeholder" in env_token_id):
-        print(f"❌ Original MODAL_TOKEN_ID still exists: '{env_token_id}'")
-        return False
-    
-    if env_token and not ("invalid" in env_token or "placeholder" in env_token):
-        print(f"❌ Original MODAL_TOKEN still exists: '{env_token}'")
-        return False
-    
-    if env_token_secret and not ("invalid" in env_token_secret or "placeholder" in env_token_secret):
-        print(f"❌ Original MODAL_TOKEN_SECRET still exists: '{env_token_secret}'")
-        return False
-    
-    # Check token files
-    modal_dir = Path.home() / ".modal"
-    token_file = modal_dir / "token.json"
-    
-    # Check if token.json contains invalid values
-    if token_file.exists():
-        try:
-            import json
-            with open(token_file, 'r') as f:
-                token_data = json.load(f)
-                
-            if "token_id" in token_data:
-                if not ("invalid" in token_data["token_id"] or "placeholder" in token_data["token_id"]):
-                    print(f"❌ Token file contains original token_id: {token_data['token_id']}")
-                    return False
-                print(f"✅ Token file contains invalid token_id: {token_data['token_id']}")
-            else:
-                print("❌ Token file does not contain token_id")
-                return False
-                
-            if "token_secret" in token_data:
-                if not ("invalid" in token_data["token_secret"] or "placeholder" in token_data["token_secret"]):
-                    print(f"❌ Token file contains original token_secret")
-                    return False
-                print(f"✅ Token file contains invalid token_secret")
-            else:
-                print("❌ Token file does not contain token_secret")
-                return False
-        except Exception as e:
-            print(f"❌ Error reading token file: {e}")
-            return False
-    else:
-        print("❌ Token file does not exist")
-        return False
-    
-    # Check .modalconfig file
-    modalconfig_file = Path.home() / ".modalconfig"
-    if modalconfig_file.exists():
-        try:
-            with open(modalconfig_file, 'r') as f:
-                config_content = f.read()
-                
-            if not ("invalid" in config_content or "placeholder" in config_content):
-                print("❌ .modalconfig file does not contain invalid tokens")
-                return False
-                
-            print("✅ .modalconfig file contains invalid tokens")
-        except Exception as e:
-            print(f"❌ Error reading .modalconfig file: {e}")
-            return False
-    else:
-        print("❌ .modalconfig file does not exist")
-        return False
-    
-    # Check if Modal sessions directory exists
-    session_dir = modal_dir / "sessions"
-    if session_dir.exists():
-        print(f"❌ Modal sessions directory still exists at {session_dir}")
-        return False
-    
-    # Check for any session or auth files
-    if modal_dir.exists():
-        for file in os.listdir(modal_dir):
-            if "session" in file.lower() or "auth" in file.lower():
-                print(f"❌ Modal session/auth file still exists: {modal_dir / file}")
-                return False
-    
-    # Check if Modal CLI works with invalid tokens
-    try:
-        import subprocess
-        result = subprocess.run(
-            ["modal", "--help"],
-            capture_output=True,
-            text=True
-        )
-        if result.returncode == 0:
-            print("✅ Modal CLI works with invalid tokens")
-        else:
-            print("❌ Modal CLI does not work with invalid tokens")
-            print(f"Output: {result.stdout}")
-            print(f"Error: {result.stderr}")
-            return False
-            
-        # Check that operations requiring authentication fail
-        result = subprocess.run(
-            ["modal", "app", "list"],
-            capture_output=True,
-            text=True
-        )
-        if result.returncode != 0 or "unauthorized" in result.stderr.lower() or "error" in result.stderr.lower():
-            print("✅ Modal operations requiring authentication fail as expected")
-        else:
-            print("❌ Modal operations requiring authentication still work")
-            print(f"Output: {result.stdout}")
-            return False
-    except Exception as e:
-        print(f"⚠️ Error checking Modal CLI status: {e}")
-    
-    print("✅ Token has been cleaned up successfully")
-    return True
-
-def run_test():
-    """Run the token cleanup test"""
-    print("🧪 Running Modal token cleanup test...")
-    
-    # Set up test token
-    test_token = setup_test_token()
-    
-    # Verify token exists
-    if not verify_token_exists(test_token):
-        print("❌ Test failed: Token setup verification failed")
-        return False
-    
-    # Clean up token
-    print("🧹 Cleaning up token...")
-    cleanup_modal_token()
-    
-    # Verify token has been cleaned up
-    if not verify_token_cleaned_up():
-        print("❌ Test failed: Token cleanup verification failed")
-        return False
-    
-    print("✅ Test passed: Token cleanup works correctly")
-    return True
-
-if __name__ == "__main__":
-    success = run_test()
-    sys.exit(0 if success else 1) 

package/python/verify_env_vars.py

@@ -1,64 +0,0 @@
-#!/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()