gitarsenal-cli 1.3.6 → 1.3.7

package/package.json

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

package/python/fetch_modal_tokens.py

@@ -41,12 +41,12 @@ def fetch_tokens_from_proxy(proxy_url=None, api_key=None):
     # Check if we have the necessary information
     if not proxy_url:
         print("❌ No proxy URL provided or found in environment")
-        print("💡 Set MODAL_PROXY_URL environment variable or use --proxy-url argument")
+        # print("💡 Set MODAL_PROXY_URL environment variable or use --proxy-url argument")
         return None, None
         
     if not api_key:
         print("❌ No API key provided or found in environment")
-        print("💡 Set MODAL_PROXY_API_KEY environment variable or use --proxy-api-key argument")
+        # print("💡 Set MODAL_PROXY_API_KEY environment variable or use --proxy-api-key argument")
         return None, None
     
     # Ensure the URL ends with a slash
@@ -103,7 +103,7 @@ def get_tokens():
     # Set the tokens in environment variables
     os.environ["MODAL_TOKEN_ID"] = token_id
     os.environ["MODAL_TOKEN_SECRET"] = token_secret
-    print(f"✅ Set MODAL_TOKEN_ID and MODAL_TOKEN_SECRET environment variables")
+    # print(f"✅ Set MODAL_TOKEN_ID and MODAL_TOKEN_SECRET environment variables")
     
     return token_id, token_secret
 
@@ -119,25 +119,25 @@ if __name__ == "__main__":
     # Set proxy URL and API key in environment variables if provided
     if args.proxy_url:
         os.environ["MODAL_PROXY_URL"] = args.proxy_url
-        print(f"✅ Set MODAL_PROXY_URL from command line")
+        # print(f"✅ Set MODAL_PROXY_URL from command line")
     
     if args.proxy_api_key:
         os.environ["MODAL_PROXY_API_KEY"] = args.proxy_api_key
-        print(f"✅ Set MODAL_PROXY_API_KEY from command line")
+        # print(f"✅ Set MODAL_PROXY_API_KEY from command line")
     
     # Get tokens
     token_id, token_secret = get_tokens()
-    print(f"Token ID: [HIDDEN]")
-    print(f"Token Secret: [HIDDEN]")
-    
-    # Check if tokens are set in environment variables
-    print(f"\n🔍 DEBUG: Checking environment variables")
-    print(f"🔍 MODAL_TOKEN_ID exists: {'Yes' if os.environ.get('MODAL_TOKEN_ID') else 'No'}")
-    print(f"🔍 MODAL_TOKEN_SECRET exists: {'Yes' if os.environ.get('MODAL_TOKEN_SECRET') else 'No'}")
-    if os.environ.get('MODAL_TOKEN_ID'):
-        print(f"🔍 MODAL_TOKEN_ID length: {len(os.environ.get('MODAL_TOKEN_ID'))}")
-    if os.environ.get('MODAL_TOKEN_SECRET'):
-        print(f"🔍 MODAL_TOKEN_SECRET length: {len(os.environ.get('MODAL_TOKEN_SECRET'))}")
+    # print(f"Token ID: [HIDDEN]")
+    # print(f"Token Secret: [HIDDEN]")
+    
+    # # Check if tokens are set in environment variables
+    # print(f"\n🔍 DEBUG: Checking environment variables")
+    # print(f"🔍 MODAL_TOKEN_ID exists: {'Yes' if os.environ.get('MODAL_TOKEN_ID') else 'No'}")
+    # print(f"🔍 MODAL_TOKEN_SECRET exists: {'Yes' if os.environ.get('MODAL_TOKEN_SECRET') else 'No'}")
+    # if os.environ.get('MODAL_TOKEN_ID'):
+    #     print(f"🔍 MODAL_TOKEN_ID length: {len(os.environ.get('MODAL_TOKEN_ID'))}")
+    # if os.environ.get('MODAL_TOKEN_SECRET'):
+    #     print(f"🔍 MODAL_TOKEN_SECRET length: {len(os.environ.get('MODAL_TOKEN_SECRET'))}")
     
     # Write the tokens to a file for use by other scripts
     tokens_file = Path(__file__).parent / "modal_tokens.json"

