gitarsenal-cli 1.1.19 → 1.1.21

package/python/modal_auth_patch.py

@@ -18,27 +18,40 @@ import types
 import json
 from pathlib import Path
 
-# The token to use
-TOKEN = "ak-eNMIXRdfbvpxIXcSHKPFQW"
+# Try to get tokens from the proxy server
+try:
+    # First, try to import the fetch_modal_tokens module
+    from fetch_modal_tokens import get_tokens
+    TOKEN_ID, TOKEN_SECRET = get_tokens()
+    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
+    print(f"⚠️ Using hardcoded tokens")
 
 # Set environment variables
-os.environ["MODAL_TOKEN_ID"] = TOKEN
-os.environ["MODAL_TOKEN"] = TOKEN
+os.environ["MODAL_TOKEN_ID"] = TOKEN_ID
+os.environ["MODAL_TOKEN_SECRET"] = TOKEN_SECRET
 
 # Create token files
 modal_dir = Path.home() / ".modal"
 modal_dir.mkdir(exist_ok=True)
 token_file = modal_dir / "token.json"
 with open(token_file, 'w') as f:
-    f.write(f'{{"token_id": "{TOKEN}", "token": "{TOKEN}"}}')
+    f.write(f'{{"token_id": "{TOKEN_ID}", "token_secret": "{TOKEN_SECRET}"}}')
 
 modalconfig_file = Path.home() / ".modalconfig"
 with open(modalconfig_file, 'w') as f:
-    f.write(f"token_id = {TOKEN}\n")
+    f.write(f"token_id = {TOKEN_ID}\n")
+    f.write(f"token_secret = {TOKEN_SECRET}\n")
+
+# Define functions that will always return our tokens
+def get_token_id(*args, **kwargs):
+    return TOKEN_ID
 
-# Define a function that will always return our token
-def get_token(*args, **kwargs):
-    return TOKEN
+def get_token_secret(*args, **kwargs):
+    return TOKEN_SECRET
 
 # Patch Modal's authentication system
 try:
@@ -47,25 +60,32 @@ try:
     
     # Create a fake auth config object
     class FakeAuthConfig:
-        token_id = TOKEN
-        token = TOKEN
+        token_id = TOKEN_ID
+        token_secret = TOKEN_SECRET
         
-        def get_token(self, *args, **kwargs):
-            return TOKEN
-            
         def get_token_id(self, *args, **kwargs):
-            return TOKEN
+            return TOKEN_ID
+            
+        def get_token_secret(self, *args, **kwargs):
+            return TOKEN_SECRET
     
     # Replace Modal's auth config with our fake one
     modal.config._auth_config = FakeAuthConfig()
     
     # Also patch any token-related functions
     for name in dir(modal.config):
-        if "token" in name.lower() or "auth" in name.lower():
+        if "token_id" in name.lower():
             try:
                 attr = getattr(modal.config, name)
                 if callable(attr):
-                    setattr(modal.config, name, get_token)
+                    setattr(modal.config, name, get_token_id)
+            except:
+                pass
+        elif "token_secret" in name.lower() or "token" in name.lower():
+            try:
+                attr = getattr(modal.config, name)
+                if callable(attr):
+                    setattr(modal.config, name, get_token_secret)
             except:
                 pass
     
@@ -92,34 +112,41 @@ except ImportError:
                     # Create a fake auth config object if needed
                     if not hasattr(config, "_auth_config"):
                         class FakeAuthConfig:
-                            token_id = TOKEN
-                            token = TOKEN
+                            token_id = TOKEN_ID
+                            token_secret = TOKEN_SECRET
                             
-                            def get_token(self, *args, **kwargs):
-                                return TOKEN
-                                
                             def get_token_id(self, *args, **kwargs):
-                                return TOKEN
+                                return TOKEN_ID
+                                
+                            def get_token_secret(self, *args, **kwargs):
+                                return TOKEN_SECRET
                         
                         config._auth_config = FakeAuthConfig()
                     else:
                         # Patch existing auth config
-                        config._auth_config.token_id = TOKEN
-                        config._auth_config.token = TOKEN
+                        config._auth_config.token_id = TOKEN_ID
+                        config._auth_config.token_secret = TOKEN_SECRET
                         
                         # Patch methods
-                        if hasattr(config._auth_config, "get_token"):
-                            config._auth_config.get_token = get_token
                         if hasattr(config._auth_config, "get_token_id"):
