gitarsenal-cli 1.5.4 → 1.5.5

package/package.json

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

package/python/test_modalSandboxScript.py

@@ -343,10 +343,6 @@ def call_openai_for_debug(command, error_output, api_key=None, current_dir=None,
     print(f"🔍 DEBUG: Current directory: {current_dir}")
     print(f"🔍 DEBUG: Sandbox available: {sandbox is not None}")
     print(f"🔍 DEBUG: API key provided: {'Yes' if api_key else 'No'}")
-    if api_key:
-        print(f"🔍 DEBUG: API key value: {api_key}")
-    else:
-        print(f"🔍 DEBUG: API key from environment: {os.environ.get('OPENAI_API_KEY')}")
     
     # Define _to_str function locally to avoid NameError
     def _to_str(maybe_bytes):
@@ -692,9 +688,9 @@ Do not provide any explanations, just the exact command to run.
     def try_api_call(model_name, retries=2, backoff_factor=1.5):
         print(f"🔍 DEBUG: Attempting API call with model: {model_name}")
         print(f"🔍 DEBUG: API key available: {'Yes' if api_key else 'No'}")
-        if api_key:
-            print(f"🔍 DEBUG: API key length: {len(api_key)}")
-            print(f"🔍 DEBUG: API key starts with: {api_key[:10]}...")
+        # if api_key:
+        #     print(f"🔍 DEBUG: API key length: {len(api_key)}")
+        #     print(f"🔍 DEBUG: API key starts with: {api_key[:10]}...")
         
         payload = {
             "model": model_name,

package/python/MODAL_PROXY_README.md

@@ -1,145 +0,0 @@
-# Modal Proxy Service for GitArsenal CLI
-
-This document explains how to set up and use the Modal proxy service with GitArsenal CLI.
-
-## What is the Modal Proxy Service?
-
-The Modal proxy service allows users to access Modal services (like GPU-accelerated containers) without exposing the owner's Modal token. The service runs on a server and provides API endpoints for creating sandboxes and SSH containers, using API key authentication.
-
-## Server-Side Setup
-
-1. **Install Requirements**:
-   ```bash
-   pip install flask flask-cors modal python-dotenv
-   ```
-
-2. **Set Environment Variables**:
-   Create a `.env` file in the same directory as `modal_proxy_service.py`:
-   ```
-   MODAL_TOKEN=your_modal_token_here
-   ADMIN_KEY=your_admin_key_here
-   API_KEYS=optional_comma_separated_list_of_api_keys
-   ```
-
-3. **Start the Service**:
-   ```bash
-   python modal_proxy_service.py
-   ```
-   
-   The service will start on port 5001 by default.
-
-4. **Create an API Key** (if not pre-configured in `.env`):
-   ```bash
-   curl -X POST http://localhost:5001/api/create-api-key \
-        -H "X-Admin-Key: your_admin_key_here"
-   ```
-   
-   This will return a JSON response with a new API key:
-   ```json
-   {"api_key": "generated_api_key_here"}
-   ```
-
-5. **Optional: Use ngrok to expose the service publicly**:
-   ```bash
-   ngrok http 5001
-   ```
-   
-   This will provide you with a public URL that you can share with users.
-   
-   Current ngrok URL: `https://932ffd63ad3d.ngrok-free.app`
-
-## Client-Side Setup
-
-1. **Configure the proxy client**:
-   ```bash
-   ./gitarsenal.py proxy configure
-   ```
-   
-   You'll be prompted to enter:
-   - The proxy URL (the default is now set to `https://932ffd63ad3d.ngrok-free.app`)
-   - Your API key
-
-2. **Check proxy service status**:
-   ```bash
-   ./gitarsenal.py proxy status
-   ```
-
-## Using the Proxy Service
-
-### Create an SSH Container
-
-```bash
-# Using the proxy command
-./gitarsenal.py proxy ssh --gpu A10G --repo-url https://github.com/username/repo.git --wait
-
-# Or using the standard ssh command with --use-proxy flag
-./gitarsenal.py ssh --use-proxy --gpu A10G --repo-url https://github.com/username/repo.git
-```
-
-### Create a Sandbox
-
-```bash
-# Using the proxy command
-./gitarsenal.py proxy sandbox --gpu A10G --repo-url https://github.com/username/repo.git --wait
-
-# Or using the standard sandbox command with --use-proxy flag
-./gitarsenal.py sandbox --use-proxy --gpu A10G --repo-url https://github.com/username/repo.git
-```
-
-## Troubleshooting
-
-### "Token missing" Error
-
-If you see a "Token missing" error when creating containers through the proxy service:
-
-1. **Check that the MODAL_TOKEN is set on the server**:
-   - Verify the `.env` file has a valid MODAL_TOKEN
-   - Ensure the token is correctly formatted and not expired
-   - Restart the proxy service after updating the token
-
-2. **Manually set the token on the server**:
-   ```bash
-   # On the server running the proxy service
-   export MODAL_TOKEN_ID=your_modal_token_here
-   modal token set your_modal_token_here
-   ```
-
-3. **Verify the token works directly on the server**:
-   ```bash
-   # Test if the token works by listing Modal volumes
-   modal volume list
-   ```
-
-4. **Check the proxy service logs**:
-   - Look at `modal_proxy.log` on the server for detailed error messages
-   - Check for messages like "Modal token verification failed"
-   - Ensure the token is being properly passed to the Modal API
-
-5. **Restart the proxy service**:
-   ```bash
-   # Kill the existing process and restart
-   pkill -f modal_proxy_service.py
-   python modal_proxy_service.py
-   ```
-
-6. **Check ngrok connection**:
-   - Verify the ngrok tunnel is active and the URL is correct
-   - Ensure requests are being properly forwarded to the proxy service
-
-### "Unauthorized" Error
-
-If you see an "Unauthorized" error:
-
-1. **When creating an API key**:
-   - Make sure you're including the correct admin key in the request header
-   - Example: `-H "X-Admin-Key: your_admin_key_here"`
-
-2. **When using the API**:
-   - Make sure your client is configured with a valid API key
-   - Reconfigure with `./gitarsenal.py proxy configure`
-
-## Security Considerations
-
-- Keep your admin key and API keys secure
-- Use HTTPS if exposing the service publicly (ngrok provides this automatically)
-- Consider implementing additional authentication mechanisms for production use 

package/python/README.md

@@ -1,68 +0,0 @@
-# GitArsenal CLI Python Modules
-
-This directory contains Python modules for the GitArsenal CLI.
-
-## Modal Integration
-
-The GitArsenal CLI integrates with Modal for creating sandboxes and SSH containers. The following modules are available:
-
-- `modal_proxy_service.py`: A proxy service for Modal operations
-- `test_modalSandboxScript.py`: Creates Modal sandboxes and SSH containers
-- `setup_modal_token.py`: Sets up the Modal token in the environment
-- `fetch_modal_tokens.py`: Fetches Modal tokens from the proxy server
-
-## Security Features
-
-### Modal Token Cleanup
-
-For enhanced security, GitArsenal CLI now automatically cleans up Modal tokens after SSH containers are created. This ensures that your Modal token is not left in the environment or on disk after the container is started.
-
-The cleanup process:
-1. Removes Modal token environment variables (MODAL_TOKEN_ID, MODAL_TOKEN, MODAL_TOKEN_SECRET)
-2. Deletes the ~/.modal.toml file which contains the authentication token
-3. Runs automatically after SSH container creation
-4. Runs on service shutdown via signal handlers
-
-This simple but effective approach prevents potential token leakage when containers are shared or when the service is stopped, and ensures that users cannot continue to use Modal CLI commands like `modal shell` after the container is created.
-
-## Usage
-
-To use the GitArsenal CLI Python modules, you can import them directly or use the provided scripts.
-
-### Creating a Modal SSH Container
-
-```python
-from test_modalSandboxScript import create_modal_ssh_container
-
-result = create_modal_ssh_container(
-    gpu_type="A10G",
-    repo_url="https://github.com/user/repo",
-    repo_name="repo",
-    setup_commands=["pip install -r requirements.txt"],
-    timeout_minutes=60
-)
-
-# The Modal token is automatically cleaned up after the container is created
-```
-
-### Running the Modal Proxy Service
-
-```bash
-python modal_proxy_service.py
-```
-
-The service will automatically clean up Modal tokens on shutdown.
-
-## Testing
-
-To test the Modal token cleanup functionality:
-
-```bash
-python test_token_cleanup.py
-```
-
-This script verifies that the token cleanup process works correctly by:
-1. Setting up a test Modal token
-2. Verifying the token exists in environment and files
-3. Cleaning up the token
-4. Verifying the token has been removed 

package/python/fix_commands.py

@@ -1,71 +0,0 @@
-#!/usr/bin/env python3
-"""
-Fix commands for Modal SSH container
-This script fixes common issues with commands in the Modal SSH container
-"""
-
-import os
-import sys
-import subprocess
-
-def fix_command(cmd):
-    """Fix common issues with commands"""
-    # Replace 'source' with '.' for sh shell
-    if 'source' in cmd:
-        cmd = cmd.replace('source', '.')
-        print(f"✅ Fixed: Replaced 'source' with '.' for sh shell")
-    
-    # Fix uv venv and activation in one command
-    if 'uv venv' in cmd and '&&' in cmd:
-        # The command is already trying to create and activate a venv
-        # Just need to make sure 'source' is replaced with '.'
-        pass
-    
-    # Fix uv pip install without active venv
-    if 'uv pip install' in cmd and 'venv' not in cmd:
-        # Create and activate a venv first
-        cmd = f"uv venv .venv && . .venv/bin/activate && {cmd}"
-        print(f"✅ Fixed: Added venv creation and activation before pip install")
-    
-    return cmd
-
-def run_fixed_command(cmd):
-    """Run the fixed command"""
-    fixed_cmd = fix_command(cmd)
-    print(f"\n🔧 Running fixed command: {fixed_cmd}")
-    
-    # Run the command
-    result = subprocess.run(fixed_cmd, shell=True, text=True, capture_output=True)
-    
-    # Print the output
-    if result.stdout:
-        print(f"\n--- Output ---\n{result.stdout}")
-    if result.stderr:
-        print(f"\n--- Error ---\n{result.stderr}")
-    
-    # Return the result
-    return result.returncode == 0
-
-def main():
-    """Main function"""
-    if len(sys.argv) < 2:
-        print("Usage: python fix_commands.py 'command to fix'")
-        return 1
-    
-    # Get the command from command line
-    cmd = ' '.join(sys.argv[1:])
-    print(f"🔍 Original command: {cmd}")
-    
-    # Run the fixed command
-    success = run_fixed_command(cmd)
-    
-    # Print the result
-    if success:
-        print("\n✅ Command executed successfully")
-    else:
-        print("\n❌ Command failed")
-    
-    return 0 if success else 1
-
-if __name__ == "__main__":
-    sys.exit(main()) 

package/python/fixed_function.py

@@ -1,58 +0,0 @@
-def get_setup_commands_from_local_api(repo_url, gitingest_data):
-    """Try to get setup commands from the API."""
-    # Use only online endpoints
-    api_endpoints = [
-        "https://www.gitarsenal.dev/api/analyze-with-gitingest"  # Working endpoint with www prefix
-    ]
-    
-    # Prepare the request payload
-    payload = {
-        "repoUrl": repo_url,
-        "gitingestData": gitingest_data,
-        "userRequest": "Setup and run the repository"
-    }
-    
-    # Try each API endpoint
-    for api_url in api_endpoints:
-        # Use the retry mechanism for more reliable requests
-        response = make_api_request_with_retry(
-            url=api_url,
-            payload=payload,
-            max_retries=2,
-            timeout=180  # 3 minute timeout
-        )
-        
-        if response and response.status_code == 200:
-            try:
-                data = response.json()
-                print(f"📄 Response size: {len(response.text)} bytes")
-                print(f"📄 Response URL: {response.url}")
-                if "setupInstructions" in data and "commands" in data["setupInstructions"]:
-                    commands = data["setupInstructions"]["commands"]
-                    print(f"✅ Successfully fetched {len(commands)} setup commands from API at {api_url}")
-                    
-                    # Print the original commands
-                    print("📋 Original commands from API:")
-                    for i, cmd in enumerate(commands, 1):
-                        print(f"  {i}. {cmd}")
-                    
-                    # Fix the commands
-                    fixed_commands = fix_setup_commands(commands)
-                    
-                    # Print the fixed commands
-                    print("\n📋 Fixed commands:")
-                    for i, cmd in enumerate(fixed_commands, 1):
-                        print(f"  {i}. {cmd}")
-                    
-                    return fixed_commands
-                else:
-                    print("⚠️ API response did not contain setupInstructions.commands field")
-            except json.JSONDecodeError:
-                print(f"❌ Failed to parse API response as JSON")
-        elif response:
-            print(f"❌ API request failed with status code: {response.status_code}")
-        else:
-            print(f"❌ Failed to connect to {api_url}")
-    
-    print("❌ All API endpoints failed")
-    return None

package/python/manage_credentials.py

@@ -1,119 +0,0 @@
-#!/usr/bin/env python3
-"""
-GitArsenal Credentials Manager CLI
-
-This script allows users to manage their API keys and tokens for GitArsenal CLI.
-"""
-
-import argparse
-import sys
-from credentials_manager import CredentialsManager
-
-def main():
-    parser = argparse.ArgumentParser(description="Manage credentials for GitArsenal CLI")
-    subparsers = parser.add_subparsers(dest="command", help="Command to run")
-    
-    # Setup command
-    setup_parser = subparsers.add_parser("setup", help="Set up all credentials")
-    
-    # Set command
-    set_parser = subparsers.add_parser("set", help="Set a specific credential")
-    set_parser.add_argument("key", choices=["openai_api_key", "modal_token", "huggingface_token", "wandb_api_key"], 
-                          help="The credential to set")
-    
-    # Get command
-    get_parser = subparsers.add_parser("get", help="Get a specific credential")
-    get_parser.add_argument("key", choices=["openai_api_key", "modal_token", "huggingface_token", "wandb_api_key"], 
-                          help="The credential to get")
-    
-    # Clear command
-    clear_parser = subparsers.add_parser("clear", help="Clear credentials")
-    clear_parser.add_argument("key", nargs="?", choices=["openai_api_key", "modal_token", "huggingface_token", "wandb_api_key", "all"], 
-                            default="all", help="The credential to clear (default: all)")
-    
-    # List command
-    list_parser = subparsers.add_parser("list", help="List all saved credentials (shows only existence, not values)")
-    
-    args = parser.parse_args()
-    
-    # Create credentials manager
-    credentials_manager = CredentialsManager()
-    
-    if args.command == "setup":
-        print("📋 Setting up all credentials for GitArsenal CLI")
-        print("You'll be prompted for each credential. Press Ctrl+C to skip any credential.")
-        
-        try:
-            # OpenAI API key
-            print("\n🔑 Setting up OpenAI API key")
-            credentials_manager.get_openai_api_key()
-            
-            # Modal token
-            print("\n🔑 Setting up Modal token")
-            credentials_manager.get_modal_token()
-            
-            # Hugging Face token
-            print("\n🔑 Setting up Hugging Face token")
-            credentials_manager.get_huggingface_token()
-            
-            # Weights & Biases API key
-            print("\n🔑 Setting up Weights & Biases API key")
-            credentials_manager.get_wandb_api_key()
-            
-            print("\n✅ Credentials setup complete!")
-            
-        except KeyboardInterrupt:
-            print("\n\n⚠️ Setup interrupted. Some credentials may not have been set.")
-            return 1
-    
-    elif args.command == "set":
-        print(f"🔑 Setting {args.key}")
-        if args.key == "openai_api_key":
-            credentials_manager.get_openai_api_key()
-        elif args.key == "modal_token":
-            credentials_manager.get_modal_token()
-        elif args.key == "huggingface_token":
-            credentials_manager.get_huggingface_token()
-        elif args.key == "wandb_api_key":
-            credentials_manager.get_wandb_api_key()
-    
-    elif args.command == "get":
-        credentials = credentials_manager.load_credentials()
-        if args.key in credentials:
-            # Show only first and last few characters for security
-            value = credentials[args.key]
-            masked_value = value[:4] + "*" * (len(value) - 8) + value[-4:] if len(value) > 8 else "****"
-            print(f"{args.key}: {masked_value}")
-        else:
-            print(f"❌ {args.key} not found in saved credentials")
-            return 1
-    
-    elif args.command == "clear":
-        if args.key == "all":
-            credentials_manager.clear_all_credentials()
-            print("✅ All credentials cleared")
-        else:
-            if credentials_manager.clear_credential(args.key):
-                print(f"✅ {args.key} cleared")
-            else:
-                print(f"❌ {args.key} not found in saved credentials")
-                return 1
-    
-    elif args.command == "list":
-        credentials = credentials_manager.load_credentials()
-        if not credentials:
-            print("No credentials saved")
-            return 0
-            
-        print("📋 Saved credentials:")
-        for key in credentials:
-            print(f"- {key}: {'*' * 8}")
-    
-    else:
-        parser.print_help()
-        return 1
-    
-    return 0
-
-if __name__ == "__main__":
-    sys.exit(main()) 

package/python/patch_modal_script.py

@@ -1,75 +0,0 @@
-#!/usr/bin/env python3
-"""
-Patch the test_modalSandboxScript.py file to fix issues with LLM debugging
-"""
-
-import os
-import sys
-import re
-
-def read_file(filename):
-    """Read a file and return its contents"""
-    with open(filename, 'r') as f:
-        return f.read()
-
-def write_file(filename, content):
-    """Write content to a file"""
-    with open(filename, 'w') as f:
-        f.write(content)
-
-def patch_file(filename):
-    """Patch the file to fix issues with LLM debugging"""
-    print(f"🔧 Patching {filename}...")
-    
-    # Read the file
-    content = read_file(filename)
-    
-    # Make a backup
-    backup_filename = f"{filename}.bak"
-    write_file(backup_filename, content)
-    print(f"✅ Created backup: {backup_filename}")
-    
-    # Fix 1: Replace 'source' with '.' in commands
-    pattern1 = r'(uv venv.*?)source(.*?activate)'
-    replacement1 = r'\1.\2'
-    content = re.sub(pattern1, replacement1, content)
-    print("✅ Fixed 'source' commands")
-    
-    # Fix 2: Add environment activation before uv pip commands
-    pattern2 = r'(uv pip install.*?)(?!\. .*?activate)'
-    replacement2 = r'. openr1/bin/activate && \1'
-    content = re.sub(pattern2, replacement2, content)
-    print("✅ Added environment activation before pip commands")
-    
-    # Write the patched file
-    write_file(filename, content)
-    print(f"✅ Patched file written: {filename}")
-    
-    return True
-
-def main():
-    """Main function"""
-    # Get the file to patch
-    if len(sys.argv) > 1:
-        filename = sys.argv[1]
-    else:
-        # Default to the test_modalSandboxScript.py in the current directory
-        filename = "test_modalSandboxScript.py"
-    
-    # Check if the file exists
-    if not os.path.exists(filename):
-        print(f"❌ File not found: {filename}")
-        return 1
-    
-    # Patch the file
-    success = patch_file(filename)
-    
-    if success:
-        print("\n✅ Patching completed successfully")
-        return 0
-    else:
-        print("\n❌ Patching failed")
-        return 1
-
-if __name__ == "__main__":
-    sys.exit(main()) 

package/python/run_with_modal_token.py

@@ -1,47 +0,0 @@
-#!/usr/bin/env python3
-"""
-Run With Modal Token - Wrapper Script
-
-This script sets up the Modal token in the environment and then runs a specified command.
-It's useful for running commands that need Modal authentication without modifying them.
-
-Usage:
-    python run_with_modal_token.py <command> [args...]
-    
-Example:
-    python run_with_modal_token.py python modal_proxy_service.py
-"""
-
-import os
-import sys
-import subprocess
-from setup_modal_token import setup_modal_token
-
-def main():
-    # Set up Modal token (should always succeed with built-in token)
-    setup_modal_token()
-    print("✅ Using built-in Modal token for freemium service")
-    
-    # Check if a command was provided
-    if len(sys.argv) < 2:
-        print("❌ No command provided")
-        print(f"Usage: {sys.argv[0]} <command> [args...]")
-        sys.exit(1)
-    
-    # Get the command and arguments
-    cmd = sys.argv[1]
-    args = sys.argv[2:]
-    
-    # Print what we're about to run
-    print(f"🚀 Running command with Modal token: {cmd} {' '.join(args)}")
-    
-    # Run the command
-    try:
-        result = subprocess.run([cmd] + args)
-        sys.exit(result.returncode)
-    except Exception as e:
-        print(f"❌ Error running command: {e}")
-        sys.exit(1)
-
-if __name__ == "__main__":
-    main() 

package/python/test_import.py

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