package/python/fix_modal_token_advanced.py

@@ -24,24 +24,22 @@ 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")
+    # 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 default tokens")
+    # print(f"⚠️ Using default tokens")
 
-print("🔧 Advanced Modal Token Fixer")
+# print("🔧 Advanced Modal Token Fixer")
 
 # Approach 1: Set environment variables
-print("\n📋 Approach 1: Setting environment variables")
+# print("\n📋 Approach 1: Setting environment variables")
 os.environ["MODAL_TOKEN_ID"] = TOKEN_ID
 os.environ["MODAL_TOKEN_SECRET"] = TOKEN_SECRET
-print(f"✅ Set MODAL_TOKEN_ID = [HIDDEN]")
-print(f"✅ Set MODAL_TOKEN_SECRET = [HIDDEN]")
+# print(f"✅ Set MODAL_TOKEN_ID = [HIDDEN]")
+# print(f"✅ Set MODAL_TOKEN_SECRET = [HIDDEN]")
 
 # Approach 2: Create token files in various formats
-print("\n📋 Approach 2: Creating token files in various formats")
+# print("\n📋 Approach 2: Creating token files in various formats")
 modal_dir = Path.home() / ".modal"
 modal_dir.mkdir(exist_ok=True)
 
@@ -53,7 +51,7 @@ with open(token_file, 'w') as f:
         "token_secret": TOKEN_SECRET
     }
     json.dump(token_data, f)
-print(f"✅ Created token file at {token_file}")
+# print(f"✅ Created token file at {token_file}")
 
 # Format 2: Alternative token.json format
 token_file_alt = modal_dir / "token_alt.json"
@@ -63,14 +61,14 @@ with open(token_file_alt, 'w') as f:
         "secret": TOKEN_SECRET
     }
     json.dump(token_data_alt, f)
-print(f"✅ Created alternative token file at {token_file_alt}")
+# 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_ID}\n")
     f.write(f"token_secret = {TOKEN_SECRET}\n")
-print(f"✅ Created .modalconfig file at {modalconfig_file}")
+# print(f"✅ Created .modalconfig file at {modalconfig_file}")
 
 # Format 4: Create config.json file
 config_file = modal_dir / "config.json"
@@ -80,10 +78,10 @@ with open(config_file, 'w') as f:
         "token_secret": TOKEN_SECRET
     }
     json.dump(config_data, f)
-print(f"✅ Created config.json file at {config_file}")
+# print(f"✅ Created config.json file at {config_file}")
 
 # Approach 3: Use Modal CLI to set token
-print("\n📋 Approach 3: Using Modal CLI")
+# print("\n📋 Approach 3: Using Modal CLI")
 try:
     # Use the CLI to set the token directly
     result = subprocess.run(
@@ -92,17 +90,17 @@ try:
     )
     
     if result.returncode == 0:
-        print(f"✅ Successfully set token via Modal CLI")
+        # print(f"✅ Successfully set token via Modal CLI")
     else:
-        print(f"❌ Failed to set token via Modal CLI: {result.stderr}")
+        # print(f"❌ Failed to set token via Modal CLI: {result.stderr}")
 except Exception as e:
-    print(f"❌ Error using Modal CLI: {e}")
+    # print(f"❌ Error using Modal CLI: {e}")
 
 # Approach 4: Use Modal Python API to set token
-print("\n📋 Approach 4: Using Modal Python API")
+# print("\n📋 Approach 4: Using Modal Python API")
 try:
     import modal
-    print(f"✅ Successfully imported Modal")
+    # print(f"✅ Successfully imported Modal")
     
     # Try to set token directly in Modal's config
     try:
@@ -114,49 +112,49 @@ try:
             if hasattr(modal.config, '_auth_config'):
                 modal.config._auth_config.token_id = TOKEN_ID
                 modal.config._auth_config.token_secret = TOKEN_SECRET
-                print(f"✅ Set tokens via _auth_config")
+                # print(f"✅ Set tokens via _auth_config")
         except Exception as e:
-            print(f"❌ Error setting tokens via _auth_config: {e}")
+            # print(f"❌ Error setting tokens via _auth_config: {e}")
             
         try:
             # Approach 4.2: Set token via set_token() if it exists
             if hasattr(modal.config, 'set_token'):
                 modal.config.set_token(TOKEN_ID, TOKEN_SECRET)
-                print(f"✅ Set tokens via set_token()")
+                # print(f"✅ Set tokens via set_token()")
         except Exception as e:
-            print(f"❌ Error setting tokens via set_token(): {e}")
+            # print(f"❌ Error setting tokens via set_token(): {e}")
             
         try:
             # Approach 4.3: Set token via Config
             if hasattr(modal.config, 'Config'):
                 modal.config.Config.token_id = TOKEN_ID
                 modal.config.Config.token_secret = TOKEN_SECRET
-                print(f"✅ Set tokens via Config")
+                # print(f"✅ Set tokens via Config")
         except Exception as e:
-            print(f"❌ Error setting tokens via Config: {e}")
+            # print(f"❌ Error setting tokens via Config: {e}")
             
         # Approach 4.4: Inspect modal.config and try to find token-related attributes
-        print("\n🔍 Inspecting modal.config for token-related attributes...")
+        # print("\n🔍 Inspecting modal.config for token-related attributes...")
         for name in dir(modal.config):
             if "token" in name.lower() or "auth" in name.lower():
-                print(f"Found potential token-related attribute: {name}")
+                # print(f"Found potential token-related attribute: {name}")
                 try:
                     attr = getattr(modal.config, name)
                     if hasattr(attr, "token_id"):
-                        print(f"  - Setting token_id in {name}")
+                        # print(f"  - Setting token_id in {name}")
                         setattr(attr, "token_id", TOKEN_ID)
                     if hasattr(attr, "token_secret"):
-                        print(f"  - Setting token_secret in {name}")
+                        # print(f"  - Setting token_secret in {name}")
                         setattr(attr, "token_secret", TOKEN_SECRET)
                 except Exception as e:
-                    print(f"  - Error setting tokens in {name}: {e}")
+                    # print(f"  - Error setting tokens in {name}: {e}")
     except Exception as e:
-        print(f"❌ Error setting tokens in Modal config: {e}")
+        # print(f"❌ Error setting tokens in Modal config: {e}")
 except Exception as e:
     print(f"❌ Error importing Modal: {e}")
 
 # Approach 5: Monkey-patch Modal's authentication system
-print("\n📋 Approach 5: Monkey-patching Modal's authentication system")
+# print("\n📋 Approach 5: Monkey-patching Modal's authentication system")
 try:
     import modal
     
@@ -174,7 +172,7 @@ try:
             try:
                 module = getattr(modal, module_name)
                 auth_related.append((module_name, module))
-                print(f"Found potential auth-related module: {module_name}")
+                # print(f"Found potential auth-related module: {module_name}")
             except Exception:
                 pass
     
@@ -187,25 +185,25 @@ try:
                         try:
                             original_func = getattr(module, func_name)
                             if callable(original_func):
-                                print(f"  - Patching {name}.{func_name} to return token_id")
+                                # print(f"  - Patching {name}.{func_name} to return token_id")
                                 setattr(module, func_name, get_token_id)
                         except Exception as e:
-                            print(f"  - Error patching {name}.{func_name}: {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} to return token_secret")
+                                # print(f"  - Patching {name}.{func_name} to return token_secret")
                                 setattr(module, func_name, get_token_secret)
                         except Exception as e:
-                            print(f"  - Error patching {name}.{func_name}: {e}")
+                            # print(f"  - Error patching {name}.{func_name}: {e}")
     