-                            config._auth_config.get_token_id = get_token
+                            config._auth_config.get_token_id = get_token_id
+                        if hasattr(config._auth_config, "get_token_secret"):
+                            config._auth_config.get_token_secret = get_token_secret
                     
                     # Also patch any token-related functions
                     for name in dir(config):
-                        if "token" in name.lower() or "auth" in name.lower():
+                        if "token_id" in name.lower():
+                            try:
+                                attr = getattr(config, name)
+                                if callable(attr):
+                                    setattr(config, name, get_token_id)
+                            except:
+                                pass
+                        elif "token_secret" in name.lower() or "token" in name.lower():
                             try:
                                 attr = getattr(config, name)
                                 if callable(attr):
-                                    setattr(config, name, get_token)
+                                    setattr(config, name, get_token_secret)
                             except:
                                 pass
                     

package/python/modal_proxy_service.py

@@ -111,7 +111,50 @@ def generate_random_password(length=16):
 
 def setup_modal_auth():
     """Set up Modal authentication using the server's token"""
-    # Use the comprehensive Modal token solution
+    # First, try to fetch tokens from the proxy server
+    try:
+        # Import the fetch_modal_tokens module
+        logger.info("Fetching Modal tokens from proxy server...")
+        from fetch_modal_tokens import get_tokens
+        token_id, token_secret = get_tokens()
+        logger.info("Modal tokens fetched successfully")
+        
+        # Set the tokens in environment variables
+        os.environ["MODAL_TOKEN_ID"] = token_id
+        os.environ["MODAL_TOKEN_SECRET"] = token_secret
+        
+        # Create token files
+        modal_dir = Path.home() / ".modal"
+        modal_dir.mkdir(exist_ok=True)
+        token_file = modal_dir / "token.json"
+        with open(token_file, 'w') as f:
+            json.dump({
+                "token_id": token_id,
+                "token_secret": token_secret
+            }, f)
+        logger.info(f"Created token file at {token_file}")
+        
+        # Create .modalconfig file
+        modalconfig_file = Path.home() / ".modalconfig"
+        with open(modalconfig_file, 'w') as f:
+            f.write(f"token_id = {token_id}\n")
+            f.write(f"token_secret = {token_secret}\n")
+        logger.info(f"Created .modalconfig file at {modalconfig_file}")
+        
+        # Verify token is working by attempting a simple operation
+        try:
+            # Try a simple Modal operation
+            import modal.cli.app_create
+            logger.info("Modal module imported successfully")
+            return True
+        except Exception as e:
+            logger.error(f"Error importing Modal module: {e}")
+            # Fall back to other methods
+    except Exception as e:
+        logger.error(f"Error fetching Modal tokens: {e}")
+        # Fall back to other methods
+    
+    # Use the comprehensive Modal token solution as fallback
     try:
         # Import the comprehensive solution module
         logger.info("Applying comprehensive Modal token solution...")
@@ -361,45 +404,77 @@ def create_ssh_container():
                 env_copy["MODAL_TOKEN_ID"] = MODAL_TOKEN
                 env_copy["MODAL_TOKEN"] = MODAL_TOKEN
                 
-                # Use the comprehensive Modal token solution
+                # First, try to fetch tokens from the proxy server
                 try:
-                    # Import the comprehensive solution module
-                    logger.info("Applying comprehensive Modal token solution in thread...")
-                    import modal_token_solution
-                    logger.info("Comprehensive Modal token solution applied in thread")
+                    # Import the fetch_modal_tokens module
+                    logger.info("Fetching Modal tokens from proxy server in thread...")
+                    from fetch_modal_tokens import get_tokens
+                    token_id, token_secret = get_tokens()
+                    logger.info("Modal tokens fetched successfully in thread")
+                    
+                    # Set the tokens in environment variables
+                    os.environ["MODAL_TOKEN_ID"] = token_id
+                    os.environ["MODAL_TOKEN_SECRET"] = token_secret
+                    
+                    # Create token files
+                    modal_dir = Path.home() / ".modal"
+                    modal_dir.mkdir(exist_ok=True)
+                    token_file = modal_dir / "token.json"
+                    with open(token_file, 'w') as f:
+                        json.dump({
+                            "token_id": token_id,
+                            "token_secret": token_secret
+                        }, f)
+                    logger.info(f"Created token file at {token_file} in thread")
+                    
+                    # Create .modalconfig file
+                    modalconfig_file = Path.home() / ".modalconfig"
+                    with open(modalconfig_file, 'w') as f:
+                        f.write(f"token_id = {token_id}\n")
+                        f.write(f"token_secret = {token_secret}\n")
+                    logger.info(f"Created .modalconfig file at {modalconfig_file} in thread")
                 except Exception as e:
-                    logger.error(f"Error applying comprehensive Modal token solution in thread: {e}")
+                    logger.error(f"Error fetching Modal tokens in thread: {e}")
                     
-                    # Fall back to the authentication patch
+                    # Fall back to the comprehensive Modal token solution
                     try:
-                        logger.info("Falling back to Modal authentication patch in thread...")
-                        import modal_auth_patch
-                        logger.info("Modal authentication patch applied in thread")
-                    except Exception as patch_e:
-                        logger.error(f"Error applying Modal authentication patch in thread: {patch_e}")
+                        # Import the comprehensive solution module
+                        logger.info("Applying comprehensive Modal token solution in thread...")
+                        import modal_token_solution
+                        logger.info("Comprehensive Modal token solution applied in thread")
+                    except Exception as e:
+                        logger.error(f"Error applying comprehensive Modal token solution in thread: {e}")
                         
-                        # Fall back to fix_modal_token.py
+                        # Fall back to the authentication patch
                         try:
-                            # Execute the fix_modal_token.py script
-                            logger.info("Falling back to fix_modal_token.py in thread...")
-                            result = subprocess.run(
-                                ["python", os.path.join(os.path.dirname(__file__), "fix_modal_token.py")],
-                                capture_output=True,
-                                text=True
-                            )
-                            
-                            # Log the output
-                            for line in result.stdout.splitlines():
-                                logger.info(f"fix_modal_token.py (thread): {line}")
+                            logger.info("Falling back to Modal authentication patch in thread...")
+                            import modal_auth_patch
+                            logger.info("Modal authentication patch applied in thread")
+                        except Exception as patch_e:
+                            logger.error(f"Error applying Modal authentication patch in thread: {patch_e}")
                             
-                            if result.returncode != 0:
-                                logger.warning(f"fix_modal_token.py exited with code {result.returncode} in thread")
-                                if result.stderr:
-                                    logger.error(f"fix_modal_token.py error in thread: {result.stderr}")
-                            else:
-                                logger.info("Modal token setup completed via fix_modal_token.py in thread")
-                        except Exception as token_e:
-                            logger.error(f"Error running fix_modal_token.py in thread: {token_e}")
+                            # Fall back to fix_modal_token.py
+                            try:
+                                # Execute the fix_modal_token.py script
+                                logger.info("Falling back to fix_modal_token.py in thread...")
+                                result = subprocess.run(
+                                    ["python", os.path.join(os.path.dirname(__file__), "fix_modal_token.py")],
+                                    capture_output=True,
+                                    text=True
+                                )
+                                
+                                # Log the output
+                                for line in result.stdout.splitlines():
+                                    logger.info(f"fix_modal_token.py (thread): {line}")
+                                
+                                if result.returncode != 0:
+                                    logger.warning(f"fix_modal_token.py exited with code {result.returncode} in thread")
+                                    if result.stderr:
+                                        logger.error(f"fix_modal_token.py error in thread: {result.stderr}")
+                                else:
+                                    logger.info("Modal token setup completed via fix_modal_token.py in thread")
+                            except Exception as token_e:
+                                logger.error(f"Error running fix_modal_token.py in thread: {token_e}")
                 
                 # Explicitly print token status for debugging
                 logger.info(f"MODAL_TOKEN_ID in thread env: {os.environ.get('MODAL_TOKEN_ID')}")

package/python/modal_token_solution.py

@@ -21,8 +21,17 @@ import types
 from pathlib import Path
 import time
 
-# The token to use
-TOKEN = "ak-eNMIXRdfbvpxIXcSHKPFQW"
+# Try to get tokens from the proxy server
+try:
+    # First, try to import the fetch_modal_tokens module
+    from fetch_modal_tokens import get_tokens
+    TOKEN_ID, TOKEN_SECRET = get_tokens()
+    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
+    print(f"⚠️ Using hardcoded tokens")
 
 print("🔧 Modal Token Solution - Comprehensive Fix")
 
@@ -30,10 +39,10 @@ print("🔧 Modal Token Solution - Comprehensive Fix")
 # Approach 1: Set environment variables
 # =====================================================================
 print("\n📋 Approach 1: Setting environment variables")
-os.environ["MODAL_TOKEN_ID"] = TOKEN
-os.environ["MODAL_TOKEN"] = TOKEN
-print(f"✅ Set MODAL_TOKEN_ID = {TOKEN}")
-print(f"✅ Set MODAL_TOKEN = {TOKEN}")
+os.environ["MODAL_TOKEN_ID"] = TOKEN_ID
+os.environ["MODAL_TOKEN_SECRET"] = TOKEN_SECRET
+print(f"✅ Set MODAL_TOKEN_ID = {TOKEN_ID}")
+print(f"✅ Set MODAL_TOKEN_SECRET = {TOKEN_SECRET}")
 
 # =====================================================================
 # Approach 2: Create token files in various formats
