Upload 5 files

README.md

@@ -1,13 +1,56 @@
 ---
 title: HarshItPDF
-emoji: 👁
-colorFrom: red
-colorTo: red
+emoji: 🖥️
+colorFrom: indigo
+colorTo: purple
 sdk: gradio
-sdk_version: 6.20.0
-python_version: '3.12'
+sdk_version: "5.23.3"
+python_version: "3.12"
 app_file: app.py
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# HarshItPDF — HF Spaces Gradio (Free Tier)
+
+HarshItPDF is a rebranded, fully-unlocked Stirling-PDF deployed on Hugging Face Spaces Free Tier using Gradio.
+
+## What you get
+
+- **All premium / enterprise features enabled** (3-layer bytecode patch + mock license server)
+- **OCR support** (Tesseract pre-installed via `packages.txt`)
+- **Gradio splash screen** with JavaScript auto-redirect to the Java backend
+- **No credit card required**
+
+## Default login
+
+- **Username:** `admin`
+- **Password:** `changeme123`
+
+## How to deploy
+
+1. Create a new **HF Space** → choose **Gradio** as the SDK
+2. Upload these files to the repo root:
+   - `app.py`
+   - `license_server.py`
+   - `requirements.txt`
+   - `packages.txt`
+   - `README.md`
+3. HF builds the environment automatically (~3–5 minutes)
+4. Once the Space status shows **Running**, click the **Open** button
+5. The splash screen will auto-redirect to the app once the Java backend is ready (~30–60 seconds)
+
+## Files
+
+| File | Purpose |
+|---|---|
+| `app.py` | Runtime patcher + orchestrator + Gradio UI |
+| `license_server.py` | Mock Keygen API on port 7871 |
+| `requirements.txt` | Python dependencies (gradio) |
+| `packages.txt` | System packages (Java 17 JDK, Tesseract, unzip, wget) |
+
+## Important notes
+
+- **Cold start:** Free CPU Spaces hibernate after ~48 hours of inactivity. First visit after sleep triggers a ~1–2 minute cold start (JAR download + extraction + patching + Java startup).
+- **While awake:** The app stays responsive. The Gradio UI proxies to the Java backend via HF Spaces' internal port proxy (`/proxy/7870/`).
+- **OCR languages:** English is pre-installed. Add more `tesseract-ocr-*` packages in `packages.txt` if needed.
+- **Premium license:** Three independent patches ensure Enterprise status — bytecode flip (`iconst_0→1`), `LicenseKeyChecker` getter override, and Spring bean `runningProOrHigher()→true`.

app.py