-    print(f"✅ Monkey-patching completed")
+    # print(f"✅ Monkey-patching completed")
 except Exception as e:
-    print(f"❌ Error during monkey-patching: {e}")
+    # print(f"❌ Error during monkey-patching: {e}")
 
 # Approach 6: Test Modal authentication
-print("\n📋 Approach 6: Testing Modal authentication")
+# print("\n📋 Approach 6: Testing Modal authentication")
 try:
     import modal
     
@@ -217,14 +215,14 @@ try:
         return "Hello, world!"
     
     # Try to run the function to test authentication
-    print("Creating a test Modal app...")
+    # print("Creating a test Modal app...")
     with app.run() as running_app:
-        print("Running the test function...")
+        # print("Running the test function...")
         result = running_app.hello.remote()
-        print(f"✅ Successfully ran Modal function: {result}")
-        print("🎉 Modal authentication is working!")
+        # print(f"✅ Successfully ran Modal function: {result}")
+        # print("🎉 Modal authentication is working!")
         
 except Exception as e:
-    print(f"❌ Error testing Modal authentication: {e}")
+    # print(f"❌ Error testing Modal authentication: {e}")
 
-print("\n✅ Done fixing Modal token. Please try your command again.") 
+# print("\n✅ Done fixing Modal token. Please try your command again.") 

package/python/test_modalSandboxScript.py

@@ -27,19 +27,19 @@ args, unknown = parser.parse_known_args()
 # Set proxy URL and API key in environment variables if provided
 if args.proxy_url:
     os.environ["MODAL_PROXY_URL"] = args.proxy_url
-    print(f"✅ Set MODAL_PROXY_URL from command line")
+    # print(f"✅ Set MODAL_PROXY_URL from command line")
     
 if args.proxy_api_key:
     os.environ["MODAL_PROXY_API_KEY"] = args.proxy_api_key
-    print(f"✅ Set MODAL_PROXY_API_KEY from command line")
+    # print(f"✅ Set MODAL_PROXY_API_KEY from command line")
 
 # First, try to fetch tokens from the proxy server
 try:
     # Import the fetch_modal_tokens module
-    print("🔄 Fetching tokens from proxy server...")
+    # print("🔄 Fetching tokens from proxy server...")
     from fetch_modal_tokens import get_tokens
     token_id, token_secret = get_tokens()
-    print(f"✅ Tokens fetched successfully")
+    # print(f"✅ Tokens fetched successfully")
     
     # Explicitly set the environment variables again to be sure
     os.environ["MODAL_TOKEN_ID"] = token_id
@@ -56,26 +56,26 @@ except Exception as e:
     # Apply the comprehensive Modal token solution as fallback
     try:
         # Import the comprehensive solution module
-        print("🔄 Applying comprehensive Modal token solution...")
+        # print("🔄 Applying comprehensive Modal token solution...")
         import modal_token_solution
-        print("✅ Comprehensive Modal token solution applied")
+        # print("✅ Comprehensive Modal token solution applied")
         
         # Set token variables for later use
         token = modal_token_solution.TOKEN_ID  # For backward compatibility
     except Exception as e:
-        print(f"⚠️ Error applying comprehensive Modal token solution: {e}")
+        # print(f"⚠️ Error applying comprehensive Modal token solution: {e}")
         
         # Fall back to the authentication patch
         try:
             # Import the patch module
-            print("🔄 Falling back to Modal authentication patch...")
+            # print("🔄 Falling back to Modal authentication patch...")
             import modal_auth_patch
-            print("✅ Modal authentication patch applied")
+            # print("✅ Modal authentication patch applied")
             
             # Set token variables for later use
             token = modal_auth_patch.TOKEN_ID  # For backward compatibility
         except Exception as e:
-            print(f"⚠️ Error applying Modal authentication patch: {e}")
+            # print(f"⚠️ Error applying Modal authentication patch: {e}")
             
             # Fall back to fix_modal_token.py
             try:
@@ -115,17 +115,17 @@ except Exception as e:
                 token = "ak-sLhYqCjkvixiYcb9LAuCHp"  # Default token ID
 
 # Print debug info
-print(f"🔍 DEBUG: Checking environment variables")
-print(f"🔍 Token ID exists: {'Yes' if os.environ.get('MODAL_TOKEN_ID') else 'No'}")
-print(f"🔍 Token secret exists: {'Yes' if os.environ.get('MODAL_TOKEN_SECRET') else 'No'}")
-print(f"🔍 Token exists: {'Yes' if os.environ.get('MODAL_TOKEN') else 'No'}")
-if os.environ.get('MODAL_TOKEN_ID'):
-    print(f"🔍 Token ID length: {len(os.environ.get('MODAL_TOKEN_ID'))}")
-if os.environ.get('MODAL_TOKEN_SECRET'):
-    print(f"🔍 Token secret length: {len(os.environ.get('MODAL_TOKEN_SECRET'))}")
-if os.environ.get('MODAL_TOKEN'):
-    print(f"🔍 Token length: {len(os.environ.get('MODAL_TOKEN'))}")
-print(f"✅ Token setup completed")
+# print(f"🔍 DEBUG: Checking environment variables")
+# print(f"🔍 Token ID exists: {'Yes' if os.environ.get('MODAL_TOKEN_ID') else 'No'}")
+# print(f"🔍 Token secret exists: {'Yes' if os.environ.get('MODAL_TOKEN_SECRET') else 'No'}")
+# print(f"🔍 Token exists: {'Yes' if os.environ.get('MODAL_TOKEN') else 'No'}")
+# if os.environ.get('MODAL_TOKEN_ID'):
+#     print(f"🔍 Token ID length: {len(os.environ.get('MODAL_TOKEN_ID'))}")
+# if os.environ.get('MODAL_TOKEN_SECRET'):
+#     print(f"🔍 Token secret length: {len(os.environ.get('MODAL_TOKEN_SECRET'))}")
+# if os.environ.get('MODAL_TOKEN'):
+#     print(f"🔍 Token length: {len(os.environ.get('MODAL_TOKEN'))}")
+# print(f"✅ Token setup completed")
 
 # Import modal after token setup
 import modal
@@ -2025,7 +2025,7 @@ cd "{current_dir}"
     print("⏳ Sandbox will remain running until you terminate it with:")
     print(f"modal sandbox terminate {sandbox_id}")
 
-    # Try to open a new terminal window and connect to the container
+    # Try to open a new terminal window and connect to the containera
     if container_id:
         print("🖥️ Attempting to open new terminal window...")
         # Use osascript to open a new terminal with the modal shell command
@@ -2618,32 +2618,44 @@ def fetch_setup_commands_from_api(repo_url):
             else:
                 print(f"✅ GitIngest analysis completed successfully")
                 
-                # Read the output file - note that the default format might not be JSON
+                # Read the output file - GitIngest outputs structured text, not JSON
                 try:
-                    # First try to parse as JSON
-                    try:
-                        with open(output_file, 'r', encoding='utf-8') as f:
-                            content = f.read()
-                            try:
-                                gitingest_data = json.loads(content)
-                                print(f"✅ GitIngest data loaded as JSON from {output_file}")
-                            except json.JSONDecodeError:
-                                # If not JSON, convert the text output to a basic structure
-                                print(f"⚠️ GitIngest output is not in JSON format, converting text to structure")
-                                gitingest_data = {
-                                    "system_info": {
-                                        "detected_language": "Unknown",
-                                        "detected_technologies": [],
-                                    },
-                                    "repository_analysis": {
-                                        "summary": content[:5000],  # First 5000 chars as summary
-                                        "content_preview": content[:10000]  # First 10000 chars as preview
-                                    },
-                                    "success": True
-                                }
-                    except FileNotFoundError:
-                        print(f"⚠️ Output file not found at {output_file}")
-                        gitingest_data = generate_basic_repo_analysis_from_url(repo_url)
+                    with open(output_file, 'r', encoding='utf-8') as f:
+                        content = f.read()
+                    
+                    # Process the text output into a structured format
+                    print(f"📄 Processing GitIngest text output")
+                    
+                    # Extract key information from the text output
+                    import re
+                    
+                    # Try to identify language
+                    language_match = re.search(r"(?i)language[s]?:?\s*(\w+)", content)
+                    detected_language = language_match.group(1) if language_match else "Unknown"
+                    
+                    # Try to identify technologies
+                    tech_matches = re.findall(r"(?i)(python|javascript|typescript|react|node|vue|angular|django|flask|express|pytorch|tensorflow|rust|go|ruby|rails|php|laravel|c\+\+|java|kotlin|swift)", content)
+                    detected_technologies = list(set(tech_matches)) if tech_matches else []
+                    
+                    # Create a structured representation
+                    gitingest_data = {
+                        "system_info": {
+                            "detected_language": detected_language,
+                            "detected_technologies": detected_technologies,
+                        },
+                        "repository_analysis": {
+                            "summary": content[:1000],  # First 1000 chars as summary
+                            "content_preview": content[:5000]  # First 5000 chars as preview
+                        },
+                        "raw_text": content[:10000],  # Include a portion of the raw text
+                        "success": True
+                    }
+                    
+                    print(f"📄 Processed GitIngest output: Detected language: {detected_language}, Technologies: {', '.join(detected_technologies) if detected_technologies else 'None'}")
+                    
+                except FileNotFoundError:
+                    print(f"⚠️ Output file not found at {output_file}")
+                    gitingest_data = generate_basic_repo_analysis_from_url(repo_url)
                 except Exception as e:
                     print(f"⚠️ Error reading GitIngest output: {e}")
                     gitingest_data = generate_basic_repo_analysis_from_url(repo_url)
@@ -2660,10 +2672,10 @@ def fetch_setup_commands_from_api(repo_url):
         
         print(f"📤 API Request payload prepared (GitIngest data size: {len(json.dumps(gitingest_data))} bytes)")
         
-        # Make the API request
+        # Make the API request with a shorter timeout to avoid long waits
         print(f"🌐 Making POST request to: {api_url}")
         try:
-            response = requests.post(api_url, json=payload, timeout=60)
+            response = requests.post(api_url, json=payload, timeout=30)  # Reduced timeout to 30 seconds
             
             print(f"📥 API Response status code: {response.status_code}")
             
@@ -2708,43 +2720,68 @@ def fetch_setup_commands_from_api(repo_url):
                         print("📋 Available fields in response:")
                         for key in data.keys():
                             print(f"  - {key}")
-                        # Return fallback commands
-                        return generate_fallback_commands(gitingest_data)
-                except json.JSONDecodeError as e:
-                    print(f"❌ Failed to parse API response as JSON: {e}")
-                    print(f"Raw response: {response.text[:500]}...")
-                    # Return fallback commands
-                    return generate_fallback_commands(gitingest_data)
+                        
+                        # Generate fallback commands based on the gitingest data
+                        print("\n" + "="*80)
+                        print("📋 GENERATING FALLBACK SETUP COMMANDS")
+                        print("="*80)
+                        fallback_commands = generate_fallback_commands(gitingest_data)
+                        return fallback_commands
+                except Exception as e:
+                    print(f"⚠️ Error parsing API response: {e}")
             elif response.status_code == 504:
                 print(f"❌ API request timed out (504 Gateway Timeout)")
-                print("⚠️ The server took too long to respond. Using fallback commands instead.")
-                # Return fallback commands
-                return generate_fallback_commands(gitingest_data)
+                print(f"⚠️ The server took too long to respond. Using fallback commands instead.")
+                
+                # Generate fallback commands based on the gitingest data
+                print("\n" + "="*80)
+                print("📋 GENERATING FALLBACK SETUP COMMANDS")
+                print("="*80)
+                fallback_commands = generate_fallback_commands(gitingest_data)
+                return fallback_commands
             else:
-                print(f"❌ API request failed with status code: {response.status_code}")
-                print(f"Error response: {response.text[:500]}...")
-                # Return fallback commands
-                return generate_fallback_commands(gitingest_data)
+                print(f"❌ API request failed with status code {response.status_code}")
+                print(f"Response: {response.text[:500]}")
+                
+                # Generate fallback commands based on the gitingest data
+                print("\n" + "="*80)
+                print("📋 GENERATING FALLBACK SETUP COMMANDS")
+                print("="*80)
+                fallback_commands = generate_fallback_commands(gitingest_data)
+                return fallback_commands
         except requests.exceptions.Timeout:
-            print("❌ API request timed out after 60 seconds")
-            print("⚠️ Using fallback commands instead")
-            # Return fallback commands
-            return generate_fallback_commands(gitingest_data)
-        except requests.exceptions.ConnectionError:
-            print(f"❌ Connection error: Could not connect to {api_url}")
-            print("⚠️ Using fallback commands instead")
-            # Return fallback commands
-            return generate_fallback_commands(gitingest_data)
-    except Exception as e:
-        print(f"❌ Error fetching setup commands from API: {e}")
-        import traceback
-        traceback.print_exc()
-        # Return fallback commands
-        return generate_fallback_commands(None)
+            print(f"❌ API request timed out after 30 seconds")
+            print(f"⚠️ The server took too long to respond. Using fallback commands instead.")
+            
+            # Generate fallback commands based on the gitingest data
+            print("\n" + "="*80)
+            print("📋 GENERATING FALLBACK SETUP COMMANDS")
+            print("="*80)
+            fallback_commands = generate_fallback_commands(gitingest_data)
+            return fallback_commands
+        except Exception as e:
+            print(f"❌ Error making API request: {e}")
+            
+            # Generate fallback commands based on the gitingest data
+            print("\n" + "="*80)
+            print("📋 GENERATING FALLBACK SETUP COMMANDS")
+            print("="*80)
+            fallback_commands = generate_fallback_commands(gitingest_data)
+            return fallback_commands
     finally:
-        # Clean up the temporary directory
+        # Clean up temporary directory
         print(f"🧹 Cleaning up temporary directory...")
-        shutil.rmtree(temp_dir, ignore_errors=True)
+        try:
+            shutil.rmtree(temp_dir)
+        except Exception as e:
+            print(f"⚠️ Error cleaning up temporary directory: {e}")
+    
+    # If all else fails, return basic setup commands
+    return [
+        "apt-get update -y",
+        "apt-get install -y git curl wget",
+        "pip install --upgrade pip setuptools wheel"
+    ]
 
 def generate_fallback_commands(gitingest_data):
     """Generate fallback setup commands based on repository analysis"""
@@ -3309,24 +3346,24 @@ def cleanup_modal_token():
         # Remove token from environment variables
         if "MODAL_TOKEN_ID" in os.environ:
             del os.environ["MODAL_TOKEN_ID"]
-            print("✅ Removed token ID from environment")
+            # print("✅ Removed token ID from environment")
         
         if "MODAL_TOKEN" in os.environ:
             del os.environ["MODAL_TOKEN"]
-            print("✅ Removed token from environment")
+            # print("✅ Removed token from environment")
             
         if "MODAL_TOKEN_SECRET" in os.environ:
             del os.environ["MODAL_TOKEN_SECRET"]
-            print("✅ Removed token secret from environment")
+            # print("✅ Removed token secret from environment")
         
         # Delete ~/.modal.toml file
         home_dir = os.path.expanduser("~")
         modal_toml = os.path.join(home_dir, ".modal.toml")
         if os.path.exists(modal_toml):
             os.remove(modal_toml)
