auth: use pass_hash + prenorm + lazy LoRA load + translate/history

app.py

@@ -1,421 +1,289 @@
-import os, re, json, logging, datetime as dt
-from typing import Optional, List
+# app.py
+# PapuaTranslate — Flask 3 + SQLAlchemy + Supabase + mT5-LoRA (lazy load) + prenorm
+import os, re, json, logging, threading
+from datetime import datetime, timezone
+from functools import wraps
+from typing import Optional, Tuple, List
+
+from flask import (
+    Flask, render_template, request, redirect, url_for,
+    session, jsonify, flash
+)
+
+# ========= Logging =========
+logging.basicConfig(level=logging.INFO, format="%(asctime)s | %(levelname)s | %(message)s")
+log = logging.getLogger("papua-app")
 
-from flask import Flask, request, render_template, redirect, url_for, jsonify
-from flask_login import (
-    LoginManager, UserMixin, login_user, logout_user,
-    login_required, current_user
+# ========= Flask =========
+app = Flask(
+    __name__,
+    template_folder="frontend",  # folder HTML kamu
+    static_folder="static"
 )
-from werkzeug.security import generate_password_hash, check_password_hash
+app.config["SECRET_KEY"] = os.getenv("SECRET_KEY", "dev-secret-change-me")
+app.config["SESSION_COOKIE_SAMESITE"] = "Lax"     # biar fetch same-origin ikut kirim cookie
+app.config["SESSION_COOKIE_SECURE"] = False       # True kalau pakai https strict
 
+# ========= DB: SQLAlchemy (Supabase Postgres) =========
 from sqlalchemy import (
-    create_engine, Column, Integer, String, Text, DateTime, ForeignKey, func, text, inspect
+    create_engine, Column, Integer, Text, DateTime, ForeignKey, func
 )
 from sqlalchemy.orm import declarative_base, sessionmaker, scoped_session, relationship
 
-# =========================
-# Logging
-# =========================
-logging.basicConfig(level=logging.INFO, format="%(asctime)s | %(levelname)s | %(message)s")
-log = logging.getLogger("papuatranslate")
-
-# =========================
-# Flask
-# =========================
-app = Flask(__name__, static_folder="static", template_folder="frontend")
-app.config["SECRET_KEY"] = os.getenv("SECRET_KEY", "dev-secret")
-
-# =========================
-# Database (Supabase or fallback SQLite)
-# =========================
-def normalize_database_url(url: Optional[str]) -> str:
-    if not url:
-        return "sqlite:////tmp/app.db"
-    url = url.strip()
-    if url.startswith("postgresql://") and "psycopg2" not in url:
-        url = "postgresql+psycopg2://" + url.split("postgresql://", 1)[1]
-    if url.startswith("postgresql+psycopg2://") and "sslmode=" not in url:
-        sep = "&" if "?" in url else "?"
-        url = f"{url}{sep}sslmode=require"
-    return url
-
-DATABASE_URL = normalize_database_url(os.getenv("DATABASE_URL"))
-try:
-    engine = create_engine(DATABASE_URL, pool_pre_ping=True)
-    log.info("[DB] Ready: %s", DATABASE_URL)
-except Exception as e:
-    log.error("[DB] init error: %s", e)
-    engine = create_engine("sqlite:////tmp/app.db")
-    log.info("[DB] Fallback: sqlite:////tmp/app.db")
+DATABASE_URL = os.getenv("DATABASE_URL") or os.getenv("DB_URL")
+if not DATABASE_URL:
+    # fallback aman untuk run lokal
+    DATABASE_URL = "sqlite:////tmp/app.db"
+    log.warning("[DB] DATABASE_URL tidak diset; pakai SQLite /tmp/app.db")
+
+# tambahkan sslmode=require kalau Postgres dan belum ada
+if DATABASE_URL.startswith("postgresql") and "sslmode=" not in DATABASE_URL:
+    sep = "&" if "?" in DATABASE_URL else "?"
+    DATABASE_URL = f"{DATABASE_URL}{sep}sslmode=require"
 
-Session = scoped_session(sessionmaker(bind=engine, autoflush=False, expire_on_commit=False))
+engine = create_engine(
+    DATABASE_URL,
+    pool_pre_ping=True,
+)
+SessionLocal = scoped_session(sessionmaker(bind=engine, autoflush=False, autocommit=False))
 Base = declarative_base()
 
-# =========================
-# ORM Models (jangan map kolom 'pass_hash' di sini agar query aman)
-# =========================
-class User(Base, UserMixin):
+class User(Base):
     __tablename__ = "users"
     id = Column(Integer, primary_key=True)
-    email = Column(String(255), unique=True, nullable=False)
-    password = Column(String(255), nullable=True)  # bisa nullable karena beberapa DB lama pakai pass_hash
-    created_at = Column(DateTime, server_default=func.now())
-    translations = relationship("Translation", back_populates="user")
+    email = Column(Text, unique=True, nullable=False)
+    pass_hash = Column(Text, nullable=False)  # WAJIB: pakai pass_hash
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
 
 class Translation(Base):
     __tablename__ = "translations"
     id = Column(Integer, primary_key=True)
-    user_id = Column(Integer, ForeignKey("users.id"))
-    src = Column(Text)
-    mt = Column(Text)
-    created_at = Column(DateTime, server_default=func.now())
-    user = relationship("User", back_populates="translations")
-
-# create jika belum ada
-Base.metadata.create_all(engine)
-
-# =========================
-# MIGRASI RINGAN: sinkron kolom users (password/created_at) dan handle pass_hash
-# =========================
-def has_col(table: str, col: str) -> bool:
-    insp = inspect(engine)
-    if not insp.has_table(table): return False
-    return any(c["name"] == col for c in insp.get_columns(table))
-
-def col_nullable(table: str, col: str) -> Optional[bool]:
-    insp = inspect(engine)
-    if not insp.has_table(table): return None
-    for c in insp.get_columns(table):
-        if c["name"] == col:
-            return c.get("nullable", None)
-    return None
-
-def auto_migrate_users_table():
-    insp = inspect(engine)
-    if not insp.has_table("users"):
-        log.info("[DB] Table users belum ada; ORM sudah membuatnya via create_all")
-        return
-
-    cols = {c["name"] for c in insp.get_columns("users")}
-    alters = []
-    if "password" not in cols:
-        alters.append("ALTER TABLE users ADD COLUMN password VARCHAR(255)")
-    if "created_at" not in cols:
-        alters.append("ALTER TABLE users ADD COLUMN created_at TIMESTAMP DEFAULT NOW()")
-
-    # Eksekusi ALTER yang perlu
-    if alters:
-        with engine.begin() as conn:
-            for stmt in alters:
-                log.info("[DB] MIGRATE: %s", stmt)
-                conn.execute(text(stmt))
-
-    # Jika ada kolom pass_hash, pastikan terisi (backfill dari password)
-    if "pass_hash" in cols:
-        with engine.begin() as conn:
-            # Backfill: kalau pass_hash NULL & password IS NOT NULL → copy
-            conn.execute(text("""
-                UPDATE users
-                SET pass_hash = password
-                WHERE pass_hash IS NULL AND password IS NOT NULL
-            """))
-    log.info("[DB] Skema users sudah sesuai")
-
-auto_migrate_users_table()
-
-# =========================
-# Auth
-# =========================
-login_manager = LoginManager()
-login_manager.login_view = "login_get"
-login_manager.init_app(app)
-
-@login_manager.user_loader
-def load_user(uid: str):
-    s = Session()
-    try:
-        return s.get(User, int(uid))
-    finally:
-        s.close()
-
-# =========================
-# Pre-norm & Heuristics
-# =========================
-_PRE_NORM_ON = os.getenv("PRE_NORM", "1") != "0"
-_N_BEST = max(1, int(os.getenv("N_BEST", "1")))
-_COPY_PENALTY = os.getenv("COPY_PENALTY", "1") != "0"
-
-_PN_SPACE = re.compile(r"\s+")
-_PN_REPEAT = re.compile(r"(.)\1{3,}")
-_PN_SYMBOLS = { "“":"\"", "”":"\"", "‘":"'", "’":"'" }
-_PN_RULES = [
-    (r"\bsa\b", "saya"),
-    (r"\bko\b", "kamu"),
-    (r"\btra\b", "tidak"),
-    (r"\bsu\b", "sudah"),
-    (r"\bbeta\b", "saya"),
-    (r"\bdorang\b", "mereka"),
-    (r"\bdong\b", "mereka"),
-    (r"\bma\b", "tetapi"),
-]
-
-def pre_norm(text: str) -> str:
-    if not text: return text
-    t = text.replace("\ufeff", "")
-    for k, v in _PN_SYMBOLS.items(): t = t.replace(k, v)
-    t = _PN_SPACE.sub(" ", t.strip())
-    t = _PN_REPEAT.sub(r"\1\1", t)
-    lower = t.lower()
-    for rx, rep in _PN_RULES:
-        lower = re.sub(rx, rep, lower)
-    return lower.capitalize()
-
-def copy_distance(a: str, b: str) -> float:
-    if not a or not b: return 1.0
-    a, b = a.lower(), b.lower()
-    same = int(a == b)
-    sub = sum(1 for x, y in zip(a.split(), b.split()) if x == y)
-    return max(0.0, 1.0 - (same * 0.7 + sub / (len(a.split()) + 1)))
-
-# =========================
-# Model (lazy)
-# =========================
-DEVICE = "cpu"
-_tok = None
-_model = None
-
-def load_model_safe():
-    global _tok, _model, DEVICE
-    if _model is not None: return
-    base = os.getenv("BASE_MODEL", "").strip()
-    adapter = os.getenv("LORA_ADAPTER", "").strip()
-    if not base:
-        log.warning("[MODEL] BASE_MODEL not set -> DUMMY mode")
-        return
-    try:
-        from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
-        from peft import PeftModel
-        import torch
-        DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
-        log.info("[INFO] Using device: %s", DEVICE)
-        log.info("[INFO] Base model: %s", base)
-        if adapter: log.info("[INFO] Adapter   : %s", adapter)
-
-        _tok = AutoTokenizer.from_pretrained(base)
-        _model = AutoModelForSeq2SeqLM.from_pretrained(base)
-        if adapter:
-            try:
-                _model = PeftModel.from_pretrained(_model, adapter)
-            except Exception as e:
-                log.error("[MODEL] adapter load error: %s", e)
-
-        _model.eval()
-        if DEVICE == "cuda":
-            _model.to("cuda")
-    except Exception as e:
-        log.error("[MODEL] load error: %s", e)
-        _tok, _model = None, None
-
-def generate_n_best(prompt: str, n_best: int, max_new_tokens: int) -> List[str]:
-    load_model_safe()
-    if _model is None or _tok is None:
-        return [f"(dummy) {prompt}"]
-    import torch
-    inputs = _tok([prompt], return_tensors="pt", padding=True, truncation=True)
-    if DEVICE == "cuda":
-        inputs = {k: v.to("cuda") for k, v in inputs.items()}
-    outs = []
-    for seed in range(n_best):
-        torch.manual_seed(1234 + seed)
-        with torch.no_grad():
-            out = _model.generate(
-                **inputs,
-                max_new_tokens=max_new_tokens,
-                do_sample=True, top_p=0.9, top_k=40, temperature=0.9,
-                num_return_sequences=1
-            )
-        detok = _tok.batch_decode(out, skip_special_tokens=True)
-        if detok: outs.append(detok[0])
-    return outs or [""]
-
-def score_candidate(src: str, hyp: str) -> float:
-    score = 1.0
-    if len(hyp.split()) <= 2: score -= 0.3
-    if _COPY_PENALTY: score += copy_distance(src, hyp) * 0.5
-    if src.strip().lower() == hyp.strip().lower(): score -= 0.5
-    return score
-
-def translate_core(text: str, max_new_tokens: int = 32) -> str:
-    raw = text or ""
-    src = pre_norm(raw) if _PRE_NORM_ON else raw
-    cands = generate_n_best(src, max(1, _N_BEST), max_new_tokens)
-    hyp = cands[0] if len(cands) == 1 else sorted(
-        ((score_candidate(src, h), h) for h in cands),
-        key=lambda x: x[0], reverse=True
-    )[0][1]
-    hyp = hyp.strip()
-    if not hyp.endswith(('.', '!', '?')): hyp += '.'
-    if hyp: hyp = hyp[0].upper() + hyp[1:]
-    return hyp
-
-# =========================
-# Helpers untuk register/login menyesuaikan kolom pass_hash
-# =========================
-def users_has_pass_hash() -> bool:
-    return has_col("users", "pass_hash")
-
-def insert_user(email: str, hashed: str) -> int:
-    """Insert user. Jika ada kolom pass_hash, isi keduanya."""
-    with engine.begin() as conn:
-        if users_has_pass_hash():
-            # Isi keduanya agar constraint NOT NULL terpenuhi
-            row = conn.execute(
-                text("INSERT INTO users (email, password, pass_hash) VALUES (:e, :p, :p) RETURNING id"),
-                {"e": email, "p": hashed}
-            ).first()
-        else:
-            row = conn.execute(
-                text("INSERT INTO users (email, password) VALUES (:e, :p) RETURNING id"),
-                {"e": email, "p": hashed}
-            ).first()
-        return int(row[0])
-
-# =========================
-# Routes
-# =========================
-@app.get("/")
-def home():
-    if not current_user.is_authenticated:
-        return redirect(url_for("login_get"))
-    s = Session()
+    user_id = Column(Integer, ForeignKey("users.id"), nullable=False)
+    src = Column(Text, nullable=False)
+    mt = Column(Text, nullable=False)
+    created_at = Column(DateTime(timezone=True), server_default=func.now())
+
+    user = relationship("User")
+
+# create_all aman untuk SQLite; untuk Supabase jika tabel sudah ada, ini tidak mengubah skema
+try:
+    Base.metadata.create_all(engine)
+    log.info("[DB] Ready: %s", DATABASE_URL)
+except Exception as e:
+    log.exception("[DB] init error: %s", e)
+
+# ========= Auth helpers =========
+from werkzeug.security import generate_password_hash, check_password_hash
+
+def set_password(user: User, raw: str):
+    user.pass_hash = generate_password_hash(raw)
+
+def verify_password(user: User, raw: str) -> bool:
     try:
-        q = (s.query(Translation)
-              .filter(Translation.user_id == current_user.id)
-              .order_by(Translation.id.desc())
-              .limit(10))
-        recent = [
-            {"src": r.src, "mt": r.mt, "created_at": (r.created_at.isoformat() if r.created_at else "")}
-            for r in q.all()
-        ]
-    finally:
-        s.close()
-    return render_template("index.html",
-                           device=("cuda" if os.getenv("CUDA_VISIBLE_DEVICES") else "cpu"),
-                           recent=recent, logged_in=True)
+        return check_password_hash(user.pass_hash, raw)
+    except Exception:
+        return False
+
+def login_required(fn):
+    @wraps(fn)
+    def _wrap(*args, **kwargs):
+        if not session.get("uid"):
+            return redirect(url_for("login_get"))
+        return fn(*args, **kwargs)
+    return _wrap
+
+# ========= Prenorm (heuristik ringan agar input lebih bersih) =========
+# Kamu bisa kembangkan sesuai kebutuhanmu.
+PAPUA_MAP = {
+    r"\bsa\b": "saya",
+    r"\bko\b": "kamu",
+    r"\btra\b": "tidak",
+    r"\bndak\b": "tidak",
+    r"\bmo\b": "mau",
+    r"\bpu\b": "punya",
+    r"\bsu\b": "sudah",
+    r"\bkong\b": "kemudian",
+}
+
+def prenorm(text: str) -> str:
+    t = text.strip()
+    t = re.sub(r"\s+", " ", t)
+    # normalisasi tanda baca aneh
+    t = t.replace("…", "...").replace("–", "-").replace("—", "-")
+    # map kata umum dialek → baku (heuristik)
+    for pat, repl in PAPUA_MAP.items():
+        t = re.sub(pat, repl, t, flags=re.IGNORECASE)
+    return t
+
+# ========= Model (lazy-load LoRA) =========
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
+from peft import PeftModel
+
+BASE_MODEL_ID = os.getenv("BASE_MODEL_ID", "amosnbn/cendol-mt5-base-inst")
+ADAPTER_ID    = os.getenv("ADAPTER_ID", "amosnbn/papua-lora-ckpt-168")
+DEVICE = os.getenv("DEVICE", "cpu")  # di Spaces CPU
+TOK = None
+MODEL = None
+_MODEL_LOCK = threading.Lock()
+
+def _load_model():
+    global TOK, MODEL
+    log.info("[MODEL] loading base=%s adapter=%s", BASE_MODEL_ID, ADAPTER_ID)
+    TOK = AutoTokenizer.from_pretrained(BASE_MODEL_ID)
+    base = AutoModelForSeq2SeqLM.from_pretrained(BASE_MODEL_ID)
+    MODEL = PeftModel.from_pretrained(base, ADAPTER_ID)
+    MODEL.eval()
+    if DEVICE == "cpu":
+        MODEL.to("cpu")
+    log.info("[MODEL] ready")
+
+def get_model():
+    global MODEL
+    if MODEL is None:
+        with _MODEL_LOCK:
+            if MODEL is None:
+                _load_model()
+    return TOK, MODEL
+
+def translate_with_model(text: str, max_new_tokens: int = 48) -> str:
+    tok, m = get_model()
+    inputs = tok([text], return_tensors="pt")
+    outputs = m.generate(
+        **inputs,
+        max_new_tokens=max_new_tokens,
+        num_beams=4,
+        length_penalty=0.9,
+        no_repeat_ngram_size=3,
+        early_stopping=True,
+    )
+    mt = tok.decode(outputs[0], skip_special_tokens=True)
+    return mt
+
+# ========= Hooks & small utils =========
+@app.before_request
+def _log_req():
+    path = request.path
+    if path not in ("/health", "/ping", "/favicon.ico"):
+        log.info("[REQ] %s %s", request.method, path)
+
+# ========= Routes =========
+@app.get("/health")
+@app.get("/ping")
+def health():
+    return jsonify({"ok": True, "time": datetime.now(timezone.utc).isoformat()})
 
 @app.get("/login")
 def login_get():
-    if current_user.is_authenticated:
-        return redirect(url_for("home"))
-    return render_template("login.html", error=None, logged_in=False)
+    return render_template("login.html")
 
 @app.post("/login")
 def login_post():
     email = (request.form.get("email") or "").strip().lower()
-    password = request.form.get("password") or ""
-    s = Session()
-    try:
+    pwd = request.form.get("password") or ""
+    if not email or not pwd:
+        flash("Isi email dan password", "error")
+        return redirect(url_for("login_get"))
+
+    with SessionLocal() as s:
         u = s.query(User).filter_by(email=email).first()
-        if not u or not u.password or not check_password_hash(u.password, password):
-            return render_template("login.html", error="Email atau password salah.", logged_in=False), 401
-        login_user(u, remember=True, duration=dt.timedelta(days=7))
-        return redirect(url_for("home"))
-    finally:
-        s.close()
+        if not u or not verify_password(u, pwd):
+            flash("Email atau password salah", "error")
+            return redirect(url_for("login_get"))
+
+        session["uid"] = u.id
+        session["email"] = u.email
+        return redirect(url_for("index"))
 
 @app.get("/register")
 def register_get():
-    if current_user.is_authenticated:
-        return redirect(url_for("home"))
-    return render_template("register.html", error=None, logged_in=False)
+    return render_template("register.html")
 
 @app.post("/register")
 def register_post():
     email = (request.form.get("email") or "").strip().lower()
-    password = request.form.get("password") or ""
-    if not email or not password:
-        return render_template("register.html", error="Email & password wajib diisi.", logged_in=False), 400
-
-    s = Session()
-    try:
-        exists = s.query(User).filter_by(email=email).first()
-        if exists:
-            return render_template("register.html", error="Email sudah terpakai.", logged_in=False), 400
-
-        hashed = generate_password_hash(password)
-
-        # Gunakan insert manual agar bisa isi pass_hash jika diperlukan
-        new_id = insert_user(email, hashed)
-
-        # Load lagi usernya untuk login_user
-        u = s.get(User, new_id)
-        if not u:
-            # fallback: buat ORM object (harusnya tidak kejadian)
-            u = User(id=new_id, email=email, password=hashed)
-            s.merge(u); s.commit()
-
-        login_user(u, remember=True, duration=dt.timedelta(days=7))
-        return redirect(url_for("home"))
-    finally:
-        s.close()
+    pwd = request.form.get("password") or ""
+    if not email or not pwd:
+        flash("Isi email dan password", "error")
+        return redirect(url_for("register_get"))
+
+    with SessionLocal() as s:
+        if s.query(User).filter_by(email=email).first():
+            flash("Email sudah terdaftar", "error")
+            return redirect(url_for("register_get"))
+        u = User(email=email)
+        set_password(u, pwd)     # SIMPAN di pass_hash
+        s.add(u); s.commit()
+        session["uid"] = u.id
+        session["email"] = u.email
+    return redirect(url_for("index"))
 
 @app.get("/logout")
-@login_required
 def logout():
-    logout_user()
+    session.clear()
     return redirect(url_for("login_get"))
 
-@app.post("/translate")
+@app.get("/")
 @login_required
+def index():
+    device = DEVICE
+    # ambil 10 history terakhir
+    with SessionLocal() as s:
+        uid = session.get("uid")
+        items = (
+            s.query(Translation)
+            .filter(Translation.user_id == uid)
+            .order_by(Translation.id.desc())
+            .limit(10)
+            .all()
+        )
+        recent = [{"src": it.src, "mt": it.mt, "created_at": it.created_at} for it in items]
+    return render_template("index.html", logged_in=True, device=device, recent=recent)
+
+@app.post("/translate")
 def api_translate():
+    # jika ingin wajib login:
+    if not session.get("uid"):
+        return jsonify({"error": "Unauthorized"}), 401
+
+    data = request.get_json(silent=True) or {}
+    text = (data.get("text") or "").strip()
+    max_new = int(data.get("max_new_tokens", 48))
+    if not text:
+        return jsonify({"error": "Empty text"}), 400
+
     try:
-        payload = request.get_json(force=True, silent=True) or {}
-        text_in = (payload.get("text") or "").strip()
-        max_new = int(payload.get("max_new_tokens") or 32)
-        if not text_in:
-            return jsonify({"error": "text kosong"}), 400
-        mt = translate_core(text_in, max_new_tokens=max_new)
-        s = Session()
-        try:
-            rec = Translation(user_id=current_user.id, src=text_in, mt=mt)
-            s.add(rec); s.commit()
-        finally:
-            s.close()
+        # langkah prenorm → model
+        clean = prenorm(text)
+        mt = translate_with_model(clean, max_new_tokens=max_new)
+        # simpan riwayat
+        with SessionLocal() as s:
+            s.add(Translation(user_id=session["uid"], src=text, mt=mt))
+            s.commit()
         return jsonify({"mt": mt})
     except Exception as e:
         log.exception("translate error: %s", e)
         return jsonify({"error": "server error"}), 500
 
 @app.get("/history")
-@login_required
 def api_history():
-    s = Session()
-    try:
-        q = (s.query(Translation)
-              .filter(Translation.user_id == current_user.id)
-              .order_by(Translation.id.desc())
-              .limit(10))
-        items = [
-            {"src": r.src, "mt": r.mt, "created_at": (r.created_at.isoformat() if r.created_at else "")}
-            for r in q.all()
-        ]
-        return jsonify({"items": items})
-    finally:
-        s.close()
-
-@app.get("/about")
-def about():
-    return render_template("about.html", logged_in=current_user.is_authenticated)
-
-@app.get("/health")
-def health():
-    return {"status": "ok"}
-
-@app.errorhandler(500)
-def err500(e):
-    log.exception("Unhandled 500: %s", e)
-    # Tampilkan form login agar user bisa ulangi langkah
-    return render_template("login.html", error="Terjadi kesalahan server. Coba lagi."), 500
+    if not session.get("uid"):
+        return jsonify({"items": []})
+    with SessionLocal() as s:
+        uid = session["uid"]
+        items = (
+            s.query(Translation)
+            .filter(Translation.user_id == uid)
+            .order_by(Translation.id.desc())
+            .limit(10)
+            .all()
+        )
+        out = [{
+            "src": it.src,
+            "mt": it.mt,
+            "created_at": it.created_at.strftime("%Y-%m-%d %H:%M")
+        } for it in items]
+    return jsonify({"items": out})
 
 if __name__ == "__main__":
+    # untuk run lokal: python app.py
     app.run(host="0.0.0.0", port=int(os.getenv("PORT", "7860")), debug=True)

frontend/index.html

@@ -44,8 +44,6 @@
   </style>
 </head>
 <body>
-<script>window.LOGGED_IN = {{ 'true' if logged_in else 'false' }};</script>
-
 <header>
   <div class="container header-content">
     <div class="logo"><h1>PapuaTranslate</h1></div>
@@ -54,13 +52,7 @@
         <li><a href="/">Home</a></li>
         <li><a href="/about">About</a></li>
         <li><a href="/#history">History</a></li>
-        {% if logged_in %}
-          <li class="auth-badge">Login: <span class="pill">Aktif</span></li>
-          <li><a href="/logout">Logout</a></li>
-        {% else %}
-          <li><a href="/login">Login</a></li>
-          <li><a href="/register">Daftar</a></li>
-        {% endif %}
+        <li><a href="/logout">Logout</a></li>
       </ul>
     </nav>
   </div>
@@ -69,7 +61,7 @@
 <section class="hero">
   <div class="container">
     <h2>Translasi Dialek Papua → Bahasa Indonesia Baku</h2>
-    <p>Model mT5 + LoRA (CENDOL) dengan prenorm & reranking n-best.</p>
+    <p>mT5 + LoRA (CENDOL) dengan prenorm & n-best reranking ringan.</p>
   </div>
 </section>
 
@@ -112,22 +104,15 @@
   </div>
 </section>
 
-<section class="info">
-  <div class="container">
-    <h3>Tentang Aplikasi</h3>
-    <p>PapuaTranslate menerapkan arsitektur CENDOL berbasis mT5 dengan LoRA adapter untuk menerjemahkan dialek Papua ke Bahasa Indonesia baku secara ringkas dan aman.</p>
-  </div>
-</section>
-
 <footer>
   <div class="container">
     <div class="footer-content">
       <div class="footer-section">
         <h3>PapuaTranslate</h3>
-        <p>Yogotak Hubuluk, Motok Hanorogo — Hari esok harus lebih baik dari hari ini.</p>
+        <p>Yogotak Hubuluk, Motok Hanorogo.</p>
       </div>
       <div class="footer-section">
-        <h3>Informasi Teknis</h3>
+        <h3>Info</h3>
         <p>Model: mT5 Base + LoRA</p>
         <p>Device: {{ device }}</p>
       </div>
@@ -140,14 +125,10 @@
 
 <script>
   async function translateText() {
-    if (window.LOGGED_IN !== true && window.LOGGED_IN !== 'true') {
-      window.location.href = '/login';
-      return;
-    }
     const inputText = document.getElementById('papua-input').value.trim();
     const outputElement = document.getElementById('indonesia-output');
     const translateBtn = document.getElementById('translate-btn');
-    if (!inputText) { outputElement.textContent = "Silakan masukkan teks logat Papua."; return; }
+    if (!inputText) { outputElement.textContent = "Silakan masukkan teks."; return; }
     outputElement.innerHTML = '<span class="loading">Menerjemahkan...</span>';
     translateBtn.disabled = true; translateBtn.textContent = 'Menerjemahkan...';
     try {
@@ -155,7 +136,7 @@
         method: 'POST',
         headers: { 'Content-Type': 'application/json' },
         credentials: 'same-origin',
-        body: JSON.stringify({ text: inputText, max_new_tokens: 24 })
+        body: JSON.stringify({ text: inputText, max_new_tokens: 48 })
       });
       const data = await r.json();
       if (r.ok) {