@@ -0,0 +1,949 @@
+"""
+HarshItPDF — HF Spaces Gradio deployment (Free Tier).
+Build-time (packages.txt): installs Java 17 JDK, Tesseract, unzip, wget.
+Runtime: downloads JAR, patches bytecode, starts mock license + Java backend.
+Gradio UI: splash screen with JS auto-redirect to /proxy/{BACKEND_PORT}/
+"""
+
+import os
+import sys
+import time
+import json
+import shutil
+import struct
+import glob
+import re
+import threading
+import subprocess
+import urllib.request
+import zipfile
+import logging
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="[%(name)s] %(levelname)s %(message)s",
+)
+logger = logging.getLogger("harshitpdf")
+
+# ═══════════════════════════════════════════════════════════════
+# Configuration
+# ═══════════════════════════════════════════════════════════════
+PUBLIC_PORT = int(os.environ.get("PORT", "7860"))
+BACKEND_PORT = int(os.environ.get("BACKEND_PORT", "7870"))
+LICENCE_SERVER_PORT = int(os.environ.get("LICENCE_SERVER_PORT", "7871"))
+
+RELEASE_TAG = "v2.11.0"
+JAR_URL = (
+    f"https://github.com/Stirling-Tools/Stirling-PDF/releases/download/"
+    f"{RELEASE_TAG}/Stirling-PDF-with-login.jar"
+)
+
+JAR_PATH = "Stirling-PDF-with-login.jar"
+EXTRACT_DIR = "jar-extracted"
+STATIC_DIR = os.path.join(EXTRACT_DIR, "BOOT-INF", "classes", "static")
+ASSETS_DIR = os.path.join(STATIC_DIR, "assets")
+CLASSES_DIR = os.path.join(EXTRACT_DIR, "BOOT-INF", "classes")
+LIB_DIR = os.path.join(EXTRACT_DIR, "BOOT-INF", "lib")
+CONFIGS_DIR = "configs"
+PATCHED_FLAG = os.path.join(EXTRACT_DIR, ".harshitpdf-patched-v9")
+
+BRAND_REPLACEMENTS = [
+    ("Stirling PDF", "HarshItPDF"),
+    ("Stirling-PDF", "HarshItPDF"),
+    ("StirlingPDF", "HarshItPDF"),
+    ("stirling-pdf", "harshitpdf"),
+    ("stirlingpdf", "harshitpdf"),
+    ("Stirling Tools", "HarshIt"),
+    ("Stirling-Tools", "HarshIt"),
+    ("Stirling Tools ", "HarshIt "),
+]
+
+# ═══════════════════════════════════════════════════════════════
+# Branding helper
+# ═══════════════════════════════════════════════════════════════
+
+def _brand(text):
+    for old, new in BRAND_REPLACEMENTS:
+        text = text.replace(old, new)
+    return text
+
+# ═══════════════════════════════════════════════════════════════
+# Import mock license server
+# ═══════════════════════════════════════════════════════════════
+
+SELF_DIR = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, SELF_DIR)
+from license_server import start_license_server
+
+# ═══════════════════════════════════════════════════════════════
+# JAR lifecycle
+# ═══════════════════════════════════════════════════════════════
+
+def _download_jar():
+    if os.path.exists(JAR_PATH):
+        return
+    logger.info(f"Downloading {JAR_URL} ...")
+    urllib.request.urlretrieve(JAR_URL, JAR_PATH)
+    logger.info("Download complete.")
+
+
+def _extract_jar():
+    if os.path.exists(os.path.join(EXTRACT_DIR, "BOOT-INF")):
+        if not os.path.exists(PATCHED_FLAG):
+            logger.info("Patch version changed — re-extracting JAR...")
+            shutil.rmtree(EXTRACT_DIR, ignore_errors=True)
+        else:
+            return
+    logger.info("Extracting JAR...")
+    try:
+        subprocess.run(
+            ["unzip", "-q", "-o", JAR_PATH, "-d", EXTRACT_DIR],
+            check=True, timeout=120,
+        )
+    except (FileNotFoundError, subprocess.TimeoutExpired):
+        with zipfile.ZipFile(JAR_PATH) as zf:
+            zf.extractall(EXTRACT_DIR)
+    logger.info("Extraction complete.")
+
+
+def _get_main_class():
+    with zipfile.ZipFile(JAR_PATH) as zf:
+        manifest = zf.read("META-INF/MANIFEST.MF").decode()
+        for line in manifest.split("\n"):
+            s = line.strip()
+            if s.startswith("Main-Class:"):
+                return s.split(":", 1)[1].strip()
+    return "org.springframework.boot.loader.launch.JarLauncher"
+
+
+# ═══════════════════════════════════════════════════════════════
+# Constant-pool parser (robust)
+# ═══════════════════════════════════════════════════════════════
+
+CP_TAG_SIZES = {
+    1: None, 2: None,
+    3: 4, 4: 4, 5: 8, 6: 8,
+    7: 2, 8: 2, 16: 2, 19: 2, 20: 2,
+    9: 4, 10: 4, 11: 4, 12: 4, 17: 4, 18: 4,
+    15: 3,
+}
+
+
+def _parse_constant_pool(class_data):
+    if len(class_data) < 10:
+        return [], 10
+    cp_count = struct.unpack(">H", class_data[8:10])[0]
+    idx = 10
+    cp = [None]
+    i = 1
+    while i < cp_count:
+        if idx >= len(class_data):
+            break
+        tag = class_data[idx]
+        idx += 1
+        if tag == 1 or tag == 2:
+            if idx + 2 > len(class_data):
+                break
+            length = struct.unpack(">H", class_data[idx:idx+2])[0]
+            if idx + 2 + length > len(class_data):
+                break
+            val = class_data[idx+2:idx+2+length].decode("utf-8", errors="replace")
+            cp.append((tag, val))
+            idx += 2 + length
+            i += 1
+        elif tag in (5, 6):
+            if idx + 8 > len(class_data):
+                break
+            cp.append((tag, None))
+            cp.append((tag, None))
+            idx += 8
+            i += 2
+        elif tag in CP_TAG_SIZES and CP_TAG_SIZES[tag] is not None:
+            size = CP_TAG_SIZES[tag]
+            if idx + size > len(class_data):
+                break
+            if tag in (7, 8, 16, 19, 20):
+                val = struct.unpack(">H", class_data[idx:idx+2])[0]
+                cp.append((tag, val))
+            elif tag in (9, 10, 11, 12, 17, 18):
+                a = struct.unpack(">H", class_data[idx:idx+2])[0]
+                b = struct.unpack(">H", class_data[idx+2:idx+4])[0]
+                cp.append((tag, (a, b)))
+            elif tag == 15:
+                cp.append((tag, (class_data[idx], struct.unpack(">H", class_data[idx+1:idx+3])[0])))
+            else:
+                cp.append((tag, None))
+            idx += size
+            i += 1
+        else:
+            cp.append((tag, None))
+            break
+    return cp, idx
+
+
+def _get_method_code_ranges(class_data):
+    _, idx = _parse_constant_pool(class_data)
+    if not idx:
+        return []
+    idx += 6
+    if idx + 2 > len(class_data):
+        return []
+    interfaces_count = struct.unpack(">H", class_data[idx:idx+2])[0]
+    idx += 2 + interfaces_count * 2
+    if idx + 2 > len(class_data):
+        return []
+    fields_count = struct.unpack(">H", class_data[idx:idx+2])[0]
+    idx += 2
+    for _ in range(fields_count):
+        if idx + 6 > len(class_data):
+            return []
+        idx += 6
+        attr_count = struct.unpack(">H", class_data[idx:idx+2])[0]
+        idx += 2
+        for _ in range(attr_count):
+            if idx + 6 > len(class_data):
+                return []
+            idx += 2
+            attr_len = struct.unpack(">I", class_data[idx:idx+4])[0]
+            idx += 4 + attr_len
+    if idx + 2 > len(class_data):
+        return []
+    methods_count = struct.unpack(">H", class_data[idx:idx+2])[0]
+    idx += 2
+    code_ranges = []
+    for _ in range(methods_count):
+        if idx + 6 > len(class_data):
+            break
+        idx += 6
+        attr_count = struct.unpack(">H", class_data[idx:idx+2])[0]
+        idx += 2
+        for _ in range(attr_count):
+            if idx + 6 > len(class_data):
+                break
+            idx += 2
+            attr_len = struct.unpack(">I", class_data[idx:idx+4])[0]
+            idx += 4
+            attr_start = idx
+            attr_end = idx + attr_len
+            if attr_end <= len(class_data) and attr_len >= 8:
+                code_len = struct.unpack(">I", class_data[attr_start+4:attr_start+8])[0]
+                code_start = attr_start + 8
+                code_end = code_start + code_len
+                if code_end <= attr_end:
+                    code_ranges.append((code_start, code_end))
+            idx = attr_end
+    return code_ranges
+
+
+def _get_method_code_info(class_data):
+    cp, idx = _parse_constant_pool(class_data)
+    if not idx:
+        return []
+    idx += 6
+    if idx + 2 > len(class_data):
+        return []
+    interfaces_count = struct.unpack(">H", class_data[idx:idx+2])[0]
+    idx += 2 + interfaces_count * 2
+    if idx + 2 > len(class_data):
+        return []
+    fields_count = struct.unpack(">H", class_data[idx:idx+2])[0]
+    idx += 2
+    for _ in range(fields_count):
+        if idx + 6 > len(class_data):
+            return []
+        idx += 6
+        attr_count = struct.unpack(">H", class_data[idx:idx+2])[0]
+        idx += 2
+        for _ in range(attr_count):
+            if idx + 6 > len(class_data):
+                return []
+            idx += 2
+            attr_len = struct.unpack(">I", class_data[idx:idx+4])[0]
+            idx += 4 + attr_len
+    if idx + 2 > len(class_data):
+        return []
+    methods_count = struct.unpack(">H", class_data[idx:idx+2])[0]
+    idx += 2
+    methods = []
+    for _ in range(methods_count):
+        if idx + 6 > len(class_data):
+            break
+        name_idx = struct.unpack(">H", class_data[idx+2:idx+4])[0]
+        idx += 6
+        attr_count = struct.unpack(">H", class_data[idx:idx+2])[0]
+        idx += 2
+        name = ""
+        if 0 < name_idx < len(cp) and cp[name_idx] and cp[name_idx][0] == 1:
+            name = cp[name_idx][1]
+        for _ in range(attr_count):
+            if idx + 6 > len(class_data):
+                break
+            attr_name_idx = struct.unpack(">H", class_data[idx:idx+2])[0]
+            attr_len = struct.unpack(">I", class_data[idx+2:idx+6])[0]
+            idx += 6
+            attr_start = idx
+            attr_end = idx + attr_len
+            if 0 < attr_name_idx < len(cp) and cp[attr_name_idx] and cp[attr_name_idx][0] == 1:
+                attr_name = cp[attr_name_idx][1]
+                if attr_name == "Code" and attr_len >= 8:
+                    code_len = struct.unpack(">I", class_data[attr_start+4:attr_start+8])[0]
+                    code_start = attr_start + 8
+                    code_end = code_start + code_len
+                    if code_end <= attr_end:
+                        methods.append((name, code_start, code_end))
+            idx = attr_end
+    return methods
+
+
+def _find_fieldref_index(class_data, class_name_substr, field_name):
+    cp, _ = _parse_constant_pool(class_data)
+    if not cp:
+        return None
+    field_name_idx = None
+    for i, entry in enumerate(cp):
+        if entry and entry[0] == 1 and entry[1] == field_name:
+            field_name_idx = i
+            break
+    if not field_name_idx:
+        return None
+    nat_idx = None
+    for i, entry in enumerate(cp):
+        if entry and entry[0] == 12 and isinstance(entry[1], tuple) and entry[1][0] == field_name_idx:
+            nat_idx = i
+            break
+    if not nat_idx:
+        return None
+    class_idx = None
+    for i, entry in enumerate(cp):
+        if entry and entry[0] == 7 and isinstance(entry[1], int):
+            cn_entry = cp[entry[1]]
+            if cn_entry and cn_entry[0] == 1 and class_name_substr in cn_entry[1]:
+                class_idx = i
+                break
+    if not class_idx:
+        return None
+    for i, entry in enumerate(cp):
+        if entry and entry[0] == 9 and isinstance(entry[1], tuple) and entry[1][0] == class_idx and entry[1][1] == nat_idx:
+            return i
+    return None
+
+
+# ═══════════════════════════════════════════════════════════════
+# Bytecode patching
+# ═══════════════════════════════════════════════════════════════
+
+def _patch_method_to_return_true(class_data, class_name=""):
+    data = bytearray(class_data)
+    ranges = _get_method_code_ranges(class_data)
+    modified = False
+    for start, end in ranges:
+        i = start
+        while i < end - 1:
+            if data[i] == 0x03 and data[i + 1] == 0xac:
+                data[i] = 0x04
+                modified = True
+                i += 2
+                continue
+            if data[i] == 0x04 and data[i + 1] == 0xac:
+                i += 2
+                continue
+            i += 1
+    return modified, bytes(data)
+
+
+def _patch_class_file(path):
+    with open(path, "rb") as fh:
+        data = fh.read()
+    modified, new_data = _patch_method_to_return_true(data, os.path.basename(path))
+    if modified:
+        with open(path, "wb") as fh:
+            fh.write(new_data)
+        return True
+    return False
+
+
+def _is_license_class(filename):
+    name = filename.lower()
+    return any(w in name for w in [
+        "license", "licenseverifier", "licensechecker",
+        "dynamiclicense", "premiumenabled",
+    ])
+
+
+def _is_license_jar(filename):
+    name = filename.lower()
+    return "proprietary" in name or "license" in name or "ee" in name
+
+
+def _patch_license_key_checker(path):
+    """Patch getPremiumLicenseEnabledResult() → ENTERPRISE robustly."""
+    with open(path, "rb") as fh:
+        data = bytearray(fh.read())
+    enterprise_idx = _find_fieldref_index(data, "License", "ENTERPRISE")
+    if enterprise_idx:
+        methods = _get_method_code_info(data)
+        for name, cstart, cend in methods:
+            if name == "getPremiumLicenseEnabledResult":
+                for i in range(cstart, cend - 4):
+                    if data[i] == 0x2a and data[i+1] == 0xb4 and data[i+4] == 0xb0:
+                        data[i]   = 0xb2
+                        data[i+1] = (enterprise_idx >> 8) & 0xff
+                        data[i+2] = enterprise_idx & 0xff
+                        data[i+3] = 0x00
+                        data[i+4] = 0xb0
+                        with open(path, "wb") as fh:
+                            fh.write(bytes(data))
+                        logger.info(f"Robust-patched {name} → ENTERPRISE (idx={enterprise_idx})")
+                        return True
+                logger.warning(f"Found {name} but no getfield+areturn pattern")
+                return False
+    logger.warning("ENTERPRISE not found in constant pool, trying hardcoded fallback...")
+    if len(data) > 5643:
+        expected = bytes([0xb4, 0x00, 0x0d, 0xb0])
+        if data[5638:5642] == expected:
+            data[5638:5643] = bytes([0xb2, 0x00, 0x4f, 0x00, 0xb0])
+            with open(path, "wb") as fh:
+                fh.write(bytes(data))
+            logger.info("Patched LicenseKeyChecker using hardcoded offset fallback")
+            return True
+    logger.error("Could not patch LicenseKeyChecker")
+    return False
+
+
+def _extract_and_patch_license_classes_from_jar(jar_path):
+    patched_files = []
+    with zipfile.ZipFile(jar_path, "r") as zf:
+        for name in zf.namelist():
+            if not name.endswith(".class"):
+                continue
+            if not _is_license_class(os.path.basename(name)):
+                continue
+            data = zf.read(name)
+            mod1, d1 = _patch_method_to_return_true(data, os.path.basename(name))
+            if mod1:
+                dest_path = os.path.join(CLASSES_DIR, name)
+                os.makedirs(os.path.dirname(dest_path), exist_ok=True)
+                with open(dest_path, "wb") as fh:
+                    fh.write(d1)
+                patched_files.append(name)
+    if patched_files:
+        logger.info(f"Extracted/patched from {os.path.basename(jar_path)}: {len(patched_files)} classes")
+    return len(patched_files)
+
+
+def _patch_license_classes():
+    patched = 0
+    if os.path.exists(CLASSES_DIR):
+        for root, dirs, files in os.walk(CLASSES_DIR):
+            for f in files:
+                if not f.endswith(".class") or not _is_license_class(f):
+                    continue
+                path = os.path.join(root, f)
+                try:
+                    if _patch_class_file(path):
+                        patched += 1
+                        logger.info(f"Patched license class: {f}")
+                except Exception as e:
+                    logger.warning(f"Could not patch {f}: {e}")
+    if os.path.exists(LIB_DIR):
+        for f in os.listdir(LIB_DIR):
+            if not f.endswith(".jar") or not _is_license_jar(f):
+                continue
+            try:
+                patched += _extract_and_patch_license_classes_from_jar(os.path.join(LIB_DIR, f))
+            except Exception as e:
+                logger.warning(f"Could not process {f}: {e}")
+
+    lck_path = os.path.join(
+        CLASSES_DIR,
+        "stirling/software/proprietary/security/configuration/ee/LicenseKeyChecker.class"
+    )
+    if not os.path.exists(lck_path) and os.path.exists(LIB_DIR):
+        for jf in os.listdir(LIB_DIR):
+            if "proprietary" not in jf.lower():
+                continue
+            with zipfile.ZipFile(os.path.join(LIB_DIR, jf)) as zf:
+                cp = "stirling/software/proprietary/security/configuration/ee/LicenseKeyChecker.class"
+                if cp in zf.namelist():
+                    os.makedirs(os.path.dirname(lck_path), exist_ok=True)
+                    with open(lck_path, "wb") as fh:
+                        fh.write(zf.read(cp))
+                    logger.info("Extracted LicenseKeyChecker.class for patching")
+                    break
+    if os.path.exists(lck_path):
+        try:
+            if _patch_license_key_checker(lck_path):
+                patched += 1
+        except Exception as e:
+            logger.warning(f"Could not patch LicenseKeyChecker: {e}")
+    else:
+        logger.warning("LicenseKeyChecker.class not found")
+
+    if patched:
+        logger.info(f"Patched {patched} license verifier classes total.")
+
+
+# ═══════════════════════════════════════════════════════════════
+# HTML / JS / SVG / CSS patching
+# ═══════════════════════════════════════════════════════════════
+
+def _patch_html():
+    count = 0
+    if not os.path.exists(STATIC_DIR):
+        return
+    for root, dirs, files in os.walk(STATIC_DIR):
+        for f in files:
+            if not f.endswith(".html"):
+                continue
+            path = os.path.join(root, f)
+            with open(path, "r", encoding="utf-8", errors="replace") as fh:
+                content = fh.read()
+            content = _brand(content)
+            content = content.replace(
+                "The Free Adobe Acrobat alternative (10M+ Downloads)",
+                "Your private PDF powerhouse by HarshIt",
+            )
+            css_link = '<link rel="stylesheet" href="/harshitpdf-liquidglass.css">'
+            if "harshitpdf-liquidglass.css" not in content:
+                content = content.replace("</head>", css_link + "</head>")
+            with open(path, "w", encoding="utf-8") as fh:
+                fh.write(content)
+            count += 1
+    logger.info(f"Patched {count} HTML files.")
+
+
+def _patch_js():
+    count = 0
+    if not os.path.exists(ASSETS_DIR):
+        return
+    for f in os.listdir(ASSETS_DIR):
+        if not f.endswith(".js"):
+            continue
+        path = os.path.join(ASSETS_DIR, f)
+        with open(path, "r", encoding="utf-8", errors="replace") as fh:
+            content = fh.read()
+        orig = content
+        content = _brand(content)
+        content = re.sub(
+            r'requiresPremium\s*[=:]=?\s*(?:!0|!1|true|false|null)',
+            'requiresPremium=!1',
+            content,
+        )
+        content = re.sub(
+            r'["\'](?:Premium feature[:\s].*?|Enterprise only[:\s].*?|Enterprise Seats|Upgrade to Server Plan)["\']',
+            '""', content,
+        )
+        content = re.sub(
+            r'premiumEnabled\s*[=:]=?\s*[se][?\w]+\.premiumEnabled\?\??[!\d]+',
+            'premiumEnabled:!0', content,
+        )
+        if content != orig:
+            with open(path, "w", encoding="utf-8") as fh:
+                fh.write(content)
+            count += 1
+    logger.info(f"Patched {count} JS files.")
+
+
+def _write_svgs():
+    LOGO_SVGS = [
+        (
+            "StirlingPDFLogoBlackText.svg",
+            '<svg width="140" height="26" viewBox="0 0 140 26" fill="none" '
+            'xmlns="http://www.w3.org/2000/svg">'
+            '<path d="M3 2h12l4 4v18a2 2 0 0 1-2 2H3a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2z" '
+            'fill="#6366f1" opacity="0.9"/>'
+            '<path d="M15 2l4 4h-4V2z" fill="#818cf8"/>'
+            '<text x="6" y="17" font-family="system-ui,sans-serif" font-size="7" '
+            'font-weight="700" fill="#fff">PDF</text>'
+            '<text x="24" y="18" font-family="system-ui,-apple-system,sans-serif" '
+            'font-size="14" font-weight="700" fill="#1a1a2e" letter-spacing="-0.3">'
+            'HarshIt<tspan fill="#6366f1">PDF</tspan></text></svg>',
+        ),
+        (
+            "favicon.svg",
+            '<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512">'
+            '<defs><linearGradient id="g" x1="0" y1="0" x2="1" y2="1">'
+            '<stop offset="0" stop-color="#6366f1"/>'
+            '<stop offset="1" stop-color="#a855f7"/>'
+            "</linearGradient></defs>"
+            '<rect width="512" height="512" rx="100" fill="url(#g)"/>'
+            '<path d="M140 120h160l60 60v200a20 20 0 0 1-20 20H140a20 20 0 0 1-20-20'
+            'V140a20 20 0 0 1 20-20z" fill="#fff" opacity="0.95"/>'
+            '<path d="M300 120l60 60h-60V120z" fill="#ddd" opacity="0.8"/>'
+            '<text x="170" y="280" font-family="system-ui,sans-serif" font-size="80" '
+            'font-weight="800" fill="#6366f1">PDF</text></svg>',
+        ),
+    ]
+    logo_dir = os.path.join(STATIC_DIR, "modern-logo")
+    os.makedirs(logo_dir, exist_ok=True)
+    for name, svg in LOGO_SVGS:
+        with open(os.path.join(logo_dir, name), "w") as fh:
+            fh.write(svg)
+    logger.info("Wrote SVGs.")
+
+
+def _write_manifests():
+    manifest = {
+        "short_name": "HarshItPDF",
+        "name": "HarshItPDF",
+        "icons": [],
+        "start_url": ".",
+        "display": "standalone",
+        "theme_color": "#0a0a1a",
+        "background_color": "#0a0a1a",
+    }
+    for name in ("manifest.json", "manifest-classic.json"):
+        path = os.path.join(STATIC_DIR, name)
+        os.makedirs(os.path.dirname(path), exist_ok=True)
+        with open(path, "w") as fh:
+            json.dump(manifest, fh, indent=2)
+
+
+def _write_css():
+    candidates = glob.glob(os.path.join(SELF_DIR, "liquidglass*.css"))
+    css_src = candidates[0] if candidates else None
+    css_dst = os.path.join(STATIC_DIR, "harshitpdf-liquidglass.css")
+    if css_src and os.path.exists(css_src):
+        shutil.copy(css_src, css_dst)
+        logger.info(f"Copied CSS: {css_src} -> {css_dst}")
+    else:
+        with open(css_dst, "w") as fh:
+            fh.write("/* HarshItPDF Liquid Glass fallback */\n")
+
+
+def _patch_settings_template():
+    template_path = os.path.join(CLASSES_DIR, "settings.yml.template")
+    if not os.path.exists(template_path):
+        logger.warning("settings.yml.template not found.")
+        return
+    with open(template_path, "r") as fh:
+        content = fh.read()
+    content = _brand(content)
+    with open(template_path, "w") as fh:
+        fh.write(content)
+    logger.info("Patched settings.yml.template.")
+
+
+def _write_settings_yml():
+    os.makedirs(CONFIGS_DIR, exist_ok=True)
+    settings_path = os.path.join(CONFIGS_DIR, "settings.yml")
+    template_path = os.path.join(CLASSES_DIR, "settings.yml.template")
+    if os.path.exists(template_path):
+        with open(template_path, "r") as fh:
+            content = fh.read()
+    else:
+        content = """# HarshItPDF Settings
+security:
+  enableLogin: true
+  initialLogin:
+    username: admin
+    password: changeme123
+ui:
+  appName: HarshItPDF
+  appNavbarName: HarshItPDF
+  homeDescription: Your private PDF powerhouse by HarshIt
+system:
+  showUpdate: false
+  rootUriPath: ""
+  defaultLocale: en-US
+premium:
+  enabled: false
+enterpriseEdition:
+  enabled: true
+  maxUsers: 999
+endpoints:
+  groupsToRemove: []
+"""
+    content = _brand(content)
+    with open(settings_path, "w") as fh:
+        fh.write(content)
+    logger.info(f"Wrote settings.yml ({len(content)} chars).")
+
+
+def _patch_banner():
+    banner_path = os.path.join(CLASSES_DIR, "banner.txt")
+    os.makedirs(os.path.dirname(banner_path), exist_ok=True)
+    with open(banner_path, "w") as fh:
+        fh.write(r"""  _  __           _     _ ___ ___  ___  ___
+ | |/ /__ _ _ __| |_  |_ _| _ \ _ _| __| _ \
+ | ' // _` | '_ \ ' \  | ||  _/| || _||   /
+ | . \ (_| | | | | || | | || | | |_| |_| _|
+ |_|\_\__,_|_| |_|
+                  |__/
+Powered by Spring Boot ${spring-boot.version}
+""")
+
+
+def _patch_meta():
+    for name in ("og-metadata.json",):
+        path = os.path.join(STATIC_DIR, name)
+        if os.path.exists(path):
+            with open(path, "r") as fh:
+                content = fh.read()
+            with open(path, "w") as fh:
+                fh.write(_brand(content))
+
+
+def _fix_python_path():
+    venv_dir = "/opt/venv"
+    venv_bin = os.path.join(venv_dir, "bin")
+    venv_python = os.path.join(venv_bin, "python3")
+    if not os.path.exists(venv_dir):
+        os.makedirs(venv_bin, exist_ok=True)
+    system_python = shutil.which("python3")
+    if system_python and not os.path.exists(venv_python):
+        try:
+            os.symlink(system_python, venv_python)
+        except Exception as e:
+            logger.warning(f"Could not create python3 symlink: {e}")
+
+
+def _install_opencv():
+    try:
+        import cv2
+        logger.info(f"OpenCV available: {cv2.__version__}")
+    except ImportError:
+        logger.info("OpenCV not found, installing...")
+        try:
+            subprocess.run(
+                [sys.executable, "-m", "pip", "install", "--quiet", "opencv-python-headless"],
+                check=False, timeout=60,
+            )
+            import cv2
+            logger.info(f"OpenCV installed: {cv2.__version__}")
+        except Exception as e:
+            logger.warning(f"Could not install OpenCV: {e}")
+
+
+def _compile_license_override():
+    java_src = """package stirling.software.SPDF.config;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.beans.factory.annotation.Qualifier;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+
+@Configuration
+public class HarshItLicenseOverride {
+    @Bean
+    @ConditionalOnMissingBean(name = "runningProOrHigher")
+    @Qualifier("runningProOrHigher")
+    public boolean runningProOrHigher() {
+        return true;
+    }
+}
+"""
+    src_path = os.path.join(EXTRACT_DIR, "HarshItLicenseOverride.java")
+    with open(src_path, "w") as fh:
+        fh.write(java_src)
+    lib_dir = os.path.join(EXTRACT_DIR, "BOOT-INF", "lib")
+    if not os.path.exists(lib_dir):
+        logger.warning("BOOT-INF/lib not found, skipping license override compile")
+        return False
+    jars = [os.path.join(lib_dir, j) for j in os.listdir(lib_dir) if j.endswith(".jar")]
+    classpath = ":".join(jars)
+    dest_dir = os.path.join(EXTRACT_DIR, "BOOT-INF", "classes")
+    try:
+        result = subprocess.run(
+            ["javac", "-cp", classpath, "-d", dest_dir, src_path],
+            capture_output=True, text=True, timeout=60
+        )
+        if result.returncode == 0:
+            logger.info("Compiled HarshItLicenseOverride.class")
+            return True
+        else:
+            logger.warning(f"javac failed: {result.stderr[:200]}")
+            return False
+    except Exception as e:
+        logger.warning(f"Could not compile override: {e}")
+        return False
+
+
+def _patch_files():
+    if os.path.exists(PATCHED_FLAG):
+        return
+    logger.info("Applying HarshItPDF patches...")
+    _patch_html()
+    _patch_js()
+    _write_svgs()
+    _write_manifests()
+    _write_css()
+    _patch_settings_template()
+    _write_settings_yml()
+    _patch_banner()
+    _patch_meta()
+    _fix_python_path()
+    _install_opencv()
+    _patch_license_classes()
+    _compile_license_override()
+    with open(PATCHED_FLAG, "w") as fh:
+        fh.write(str(time.time()))
+    logger.info("All patches applied.")
+
+
+# ═══════════════════════════════════════════════════════════════
+# Backend lifecycle
+# ═══════════════════════════════════════════════════════════════
+
+_backend_process = None
+_backend_ready = threading.Event()
+
+
+def _stream_output(pipe):
+    try:
+        for line in pipe:
+            print(line, end="")
+            if "Started SPDFApplication" in line:
+                _backend_ready.set()
+    except Exception as e:
+        logger.warning(f"Backend stream error: {e}")
+
+
+def _find_tessdata():
+    candidates = [
+        "/usr/share/tesseract-ocr/5/tessdata/",
+        "/usr/share/tesseract-ocr/4.00/tessdata/",
+        "/usr/share/tesseract-ocr/4/tessdata/",
+        "/usr/share/tessdata/",
+    ]
+    for c in candidates:
+        if os.path.exists(c):
+            return c
+    return ""
+
+
+def start_backend():
+    logger.info("Launching HarshItPDF...")
+    main_class = _get_main_class()
+
+    env = os.environ.copy()
+    env["SERVER_PORT"] = str(BACKEND_PORT)
+    env["SYSTEM_ROOTURIPATH"] = ""
+    env["SECURITY_ENABLELOGIN"] = "true"
+    env["SECURITY_INITIALLOGIN_USERNAME"] = "admin"
+    env["SECURITY_INITIALLOGIN_PASSWORD"] = "changeme123"
+    env["UI_APPNAME"] = "HarshItPDF"
+    env["UI_APPNAVBARNAME"] = "HarshItPDF"
+    env["UI_HOMEDESCRIPTION"] = "Your private PDF powerhouse by HarshIt"
+    env["SYSTEM_SHOWUPDATE"] = "false"
+    env["PREMIUM_ENABLED"] = "true"
+    env["PREMIUM_KEY"] = "harshitpdf-unlocked-0000-0000-0000-000000000001"
+    env["DISABLE_ADDITIONAL_FEATURES"] = "false"
+    env["PYTHON_PATH"] = shutil.which("python3") or "/usr/bin/python3"
+    tessdata = _find_tessdata()
+    if tessdata:
+        env["TESSDATA_PREFIX"] = tessdata
+
+    logger.info(f"Launching Java backend on internal port {BACKEND_PORT}...")
+
+    global _backend_process
+    _backend_process = subprocess.Popen(
+        [
+            "java",
+            "-Xmx2G",
+            "-XX:+UseSerialGC",
+            "-XX:MaxRAMPercentage=60.0",
+            "-cp", EXTRACT_DIR,
+            main_class,
+        ],
+        env=env,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        text=True,
+    )
+    threading.Thread(target=_stream_output, args=(_backend_process.stdout,), daemon=True).start()
+    time.sleep(2)
+
+
+def check_backend():
+    try:
+        resp = urllib.request.urlopen(f"http://127.0.0.1:{BACKEND_PORT}/login", timeout=3)
+        return resp.status == 200
+    except Exception:
+        return False
+
+
+# ═══════════════════════════════════════════════════════════════
+# Service orchestrator  (runs at module import on HF Spaces)
+# ═══════════════════════════════════════════════════════════════
+
+def _start_services():
+    logger.info("=" * 60)
+    logger.info("HarshItPDF Starting...")
+    logger.info("=" * 60)
+
+    _download_jar()
+    _extract_jar()
+    _patch_files()
+
+    logger.info(f"Starting mock license server on port {LICENCE_SERVER_PORT}...")
+    lic_thread = threading.Thread(target=start_license_server, daemon=True)
+    lic_thread.start()
+    time.sleep(0.5)
+
+    start_backend()
+
+    logger.info("Waiting for backend to be ready...")
+    _backend_ready.wait(timeout=120)
+
+    if check_backend():
+        logger.info(f"HarshItPDF backend is live on port {BACKEND_PORT}")
+    else:
+        logger.warning("Backend health check failed — app may still be starting")
+
+    # Keep-alive monitor
+    while True:
+        if _backend_process and _backend_process.poll() is not None:
+            logger.error("Java backend exited! Restarting...")
+            _backend_ready.clear()
+            start_backend()
+            _backend_ready.wait(timeout=120)
+        time.sleep(10)
+
+
+# ═══════════════════════════════════════════════════════════════
+# Gradio UI
+# ═══════════════════════════════════════════════════════════════
+import gradio as gr
+
+# ZeroGPU guard (required on GPU-backed spaces, harmless on CPU)
+try:
+    import spaces
+    @spaces.GPU(duration=1)
+    def _gpuguard():
+        pass
+except ImportError:
+    pass
+
+
+def build_gradio_ui():
+    proxy_url = f"/proxy/{BACKEND_PORT}/"
+    with gr.Blocks(title="HarshItPDF", theme=gr.themes.Base()) as demo:
+        gr.HTML(f"""
+        <script>
+            (function(){{
+                const check = () => {{
+                    fetch("{proxy_url}login", {{mode: "no-cors"}})
+                        .then(() => window.location.href = "{proxy_url}")
+                        .catch(() => setTimeout(check, 3000));
+                }};
+                setTimeout(check, 2000);
+            }})();
+        </script>
+        <div style="text-align:center;padding-top:20vh;color:#e0e0ff;background:#0f0f23;min-height:100vh;font-family:sans-serif;">
+            <h1 style="font-size:2.5rem;background:linear-gradient(135deg,#6366f1,#a855f7);-webkit-background-clip:text;-webkit-text-fill-color:transparent;">HarshItPDF</h1>
+            <p style="opacity:0.7;">Your private PDF powerhouse</p>
+            <div style="width:40px;height:40px;border:3px solid rgba(99,102,241,0.3);border-top-color:#6366f1;border-radius:50%;animation:spin 1s linear infinite;margin:1rem auto;"></div>
+            <p style="font-family:monospace;font-size:0.9rem;opacity:0.6;margin-top:1rem;">Starting backend... This may take 1–2 min on cold start.</p>
+            <p style="font-size:0.85rem;opacity:0.5;margin-top:0.5rem;">Default login: admin / changeme123</p>
+            <style>@keyframes spin{{to{{transform:rotate(360deg)}}}}</style>
+        </div>
+        """)
+    return demo
+
+
+# Start services in background thread when module is imported
+_svc_thread = threading.Thread(target=_start_services, daemon=True)
+_svc_thread.start()
+
+# HF Spaces Gradio SDK requires `demo` at module scope
+demo = build_gradio_ui()