-            print(f"✅ Deleted token file at {modal_toml}")
+            # print(f"✅ Deleted token file at {modal_toml}")
         
-        print("✅ Token cleanup completed successfully")
+        # print("✅ Token cleanup completed successfully")
     except Exception as e:
         print(f"❌ Error during token cleanup: {e}")
 
@@ -3492,12 +3529,12 @@ if __name__ == "__main__":
             ssh_password=ssh_password
         )
     except KeyboardInterrupt:
-        print("\n\n🛑 Execution interrupted")
-        print("🧹 Cleaning up resources...")
+        # print("\n\n🛑 Execution interrupted")
+        # print("🧹 Cleaning up resources...")
         cleanup_modal_token()
         sys.exit(1)
     except Exception as e:
-        print(f"\n❌ Error: {e}")
-        print("🧹 Cleaning up resources...")
+        # print(f"\n❌ Error: {e}")
+        # print("🧹 Cleaning up resources...")
         cleanup_modal_token()
         sys.exit(1)

package/python/emoji_fix_patch.py

@@ -1,79 +0,0 @@
-#!/usr/bin/env python3
-"""
-This script removes emojis from the test_modalSandboxScript.py file to fix syntax errors.
-"""
-
-import re
-import sys
-import shutil
-from pathlib import Path
-
-def remove_emojis(script_path):
-    """
-    Remove emojis from the Python script to fix syntax errors.
-    """
-    print(f"Removing emojis from {script_path}...")
-    
-    # Make a backup of the original file
-    backup_path = f"{script_path}.emoji_backup"
-    shutil.copy2(script_path, backup_path)
-    
-    # Read the file
-    with open(script_path, 'r', encoding='utf-8', errors='ignore') as f:
-        content = f.read()
-    
-    # Emoji pattern - matches most common emoji characters
-    emoji_pattern = re.compile(
-        "["
-        "\U0001F1E0-\U0001F1FF"  # flags (iOS)
-        "\U0001F300-\U0001F5FF"  # symbols & pictographs
-        "\U0001F600-\U0001F64F"  # emoticons
-        "\U0001F680-\U0001F6FF"  # transport & map symbols
-        "\U0001F700-\U0001F77F"  # alchemical symbols
-        "\U0001F780-\U0001F7FF"  # Geometric Shapes
-        "\U0001F800-\U0001F8FF"  # Supplemental Arrows-C
-        "\U0001F900-\U0001F9FF"  # Supplemental Symbols and Pictographs
-        "\U0001FA00-\U0001FA6F"  # Chess Symbols
-        "\U0001FA70-\U0001FAFF"  # Symbols and Pictographs Extended-A
-        "\U00002702-\U000027B0"  # Dingbats
-        "\U000024C2-\U0001F251" 
-        "]+", flags=re.UNICODE)
-    
-    # Simply remove all emojis
-    content = emoji_pattern.sub('', content)
-    
-    # Fix common syntax issues after emoji removal
-    content = re.sub(r'print\(\s*\)', r'print()', content)
-    content = re.sub(r'print\(\s*"', r'print("', content)
-    
-    # Fix specific syntax errors
-    content = re.sub(r'print\(\s*container\'s', r'print("container\'s', content)
-    
-    # Write the modified content back to the file
-    with open(script_path, 'w', encoding='utf-8') as f:
-        f.write(content)
-    
-    print(f"Emoji removal complete. Original file backed up to {backup_path}")
-    return True
-
-def main():
-    """
-    Main entry point for the script.
-    """
-    # Get the path to the script
-    script_dir = Path(__file__).parent
-    script_path = script_dir / "test_modalSandboxScript.py"
-    
-    if not script_path.exists():
-        print(f"Error: Script not found at {script_path}")
-        return 1
-    
-    try:
-        remove_emojis(script_path)
-        return 0
-    except Exception as e:
-        print(f"Error removing emojis: {e}")
-        return 1
-
-if __name__ == "__main__":
-    sys.exit(main())