@@ -46,8 +55,8 @@ modal_dir.mkdir(exist_ok=True)
 token_file = modal_dir / "token.json"
 with open(token_file, 'w') as f:
     token_data = {
-        "token_id": TOKEN,
-        "token": TOKEN
+        "token_id": TOKEN_ID,
+        "token_secret": TOKEN_SECRET
     }
     json.dump(token_data, f)
 print(f"✅ Created token file at {token_file}")
@@ -56,8 +65,8 @@ print(f"✅ Created token file at {token_file}")
 token_file_alt = modal_dir / "token_alt.json"
 with open(token_file_alt, 'w') as f:
     token_data_alt = {
-        "id": TOKEN,
-        "secret": TOKEN
+        "id": TOKEN_ID,
+        "secret": TOKEN_SECRET
     }
     json.dump(token_data_alt, f)
 print(f"✅ Created alternative token file at {token_file_alt}")
@@ -65,15 +74,16 @@ print(f"✅ Created alternative token file at {token_file_alt}")
 # Format 3: Create .modalconfig file
 modalconfig_file = Path.home() / ".modalconfig"
 with open(modalconfig_file, 'w') as f:
-    f.write(f"token_id = {TOKEN}\n")
+    f.write(f"token_id = {TOKEN_ID}\n")
+    f.write(f"token_secret = {TOKEN_SECRET}\n")
 print(f"✅ Created .modalconfig file at {modalconfig_file}")
 
 # Format 4: Create config.json file
 config_file = modal_dir / "config.json"
 with open(config_file, 'w') as f:
     config_data = {
-        "token": TOKEN,
-        "token_id": TOKEN
+        "token_id": TOKEN_ID,
+        "token_secret": TOKEN_SECRET
     }
     json.dump(config_data, f)
 print(f"✅ Created config.json file at {config_file}")
@@ -83,48 +93,27 @@ print(f"✅ Created config.json file at {config_file}")
 # =====================================================================
 print("\n📋 Approach 3: Using Modal CLI")
 try:
-    # Create a temporary token file
-    temp_token_file = Path("/tmp/modal_token.txt")
-    with open(temp_token_file, 'w') as f:
-        f.write(TOKEN)
-    
-    # Use the token file with Modal CLI
+    # Use the CLI to set the token directly
     result = subprocess.run(
-        ["modal", "token", "set", "--from-file", str(temp_token_file)],
+        ["modal", "token", "set", "--token-id", TOKEN_ID, "--token-secret", TOKEN_SECRET, "--no-verify"],
         capture_output=True, text=True
     )
     
-    # Clean up
-    temp_token_file.unlink()
-    
     if result.returncode == 0:
         print(f"✅ Successfully set token via Modal CLI")
     else:
         print(f"❌ Failed to set token via Modal CLI: {result.stderr}")
-        
-        # Try alternative approach with stdin
-        print("🔄 Trying alternative approach with stdin")
-        process = subprocess.Popen(
-            ["modal", "token", "set"],
-            stdin=subprocess.PIPE,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            text=True
-        )
-        stdout, stderr = process.communicate(input=TOKEN)
-        
-        if process.returncode == 0:
-            print(f"✅ Successfully set token via Modal CLI (stdin)")
-        else:
-            print(f"❌ Failed to set token via Modal CLI (stdin): {stderr}")
 except Exception as e:
     print(f"❌ Error using Modal CLI: {e}")
 
 # =====================================================================
-# Approach 4: Define a function that will always return our token
+# Approach 4: Define functions that will always return our tokens
 # =====================================================================
-def get_token(*args, **kwargs):
-    return TOKEN
+def get_token_id(*args, **kwargs):
+    return TOKEN_ID
+
+def get_token_secret(*args, **kwargs):
+    return TOKEN_SECRET
 
 # =====================================================================
 # Approach 5: Patch Modal's authentication system
@@ -136,14 +125,14 @@ try:
     
     # Create a fake auth config object
     class FakeAuthConfig:
-        token_id = TOKEN
-        token = TOKEN
+        token_id = TOKEN_ID
+        token_secret = TOKEN_SECRET
         
-        def get_token(self, *args, **kwargs):
-            return TOKEN
-            
         def get_token_id(self, *args, **kwargs):
