gitarsenal-cli 1.4.2 → 1.4.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitarsenal-cli",
-  "version": "1.4.2",
+  "version": "1.4.3",
   "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 proxy server.
+This script fetches Modal tokens from the GitArsenal API.
 """
 
 import os
@@ -13,92 +13,107 @@ 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"
+# DEFAULT_TOKEN_ID = "ak-sLhYqCjkvixiYcb9LAuCHp"
+# DEFAULT_TOKEN_SECRET = "as-fPzD0Zm0dl6IFAEkhaH9pq"
 
-def fetch_tokens_from_proxy(proxy_url=None, api_key=None):
+def fetch_credentials_from_api(api_url=None, api_key=None, credential_id=None):
     """
-    Fetch Modal tokens from the proxy server.
+    Fetch credentials from the GitArsenal API.
     
     Args:
-        proxy_url: URL of the proxy server
+        api_url: Base URL of the API (default: gitarsenal.dev)
         api_key: API key for authentication
+        credential_id: Optional ID of specific credentials to fetch
         
     Returns:
-        tuple: (token_id, token_secret) if successful, (None, None) otherwise
+        dict: Credentials containing modalTokenId and modalTokenSecret if successful, None otherwise
     """
     # Use environment variables if not provided
-    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_url:
+        api_url = os.environ.get("GITARSENAL_API_URL", "https://gitarsenal.dev")
+        if api_url:
+            print(f"📋 Using API URL from environment")
     
     if not api_key:
-        api_key = os.environ.get("MODAL_PROXY_API_KEY")
+        api_key = os.environ.get("GITARSENAL_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 MODAL_PROXY_API_KEY environment variable or use --proxy-api-key argument")
-        return None, None
+        print("💡 Set GITARSENAL_API_KEY environment variable or use --api-key argument")
+        return None
     
     # Ensure the URL ends with a slash
-    if not proxy_url.endswith("/"):
-        proxy_url += "/"
+    if not api_url.endswith("/"):
+        api_url += "/"
+    
+    # Add the endpoint for fetching credentials
+    credentials_url = f"{api_url}api/credentials"
     
-    # Add the endpoint for fetching tokens
-    token_url = f"{proxy_url}api/modal-tokens"
+    # Add credential ID if provided
+    if credential_id:
+        credentials_url += f"?id={credential_id}"
     
     try:
         # Make the request
-        print(f"🔄 Fetching tokens from proxy server")
+        print(f"🔄 Fetching credentials from GitArsenal API")
         response = requests.get(
-            token_url,
+            credentials_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("token_id")
-            token_secret = data.get("token_secret")
+            token_id = data.get("modalTokenId")
+            token_secret = data.get("modalTokenSecret")
+            openai_api_key = data.get("openaiApiKey")
             
             if token_id and token_secret:
-                print("✅ Successfully fetched tokens from proxy server")
-                return token_id, token_secret
+                print("✅ Successfully fetched credentials from GitArsenal API")
+                return {
+                    "token_id": token_id,
+                    "token_secret": token_secret,
+                    "openai_api_key": openai_api_key
+                }
             else:
-                print("❌ Tokens not found in response")
-                return None, None
+                print("❌ Modal tokens not found in response")
+                return None
         else:
-            print(f"❌ Failed to fetch tokens: {response.status_code} - {response.text}")
-            return None, None
+            print(f"❌ Failed to fetch credentials: {response.status_code} - {response.text}")
+            return None
     except Exception as e:
-        print(f"❌ Error fetching tokens: {e}")
-        return None, None
+        print(f"❌ Error fetching credentials: {e}")
+        return None
 
 def get_tokens():
     """
