gitarsenal-cli 1.2.4 → 1.2.6

package/package.json

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

package/python/README.md

@@ -18,13 +18,15 @@ The GitArsenal CLI integrates with Modal for creating sandboxes and SSH containe
 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 Modal token files (.modal/token.json, .modal/token_alt.json, .modalconfig)
+1. Removes real Modal token environment variables (MODAL_TOKEN_ID, MODAL_TOKEN, MODAL_TOKEN_SECRET)
+2. Deletes real Modal token files (.modal/token.json, .modal/token_alt.json, .modalconfig)
 3. Invalidates Modal sessions by removing session files and directories
-4. Runs automatically after SSH container creation
-5. Runs on service shutdown via signal handlers
+4. Creates corrupted token files that will cause Modal CLI authentication to fail
+5. Creates a wrapper script around the Modal CLI that specifically blocks the `modal shell` command
+6. Runs automatically after SSH container creation
+7. Runs on service shutdown via signal handlers
 
-This 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 after the container is created.
+This 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
 

package/python/modal_proxy_service.py

@@ -215,7 +215,7 @@ def cleanup_modal_token():
     logger.info("🧹 Cleaning up Modal token for security...")
     
     try:
-        # Remove token from environment variables
+        # Remove real token from environment variables
         if "MODAL_TOKEN_ID" in os.environ:
             del os.environ["MODAL_TOKEN_ID"]
             logger.info("✅ Removed MODAL_TOKEN_ID from environment")
@@ -276,6 +276,79 @@ def cleanup_modal_token():
         except Exception as e:
             logger.warning(f"⚠️ Error during Modal session invalidation: {e}")
             
+        # Create corrupted token files that will cause Modal CLI to fail
+        try:
+            logger.info("🔒 Creating corrupted Modal token files...")
+            
+            # Create .modal directory if it doesn't exist
+            if not modal_dir.exists():
+                modal_dir.mkdir(parents=True)
+                logger.info(f"✅ Created Modal directory at {modal_dir}")
+            
+            # Create a corrupted token.json file
+            token_file = modal_dir / "token.json"
+            with open(token_file, 'w') as f:
+                f.write('{"corrupted": true, "message": "Token has been invalidated for security reasons"}')
+            logger.info(f"✅ Created corrupted token file at {token_file}")
+            
+            # Create a corrupted .modalconfig file
+            modalconfig_file = Path.home() / ".modalconfig"
+            with open(modalconfig_file, 'w') as f:
+                f.write("# This file has been corrupted for security reasons\n")
+                f.write("corrupted = true\n")
+            logger.info(f"✅ Created corrupted .modalconfig file at {modalconfig_file}")
+            
+            # Try to disable the modal shell command specifically
+            try:
+                # Find the modal executable path
+                result = subprocess.run(
+                    ["which", "modal"],
+                    capture_output=True,
+                    text=True
+                )
+                modal_path = result.stdout.strip()
+                
+                if modal_path:
+                    logger.info(f"📍 Found Modal CLI at: {modal_path}")
+                    
+                    # Create a wrapper script that intercepts the shell command
+                    modal_shell_wrapper = """#!/bin/bash
+if [[ "$1" == "shell" ]]; then
+  echo "❌ Modal shell has been disabled for security reasons."
+  echo "Modal token has been removed after SSH container creation."
+  exit 1
+fi
+
+# Pass all other commands to the real modal CLI
+REAL_MODAL=$(which modal.real 2>/dev/null)
+if [ -n "$REAL_MODAL" ]; then
+  exec "$REAL_MODAL" "$@"
+else
+  echo "❌ Modal CLI has been disabled for security reasons."
+  echo "Modal token has been removed after SSH container creation."
+  exit 1
+fi
+"""
+                    
+                    # Rename the original modal executable
+                    os.rename(modal_path, f"{modal_path}.real")
+                    logger.info(f"✅ Renamed original Modal CLI to {modal_path}.real")
+                    
+                    # Create a new modal script
+                    with open(modal_path, 'w') as f:
+                        f.write(modal_shell_wrapper)
+                    
+                    # Make it executable
+                    os.chmod(modal_path, 0o755)
+                    logger.info(f"✅ Created Modal CLI wrapper at {modal_path}")
+                else:
+                    logger.warning("⚠️ Could not find Modal CLI path")
+            except Exception as e:
+                logger.warning(f"⚠️ Error creating Modal CLI wrapper: {e}")
+            
+        except Exception as e:
+            logger.warning(f"⚠️ Error creating corrupted token files: {e}")
+            
         logger.info("✅ Modal token cleanup completed successfully")
     except Exception as e:
         logger.error(f"❌ Error during Modal token cleanup: {e}")

package/python/test_modalSandboxScript.py

@@ -3298,7 +3298,7 @@ def cleanup_modal_token():
     print("🧹 Cleaning up Modal token for security...")
     
     try:
-        # Remove token from environment variables
+        # Remove real token from environment variables
         if "MODAL_TOKEN_ID" in os.environ:
             del os.environ["MODAL_TOKEN_ID"]
             print("✅ Removed MODAL_TOKEN_ID from environment")
@@ -3332,12 +3332,12 @@ def cleanup_modal_token():
         if os.path.exists(modalconfig_file):
             os.remove(modalconfig_file)
             print(f"✅ Deleted .modalconfig file at {modalconfig_file}")
