gitarsenal-cli 1.5.3 → 1.5.5

package/README.md

@@ -1,74 +1,119 @@
 # GitArsenal CLI
 
-A tool for creating and managing GPU-accelerated development environments using Modal.
+**Run any GitHub repository instantly with pre-configured GPU environments.**
 
-## Features
+GitArsenal CLI makes it incredibly easy to run any GitHub repository without worrying about setup, dependencies, or environment configuration. Just point it at a repository and start coding with GPU acceleration.
 
-- Create Modal containers with GPU support
-- Clone repositories and run setup commands
-- Persistent storage with Modal volumes
-- SSH access to containers
-- API key management for various services
+## Why GitArsenal CLI?
 
-## API Key Management
+- **Zero Setup**: No need to install dependencies, configure environments, or manage GPU drivers
+- **GPU Ready**: Every environment comes with GPU acceleration (A10G, A100, H100)
+- **Persistent Storage**: Your work and data persist between sessions
+- **SSH Access**: Connect directly to your running environment
+- **API Key Management**: Securely store and auto-inject API keys for services like OpenAI, Weights & Biases, and Hugging Face
 
-The CLI now supports secure storage of API keys for various services. Keys are stored in `~/.gitarsenal/keys/` with proper permissions (only readable by the current user).
+## Quick Start
 
-### Supported Services
+### Run any GitHub repository
 
-- `openai` - OpenAI API keys for debugging and assistance
-- `wandb` - Weights & Biases API keys for experiment tracking
-- `huggingface` - Hugging Face tokens for model access
+```bash
+# Basic usage - clone and run any repo
+gitarsenal container --repo-url https://github.com/username/awesome-project.git
+
+# With GPU acceleration
+gitarsenal container --gpu A10G --repo-url https://github.com/username/awesome-project.git
 
-### Managing API Keys
+# With custom setup commands
+gitarsenal container --gpu A100 --repo-url https://github.com/username/awesome-project.git --setup-commands "pip install -r requirements.txt" "python setup.py install"
+```
 
-#### Adding a new API key
+### Examples
 
 ```bash
-# Add a key interactively (will prompt for the key)
-python test_modalSandboxScript.py keys add --service openai
+# Run a machine learning project
+gitarsenal container --gpu A100 --repo-url https://github.com/username/transformer-project.git --setup-commands "pip install torch transformers" "wandb login"
 
-# Add a key directly (not recommended for security)
-python test_modalSandboxScript.py keys add --service wandb --key YOUR_API_KEY
+# Run a web development project
+gitarsenal container --repo-url https://github.com/username/react-app.git --setup-commands "npm install" "npm start"
+
+# Run a data science project with persistent storage
+gitarsenal container --gpu A10G --repo-url https://github.com/username/data-analysis.git --volume-name my-data --setup-commands "pip install pandas numpy matplotlib"
 ```
 
-#### Listing saved API keys
+## API Key Management
+
+Store your API keys once and use them across all projects:
 
 ```bash
-python test_modalSandboxScript.py keys list
-```
+# Add API keys for seamless integration
+gitarsenal keys add --service openai
+gitarsenal keys add --service wandb
+gitarsenal keys add --service huggingface
 
-#### Viewing a specific API key (masked)
+# View your saved keys
+gitarsenal keys list
 
-```bash
-python test_modalSandboxScript.py keys view --service huggingface
+# Remove a key
+gitarsenal keys delete --service openai
 ```
 
-#### Deleting an API key
+### Supported Services
+
+- **OpenAI** - For debugging and AI assistance
+- **Weights & Biases** - For experiment tracking
+- **Hugging Face** - For model access and downloads
+
+## Features
+
+### Automatic Environment Setup
+The CLI automatically:
+- Clones your repository
+- Installs dependencies based on your setup commands
+- Configures GPU acceleration
+- Sets up persistent storage
+- Injects your saved API keys
+
+### Persistent Storage
+Keep your work safe with persistent volumes:
 
 ```bash
-python test_modalSandboxScript.py keys delete --service openai
+# Create a persistent environment
+gitarsenal container --repo-url https://github.com/username/project.git --volume-name my-work
+
+# Your data, models, and work will persist between sessions
 ```
 
-## Creating a Modal Container
+### SSH Access
+Connect directly to your running environment:
 
 ```bash
-# Basic container creation
-python test_modalSandboxScript.py container --gpu A10G --repo-url https://github.com/username/repo.git
-
-# With setup commands
-python test_modalSandboxScript.py container --gpu A100 --repo-url https://github.com/username/repo.git --setup-commands "pip install -r requirements.txt" "python setup.py install"
+# Get SSH connection details
+gitarsenal container --repo-url https://github.com/username/project.git --ssh
 
-# With volume for persistent storage
-python test_modalSandboxScript.py container --gpu A10G --repo-url https://github.com/username/repo.git --volume-name my-persistent-volume
+# Connect via SSH to your environment
+ssh user@your-environment-ip
 ```
 
-## Automatic API Key Usage
+## Workflow
+
+1. **Choose a repository** - Any GitHub repo you want to work with
+2. **Run the command** - Specify GPU, setup commands, and storage
+3. **Start coding** - Your environment is ready with all dependencies installed
+4. **Save your work** - Use persistent volumes to keep your progress
+
+## Perfect For
+
+- **Machine Learning Projects** - GPU-accelerated training with pre-configured environments
+- **Data Science** - Jupyter notebooks with all dependencies ready
+- **Web Development** - Full-stack projects with development servers
+- **Research** - Reproducible environments for academic work
+- **Hackathons** - Quick setup for rapid prototyping
 
-When using commands that require API keys (like `wandb login` or `huggingface-cli login`), the system will:
+## Getting Started
 
-1. Check if a saved API key exists for the service
-2. If found, use the saved key automatically
-3. If not found, prompt for the key and offer to save it for future use
+1. Install the CLI (see installation instructions)
+2. Add your API keys: `gitarsenal keys add --service openai`
+3. Run any repository: `gitarsenal container --repo-url https://github.com/username/project.git`
+4. Start coding!
 
-This makes it easy to work with multiple projects that require the same API keys without having to re-enter them each time. 
+No more "works on my machine" - every environment is identical and ready to go. 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitarsenal-cli",
-  "version": "1.5.3",
+  "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())