Update app.py

app.py

@@ -3,18 +3,27 @@ import subprocess
 import tempfile
 import shutil
 import re
+import logging
 from flask import Flask, request, send_file, jsonify
 from werkzeug.utils import secure_filename
 
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
 app = Flask(__name__)
 
 # Configuration
-app.config['MAX_CONTENT_LENGTH'] = 1 * 1024 * 1024  # 1MB max upload size
-app.config['ALLOWED_HOSTS'] = ['https://huggingface.co/spaces/sudo-soldier/']  # Add your production domain
-app.config['BUBBLEWRAP_MIN_VERSION'] = '1.0.0'  # Minimum required version
+app.config['MAX_CONTENT_LENGTH'] = 1 * 1024 * 1024  # 1MB max
+app.config['ALLOWED_EXTENSIONS'] = {'png', 'jpg', 'jpeg'}
+app.config['TEMP_DIR'] = '/tmp/pwa2apk'  # Using system temp directory
+app.config['BUBBLEWRAP_MIN_VERSION'] = '1.0.0'
+
+# Ensure temp directory exists
+os.makedirs(app.config['TEMP_DIR'], exist_ok=True)
 
-# Validate URL format
 def is_valid_url(url):
+    """Validate URL format using regex"""
     regex = re.compile(
         r'^(https?://)?'  # http:// or https://
         r'([a-zA-Z0-9-]+\.)+[a-zA-Z]{2,}'  # domain
@@ -23,103 +32,114 @@ def is_valid_url(url):
     )
     return re.match(regex, url) is not None
 
-# Check if bubblewrap is available
 def check_bubblewrap():
+    """Verify bubblewrap is installed and meets version requirements"""
     try:
-        result = subprocess.run(['bubblewrap', '--version'], 
-                              capture_output=True, text=True, check=True)
+        result = subprocess.run(
+            ['bubblewrap', '--version'],
+            capture_output=True,
+            text=True,
+            check=True
+        )
         version = result.stdout.strip()
-        if version < app.config['BUBBLEWRAP_MIN_VERSION']:
-            raise Exception(f"Bubblewrap version {version} is below minimum required version")
+        logger.info(f"Bubblewrap version detected: {version}")
         return True
     except Exception as e:
-        app.logger.error(f"Bubblewrap check failed: {str(e)}")
+        logger.error(f"Bubblewrap check failed: {str(e)}")
         return False
 
-# Clean up directory
 def cleanup_directory(dir_path):
+    """Safely remove temporary directory"""
     try:
         if os.path.exists(dir_path):
             shutil.rmtree(dir_path)
+            logger.info(f"Cleaned up directory: {dir_path}")
     except Exception as e:
-        app.logger.error(f"Cleanup failed for {dir_path}: {str(e)}")
-
-@app.route("/generate-apk", methods=["POST"])
-def generate_apk():
-    # Validate request
-    if 'url' not in request.form:
-        return jsonify({"error": "URL parameter is required"}), 400
-    
-    pwa_url = request.form['url'].strip()
-    
-    if not is_valid_url(pwa_url):
-        return jsonify({"error": "Invalid URL format"}), 400
+        logger.error(f"Cleanup failed for {dir_path}: {str(e)}")
 
-    # Create temp directory
-    temp_dir = tempfile.mkdtemp(prefix='pwa2apk_')
-    os.chdir(temp_dir)  # Work in temp directory
-    
+def generate_apk_internal(pwa_url, output_dir):
+    """Core APK generation logic"""
     try:
         # Initialize project
         init_cmd = [
             'bubblewrap', 'init',
             '--manifest', pwa_url,
-            '--directory', temp_dir,
+            '--directory', output_dir,
             '--non-interactive'
         ]