-        
+            
         # Try to invalidate Modal sessions
         try:
             print("🔑 Invalidating Modal sessions...")
             
-            # As a last resort, try to directly modify Modal's session files
+            # Try to directly modify Modal's session files
             try:
                 # Check for session files in .modal directory
                 session_dir = os.path.join(modal_dir, "sessions")
@@ -3359,6 +3359,82 @@ def cleanup_modal_token():
         except Exception as e:
             print(f"⚠️ Error during Modal session invalidation: {e}")
             
+        # Create corrupted token files that will cause Modal CLI to fail
+        try:
+            print("🔒 Creating corrupted Modal token files...")
+            
+            # Create .modal directory if it doesn't exist
+            if not os.path.exists(modal_dir):
+                os.makedirs(modal_dir)
+                print(f"✅ Created Modal directory at {modal_dir}")
+            
+            # Create a corrupted token.json file
+            token_file = os.path.join(modal_dir, "token.json")
+            with open(token_file, 'w') as f:
+                f.write('{"corrupted": true, "message": "Token has been invalidated for security reasons"}')
+            print(f"✅ Created corrupted token file at {token_file}")
+            
+            # Create a corrupted .modalconfig file
+            modalconfig_file = os.path.join(home_dir, ".modalconfig")
+            with open(modalconfig_file, 'w') as f:
+                f.write("# This file has been corrupted for security reasons\n")
+                f.write("corrupted = true\n")
+            print(f"✅ Created corrupted .modalconfig file at {modalconfig_file}")
+            
+            # Try to disable the modal shell command specifically
+            try:
+                import subprocess
+                import sys
+                
+                # Find the modal executable path
+                result = subprocess.run(
+                    ["which", "modal"],
+                    capture_output=True,
+                    text=True
+                )
+                modal_path = result.stdout.strip()
+                
+                if modal_path:
+                    print(f"📍 Found Modal CLI at: {modal_path}")
+                    
+                    # Create a wrapper script that intercepts the shell command
+                    modal_shell_wrapper = """#!/bin/bash
+if [[ "$1" == "shell" ]]; then
+  echo "❌ Modal shell has been disabled for security reasons."
+  echo "Modal token has been removed after SSH container creation."
+  exit 1
+fi
+
+# Pass all other commands to the real modal CLI
+REAL_MODAL=$(which modal.real 2>/dev/null)
+if [ -n "$REAL_MODAL" ]; then
+  exec "$REAL_MODAL" "$@"
+else
+  echo "❌ Modal CLI has been disabled for security reasons."
+  echo "Modal token has been removed after SSH container creation."
+  exit 1
+fi
+"""
+                    
+                    # Rename the original modal executable
+                    os.rename(modal_path, f"{modal_path}.real")
+                    print(f"✅ Renamed original Modal CLI to {modal_path}.real")
+                    
+                    # Create a new modal script
+                    with open(modal_path, 'w') as f:
+                        f.write(modal_shell_wrapper)
+                    
+                    # Make it executable
+                    os.chmod(modal_path, 0o755)
+                    print(f"✅ Created Modal CLI wrapper at {modal_path}")
+                else:
+                    print("⚠️ Could not find Modal CLI path")
+            except Exception as e:
+                print(f"⚠️ Error creating Modal CLI wrapper: {e}")
+            
+        except Exception as e:
+            print(f"⚠️ Error creating corrupted token files: {e}")
+            
         print("✅ Modal token cleanup completed successfully")
     except Exception as e:
         print(f"❌ Error during Modal token cleanup: {e}")

package/python/test_token_cleanup.py

@@ -108,38 +108,76 @@ def verify_token_cleaned_up():
     """Verify that the test token has been cleaned up"""
     print("🔍 Verifying token cleanup...")
     
-    # Check environment variables
+    # 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")
     
-    if env_token_id:
-        print(f"❌ MODAL_TOKEN_ID still exists: '{env_token_id}'")
+    # 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:
-        print(f"❌ MODAL_TOKEN still exists: '{env_token}'")
+    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:
-        print(f"❌ MODAL_TOKEN_SECRET still exists: '{env_token_secret}'")
+    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"
-    if token_file.exists():
-        print(f"❌ Token file still exists at {token_file}")
-        return False
     
-    token_alt_file = modal_dir / "token_alt.json"
-    if token_alt_file.exists():
-        print(f"❌ Alternative token file still exists at {token_alt_file}")
+    # 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():
-        print(f"❌ .modalconfig file still exists at {modalconfig_file}")
+        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
@@ -148,27 +186,43 @@ def verify_token_cleaned_up():
         print(f"❌ Modal sessions directory still exists at {session_dir}")
         return False
     
-    # Check for any other session or auth files
+    # 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 is still able to access tokens
+    # Check if Modal CLI works with invalid tokens
     try:
         import subprocess
         result = subprocess.run(
-            ["modal", "token", "current"],
+            ["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 and "No token found" not in result.stdout and "No token found" not in result.stderr:
-            print("❌ Modal CLI is still able to access tokens")
+        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 token status: {e}")
+        print(f"⚠️ Error checking Modal CLI status: {e}")
     
     print("✅ Token has been cleaned up successfully")
     return True