Update app.py

app.py

@@ -1,83 +1,150 @@
 from flask import Flask, request, send_file, redirect, jsonify
 from flask_cors import CORS
+
 import subprocess
-import os
-import uuid
 import plistlib
 import zipfile
+import shutil
+import uuid
+import os
+
 from pathlib import Path
 
 app = Flask(__name__)
 CORS(app)
 
+# CHANGE THIS TO YOUR REAL SPACE URL
 BASE_URL = "https://gabefromsimplebit-simplebit-signer.hf.space"
 
 
 @app.route("/")
 def home():
-    return "SimpleBit Signer is Online!"
+    return jsonify({
+        "status": "online",
+        "service": "SimpleBit Signer"
+    })
 
 
 def get_actual_bundle_id(ipa_path):
     """
-    Extract the real bundle ID from the IPA Info.plist safely.
+    Safely extract CFBundleIdentifier from IPA
     """
     try:
         with zipfile.ZipFile(ipa_path, "r") as ipa:
-            plist_file = next(
-                f for f in ipa.namelist()
-                if f.startswith("Payload/") and f.endswith("Info.plist")
-            )
+            plist_name = None
 
-            with ipa.open(plist_file) as fp:
-                plist_data = plistlib.load(fp)
+            for name in ipa.namelist():
+                if name.startswith("Payload/") and name.endswith("Info.plist"):
+                    plist_name = name
+                    break
+
+            if not plist_name:
+                return None
+
+            with ipa.open(plist_name) as plist_file:
+                plist_data = plistlib.load(plist_file)
 
             return plist_data.get("CFBundleIdentifier")
 
     except Exception as e:
-        print(f"Bundle ID extraction failed: {e}")
+        print("Bundle ID extraction failed:", str(e))
 
     return None
 
 
+def save_bundle_id(job_dir, bundle_id):
+    try:
+        with open(job_dir / "bundle_id.txt", "w") as f:
+            f.write(bundle_id)
+    except Exception as e:
+        print("Failed to save bundle ID:", str(e))
+
+
+def load_bundle_id(job_dir):
+    try:
+        with open(job_dir / "bundle_id.txt", "r") as f:
+            return f.read().strip()
+    except:
+        return "com.simplebit.dynamic"
+
+
 @app.route("/sign", methods=["POST"])
 def sign():
     try:
+        # ---------------------------------------------------
         # Validate uploads
+        # ---------------------------------------------------
+
         if "ipa" not in request.files:
-            return jsonify({"error": "Missing IPA file"}), 400
+            return jsonify({
+                "error": "Missing IPA file"
+            }), 400
 
         if "p12" not in request.files:
-            return jsonify({"error": "Missing P12 certificate"}), 400
+            return jsonify({
+                "error": "Missing P12 certificate"
+            }), 400
 
         if "provision" not in request.files:
-            return jsonify({"error": "Missing mobileprovision file"}), 400
+            return jsonify({
+                "error": "Missing provisioning profile"
+            }), 400
+
+        # ---------------------------------------------------
+        # Check zsign installation
+        # ---------------------------------------------------
+
+        zsign_path = shutil.which("zsign")
+
+        print("ZSIGN PATH:", zsign_path)
+
+        if not zsign_path:
+            return jsonify({
+                "error": "zsign is not installed"
+            }), 500
+
+        # ---------------------------------------------------
+        # Create job directory
+        # ---------------------------------------------------
 
         job_id = str(uuid.uuid4())[:8]
+
         job_dir = Path(job_id)
         job_dir.mkdir(exist_ok=True)
 
+        # ---------------------------------------------------
+        # Uploaded files
+        # ---------------------------------------------------
+
         ipa = request.files["ipa"]
         p12 = request.files["p12"]
-        prov = request.files["provision"]
+        provision = request.files["provision"]
 
-        password = request.form.get("password", "1234")
+        password = request.form.get("password", "")
 
         ipa_path = job_dir / "app.ipa"
         p12_path = job_dir / "cert.p12"
-        prov_path = job_dir / "prov.mobileprovision"
+        prov_path = job_dir / "profile.mobileprovision"
         out_path = job_dir / "signed.ipa"
 
         ipa.save(ipa_path)
         p12.save(p12_path)
-        prov.save(prov_path)
+        provision.save(prov_path)
+
+        # ---------------------------------------------------
+        # Extract bundle ID
+        # ---------------------------------------------------
 
-        # Extract bundle ID before signing
         bundle_id = get_actual_bundle_id(ipa_path)
 
-        # Run zsign
+        print("BUNDLE ID:", bundle_id)
+
+        # ---------------------------------------------------
+        # zsign command
+        # ---------------------------------------------------
+
         command = [
-            "zsign",
+            zsign_path,
             "-k", str(p12_path),
             "-p", password,
             "-m", str(prov_path),
@@ -86,33 +153,78 @@ def sign():
             str(ipa_path)
         ]
 
+        print("RUNNING COMMAND:")
+        print(" ".join(command))
+
+        # ---------------------------------------------------
+        # Run signing
+        # ---------------------------------------------------
+
         result = subprocess.run(
             command,
             capture_output=True,
             text=True
         )
 