-        
-        subprocess.run(init_cmd, check=True, timeout=300, 
-                      stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-        
+        subprocess.run(init_cmd, check=True, timeout=300)
+
         # Build APK
         build_cmd = ['bubblewrap', 'build']
-        subprocess.run(build_cmd, check=True, timeout=600, 
-                      stdout=subprocess.PIPE, stderr=subprocess.PIPE)
-        
+        subprocess.run(build_cmd, cwd=output_dir, check=True, timeout=600)
+
         # Verify APK was created
-        apk_path = os.path.join(temp_dir, 'app-release.apk')
+        apk_path = os.path.join(output_dir, 'app-release.apk')
         if not os.path.exists(apk_path):
-            raise Exception("APK file not found after build")
+            raise FileNotFoundError("APK file not found after build")
+        
+        return apk_path
+
+    except subprocess.TimeoutExpired as e:
+        logger.error(f"Build timed out: {str(e)}")
+        raise
+    except subprocess.CalledProcessError as e:
+        logger.error(f"Build failed with code {e.returncode}: {e.stderr}")
+        raise
+    except Exception as e:
+        logger.error(f"Unexpected error: {str(e)}")
+        raise
+
+@app.route('/health', methods=['GET'])
+def health_check():
+    """Health check endpoint"""
+    return jsonify({'status': 'healthy', 'bubblewrap': check_bubblewrap()})
+
+@app.route("/generate-apk", methods=["POST"])
+def generate_apk():
+    """Main APK generation endpoint"""
+    if not check_bubblewrap():
+        return jsonify({"error": "Bubblewrap not available"}), 503
+
+    if 'url' not in request.form:
+        return jsonify({"error": "URL parameter is required"}), 400
+
+    pwa_url = request.form['url'].strip()
+    if not is_valid_url(pwa_url):
+        return jsonify({"error": "Invalid URL format"}), 400
+
+    # Create unique temp directory
+    temp_dir = tempfile.mkdtemp(dir=app.config['TEMP_DIR'])
+    logger.info(f"Created temp directory: {temp_dir}")
+
+    try:
+        apk_path = generate_apk_internal(pwa_url, temp_dir)
         
-        # Secure filename for download
+        # Generate safe filename
         domain = pwa_url.split('//')[-1].split('/')[0].replace('.', '_')
         apk_name = secure_filename(f"{domain}_app.apk")
-        
-        # Return the file
+
+        logger.info(f"Successfully generated APK: {apk_path}")
         return send_file(
             apk_path,
             as_attachment=True,
             download_name=apk_name,
             mimetype='application/vnd.android.package-archive'
         )
-        
-    except subprocess.TimeoutExpired:
-        return jsonify({"error": "APK generation timed out"}), 504
-    except subprocess.CalledProcessError as e:
-        app.logger.error(f"Build failed: {e.stderr}")
-        return jsonify({"error": "APK generation failed", "details": str(e)}), 500
+
     except Exception as e:
-        app.logger.error(f"Unexpected error: {str(e)}")
-        return jsonify({"error": "APK generation failed", "details": str(e)}), 500
+        logger.error(f"APK generation failed: {str(e)}")
+        return jsonify({
+            "error": "APK generation failed",
+            "details": str(e)
+        }), 500
     finally:
-        # Clean up
-        os.chdir('/')  # Change out of directory before cleanup
         cleanup_directory(temp_dir)
 
-@app.before_request
-def before_request():
-    # Simple host validation
-    if request.headers.get('Host') not in app.config['ALLOWED_HOSTS']:
-        return jsonify({"error": "Unauthorized host"}), 403
-    
-    # Check bubblewrap is available
-    if not check_bubblewrap():
-        return jsonify({"error": "Service temporarily unavailable"}), 503
-
 if __name__ == "__main__":
     # Verify dependencies at startup
     if not check_bubblewrap():
-        print("Error: Bubblewrap not available or version too old")
+        logger.error("Bubblewrap not available - service cannot start")
         exit(1)
         
-    app.run(host="0.0.0.0", port=7860, threaded=True)
+    app.run(host="0.0.0.0", port=7860)