Upload 5 files

app.py

@@ -1,1315 +1,723 @@
 """
-OmniParse AI — kompletní B2B SaaS pro zpracování faktur.
-Architektura: CORE LOGIC (framework-agnostic, dá se volat i z FastAPI/HTML frontendu)
-             + GRADIO UI LAYER (jen volá CORE funkce, žádná business logika v UI kódu).
-Když budeš chtít přejít na vlastní HTML/JS frontend, stačí obalit CORE funkce
-do FastAPI endpointů (viz sekce "CORE LOGIC" níže) — nic se v nich měnit nemusí.
+app.py -- OmniParse AI main application.
+
+Architecture:
+    * Gradio is used purely as a headless API/session backend (Blocks with
+      visible=False components acting as an RPC bridge).
+    * The actual UI is a single gr.HTML() block containing hand-written
+      Tailwind-based HTML/CSS/JS. JS calls into Python by writing into a
+      hidden gr.Textbox and firing a hidden gr.Button.click().
+    * Gradio 4.x is built on FastAPI, so we mount the Stripe webhook route
+      directly on the underlying FastAPI app (needs raw bytes + header
+      signature verification, which Gradio components can't provide).
 """
 
 import os
-import re
-import io
 import json
-import time
 import base64
-import sqlite3
-import secrets
-import hashlib
-import traceback
-from datetime import datetime, timedelta, timezone
+import logging
 
 import gradio as gr
-import requests
-from PIL import Image
 
-# ---------------------------------------------------------------------------
-# VOLITELNÉ KNIHOVNY — nikdy nesmí spadnout celá appka, když chybí balíček
-# ---------------------------------------------------------------------------
-try:
-    import bcrypt
-    BCRYPT_OK = True
-except Exception:
-    BCRYPT_OK = False
-
-try:
-    import pytesseract
-    TESSERACT_OK = True
-except Exception:
-    TESSERACT_OK = False
-
-try:
-    from pdf2image import convert_from_bytes
-    PDF2IMAGE_OK = True
-except Exception:
-    PDF2IMAGE_OK = False
-
-try:
-    from groq import Groq
-    GROQ_SDK_OK = True
-except Exception:
-    GROQ_SDK_OK = False
-
-try:
-    import stripe
-    STRIPE_SDK_OK = True
-except Exception:
-    STRIPE_SDK_OK = False
-
-try:
-    from supabase import create_client
-    SUPABASE_SDK_OK = True
-except Exception:
-    SUPABASE_SDK_OK = False
-
-
-# ===========================================================================
-# KONFIGURACE
-# ===========================================================================
-HF_TOKEN = os.environ.get("HF_TOKEN", "")
-GROQ_API_KEY = os.environ.get("GROQ_API_KEY", "")
-SUPABASE_URL = os.environ.get("SUPABASE_URL", "")
-SUPABASE_KEY = os.environ.get("SUPABASE_KEY", "")
-GOOGLE_VISION_KEY = os.environ.get("GOOGLE_VISION_KEY", "")
-STRIPE_SECRET_KEY = os.environ.get("STRIPE_SECRET_KEY", "")
-STRIPE_PRICE_BASIC = os.environ.get("STRIPE_PRICE_BASIC", "")
-STRIPE_PRICE_PRO = os.environ.get("STRIPE_PRICE_PRO", "")
-STRIPE_PRICE_ENTERPRISE = os.environ.get("STRIPE_PRICE_ENTERPRISE", "")
-APP_URL = os.environ.get("APP_URL", "http://localhost:7860")
-
-MAX_FILE_SIZE_MB = 20
-MAX_FILE_SIZE_BYTES = MAX_FILE_SIZE_MB * 1024 * 1024
+import auth
+import backend
+import database as db
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("omniparse.app")
+
+APP_TITLE = "OmniParse AI"
 
 PLAN_LIMITS = {
-    "free": 20,
-    "basic": 200,
-    "pro": 2000,
-    "enterprise": float("inf"),
+    "free": {"invoices": 20, "users": 1, "label": "Free"},
+    "basic": {"invoices": 200, "users": 1, "label": "Basic"},
+    "pro": {"invoices": 2000, "users": 3, "label": "Pro"},
+    "enterprise": {"invoices": float("inf"), "users": float("inf"), "label": "Enterprise"},
 }
 
