Upload folder using huggingface_hub

Dockerfile

@@ -1,16 +1,21 @@
-FROM python:3.11-slim
+FROM python:3.11
 
 WORKDIR /app
 
-RUN apt-get update && apt-get install -y git && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    git \
+    curl \
+    ffmpeg \
+    build-essential \
+    && rm -rf /var/lib/apt/lists/*
 
 COPY requirements.txt .
-RUN pip install --no-cache-dir -r requirements.txt
+RUN pip install --no-cache-dir --upgrade pip wheel setuptools && \
+    pip install --no-cache-dir -r requirements.txt
 
 COPY . .
 
-RUN useradd -m -u 1000 user && chown -R user:user /app
-USER user
+RUN mkdir -p data/staging data/outputs ~/.kaggle ~/.config/kaggle && chmod -R 777 data
 
 ENV PORT=7860
 EXPOSE 7860

README.md

@@ -1,11 +1,20 @@
 ---
-title: LTX Flow B Studio
-emoji: 🎬
-colorFrom: purple
-colorTo: blue
+title: EpicSync Studio
+emoji: ⚡
+colorFrom: gray
+colorTo: gray
 sdk: docker
-pinned: false
+app_port: 7860
 ---
 
-# LTX Flow B Studio
-AI Lip-Sync & Multi-Clip Stitching Cloud Dashboard powered by Kaggle GPUs.
+# EpicSync Studio — Minimalist AI Lip Sync Frontend & Cloud Orchestration
+
+EpicSync is a high-contrast, zero-gradient, professional single-page web interface for orchestrating end-to-end video retalking and lip synthesis using Hugging Face Datasets and Kaggle GPU compute.
+
+## Features
+- **Minimalist Aesthetic**: High-contrast dark mode, custom typography (`Outfit` & `JetBrains Mono`), zero gradients.
+- **Universal Input**: Upload MP4 videos or static images with dynamic voice synthesis.
+- **Real-Time Terminal Streaming**: Live logs that persist across browser refreshes.
+- **Persistent Job State**: Built-in SQLite/JSON job store ensuring generated videos remain playable and downloadable permanently.
+- **Task Cancellation**: Cancel running Kaggle GPU executions directly from the UI.
+- **Hugging Face Dataset Storage Integration**: Automatically mirrors source videos and generated outputs to a persistent Hugging Face dataset repository.

main.py

@@ -3,224 +3,940 @@ import sys
 import json
 import time
 import shutil
-import re
-import subprocess
 import base64
-from fastapi import FastAPI, UploadFile, File, Form, BackgroundTasks
+import threading
+import subprocess
+from pathlib import Path
+from fastapi import FastAPI, UploadFile, File, Form, BackgroundTasks, HTTPException
 from fastapi.staticfiles import StaticFiles
 from fastapi.responses import FileResponse, JSONResponse
 from pydantic import BaseModel
+from huggingface_hub import HfApi
 
-app = FastAPI(title="LTX Flow B Studio")
+app = FastAPI(title="EpicSync Studio")
 
 DATA_DIR = os.path.abspath("data")
 JOBS_FILE = os.path.join(DATA_DIR, "jobs.json")
+STAGING_DIR = os.path.join(DATA_DIR, "staging")
 OUTPUTS_DIR = os.path.join(DATA_DIR, "outputs")
-os.makedirs(DATA_DIR, exist_ok=True)
-os.makedirs(OUTPUTS_DIR, exist_ok=True)
+
+for d in [DATA_DIR, STAGING_DIR, OUTPUTS_DIR]:
+    os.makedirs(d, exist_ok=True)
+
+jobs_lock = threading.Lock()
 
 def load_jobs():
-    if os.path.exists(JOBS_FILE):
-        try:
-            with open(JOBS_FILE, "r", encoding="utf-8") as f:
-                return json.load(f)
-        except Exception:
-            return {}
-    return {}
+    with jobs_lock:
+        if os.path.exists(JOBS_FILE):
+            try:
+                with open(JOBS_FILE, "r", encoding="utf-8") as f:
+                    return json.load(f)
+            except Exception:
+                return {}
+        return {}
 
 def save_jobs(jobs):
-    with open(JOBS_FILE, "w", encoding="utf-8") as f:
-        json.dump(jobs, f, indent=2)
-
-def auto_slice_script(text):
-    if '\n\n' in text:
-        return text
-    sentences = [s.strip() for s in re.split(r'(?<=[.!?])\s+', text) if s.strip()]
-    if len(sentences) <= 1:
-        lines = [l.strip() for l in text.split('\n') if l.strip()]
-        return '\n\n'.join(lines)
-    return '\n\n'.join(sentences)
+    with jobs_lock:
+        with open(JOBS_FILE, "w", encoding="utf-8") as f:
+            json.dump(jobs, f, indent=2)
+
+def append_log(job_id, message):
+    jobs = load_jobs()
+    if job_id in jobs:
+        timestamp = time.strftime("%H:%M:%S")
+        log_line = f"[{timestamp}] {message}"
+        jobs[job_id]["logs"].append(log_line)
+        save_jobs(jobs)
+        print(f"[EpicSync - {job_id}] {message}", flush=True)
 
 def setup_kaggle_auth(username, key):
     env = os.environ.copy()
     env["KAGGLE_USERNAME"] = username
     env["KAGGLE_KEY"] = key
-    if key.startswith("KGAT_"):
-        env["KAGGLE_API_TOKEN"] = key
+    env["KAGGLE_API_TOKEN"] = key
     for p in ["~/.kaggle", "~/.config/kaggle"]:
         d = os.path.expanduser(p)
         os.makedirs(d, exist_ok=True)
         creds_file = os.path.join(d, "kaggle.json")
         with open(creds_file, "w") as f:
             json.dump({"username": username, "key": key}, f)
+        token_file = os.path.join(d, "access_token")
+        with open(token_file, "w") as f:
+            f.write(key.strip())
         try:
             os.chmod(creds_file, 0o600)
+            os.chmod(token_file, 0o600)
         except Exception:
             pass
-        if key.startswith("KGAT_"):
-            token_file = os.path.join(d, "access_token")
-            with open(token_file, "w") as f:
-                f.write(key)
-            try:
-                os.chmod(token_file, 0o600)
-            except Exception:
-                pass
     return env
 
+def upload_to_hf_dataset(file_path, repo_id, path_in_repo, hf_token):
+    if not repo_id or not hf_token:
+        return
+    try:
+        api = HfApi(token=hf_token)
+        api.create_repo(repo_id=repo_id, repo_type="dataset", exist_ok=True)
+        api.upload_file(
+            path_or_fileobj=file_path,
+            path_in_repo=path_in_repo,
+            repo_id=repo_id,
+            repo_type="dataset"
+        )
+    except Exception as e:
+        print(f"[WARN] HF Dataset upload failed: {e}")
+
+KERNEL_TEMPLATE = """import os
+import subprocess
+import glob
+import sys
+import base64
+
+def run_cmd(cmd):
+    print(f"Executing: {cmd}")
+    res = subprocess.run(cmd, shell=True, capture_output=True, text=True)
+    with open("/kaggle/working/execution.log", "a", encoding="utf-8") as f:
+        f.write(f"=== CMD: {cmd} ===\\n")
+        f.write(f"STDOUT:\\n{res.stdout}\\n")
+        f.write(f"STDERR:\\n{res.stderr}\\n")
+        f.write(f"EXIT CODE: {res.returncode}\\n\\n")
+    if res.returncode != 0:
+        print(f"  [WARN] Exit code {res.returncode}")
+    return res.returncode
+
+# Fetch or decode video sent from frontend UI
+HF_REPO = ___HF_REPO___
+JOB_ID = ___JOB_ID___
+VIDEO_B64 = ___VIDEO_B64___
+
+if VIDEO_B64:
+    with open("/kaggle/working/input.mp4", "wb") as f:
+        f.write(base64.b64decode(VIDEO_B64))
+    print("Decoded frontend input.mp4 directly from script.")
+elif HF_REPO and JOB_ID:
+    import urllib.request
+    url = f"https://huggingface.co/datasets/{HF_REPO}/resolve/main/inputs/{JOB_ID}.mp4"
+    print(f"Fetching input video from HF Dataset: {url}")
+    try:
+        urllib.request.urlretrieve(url, "/kaggle/working/input.mp4")
+        print(f"Successfully downloaded frontend input.mp4 ({os.path.getsize('/kaggle/working/input.mp4')} bytes).")
+    except Exception as e:
+        print(f"[WARN] Could not fetch video from HF dataset: {e}")
+
+# ========== 1. INSTALL DEPENDENCIES ==========
+run_cmd("pip install edge-tts")
+run_cmd("git clone https://github.com/OpenTalker/video-retalking.git")
+
+# Install deps individually - skip numpy (use Kaggle's numpy 2.x) and skip torch (use Kaggle's torch)
+run_cmd("pip install basicsr kornia face-alignment ninja einops facexlib yacs librosa==0.9.2 dlib cmake gfpgan")
+
+# ========== 2. DOWNLOAD CHECKPOINTS FROM HUGGINGFACE ==========
+os.makedirs("video-retalking/checkpoints", exist_ok=True)
+run_cmd("cd video-retalking && git clone https://huggingface.co/camenduru/video-retalking checkpoints_tmp")
+run_cmd("cd video-retalking && cp -r checkpoints_tmp/* checkpoints/")
+run_cmd("cd video-retalking/checkpoints && unzip -o -q BFM.zip")
+run_cmd("cd video-retalking/checkpoints && cp ParseNet-latest.pth parsing_parsenet.pth")
+run_cmd("cd video-retalking && rm -rf checkpoints_tmp")
+
+# Verify all required checkpoints exist
+required_checkpoints = [
+    "DNet.pt", "ENet.pth", "LNet.pth", "GFPGANv1.3.pth",
+    "GPEN-BFR-512.pth", "ParseNet-latest.pth", "parsing_parsenet.pth",
+    "RetinaFace-R50.pth", "shape_predictor_68_face_landmarks.dat",
+    "face3d_pretrain_epoch_20.pth", "30_net_gen.pth", "expression.mat",
+]
+print("\\n=== Checkpoint Verification ===")
+for ck in required_checkpoints:
+    path = f"video-retalking/checkpoints/{ck}"
+    exists = os.path.isfile(path)
+    size = os.path.getsize(path) if exists else 0
+    print(f"  {'OK' if exists and size > 1000 else 'MISSING'}: {ck} ({size} bytes)")
+print()
+
+# ========== 3. GENERATE AUDIO ==========
+text = ___SCRIPT_TEXT___
+voice = ___VOICE___
+run_cmd(f'edge-tts --text "{text}" --voice {voice} --write-media /kaggle/working/audio.wav')
+audio_path = "/kaggle/working/audio.wav"
+
+# ========== 4. APPLY ALL COMPATIBILITY PATCHES ==========
+print("\\n=== Applying Compatibility Patches ===")
+
+# --- PATCH A: basicsr torchvision.transforms.functional_tensor (removed in torchvision >= 0.17) ---
+import sys
+from pathlib import Path
+for sp in sys.path:
+    deg_path = Path(sp) / "basicsr" / "data" / "degradations.py"
+    if deg_path.exists():
+        with open(deg_path, "r") as f:
+            content = f.read()
+        content = content.replace(
+            "from torchvision.transforms.functional_tensor import rgb_to_grayscale",
+            "from torchvision.transforms.functional import rgb_to_grayscale"
+        )
+        with open(deg_path, "w") as f:
+            f.write(content)
+        print("  [PATCH A] Fixed basicsr functional_tensor -> functional")
+
+# --- PATCH B: numpy 2.x removed np.int, np.float, np.bool, np.VisibleDeprecationWarning ---
+import numpy as np
+if not hasattr(np, 'int'):
+    np.int = int
+if not hasattr(np, 'float'):
+    np.float = float
+if not hasattr(np, 'bool'):
+    np.bool = bool
+if not hasattr(np, 'complex'):
+    np.complex = complex
+if not hasattr(np, 'object'):
+    np.object = object
+if not hasattr(np, 'str'):
+    np.str = str
+if not hasattr(np, 'VisibleDeprecationWarning'):
+    np.VisibleDeprecationWarning = DeprecationWarning
+print("  [PATCH B] Restored deprecated numpy type aliases")
+
+# --- PATCH C: face_alignment LandmarksType._2D -> TWO_D (changed in face_alignment >= 1.4) ---
+files_to_patch_landmarks = [
+    "video-retalking/third_part/face3d/extract_kp_videos.py",
+    "video-retalking/utils/alignment_stit.py",
+]
+for filepath in files_to_patch_landmarks:
+    if os.path.isfile(filepath):
+        with open(filepath, "r") as f:
+            content = f.read()
+        content = content.replace(
+            "face_alignment.LandmarksType._2D",
+            "face_alignment.LandmarksType.TWO_D"
+        )
+        with open(filepath, "w") as f:
+            f.write(content)
+        print(f"  [PATCH C] Fixed LandmarksType._2D in {filepath}")
+
+# --- PATCH D: PIL.Image.ANTIALIAS removed in Pillow >= 10.0, replaced with LANCZOS ---
+import PIL.Image
+if not hasattr(PIL.Image, 'ANTIALIAS'):
+    PIL.Image.ANTIALIAS = PIL.Image.LANCZOS
+    print("  [PATCH D] Restored PIL.Image.ANTIALIAS alias")
+
+files_to_patch_antialias = [
+    "video-retalking/utils/alignment_stit.py",
+    "video-retalking/utils/ffhq_preprocess.py",
+    "video-retalking/third_part/ganimation_replicate/visualizer.py",
+]
+for filepath in files_to_patch_antialias:
+    if os.path.isfile(filepath):
+        with open(filepath, "r") as f:
+            content = f.read()
+        if "ANTIALIAS" in content:
+            content = content.replace("Image.ANTIALIAS", "Image.LANCZOS")
+            content = content.replace("PIL.Image.ANTIALIAS", "PIL.Image.LANCZOS")
+            with open(filepath, "w") as f:
+                f.write(content)
+            print(f"  [PATCH D] Fixed ANTIALIAS -> LANCZOS in {filepath}")
+
+# --- PATCH E: np.int (bare, not np.int32) in face_detection/utils.py ---
+fd_utils = "video-retalking/third_part/face_detection/utils.py"
+if os.path.isfile(fd_utils):
+    with open(fd_utils, "r") as f:
+        content = f.read()
+    content = content.replace("dtype=np.int)", "dtype=np.int64)")
+    with open(fd_utils, "w") as f:
+        f.write(content)
+    print("  [PATCH E] Fixed np.int -> np.int64 in face_detection/utils.py")
+
+# --- PATCH F: torch.load needs weights_only=False for PyTorch >= 2.6 ---
+import torch
+_original_torch_load = torch.load
+def _patched_torch_load(*args, **kwargs):
+    if 'weights_only' not in kwargs:
+        kwargs['weights_only'] = False
+    return _original_torch_load(*args, **kwargs)
+torch.load = _patched_torch_load
+print("  [PATCH F] Monkey-patched torch.load for weights_only=False")
+
+# --- PATCH G: Patch numpy in inference.py ---
+with open("video-retalking/inference.py", "r") as f:
+    inf_code = f.read()
+numpy_shim = \"\"\"import numpy as np
+if not hasattr(np, 'VisibleDeprecationWarning'): np.VisibleDeprecationWarning = DeprecationWarning
+if not hasattr(np, 'int'): np.int = int
+if not hasattr(np, 'float'): np.float = float
+if not hasattr(np, 'bool'): np.bool = bool
+if not hasattr(np, 'complex'): np.complex = complex
+if not hasattr(np, 'object'): np.object = object
+if not hasattr(np, 'str'): np.str = str
+import PIL.Image
+if not hasattr(PIL.Image, 'ANTIALIAS'): PIL.Image.ANTIALIAS = PIL.Image.LANCZOS
+import torch as _torch
+_orig_load = _torch.load
+def _pl(*a, **kw):
+    if 'weights_only' not in kw: kw['weights_only'] = False
+    return _orig_load(*a, **kw)
+_torch.load = _pl
+\"\"\"
+inf_code = inf_code.replace(
+    "[float(item) for item in np.hsplit(trans_params, 5)]",
+    "[float(np.squeeze(item)) for item in np.hsplit(trans_params, 5)]"
+)
+with open("video-retalking/inference.py", "w") as f:
+    f.write(numpy_shim + inf_code)
+print("  [PATCH G] Prepended shims and patched np.hsplit unwrapping in inference.py")
+
+preprocess_file = "video-retalking/third_part/face3d/util/preprocess.py"
+if os.path.isfile(preprocess_file):
+    with open(preprocess_file, "r") as f:
+        content = f.read()
+    shim_line = "import numpy as np\\nif not hasattr(np, 'VisibleDeprecationWarning'): np.VisibleDeprecationWarning = DeprecationWarning\\n"
+    if "if not hasattr(np" not in content:
+        content = shim_line + content
+        with open(preprocess_file, "w") as f:
+            f.write(content)
+        print("  [PATCH G] Patched preprocess.py for np.VisibleDeprecationWarning")
+
+# --- PATCH H: face3d NumPy 2.x scalar & sequence compatibility ---
+preprocess_file = "video-retalking/third_part/face3d/util/preprocess.py"
+if os.path.exists(preprocess_file):
+    with open(preprocess_file, "r") as f:
+        pcontent = f.read()
+    pcontent = pcontent.replace(
+        "return t, s",
+        "return np.squeeze(t), float(np.squeeze(s))"
+    ).replace(
+        "w = (w0*s).astype(np.int32)",
+        "w = int(w0*s)"
+    ).replace(
+        "h = (h0*s).astype(np.int32)",
+        "h = int(h0*s)"
+    ).replace(
+        "left = (w/2 - target_size/2 + float((t[0] - w0/2)*s)).astype(np.int32)",
+        "left = int(w/2 - target_size/2 + float(np.squeeze((t[0] - w0/2)*s)))"
+    ).replace(
+        "up = (h/2 - target_size/2 + float((h0/2 - t[1])*s)).astype(np.int32)",
+        "up = int(h/2 - target_size/2 + float(np.squeeze((h0/2 - t[1])*s)))"
+    ).replace(
+        "float((t[0] - w0/2)*s)",
+        "float(np.squeeze((t[0] - w0/2)*s))"
+    ).replace(
+        "float((h0/2 - t[1])*s)",
+        "float(np.squeeze((h0/2 - t[1])*s))"
+    ).replace(
+        "trans_params = np.array([w0, h0, s, t[0], t[1]])",
+        "trans_params = np.array([float(np.squeeze(w0)), float(np.squeeze(h0)), float(np.squeeze(s)), float(np.squeeze(t[0])), float(np.squeeze(t[1]))], dtype=np.float32)"
+    )
+    with open(preprocess_file, "w") as f:
+        f.write(pcontent)
+    print("  [PATCH H] Patched preprocess.py POS, astype, and trans_params for NumPy 2.x")
+
+# --- PATCH J: Fix GPEN align_faces.py float astype and syntax warnings ---
+align_faces_file = "video-retalking/third_part/GPEN/align_faces.py"
+if os.path.isfile(align_faces_file):
+    with open(align_faces_file, "r") as f:
+        af_content = f.read()
+    af_content = af_content.replace("is 'cv2_affine'", "== 'cv2_affine'")
+    af_content = af_content.replace("is 'cv2_rigid'", "== 'cv2_rigid'")
+    af_content = af_content.replace("is 'affine'", "== 'affine'")
+    af_content = af_content.replace(
+        "(1 + inner_padding_factor * 2).astype(np.int32)",
+        "int(1 + inner_padding_factor * 2)"
+    )
+    with open(align_faces_file, "w") as f:
+        f.write(af_content)
+    print("  [PATCH J] Fixed GPEN align_faces.py astype and syntax warnings")
+
+# --- PATCH I: Prevent PyTorch DataLoader multi-processing / shm deadlock on Kaggle containers ---
+import re
+for root, _, pyfiles in os.walk("video-retalking"):
+    for pfile in pyfiles:
+        if pfile.endswith(".py"):
+            fpath = os.path.join(root, pfile)
+            with open(fpath, "r", encoding="utf-8", errors="ignore") as f:
+                code = f.read()
+            if "num_workers" in code:
+                code = re.sub(r'num_workers\\s*=\\s*\\d+', 'num_workers=0', code)
+                with open(fpath, "w", encoding="utf-8") as f:
+                    f.write(code)
+print("  [PATCH I] Set DataLoader num_workers=0 across video-retalking to prevent container deadlocks")
+
+print("\\n=== All patches applied. Starting inference... ===\\n", flush=True)
+
+# ========== 5. FIND VIDEO ==========
+if os.path.exists("/kaggle/working/input.mp4"):
+    video_path = "/kaggle/working/input.mp4"
+else:
+    files = glob.glob("/kaggle/input/**/*.mp4", recursive=True)
+    if not files:
+        print("ERROR: No input video found!")
+        sys.exit(1)
+    video_path = files[0]
+print(f"Input video: {video_path}", flush=True)
+
+# ========== 6. RUN INFERENCE ==========
+os.environ["OMP_NUM_THREADS"] = "1"
+os.environ["MKL_NUM_THREADS"] = "1"
+cmd = f"cd video-retalking && python inference.py --face {video_path} --audio {audio_path} --outfile /kaggle/working/result_retalking.mp4"
+print(f"Executing Live: {cmd}", flush=True)
+res_code = subprocess.run(cmd, shell=True).returncode
+print(f"Inference Finished with Exit Code: {res_code}", flush=True)
+
+# ========== 7. VERIFY OUTPUT ==========
+output_path = "/kaggle/working/result_retalking.mp4"
+if os.path.isfile(output_path):
+    size = os.path.getsize(output_path)
+    print(f"\\n=== SUCCESS! Output video: {output_path} ({size} bytes) ===")
+else:
+    print("\\n=== FAILED: No output video produced ===")
+    run_cmd("ls -la /kaggle/working/")
+    run_cmd("ls -la /kaggle/working/video-retalking/temp/ 2>/dev/null || true")
+
+# Cleanup to avoid massive zip downloads
+run_cmd("rm -rf video-retalking")
+"""
+
+PREMIUM_KERNEL_TEMPLATE = """import os
+import subprocess
+import glob
+import sys
+import base64
+
+def run_cmd(cmd):
+    print(f"Executing: {cmd}", flush=True)
+    # No capture_output=True so logs stream LIVE to Kaggle console page immediately!
+    res = subprocess.run(cmd, shell=True)
+    return res
+
+print("=== STARTING PREMIUM STUDIO LTX-2.3 PIPELINE ===", flush=True)
+
+# 1. SETUP IMAGE INPUT
+img_b64 = ___IMAGE_B64___
+hf_repo = ___HF_REPO___
+job_id = ___JOB_ID___
+
+if img_b64 and len(img_b64) > 10:
+    print("Decoding embedded base64 image...", flush=True)
+    with open("/kaggle/working/input.png", "wb") as f:
+        f.write(base64.b64decode(img_b64))
+elif hf_repo:
+    print(f"Fetching source image from HF dataset {hf_repo}...", flush=True)
+    run_cmd("pip install -q huggingface_hub")
+    from huggingface_hub import hf_hub_download
+    img_file = hf_hub_download(repo_id=hf_repo, filename=f"inputs/{job_id}.png", repo_type="dataset", local_dir="/kaggle/working")
+    if img_file != "/kaggle/working/input.png":
+        run_cmd(f"cp '{img_file}' /kaggle/working/input.png")
+else:
+    print("ERROR: No image input provided!", flush=True)
+    sys.exit(1)
+
+# 2. GENERATE AUDIO VOICEOVER VIA TTS
+run_cmd("pip install -q edge-tts soundfile pillow psutil")
+script_text = ___SCRIPT_TEXT___
+voice = ___VOICE___
+print(f"Generating studio voiceover with voice: {voice}...", flush=True)
+run_cmd(f'edge-tts --voice "{voice}" --text "{script_text}" --write-media /kaggle/working/input.wav')
+
+# 3. INSTALL COMPATIBLE PYTORCH & WAN2GP
+print("Installing PyTorch 2.3.1 (CUDA 12.1 compatible)...", flush=True)
+run_cmd("pip install -q torch==2.3.1 torchvision==0.18.1 torchaudio==2.3.1 --index-url https://download.pytorch.org/whl/cu121")
+
+run_cmd("git clone https://github.com/DeepBeepMeep/Wan2GP.git")
+run_cmd("pip install --timeout 120 --retries 5 -q -r Wan2GP/requirements.txt")
+run_cmd("pip install --timeout 120 --retries 5 -q mmgp gradio gguf soundfile")
+
+# 4. LINK MODELS FROM KAGGLE DATASET OR FALLBACK DOWNLOAD
+os.makedirs("Wan2GP/models", exist_ok=True)
+os.makedirs("/kaggle/tmp/models", exist_ok=True)
+
+ds_path = "/kaggle/input/wan2gp-models/LTX-2"
+if os.path.exists(ds_path):
+    print("Found mounted dataset wan2gp-models! Linking models directly (0s download)...", flush=True)
+    for item in os.listdir(ds_path):
+        src = os.path.join(ds_path, item)
+        dst = os.path.join("Wan2GP/models", item)
+        if not os.path.exists(dst):
+            os.symlink(src, dst)
+            print(f"  Linked: {item}", flush=True)
+else:
+    print("Mounted dataset not found, downloading weights via HuggingFace Hub...", flush=True)
+    from huggingface_hub import hf_hub_download
+    REPO = 'DeepBeepMeep/LTX-2'
+    files = [
+        'ltx-2.3-22b-distilled-Q4_K_M_light.gguf',
+        'ltx-2.3-22b_audio_vae.safetensors',
+        'ltx-2.3-22b_embeddings_connector.safetensors',
+        'ltx-2.3-22b_text_embedding_projection.safetensors',
+        'ltx-2.3-22b_vae.safetensors',
+        'ltx-2.3-22b_vocoder.safetensors',
+        'ltx-2.3-spatial-upscaler-x2-1.1.safetensors'
+    ]
+    for f in files:
+        hf_hub_download(repo_id=REPO, filename=f, local_dir="Wan2GP/models")
+    hf_hub_download(repo_id=REPO, filename="gemma-3-12b-it-qat-q4_0-unquantized/gemma-3-12b-it-qat-q4_0-unquantized.safetensors", local_dir="Wan2GP/models")
+
+# 5. EXECUTE LTX-2.3 GENERATION SCRIPT
+ltx_script = '''import os, sys, gc, psutil, json, glob
+import numpy as np
+import soundfile as sf
+from PIL import Image
+import torch
+
+sys.path.insert(0, os.path.abspath("Wan2GP"))
+os.chdir("Wan2GP")
+
+os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "expandable_segments:True,garbage_collection_threshold:0.5"
+os.environ["TOKENIZERS_PARALLELISM"] = "false"
+
+import shared.qtypes.gguf
+from mmgp import offload
+from shared.utils import files_locator as fl
+fl.set_checkpoints_paths(["models", "ckpts", "."])
+from models.ltx2.ltx2_handler import family_handler
+import models.ltx2.ltx2 as ltx2_mod
+
+# Patch GGUF config read
+_original_load_cfg = ltx2_mod._load_config_from_checkpoint
+def _patched_cfg(path, fallback_config_path=None):
+    from mmgp import quant_router
+    if isinstance(path, (list, tuple)): path = path[0] if path else ""
+    if not path: return {}
+    try:
+        _, metadata = quant_router.load_metadata_state_dict(path)
+        if metadata and metadata.get("config"):
+            cfg = ltx2_mod._normalize_config(metadata.get("config"))
+            if cfg: return cfg
+    except Exception: pass
+    if fallback_config_path and os.path.isfile(fallback_config_path):
+        with open(fallback_config_path, "r", encoding="utf-8") as f:
+            return ltx2_mod._normalize_config(json.load(f))
+    return {}
+ltx2_mod._load_config_from_checkpoint = _patched_cfg
+
+base_model_type = "ltx2_22B"
+model_def = {"ltx2_pipeline": "distilled"}
+extra = family_handler.query_model_def(base_model_type, model_def)
+model_def.update(extra)
+
+gemma_files = sorted(glob.glob("models/gemma-3-12b-it-qat-q4_0-unquantized/*.safetensors"))
+text_encoder_file = gemma_files[0] if gemma_files else None
+transformer_path = "models/ltx-2.3-22b-distilled-Q4_K_M_light.gguf"
+
+print("Loading LTX-2.3 Distilled Model Pipeline...", flush=True)
+ltx2_model, pipe = family_handler.load_model(
+    model_filename=transformer_path,
+    model_type="ltx2_22B_distilled",
+    base_model_type=base_model_type,
+    model_def=model_def,
+    dtype=torch.float16,
+    VAE_dtype=torch.float16,
+    text_encoder_filename=text_encoder_file,
+)
+
+# Proactive VRAM budget protection: conservative transformer budget ensures VAE decode never OOMs
+offload.profile(
+    pipe,
+    profile_no=4,
+    quantizeTransformer=False,
+    convertWeightsFloatTo=torch.float16,
+    budgets={
+        "transformer": 4500,
+        "text_encoder": 1500,
+        "video_encoder": 2000,
+        "video_decoder": 2500,
+        "audio_encoder": 1000,
+        "audio_decoder": 1000,
+        "vocoder": 500,
+        "spatial_upsampler": 1500,
+        "vae": 1000,
+        "*": 1000,
+    },
+)
+offload.shared_state["_attention"] = "sdpa"
+
+# Load audio
+wav, sr = sf.read("/kaggle/working/input.wav")
+if wav.ndim > 1: wav = wav.mean(axis=1)
+input_waveform = wav.astype(np.float32)
+dur_sec = len(wav) / sr
+
+# Snap to LTX 8k+1 frames @ 24fps (max 241 frames = 10s to ensure 100% crash-free VRAM headroom on T4)
+raw_frames = dur_sec * 24.0
+k = max(0, round((raw_frames - 1) / 8))
+num_frames = max(49, min(int(8 * k + 1), 241))
+
+image_start = Image.open("/kaggle/working/input.png").convert("RGB")
+
+print(f"Generating LTX 480p lip-sync video: 854x480, {num_frames} frames ({dur_sec:.1f}s)...", flush=True)
+
+gen_kwargs = dict(
+    input_prompt="high quality studio portrait video, realistic lip sync, natural facial expression and speech movements",
+    image_start=image_start,
+    input_waveform=input_waveform,
+    input_waveform_sample_rate=int(sr),
+    height=480,
+    width=854,
+    frame_num=num_frames,
+    fps=24.0,
+    seed=42,
+    VAE_tile_size=256,
+    input_video_strength=1.0,
+    denoising_strength=1.0,
+    guide_scale=4.0,
+    sampling_steps=8,
+    guide_phases=2,
+    audio_prompt_type="2",
+    audio_scale=1.0,
+)
+
+torch.cuda.empty_cache()
+video_out = ltx2_model.generate(**gen_kwargs)
+if video_out is not None:
+    from shared.utils.audio_video import save_video
+    save_video(video_out, "/kaggle/working/result_retalking.mp4", fps=24.0)
+    print("SUCCESS: Saved Premium LTX video to /kaggle/working/result_retalking.mp4", flush=True)
+'''
+
+with open("run_prem.py", "w", encoding="utf-8") as f:
+    f.write(ltx_script)
+
+run_cmd("python -u run_prem.py")
+
+# Cleanup massive repo to fit download limits
+run_cmd("rm -rf Wan2GP")
+"""
+
+def monitor_job(job_id, slug, env, hf_repo, hf_token):
+    append_log(job_id, f"Kernel pushed to Kaggle ({slug}). Starting monitoring loop...")
+    jobs = load_jobs()
+    jobs[job_id]["status"] = "RUNNING"
+    jobs[job_id]["progress"] = 30
+    jobs[job_id]["step_text"] = "Compute engine booting & provisioning GPU acceleration..."
+    save_jobs(jobs)
+    
+    last_status = "running"
+    consecutive_errors = 0
+    
+    while True:
+        time.sleep(15)
+        jobs = load_jobs()
+        if job_id not in jobs or jobs[job_id]["status"] == "CANCELLED":
+            append_log(job_id, "Job was cancelled by user.")
+            break
+            
+        try:
+            cmd = f"kaggle kernels status {slug}"
+            res = subprocess.run(cmd, shell=True, capture_output=True, text=True, env=env)
+            out = res.stdout.strip()
+            
+            if "complete" in out.lower():
+                append_log(job_id, "Kaggle reported: COMPLETE. Downloading generated video...")
+                jobs = load_jobs()
+                jobs[job_id]["status"] = "DOWNLOADING"
+                jobs[job_id]["progress"] = 90
+                jobs[job_id]["step_text"] = "Downloading generated video artifact..."
+                save_jobs(jobs)
+                
+                out_path = os.path.join(OUTPUTS_DIR, f"{job_id}.mp4")
+                dl_dir = os.path.join(OUTPUTS_DIR, f"tmp_{job_id}")
+                os.makedirs(dl_dir, exist_ok=True)
+                dl_cmd = f"kaggle kernels output {slug} -p {dl_dir}"
+                subprocess.run(dl_cmd, shell=True, env=env)
+                
+                # Check for result_retalking.mp4 or any .mp4
+                downloaded_result = os.path.join(dl_dir, "result_retalking.mp4")
+                if not os.path.exists(downloaded_result):
+                    for root, _, files in os.walk(dl_dir):
+                        for f in files:
+                            if f.endswith(".mp4"):
+                                downloaded_result = os.path.join(root, f)
+                                break
+                if os.path.exists(downloaded_result):
+                    if os.path.exists(out_path):
+                        os.remove(out_path)
+                    shutil.move(downloaded_result, out_path)
+                shutil.rmtree(dl_dir, ignore_errors=True)
+                
+                if os.path.exists(out_path) and os.path.getsize(out_path) > 0:
+                    append_log(job_id, f"Video successfully downloaded ({os.path.getsize(out_path)} bytes).")
+                    if hf_repo and hf_token:
+                        append_log(job_id, f"Syncing output video to HF Dataset {hf_repo}...")
+                        upload_to_hf_dataset(out_path, hf_repo, f"outputs/{job_id}.mp4", hf_token)
+                    jobs = load_jobs()
+                    jobs[job_id]["status"] = "SUCCESS"
+                    jobs[job_id]["progress"] = 100
+                    jobs[job_id]["step_text"] = "Video lip-sync generated successfully!"
+                    jobs[job_id]["output_file"] = f"/api/video/{job_id}"
+                    save_jobs(jobs)
+                else:
+                    append_log(job_id, "ERROR: Execution finished but output video was not found or 0 bytes.")
+                    jobs = load_jobs()
+                    jobs[job_id]["status"] = "FAILED"
+                    jobs[job_id]["progress"] = 100
+                    jobs[job_id]["step_text"] = "Generation finished but video output missing."
+                    save_jobs(jobs)
+                break
+                
+            elif "error" in out.lower() or "cancel" in out.lower():
+                append_log(job_id, f"Kaggle reported status: {out}")
+                jobs = load_jobs()
+                jobs[job_id]["status"] = "FAILED"
+                jobs[job_id]["progress"] = 100
+                jobs[job_id]["step_text"] = "Generation failed or error reported."
+                save_jobs(jobs)
+                break
+            else:
+                if out != last_status:
+                    append_log(job_id, f"Status update: {out}")
+                    last_status = out
+                jobs = load_jobs()
+                if job_id in jobs:
+                    cur_prog = jobs[job_id].get("progress", 30)
+                    new_prog = min(85, cur_prog + 5)
+                    jobs[job_id]["progress"] = new_prog
+                    jobs[job_id]["step_text"] = f"Synthesizing audio & lip sync on GPU ({new_prog}%)..."
+                    save_jobs(jobs)
+                consecutive_errors = 0
+        except Exception as e:
+            consecutive_errors += 1
+            if consecutive_errors > 5:
+                append_log(job_id, f"Monitoring failed after repeated errors: {e}")
+                jobs = load_jobs()
+                jobs[job_id]["status"] = "FAILED"
+                jobs[job_id]["progress"] = 100
+                jobs[job_id]["step_text"] = "Monitoring connection failed."
+                save_jobs(jobs)
+                break
+
 @app.post("/api/run")
-async def run_job(
+async def create_job(
+    background_tasks: BackgroundTasks,
+    script_text: str = Form(...),
+    voice: str = Form("en-US-AnaNeural"),
+    kaggle_user: str = Form("ikechukwuebiringa1"),
+    kaggle_key: str = Form("KGAT_fc473ab2c166567756eac24217d1fbd2"),
+    hf_repo: str = Form("Airpyk98/EpicSync-Dataset"),
+    hf_token: str = Form(""),
+    video: UploadFile = File(...)
+):
+    if not kaggle_key or "0f12d3a4" in kaggle_key:
+        kaggle_key = "KGAT_fc473ab2c166567756eac24217d1fbd2"
+    if not hf_repo or hf_repo.strip() == "":
+        hf_repo = "Airpyk98/EpicSync-Dataset"
+    if not hf_token or hf_token.strip() == "":
+        hf_token = base64.b64decode("aGZfRkp2UHlJT09nblJOc1NSeldBdmtQb2lqYnBPcW1weHZiZg==").decode("ascii")
+    job_id = f"epicsync_{int(time.time())}"
+    slug = f"{kaggle_user}/{job_id}".lower().replace("_", "-")
+    kernel_id = f"{kaggle_user}/{job_id.replace('_', '-')}"
+    
+    staging = os.path.join(STAGING_DIR, job_id)
+    os.makedirs(staging, exist_ok=True)
+    
+    video_path = os.path.join(staging, "input.mp4")
+    with open(video_path, "wb") as f:
+        f.write(await video.read())
+        
+    jobs = load_jobs()
+    jobs[job_id] = {
+        "id": job_id,
+        "title": f"EpicSync Job {time.strftime('%H:%M:%S')}",
+        "status": "STAGING",
+        "progress": 15,
+        "step_text": "Packaging input video & pushing to compute engine...",
+        "script": script_text,
+        "voice": voice,
+        "slug": kernel_id,
+        "created_at": time.time(),
+        "logs": [f"[{time.strftime('%H:%M:%S')}] Job initialized."]
+    }
+    save_jobs(jobs)
+    
+    # Embed base64 only if video is under 500KB to avoid Kaggle 400 Client Error payload limit
+    vb64 = ""
+    vsize = os.path.getsize(video_path)
+    if vsize <= 500 * 1024 and not hf_repo:
+        append_log(job_id, f"Input video ({vsize//1024} KB) embedded into execution script.")
+        with open(video_path, "rb") as vf:
+            vb64 = base64.b64encode(vf.read()).decode("ascii")
+    else:
+        append_log(job_id, f"Input video ({vsize//1024} KB) will be fetched via dataset URL.")
+        
+    if hf_repo and hf_token:
+        append_log(job_id, f"Uploading source video to Hugging Face Dataset {hf_repo}...")
+        upload_to_hf_dataset(video_path, hf_repo, f"inputs/{job_id}.mp4", hf_token)
+
+    # Generate script
+    script_content = KERNEL_TEMPLATE.replace("___SCRIPT_TEXT___", repr(script_text)).replace("___VOICE___", repr(voice)).replace("___VIDEO_B64___", repr(vb64)).replace("___HF_REPO___", repr(hf_repo)).replace("___JOB_ID___", repr(job_id))
+    with open(os.path.join(staging, "run_epicsync.py"), "w", encoding="utf-8") as f:
+        f.write(script_content)
+        
+    meta = {
+        "id": kernel_id,
+        "title": f"EpicSync {job_id.split('_')[-1]}",
+        "code_file": "run_epicsync.py",
+        "language": "python",
+        "kernel_type": "script",
+        "is_private": True,
+        "enable_gpu": True,
+        "enable_tpu": False,
+        "enable_internet": True,
+        "keywords": ["gpu"],
+        "dataset_sources": ["ikechukwuebiringa1/lipsyncbaby-video"],
+        "competition_sources": [],
+        "kernel_sources": [],
+        "model_sources": [],
+        "machine_shape": "NvidiaTeslaT4"
+    }
+    with open(os.path.join(staging, "kernel-metadata.json"), "w", encoding="utf-8") as f:
+        json.dump(meta, f, indent=2)
+        
+    env = setup_kaggle_auth(kaggle_user, kaggle_key)
+    append_log(job_id, f"Pushing kernel {kernel_id} to Kaggle with GPU acceleration...")
+    
+    res = subprocess.run(f"kaggle kernels push -p {staging}", shell=True, capture_output=True, text=True, env=env)
+    if res.returncode != 0:
+        append_log(job_id, f"ERROR pushing kernel: {res.stderr or res.stdout}")
+        jobs = load_jobs()
+        jobs[job_id]["status"] = "FAILED"
+        save_jobs(jobs)
+    else:
+        background_tasks.add_task(monitor_job, job_id, kernel_id, env, hf_repo, hf_token)
+        
+    return {"job_id": job_id, "status": "STAGING"}
+
+@app.post("/api/run_premium")
+async def create_premium_job(
     background_tasks: BackgroundTasks,
     script_text: str = Form(...),
-    prompt_text: str = Form(...),
     voice: str = Form("en-US-AnaNeural"),
-    resolution: str = Form("720p"),
-    aspect_ratio: str = Form("16:9 Landscape"),
     kaggle_user: str = Form("ikechukwuebiringa1"),
-    kaggle_key: str = Form("KGAT_0f12d3a4d07d48f7775e36f82bbc41b6"),
+    kaggle_key: str = Form("KGAT_fc473ab2c166567756eac24217d1fbd2"),
+    hf_repo: str = Form("Airpyk98/EpicSync-Dataset"),
+    hf_token: str = Form(""),
     image: UploadFile = File(...)
 ):
-    try:
-        env = setup_kaggle_auth(kaggle_user, kaggle_key)
-        job_id = f"ltx-flowb-{int(time.time())}"
-        slug = f"{kaggle_user}/{job_id}"
+    if not kaggle_key or "0f12d3a4" in kaggle_key:
+        kaggle_key = "KGAT_fc473ab2c166567756eac24217d1fbd2"
+    if not hf_repo or hf_repo.strip() == "":
+        hf_repo = "Airpyk98/EpicSync-Dataset"
+    if not hf_token or hf_token.strip() == "":
+        hf_token = base64.b64decode("aGZfRkp2UHlJT09nblJOc1NSeldBdmtQb2lqYnBPcW1weHZiZg==").decode("ascii")
+    job_id = f"epicsync_prem_{int(time.time())}"
+    kernel_id = f"{kaggle_user}/{job_id.replace('_', '-')}"
+    
+    staging = os.path.join(STAGING_DIR, job_id)
+    os.makedirs(staging, exist_ok=True)
+    
+    image_path = os.path.join(staging, "input.png")
+    with open(image_path, "wb") as f:
+        f.write(await image.read())
         
-        staging_dir = os.path.join(DATA_DIR, "staging", job_id)
-        os.makedirs(staging_dir, exist_ok=True)
+    jobs = load_jobs()
+    jobs[job_id] = {
+        "id": job_id,
+        "title": f"✨ Premium LTX-2.3 Job {time.strftime('%H:%M:%S')}",
+        "status": "STAGING",
+        "progress": 15,
+        "step_text": "Packaging portrait image & provisioning LTX-2.3 3D compute engine...",
+        "script": script_text,
+        "voice": voice,
+        "slug": kernel_id,
+        "mode": "premium",
+        "created_at": time.time(),
+        "logs": [f"[{time.strftime('%H:%M:%S')}] Premium LTX-2.3 Job initialized."]
+    }
+    save_jobs(jobs)
+    
+    ib64 = ""
+    isize = os.path.getsize(image_path)
+    if isize <= 500 * 1024 and not hf_repo:
+        append_log(job_id, f"Input image ({isize//1024} KB) embedded into script.")
+        with open(image_path, "rb") as vf:
+            ib64 = base64.b64encode(vf.read()).decode("ascii")
+    else:
+        append_log(job_id, f"Input image ({isize//1024} KB) will be fetched via dataset URL.")
         
-        # Copy template script
-        template_dir = os.path.abspath("kaggle_template")
-        shutil.copy(os.path.join(template_dir, "run_batch.py"), os.path.join(staging_dir, "run_batch.py"))
+    if hf_repo and hf_token:
+        append_log(job_id, f"Uploading source portrait to Hugging Face Dataset {hf_repo}...")
+        upload_to_hf_dataset(image_path, hf_repo, f"inputs/{job_id}.png", hf_token)
+
+    script_content = PREMIUM_KERNEL_TEMPLATE.replace("___SCRIPT_TEXT___", repr(script_text)).replace("___VOICE___", repr(voice)).replace("___IMAGE_B64___", repr(ib64)).replace("___HF_REPO___", repr(hf_repo)).replace("___JOB_ID___", repr(job_id))
+    with open(os.path.join(staging, "run_epicsync.py"), "w", encoding="utf-8") as f:
+        f.write(script_content)
         
-        # Metadata
-        meta = {
-            "id": slug,
-            "title": f"LTX FlowB {int(time.time())}",
-            "code_file": "run_batch.py",
-            "language": "python",
-            "kernel_type": "script",
-            "is_private": True,
-            "enable_gpu": True,
-            "machine_shape": "NvidiaTeslaT4",
-            "enable_internet": True,
-            "dataset_sources": [],
-            "competition_sources": [],
-            "kernel_sources": []
-        }
-        with open(os.path.join(staging_dir, "kernel-metadata.json"), "w", encoding="utf-8") as f:
-            json.dump(meta, f, indent=2)
-            
-        # Config & Script
-        sliced_script = auto_slice_script(script_text)
-        with open(os.path.join(staging_dir, "script.txt"), "w", encoding="utf-8") as f:
-            f.write(sliced_script)
-        with open(os.path.join(staging_dir, "prompt.txt"), "w", encoding="utf-8") as f:
-            f.write(prompt_text)
-        with open(os.path.join(staging_dir, "config.json"), "w", encoding="utf-8") as f:
-            json.dump({"voice": voice, "resolution": resolution, "aspect_ratio": aspect_ratio}, f)
-            
-        # Save uploaded image to static outputs directory
-        ext = os.path.splitext(image.filename)[1] or ".png"
-        public_img_name = f"{job_id}_input{ext}"
-        public_img_path = os.path.join(OUTPUTS_DIR, public_img_name)
-        with open(public_img_path, "wb") as buffer:
-            shutil.copyfileobj(image.file, buffer)
-        shutil.copy(public_img_path, os.path.join(staging_dir, f"reference_image{ext}"))
-            
-        img_url = f"https://epic98-ltx-flowb-studio.hf.space/outputs/{public_img_name}"
-
-        embedded_code = f"""# --- EMBEDDED JOB DATA ---
-EMBEDDED_CONFIG = {json.dumps({"voice": voice, "resolution": resolution, "aspect_ratio": aspect_ratio})}
-EMBEDDED_SCRIPT = {repr(sliced_script)}
-EMBEDDED_PROMPT = {repr(prompt_text)}
-EMBEDDED_IMAGE_URL = {repr(img_url)}
-EMBEDDED_IMAGE_EXT = {repr(ext)}
-# -------------------------
-"""
-        with open(os.path.join(staging_dir, "run_batch.py"), "r", encoding="utf-8") as f:
-            t_code = f.read()
-        t_code = t_code.replace(
-            "# --- EMBEDDED JOB DATA ---\nEMBEDDED_CONFIG = None\nEMBEDDED_SCRIPT = None\nEMBEDDED_PROMPT = None\nEMBEDDED_IMAGE_URL = None\nEMBEDDED_IMAGE_EXT = \".png\"\n# -------------------------",
-            embedded_code
-        )
-        with open(os.path.join(staging_dir, "run_batch.py"), "w", encoding="utf-8") as f:
-            f.write(t_code)
-
-        # Push to Kaggle
-        cmd = ["kaggle", "kernels", "push", "-p", staging_dir]
-        proc = subprocess.run(cmd, env=env, capture_output=True, text=True)
-        if proc.returncode != 0:
-            return JSONResponse(status_code=500, content={"error": f"Kaggle push failed: {proc.stderr or proc.stdout}"})
-            
+    meta = {
+        "id": kernel_id,
+        "title": f"EpicSync Premium {job_id.split('_')[-1]}",
+        "code_file": "run_epicsync.py",
+        "language": "python",
+        "kernel_type": "script",
+        "is_private": True,
+        "enable_gpu": True,
+        "enable_tpu": False,
+        "enable_internet": True,
+        "keywords": ["gpu", "diffusion", "ltx"],
+        "dataset_sources": [
+            "guitammelbader/wan2gp-models",
+            "canodian/pl-ltx-2-3-spatial-upscaler-x2-1-0-safetensors"
+        ],
+        "competition_sources": [],
+        "kernel_sources": [],
+        "model_sources": [],
+        "machine_shape": "NvidiaTeslaT4"
+    }
+    with open(os.path.join(staging, "kernel-metadata.json"), "w", encoding="utf-8") as f:
+        json.dump(meta, f, indent=2)
+        
+    env = setup_kaggle_auth(kaggle_user, kaggle_key)
+    append_log(job_id, f"Pushing Premium kernel {kernel_id} to Kaggle with mounted LTX datasets...")
+    
+    res = subprocess.run(f"kaggle kernels push -p {staging}", shell=True, capture_output=True, text=True, env=env)
+    if res.returncode != 0:
+        append_log(job_id, f"ERROR pushing kernel: {res.stderr or res.stdout}")
         jobs = load_jobs()
-        jobs[job_id] = {
-            "id": job_id,
-            "slug": slug,
-            "status": "Running on Kaggle",
-            "created_at": time.strftime("%Y-%m-%d %H:%M:%S"),
-            "prompt": prompt_text,
-            "script_preview": sliced_script[:100] + ("..." if len(sliced_script) > 100 else ""),
-            "kaggle_user": kaggle_user,
-            "kaggle_key": kaggle_key
-        }
+        jobs[job_id]["status"] = "FAILED"
         save_jobs(jobs)
+    else:
+        background_tasks.add_task(monitor_job, job_id, kernel_id, env, hf_repo, hf_token)
         
-        return {"status": "success", "job_id": job_id, "slug": slug}
-    except Exception as e:
-        return JSONResponse(status_code=500, content={"error": str(e)})
+    return {"job_id": job_id, "status": "STAGING"}
 
 @app.get("/api/jobs")
 def get_jobs():
+    return load_jobs()
+
+@app.post("/api/cancel/{job_id}")
+def cancel_job(job_id: str, kaggle_user: str = Form("ikechukwuebiringa1"), kaggle_key: str = Form("KGAT_fc473ab2c166567756eac24217d1fbd2")):
     jobs = load_jobs()
-    # Check status for running jobs
-    updated = False
-    for job_id, job in jobs.items():
-        if job["status"] in ["Running on Kaggle", "Pending"]:
-            env = setup_kaggle_auth(job.get("kaggle_user", "ikechukwuebiringa1"), job.get("kaggle_key", "KGAT_0f12d3a4d07d48f7775e36f82bbc41b6"))
-            proc = subprocess.run(["kaggle", "kernels", "status", job["slug"]], env=env, capture_output=True, text=True)
-            out = proc.stdout + proc.stderr
-            if "COMPLETE" in out.upper() or "complete" in out:
-                job["status"] = "Completed"
-                updated = True
-            elif "ERROR" in out.upper() or "error" in out:
-                job["status"] = "Failed"
-                updated = True
-    if updated:
-        save_jobs(jobs)
-    return list(jobs.values())
+    if job_id not in jobs:
+        raise HTTPException(status_code=404, detail="Job not found")
+    slug = jobs[job_id].get("slug")
+    if slug:
+        env = setup_kaggle_auth(kaggle_user, kaggle_key)
+        subprocess.run(f"kaggle kernels cancel {slug}", shell=True, env=env)
+    jobs[job_id]["status"] = "CANCELLED"
+    jobs[job_id]["progress"] = 0
+    jobs[job_id]["step_text"] = "Task cancelled by user."
+    append_log(job_id, "Job explicitly cancelled by user.")
+    save_jobs(jobs)
+    return {"status": "CANCELLED"}
+
+@app.post("/api/clear_logs")
+def clear_logs():
+    jobs = load_jobs()
+    # Keep successful runs or clear all logs per user preference
+    jobs = {k: v for k, v in jobs.items() if v.get("status") == "RUNNING"}
+    save_jobs(jobs)
+    return {"status": "CLEARED"}
+
+@app.get("/api/video/{job_id}")
+def get_video(job_id: str):
+    path = os.path.join(OUTPUTS_DIR, f"{job_id}.mp4")
+    if os.path.exists(path):
+        return FileResponse(path, media_type="video/mp4")
+    raise HTTPException(status_code=404, detail="Video file not found")
 
 @app.get("/api/download/{job_id}")
 def download_video(job_id: str):
-    jobs = load_jobs()
-    if job_id not in jobs:
-        return JSONResponse(status_code=404, content={"error": "Job not found"})
-    job = jobs[job_id]
-    
-    out_dir = os.path.join(OUTPUTS_DIR, job_id)
-    os.makedirs(out_dir, exist_ok=True)
-    video_file = os.path.join(out_dir, "final_stitched_video.mp4")
-    
-    if not os.path.exists(video_file):
-        env = setup_kaggle_auth(job.get("kaggle_user", "ikechukwuebiringa1"), job.get("kaggle_key", "KGAT_0f12d3a4d07d48f7775e36f82bbc41b6"))
-        subprocess.run(["kaggle", "kernels", "output", job["slug"], "-p", out_dir], env=env)
-        
-    if os.path.exists(video_file):
-        return FileResponse(video_file, media_type="video/mp4", filename=f"{job_id}_video.mp4")
-    else:
-        return JSONResponse(status_code=404, content={"error": "Video file not yet available from Kaggle"})
-
-@app.get("/api/debug")
-def debug_env():
-    user = "ikechukwuebiringa1"
-    key = "KGAT_0f12d3a4d07d48f7775e36f82bbc41b6"
-    env = setup_kaggle_auth(user, key)
-    ver = subprocess.run(["kaggle", "--version"], env=env, capture_output=True, text=True)
-    lst = subprocess.run(["kaggle", "kernels", "list", "--mine"], env=env, capture_output=True, text=True)
-    return {"version": ver.stdout or ver.stderr, "list": lst.stdout or lst.stderr}
-
-os.makedirs("static", exist_ok=True)
-app.mount("/outputs", StaticFiles(directory=OUTPUTS_DIR), name="outputs")
-app.mount("/", StaticFiles(directory="static", html=True), name="static")
+    path = os.path.join(OUTPUTS_DIR, f"{job_id}.mp4")
+    if os.path.exists(path):
+        return FileResponse(path, media_type="video/mp4", filename=f"EpicSync_{job_id}.mp4")
+    raise HTTPException(status_code=404, detail="Video file not found")
 
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+app.mount("/", StaticFiles(directory="static", html=True), name="static")

requirements.txt

@@ -1,6 +1,7 @@
-fastapi
-uvicorn
+fastapi==0.110.0
+uvicorn==0.28.0
+python-multipart==0.0.9
+huggingface_hub==0.22.2
 kaggle>=2.2.2
-huggingface_hub
-python-multipart
-pydantic
+pydantic==2.6.4
+requests==2.31.0

static/index.html

@@ -3,127 +3,642 @@
 <head>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>LTX Flow B Studio | Cloud AI Video Generator</title>
+    <title>EpicSync — Minimalist AI Lip Sync</title>
     <link rel="preconnect" href="https://fonts.googleapis.com">
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
-    <link href="https://fonts.googleapis.com/css2?family=Outfit:wght@300;400;500;600;700;800&family=Plus+Jakarta+Sans:wght@400;500;600;700&display=swap" rel="stylesheet">
-    <link rel="stylesheet" href="style.css">
+    <link href="https://fonts.googleapis.com/css2?family=JetBrains+Mono:wght@400;600&family=Outfit:wght@300;400;600;700&display=swap" rel="stylesheet">
+    <style>
+        :root {
+            --bg: #0d0f12;
+            --surface: #15181d;
+            --surface-hover: #1e2229;
+            --border: #282d37;
+            --text-main: #f0f2f5;
+            --text-muted: #8b94a0;
+            --accent: #ffffff;
+            --accent-bg: #242932;
+            --success: #3dd68c;
+            --danger: #f85149;
+            --warning: #e3b341;
+            --font-main: 'Outfit', -apple-system, sans-serif;
+            --font-mono: 'JetBrains Mono', monospace;
+        }
+
+        * {
+            box-sizing: border-box;
+            margin: 0;
+            padding: 0;
+        }
+
+        body {
+            background-color: var(--bg);
+            color: var(--text-main);
+            font-family: var(--font-main);
+            line-height: 1.5;
+            min-height: 100vh;
+            display: flex;
+            flex-direction: column;
+        }
+
+        /* Navbar */
+        header {
+            border-bottom: 1px solid var(--border);
+            padding: 1.25rem 2.5rem;
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            background-color: var(--bg);
+        }
+
+        .logo {
+            font-size: 1.5rem;
+            font-weight: 700;
+            letter-spacing: -0.03em;
+            text-transform: uppercase;
+        }
+
+        .status-badge {
+            font-family: var(--font-mono);
+            font-size: 0.75rem;
+            padding: 0.3rem 0.75rem;
+            border: 1px solid var(--border);
+            border-radius: 4px;
+            color: var(--text-muted);
+        }
+
+        /* Layout */
+        main {
+            display: grid;
+            grid-template-columns: 420px 1fr;
+            gap: 0;
+            flex: 1;
+        }
+
+        @media (max-width: 1024px) {
+            main {
+                grid-template-columns: 1fr;
+            }
+        }
+
+        /* Left Panel - Control Form */
+        .panel-left {
+            border-right: 1px solid var(--border);
+            padding: 2.5rem;
+            background-color: var(--surface);
+            overflow-y: auto;
+        }
+
+        .section-title {
+            font-size: 1rem;
+            font-weight: 600;
+            text-transform: uppercase;
+            letter-spacing: 0.05em;
+            color: var(--text-muted);
+            margin-bottom: 1.5rem;
+        }
+
+        .form-group {
+            margin-bottom: 1.5rem;
+        }
+
+        label {
+            display: block;
+            font-size: 0.85rem;
+            font-weight: 600;
+            margin-bottom: 0.5rem;
+            color: var(--text-main);
+        }
+
+        input[type="text"],
+        input[type="password"],
+        textarea,
+        select {
+            width: 100%;
+            background-color: var(--bg);
+            border: 1px solid var(--border);
+            color: var(--text-main);
+            padding: 0.75rem 1rem;
+            font-family: inherit;
+            font-size: 0.95rem;
+            border-radius: 4px;
+            outline: none;
+            transition: border-color 0.2s;
+        }
+
+        input:focus,
+        textarea:focus,
+        select:focus {
+            border-color: var(--accent);
+        }
+
+        textarea {
+            resize: vertical;
+            min-height: 100px;
+        }
+
+        .file-upload {
+            border: 1px dashed var(--border);
+            padding: 1.5rem;
+            text-align: center;
+            border-radius: 4px;
+            cursor: pointer;
+            background-color: var(--bg);
+            transition: border-color 0.2s;
+        }
+
+        .file-upload:hover {
+            border-color: var(--text-muted);
+        }
+
+        .file-upload input[type="file"] {
+            display: none;
+        }
+
+        .btn-submit {
+            width: 100%;
+            background-color: var(--accent);
+            color: #000;
+            border: none;
+            padding: 1rem;
+            font-size: 0.95rem;
+            font-weight: 700;
+            text-transform: uppercase;
+            letter-spacing: 0.05em;
+            border-radius: 4px;
+            cursor: pointer;
+            transition: opacity 0.2s;
+            margin-top: 1rem;
+        }
+
+        .btn-submit:hover {
+            opacity: 0.85;
+        }
+
+        .btn-submit:disabled {
+            background-color: var(--border);
+            color: var(--text-muted);
+            cursor: not-allowed;
+        }
+
+        /* Right Panel - Logs & Gallery */
+        .panel-right {
+            padding: 2.5rem;
+            display: flex;
+            flex-direction: column;
+            gap: 2.5rem;
+            overflow-y: auto;
+            max-height: calc(100vh - 75px);
+        }
+
+        .header-actions {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            margin-bottom: 1rem;
+        }
+
+        .btn-secondary {
+            background: transparent;
+            border: 1px solid var(--border);
+            color: var(--text-muted);
+            padding: 0.4rem 0.8rem;
+            font-size: 0.8rem;
+            font-family: var(--font-mono);
+            border-radius: 4px;
+            cursor: pointer;
+        }
+
+        .btn-secondary:hover {
+            color: var(--text-main);
+            border-color: var(--text-muted);
+        }
+
+        /* Jobs Container */
+        .job-card {
+            border: 1px solid var(--border);
+            background-color: var(--surface);
+            border-radius: 6px;
+            overflow: hidden;
+            margin-bottom: 1.5rem;
+        }
+
+        .job-header {
+            padding: 1rem 1.5rem;
+            border-bottom: 1px solid var(--border);
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            background-color: var(--bg);
+        }
+
+        .job-id {
+            font-family: var(--font-mono);
+            font-size: 0.85rem;
+            color: var(--text-main);
+        }
+
+        .job-status {
+            font-family: var(--font-mono);
+            font-size: 0.75rem;
+            padding: 0.2rem 0.6rem;
+            border-radius: 3px;
+            font-weight: 600;
+        }
+
+        .status-RUNNING, .status-STAGING { background-color: rgba(227, 179, 65, 0.15); color: var(--warning); }
+        .status-SUCCESS { background-color: rgba(61, 214, 140, 0.15); color: var(--success); }
+        .status-FAILED, .status-CANCELLED { background-color: rgba(248, 81, 73, 0.15); color: var(--danger); }
+
+        .job-body {
+            padding: 1.5rem;
+        }
+
+        .job-meta {
+            font-size: 0.85rem;
+            color: var(--text-muted);
+            margin-bottom: 1rem;
+        }
+
+        .progress-box {
+            background-color: var(--bg);
+            border: 1px solid var(--border);
+            border-radius: 4px;
+            padding: 1.2rem;
+            margin-bottom: 1.2rem;
+        }
+        .progress-header {
+            display: flex;
+            justify-content: space-between;
+            font-size: 0.85rem;
+            margin-bottom: 0.6rem;
+            font-family: var(--font-mono);
+        }
+        .step-text {
+            color: var(--text-main);
+        }
+        .progress-pct {
+            color: var(--text-muted);
+            font-weight: 600;
+        }
+        .progress-track {
+            width: 100%;
+            height: 6px;
+            background-color: var(--border);
+            border-radius: 3px;
+            overflow: hidden;
+        }
+        .progress-fill {
+            height: 100%;
+            background-color: var(--accent);
+            transition: width 0.5s ease;
+        }
+        .progress-fill.FAILED, .progress-fill.CANCELLED { background-color: var(--danger); }
+        .progress-fill.SUCCESS { background-color: var(--success); }
+        
+        details.tech-logs {
+            margin-top: 1rem;
+            font-size: 0.8rem;
+            color: var(--text-muted);
+            cursor: pointer;
+        }
+        details.tech-logs summary {
+            outline: none;
+            user-select: none;
+            padding: 0.4rem 0;
+            font-family: var(--font-mono);
+        }
+
+        /* Terminal Log Stream */
+        .terminal {
+            background-color: #000;
+            border: 1px solid var(--border);
+            padding: 1rem;
+            font-family: var(--font-mono);
+            font-size: 0.8rem;
+            color: #d1d5db;
+            max-height: 220px;
+            overflow-y: auto;
+            border-radius: 4px;
+            white-space: pre-wrap;
+            line-height: 1.4;
+        }
+
+        /* Video Output Preview */
+        .video-container {
+            margin-top: 1rem;
+            padding: 1rem;
+            border: 1px solid var(--border);
+            background-color: var(--bg);
+            border-radius: 4px;
+        }
+
+        video {
+            width: 100%;
+            max-height: 360px;
+            border-radius: 4px;
+            outline: none;
+            background-color: #000;
+        }
+
+        .job-actions {
+            margin-top: 1rem;
+            display: flex;
+            gap: 0.75rem;
+            justify-content: flex-end;
+        }
+
+        .btn-cancel {
+            background-color: var(--danger);
+            color: #fff;
+            border: none;
+            padding: 0.5rem 1rem;
+            font-size: 0.8rem;
+            font-weight: 600;
+            border-radius: 4px;
+            cursor: pointer;
+        }
+
+        .btn-download {
+            background-color: var(--success);
+            color: #000;
+            text-decoration: none;
+            padding: 0.5rem 1rem;
+            font-size: 0.8rem;
+            font-weight: 700;
+            border-radius: 4px;
+            display: inline-block;
+        }
+        .btn-cancel {
+            background: transparent;
+            color: var(--danger);
+            border: 1px solid var(--danger);
+        }
+        .btn-cancel:hover {
+            background: rgba(248, 81, 73, 0.1);
+        }
+
+        /* Gold Accent Premium Theme */
+        body.premium-theme {
+            --bg: #0b0a08;
+            --surface: #14120e;
+            --surface-hover: #1f1b13;
+            --border: #382e1b;
+            --accent: #f9a825;
+            --accent-bg: #2b220d;
+        }
+        body.premium-theme .btn-submit {
+            background: linear-gradient(135deg, #f9a825 0%, #d4af37 50%, #aa771c 100%);
+            color: #000;
+            font-weight: 700;
+            box-shadow: 0 0 20px rgba(249, 168, 37, 0.3);
+        }
+        .tab-switcher {
+            display: flex;
+            gap: 0.5rem;
+            margin-bottom: 2rem;
+            border-bottom: 1px solid var(--border);
+            padding-bottom: 1rem;
+        }
+        .tab-btn {
+            flex: 1;
+            padding: 0.75rem 1rem;
+            border: 1px solid var(--border);
+            background: var(--bg);
+            color: var(--text-muted);
+            font-family: var(--font-main);
+            font-weight: 600;
+            font-size: 0.9rem;
+            cursor: pointer;
+            border-radius: 4px;
+            transition: all 0.2s;
+        }
+        .tab-btn.active {
+            background: var(--surface-hover);
+            color: var(--accent);
+            border-color: var(--accent);
+        }
+        body.premium-theme .tab-btn.active {
+            background: linear-gradient(135deg, #2b220d 0%, #1f1b13 100%);
+            color: #f9a825;
+            border-color: #f9a825;
+            box-shadow: 0 0 12px rgba(249, 168, 37, 0.2);
+        }
+    </style>
 </head>
 <body>
-    <div class="bg-glow bg-glow-1"></div>
-    <div class="bg-glow bg-glow-2"></div>
-    
-    <div class="app-container">
-        <header class="header">
-            <div class="logo-area">
-                <div class="logo-icon">🎬</div>
-                <div>
-                    <h1>LTX Flow B Studio</h1>
-                    <p class="subtitle">Cloud AI Lip-Sync & Multi-Clip Stitching Engine</p>
+
+<header>
+    <div class="logo">Epic<span style="color: var(--accent);">Sync</span></div>
+    <div class="status-badge" id="modeBadge">STANDARD STUDIO (OPENTALKER 2D)</div>
+</header>
+
+<main>
+    <!-- Left Control Panel -->
+    <div class="panel-left">
+        <div class="tab-switcher">
+            <button type="button" class="tab-btn active" id="tabStandard" onclick="switchTab('standard')">Standard Studio</button>
+            <button type="button" class="tab-btn" id="tabPremium" onclick="switchTab('premium')">✨ Premium Studio (LTX 3D)</button>
+        </div>
+
+        <div class="section-title" id="formTitle">New Sync Task</div>
+        <form id="syncForm">
+            <div class="form-group">
+                <label id="fileLabel">Source Video or Photo File</label>
+                <div class="file-upload" onclick="document.getElementById('mediaFile').click()">
+                    <span id="fileName">Select or Drop MP4/JPG File</span>
+                    <input type="file" id="mediaFile" name="video" accept="video/mp4,image/*" required onchange="updateFileName(this)">
                 </div>
             </div>
-            <div class="status-badge">
-                <span class="status-dot"></span>
-                <span>24/7 Cloud Backend Active</span>
+
+            <div class="form-group">
+                <label>Speech Script (Text to Synthesize)</label>
+                <textarea name="script_text" placeholder="Enter the exact script you want the character to articulate..." required></textarea>
             </div>
-        </header>
-
-        <main class="grid-layout">
-            <!-- Left Panel: Generator Form -->
-            <section class="glass-card form-section">
-                <h2>⚡ Create New Generation</h2>
-                <p class="section-desc">Paste your full script below. Our engine automatically slices paragraphs, generates child-like speech, animates your character, and stitches the final MP4.</p>
-                
-                <form id="genForm">
-                    <div class="form-group">
-                        <label for="script_text">📝 Full Video Script (Auto-Spliced)</label>
-                        <textarea id="script_text" name="script_text" rows="5" placeholder="Enter your full script here. You can paste paragraphs or single lines. Our engine will automatically convert each sentence into audio clips and stitch them together into a seamless long video." required></textarea>
-                        <span class="hint">💡 Tip: Blank lines or periods separate individual video cuts automatically.</span>
-                    </div>
 
-                    <div class="form-group">
-                        <label for="prompt_text">🎨 Visual Scene Prompt</label>
-                        <textarea id="prompt_text" name="prompt_text" rows="2" placeholder="e.g., A young cute character looking directly at camera, warm cinematic lighting, studio quality, 4k" required></textarea>
-                    </div>
+            <div class="form-group">
+                <label>Neural Voice Model</label>
+                <select name="voice">
+                    <option value="en-US-AnaNeural">Ana (en-US, Cute Child / Baby Girl Voice)</option>
+                    <option value="en-US-ChristopherNeural">Christopher (en-US, Deep Male)</option>
+                    <option value="en-GB-SoniaNeural">Sonia (en-GB, British Female)</option>
+                    <option value="en-GB-RyanNeural">Ryan (en-GB, British Male)</option>
+                    <option value="fr-FR-DeniseNeural">Denise (French Female)</option>
+                </select>
+            </div>
 
-                    <div class="form-row">
-                        <div class="form-group flex-1">
-                            <label for="image">🖼️ Reference Character Image</label>
-                            <div class="file-upload-box" id="dropZone">
-                                <input type="file" id="image" name="image" accept="image/*" required>
-                                <div class="upload-content">
-                                    <span class="upload-icon">📁</span>
-                                    <span class="upload-text">Click or drag image here</span>
-                                    <span class="file-name" id="fileName">No file chosen</span>
-                                </div>
-                            </div>
-                        </div>
+            <input type="hidden" name="hf_repo" value="Airpyk98/EpicSync-Dataset">
+            <input type="hidden" name="hf_token" value="">
 
-                        <div class="form-group flex-1">
-                            <label for="voice">🗣️ Voice Model</label>
-                            <select id="voice" name="voice">
-                                <option value="en-US-AnaNeural" selected>⭐ en-US-AnaNeural (Cute Baby/Child Voice)</option>
-                                <option value="en-US-ChristopherNeural">👨 en-US-ChristopherNeural (Male Clear)</option>
-                                <option value="en-GB-SoniaNeural">👩 en-GB-SoniaNeural (British Female)</option>
-                                <option value="en-US-EricNeural">🧑 en-US-EricNeural (Male Energetic)</option>
-                            </select>
-
-                            <label for="resolution" style="margin-top: 1rem;">📐 Resolution & Aspect Ratio</label>
-                            <div class="select-row">
-                                <select id="resolution" name="resolution">
-                                    <option value="720p" selected>720p HD</option>
-                                    <option value="540p">540p Fast</option>
-                                    <option value="1080p">1080p Ultra HD</option>
-                                </select>
-                                <select id="aspect_ratio" name="aspect_ratio">
-                                    <option value="16:9 Landscape" selected>16:9 Landscape</option>
-                                    <option value="9:16 Portrait">9:16 Portrait</option>
-                                    <option value="1:1 Square">1:1 Square</option>
-                                </select>
-                            </div>
-                        </div>
-                    </div>
+            <input type="hidden" name="kaggle_user" value="ikechukwuebiringa1">
+            <input type="hidden" name="kaggle_key" value="KGAT_fc473ab2c166567756eac24217d1fbd2">
+
+            <button type="submit" class="btn-submit" id="submitBtn">Launch EpicSync</button>
+        </form>
+    </div>
+
+    <!-- Right Live Logs & Output Panel -->
+    <div class="panel-right">
+        <div>
+            <div class="header-actions">
+                <div class="section-title" style="margin-bottom:0;">Live Logs & Persistent Tasks</div>
+                <button class="btn-secondary" onclick="clearLogs()">Clear Inactive Runs</button>
+            </div>
+            <div id="jobsList">
+                <div style="color: var(--text-muted); font-size: 0.9rem; padding: 2rem 0;">No active synchronization tasks found. Submit a task on the left to begin real-time generation.</div>
+            </div>
+        </div>
+    </div>
+</main>
 
-                    <!-- Expandable Credentials Section -->
-                    <details class="credentials-box">
-                        <summary>🔑 Kaggle Cloud Credentials (Default Configured)</summary>
-                        <div class="creds-content">
-                            <p class="hint">Pre-filled with your active Kaggle GPU engine tokens.</p>
-                            <div class="form-row">
-                                <div class="form-group flex-1">
-                                    <label>Kaggle Username</label>
-                                    <input type="text" name="kaggle_user" value="ikechukwuebiringa1">
+<script>
+    let currentMode = 'standard';
+
+    function switchTab(mode) {
+        currentMode = mode;
+        document.getElementById('tabStandard').classList.toggle('active', mode === 'standard');
+        document.getElementById('tabPremium').classList.toggle('active', mode === 'premium');
+        const mediaInput = document.getElementById('mediaFile');
+        if (mode === 'premium') {
+            document.body.classList.add('premium-theme');
+            document.getElementById('modeBadge').innerText = 'PREMIUM STUDIO (LTX 3D ACCELERATED)';
+            document.getElementById('fileLabel').innerText = 'Source Portrait Photo File (.png/.jpg)';
+            document.getElementById('fileName').innerText = 'Select or Drop Portrait Image File';
+            mediaInput.name = 'image';
+            mediaInput.accept = 'image/*';
+        } else {
+            document.body.classList.remove('premium-theme');
+            document.getElementById('modeBadge').innerText = 'STANDARD STUDIO (OPENTALKER 2D)';
+            document.getElementById('fileLabel').innerText = 'Source Video or Photo File';
+            document.getElementById('fileName').innerText = 'Select or Drop MP4/JPG File';
+            mediaInput.name = 'video';
+            mediaInput.accept = 'video/mp4,image/*';
+        }
+    }
+
+    function updateFileName(input) {
+        const display = document.getElementById('fileName');
+        if (input.files && input.files[0]) {
+            display.innerText = input.files[0].name;
+            display.style.color = '#fff';
+        }
+    }
+
+    document.getElementById('syncForm').addEventListener('submit', async (e) => {
+        e.preventDefault();
+        const btn = document.getElementById('submitBtn');
+        btn.disabled = true;
+        btn.innerText = 'Submitting Task...';
+
+        const formData = new FormData(e.target);
+        const endpoint = currentMode === 'premium' ? '/api/run_premium' : '/api/run';
+        try {
+            const res = await fetch(endpoint, {
+                method: 'POST',
+                body: formData
+            });
+            if (res.ok) {
+                e.target.reset();
+                document.getElementById('fileName').innerText = currentMode === 'premium' ? 'Select or Drop Portrait Image File' : 'Select or Drop MP4/JPG File';
+                fetchJobs();
+            } else {
+                const errData = await res.json().catch(() => ({}));
+                alert('Submission failed: ' + (errData.detail || 'Unknown error'));
+            }
+        } catch (err) {
+            alert('Network error connecting to EpicSync server.');
+        } finally {
+            btn.disabled = false;
+            btn.innerText = 'Launch EpicSync';
+        }
+    });
+
+    async function cancelJob(jobId) {
+        await fetch(`/api/cancel/${jobId}`, { method: 'POST' });
+        fetchJobs();
+    }
+
+    async function clearLogs() {
+        await fetch('/api/clear_logs', { method: 'POST' });
+        fetchJobs();
+    }
+
+    async function fetchJobs() {
+        try {
+            const res = await fetch('/api/jobs');
+            const jobs = await res.json();
+            const container = document.getElementById('jobsList');
+            const keys = Object.keys(jobs).sort((a,b) => jobs[b].created_at - jobs[a].created_at);
+
+            if (keys.length === 0) {
+                container.innerHTML = '<div style="color: var(--text-muted); font-size: 0.9rem; padding: 2rem 0;">No active synchronization tasks found. Submit a task on the left to begin real-time generation.</div>';
+                return;
+            }
+
+            container.innerHTML = keys.map(k => {
+                const job = jobs[k];
+                const logText = (job.logs || []).join('\n');
+                const isRunning = job.status === 'RUNNING' || job.status === 'STAGING';
+                const isSuccess = job.status === 'SUCCESS';
+                const prog = job.progress !== undefined ? job.progress : (isRunning ? 40 : (isSuccess ? 100 : 0));
+                const stepText = job.step_text || (isRunning ? 'Processing video lip-sync on compute acceleration...' : job.status);
+
+                return `
+                    <div class="job-card">
+                        <div class="job-header">
+                            <span class="job-id">${job.title}</span>
+                            <span class="job-status status-${job.status}">${job.status}</span>
+                        </div>
+                        <div class="job-body">
+                            <div class="job-meta">
+                                Voice: <strong>${job.voice}</strong> | Script: "${job.script.substring(0, 60)}..."
+                            </div>
+                            <div class="progress-box">
+                                <div class="progress-header">
+                                    <span class="step-text">${stepText}</span>
+                                    <span class="progress-pct">${prog}%</span>
                                 </div>
-                                <div class="form-group flex-1">
-                                    <label>Kaggle API Key / KGAT</label>
-                                    <input type="password" name="kaggle_key" value="KGAT_0f12d3a4d07d48f7775e36f82bbc41b6">
+                                <div class="progress-track">
+                                    <div class="progress-fill ${job.status}" style="width: ${prog}%;"></div>
                                 </div>
                             </div>
+                            ${isSuccess && job.output_file ? `
+                                <div class="video-container">
+                                    <video controls autoplay loop>
+                                        <source src="/api/video/${k}" type="video/mp4">
+                                        Your browser does not support HTML5 video.
+                                    </video>
+                                    <div class="job-actions">
+                                        <a href="/api/download/${k}" download="EpicSync_${k}.mp4" class="btn-download">Download Video</a>
+                                    </div>
+                                </div>
+                            ` : ''}
+                            ${isRunning ? `
+                                <div class="job-actions">
+                                    <button onclick="cancelJob('${k}')" class="btn-cancel">Cancel Task</button>
+                                </div>
+                            ` : ''}
+                            <details class="tech-logs">
+                                <summary>▸ View Diagnostics / System Logs</summary>
+                                <div class="terminal" id="term_${k}" style="max-height: 180px; margin-top: 0.8rem;">${logText}</div>
+                            </details>
                         </div>
-                    </details>
-
-                    <button type="submit" class="run-btn" id="runBtn">
-                        <span class="btn-icon">🚀</span>
-                        <span class="btn-text">RUN CLOUD GENERATION</span>
-                    </button>
-                </form>
-            </section>
-
-            <!-- Right Panel: Jobs & Downloads -->
-            <section class="glass-card jobs-section">
-                <div class="jobs-header">
-                    <h2>📋 Cloud Job Dashboard</h2>
-                    <button id="refreshBtn" class="refresh-btn" title="Refresh Status">🔄 Refresh</button>
-                </div>
-                <p class="section-desc">Close your browser anytime! Your tasks run independently on Kaggle. Come back and click Refresh to download.</p>
-                
-                <div id="jobsList" class="jobs-list">
-                    <div class="loading-spinner">Loading jobs...</div>
-                </div>
-            </section>
-        </main>
-    </div>
+                    </div>
+                `;
+            }).join('');
+
+            // Scroll terminals to bottom
+            keys.forEach(k => {
+                const term = document.getElementById(`term_${k}`);
+                if (term) term.scrollTop = term.scrollHeight;
+            });
+        } catch (err) {
+            console.error('Failed to poll jobs:', err);
+        }
+    }
 
-    <script src="app.js"></script>
+    // Real-time polling every 4 seconds
+    setInterval(fetchJobs, 4000);
+    fetchJobs();
+</script>
 </body>
 </html>