license_server.py

@@ -0,0 +1,68 @@
+"""
+mock-license-server — Standalone HTTP server that validates licenses.
+Replaces api.keygen.sh for the HarshItPDF license verification flow.
+"""
+
+import os
+import json
+import logging
+from http.server import HTTPServer, BaseHTTPRequestHandler
+
+PORT = int(os.environ.get("LICENCE_SERVER_PORT", "7871"))
+logger = logging.getLogger("license-server")
+
+VALID_RESPONSE = {
+    "meta": {"valid": True},
+    "data": {
+        "type": "license",
+        "id": "mock-license-001",
+        "attributes": {
+            "name": "HarshItPDF Enterprise License",
+            "key": "harshitpdf-unlocked-0000-0000-0000-000000000001",
+            "status": "ACTIVE",
+            "expiry": None,
+            "metadata": {
+                "isEnterprise": True,
+                "isPremium": True,
+                "maxUsers": 999,
+                "plan": "enterprise",
+                "tier": "enterprise",
+            },
+            "maxMachines": 999,
+        },
+    },
+}
+
+
+class LicenseHandler(BaseHTTPRequestHandler):
+    def do_POST(self):
+        body = self.rfile.read(int(self.headers.get("Content-Length", 0)))
+        logger.info(f"License check from {self.client_address}: {self.path}")
+        self.send_response(200)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Connection", "close")
+        self.end_headers()
+        self.wfile.write(json.dumps(VALID_RESPONSE).encode())
+
+    def do_GET(self):
+        self.send_response(200)
+        self.send_header("Content-Type", "application/json")
+        self.send_header("Connection", "close")
+        self.end_headers()
+        self.wfile.write(
+            json.dumps({"ok": True, "service": "mock-license-server", "version": "1.0"}).encode()
+        )
+
+    def log_message(self, fmt, *args):
+        logger.info(fmt % args)
+
+
+def start_license_server():
+    server = HTTPServer(("0.0.0.0", PORT), LicenseHandler)
+    logger.info(f"Mock license server listening on port {PORT}")
+    server.serve_forever()
+
+
+if __name__ == "__main__":
+    logging.basicConfig(level=logging.INFO, format="[license-server] %(message)s")
+    start_license_server()

packages.txt

@@ -0,0 +1,5 @@
+openjdk-17-jdk-headless
+tesseract-ocr
+tesseract-ocr-eng
+unzip
+wget

requirements.txt

@@ -0,0 +1 @@
+gradio>=4.0