+        print("RETURN CODE:", result.returncode)
+        print("STDOUT:")
+        print(result.stdout)
+        print("STDERR:")
+        print(result.stderr)
+
+        # ---------------------------------------------------
+        # Handle failure
+        # ---------------------------------------------------
+
         if result.returncode != 0:
             return jsonify({
                 "error": "Signing failed",
-                "details": result.stderr
+                "returncode": result.returncode,
+                "stdout": result.stdout,
+                "stderr": result.stderr
+            }), 500
+
+        # ---------------------------------------------------
+        # Verify signed IPA exists
+        # ---------------------------------------------------
+
+        if not out_path.exists():
+            return jsonify({
+                "error": "Signed IPA missing after signing"
             }), 500
 
+        # ---------------------------------------------------
         # Fallback bundle ID
+        # ---------------------------------------------------
+
         if not bundle_id:
             bundle_id = "com.simplebit.dynamic"
 
-        # Save bundle ID
-        with open(job_dir / "bundle_id.txt", "w") as f:
-            f.write(bundle_id)
+        save_bundle_id(job_dir, bundle_id)
+
+        # ---------------------------------------------------
+        # OTA Install URL
+        # ---------------------------------------------------
 
         plist_url = f"{BASE_URL}/plist/{job_id}"
 
-        return redirect(
-            f"itms-services://?action=download-manifest&url={plist_url}"
+        ota_url = (
+            "itms-services://?action=download-manifest"
+            f"&url={plist_url}"
         )
 
+        return jsonify({
+            "success": True,
+            "job_id": job_id,
+            "bundle_id": bundle_id,
+            "install_url": ota_url,
+            "plist_url": plist_url,
+            "download_url": f"{BASE_URL}/download/{job_id}"
+        })
+
     except Exception as e:
+        print("FATAL ERROR:", str(e))
+
         return jsonify({
             "error": str(e)
         }), 500
@@ -120,36 +232,45 @@ def sign():
 
 @app.route("/plist/<job_id>")
 def serve_plist(job_id):
-    job_dir = Path(job_id)
-
     try:
-        with open(job_dir / "bundle_id.txt", "r") as f:
-            bundle_id = f.read().strip()
-    except:
-        bundle_id = "com.simplebit.dynamic"
+        job_dir = Path(job_id)
+
+        signed_ipa = job_dir / "signed.ipa"
+
+        if not signed_ipa.exists():
+            return jsonify({
+                "error": "Signed IPA not found"
+            }), 404
 
-    ipa_direct_url = f"{BASE_URL}/download/{job_id}"
+        bundle_id = load_bundle_id(job_dir)
 
-    plist_content = f"""<?xml version="1.0" encoding="UTF-8"?>
+        ipa_url = f"{BASE_URL}/download/{job_id}"
+
+        plist_content = f"""<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
 "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+
 <plist version="1.0">
 <dict>
+
     <key>items</key>
     <array>
         <dict>
+
             <key>assets</key>
             <array>
                 <dict>
                     <key>kind</key>
                     <string>software-package</string>
+
                     <key>url</key>
-                    <string>{ipa_direct_url}</string>
+                    <string>{ipa_url}</string>
                 </dict>
             </array>
 
             <key>metadata</key>
             <dict>
+
                 <key>bundle-identifier</key>
                 <string>{bundle_id}</string>
 
@@ -161,36 +282,65 @@ def serve_plist(job_id):
 
                 <key>title</key>
                 <string>SimpleBit Signed App</string>
+
             </dict>
+
         </dict>
     </array>
+
 </dict>
-</plist>"""
+</plist>
+"""
+
+        plist_path = job_dir / "manifest.plist"
 
-    plist_path = job_dir / "manifest.plist"
+        with open(plist_path, "w") as f:
+            f.write(plist_content)
 
-    with open(plist_path, "w") as f:
-        f.write(plist_content)
+        return send_file(
+            plist_path,
+            mimetype="application/xml"
+        )
 
-    return send_file(
-        plist_path,
-        mimetype="application/xml"
-    )
+    except Exception as e:
+        return jsonify({
+            "error": str(e)
+        }), 500
 
 
 @app.route("/download/<job_id>")
 def download_ipa(job_id):
-    ipa_path = Path(job_id) / "signed.ipa"
+    try:
+        ipa_path = Path(job_id) / "signed.ipa"
+
+        if not ipa_path.exists():
+            return jsonify({
+                "error": "IPA not found"
+            }), 404
+
+        return send_file(
+            ipa_path,
+            as_attachment=True,
+            download_name="signed.ipa"
+        )
+
+    except Exception as e:
+        return jsonify({
+            "error": str(e)
+        }), 500
 
-    if not ipa_path.exists():
-        return jsonify({"error": "IPA not found"}), 404
 
-    return send_file(
-        ipa_path,
-        as_attachment=True,
-        download_name="signed.ipa"
-    )
+@app.route("/health")
+def health():
+    return jsonify({
+        "status": "healthy",
+        "zsign_installed": shutil.which("zsign") is not None
+    })
 
 
 if __name__ == "__main__":
-    app.run(host="0.0.0.0", port=7860)
+    app.run(
+        host="0.0.0.0",
+        port=7860,
+        debug=True
+    )