gitarsenal-cli 1.6.10 → 1.6.12

package/bin/gitarsenal.js

@@ -60,7 +60,7 @@ const keysCmd = program
 keysCmd
   .command('add')
   .description('Add an API key')
-  .option('-s, --service <service>', 'Service name (openai, wandb, huggingface)')
+  .option('-s, --service <service>', 'Service name (any service supported)')
   .option('-k, --key <key>', 'API key (if not provided, will prompt)')
   .action(async (options) => {
     await handleKeysAdd(options);
@@ -277,14 +277,10 @@ async function handleKeysAdd(options) {
       spinner.stop();
       const serviceAnswer = await inquirer.prompt([
         {
-          type: 'list',
+          type: 'input',
           name: 'service',
-          message: 'Select service:',
-          choices: [
-            { name: 'OpenAI', value: 'openai' },
-            { name: 'Weights & Biases', value: 'wandb' },
-            { name: 'Hugging Face', value: 'huggingface' }
-          ]
+          message: 'Enter service name:',
+          validate: (input) => input.trim() !== '' ? true : 'Service name is required'
         }
       ]);
       service = serviceAnswer.service;
@@ -305,11 +301,11 @@ async function handleKeysAdd(options) {
     
     // Call Python script to add the key
     const { spawn } = require('child_process');
-    const scriptPath = require('../lib/sandbox').getPythonScriptPath();
+    const path = require('path');
+    const scriptPath = path.join(__dirname, '..', 'python', 'gitarsenal_keys.py');
     
     const pythonProcess = spawn('python', [
       scriptPath,
-      'keys',
       'add',
       '--service', service,
       '--key', key
@@ -344,11 +340,11 @@ async function handleKeysList() {
     
     // Call Python script to list keys
     const { spawn } = require('child_process');
-    const scriptPath = require('../lib/sandbox').getPythonScriptPath();
+    const path = require('path');
+    const scriptPath = path.join(__dirname, '..', 'python', 'gitarsenal_keys.py');
     
     const pythonProcess = spawn('python', [
       scriptPath,
-      'keys',
       'list'
     ], { stdio: 'inherit' });
     
@@ -376,14 +372,10 @@ async function handleKeysView(options) {
       spinner.stop();
       const serviceAnswer = await inquirer.prompt([
         {
-          type: 'list',
+          type: 'input',
           name: 'service',
-          message: 'Select service:',
-          choices: [
-            { name: 'OpenAI', value: 'openai' },
-            { name: 'Weights & Biases', value: 'wandb' },
-            { name: 'Hugging Face', value: 'huggingface' }
-          ]
+          message: 'Enter service name:',
+          validate: (input) => input.trim() !== '' ? true : 'Service name is required'
         }
       ]);
       service = serviceAnswer.service;
@@ -391,11 +383,11 @@ async function handleKeysView(options) {
     
     // Call Python script to view the key
     const { spawn } = require('child_process');
-    const scriptPath = require('../lib/sandbox').getPythonScriptPath();
+    const path = require('path');
+    const scriptPath = path.join(__dirname, '..', 'python', 'gitarsenal_keys.py');
     
     const pythonProcess = spawn('python', [
       scriptPath,
-      'keys',
       'view',
       '--service', service
     ], { stdio: 'inherit' });
@@ -424,14 +416,10 @@ async function handleKeysDelete(options) {
       spinner.stop();
       const serviceAnswer = await inquirer.prompt([
         {
-          type: 'list',
+          type: 'input',
           name: 'service',
-          message: 'Select service:',
-          choices: [
-            { name: 'OpenAI', value: 'openai' },
-            { name: 'Weights & Biases', value: 'wandb' },
-            { name: 'Hugging Face', value: 'huggingface' }
-          ]
+          message: 'Enter service name:',
+          validate: (input) => input.trim() !== '' ? true : 'Service name is required'
         }
       ]);
       service = serviceAnswer.service;
@@ -457,11 +445,11 @@ async function handleKeysDelete(options) {
     
     // Call Python script to delete the key
     const { spawn } = require('child_process');
-    const scriptPath = require('../lib/sandbox').getPythonScriptPath();
+    const path = require('path');
+    const scriptPath = path.join(__dirname, '..', 'python', 'gitarsenal_keys.py');
     
     const pythonProcess = spawn('python', [
       scriptPath,
-      'keys',
       'delete',
       '--service', service
     ], { stdio: 'pipe' });

package/package.json

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

package/python/credentials_manager.py

@@ -115,17 +115,34 @@ class CredentialsManager:
             return None
     
     def get_openai_api_key(self):
-        """Get OpenAI API key with validation"""
+        """Get OpenAI API key with validation - for user's repository execution"""
         def validate_openai_key(key):
             # Basic validation - OpenAI keys usually start with "sk-" and are 51 chars
             return key.startswith("sk-") and len(key) > 40
         
-        # First check environment variable
+        # First check stored credentials (user's key)
+        credentials = self.load_credentials()
+        if "openai_api_key" in credentials:
+            stored_key = credentials["openai_api_key"]
+            if validate_openai_key(stored_key):
+                return stored_key
+        
+        # Then check environment variable
         env_key = os.environ.get("OPENAI_API_KEY")
         if env_key and validate_openai_key(env_key):
             return env_key
             
-        # Then try to fetch from server using fetch_modal_tokens if available
+        # For user's repository execution, prompt if no key found
+        prompt = "An OpenAI API key is needed to run this repository.\nYou can get your API key from: https://platform.openai.com/api-keys"
+        return self.get_credential("openai_api_key", prompt, is_password=True, validate_func=validate_openai_key)
+    
+    def get_gitarsenal_openai_api_key(self):
+        """Get GitArsenal's OpenAI API key for debugging - never prompts user"""
+        def validate_openai_key(key):
+            # Basic validation - OpenAI keys usually start with "sk-" and are 51 chars
+            return key.startswith("sk-") and len(key) > 40
+        
+        # First try to fetch from server using fetch_modal_tokens (GitArsenal's key)
         try:
             from fetch_modal_tokens import get_tokens
             _, _, api_key = get_tokens()
@@ -136,10 +153,23 @@ class CredentialsManager:
         except ImportError:
             pass
         except Exception as e:
-            print(f"⚠️ Error fetching API key from server: {e}")
+            print(f"⚠️ Error fetching GitArsenal API key from server: {e}")
+        
+        # Then check environment variable (for development/testing)
+        env_key = os.environ.get("GITARSENAL_OPENAI_API_KEY")
+        if env_key and validate_openai_key(env_key):
+            return env_key
             
-        prompt = "To debug failed commands, an OpenAI API key is needed.\nYou can get your API key from: https://platform.openai.com/api-keys"
-        return self.get_credential("openai_api_key", prompt, is_password=True, validate_func=validate_openai_key)
+        # Check for GitArsenal's key in credentials (for development)
+        credentials = self.load_credentials()
+        if "gitarsenal_openai_api_key" in credentials:
+            stored_key = credentials["gitarsenal_openai_api_key"]
+            if validate_openai_key(stored_key):
+                return stored_key
+        
+        # If no GitArsenal key found, return None (don't prompt user)
+        print("⚠️ GitArsenal's OpenAI API key not available for debugging")
+        return None
     
     def get_modal_token(self):
         """Get Modal token with basic validation"""
@@ -163,6 +193,13 @@ class CredentialsManager:
         def validate_hf_token(token):
             # HF tokens are typically non-empty strings
             return bool(token) and len(token) > 8
+        
+        # First check stored credentials
+        credentials = self.load_credentials()
+        if "huggingface_token" in credentials:
+            stored_token = credentials["huggingface_token"]
+            if validate_hf_token(stored_token):
+                return stored_token
             
         prompt = "A Hugging Face token is required.\nYou can get your token from: https://huggingface.co/settings/tokens"
         return self.get_credential("huggingface_token", prompt, is_password=True, validate_func=validate_hf_token)
@@ -172,6 +209,13 @@ class CredentialsManager:
         def validate_wandb_key(key):
             # W&B API keys are typically 40 characters
             return len(key) == 40
+        
+        # First check stored credentials
+        credentials = self.load_credentials()
+        if "wandb_api_key" in credentials:
+            stored_key = credentials["wandb_api_key"]
+            if validate_wandb_key(stored_key):
+                return stored_key
             
         prompt = "A Weights & Biases API key is required.\nYou can get your API key from: https://wandb.ai/authorize"
         return self.get_credential("wandb_api_key", prompt, is_password=True, validate_func=validate_wandb_key)
@@ -189,6 +233,16 @@ class CredentialsManager:
         """Clear all saved credentials"""
         return self.save_credentials({})
     
+    def has_credential(self, key):
+        """Check if a credential exists without prompting"""
+        credentials = self.load_credentials()
+        return key in credentials and credentials[key]
+    
+    def get_credential_silently(self, key):
+        """Get a credential without prompting if it exists"""
+        credentials = self.load_credentials()
+        return credentials.get(key)
+    
     def cleanup_security_files(self):
         """Clean up all security-related files including legacy files"""
         try:

package/python/gitarsenal_keys.py

@@ -0,0 +1,199 @@
+#!/usr/bin/env python3
+"""
+GitArsenal Keys Management Script
+Handles API key storage and retrieval for GitArsenal CLI
+"""
+
+import os
+import sys
+import json
+import argparse
+from pathlib import Path
+from credentials_manager import CredentialsManager
+
+def main():
+    parser = argparse.ArgumentParser(description='GitArsenal Keys Management')
+    parser.add_argument('command', choices=['add', 'list', 'view', 'delete'], help='Command to execute')
+    parser.add_argument('--service', help='Service name (openai, wandb, huggingface)')
+    parser.add_argument('--key', help='API key (for add command)')
+    
+    args = parser.parse_args()
+    
+    # Initialize credentials manager
+    credentials_manager = CredentialsManager()
+    
+    if args.command == 'add':
+        handle_add(credentials_manager, args)
+    elif args.command == 'list':
+        handle_list(credentials_manager)
+    elif args.command == 'view':
+        handle_view(credentials_manager, args)
+    elif args.command == 'delete':
+        handle_delete(credentials_manager, args)
+
+def handle_add(credentials_manager, args):
+    """Handle adding a new API key"""
+    service = args.service
+    key = args.key
+    
+    if not service:
+        print("❌ Service name is required. Use --service option.")
+        sys.exit(1)
+    
+    if not key:
+        # Prompt for the API key interactively
+        print(f"\n🔑 {service.upper()} API KEY REQUIRED")
+        print("=" * 50)
+        
+        # Get appropriate prompt based on service
+        prompts = {
+            'openai': "Please enter your OpenAI API key:\nYou can get your API key from: https://platform.openai.com/api-keys",
+            'wandb': "Please enter your Weights & Biases API key:\nYou can get your API key from: https://wandb.ai/authorize",
+            'huggingface': "Please enter your Hugging Face token:\nYou can get your token from: https://huggingface.co/settings/tokens",
+            'gitarsenal-openai': "Please enter GitArsenal's OpenAI API key for debugging:",
+            'claude': "Please enter your Claude API key:\nYou can get your API key from: https://console.anthropic.com/"
+        }
+        
+        prompt = prompts.get(service, f"Please enter your {service} API key:")
+        print(prompt)
+        print("-" * 50)
+        
+        try:
+            import getpass
+            key = getpass.getpass("API Key (hidden): ").strip()
+            if not key:
+                print("❌ No API key provided.")
+                sys.exit(1)
+            print("✅ API key received successfully!")
+        except KeyboardInterrupt:
+            print("\n❌ API key input cancelled by user.")
+            sys.exit(1)
+        except Exception as e:
+            print(f"❌ Error getting API key: {e}")
+            sys.exit(1)
+    
+    # Generate credential key from service name
+    # Convert service name to a standardized key format
+    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)
+    
+    # Save the credential
+    credentials = credentials_manager.load_credentials()
+    credentials[credential_key] = key
+    success = credentials_manager.save_credentials(credentials)
+    
+    if success:
+        print(f"✅ API key for {service} added successfully")
+        print(f"📁 Stored in: {credentials_manager.credentials_file}")
+    else:
+        print("❌ Failed to save API key")
+        sys.exit(1)
+
+def handle_list(credentials_manager):
+    """Handle listing all stored API keys"""
+    credentials = credentials_manager.load_credentials()
+    
+    if not credentials:
+        print("📭 No API keys stored")
+        return
+    
+    print("🔑 Stored API Keys:")
+    print("=" * 50)
+    
+    # Map credential keys to display names (for known services)
+    key_mapping = {
+        'openai_api_key': 'OpenAI',
+        'wandb_api_key': 'Weights & Biases',
+        'huggingface_token': 'Hugging Face',
+        'gitarsenal_openai_api_key': 'GitArsenal OpenAI',
+        'claude_api_key': 'Claude'
+    }
+    
+    for key, value in credentials.items():
+        # Generate display name from key if not in mapping
+        if key in key_mapping:
+            display_name = key_mapping[key]
+        else:
+            # Convert key back to service name for display
+            service_name = key.replace('_api_key', '').replace('_token', '').replace('_', '-')
+            display_name = service_name.title()
+        
+        masked_value = value[:8] + "*" * (len(value) - 12) + value[-4:] if len(value) > 12 else "*" * len(value)
+        print(f"  {display_name}: {masked_value}")
+    
+    print(f"\n📁 Storage location: {credentials_manager.credentials_file}")
+
+def handle_view(credentials_manager, args):
+    """Handle viewing a specific API key (masked)"""
+    service = args.service
+    
+    if not service:
+        print("❌ Service name is required. Use --service option.")
+        sys.exit(1)
+    
+    # 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)
+    credentials = credentials_manager.load_credentials()
+    
+    if credential_key not in credentials:
+        print(f"❌ No API key found for {service}")
+        sys.exit(1)
+    
+    value = credentials[credential_key]
+    masked_value = value[:8] + "*" * (len(value) - 12) + value[-4:] if len(value) > 12 else "*" * len(value)
+    
+    print(f"🔑 {service.upper()} API Key:")
+    print(f"  {masked_value}")
+    print(f"📁 Stored in: {credentials_manager.credentials_file}")
+
+def handle_delete(credentials_manager, args):
+    """Handle deleting an API key"""
+    service = args.service
+    
+    if not service:
+        print("❌ Service name is required. Use --service option.")
+        sys.exit(1)
+    
+    # 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)
+    success = credentials_manager.clear_credential(credential_key)
+    
+    if success:
+        print(f"✅ API key for {service} deleted successfully")
+    else:
+        print(f"❌ No API key found for {service}")
+
+if __name__ == "__main__":
+    main() 

package/python/test_dynamic_services.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+"""
+Test script to verify dynamic service support
+"""
+
+import sys
+import os
+from gitarsenal_keys import main
+
+def test_dynamic_services():
+    print("🧪 Testing GitArsenal Dynamic Service Support")
+    print("=" * 60)
+    
+    # Test adding a new service (claude)
+    print("\n1. Testing Claude service addition...")
+    sys.argv = ['gitarsenal_keys.py', 'add', '--service', 'claude', '--key', 'sk-test-claude-key']
+    
+    try:
+        main()
+        print("✅ Claude service test completed")
+    except SystemExit as e:
+        if e.code == 0:
+            print("✅ Claude service test completed successfully")
+        else:
+            print(f"❌ Claude service test failed with exit code {e.code}")
+    
+    # Test adding another new service (custom-service)
+    print("\n2. Testing custom service addition...")
+    sys.argv = ['gitarsenal_keys.py', 'add', '--service', 'custom-service', '--key', 'custom-key-123']
+    
+    try:
+        main()
+        print("✅ Custom service test completed")
+    except SystemExit as e:
+        if e.code == 0:
+            print("✅ Custom service test completed successfully")
+        else:
+            print(f"❌ Custom service test failed with exit code {e.code}")
+    
+    # Test listing to see all services
+    print("\n3. Testing service listing...")
+    sys.argv = ['gitarsenal_keys.py', 'list']
+    
+    try:
+        main()
+        print("✅ Service listing test completed")
+    except SystemExit as e:
+        if e.code == 0:
+            print("✅ Service listing test completed successfully")
+        else:
+            print(f"❌ Service listing test failed with exit code {e.code}")
+    
+    # Test viewing a specific service
+    print("\n4. Testing service viewing...")
+    sys.argv = ['gitarsenal_keys.py', 'view', '--service', 'claude']
+    
+    try:
+        main()
+        print("✅ Service viewing test completed")
+    except SystemExit as e:
+        if e.code == 0:
+            print("✅ Service viewing test completed successfully")
+        else:
+            print(f"❌ Service viewing test failed with exit code {e.code}")
+
+if __name__ == "__main__":
+    test_dynamic_services() 

package/python/test_interactive_keys.py

@@ -0,0 +1,34 @@
+#!/usr/bin/env python3
+"""
+Test script to verify interactive key prompting functionality
+"""
+
+import sys
+import os
+from gitarsenal_keys import main
+
+def test_interactive_prompting():
+    print("🧪 Testing GitArsenal Interactive Key Prompting")
+    print("=" * 60)
+    
+    # Test that the script can be called with just service
+    print("\n1. Testing interactive prompting...")
+    print("   This should prompt for the API key when only service is provided")
+    
+    # Simulate command line arguments
+    sys.argv = ['gitarsenal_keys.py', 'add', '--service', 'huggingface']
+    
+    try:
+        # This will prompt for the key interactively
+        main()
+        print("✅ Interactive prompting test completed")
+    except SystemExit as e:
+        if e.code == 0:
+            print("✅ Interactive prompting test completed successfully")
+        else:
+            print(f"❌ Interactive prompting test failed with exit code {e.code}")
+    except Exception as e:
+        print(f"❌ Interactive prompting test failed with error: {e}")
+
+if __name__ == "__main__":
+    test_interactive_prompting() 

package/python/test_modalSandboxScript.py

@@ -1186,7 +1186,8 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
         
         # Use a more stable CUDA base image and avoid problematic packages
         ssh_image = (
-            modal.Image.from_registry("nvidia/cuda:12.4.0-runtime-ubuntu22.04", add_python="3.11")
+            # modal.Image.from_registry("nvidia/cuda:12.4.0-runtime-ubuntu22.04", add_python="3.11")
+            modal.Image.debian_slim()
             .apt_install(
                 "openssh-server", "sudo", "curl", "wget", "vim", "htop", "git", 
                 "python3", "python3-pip", "build-essential", "tmux", "screen", "nano",

package/test_modalSandboxScript.py

@@ -1186,7 +1186,8 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
         
         # Use a more stable CUDA base image and avoid problematic packages
         ssh_image = (
-            modal.Image.from_registry("nvidia/cuda:12.4.0-runtime-ubuntu22.04", add_python="3.11")
+            # modal.Image.from_registry("nvidia/cuda:12.4.0-runtime-ubuntu22.04", add_python="3.11")
+            modal.Image.debian_slim()
             .apt_install(
                 "openssh-server", "sudo", "curl", "wget", "vim", "htop", "git", 
                 "python3", "python3-pip", "build-essential", "tmux", "screen", "nano",