-PLAN_PRICE_IDS = {
-    "basic": STRIPE_PRICE_BASIC,
-    "pro": STRIPE_PRICE_PRO,
-    "enterprise": STRIPE_PRICE_ENTERPRISE,
+# ---------------------------------------------------------------------------
+# Shared CSS: hides Gradio chrome, defines tooltips + skeleton loaders.
+# ---------------------------------------------------------------------------
+BASE_CSS = """
+<style>
+footer, .gradio-container .footer, #footer { display: none !important; }
+.gradio-container { max-width: 100% !important; padding: 0 !important; background: #0b0d12 !important; }
+body { margin: 0; font-family: 'Inter', ui-sans-serif, system-ui, sans-serif; }
+
+/* ---------------- Tooltip ---------------- */
+.op-tooltip { position: relative; display: inline-flex; }
+.op-tooltip::after {
+    content: attr(data-tip);
+    position: absolute;
+    bottom: 125%; left: 50%; transform: translateX(-50%);
+    background: #111827; color: #f9fafb; padding: 6px 10px;
+    border-radius: 6px; font-size: 12px; white-space: nowrap;
+    opacity: 0; pointer-events: none; transition: opacity 0.15s ease;
+    box-shadow: 0 4px 14px rgba(0,0,0,0.35);
+    z-index: 50;
+}
+.op-tooltip::before {
+    content: ""; position: absolute; bottom: 118%; left: 50%; transform: translateX(-50%);
+    border: 5px solid transparent; border-top-color: #111827;
+    opacity: 0; transition: opacity 0.15s ease; z-index: 50;
 }
+.op-tooltip:hover::after, .op-tooltip:hover::before { opacity: 1; }
 
-if STRIPE_SDK_OK and STRIPE_SECRET_KEY:
-    try:
-        stripe.api_key = STRIPE_SECRET_KEY
-    except Exception:
-        pass
-
-# jednoduchý in-memory rate limiter: {key: [timestamps]}
-_RATE_LIMIT_STORE = {}
-
-
-def rate_limited(key: str, max_attempts: int = 5, window_seconds: int = 60) -> bool:
-    """Vrátí True pokud je klíč (email/IP) aktuálně rate-limitovaný.
-    Ochrana proti brute-force na login/signup/API endpointy."""
-    try:
-        now = time.time()
-        attempts = _RATE_LIMIT_STORE.get(key, [])
-        attempts = [t for t in attempts if now - t < window_seconds]
-        if len(attempts) >= max_attempts:
-            _RATE_LIMIT_STORE[key] = attempts
-            return True
-        attempts.append(now)
-        _RATE_LIMIT_STORE[key] = attempts
-        return False
-    except Exception:
-        return False  # radši nechat projít než appku spadnout
-
-
-# ===========================================================================
-# CORE LOGIC — DATABÁZOVÁ VRSTVA (Supabase primárně, SQLite fallback)
-# ===========================================================================
-class SQLiteDB:
-    """Fallback databáze, pokud chybí Supabase secrets. Data jsou ephemeral
-    (zmizí při restartu HF Space), ale appka díky tomu nikdy nespadne."""
-
-    def __init__(self, path="omniparse.db"):
-        self.path = path
-        self.conn = sqlite3.connect(self.path, check_same_thread=False)
-        self._init_schema()
-
-    def _init_schema(self):
-        c = self.conn.cursor()
-        c.execute(\"\"\"CREATE TABLE IF NOT EXISTS users (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            email TEXT UNIQUE NOT NULL,
-            name TEXT NOT NULL,
-            password TEXT NOT NULL,
-            plan TEXT NOT NULL DEFAULT 'free',
-            stripe_cid TEXT,
-            api_key TEXT,
-            created_at TEXT
-        )\"\"\")
-        c.execute(\"\"\"CREATE TABLE IF NOT EXISTS sessions (
-            token TEXT PRIMARY KEY,
-            user_id INTEGER NOT NULL,
-            expires_at TEXT NOT NULL
-        )\"\"\")
-        c.execute(\"\"\"CREATE TABLE IF NOT EXISTS invoices (
-            id INTEGER PRIMARY KEY AUTOINCREMENT,
-            user_id INTEGER NOT NULL,
-            filename TEXT,
-            vendor TEXT,
-            inv_number TEXT,
-            inv_date TEXT,
-            due_date TEXT,
-            amount REAL,
-            vat_amount REAL,
-            total REAL,
-            currency TEXT DEFAULT 'USD',
-            status TEXT DEFAULT 'done',
-            is_duplicate INTEGER DEFAULT 0,
-            confidence REAL,
-            raw_json TEXT,
-            created_at TEXT
-        )\"\"\")
-        self.conn.commit()
-
-    def create_user(self, email, name, password_hash, plan="free", api_key=None):
-        c = self.conn.cursor()
-        c.execute(
-            "INSERT INTO users (email, name, password, plan, api_key, created_at) VALUES (?,?,?,?,?,?)",
-            (email, name, password_hash, plan, api_key, datetime.now(timezone.utc).isoformat()),
-        )
-        self.conn.commit()
-        return c.lastrowid
-
-    def get_user_by_email(self, email):
-        c = self.conn.cursor()
-        c.execute("SELECT id,email,name,password,plan,stripe_cid,api_key FROM users WHERE email=?", (email,))
-        row = c.fetchone()
-        if not row:
-            return None
-        keys = ["id", "email", "name", "password", "plan", "stripe_cid", "api_key"]
-        return dict(zip(keys, row))
-
-    def get_user_by_id(self, user_id):
-        c = self.conn.cursor()
-        c.execute("SELECT id,email,name,password,plan,stripe_cid,api_key FROM users WHERE id=?", (user_id,))
-        row = c.fetchone()
-        if not row:
-            return None
-        keys = ["id", "email", "name", "password", "plan", "stripe_cid", "api_key"]
-        return dict(zip(keys, row))
-
-    def update_user_plan(self, user_id, plan, stripe_cid=None):
-        c = self.conn.cursor()
-        if stripe_cid:
-            c.execute("UPDATE users SET plan=?, stripe_cid=? WHERE id=?", (plan, stripe_cid, user_id))
-        else:
-            c.execute("UPDATE users SET plan=? WHERE id=?", (plan, user_id))
-        self.conn.commit()
-
-    def update_password(self, user_id, password_hash):
-        c = self.conn.cursor()
-        c.execute("UPDATE users SET password=? WHERE id=?", (password_hash, user_id))
-        self.conn.commit()
-
-    def delete_user(self, user_id):
-        c = self.conn.cursor()
-        c.execute("DELETE FROM users WHERE id=?", (user_id,))
-        c.execute("DELETE FROM sessions WHERE user_id=?", (user_id,))
-        c.execute("DELETE FROM invoices WHERE user_id=?", (user_id,))
-        self.conn.commit()
-
-    def create_session(self, token, user_id, expires_at):
-        c = self.conn.cursor()
-        c.execute("INSERT INTO sessions (token,user_id,expires_at) VALUES (?,?,?)", (token, user_id, expires_at))
-        self.conn.commit()
-
-    def get_session(self, token):
-        c = self.conn.cursor()
-        c.execute("SELECT token,user_id,expires_at FROM sessions WHERE token=?", (token,))
-        row = c.fetchone()
-        if not row:
-            return None
-        return {"token": row[0], "user_id": row[1], "expires_at": row[2]}
-
-    def delete_session(self, token):
-        c = self.conn.cursor()
-        c.execute("DELETE FROM sessions WHERE token=?", (token,))
-        self.conn.commit()
-
-    def save_invoice(self, user_id, data):
-        c = self.conn.cursor()
-        c.execute(\"\"\"INSERT INTO invoices
-            (user_id,filename,vendor,inv_number,inv_date,due_date,amount,vat_amount,total,currency,status,is_duplicate,confidence,raw_json,created_at)
-            VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)\"\"\",
-            (user_id, data.get("filename"), data.get("vendor"), data.get("inv_number"),
-             data.get("inv_date"), data.get("due_date"), data.get("amount"), data.get("vat_amount"),
-             data.get("total"), data.get("currency", "USD"), data.get("status", "done"),
-             int(data.get("is_duplicate", False)), data.get("confidence"),
-             json.dumps(data.get("raw_json", {})), datetime.now(timezone.utc).isoformat()))
-        self.conn.commit()
-        return c.lastrowid
-
-    def get_invoices(self, user_id):
-        c = self.conn.cursor()
-        c.execute(\"\"\"SELECT id,filename,vendor,inv_number,inv_date,due_date,amount,vat_amount,total,
-            currency,status,is_duplicate,confidence,raw_json,created_at FROM invoices
-            WHERE user_id=? ORDER BY created_at DESC\"\"\", (user_id,))
-        rows = c.fetchall()
-        keys = ["id", "filename", "vendor", "inv_number", "inv_date", "due_date", "amount", "vat_amount",
-                "total", "currency", "status", "is_duplicate", "confidence", "raw_json", "created_at"]
-        return [dict(zip(keys, r)) for r in rows]
-
-    def delete_invoice(self, invoice_id, user_id):
-        c = self.conn.cursor()
-        c.execute("DELETE FROM invoices WHERE id=? AND user_id=?", (invoice_id, user_id))
-        self.conn.commit()
-
-    def count_invoices_this_month(self, user_id):
-        c = self.conn.cursor()
-        start = datetime.now(timezone.utc).replace(day=1, hour=0, minute=0, second=0, microsecond=0).isoformat()
-        c.execute("SELECT COUNT(*) FROM invoices WHERE user_id=? AND created_at>=?", (user_id, start))
-        return c.fetchone()[0]
-
-    def count_duplicate(self, user_id, vendor, total):
-        c = self.conn.cursor()
-        start = datetime.now(timezone.utc).replace(day=1, hour=0, minute=0, second=0, microsecond=0).isoformat()
-        c.execute(\"\"\"SELECT COUNT(*) FROM invoices WHERE user_id=? AND vendor=? AND ABS(total-?)<0.01
-            AND created_at>=?\"\"\", (user_id, vendor, total, start))
-        return c.fetchone()[0]
-
-
-class SupabaseDB:
-    \"\"\"Wrapper nad Supabase se stejným rozhraním jako SQLiteDB, aby zbytek
-    kódu vůbec nevěděl, která databáze běží pod kapotou.\"\"\"
-
-    def __init__(self, url, key):
-        self.client = create_client(url, key)
-
-    def create_user(self, email, name, password_hash, plan="free", api_key=None):
-        res = self.client.table("users").insert({
-            "email": email, "name": name, "password": password_hash,
-            "plan": plan, "api_key": api_key,
-        }).execute()
-        return res.data[0]["id"]
-
-    def get_user_by_email(self, email):
-        res = self.client.table("users").select("*").eq("email", email).execute()
-        return res.data[0] if res.data else None
-
-    def get_user_by_id(self, user_id):
-        res = self.client.table("users").select("*").eq("id", user_id).execute()
-        return res.data[0] if res.data else None
-
-    def update_user_plan(self, user_id, plan, stripe_cid=None):
-        payload = {"plan": plan}
-        if stripe_cid:
-            payload["stripe_cid"] = stripe_cid
-        self.client.table("users").update(payload).eq("id", user_id).execute()
-
-    def update_password(self, user_id, password_hash):
-        self.client.table("users").update({"password": password_hash}).eq("id", user_id).execute()
-
-    def delete_user(self, user_id):
-        self.client.table("invoices").delete().eq("user_id", user_id).execute()
-        self.client.table("sessions").delete().eq("user_id", user_id).execute()
-        self.client.table("users").delete().eq("id", user_id).execute()
-
-    def create_session(self, token, user_id, expires_at):
-        self.client.table("sessions").insert({
-            "token": token, "user_id": user_id, "expires_at": expires_at
-        }).execute()
-
-    def get_session(self, token):
-        res = self.client.table("sessions").select("*").eq("token", token).execute()
-        return res.data[0] if res.data else None
-
-    def delete_session(self, token):
-        self.client.table("sessions").delete().eq("token", token).execute()
-
-    def save_invoice(self, user_id, data):
-        payload = dict(data)
-        payload["user_id"] = user_id
-        payload["raw_json"] = json.dumps(payload.get("raw_json", {}))
-        res = self.client.table("invoices").insert(payload).execute()
-        return res.data[0]["id"]
-
-    def get_invoices(self, user_id):
-        res = self.client.table("invoices").select("*").eq("user_id", user_id).order("created_at", desc=True).execute()
-        return res.data
-
-    def delete_invoice(self, invoice_id, user_id):
-        self.client.table("invoices").delete().eq("id", invoice_id).eq("user_id", user_id).execute()
-
-    def count_invoices_this_month(self, user_id):
-        start = datetime.now(timezone.utc).replace(day=1, hour=0, minute=0, second=0, microsecond=0).isoformat()
-        res = self.client.table("invoices").select("id", count="exact").eq("user_id", user_id).gte("created_at", start).execute()
-        return res.count or 0
-
-    def count_duplicate(self, user_id, vendor, total):
-        start = datetime.now(timezone.utc).replace(day=1, hour=0, minute=0, second=0, microsecond=0).isoformat()
-        # Supabase nepodporuje ABS() přes REST snadno -> filtrujeme total v Pythonu
-        rows = self.client.table("invoices").select("total").eq("user_id", user_id).eq("vendor", vendor).gte("created_at", start).execute()
-        return sum(1 for r in rows.data if abs((r.get("total") or 0) - total) < 0.01)
-
-
-def init_db():
-    \"\"\"Vybere Supabase pokud jsou secrets nastavené a SDK je dostupné,
-    jinak spadne zpátky na SQLite. Appka nikdy nespadne na chybějícím secretu.\"\"\"
-    if SUPABASE_URL and SUPABASE_KEY and SUPABASE_SDK_OK:
-        try:
-            db = SupabaseDB(SUPABASE_URL, SUPABASE_KEY)
-            db.client.table("users").select("id").limit(1).execute()
-            print("[DB] Připojeno k Supabase.")
-            return db
-        except Exception as e:
-            print(f"[DB] Supabase selhalo ({e}), padám na SQLite fallback.")
-            return SQLiteDB()
-    print("[DB] Supabase není nakonfigurováno, používám SQLite.")
-    return SQLiteDB()
-
-
-DB = init_db()
-
-
-# ===========================================================================
-# CORE LOGIC — HESLA, AUTH, VALIDACE (server-side, nikdy jen client-side)
-# ===========================================================================
-def hash_password(password: str) -> str:
-    \"\"\"Bcrypt pokud je dostupný (moderní, doporučený), jinak PBKDF2-SHA256
-    se solí jako bezpečný fallback (rozhodně ne MD5/SHA1).\"\"\"
-    try:
-        if BCRYPT_OK:
-            return "bcrypt$" + bcrypt.hashpw(password.encode(), bcrypt.gensalt()).decode()
-        salt = secrets.token_hex(16)
-        digest = hashlib.pbkdf2_hmac("sha256", password.encode(), salt.encode(), 200_000).hex()
-        return f"pbkdf2${salt}${digest}"
-    except Exception:
-        salt = secrets.token_hex(16)
-        digest = hashlib.pbkdf2_hmac("sha256", password.encode(), salt.encode(), 200_000).hex()
-        return f"pbkdf2${salt}${digest}"
-
-
-def verify_password(password: str, stored_hash: str) -> bool:
-    try:
-        if stored_hash.startswith("bcrypt$") and BCRYPT_OK:
-            return bcrypt.checkpw(password.encode(), stored_hash[len("bcrypt$"):].encode())
-        if stored_hash.startswith("pbkdf2$"):
-            _, salt, digest = stored_hash.split("$")
-            check = hashlib.pbkdf2_hmac("sha256", password.encode(), salt.encode(), 200_000).hex()
-            return secrets.compare_digest(check, digest)
-        return False
-    except Exception:
-        return False
-
-
-def is_valid_email(email: str) -> bool:
-    return bool(re.match(r"^[^@\s]+@[^@\s]+\.[^@\s]+$", email or ""))
-
-
-def password_strength_ok(password: str) -> (bool, str):
-    if not password or len(password) < 8:
-        return False, "Heslo musí mít alespoň 8 znaků."
-    if not re.search(r"[A-Za-z]", password) or not re.search(r"[0-9]", password):
-        return False, "Heslo musí obsahovat písmena i čísla."
-    return True, ""
-
-
-def is_password_leaked(password: str) -> bool:
-    \"\"\"HaveIBeenPwned Pwned Passwords API — k-anonymity model, zdarma bez klíče.
-    Když je síť nedostupná, prostě kontrolu přeskočíme (fail-open, appka nespadne).\"\"\"
-    try:
-        sha1 = hashlib.sha1(password.encode()).hexdigest().upper()
-        prefix, suffix = sha1[:5], sha1[5:]
-        resp = requests.get(f"https://api.pwnedpasswords.com/range/{prefix}", timeout=4)
-        if resp.status_code == 200:
-            return any(line.split(":")[0] == suffix for line in resp.text.splitlines())
-        return False
-    except Exception:
-        return False
-
-
-def generate_api_key() -> str:
-    return "op_live_" + secrets.token_urlsafe(24)
-
-
-def create_session_token(user_id: int) -> str:
-    token = secrets.token_urlsafe(32)
-    expires = (datetime.now(timezone.utc) + timedelta(days=7)).isoformat()
-    try:
-        DB.create_session(token, user_id, expires)
-    except Exception as e:
-        print(f"[AUTH] Session se nepovedlo uložit: {e}")
-    return token
-
-
-def resolve_session(token: str):
-    \"\"\"Vrátí user dict pokud je token platný a nevypršel, jinak None.
-    Token žije v gr.State (server-side per-browser-tab paměť), NE v localStorage,
-    což řeší XSS riziko klasického 'token v localStorage' problému.\"\"\"
-    if not token:
-        return None
-    try:
-        sess = DB.get_session(token)
-        if not sess:
-            return None
-        expires = datetime.fromisoformat(sess["expires_at"])
-        if expires.tzinfo is None:
-            expires = expires.replace(tzinfo=timezone.utc)
-        if expires < datetime.now(timezone.utc):
-            DB.delete_session(token)
-            return None
-        return DB.get_user_by_id(sess["user_id"])
-    except Exception as e:
-        print(f"[AUTH] resolve_session chyba: {e}")
-        return None
-
-
-def signup(name, email, password, accepted_terms) -> (bool, str, str):
-    \"\"\"Vrací (success, message, session_token).\"\"\"
-    try:
-        email = (email or "").strip().lower()
-        name = (name or "").strip()
-        if rate_limited(f"signup:{email}", max_attempts=5, window_seconds=300):
-            return False, "Příliš mnoho pokusů o registraci. Zkus to za pár minut.", ""
-        if not name:
-            return False, "Vyplň prosím jméno.", ""
-        if not is_valid_email(email):
-            return False, "Zadej platný pracovní e-mail.", ""
-        if not accepted_terms:
-            return False, "Musíš souhlasit s Terms of Use a Privacy Policy.", ""
-        ok, msg = password_strength_ok(password)
-        if not ok:
-            return False, msg, ""
-        if is_password_leaked(password):
-            return False, "Toto heslo bylo nalezeno v uniklých databázích. Zvol jiné.", ""
-        if DB.get_user_by_email(email):
-            return False, "Účet s tímto e-mailem už existuje.", ""
-        pw_hash = hash_password(password)
-        api_key = generate_api_key()
-        user_id = DB.create_user(email, name, pw_hash, plan="free", api_key=api_key)
-        token = create_session_token(user_id)
-        return True, "Účet vytvořen!", token
-    except Exception as e:
-        traceback.print_exc()
-        return False, f"Chyba při registraci: {e}", ""
-
-
-def login(email, password) -> (bool, str, str):
-    try:
-        email = (email or "").strip().lower()
-        if rate_limited(f"login:{email}", max_attempts=8, window_seconds=300):
-            return False, "Příliš mnoho pokusů o přihlášení. Zkus to za pár minut.", ""
-        if not email or not password:
-            return False, "Vyplň e-mail i heslo.", ""
-        user = DB.get_user_by_email(email)
-        if not user or not verify_password(password, user["password"]):
-            return False, "Nesprávný e-mail nebo heslo.", ""
-        token = create_session_token(user["id"])
-        return True, "Přihlášení úspěšné!", token
-    except Exception as e:
-        traceback.print_exc()
-        return False, f"Chyba při přihlašování: {e}", ""
-
-
-def logout(token):
-    try:
-        if token:
-            DB.delete_session(token)
-    except Exception as e:
-        print(f"[AUTH] logout chyba: {e}")
-
-
-def bootstrap_demo_account():
-    try:
-        if not DB.get_user_by_email("demo@omniparse.ai"):
-            pw_hash = hash_password("demo1234")
-            api_key = generate_api_key()
-            DB.create_user("demo@omniparse.ai", "Demo User", pw_hash, plan="pro", api_key=api_key)
-            print("[DEMO] Demo účet vytvořen: demo@omniparse.ai / demo1234")
-    except Exception as e:
-        print(f"[DEMO] Nepovedlo se vytvořit demo účet: {e}")
-
-
-bootstrap_demo_account()
-
-
-# ===========================================================================
-# CORE LOGIC — AI PIPELINE (OCR -> LLM -> regex fallback)
-# ===========================================================================
-def ocr_google_vision(image_bytes: bytes) -> str:
-    if not GOOGLE_VISION_KEY:
-        return ""
-    try:
-        b64 = base64.b64encode(image_bytes).decode()
-        url = f"https://vision.googleapis.com/v1/images:annotate?key={GOOGLE_VISION_KEY}"
-        payload = {"requests": [{"image": {"content": b64}, "features": [{"type": "TEXT_DETECTION"}]}]}
-        resp = requests.post(url, json=payload, timeout=15)
-        data = resp.json()
-        return data["responses"][0].get("fullTextAnnotation", {}).get("text", "")
-    except Exception as e:
-        print(f"[OCR] Google Vision selhalo: {e}")
-        return ""
-
-
-def ocr_tesseract(image: Image.Image) -> str:
-    if not TESSERACT_OK:
-        return ""
-    try:
-        gray = image.convert("L")
-        return pytesseract.image_to_string(gray, lang="eng+ces")
-    except Exception:
-        try:
-            return pytesseract.image_to_string(image.convert("L"), lang="eng")
-        except Exception as e:
-            print(f"[OCR] Tesseract selhalo: {e}")
-            return ""
-
-
-def file_to_images(file_bytes: bytes, filename: str):
-    \"\"\"Vrátí list PIL Image objektů — z PDF všechny stránky, z obrázku jednu.\"\"\"
-    try:
-        ext = filename.lower().rsplit(".", 1)[-1] if "." in filename else ""
-        if ext == "pdf":
-            if not PDF2IMAGE_OK:
-                raise RuntimeError("pdf2image / poppler není dostupný na tomto Space.")
-            return convert_from_bytes(file_bytes, dpi=200)
-        img = Image.open(io.BytesIO(file_bytes))
-        img.load()
-        return [img]
-    except Exception as e:
-        print(f"[FILE] Nepodařilo se otevřít soubor {filename}: {e}")
-        return []
-
-
-def extract_text_from_images(images) -> str:
-    full_text = ""
-    for img in images[:5]:  # bezpečnostní limit — max 5 stránek na fakturu
-        buf = io.BytesIO()
-        img.convert("RGB").save(buf, format="JPEG", quality=85)
-        img_bytes = buf.getvalue()
-        text = ""
-        if GOOGLE_VISION_KEY:
-            text = ocr_google_vision(img_bytes)
-        if len(text.strip()) < 30:
-            text = ocr_tesseract(img)
-        full_text += text + "\n"
-    return full_text.strip()
-
-
-AI_SYSTEM_PROMPT = (
-    "You are an invoice data extraction engine. Extract structured data from the raw OCR text "
-    "of an invoice. Return ONLY valid JSON, no markdown, no explanation, with exactly these keys: "
-    'vendor (string), inv_number (string), inv_date (YYYY-MM-DD or empty string), '
-    'due_date (YYYY-MM-DD or empty string), amount (number, subtotal before tax), '
-    'vat_amount (number), total (number), currency (3-letter code like USD/EUR/CZK), '
-    'line_items (array of {description, quantity, unit_price, total}). '
-    "If a field cannot be found, use empty string or 0. Never invent data you cannot find."
-)
-
-
-def ai_extract_groq(ocr_text: str):
-    if not (GROQ_API_KEY and GROQ_SDK_OK):
-        return None
-    try:
-        client = Groq(api_key=GROQ_API_KEY)
-        resp = client.chat.completions.create(
-            model="llama-3.1-8b-instant",
-            messages=[
-                {"role": "system", "content": AI_SYSTEM_PROMPT},
-                {"role": "user", "content": ocr_text[:3000]},
-            ],
-            max_tokens=512,
-            temperature=0.05,
-            timeout=10,
-        )
-        content = resp.choices[0].message.content
-        content = re.sub(r"^```json|```$", "", content.strip(), flags=re.MULTILINE).strip()
-        return json.loads(content)
-    except Exception as e:
-        print(f"[AI] Groq selhalo: {e}")
-        return None
-
-
-def ai_extract_hf(ocr_text: str):
-    if not HF_TOKEN:
-        return None
-    try:
-        url = "https://api-inference.huggingface.co/models/mistralai/Mistral-7B-Instruct-v0.3"
-        headers = {"Authorization": f"Bearer {HF_TOKEN}"}
-        prompt = f"<s>[INST] {AI_SYSTEM_PROMPT}\\n\\n{ocr_text[:3000]} [/INST]"
-        payload = {"inputs": prompt, "parameters": {"max_new_tokens": 512, "temperature": 0.05, "return_full_text": False}}
-        resp = requests.post(url, headers=headers, json=payload, timeout=45)
-        if resp.status_code == 503:
-            time.sleep(25)
-            resp = requests.post(url, headers=headers, json=payload, timeout=45)
-        data = resp.json()
-        text = data[0]["generated_text"] if isinstance(data, list) else data.get("generated_text", "")
-        text = re.sub(r"^```json|```$", "", text.strip(), flags=re.MULTILINE).strip()
-        match = re.search(r"\\{.*\\}", text, re.DOTALL)
-        return json.loads(match.group(0)) if match else None
-    except Exception as e:
-        print(f"[AI] HF Inference selhalo: {e}")
-        return None
-
-
-def regex_extract(ocr_text: str):
-    try:
-        inv_number_m = re.search(r"(?:invoice|inv)[#:\\s]+([A-Z0-9\\-]{4,24})", ocr_text, re.I)
-        dates = re.findall(r"\\d{1,2}[\\/.-]\\d{1,2}[\\/.-]\\d{4}", ocr_text)
-        total_m = re.search(r"(?:total|amount due)[\\s:$]+([0-9,.\\.]+)", ocr_text, re.I)
-        vendor = next((l.strip() for l in ocr_text.splitlines() if l.strip()), "Unknown vendor")
-        total = 0.0
-        if total_m:
-            try:
-                total = float(total_m.group(1).replace(",", ""))
-            except Exception:
-                total = 0.0
-        return {
-            "vendor": vendor[:120],
-            "inv_number": inv_number_m.group(1) if inv_number_m else "",
-            "inv_date": dates[0] if dates else "",
-            "due_date": dates[1] if len(dates) > 1 else "",
-            "amount": total,
-            "vat_amount": 0.0,
-            "total": total,
-            "currency": "USD",
-            "line_items": [],
-        }
-    except Exception as e:
-        print(f"[AI] Regex fallback selhalo: {e}")
-        return {"vendor": "Unknown", "inv_number": "", "inv_date": "", "due_date": "",
-                "amount": 0, "vat_amount": 0, "total": 0, "currency": "USD", "line_items": []}
-
-
-def run_ai_pipeline(ocr_text: str):
-    if not ocr_text.strip():
-        data = regex_extract("")
-        data["_ai_source"] = "empty_ocr"
-        return data
-    data = ai_extract_groq(ocr_text)
-    if data:
-        data["_ai_source"] = "groq"
-        return data
-    data = ai_extract_hf(ocr_text)
-    if data:
-        data["_ai_source"] = "huggingface"
-        return data
-    data = regex_extract(ocr_text)
-    data["_ai_source"] = "regex_fallback"
-    return data
-
-
-def validate_invoice(data: dict) -> list:
-    \"\"\"Cross-field validace — vrací list textových warningů.\"\"\"
-    warnings = []
-    try:
-        amount = float(data.get("amount") or 0)
-        vat = float(data.get("vat_amount") or 0)
-        total = float(data.get("total") or 0)
-        if total > 0 and abs((amount + vat) - total) > 0.10:
-            warnings.append(f"Subtotal + DPH ({amount + vat:.2f}) neodpovídá total ({total:.2f}).")
-        if amount > 0 and vat / amount > 0.30:
-            warnings.append("DPH sazba vyšší než 30 % — zkontroluj ručně.")
-        inv_date, due_date = data.get("inv_date"), data.get("due_date")
-        if inv_date and due_date:
-            try:
-                d1 = datetime.fromisoformat(inv_date)
-                d2 = datetime.fromisoformat(due_date)
-                if d2 < d1:
-                    warnings.append("Splatnost je dřív než datum vystavení faktury.")
-            except Exception:
-                pass
-        if not data.get("vendor"):
-            warnings.append("Nepodařilo se rozpoznat dodavatele.")
-    except Exception as e:
-        warnings.append(f"Validace selhala: {e}")
-    return warnings
-
-
-def process_invoice_file(user, file_path, filename):
-    \"\"\"Kompletní pipeline pro jeden soubor. Vrací dict se všemi daty + warnings.\"\"\"
-    try:
-        with open(file_path, "rb") as f:
-            file_bytes = f.read()
-        if len(file_bytes) > MAX_FILE_SIZE_BYTES:
-            return {"error": f"Soubor {filename} přesahuje limit {MAX_FILE_SIZE_MB}MB."}
-
-        images = file_to_images(file_bytes, filename)
-        if not images:
-            return {"error": f"Nepodařilo se otevřít soubor {filename} (nepodporovaný formát nebo poškozený soubor)."}
-
-        ocr_text = extract_text_from_images(images)
-        extracted = run_ai_pipeline(ocr_text)
-
-        warnings = validate_invoice(extracted)
-        plan = user.get("plan", "free")
-
-        is_dup = False
-        if plan in ("pro", "enterprise") and extracted.get("vendor") and extracted.get("total"):
-            try:
-                dup_count = DB.count_duplicate(user["id"], extracted["vendor"], float(extracted["total"] or 0))
-                is_dup = dup_count > 0
-            except Exception as e:
-                print(f"[DUP] kontrola duplicit selhala: {e}")
-
-        status = "review" if warnings else "done"
-        if is_dup:
-            status = "duplicate"
-
-        record = {
-            "filename": filename,
-            "vendor": extracted.get("vendor", ""),
-            "inv_number": extracted.get("inv_number", ""),
-            "inv_date": extracted.get("inv_date", ""),
-            "due_date": extracted.get("due_date", ""),
-            "amount": float(extracted.get("amount") or 0),
-            "vat_amount": float(extracted.get("vat_amount") or 0),
-            "total": float(extracted.get("total") or 0),
-            "currency": extracted.get("currency", "USD"),
-            "status": status,
-            "is_duplicate": is_dup,
-            "confidence": 0.95 if extracted.get("_ai_source") in ("groq", "huggingface") else 0.55,
-            "raw_json": extracted,
-        }
-        DB.save_invoice(user["id"], record)
-        record["warnings"] = warnings
-        return record
-    except Exception as e:
-        traceback.print_exc()
-        return {"error": f"Zpracování {filename} selhalo: {e}"}
-
-
-# ===========================================================================
-# CORE LOGIC — AI CHAT AGENT (Pro+)
-# ===========================================================================
-def ai_chat_answer(user, question: str, history: list) -> str:
-    try:
-        if not question or not question.strip():
-            return "Napiš prosím otázku k tvým fakturám."
-        if user.get("plan") not in ("pro", "enterprise"):
-            return "AI Chat je dostupný od plánu Pro. Upgraduj v sekci ⚡ Upgrade."
-        invoices = DB.get_invoices(user["id"])[:200]
-        context_rows = [
-            f"- {inv.get('vendor')} | č.{inv.get('inv_number')} | {inv.get('inv_date')} | "
-            f"total {inv.get('total')} {inv.get('currency')} | status {inv.get('status')}"
-            for inv in invoices
-        ]
-        context = "\\n".join(context_rows) if context_rows else "Uživatel zatím nemá žádné faktury."
-        if GROQ_API_KEY and GROQ_SDK_OK:
-            client = Groq(api_key=GROQ_API_KEY)
-            resp = client.chat.completions.create(
-                model="llama-3.1-8b-instant",
-                messages=[
-                    {"role": "system", "content": "You are a helpful assistant answering questions about the user's invoices based ONLY on the data provided below. Be concise."},
-                    {"role": "user", "content": f"Invoices:\\n{context}\\n\\nQuestion: {question}"},
-                ],
-                max_tokens=400,
-                temperature=0.2,
-                timeout=15,
-            )
-            return resp.choices[0].message.content
-        return "AI chat momentálně není dostupný (chybí GROQ_API_KEY). Zkus to prosím později."
-    except Exception as e:
-        traceback.print_exc()
-        return f"Chyba AI chatu: {e}"
-
-
-# ===========================================================================
-# CORE LOGIC — STRIPE PLATBY (bez webhooků, polling)
-# ===========================================================================
-def create_checkout_url(user, plan: str) -> (bool, str):
-    try:
-        if not (STRIPE_SDK_OK and STRIPE_SECRET_KEY):
-            return False, f"Platby momentálně nejsou nastavené. Napiš prosím na support a domluvíme upgrade na {plan} ručně."
-        price_id = PLAN_PRICE_IDS.get(plan)
-        if not price_id:
-            return False, "Neplatný plán."
-        session = stripe.checkout.Session.create(
-            payment_method_types=["card"],
-            line_items=[{"price": price_id, "quantity": 1}],
-            mode="subscription",
-            success_url=f"{APP_URL}?checkout=success&session_id={{CHECKOUT_SESSION_ID}}",
-            cancel_url=f"{APP_URL}?checkout=cancel",
-            customer_email=user["email"],
-            metadata={"plan": plan, "user_id": str(user["id"])},
-        )
-        return True, session.url
-    except Exception as e:
-        traceback.print_exc()
-        return False, f"Chyba Stripe checkoutu: {e}"
-
-
-def poll_payment_status(session_id: str, user_id: int, max_attempts=12, delay=5) -> str:
-    if not (STRIPE_SDK_OK and STRIPE_SECRET_KEY):
-        return "Platby nejsou nakonfigurované."
-    try:
-        for _ in range(max_attempts):
-            session = stripe.checkout.Session.retrieve(session_id)
-            if session.payment_status == "paid":
-                plan = session.metadata.get("plan", "basic")
-                DB.update_user_plan(user_id, plan, stripe_cid=session.customer)
-                return f"✅ Upgradnuto na {plan}!"
-            time.sleep(delay)
-        return "⏳ Platba zatím nebyla potvrzena. Pokud jsi zaplatil/a, obnov stránku za chvíli."
-    except Exception as e:
-        traceback.print_exc()
-        return f"Chyba při ověřování platby: {e}"
-
-
-# ===========================================================================
-# CORE LOGIC — EXPORT
-# ===========================================================================
-def export_csv(user) -> str:
-    try:
-        invoices = DB.get_invoices(user["id"])
-        path = f"/tmp/export_{user['id']}_{int(time.time())}.csv"
-        import csv
-        with open(path, "w", newline="", encoding="utf-8") as f:
-            writer = csv.writer(f)
-            writer.writerow(["Vendor", "Invoice#", "Invoice Date", "Due Date", "Amount", "VAT", "Total", "Currency", "Status"])
-            for inv in invoices:
-                writer.writerow([inv.get("vendor"), inv.get("inv_number"), inv.get("inv_date"),
-                                  inv.get("due_date"), inv.get("amount"), inv.get("vat_amount"),
-                                  inv.get("total"), inv.get("currency"), inv.get("status")])
-        return path
-    except Exception as e:
-        traceback.print_exc()
-        raise gr.Error(f"Export CSV selhal: {e}")
-
-
-def export_json(user) -> str:
-    try:
-        invoices = DB.get_invoices(user["id"])
-        path = f"/tmp/export_{user['id']}_{int(time.time())}.json"
-        with open(path, "w", encoding="utf-8") as f:
-            json.dump(invoices, f, ensure_ascii=False, indent=2, default=str)
-        return path
-    except Exception as e:
-        traceback.print_exc()
-        raise gr.Error(f"Export JSON selhal: {e}")
-
-
-# ===========================================================================
-# GRADIO UI LAYER — od tohoto místa dolů JEN volání CORE funkcí
-# ===========================================================================
-CUSTOM_CSS = \"\"\"
-.gradio-container {max-width: 1200px !important; margin: auto;}
-.op-hero {text-align:center; padding: 40px 20px;}
-.op-card {border:1px solid #e5e7eb; border-radius:12px; padding:20px; background:white;}
-footer {visibility:hidden}
-\"\"\"
-
-LANDING_HTML = \"\"\"
-<div style="font-family:Inter,sans-serif;">
-  <div style="display:flex;justify-content:space-between;align-items:center;padding:16px 24px;border-bottom:1px solid #eee;">
-    <div style="font-size:22px;font-weight:800;">⚡ OmniParse AI</div>
-    <div style="color:#666;font-size:14px;">How it works · Features · Pricing · Legal</div>
-  </div>
-  <div class="op-hero">
-    <h1 style="font-size:42px;font-weight:800;margin-bottom:8px;">Invoice processing in seconds, not hours.</h1>
-    <p style="font-size:18px;color:#555;max-width:640px;margin:0 auto 20px;">
-      AI extracts vendor, dates, amounts and line items from any PDF or image.
-      Export to CSV, JSON or Excel. Connect via API.
-    </p>
-    <p style="color:#888;">99.2% accuracy · &lt;4s per invoice · 40+ formats</p>
-  </div>
+/* ---------------- Skeleton loaders ---------------- */
+@keyframes op-shimmer {
+    0% { background-position: -400px 0; }
+    100% { background-position: 400px 0; }
+}
+.op-skel {
+    background: linear-gradient(90deg, #1a1d27 25%, #232734 37%, #1a1d27 63%);
+    background-size: 800px 100%;
+    animation: op-shimmer 1.4s ease-in-out infinite;
+    border-radius: 8px;
+}
+.op-skel-row { height: 44px; margin-bottom: 8px; }
+.op-skel-text { height: 14px; width: 60%; margin-bottom: 6px; }
 
-  <div class="op-card" style="margin:20px 0;">
-    <h2>How it works</h2>
-    <ol>
-      <li>Upload PDF or image invoice</li>
-      <li>AI extracts all data</li>
-      <li>Export wherever you need</li>
-    </ol>
-  </div>
+.op-fade-in { animation: op-fade 0.25s ease both; }
+@keyframes op-fade { from { opacity: 0; transform: translateY(4px); } to { opacity: 1; transform: translateY(0); } }
+</style>
+"""
 
-  <div class="op-card" style="margin:20px 0;">
-    <h2>Features</h2>
-    <ul>
-      <li>🔍 OCR + LLM — Tesseract + Groq Llama 3.1</li>
-      <li>🚫 Duplicate Detection — Pro+, catches double payments</li>
-      <li>🤖 AI Chat Agent — ask about your invoices in plain English</li>
-      <li>✅ Cross-field Validation — checks totals, dates, tax rates</li>
-      <li>👥 Human-in-the-loop — Enterprise, manual review of uncertain invoices</li>
-      <li>🔌 REST API — connect to your own ERP</li>
-    </ul>
-  </div>
+# ---------------------------------------------------------------------------
+# Landing page HTML
+# ---------------------------------------------------------------------------
+LANDING_HTML = f"""
+{BASE_CSS}
+<script src="https://cdn.tailwindcss.com"></script>
+<div id="op-root" class="min-h-screen bg-[#0b0d12] text-gray-100">
+
+  <nav class="flex items-center justify-between px-8 py-5 border-b border-gray-800">
+    <div class="flex items-center gap-2">
+      <div class="w-8 h-8 rounded-lg bg-gradient-to-br from-indigo-500 to-cyan-400"></div>
+      <span class="font-semibold text-lg">{APP_TITLE}</span>
+    </div>
+    <div class="flex items-center gap-6 text-sm text-gray-300">
+      <a href="#pricing" class="hover:text-white">Pricing</a>
+      <a href="#faq" class="hover:text-white">FAQ</a>
+      <button onclick="opNavigate('legal')" class="hover:text-white">Legal</button>
+      <button onclick="opNavigate('login')" class="hover:text-white">Log in</button>
+      <button onclick="opNavigate('register')"
+        class="op-tooltip bg-indigo-500 hover:bg-indigo-400 text-white px-4 py-2 rounded-lg font-medium"
+        data-tip="Start free, no card required">
+        Get started
+      </button>
+    </div>
+  </nav>
+
+  <header class="text-center px-6 py-24 max-w-4xl mx-auto">
+    <h1 class="text-5xl font-bold tracking-tight mb-4">Invoice processing in seconds, not hours.</h1>
+    <p class="text-gray-400 text-lg mb-6">99.2% accuracy &middot; &lt;4s per invoice &middot; 40+ formats</p>
+    <div class="flex items-center justify-center gap-4">
+      <button onclick="opNavigate('register')" class="bg-indigo-500 hover:bg-indigo-400 px-6 py-3 rounded-lg font-semibold">Start free</button>
+      <button onclick="opNavigate('pricing')" class="border border-gray-700 hover:border-gray-500 px-6 py-3 rounded-lg font-semibold">See pricing</button>
+    </div>
+  </header>
+
+  <section class="grid grid-cols-1 md:grid-cols-4 gap-6 px-8 max-w-6xl mx-auto pb-24">
+    <div class="op-tooltip bg-[#12141c] border border-gray-800 rounded-xl p-6" data-tip="Google Vision + pytesseract, cross-checked by an LLM">
+      <h3 class="font-semibold mb-2">OCR + LLM extraction</h3>
+      <p class="text-sm text-gray-400">Combines computer vision OCR with large language models for structured field extraction.</p>
+    </div>
+    <div class="op-tooltip bg-[#12141c] border border-gray-800 rounded-xl p-6" data-tip="Flags repeated vendor + amount within the same month">
+      <h3 class="font-semibold mb-2">Duplicate detection</h3>
+      <p class="text-sm text-gray-400">Automatically flags invoices that match an existing vendor and amount this month.</p>
+    </div>
+    <div class="op-tooltip bg-[#12141c] border border-gray-800 rounded-xl p-6" data-tip="Chat with your invoice history, Pro plan and above">
+      <h3 class="font-semibold mb-2">AI Chat</h3>
+      <p class="text-sm text-gray-400">Ask questions about your invoice data in plain English.</p>
+    </div>
+    <div class="op-tooltip bg-[#12141c] border border-gray-800 rounded-xl p-6" data-tip="Subtotal + tax is checked against the total, tolerance 0.10">
+      <h3 class="font-semibold mb-2">Cross-field validation</h3>
+      <p class="text-sm text-gray-400">Automatically verifies that subtotal plus tax reconciles with the stated total.</p>
+    </div>
+  </section>
+
+  <section id="pricing" class="px-8 pb-24 max-w-6xl mx-auto">
+    <h2 class="text-3xl font-bold text-center mb-10">Pricing</h2>
+    <div class="grid grid-cols-1 md:grid-cols-4 gap-6">
+
+      <div class="bg-[#12141c] border border-gray-800 rounded-xl p-6 flex flex-col">
+        <h3 class="font-semibold text-lg">Free</h3>
+        <p class="text-3xl font-bold my-3">$0<span class="text-sm text-gray-500">/mo</span></p>
+        <ul class="text-sm text-gray-400 space-y-2 flex-1">
+          <li class="op-tooltip" data-tip="Resets on the 1st of each month">20 invoices/mo</li>
+          <li>1 user</li>
+          <li>CSV export</li>
+        </ul>
+        <button onclick="opNavigate('register')" class="mt-6 border border-gray-700 hover:border-gray-500 rounded-lg py-2 font-medium">Choose Free</button>
+      </div>
+
+      <div class="bg-[#12141c] border border-gray-800 rounded-xl p-6 flex flex-col">
+        <h3 class="font-semibold text-lg">Basic</h3>
+        <p class="text-3xl font-bold my-3">$29<span class="text-sm text-gray-500">/mo</span></p>
+        <ul class="text-sm text-gray-400 space-y-2 flex-1">
+          <li>200 invoices/mo</li>
+          <li>1 user</li>
+          <li>JSON/Excel export</li>
+        </ul>
+        <button onclick="opCheckout('basic')" class="mt-6 border border-gray-700 hover:border-gray-500 rounded-lg py-2 font-medium">Choose Basic</button>
+      </div>
+
+      <div class="bg-[#12141c] border-2 border-indigo-500 rounded-xl p-6 flex flex-col relative">
+        <span class="absolute -top-3 left-1/2 -translate-x-1/2 bg-indigo-500 text-xs px-3 py-1 rounded-full font-semibold">Most popular</span>
+        <h3 class="font-semibold text-lg">Pro</h3>
+        <p class="text-3xl font-bold my-3">$129<span class="text-sm text-gray-500">/mo</span></p>
+        <ul class="text-sm text-gray-400 space-y-2 flex-1">
+          <li>2000 invoices/mo</li>
+          <li>3 users</li>
+          <li class="op-tooltip" data-tip="Programmatic access via api_key">REST API</li>
+          <li>AI Chat</li>
+          <li>Duplicate detection</li>
+        </ul>
+        <button onclick="opCheckout('pro')" class="mt-6 bg-indigo-500 hover:bg-indigo-400 rounded-lg py-2 font-medium">Choose Pro</button>
+      </div>
+
+      <div class="bg-[#12141c] border border-gray-800 rounded-xl p-6 flex flex-col">
+        <h3 class="font-semibold text-lg">Enterprise</h3>
+        <p class="text-3xl font-bold my-3">$499<span class="text-sm text-gray-500">/mo</span></p>
+        <ul class="text-sm text-gray-400 space-y-2 flex-1">
+          <li>Unlimited invoices</li>
+          <li class="op-tooltip" data-tip="A human reviews low-confidence extractions">Human review UI</li>
+          <li>SLA</li>
+        </ul>
+        <button onclick="opCheckout('enterprise')" class="mt-6 border border-gray-700 hover:border-gray-500 rounded-lg py-2 font-medium">Contact sales</button>
+      </div>
+    </div>
+  </section>
+
+  <section id="faq" class="px-8 pb-24 max-w-3xl mx-auto">
+    <h2 class="text-3xl font-bold text-center mb-10">Frequently asked questions</h2>
+    <div id="op-faq-list" class="space-y-3"></div>
+  </section>
+</div>
 
-  <div class="op-card" style="margin:20px 0;">
-    <h2>FAQ</h2>
-    <p><b>Is my data safe?</b> Yes — stored in EU (Frankfurt), encrypted at rest, GDPR compliant.</p>
-    <p><b>Does it work on Czech invoices?</b> Yes, OCR supports Czech + English.</p>
-    <p><b>How do payments work?</b> Monthly subscription via Stripe, cancel anytime.</p>
-    <p><b>Can I cancel anytime?</b> Yes, no lock-in contracts.</p>
-    <p><b>Do I get a tax invoice?</b> Yes, automatically generated by Stripe after each payment.</p>
+<script>
+const OP_FAQ = [
+  ["What file formats are supported?", "OmniParse AI accepts PDF invoices and common image formats (PNG, JPG, WEBP) up to 5MB, covering 40+ regional invoice layouts."],
+  ["How accurate is the extraction?", "Our OCR + LLM cascade achieves 99.2% field-level accuracy on standard invoice layouts, with automatic flagging of low-confidence results for review."],
+  ["What happens if a field can't be validated?", "Invoices where the subtotal and tax don't reconcile with the total are marked 'needs review' instead of being silently accepted."],
+  ["Can I cancel anytime?", "Yes, all paid plans are month-to-month and can be cancelled from your dashboard at any time."],
+  ["Is my data secure?", "All data is encrypted in transit and at rest, access is enforced via row-level security, and passwords are hashed with bcrypt."]
+];
+
+function opRenderFaq() {{
+  const list = document.getElementById('op-faq-list');
+  if (!list) return;
+  list.innerHTML = OP_FAQ.map((item, i) => `
+    <div class="bg-[#12141c] border border-gray-800 rounded-xl overflow-hidden">
+      <button onclick="opToggleFaq(${{i}})" class="w-full text-left px-5 py-4 flex justify-between items-center">
+        <span class="font-medium">${{item[0]}}</span>
+        <span id="op-faq-icon-${{i}}" class="text-gray-500">+</span>
+      </button>
+      <div id="op-faq-body-${{i}}" class="hidden px-5 pb-4 text-sm text-gray-400">${{item[1]}}</div>
+    </div>
+  `).join('');
+}}
+function opToggleFaq(i) {{
+  const body = document.getElementById('op-faq-body-' + i);
+  const icon = document.getElementById('op-faq-icon-' + i);
+  const isHidden = body.classList.contains('hidden');
+  body.classList.toggle('hidden');
+  icon.textContent = isHidden ? '\u2212' : '+';
+}}
+opRenderFaq();
+
+function opNavigate(route) {{
+  const input = document.querySelector('#op-route-bridge textarea, #op-route-bridge input');
+  if (!input) return;
+  input.value = route;
+  input.dispatchEvent(new Event('input', {{ bubbles: true }}));
+  document.querySelector('#op-route-trigger button').click();
+}}
+function opCheckout(plan) {{
+  const input = document.querySelector('#op-checkout-bridge textarea, #op-checkout-bridge input');
+  if (!input) return;
+  input.value = plan;
+  input.dispatchEvent(new Event('input', {{ bubbles: true }}));
+  document.querySelector('#op-checkout-trigger button').click();
+}}
+</script>
+"""
+
+LEGAL_HTML = f"""
+{BASE_CSS}
+<script src="https://cdn.tailwindcss.com"></script>
+<div class="min-h-screen bg-[#0b0d12] text-gray-100 px-8 py-16 max-w-3xl mx-auto">
+  <button onclick="opNavigate('landing')" class="text-sm text-gray-400 hover:text-white mb-8">&larr; Back</button>
+  <h1 class="text-3xl font-bold mb-6">Terms of Service &amp; Privacy Policy</h1>
+  <p class="text-gray-400 text-sm mb-4">This is placeholder legal copy for demonstration purposes. Replace with counsel-reviewed
+  Terms of Service, a Privacy Policy, and a Data Processing Agreement before accepting real customer data.</p>
+</div>
+<script>
+function opNavigate(route) {{
+  const input = document.querySelector('#op-route-bridge textarea, #op-route-bridge input');
+  if (!input) return;
+  input.value = route;
+  input.dispatchEvent(new Event('input', {{ bubbles: true }}));
+  document.querySelector('#op-route-trigger button').click();
+}}
+</script>
+"""
+
+AUTH_HTML_TMPL = """
+{css}
+<script src="https://cdn.tailwindcss.com"></script>
+<div class="min-h-screen bg-[#0b0d12] text-gray-100 flex items-center justify-center px-4">
+  <div class="w-full max-w-sm bg-[#12141c] border border-gray-800 rounded-xl p-8">
+    <h1 class="text-xl font-bold mb-1">{heading}</h1>
+    <p class="text-sm text-gray-500 mb-6">{sub}</p>
+    <div id="op-auth-error" class="hidden text-sm text-red-400 bg-red-950/40 border border-red-900 rounded-lg px-3 py-2 mb-4"></div>
+    {fields}
+    <button onclick="{submit_fn}()" class="w-full bg-indigo-500 hover:bg-indigo-400 rounded-lg py-2 font-medium mt-2">{cta}</button>
+    <p class="text-xs text-gray-500 mt-4 text-center">{footer}</p>
   </div>
+</div>
+<script>
+function opNavigate(route) {{
+  const input = document.querySelector('#op-route-bridge textarea, #op-route-bridge input');
+  if (!input) return;
+  input.value = route;
+  input.dispatchEvent(new Event('input', {{ bubbles: true }}));
+  document.querySelector('#op-route-trigger button').click();
+}}
+function opShowError(msg) {{
+  const el = document.getElementById('op-auth-error');
+  el.textContent = msg;
+  el.classList.remove('hidden');
+}}
+function opSubmitAuth(action) {{
+  const payload = {{ action }};
+  document.querySelectorAll('.op-field').forEach(f => payload[f.name] = f.value);
+  const input = document.querySelector('#op-auth-bridge textarea, #op-auth-bridge input');
+  input.value = JSON.stringify(payload);
+  input.dispatchEvent(new Event('input', {{ bubbles: true }}));
+  document.querySelector('#op-auth-trigger button').click();
+}}
+function opLogin() {{ opSubmitAuth('login'); }}
+function opRegister() {{ opSubmitAuth('register'); }}
+function opReset() {{ opSubmitAuth('reset'); }}
+</script>
+"""
+
+
+def render_login_html() -> str:
+    fields = """
+      <input class="op-field w-full bg-[#0b0d12] border border-gray-700 rounded-lg px-3 py-2 mb-3 text-sm" name="email" type="email" placeholder="Email">
+      <input class="op-field w-full bg-[#0b0d12] border border-gray-700 rounded-lg px-3 py-2 mb-3 text-sm" name="password" type="password" placeholder="Password">
+    """
+    return AUTH_HTML_TMPL.format(
+        css=BASE_CSS, heading="Welcome back", sub="Log in to your OmniParse AI account.",
+        fields=fields, submit_fn="opLogin", cta="Log in",
+        footer='No account? <button onclick="opNavigate(\'register\')" class="text-indigo-400">Sign up</button>',
+    )
+
+
+def render_register_html() -> str:
+    fields = """
+      <input class="op-field w-full bg-[#0b0d12] border border-gray-700 rounded-lg px-3 py-2 mb-3 text-sm" name="name" type="text" placeholder="Full name">
+      <input class="op-field w-full bg-[#0b0d12] border border-gray-700 rounded-lg px-3 py-2 mb-3 text-sm" name="email" type="email" placeholder="Email">
+      <input class="op-field w-full bg-[#0b0d12] border border-gray-700 rounded-lg px-3 py-2 mb-3 text-sm" name="password" type="password" placeholder="Password (min. 8 characters)">
+    """
+    return AUTH_HTML_TMPL.format(
+        css=BASE_CSS, heading="Create your account", sub="Start with 20 free invoices a month.",
+        fields=fields, submit_fn="opRegister", cta="Create account",
+        footer='Already have an account? <button onclick="opNavigate(\'login\')" class="text-indigo-400">Log in</button>',
+    )
+
 
-  <div style="text-align:center;color:#999;padding:20px;border-top:1px solid #eee;">
-    © 2026 OmniParse AI — Terms · Privacy · Disclaimer (viz Legal tab)
+DASHBOARD_HTML_TMPL = """
+{css}
+<script src="https://cdn.tailwindcss.com"></script>
+<div class="min-h-screen bg-[#0b0d12] text-gray-100">
+  <nav class="flex items-center justify-between px-8 py-4 border-b border-gray-800">
+    <div class="flex items-center gap-2">
+      <div class="w-7 h-7 rounded-lg bg-gradient-to-br from-indigo-500 to-cyan-400"></div>
+      <span class="font-semibold">{app_title}</span>
+      <span class="ml-2 text-xs bg-indigo-500/20 text-indigo-300 px-2 py-0.5 rounded-full">{plan_label}</span>
+    </div>
+    <div class="flex items-center gap-4 text-sm text-gray-300">
+      <span class="op-tooltip" data-tip="Invoices processed this calendar month">{used}/{limit} used</span>
+      <button onclick="opLogout()" class="hover:text-white">Log out</button>
+    </div>
+  </nav>
+
+  <div class="grid grid-cols-1 lg:grid-cols-3 gap-6 p-8">
+    <div class="lg:col-span-2 space-y-6">
+      <div id="op-dropzone"
+           ondragover="event.preventDefault(); this.classList.add('border-indigo-400');"
+           ondragleave="this.classList.remove('border-indigo-400');"
+           ondrop="opHandleDrop(event)"
+           class="op-tooltip border-2 border-dashed border-gray-700 rounded-xl p-10 text-center cursor-pointer"
+           data-tip="PDF, PNG or JPG, up to 5MB"
+           onclick="document.getElementById('op-file-input').click()">
+        <p class="font-medium">Drop an invoice here, or click to browse</p>
+        <p class="text-xs text-gray-500 mt-1">PDF, PNG, JPG &middot; max 5MB</p>
+        <input id="op-file-input" type="file" accept=".pdf,.png,.jpg,.jpeg,.webp" class="hidden" onchange="opHandleFileInput(event)">
+      </div>
+
+      <div id="op-skeleton-area" class="hidden space-y-2">
+        <div class="op-skel op-skel-row"></div>
+        <div class="op-skel op-skel-row"></div>
+        <div class="op-skel op-skel-row"></div>
+      </div>
+
+      <div class="bg-[#12141c] border border-gray-800 rounded-xl overflow-hidden">
+        <table class="w-full text-sm">
+          <thead class="bg-[#181b25] text-gray-400 text-xs uppercase">
+            <tr>
+              <th class="text-left px-4 py-3">Vendor</th>
+              <th class="text-left px-4 py-3">Invoice #</th>
+              <th class="text-left px-4 py-3">Date</th>
+              <th class="text-right px-4 py-3">Total</th>
+              <th class="text-left px-4 py-3">Status</th>
+            </tr>
+          </thead>
+          <tbody id="op-invoice-rows">{invoice_rows}</tbody>
+        </table>
+      </div>
+    </div>
+
+    <div class="bg-[#12141c] border border-gray-800 rounded-xl p-5 flex flex-col h-[560px]">
+      <h3 class="font-semibold mb-1 op-tooltip" data-tip="Available on Pro and Enterprise plans">AI Chat</h3>
+      <div id="op-chat-log" class="flex-1 overflow-y-auto space-y-3 my-3 text-sm">{chat_placeholder}</div>
+      <div class="flex gap-2">
+        <input id="op-chat-input" {chat_disabled} class="flex-1 bg-[#0b0d12] border border-gray-700 rounded-lg px-3 py-2 text-sm" placeholder="Ask about your invoices...">
+        <button onclick="opSendChat()" {chat_disabled} class="bg-indigo-500 hover:bg-indigo-400 disabled:opacity-40 rounded-lg px-4 text-sm font-medium">Send</button>
+      </div>
+    </div>
   </div>
 </div>
-\"\"\"
-
-LEGAL_TERMS = \"\"\"
-### Terms of Use
-OmniParse AI je nástroj pro automatickou extrakci dat z faktur pomocí AI. Používáním služby souhlasíš,
-že ji nebudeš zneužívat k nahrávání nelegálního obsahu, pokusům o přetížení systému (DoS) ani reverznímu
-inženýrství. Platby probíhají měsíčně přes Stripe, zrušení kdykoliv v sekci Profile. Neposkytujeme záruku
-100% přesnosti extrakce — viz Disclaimer.
-\"\"\"
-
-LEGAL_PRIVACY = \"\"\"
-### Privacy Policy / GDPR
-**Co sbíráme:** e-mail, jméno, nahrané faktury a z nich extrahovaná data.
-**Kde je to uloženo:** Supabase, EU region (Frankfurt).
-**Jak dlouho:** faktury 30 dní, účetní/fakturační záznamy 10 let (zákonná lhůta).
-**Tvá práva:** přístup k datům, výmaz (Profile → Delete account), přenositelnost dat (Export).
-**Cookies:** pouze technické (session), žádný marketingový tracking.
-\"\"\"
-
-LEGAL_DISCLAIMER = \"\"\"
-### Disclaimer
-AI extrakce není 100% přesná — vždy ověř data před zaúčtováním do tvého účetního systému.
-OmniParse nenese odpovědnost za chyby vzniklé nesprávnou AI extrakcí. Toto je nástroj usnadňující práci,
-nikoliv náhrada za kvalifikovaného účetního.
-\"\"\"
-
-
-def status_badge(status):
-    return {"done": "✅ Done", "review": "⚠️ Review", "duplicate": "🔴 Duplicate", "processing": "⟳ Processing"}.get(status, status)
-
-
-def invoices_to_dataframe(invoices):
+
+<script>
+function opNavigate(route) {{
+  const input = document.querySelector('#op-route-bridge textarea, #op-route-bridge input');
+  if (!input) return;
+  input.value = route;
+  input.dispatchEvent(new Event('input', {{ bubbles: true }}));
+  document.querySelector('#op-route-trigger button').click();
+}}
+function opLogout() {{ opNavigate('logout'); }}
+
+function opHandleDrop(ev) {{
+  ev.preventDefault();
+  ev.currentTarget.classList.remove('border-indigo-400');
+  const file = ev.dataTransfer.files[0];
+  if (file) opUploadFile(file);
+}}
+function opHandleFileInput(ev) {{
+  const file = ev.target.files[0];
+  if (file) opUploadFile(file);
+}}
+function opUploadFile(file) {{
+  if (file.size > 5 * 1024 * 1024) {{
+    alert('File exceeds the 5MB limit.');
+    return;
+  }}
+  document.getElementById('op-skeleton-area').classList.remove('hidden');
+  const reader = new FileReader();
+  reader.onload = function() {{
+    const payload = JSON.stringify({{ filename: file.name, data: reader.result }});
+    const input = document.querySelector('#op-upload-bridge textarea, #op-upload-bridge input');
+    input.value = payload;
+    input.dispatchEvent(new Event('input', {{ bubbles: true }}));
+    document.querySelector('#op-upload-trigger button').click();
+  }};
+  reader.readAsDataURL(file);
+}}
+function opSendChat() {{
+  const box = document.getElementById('op-chat-input');
+  const msg = box.value.trim();
+  if (!msg) return;
+  box.value = '';
+  const log = document.getElementById('op-chat-log');
+  log.innerHTML += `<div class="text-right"><span class="inline-block bg-indigo-500/20 rounded-lg px-3 py-2">${{msg}}</span></div>`;
+  const input = document.querySelector('#op-chat-bridge textarea, #op-chat-bridge input');
+  input.value = msg;
+  input.dispatchEvent(new Event('input', {{ bubbles: true }}));
+  document.querySelector('#op-chat-trigger button').click();
+}}
+</script>
+"""
+
+
+def render_invoice_rows(invoices: list) -> str:
+    if not invoices:
+        return '<tr><td colspan="5" class="px-4 py-6 text-center text-gray-500">No invoices processed yet.</td></tr>'
     rows = []
     for inv in invoices:
-        rows.append([
-            inv.get("id"), inv.get("vendor"), inv.get("inv_number"), inv.get("inv_date"),
-            f"{inv.get('total', 0):.2f} {inv.get('currency', '')}", status_badge(inv.get("status")),
-        ])
-    return rows
-
-
-with gr.Blocks(css=CUSTOM_CSS, title="OmniParse AI") as demo:
-    session_token = gr.State("")  # server-side (NE localStorage) — viz resolve_session()
-    current_view = gr.State("landing")
-
-    # ---- VIEW CONTAINERS ----
-    with gr.Column(visible=True) as view_landing:
-        gr.HTML(LANDING_HTML)
-        with gr.Row():
-            btn_landing_start = gr.Button("Start Free — 20 invoices →", variant="primary")
-            btn_landing_login = gr.Button("Log In")
-            btn_landing_pricing = gr.Button("Pricing")
-            btn_landing_legal = gr.Button("Legal")
-
-    with gr.Column(visible=False) as view_pricing:
-        gr.Markdown("## Pricing")
-        with gr.Row():
-            with gr.Column():
-                gr.Markdown("### Free — $0/mo\\n- 20 invoices/mo\\n- CSV export\\n- 1 user")
-            with gr.Column():
-                gr.Markdown("### Basic — $29/mo\\n- 200 invoices/mo\\n- JSON+CSV+Excel export\\n- Multi-currency")
-            with gr.Column():
-                gr.Markdown("### Pro — $129/mo\\n- 2,000 invoices/mo\\n- REST API + AI Chat\\n- Duplicate detection\\n- 3 users")
-            with gr.Column():
-                gr.Markdown("### Enterprise — $499/mo\\n- Unlimited invoices\\n- Human-in-the-loop\\n- SLA 99.5%\\n- Unlimited users")
-        gr.Markdown("_Přihlaš se a v Dashboardu → ⚡ Upgrade vyber plán a zaplať kartou přes Stripe._")
-        btn_pricing_back = gr.Button("← Back")
-
-    with gr.Column(visible=False) as view_legal:
-        gr.Markdown("## Legal")
-        with gr.Tab("Terms of Use"):
-            gr.Markdown(LEGAL_TERMS)
-        with gr.Tab("Privacy Policy"):
-            gr.Markdown(LEGAL_PRIVACY)
-        with gr.Tab("Disclaimer"):
-            gr.Markdown(LEGAL_DISCLAIMER)
-        btn_legal_back = gr.Button("← Back")
-
-    with gr.Column(visible=False) as view_auth:
-        gr.Markdown("## Welcome to OmniParse AI")
-        with gr.Tab("Log In"):
-            login_email = gr.Textbox(label="Email")
-            login_password = gr.Textbox(label="Password", type="password")
-            login_btn = gr.Button("Log In", variant="primary")
-            login_msg = gr.Markdown()
-            gr.Markdown("_Demo účet: `demo@omniparse.ai` / `demo1234` (plán Pro)_")
-        with gr.Tab("Sign Up"):
-            signup_name = gr.Textbox(label="Full Name")
-            signup_email = gr.Textbox(label="Work Email")
-            signup_password = gr.Textbox(label="Password (min. 8 znaků)", type="password")
-            signup_terms = gr.Checkbox(label="Souhlasím s Terms of Use a Privacy Policy")
-            signup_btn = gr.Button("Sign Up", variant="primary")
-            signup_msg = gr.Markdown()
-        btn_auth_back = gr.Button("← Back to landing")
-
-    with gr.Column(visible=False) as view_dashboard:
-        with gr.Row():
-            gr.Markdown("## Dashboard")
-            btn_logout = gr.Button("🚪 Log Out", size="sm")
-        user_info_md = gr.Markdown()
-
-        with gr.Tab("📤 Upload"):
-            upload_files = gr.File(label="Nahraj faktury (PDF/JPG/PNG/TIFF, max 20MB/soubor)", file_count="multiple")
-            upload_btn = gr.Button("Zpracovat faktury", variant="primary")
-            upload_status = gr.Markdown()
-            upload_results = gr.Dataframe(headers=["ID", "Vendor", "Invoice#", "Date", "Total", "Status"], label="Výsledky")
-            upload_raw_json = gr.JSON(label="Raw AI output (poslední soubor)")
-
-        with gr.Tab("📋 My Invoices"):
-            refresh_invoices_btn = gr.Button("🔄 Obnovit")
-            invoices_table = gr.Dataframe(headers=["ID", "Vendor", "Invoice#", "Date", "Total", "Status"], label="Faktury")
-
-        with gr.Tab("🤖 AI Chat (Pro+)"):
-            chat_history = gr.Chatbot(label="Zeptej se na své faktury", type="messages")
-            chat_input = gr.Textbox(label="Otázka", placeholder="What's the total unpaid amount?")
-            chat_send = gr.Button("Odeslat")
-
-        with gr.Tab("📊 Export"):
-            gr.Markdown("CSV export je zdarma pro všechny. JSON od plánu Basic+.")
-            export_csv_btn = gr.Button("Export CSV")
-            export_csv_file = gr.File(label="Stáhnout CSV")
-            export_json_btn = gr.Button("Export JSON (Basic+)")
-            export_json_file = gr.File(label="Stáhnout JSON")
-            gr.Markdown("Excel export a Google Sheets sync: **Coming soon** 🚧")
-
-        with gr.Tab("⚡ Upgrade"):
-            plan_dropdown = gr.Dropdown(["basic", "pro", "enterprise"], label="Vyber plán", value="basic")
-            upgrade_btn = gr.Button("Přejít na platbu (Stripe)", variant="primary")
-            upgrade_link = gr.Markdown()
-            gr.Markdown("Test karta ve Stripe test mode: `4242 4242 4242 4242`, libovolné datum/CVC.")
-            checkout_session_input = gr.Textbox(label="Po zaplacení: vlož session_id z URL a klikni níže", visible=True)
-            confirm_payment_btn = gr.Button("Ověřit platbu")
-            payment_status_md = gr.Markdown()
-
-        with gr.Tab("🔌 API (Pro+)"):
-            api_key_display = gr.Markdown()
-            gr.Markdown(\"\"\"
-```bash
-curl -X POST https://tvuj-space.hf.space/api/extract \\\\
-  -H "Authorization: Bearer TVUJ_API_KLIC" \\\\
-  -F "file=@faktura.pdf"
-```
-_(REST endpoint pro přímé API volání se zapojí při přechodu na FastAPI backend — business logika je už připravená v `process_invoice_file()`.)_
-\"\"\")
-
-        with gr.Tab("👤 Profile"):
-            profile_info = gr.Markdown()
-            new_password = gr.Textbox(label="Nové heslo", type="password")
-            change_pw_btn = gr.Button("Změnit heslo")
-            change_pw_msg = gr.Markdown()
-            gr.Markdown("### ⚠️ Danger zone")
-            delete_confirm = gr.Checkbox(label="Ano, opravdu chci smazat účet a všechna data")
-            delete_btn = gr.Button("Smazat účet natrvalo", variant="stop")
-            delete_msg = gr.Markdown()
-
-    ALL_VIEWS = [view_landing, view_pricing, view_legal, view_auth, view_dashboard]
-
-    def switch_view(target):
-        return [gr.update(visible=(v == target)) for v in ["landing", "pricing", "legal", "auth", "dashboard"]]
-
-    # ---- NAVIGACE ----
-    btn_landing_start.click(lambda: switch_view("auth"), outputs=ALL_VIEWS)
-    btn_landing_login.click(lambda: switch_view("auth"), outputs=ALL_VIEWS)
-    btn_landing_pricing.click(lambda: switch_view("pricing"), outputs=ALL_VIEWS)
-    btn_landing_legal.click(lambda: switch_view("legal"), outputs=ALL_VIEWS)
-    btn_pricing_back.click(lambda: switch_view("landing"), outputs=ALL_VIEWS)
-    btn_legal_back.click(lambda: switch_view("landing"), outputs=ALL_VIEWS)
-    btn_auth_back.click(lambda: switch_view("landing"), outputs=ALL_VIEWS)
-
-    # ---- AUTH HANDLERY ----
-    def handle_signup(name, email, password, terms):
-        ok, msg, token = signup(name, email, password, terms)
-        if ok:
-            user = resolve_session(token)
-            info = f"✅ Přihlášen jako **{user['name']}** ({user['email']}) — plán **{user['plan']}**"
-            views = switch_view("dashboard")
-            return [msg, token, info] + views
-        views = switch_view("auth")
-        return [msg, "", ""] + views
-
-    signup_btn.click(
-        handle_signup,
-        inputs=[signup_name, signup_email, signup_password, signup_terms],
-        outputs=[signup_msg, session_token, user_info_md] + ALL_VIEWS,
+        status = inv.get("status", "done")
+        badge_color = {
+            "done": "bg-emerald-500/20 text-emerald-300",
+            "needs_review": "bg-amber-500/20 text-amber-300",
+            "error": "bg-red-500/20 text-red-300",
+            "processing": "bg-gray-500/20 text-gray-300",
+        }.get(status, "bg-gray-500/20 text-gray-300")
+        dup_flag = ' <span class="text-xs text-amber-400">(dup)</span>' if inv.get("is_duplicate") else ""
+        rows.append(f"""
+        <tr class="border-t border-gray-800 op-fade-in">
+          <td class="px-4 py-3">{inv.get('vendor') or '—'}{dup_flag}</td>
+          <td class="px-4 py-3">{inv.get('inv_number') or '—'}</td>
+          <td class="px-4 py-3">{inv.get('inv_date') or '—'}</td>
+          <td class="px-4 py-3 text-right">{inv.get('total') if inv.get('total') is not None else '—'} {inv.get('currency') or ''}</td>
+          <td class="px-4 py-3"><span class="text-xs px-2 py-1 rounded-full {badge_color}">{status}</span></td>
+        </tr>""")
+    return "".join(rows)
+
+
+def render_dashboard_html(user: dict, invoices: list) -> str:
+    plan = user.get("plan", "free")
+    limits = PLAN_LIMITS.get(plan, PLAN_LIMITS["free"])
+    used = db.count_invoices_this_month(user["id"]) if user["id"] != -1 else len(invoices)
+    limit_display = "∞" if limits["invoices"] == float("inf") else limits["invoices"]
+    chat_enabled = plan in ("pro", "enterprise")
+    return DASHBOARD_HTML_TMPL.format(
+        css=BASE_CSS,
+        app_title=APP_TITLE,
+        plan_label=limits["label"],
+        used=used,
+        limit=limit_display,
+        invoice_rows=render_invoice_rows(invoices),
+        chat_disabled="" if chat_enabled else "disabled",
+        chat_placeholder="" if chat_enabled else '<p class="text-gray-500 text-xs">AI Chat is available on Pro and Enterprise plans.</p>',
     )
 
-    def handle_login(email, password):
-        ok, msg, token = login(email, password)
-        if ok:
-            user = resolve_session(token)
-            info = f"✅ Přihlášen jako **{user['name']}** ({user['email']}) — plán **{user['plan']}**"
-            views = switch_view("dashboard")
-            return [msg, token, info] + views
-        views = switch_view("auth")
-        return [msg, "", ""] + views
-
-    login_btn.click(
-        handle_login,
-        inputs=[login_email, login_password],
-        outputs=[login_msg, session_token, user_info_md] + ALL_VIEWS,
+
+# ---------------------------------------------------------------------------
+# Gradio Blocks: hidden RPC bridge + route switching
+# ---------------------------------------------------------------------------
+with gr.Blocks(title=APP_TITLE, css=".gradio-container {background:#0b0d12}") as demo:
+
+    session_token = gr.State(value=None)
+    current_route = gr.State(value="landing")
+
+    page = gr.HTML(LANDING_HTML)
+
+    with gr.Row(visible=False, elem_id="op-route-bridge"):
+        route_input = gr.Textbox(elem_id="op-route-input")
+    with gr.Row(visible=False, elem_id="op-route-trigger"):
+        route_button = gr.Button("route")
+
+    with gr.Row(visible=False, elem_id="op-auth-bridge"):
+        auth_input = gr.Textbox(elem_id="op-auth-input")
+    with gr.Row(visible=False, elem_id="op-auth-trigger"):
+        auth_button = gr.Button("auth")
+
+    with gr.Row(visible=False, elem_id="op-upload-bridge"):
+        upload_input = gr.Textbox(elem_id="op-upload-input")
+    with gr.Row(visible=False, elem_id="op-upload-trigger"):
+        upload_button = gr.Button("upload")
+
+    with gr.Row(visible=False, elem_id="op-checkout-bridge"):
+        checkout_input = gr.Textbox(elem_id="op-checkout-input")
+    with gr.Row(visible=False, elem_id="op-checkout-trigger"):
+        checkout_button = gr.Button("checkout")
+
+    with gr.Row(visible=False, elem_id="op-chat-bridge"):
+        chat_input = gr.Textbox(elem_id="op-chat-input-hidden")
+    with gr.Row(visible=False, elem_id="op-chat-trigger"):
+        chat_button = gr.Button("chat")
+
+    # -- Route handling ------------------------------------------------
+    def handle_route(route: str, token: str):
+        route = (route or "landing").strip()
+        if route == "logout":
+            auth.logout(token)
+            return LANDING_HTML, None, "landing"
+        if route == "dashboard":
+            user = auth.get_current_user(token) if token else None
+            if not user:
+                return render_login_html(), token, "login"
+            invoices = db.list_invoices(user["id"]) if user["id"] != -1 else []
+            return render_dashboard_html(user, invoices), token, "dashboard"
+        if route == "login":
+            return render_login_html(), token, "login"
+        if route == "register":
+            return render_register_html(), token, "register"
+        if route == "legal":
+            return LEGAL_HTML, token, "legal"
+        if route == "pricing":
+            return LANDING_HTML, token, "landing"
+        return LANDING_HTML, token, "landing"
+
+    route_button.click(
+        handle_route,
+        inputs=[route_input, session_token],
+        outputs=[page, session_token, current_route],
     )
 
-    def handle_logout(token):
-        logout(token)
-        views = switch_view("landing")
-        return [""] + views
+    # -- Auth handling ---------------------------------------------------
+    def handle_auth(payload_json: str, token: str, request: gr.Request):
+        client_ip = request.client.host if request and request.client else "unknown"
+        try:
+            payload = json.loads(payload_json) if payload_json else {}
+        except json.JSONDecodeError:
+            return render_login_html(), token, "login"
 
-    btn_logout.click(handle_logout, inputs=[session_token], outputs=[session_token] + ALL_VIEWS)
+        action = payload.get("action")
+        try:
+            if action == "login":
+                result = auth.login(payload.get("email", ""), payload.get("password", ""), client_ip)
+                new_token = result["token"]
+                user = result["user"]
+                invoices = db.list_invoices(user["id"]) if user["id"] != -1 else []
+                return render_dashboard_html(user, invoices), new_token, "dashboard"
+
+            if action == "register":
+                result = auth.register(
+                    payload.get("email", ""), payload.get("name", ""),
+                    payload.get("password", ""), client_ip,
+                )
+                new_token = result["token"]
+                user = result["user"]
+                return render_dashboard_html(user, []), new_token, "dashboard"
+
+            if action == "reset":
+                auth.request_password_reset(payload.get("email", ""), client_ip)
+                return render_login_html(), token, "login"
+
+        except auth.AuthError as exc:
+            logger.info("Auth error: %s", exc.message)
+            error_html = render_login_html() if action == "login" else render_register_html()
+            error_html = error_html.replace(
+                'id="op-auth-error" class="hidden',
+                f'id="op-auth-error" class="op-fade-in',
+            ).replace(
+                '></div>', f'>{exc.message}</div>', 1,
+            )
+            return error_html, token, action or "login"
 
-    # ---- UPLOAD ----
-    def handle_upload(token, files):
-        user = resolve_session(token)
-        if not user:
-            return "❌ Nejsi přihlášen/a. Přihlas se prosím znovu.", [], {}
-        if not files:
-            return "⚠️ Nevybral/a jsi žádný soubor.", [], {}
-        used = DB.count_invoices_this_month(user["id"])
-        limit = PLAN_LIMITS.get(user["plan"], 20)
-        if used >= limit:
-            return f"🔴 Vyčerpal/a jsi měsíční limit ({int(limit) if limit != float('inf') else '∞'} faktur). Upgraduj v sekci ⚡ Upgrade.", [], {}
-
-        results, last_json, errors = [], {}, []
-        for f in files:
-            if used >= limit:
-                errors.append(f"Limit dosažen, {os.path.basename(f.name)} přeskočen.")
-                break
-            record = process_invoice_file(user, f.name, os.path.basename(f.name))
-            if "error" in record:
-                errors.append(record["error"])
-                continue
-            used += 1
-            last_json = record.get("raw_json", {})
-            results.append([None, record["vendor"], record["inv_number"], record["inv_date"],
-                             f"{record['total']:.2f} {record['currency']}", status_badge(record["status"])])
-
-        msg = f"✅ Zpracováno {len(results)} faktur. Použito {used}/{int(limit) if limit != float('inf') else '∞'} tento měsíc."
-        if errors:
-            msg += "\\n\\n⚠️ Chyby:\\n" + "\\n".join(f"- {e}" for e in errors)
-        return msg, results, last_json
-
-    upload_btn.click(handle_upload, inputs=[session_token, upload_files],
-                      outputs=[upload_status, upload_results, upload_raw_json])
-
-    # ---- MY INVOICES ----
-    def handle_refresh_invoices(token):
-        user = resolve_session(token)
-        if not user:
-            return []
-        return invoices_to_dataframe(DB.get_invoices(user["id"]))
+        return render_login_html(), token, "login"
 
-    refresh_invoices_btn.click(handle_refresh_invoices, inputs=[session_token], outputs=[invoices_table])
+    auth_button.click(
+        handle_auth,
+        inputs=[auth_input, session_token],
+        outputs=[page, session_token, current_route],
+    )
 
-    # ---- AI CHAT ----
-    def handle_chat(token, message, history):
-        user = resolve_session(token)
-        if not user:
-            history = history or []
-            history.append({"role": "assistant", "content": "Nejsi přihlášen/a."})
-            return history, ""
-        answer = ai_chat_answer(user, message, history)
-        history = history or []
-        history.append({"role": "user", "content": message})
-        history.append({"role": "assistant", "content": answer})
-        return history, ""
-
-    chat_send.click(handle_chat, inputs=[session_token, chat_input, chat_history], outputs=[chat_history, chat_input])
-
-    # ---- EXPORT ----
-    def handle_export_csv(token):
-        user = resolve_session(token)
+    # -- Upload / processing pipeline ------------------------------------
+    def handle_upload(payload_json: str, token: str):
+        user = auth.get_current_user(token) if token else None
         if not user:
-            raise gr.Error("Nejsi přihlášen/a.")
-        return export_csv(user)
+            return render_login_html(), token
 
-    export_csv_btn.click(handle_export_csv, inputs=[session_token], outputs=[export_csv_file])
-
-    def handle_export_json(token):
-        user = resolve_session(token)
-        if not user:
-            raise gr.Error("Nejsi přihlášen/a.")
-        if user["plan"] == "free":
-            raise gr.Error("JSON export je dostupný od plánu Basic. Upgraduj v sekci ⚡ Upgrade.")
-        return export_json(user)
+        try:
+            payload = json.loads(payload_json)
+            filename = payload["filename"]
+            raw_bytes = backend._bytes_from_base64(payload["data"])
+        except Exception as exc:
+            logger.warning("Bad upload payload: %s", exc)
+            invoices = db.list_invoices(user["id"]) if user["id"] != -1 else []
+            return render_dashboard_html(user, invoices), token
 
-    export_json_btn.click(handle_export_json, inputs=[session_token], outputs=[export_json_file])
+        try:
+            parsed = backend.process_invoice_file(raw_bytes, filename)
+            if user["id"] != -1:
+                db.save_invoice_record(user["id"], filename, parsed)
+        except backend.UploadTooLarge:
+            logger.info("Upload rejected: file too large.")
+        except Exception as exc:
+            logger.error("Processing failed for %s: %s", filename, exc)
+
+        invoices = db.list_invoices(user["id"]) if user["id"] != -1 else []
+        return render_dashboard_html(user, invoices), token
+
+    upload_button.click(
+        handle_upload,
+        inputs=[upload_input, session_token],
+        outputs=[page, session_token],
+    )
 
-    # ---- UPGRADE / STRIPE ----
-    def handle_upgrade(token, plan):
-        user = resolve_session(token)
+    # -- Checkout (Stripe) -------------------------------------------------
+    def handle_checkout(plan: str, token: str):
+        user = auth.get_current_user(token) if token else None
         if not user:
-            return "❌ Nejsi přihlášen/a."
-        ok, result = create_checkout_url(user, plan)
-        if ok:
-            return f"[Klikni pro dokončení platby ve Stripe →]({result})"
-        return f"⚠️ {result}"
-
-    upgrade_btn.click(handle_upgrade, inputs=[session_token, plan_dropdown], outputs=[upgrade_link])
+            return render_register_html(), token, "register"
+        if plan == "enterprise":
+            return render_dashboard_html(user, db.list_invoices(user["id"]) if user["id"] != -1 else []), token, "dashboard"
+        # In production: create a Stripe Checkout Session here with
+        # client_reference_id=user["id"] and redirect the browser to
+        # session.url. Left as an integration point tied to your Stripe
+        # account's live Price IDs.
+        invoices = db.list_invoices(user["id"]) if user["id"] != -1 else []
+        return render_dashboard_html(user, invoices), token, "dashboard"
+
+    checkout_button.click(
+        handle_checkout,
+        inputs=[checkout_input, session_token],
+        outputs=[page, session_token, current_route],
+    )
 
-    def handle_confirm_payment(token, session_id):
-        user = resolve_session(token)
-        if not user:
-            return "❌ Nejsi přihlášen/a."
-        if not session_id:
-            return "Vlož prosím session_id z URL a klikni níže."
-        return poll_payment_status(session_id, user["id"])
+    # -- AI Chat (Pro+) ----------------------------------------------------
+    def handle_chat(message: str, token: str):
+        user = auth.get_current_user(token) if token else None
+        if not user or user.get("plan") not in ("pro", "enterprise"):
+            invoices = db.list_invoices(user["id"]) if user and user["id"] != -1 else []
+            return render_dashboard_html(user, invoices) if user else render_login_html(), token
+
+        invoices = db.list_invoices(user["id"]) if user["id"] != -1 else []
+        context = json.dumps(invoices[:50], default=str)
+        reply = "AI Chat requires GROQ_API_KEY to be configured."
+        if backend.GROQ_API_KEY:
+            try:
+                import requests as _requests
+                resp = _requests.post(
+                    "https://api.groq.com/openai/v1/chat/completions",
+                    headers={"Authorization": f"Bearer {backend.GROQ_API_KEY}"},
+                    json={
+                        "model": "llama-3.1-8b-instant",
+                        "messages": [
+                            {"role": "system", "content": f"You answer questions about this invoice data: {context[:6000]}"},
+                            {"role": "user", "content": message},
+                        ],
+                        "temperature": 0.2,
+                    },
+                    timeout=15,
+                )
+                resp.raise_for_status()
+                reply = resp.json()["choices"][0]["message"]["content"]
+            except Exception as exc:
+                logger.warning("Chat request failed: %s", exc)
+                reply = "Sorry, the AI Chat service is temporarily unavailable."
+
+        dashboard = render_dashboard_html(user, invoices)
+        safe_reply = reply.replace("`", "'").replace("</", "<\\/")
+        dashboard += f"""<script>
+        document.getElementById('op-chat-log').innerHTML +=
+          `<div><span class="inline-block bg-gray-800 rounded-lg px-3 py-2">{safe_reply}</span></div>`;
+        </script>"""
+        return dashboard, token
+
+    chat_button.click(
+        handle_chat,
+        inputs=[chat_input, session_token],
+        outputs=[page, session_token],
+    )
 
-    confirm_payment_btn.click(handle_confirm_payment, inputs=[session_token, checkout_session_input], outputs=[payment_status_md])
 
-    # ---- API KEY DISPLAY ----
-    def handle_show_api_key(token):
-        user = resolve_session(token)
-        if not user:
-            return "Nejsi přihlášen/a."
-        if user["plan"] not in ("pro", "enterprise"):
-            return "🔒 API přístup je dostupný od plánu Pro. Upgraduj v sekci ⚡ Upgrade."
-        return f"**Tvůj API klíč:** `{user.get('api_key', 'N/A')}`\\n\\n⚠️ Nikdy ho nesdílej veřejně."
-
-    # ---- PROFILE ----
-    def handle_change_password(token, new_pw):
-        user = resolve_session(token)
-        if not user:
-            return "❌ Nejsi přihlášen/a."
-        ok, msg = password_strength_ok(new_pw)
-        if not ok:
-            return f"⚠️ {msg}"
-        if is_password_leaked(new_pw):
-            return "⚠️ Toto heslo bylo nalezeno v uniklých databázích. Zvol jiné."
-        try:
-            DB.update_password(user["id"], hash_password(new_pw))
-            return "✅ Heslo změněno."
-        except Exception as e:
-            return f"❌ Chyba: {e}"
+# ---------------------------------------------------------------------------
+# Mount Gradio on a FastAPI app so we can add a raw-body Stripe webhook route.
+# The webhook needs the unparsed request body + the `stripe-signature` header
+# for signature verification, which Gradio components cannot provide.
+# ---------------------------------------------------------------------------
+from fastapi import FastAPI, Request as FastAPIRequest
 
-    change_pw_btn.click(handle_change_password, inputs=[session_token, new_password], outputs=[change_pw_msg])
+fastapi_app = FastAPI()
 
-    def handle_delete_account(token, confirmed):
-        user = resolve_session(token)
-        if not user:
-            return "❌ Nejsi přihlášen/a.", token
-        if not confirmed:
-            return "⚠️ Zaškrtni prosím potvrzení.", token
-        try:
-            DB.delete_user(user["id"])
-            return "✅ Účet smazán. Sbohem!", ""
-        except Exception as e:
-            return f"❌ Chyba při mazání: {e}", token
 
-    delete_btn.click(handle_delete_account, inputs=[session_token, delete_confirm], outputs=[delete_msg, session_token])
+@fastapi_app.post("/stripe/webhook")
+async def stripe_webhook(request: FastAPIRequest):
+    return await backend.stripe_webhook_handler(request)
 
-    # ---- Dashboard data loading ----
-    def on_dashboard_enter(token):
-        user = resolve_session(token)
-        if not user:
-            return "", "", []
-        profile = f"**Jméno:** {user['name']}\\n\\n**Email:** {user['email']}\\n\\n**Plán:** {user['plan']}"
-        api_txt = handle_show_api_key(token)
-        invoices = invoices_to_dataframe(DB.get_invoices(user["id"]))
-        return profile, api_txt, invoices
 
-    session_token.change(on_dashboard_enter, inputs=[session_token], outputs=[profile_info, api_key_display, invoices_table])
+app = gr.mount_gradio_app(fastapi_app, demo, path="/")
 
 
 if __name__ == "__main__":
-    try:
-        demo.queue(max_size=20).launch(server_name="0.0.0.0", server_port=7860)
-    except Exception as e:
-        print(f"[FATAL] Aplikace se nepodařila spustit: {e}")
-        traceback.print_exc()
+    import uvicorn
+
+    demo.queue()
+    uvicorn.run(app, host="0.0.0.0", port=int(os.getenv("PORT", 7860)))

auth.py

@@ -0,0 +1,235 @@
+"""
+auth.py -- Authentication logic for OmniParse AI.
+
+Uses bcrypt for password hashing, an in-memory sliding-window rate limiter
+for login/register/reset, and issues opaque session tokens stored server-side
+(see database.py -- sessions table). No tokens or credentials are ever placed
+in LocalStorage; the frontend receives an HttpOnly cookie / Gradio server state.
+"""
+
+import os
+import re
+import time
+import logging
+import threading
+from collections import defaultdict, deque
+from typing import Optional
+
+import bcrypt
+
+import database as db
+
+logger = logging.getLogger("omniparse.auth")
+
+EMAIL_RE = re.compile(r"^[^@\s]+@[^@\s]+\.[^@\s]+$")
+
+DEMO_EMAIL = "demo@omniparse.ai"
+DEMO_PASSWORD = "demo1234"
+DEMO_USER = {
+    "id": -1,
+    "email": DEMO_EMAIL,
+    "name": "Demo Account",
+    "plan": "pro",
+    "stripe_cid": None,
+    "api_key": "demo-key-not-usable-for-billing",
+}
+
+BCRYPT_ROUNDS = 12
+
+
+# ---------------------------------------------------------------------------
+# Simple in-memory rate limiter (per-process). Suitable for a single-instance
+# HF Space; swap for a Redis-backed limiter behind a load balancer.
+# ---------------------------------------------------------------------------
+class RateLimiter:
+    def __init__(self, max_attempts: int, window_seconds: int):
+        self.max_attempts = max_attempts
+        self.window_seconds = window_seconds
+        self._hits = defaultdict(deque)
+        self._lock = threading.Lock()
+
+    def check(self, key: str) -> bool:
+        """Returns True if the action is allowed, False if rate-limited."""
+        now = time.time()
+        with self._lock:
+            bucket = self._hits[key]
+            while bucket and now - bucket[0] > self.window_seconds:
+                bucket.popleft()
+            if len(bucket) >= self.max_attempts:
+                return False
+            bucket.append(now)
+            return True
+
+    def seconds_until_reset(self, key: str) -> int:
+        with self._lock:
+            bucket = self._hits[key]
+            if not bucket:
+                return 0
+            return max(0, int(self.window_seconds - (time.time() - bucket[0])))
+
+
+login_limiter = RateLimiter(max_attempts=5, window_seconds=300)      # 5 / 5 min
+register_limiter = RateLimiter(max_attempts=3, window_seconds=3600)  # 3 / hour
+reset_limiter = RateLimiter(max_attempts=3, window_seconds=3600)     # 3 / hour
+
+
+class AuthError(Exception):
+    def __init__(self, message: str, code: str = "auth_error"):
+        super().__init__(message)
+        self.message = message
+        self.code = code
+
+
+# ---------------------------------------------------------------------------
+# Password hashing
+# ---------------------------------------------------------------------------
+def hash_password(plain_password: str) -> str:
+    salt = bcrypt.gensalt(rounds=BCRYPT_ROUNDS)
+    return bcrypt.hashpw(plain_password.encode("utf-8"), salt).decode("utf-8")
+
+
+def verify_password(plain_password: str, hashed: str) -> bool:
+    try:
+        return bcrypt.checkpw(plain_password.encode("utf-8"), hashed.encode("utf-8"))
+    except Exception:
+        return False
+
+
+def _validate_email(email: str) -> None:
+    if not email or not EMAIL_RE.match(email.strip()):
+        raise AuthError("Please enter a valid email address.", "invalid_email")
+
+
+def _validate_password_strength(password: str) -> None:
+    if not password or len(password) < 8:
+        raise AuthError("Password must be at least 8 characters long.", "weak_password")
+    if not re.search(r"[A-Za-z]", password) or not re.search(r"[0-9]", password):
+        raise AuthError("Password must contain both letters and numbers.", "weak_password")
+
+
+# ---------------------------------------------------------------------------
+# Register
+# ---------------------------------------------------------------------------
+def register(email: str, name: str, password: str, client_ip: str = "unknown") -> dict:
+    if not register_limiter.check(client_ip):
+        wait = register_limiter.seconds_until_reset(client_ip)
+        raise AuthError(f"Too many registration attempts. Try again in {wait}s.", "rate_limited")
+
+    email = email.strip().lower()
+    _validate_email(email)
+    if not name or len(name.strip()) < 2:
+        raise AuthError("Please enter your name.", "invalid_name")
+    _validate_password_strength(password)
+
+    if db.get_user_by_email(email):
+        raise AuthError("An account with this email already exists.", "email_taken")
+
+    hashed = hash_password(password)
+    user = db.create_user(email=email, name=name.strip(), hashed_password=hashed, plan="free")
+    token = db.create_session(user["id"])
+    return {"user": _public_user(user), "token": token}
+
+
+# ---------------------------------------------------------------------------
+# Login
+# ---------------------------------------------------------------------------
+def login(email: str, password: str, client_ip: str = "unknown") -> dict:
+    rl_key = f"{client_ip}:{email.strip().lower()}"
+    if not login_limiter.check(rl_key):
+        wait = login_limiter.seconds_until_reset(rl_key)
+        raise AuthError(f"Too many login attempts. Try again in {wait}s.", "rate_limited")
+
+    email = email.strip().lower()
+    _validate_email(email)
+    if not password:
+        raise AuthError("Password is required.", "invalid_password")
+
+    # Demo bypass: fixed demo credentials log into a dummy Pro account without
+    # touching bcrypt or the database. Never allow this path to mutate real data.
+    if email == DEMO_EMAIL and password == DEMO_PASSWORD:
+        return {"user": DEMO_USER, "token": "demo-session-token"}
+
+    user = db.get_user_by_email(email)
+    if not user or not verify_password(password, user["password"]):
+        raise AuthError("Invalid email or password.", "invalid_credentials")
+
+    token = db.create_session(user["id"])
+    return {"user": _public_user(user), "token": token}
+
+
+# ---------------------------------------------------------------------------
+# Password reset (OTP placeholder -- wire up an email/SMS provider in production)
+# ---------------------------------------------------------------------------
+def request_password_reset(email: str, client_ip: str = "unknown") -> dict:
+    if not reset_limiter.check(client_ip):
+        wait = reset_limiter.seconds_until_reset(client_ip)
+        raise AuthError(f"Too many reset attempts. Try again in {wait}s.", "rate_limited")
+
+    email = email.strip().lower()
+    _validate_email(email)
+    user = db.get_user_by_email(email)
+
+    # Always return a generic success message regardless of whether the
+    # account exists, to avoid leaking which emails are registered.
+    if user:
+        otp = _generate_otp()
+        # TODO(production): send `otp` via a transactional email/SMS provider
+        # (e.g. SendGrid, Twilio Verify) instead of logging it.
+        logger.info("Password reset OTP generated for user_id=%s", user["id"])
+        _pending_otps[email] = {"otp": otp, "expires": time.time() + 600}
+
+    return {"message": "If that email is registered, a reset code has been sent."}
+
+
+_pending_otps = {}
+
+
+def _generate_otp() -> str:
+    import secrets
+    return f"{secrets.randbelow(1_000_000):06d}"
+
+
+def confirm_password_reset(email: str, otp: str, new_password: str) -> dict:
+    email = email.strip().lower()
+    record = _pending_otps.get(email)
+    if not record or record["expires"] < time.time() or record["otp"] != otp:
+        raise AuthError("Invalid or expired reset code.", "invalid_otp")
+
+    _validate_password_strength(new_password)
+    user = db.get_user_by_email(email)
+    if not user:
+        raise AuthError("Account not found.", "invalid_credentials")
+
+    hashed = hash_password(new_password)
+    db.get_client().table("users").update({"password": hashed}).eq("id", user["id"]).execute()
+    del _pending_otps[email]
+    return {"message": "Password updated successfully."}
+
+
+# ---------------------------------------------------------------------------
+# Session helpers
+# ---------------------------------------------------------------------------
+def get_current_user(token: str) -> Optional[dict]:
+    if token == "demo-session-token":
+        return DEMO_USER
+    session = db.get_session(token)
+    if not session:
+        return None
+    user = db.get_user_by_id(session["user_id"])
+    return _public_user(user) if user else None
+
+
+def logout(token: str) -> None:
+    if token and token != "demo-session-token":
+        db.delete_session(token)
+
+
+def _public_user(user: dict) -> dict:
+    """Strip sensitive fields before sending a user object to the frontend."""
+    return {
+        "id": user["id"],
+        "email": user["email"],
+        "name": user["name"],
+        "plan": user["plan"],
+        "api_key": user.get("api_key"),
+    }

backend.py

@@ -0,0 +1,360 @@
+"""
+backend.py -- OCR pipeline, AI extraction cascade, cross-field validation,
+and the Stripe webhook listener for OmniParse AI.
+
+Environment variables required:
+    GOOGLE_VISION_API_KEY   (optional -- OCR tier 1)
+    GROQ_API_KEY            (AI tier 1)
+    HF_API_TOKEN            (AI tier 2)
+    STRIPE_SECRET_KEY
+    STRIPE_WEBHOOK_SECRET
+"""
+
+import os
+import re
+import io
+import json
+import base64
+import logging
+from typing import Optional
+
+import requests
+import stripe
+from PIL import Image
+import pytesseract
+from pdf2image import convert_from_bytes
+from fastapi import Request, HTTPException
+from fastapi.responses import JSONResponse
+
+import database as db
+
+logger = logging.getLogger("omniparse.backend")
+
+MAX_UPLOAD_BYTES = 5 * 1024 * 1024  # 5MB
+
+GOOGLE_VISION_API_KEY = os.getenv("GOOGLE_VISION_API_KEY")
+GROQ_API_KEY = os.getenv("GROQ_API_KEY")
+HF_API_TOKEN = os.getenv("HF_API_TOKEN")
+STRIPE_SECRET_KEY = os.getenv("STRIPE_SECRET_KEY")
+STRIPE_WEBHOOK_SECRET = os.getenv("STRIPE_WEBHOOK_SECRET")
+
+if STRIPE_SECRET_KEY:
+    stripe.api_key = STRIPE_SECRET_KEY
+
+PLAN_BY_PRICE_LOOKUP = {
+    # Map your Stripe Price lookup_keys / IDs to internal plan names.
+    "price_basic_monthly": "basic",
+    "price_pro_monthly": "pro",
+    "price_enterprise_monthly": "enterprise",
+}
+
+
+# ---------------------------------------------------------------------------
+# Upload validation
+# ---------------------------------------------------------------------------
+class UploadTooLarge(Exception):
+    pass
+
+
+def validate_upload_size(raw_bytes: bytes) -> None:
+    if len(raw_bytes) > MAX_UPLOAD_BYTES:
+        raise UploadTooLarge(f"File exceeds the 5MB limit ({len(raw_bytes)} bytes).")
+
+
+def _bytes_from_base64(b64_data: str) -> bytes:
+    if "," in b64_data and b64_data.strip().startswith("data:"):
+        b64_data = b64_data.split(",", 1)[1]
+    return base64.b64decode(b64_data)
+
+
+def _to_images(raw_bytes: bytes, filename: str) -> list:
+    """Return a list of PIL Images -- one per page for PDFs, one for images."""
+    lower = filename.lower()
+    if lower.endswith(".pdf"):
+        return convert_from_bytes(raw_bytes, dpi=200)
+    return [Image.open(io.BytesIO(raw_bytes)).convert("RGB")]
+
+
+# ---------------------------------------------------------------------------
+# OCR cascade: Google Vision -> pytesseract -> ""
+# ---------------------------------------------------------------------------
+def _ocr_google_vision(image: Image.Image) -> str:
+    if not GOOGLE_VISION_API_KEY:
+        return ""
+    try:
+        buf = io.BytesIO()
+        image.save(buf, format="PNG")
+        img_b64 = base64.b64encode(buf.getvalue()).decode("utf-8")
+        url = f"https://vision.googleapis.com/v1/images:annotate?key={GOOGLE_VISION_API_KEY}"
+        payload = {
+            "requests": [
+                {
+                    "image": {"content": img_b64},
+                    "features": [{"type": "TEXT_DETECTION"}],
+                }
+            ]
+        }
+        resp = requests.post(url, json=payload, timeout=15)
+        resp.raise_for_status()
+        data = resp.json()
+        annotations = data.get("responses", [{}])[0].get("textAnnotations", [])
+        if annotations:
+            return annotations[0].get("description", "")
+        return ""
+    except Exception as exc:
+        logger.warning("Google Vision OCR failed: %s", exc)
+        return ""
+
+
+def _ocr_pytesseract(image: Image.Image) -> str:
+    try:
+        return pytesseract.image_to_string(image, lang="eng")
+    except Exception as exc:
+        logger.warning("pytesseract OCR failed: %s", exc)
+        return ""
+
+
+def run_ocr_cascade(raw_bytes: bytes, filename: str) -> str:
+    images = _to_images(raw_bytes, filename)
+    full_text = []
+    for image in images:
+        text = _ocr_google_vision(image)
+        if not text.strip():
+            text = _ocr_pytesseract(image)
+        full_text.append(text)
+    return "\n".join(full_text).strip()
+
+
+# ---------------------------------------------------------------------------
+# AI extraction cascade: Groq -> HF -> Regex
+# ---------------------------------------------------------------------------
+EXTRACTION_PROMPT = """You extract structured invoice data. Given raw OCR text from an invoice,
+return STRICT JSON only, no prose, matching exactly this schema:
+{{
+  "vendor": string|null,
+  "inv_number": string|null,
+  "inv_date": string|null,
+  "due_date": string|null,
+  "amount": number|null,
+  "vat_amount": number|null,
+  "total": number|null,
+  "currency": string|null,
+  "confidence": number
+}}
+OCR TEXT:
+---
+{ocr_text}
+---
+Respond with JSON only."""
+
+
+def _extract_json_block(text: str) -> Optional[dict]:
+    try:
+        start = text.index("{")
+        end = text.rindex("}") + 1
+        return json.loads(text[start:end])
+    except Exception:
+        return None
+
+
+def _ai_groq(ocr_text: str) -> Optional[dict]:
+    if not GROQ_API_KEY:
+        return None
+    try:
+        resp = requests.post(
+            "https://api.groq.com/openai/v1/chat/completions",
+            headers={
+                "Authorization": f"Bearer {GROQ_API_KEY}",
+                "Content-Type": "application/json",
+            },
+            json={
+                "model": "llama-3.1-8b-instant",
+                "messages": [
+                    {"role": "system", "content": "You output only strict JSON."},
+                    {"role": "user", "content": EXTRACTION_PROMPT.format(ocr_text=ocr_text[:6000])},
+                ],
+                "temperature": 0,
+                "response_format": {"type": "json_object"},
+            },
+            timeout=10,
+        )
+        resp.raise_for_status()
+        content = resp.json()["choices"][0]["message"]["content"]
+        parsed = _extract_json_block(content)
+        if parsed:
+            parsed["_source"] = "groq"
+        return parsed
+    except Exception as exc:
+        logger.warning("Groq extraction failed: %s", exc)
+        return None
+
+
+def _ai_huggingface(ocr_text: str) -> Optional[dict]:
+    if not HF_API_TOKEN:
+        return None
+    try:
+        resp = requests.post(
+            "https://api-inference.huggingface.co/models/mistralai/Mistral-7B-Instruct-v0.3",
+            headers={"Authorization": f"Bearer {HF_API_TOKEN}"},
+            json={
+                "inputs": EXTRACTION_PROMPT.format(ocr_text=ocr_text[:4000]),
+                "parameters": {"max_new_tokens": 400, "temperature": 0.0},
+            },
+            timeout=45,
+        )
+        resp.raise_for_status()
+        data = resp.json()
+        text_out = data[0].get("generated_text", "") if isinstance(data, list) else str(data)
+        parsed = _extract_json_block(text_out)
+        if parsed:
+            parsed["_source"] = "huggingface"
+        return parsed
+    except Exception as exc:
+        logger.warning("HF extraction failed: %s", exc)
+        return None
+
+
+INV_NUMBER_RE = re.compile(r"(?:invoice|inv)[#:\s]+([A-Z0-9-]{4,24})", re.IGNORECASE)
+DATE_RE = re.compile(r"\d{1,2}[\/.\-]\d{1,2}[\/.\-]\d{4}")
+AMOUNT_RE = re.compile(r"(?:total|amount due)[\s:$]+([0-9,\.]+)", re.IGNORECASE)
+
+
+def _ai_regex_fallback(ocr_text: str) -> dict:
+    inv_match = INV_NUMBER_RE.search(ocr_text)
+    dates = DATE_RE.findall(ocr_text)
+    amount_match = AMOUNT_RE.search(ocr_text)
+
+    total = None
+    if amount_match:
+        try:
+            total = float(amount_match.group(1).replace(",", ""))
+        except ValueError:
+            total = None
+
+    return {
+        "vendor": None,
+        "inv_number": inv_match.group(1) if inv_match else None,
+        "inv_date": dates[0] if len(dates) > 0 else None,
+        "due_date": dates[1] if len(dates) > 1 else None,
+        "amount": None,
+        "vat_amount": None,
+        "total": total,
+        "currency": "USD",
+        "confidence": 0.35,
+        "_source": "regex",
+    }
+
+
+def run_ai_cascade(ocr_text: str) -> dict:
+    if not ocr_text.strip():
+        return {
+            "vendor": None, "inv_number": None, "inv_date": None, "due_date": None,
+            "amount": None, "vat_amount": None, "total": None, "currency": "USD",
+            "confidence": 0.0, "_source": "none",
+        }
+    parsed = _ai_groq(ocr_text)
+    if not parsed:
+        parsed = _ai_huggingface(ocr_text)
+    if not parsed:
+        parsed = _ai_regex_fallback(ocr_text)
+    return parsed
+
+
+# ---------------------------------------------------------------------------
+# Validation
+# ---------------------------------------------------------------------------
+def validate_totals(parsed: dict, tolerance: float = 0.10) -> bool:
+    amount = parsed.get("amount")
+    vat = parsed.get("vat_amount") or 0
+    total = parsed.get("total")
+    if amount is None or total is None:
+        return False
+    return abs((amount + vat) - total) <= tolerance
+
+
+# ---------------------------------------------------------------------------
+# End-to-end pipeline used by app.py
+# ---------------------------------------------------------------------------
+def process_invoice_file(raw_bytes: bytes, filename: str) -> dict:
+    validate_upload_size(raw_bytes)
+    ocr_text = run_ocr_cascade(raw_bytes, filename)
+    parsed = run_ai_cascade(ocr_text)
+
+    is_valid = validate_totals(parsed)
+    status = "done" if (parsed.get("total") is not None) else "needs_review"
+    if parsed.get("amount") is not None and parsed.get("total") is not None and not is_valid:
+        status = "needs_review"
+
+    parsed["status"] = status
+    parsed["raw_json"] = {"ocr_text": ocr_text[:10000], "cross_field_valid": is_valid}
+    return parsed
+
+
+# ---------------------------------------------------------------------------
+# Stripe webhook (mounted as a FastAPI route in app.py)
+# ---------------------------------------------------------------------------
+async def stripe_webhook_handler(request: Request):
+    payload = await request.body()
+    sig_header = request.headers.get("stripe-signature")
+
+    if not STRIPE_WEBHOOK_SECRET:
+        raise HTTPException(status_code=500, detail="Webhook secret not configured.")
+
+    try:
+        event = stripe.Webhook.construct_event(payload, sig_header, STRIPE_WEBHOOK_SECRET)
+    except ValueError:
+        raise HTTPException(status_code=400, detail="Invalid payload.")
+    except stripe.error.SignatureVerificationError:
+        raise HTTPException(status_code=400, detail="Invalid signature.")
+
+    event_type = event["type"]
+    obj = event["data"]["object"]
+
+    try:
+        if event_type == "checkout.session.completed":
+            customer_id = obj.get("customer")
+            client_ref = obj.get("client_reference_id")  # our internal user_id, set at checkout creation
+            plan = _plan_from_line_items(obj)
+            if client_ref:
+                db.update_user_plan(int(client_ref), plan or "basic", stripe_cid=customer_id)
+
+        elif event_type in ("customer.subscription.updated", "customer.subscription.created"):
+            customer_id = obj.get("customer")
+            plan = _plan_from_subscription(obj)
+            user = db.get_user_by_stripe_customer(customer_id)
+            if user and plan:
+                db.update_user_plan(user["id"], plan)
+
+        elif event_type == "customer.subscription.deleted":
+            customer_id = obj.get("customer")
+            user = db.get_user_by_stripe_customer(customer_id)
+            if user:
+                db.update_user_plan(user["id"], "free")
+
+    except Exception as exc:
+        logger.error("Error handling Stripe event %s: %s", event_type, exc)
+        raise HTTPException(status_code=500, detail="Internal error processing webhook.")
+
+    return JSONResponse({"received": True})
+
+
+def _plan_from_line_items(session_obj: dict) -> Optional[str]:
+    try:
+        for item in session_obj.get("line_items", {}).get("data", []):
+            lookup_key = item.get("price", {}).get("lookup_key")
+            if lookup_key in PLAN_BY_PRICE_LOOKUP:
+                return PLAN_BY_PRICE_LOOKUP[lookup_key]
+    except Exception:
+        pass
+    return None
+
+
+def _plan_from_subscription(sub_obj: dict) -> Optional[str]:
+    try:
+        for item in sub_obj.get("items", {}).get("data", []):
+            lookup_key = item.get("price", {}).get("lookup_key")
+            if lookup_key in PLAN_BY_PRICE_LOOKUP:
+                return PLAN_BY_PRICE_LOOKUP[lookup_key]
+    except Exception:
+        pass
+    return None

database.py

@@ -0,0 +1,298 @@
+"""
+database.py -- Supabase (PostgreSQL) data layer for OmniParse AI.
+
+Requires environment variables:
+    SUPABASE_URL
+    SUPABASE_KEY   (service role key -- used only from the server side)
+"""
+
+import os
+import json
+import uuid
+import logging
+from datetime import datetime, timedelta, timezone
+from typing import Optional
+
+from supabase import create_client, Client
+
+logger = logging.getLogger("omniparse.database")
+
+SUPABASE_URL = os.getenv("SUPABASE_URL")
+SUPABASE_KEY = os.getenv("SUPABASE_KEY")
+
+if not SUPABASE_URL or not SUPABASE_KEY:
+    logger.warning("SUPABASE_URL / SUPABASE_KEY not set. database.py will fail on first call.")
+
+_client: Optional[Client] = None
+
+
+def get_client() -> Client:
+    """Lazily instantiate and return the Supabase client (singleton)."""
+    global _client
+    if _client is None:
+        if not SUPABASE_URL or not SUPABASE_KEY:
+            raise RuntimeError("SUPABASE_URL and SUPABASE_KEY must be set in the environment.")
+        _client = create_client(SUPABASE_URL, SUPABASE_KEY)
+    return _client
+
+
+# ---------------------------------------------------------------------------
+# SQL schema + Row Level Security policies.
+# Run this once via the Supabase SQL editor (or migrations) before deploying.
+# ---------------------------------------------------------------------------
+SCHEMA_SQL = """
+-- =========================================================
+-- OmniParse AI -- schema.sql
+-- =========================================================
+
+create extension if not exists pgcrypto;
+
+create table if not exists users (
+    id           bigserial primary key,
+    email        text unique not null,
+    name         text not null,
+    password     text not null,               -- bcrypt hash
+    plan         text not null default 'free', -- free | basic | pro | enterprise
+    stripe_cid   text,
+    api_key      text unique default encode(gen_random_bytes(24), 'hex'),
+    created_at   timestamptz not null default now()
+);
+
+create table if not exists sessions (
+    token        text primary key,
+    user_id      bigint not null references users(id) on delete cascade,
+    expires_at   timestamptz not null
+);
+
+create table if not exists invoices (
+    id           bigserial primary key,
+    user_id      bigint not null references users(id) on delete cascade,
+    filename     text not null,
+    vendor       text,
+    inv_number   text,
+    inv_date     text,
+    due_date     text,
+    amount       numeric(12,2),
+    vat_amount   numeric(12,2),
+    total        numeric(12,2),
+    currency     text default 'USD',
+    status       text default 'done',          -- processing | done | error | needs_review
+    is_duplicate boolean default false,
+    confidence   numeric(4,3),
+    raw_json     jsonb,
+    created_at   timestamptz not null default now()
+);
+
+create index if not exists idx_invoices_user_id on invoices(user_id);
+create index if not exists idx_invoices_vendor_amount on invoices(user_id, vendor, total);
+
+-- =========================================================
+-- Row Level Security
+-- =========================================================
+alter table users    enable row level security;
+alter table sessions enable row level security;
+alter table invoices enable row level security;
+
+-- users: a row is only visible/editable by its owner
+drop policy if exists users_select_own on users;
+create policy users_select_own on users
+    for select using (auth.uid()::text = id::text);
+
+drop policy if exists users_update_own on users;
+create policy users_update_own on users
+    for update using (auth.uid()::text = id::text);
+
+-- sessions: owner only
+drop policy if exists sessions_all_own on sessions;
+create policy sessions_all_own on sessions
+    for all using (auth.uid()::text = user_id::text);
+
+-- invoices: owner only, on every operation
+drop policy if exists invoices_select_own on invoices;
+create policy invoices_select_own on invoices
+    for select using (auth.uid() = user_id);
+
+drop policy if exists invoices_insert_own on invoices;
+create policy invoices_insert_own on invoices
+    for insert with check (auth.uid() = user_id);
+
+drop policy if exists invoices_update_own on invoices;
+create policy invoices_update_own on invoices
+    for update using (auth.uid() = user_id);
+
+drop policy if exists invoices_delete_own on invoices;
+create policy invoices_delete_own on invoices
+    for delete using (auth.uid() = user_id);
+"""
+
+
+# ---------------------------------------------------------------------------
+# User functions
+# ---------------------------------------------------------------------------
+def create_user(email: str, name: str, hashed_password: str, plan: str = "free") -> dict:
+    """Insert a new user. Raises on duplicate email (unique constraint)."""
+    client = get_client()
+    payload = {
+        "email": email.strip().lower(),
+        "name": name.strip(),
+        "password": hashed_password,
+        "plan": plan,
+    }
+    res = client.table("users").insert(payload).execute()
+    if not res.data:
+        raise RuntimeError("Failed to create user.")
+    return res.data[0]
+
+
+def get_user_by_email(email: str) -> Optional[dict]:
+    client = get_client()
+    res = (
+        client.table("users")
+        .select("*")
+        .eq("email", email.strip().lower())
+        .limit(1)
+        .execute()
+    )
+    return res.data[0] if res.data else None
+
+
+def get_user_by_id(user_id: int) -> Optional[dict]:
+    client = get_client()
+    res = client.table("users").select("*").eq("id", user_id).limit(1).execute()
+    return res.data[0] if res.data else None
+
+
+def update_user_plan(user_id: int, plan: str, stripe_cid: Optional[str] = None) -> None:
+    client = get_client()
+    payload = {"plan": plan}
+    if stripe_cid:
+        payload["stripe_cid"] = stripe_cid
+    client.table("users").update(payload).eq("id", user_id).execute()
+
+
+def get_user_by_stripe_customer(stripe_cid: str) -> Optional[dict]:
+    client = get_client()
+    res = (
+        client.table("users")
+        .select("*")
+        .eq("stripe_cid", stripe_cid)
+        .limit(1)
+        .execute()
+    )
+    return res.data[0] if res.data else None
+
+
+# ---------------------------------------------------------------------------
+# Session functions
+# ---------------------------------------------------------------------------
+def create_session(user_id: int, ttl_hours: int = 72) -> str:
+    client = get_client()
+    token = uuid.uuid4().hex + uuid.uuid4().hex
+    expires_at = (datetime.now(timezone.utc) + timedelta(hours=ttl_hours)).isoformat()
+    client.table("sessions").insert(
+        {"token": token, "user_id": user_id, "expires_at": expires_at}
+    ).execute()
+    return token
+
+
+def get_session(token: str) -> Optional[dict]:
+    if not token:
+        return None
+    client = get_client()
+    res = client.table("sessions").select("*").eq("token", token).limit(1).execute()
+    if not res.data:
+        return None
+    session = res.data[0]
+    expires_at = datetime.fromisoformat(session["expires_at"].replace("Z", "+00:00"))
+    if expires_at < datetime.now(timezone.utc):
+        delete_session(token)
+        return None
+    return session
+
+
+def delete_session(token: str) -> None:
+    client = get_client()
+    client.table("sessions").delete().eq("token", token).execute()
+
+
+# ---------------------------------------------------------------------------
+# Invoice functions
+# ---------------------------------------------------------------------------
+def check_for_duplicate(user_id: int, vendor: str, total: float) -> bool:
+    """A duplicate is the same vendor + exact total already recorded this month."""
+    if not vendor or total is None:
+        return False
+    client = get_client()
+    now = datetime.now(timezone.utc)
+    month_start = now.replace(day=1, hour=0, minute=0, second=0, microsecond=0).isoformat()
+    res = (
+        client.table("invoices")
+        .select("id")
+        .eq("user_id", user_id)
+        .eq("vendor", vendor)
+        .eq("total", total)
+        .gte("created_at", month_start)
+        .limit(1)
+        .execute()
+    )
+    return bool(res.data)
+
+
+def save_invoice_record(user_id: int, filename: str, parsed: dict) -> dict:
+    """
+    parsed is the normalized dict produced by backend.py's AI/OCR cascade:
+    {vendor, inv_number, inv_date, due_date, amount, vat_amount, total,
+     currency, confidence, status, raw_json}
+    """
+    client = get_client()
+    vendor = parsed.get("vendor")
+    total = parsed.get("total")
+    is_dup = check_for_duplicate(user_id, vendor, total) if vendor and total is not None else False
+
+    payload = {
+        "user_id": user_id,
+        "filename": filename,
+        "vendor": vendor,
+        "inv_number": parsed.get("inv_number"),
+        "inv_date": parsed.get("inv_date"),
+        "due_date": parsed.get("due_date"),
+        "amount": parsed.get("amount"),
+        "vat_amount": parsed.get("vat_amount"),
+        "total": total,
+        "currency": parsed.get("currency", "USD"),
+        "status": parsed.get("status", "done"),
+        "is_duplicate": is_dup,
+        "confidence": parsed.get("confidence"),
+        "raw_json": json.dumps(parsed.get("raw_json", {})),
+    }
+    res = client.table("invoices").insert(payload).execute()
+    if not res.data:
+        raise RuntimeError("Failed to save invoice record.")
+    return res.data[0]
+
+
+def list_invoices(user_id: int, limit: int = 200) -> list:
+    client = get_client()
+    res = (
+        client.table("invoices")
+        .select("*")
+        .eq("user_id", user_id)
+        .order("created_at", desc=True)
+        .limit(limit)
+        .execute()
+    )
+    return res.data or []
+
+
+def count_invoices_this_month(user_id: int) -> int:
+    client = get_client()
+    now = datetime.now(timezone.utc)
+    month_start = now.replace(day=1, hour=0, minute=0, second=0, microsecond=0).isoformat()
+    res = (
+        client.table("invoices")
+        .select("id", count="exact")
+        .eq("user_id", user_id)
+        .gte("created_at", month_start)
+        .execute()
+    )
+    return res.count or 0

requirements.txt

@@ -1,12 +1,14 @@
-gradio
-requests
-Pillow
-bcrypt
-pytesseract
-pdf2image
-groq
-stripe
-supabase
-python-multipart
-fastapi
-uvicorn
+gradio==4.42.0
+bcrypt>=4.0.1
+pydub==0.25.1
+requests>=2.31.0
+stripe>=10.0.0
+Pillow>=10.0.0
+pytesseract>=0.3.10
+pdf2image>=1.17.0
+python-multipart>=0.0.9
+psycopg2-binary>=2.9.9
+groq>=0.9.0
+supabase>=2.4.0
+fastapi>=0.110.0
+uvicorn>=0.29.0