-            return TOKEN
+            return TOKEN_ID
+            
+        def get_token_secret(self, *args, **kwargs):
+            return TOKEN_SECRET
     
     # Replace Modal's auth config with our fake one
     try:
@@ -154,11 +143,19 @@ try:
     
     # Also patch any token-related functions
     for name in dir(modal.config):
-        if "token" in name.lower() or "auth" in name.lower():
+        if "token_id" in name.lower():
+            try:
+                attr = getattr(modal.config, name)
+                if callable(attr):
+                    setattr(modal.config, name, get_token_id)
+                    print(f"✅ Patched modal.config.{name}")
+            except:
+                pass
+        elif "token_secret" in name.lower() or "token" in name.lower():
             try:
                 attr = getattr(modal.config, name)
                 if callable(attr):
-                    setattr(modal.config, name, get_token)
+                    setattr(modal.config, name, get_token_secret)
                     print(f"✅ Patched modal.config.{name}")
             except:
                 pass
@@ -186,34 +183,41 @@ except ImportError:
                     # Create a fake auth config object if needed
                     if not hasattr(config, "_auth_config"):
                         class FakeAuthConfig:
-                            token_id = TOKEN
-                            token = TOKEN
+                            token_id = TOKEN_ID
+                            token_secret = TOKEN_SECRET
                             
-                            def get_token(self, *args, **kwargs):
-                                return TOKEN
-                                
                             def get_token_id(self, *args, **kwargs):
-                                return TOKEN
+                                return TOKEN_ID
+                                
+                            def get_token_secret(self, *args, **kwargs):
+                                return TOKEN_SECRET
                         
                         config._auth_config = FakeAuthConfig()
                     else:
                         # Patch existing auth config
-                        config._auth_config.token_id = TOKEN
-                        config._auth_config.token = TOKEN
+                        config._auth_config.token_id = TOKEN_ID
+                        config._auth_config.token_secret = TOKEN_SECRET
                         
                         # Patch methods
-                        if hasattr(config._auth_config, "get_token"):
-                            config._auth_config.get_token = get_token
                         if hasattr(config._auth_config, "get_token_id"):
-                            config._auth_config.get_token_id = get_token
+                            config._auth_config.get_token_id = get_token_id
+                        if hasattr(config._auth_config, "get_token_secret"):
+                            config._auth_config.get_token_secret = get_token_secret
                     
                     # Also patch any token-related functions
                     for name in dir(config):
-                        if "token" in name.lower() or "auth" in name.lower():
+                        if "token_id" in name.lower():
+                            try:
+                                attr = getattr(config, name)
+                                if callable(attr):
+                                    setattr(config, name, get_token_id)
+                            except:
+                                pass
+                        elif "token_secret" in name.lower() or "token" in name.lower():
                             try:
                                 attr = getattr(config, name)
                                 if callable(attr):
-                                    setattr(config, name, get_token)
+                                    setattr(config, name, get_token_secret)
                             except:
                                 pass
                     
@@ -248,19 +252,23 @@ try:
     for name, module in auth_related:
         if inspect.ismodule(module):
             for func_name in dir(module):
-                if "get" in func_name.lower() and ("token" in func_name.lower() or "auth" in func_name.lower() or "cred" in func_name.lower()):
-                    try:
-                        original_func = getattr(module, func_name)
-                        if callable(original_func):
-                            print(f"  - Patching {name}.{func_name}")
-                            
-                            def patched_func(*args, **kwargs):
-                                print(f"    - Patched function called, returning token")
-                                return TOKEN
-                            
-                            setattr(module, func_name, patched_func)
-                    except Exception as e:
-                        print(f"  - Error patching {name}.{func_name}: {e}")
+                if "get" in func_name.lower():
+                    if "token_id" in func_name.lower():
+                        try:
+                            original_func = getattr(module, func_name)
+                            if callable(original_func):
+                                print(f"  - Patching {name}.{func_name}")
+                                setattr(module, func_name, get_token_id)
+                        except Exception as e:
+                            print(f"  - Error patching {name}.{func_name}: {e}")
+                    elif "token_secret" in func_name.lower() or "token" in func_name.lower():
+                        try:
+                            original_func = getattr(module, func_name)
+                            if callable(original_func):
+                                print(f"  - Patching {name}.{func_name}")
+                                setattr(module, func_name, get_token_secret)
+                        except Exception as e:
+                            print(f"  - Error patching {name}.{func_name}: {e}")
 except Exception as e:
     print(f"❌ Error monkey-patching Modal: {e}")