-    Get Modal tokens, trying to fetch from the proxy server first.
+    Get Modal tokens, trying to fetch from the GitArsenal API first.
     Also sets the tokens in environment variables.
     
     Returns:
         tuple: (token_id, token_secret)
     """
-    # Try to fetch from the proxy server
-    token_id, token_secret = fetch_tokens_from_proxy()
+    # Try to fetch from the API
+    credentials = fetch_credentials_from_api()
     
-    # If we couldn't fetch from the server, use the default tokens
-    if not token_id or not token_secret:
+    # 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")
     
     # Set the tokens in environment variables
     os.environ["MODAL_TOKEN_ID"] = token_id
@@ -111,33 +126,23 @@ if __name__ == "__main__":
     # Parse command-line arguments if run directly
     import argparse
     
-    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')
+    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')
     args = parser.parse_args()
     
-    # 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")
+    # 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")
     
-    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")
+    if args.api_key:
+        os.environ["GITARSENAL_API_KEY"] = args.api_key
+        print(f"✅ Set GITARSENAL_API_KEY from command line")
     
     # Get tokens
     token_id, token_secret = get_tokens()
-    # print(f"Token ID: [HIDDEN]")
-    # print(f"Token Secret: [HIDDEN]")
-    
-    # # 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"

package/python/test_modal_auth.py

@@ -19,8 +19,8 @@ try:
     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
+    # TOKEN_ID = "ak-sLhYqCjkvixiYcb9LAuCHp"
+    # TOKEN_SECRET = "as-fPzD0Zm0dl6IFAEkhaH9pq"  # Real token secret from fr8mafia profile
     print(f"⚠️ Using hardcoded tokens")
 
 # Set tokens directly in environment

package/python/MODAL_TOKEN_README.md

@@ -1,77 +0,0 @@
-# Modal Token Solution
-
-This directory contains several scripts to solve the Modal token authentication issue. The problem occurs when Modal cannot find or validate the authentication token, resulting in errors like "Token missing" or "Could not authenticate client".
-
-## Overview of the Solution
-
-We've implemented a comprehensive solution that uses multiple approaches to ensure Modal can authenticate properly:
-
-1. **fetch_modal_tokens.py**: Fetches tokens from the proxy server.
-2. **modal_token_solution.py**: The main comprehensive solution that combines all approaches.
-3. **modal_auth_patch.py**: A direct patch for Modal's authentication system.
-4. **fix_modal_token.py**: A basic token setup script.
-5. **fix_modal_token_advanced.py**: An advanced version with more approaches.
-
-## How It Works
-
-Our solution uses multiple approaches to ensure Modal authentication works:
-
-1. **Token Fetching**: Tries to fetch tokens from the proxy server.
-2. **Environment Variables**: Sets `MODAL_TOKEN_ID` and `MODAL_TOKEN_SECRET` environment variables.
-3. **Token Files**: Creates token files in various formats and locations that Modal might look for.
-4. **Modal CLI**: Attempts to use the Modal CLI to set the token with the correct profile.
-5. **Direct Patching**: Directly patches Modal's authentication system to always return our tokens.
-6. **Monkey Patching**: Monkey-patches Modal's import system to inject our tokens.
-7. **Authentication Testing**: Tests that the authentication works by creating a simple Modal app.
-
-## Usage
-
-The scripts are used in this order of preference:
-
-1. First, try `modal_token_solution.py` (most comprehensive)
-2. If that fails, fall back to `modal_auth_patch.py`
-3. If that fails, fall back to `fix_modal_token.py`
-
-In most cases, you should simply import `modal_token_solution` before importing Modal:
-
-```python
-import modal_token_solution
-import modal
-
-# Now Modal will use our tokens
-```
-
-## Proxy Server Integration
-
-The solution now integrates with the proxy server to fetch tokens:
-
-1. **fetch_modal_tokens.py**: This script fetches tokens from the proxy server using the `MODAL_PROXY_URL` and `MODAL_PROXY_API_KEY` environment variables.
-2. If the proxy server is not available, it falls back to hardcoded tokens.
-3. All other scripts try to use the fetch_modal_tokens module first before falling back to hardcoded tokens.
-
-## Troubleshooting
-
-If you still encounter token issues:
-
-1. Check that the tokens are correct (token ID: `ak-sLhYqCjkvixiYcb9LAuCHp`, token secret: `as-fPzD0Zm0dl6IFAEkhaH9pq`).
-2. Verify that the token files are created in the correct locations:
-   - `~/.modal/token.json`
-   - `~/.modalconfig`
-3. Check if the proxy server is accessible and returning valid tokens.
-4. Try running the scripts manually to see detailed output.
-
-## Implementation Details
-
-- **Token Values**: We try to fetch tokens from the proxy server, with fallback to hardcoded values.
-- **File Locations**: Token files are created in the user's home directory under `~/.modal/`.
-- **Patching**: We use Python's dynamic nature to patch Modal's authentication system at runtime.
-- **Profile**: We use the `fr8mafia` profile when setting tokens via the CLI.
-
-## Files
-
-- **fetch_modal_tokens.py**: Fetches tokens from the proxy server.
-- **modal_token_solution.py**: Comprehensive solution combining all approaches.
-- **modal_auth_patch.py**: Direct patch for Modal's authentication system.
-- **fix_modal_token.py**: Basic token setup script.
-- **fix_modal_token_advanced.py**: Advanced version with more approaches.
-- **test_modal_auth.py**: Test script for Modal authentication. 

package/python/MODAL_TOKEN_SETUP.md

@@ -1,82 +0,0 @@
-# Modal Token Setup Solution
-
-This document explains how the Modal token setup solution works in GitArsenal CLI.
-
-## Problem
-
-The GitArsenal CLI was failing with errors like:
-
-```
-🔍 MODAL_TOKEN_ID not found in environment.
-❌ No Modal token found in environment variables
-❌ Modal token file not found
-❌ Could not find Modal token in any location
-```
-
-This happened because the Modal token was not being properly set in the environment variables.
-
-## Solution
-
-We implemented a comprehensive solution to automatically find and set up the Modal token from various sources:
-
-1. Created a `setup_modal_token.py` module that:
-   - Checks for the token in environment variables (MODAL_TOKEN_ID and MODAL_TOKEN)
-   - Checks for the token in GitArsenal credentials file (~/.gitarsenal/credentials.json)
-   - Checks for the token in Modal token file (~/.modal/token.json)
-   - Sets the token in both MODAL_TOKEN_ID and MODAL_TOKEN environment variables
-
-2. Modified key files to use this module:
-   - `gitarsenal.py` - Main CLI entry point
-   - `modal_proxy_service.py` - Modal proxy service
-   - `test_modalSandboxScript.py` - Modal sandbox script
-
-3. Created a wrapper script `run_with_modal_token.py` that:
-   - Sets up the Modal token using the setup_modal_token module
-   - Runs a specified command with the token properly set in the environment
-
-## Usage
-
-### Running Commands with Modal Token
-
-Use the wrapper script to run any command that requires Modal authentication:
-
-```bash
-python run_with_modal_token.py <command> [args...]
-```
-
-Example:
-
-```bash
-python run_with_modal_token.py python modal_proxy_service.py
-```
-
-### Setting Up Modal Token
-
-If you need to set up the Modal token manually:
-
-```bash
-python setup_modal_token.py
-```
-
-This will prompt you for the token if it's not found in any of the sources.
-
-### Adding Modal Token to GitArsenal Credentials
-
-You can also add the Modal token to GitArsenal credentials:
-
-```bash
-./gitarsenal.py credentials set modal_token
-```
-
-## How It Works
-
-1. The `setup_modal_token.py` module checks multiple sources for the Modal token:
-   - Environment variables (MODAL_TOKEN_ID and MODAL_TOKEN)
-   - GitArsenal credentials file (~/.gitarsenal/credentials.json)
-   - Modal token file (~/.modal/token.json)
-
-2. When it finds a token, it sets both MODAL_TOKEN_ID and MODAL_TOKEN environment variables.
-
-3. The modified files import and use this module to ensure the token is set before any Modal operations.
-
-4. The wrapper script makes it easy to run any command with the token properly set up.