Update app.py

app.py

@@ -1,36 +1,125 @@
 import os
 import subprocess
-from flask import Flask, request, send_file
+import tempfile
+import shutil
+import re
+from flask import Flask, request, send_file, jsonify
+from werkzeug.utils import secure_filename
 
 app = Flask(__name__)
 
-# Endpoint to generate APK from PWA URL
+# Configuration
+app.config['MAX_CONTENT_LENGTH'] = 1 * 1024 * 1024  # 1MB max upload size
+app.config['ALLOWED_HOSTS'] = ['yourdomain.com']  # Add your production domain
+app.config['BUBBLEWRAP_MIN_VERSION'] = '1.0.0'  # Minimum required version
+
+# Validate URL format
+def is_valid_url(url):
+    regex = re.compile(
+        r'^(https?://)?'  # http:// or https://
+        r'([a-zA-Z0-9-]+\.)+[a-zA-Z]{2,}'  # domain
+        r'(/[a-zA-Z0-9-._~:/?#[\]@!$&\'()*+,;=]*)?$',  # path
+        re.IGNORECASE
+    )
+    return re.match(regex, url) is not None
+
+# Check if bubblewrap is available
+def check_bubblewrap():
+    try:
+        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")
+        return True
+    except Exception as e:
+        app.logger.error(f"Bubblewrap check failed: {str(e)}")
+        return False
+
+# Clean up directory
+def cleanup_directory(dir_path):
+    try:
+        if os.path.exists(dir_path):
+            shutil.rmtree(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():
-    pwa_url = request.form["url"]
+    # Validate request
+    if 'url' not in request.form:
+        return jsonify({"error": "URL parameter is required"}), 400
+    
+    pwa_url = request.form['url'].strip()
     
-    if not pwa_url:
-        return "URL is required", 400
+    if not is_valid_url(pwa_url):
+        return jsonify({"error": "Invalid URL format"}), 400
 
-    # Create the Bubblewrap configuration and generate APK
+    # Create temp directory
+    temp_dir = tempfile.mkdtemp(prefix='pwa2apk_')
+    os.chdir(temp_dir)  # Work in temp directory
+    
     try:
-        subprocess.run(["bubblewrap", "init", "--manifest", pwa_url], check=True)
-
-        # Build the APK
-        subprocess.run(["bubblewrap", "build"], check=True)
-
-        # Assuming APK is stored in 'output' directory
-        apk_path = "output/app-release.apk"
+        # Initialize project
+        init_cmd = [
+            'bubblewrap', 'init',
+            '--manifest', pwa_url,
+            '--directory', temp_dir,
+            '--non-interactive'
+        ]
         
-        # Check if APK was generated
-        if os.path.exists(apk_path):
-            return send_file(apk_path, as_attachment=True)
-        else:
-            return "APK generation failed", 500
-
+        subprocess.run(init_cmd, check=True, timeout=300, 
+                      stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        
+        # Build APK
+        build_cmd = ['bubblewrap', 'build']
+        subprocess.run(build_cmd, check=True, timeout=600, 
+                      stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+        
+        # Verify APK was created
+        apk_path = os.path.join(temp_dir, 'app-release.apk')
+        if not os.path.exists(apk_path):
+            raise Exception("APK file not found after build")
+        
+        # Secure filename for download
+        domain = pwa_url.split('//')[-1].split('/')[0].replace('.', '_')
+        apk_name = secure_filename(f"{domain}_app.apk")
+        
+        # Return the file
+        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:
-        return f"Error generating APK: {str(e)}", 500
+        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
+    finally:
+        # Clean up
+        os.chdir('/')  # Change out of directory before cleanup
+        cleanup_directory(temp_dir)
 
-if __name__ == "__main__":
-    app.run(host="0.0.0.0", port=7860)
+@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")
+        exit(1)
+        
+    app.run(host="0.0.0.0", port=7860, threaded=True)