app.py

#!/usr/bin/env python3
# FILE: app.py
# Description: Image-to-Video generation server with Gradio UI and FastAPI for Hugging Face Spaces
# Version: 1.2.8
# Timestamp: 2025-07-01 20:41 CDT
# Author: Grok 3, built by xAI (based on GhostAI's ghostpack_gradio_f1.py)
# NOTE: Optimized for Hugging Face Spaces with H200 GPU, 25 min/day render time
#       Loads models from Hugging Face Hub to avoid HDD costs
#       Uses /data for persistent storage, /tmp for temporary files
#       API key authentication for /generate endpoint (off-site use)
#       Base64-encoded video responses
#       Gradio UI matches original ghostpack_gradio_f1.py
#       Idle until triggered by API or Gradio

import os
import sys
import time
import json
import argparse
import importlib.util
import subprocess
import traceback
import torch
import einops
import numpy as np
from PIL import Image
import io
import gradio as gr
import asyncio
import queue
from threading import Thread
import re
import logging
import base64
import socket
import requests
import shutil
import uuid
from fastapi import FastAPI, HTTPException, UploadFile, File, Form, Depends, Security, status
from fastapi.security import APIKeyHeader
from fastapi.middleware.cors import CORSMiddleware
from fastapi.responses import JSONResponse
from pydantic import BaseModel
from diffusers import AutoencoderKLHunyuanVideo
from transformers import (
    LlamaModel, CLIPTextModel, LlamaTokenizerFast, CLIPTokenizer,
    SiglipImageProcessor, SiglipVisionModel
)
from diffusers_helper.hunyuan import (
    encode_prompt_conds, vae_decode, vae_encode, vae_decode_fake
)
from diffusers_helper.utils import (
    save_bcthw_as_mp4, crop_or_pad_yield_mask, soft_append_bcthw
)
from diffusers_helper.models.hunyuan_video_packed import HunyuanVideoTransformer3DModelPacked
from diffusers_helper.memory import (
    gpu, get_cuda_free_memory_gb, move_model_to_device_with_memory_preservation,
    offload_model_from_device_for_memory_preservation, fake_diffusers_current_device,
    DynamicSwapInstaller, unload_complete_models, load_model_as_complete
)
from diffusers_helper.clip_vision import hf_clip_vision_encode
from diffusers_helper.bucket_tools import find_nearest_bucket
from diffusers_helper.thread_utils import AsyncStream
from diffusers_helper.gradio.progress_bar import make_progress_bar_css, make_progress_bar_html

# Optional: Colorama for colored console output
try:
    from colorama import init, Fore, Style
    init(autoreset=True)
    COLORAMA_AVAILABLE = True
    def red(s): return Fore.RED + s + Style.RESET_ALL
    def green(s): return Fore.GREEN + s + Style.RESET_ALL
    def yellow(s): return Fore.YELLOW + s + Style.RESET_ALL
    def reset_all(s): return Style.RESET_ALL + s
except ImportError:
    COLORAMA_AVAILABLE = False
    def red(s): return s
    def green(s): return s
    def yellow(s): return s
    def reset_all(s): return s

# Set up logging
logging.basicConfig(
    filename="/data/ghostpack.log",
    level=logging.DEBUG,
    format="%(asctime)s %(levelname)s:%(message)s",
)
logger = logging.getLogger(__name__)
logger.info("Starting GhostPack F1 Pro")
print(f"{green('Using /data/video_info.json for metadata')}")

VERSION = "1.2.8"
HF_TOKEN = os.getenv('HF_TOKEN', 'your-hf-token')  # Set in Spaces secrets
API_KEY_NAME = "X-API-Key"
API_KEY = os.getenv('API_KEY', 'your-secret-key')  # Set in Spaces secrets
api_key_header = APIKeyHeader(name=API_KEY_NAME, auto_error=False)

# Global job registry
active_jobs = {}  # {job_id: AsyncStream}
job_status = {}   # {job_id: {"status": str, "progress": float, "render_time": float}}

# CLI
parser = argparse.ArgumentParser(description="GhostPack F1 Pro")
parser.add_argument("--share", action="store_true", help="Share Gradio UI publicly")
parser.add_argument("--server", type=str, default="0.0.0.0", help="Server host")
parser.add_argument("--port", type=int, default=7860, help="FastAPI port")
parser.add_argument("--gradio", action="store_true", help="Enable Gradio UI")
parser.add_argument("--inbrowser", action="store_true", help="Open in browser")
parser.add_argument("--cli", action="store_true", help="Show CLI help")
args = parser.parse_args()

# Global state
render_on_off = True

BASE = os.path.abspath(os.path.dirname(__file__))
os.environ["HF_HOME"] = "/tmp/hf_cache"  # Cache models in /tmp

# Check if ports are available
def is_port_in_use(port):
    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
        return s.connect_ex(('0.0.0.0', port)) == 0

if args.cli:
    print(f"{green('👻 GhostPack F1 Pro CLI')}")
    print("python app.py           # Launch API")
    print("python app.py --gradio  # Launch API + Gradio UI")
    print("python app.py --cli     # Show help")
    sys.exit(0)

# Paths
DATA_DIR = "/data"
TMP_DIR = "/tmp/ghostpack"
VIDEO_OUTPUT_DIR = "/tmp/ghostpack/vid"
VIDEO_IMG_DIR = "/tmp/ghostpack/img"
VIDEO_TMP_DIR = "/tmp/ghostpack/tmp_vid"
VIDEO_INFO_FILE = "/data/video_info.json"
PROMPT_LOG_FILE = "/data/prompts.txt"
SAVED_PROMPTS_FILE = "/data/saved_prompts.json"
INSTALL_LOG_FILE = "/data/install_logs.txt"
LAST_CLEANUP_FILE = "/data/last_cleanup.txt"

# Initialize directories
for d in (DATA_DIR, TMP_DIR, VIDEO_OUTPUT_DIR, VIDEO_IMG_DIR, VIDEO_TMP_DIR):
    if not os.path.exists(d):
        try:
            os.makedirs(d, exist_ok=True)
            os.chmod(d, 0o775)
            logger.debug(f"Created {d}")
        except Exception as e:
            logger.error(f"Failed to create {d}: {e}")
            print(f"{red(f'Error: Failed to create {d}: {e}')}")
            sys.exit(1)

# Initialize files
for f in (VIDEO_INFO_FILE, SAVED_PROMPTS_FILE, PROMPT_LOG_FILE, INSTALL_LOG_FILE, LAST_CLEANUP_FILE):
    if not os.path.exists(f):
        try:
            if f == LAST_CLEANUP_FILE:
                with open(f, "w") as fd:
                    fd.write(str(time.time()))
            elif f in (VIDEO_INFO_FILE, SAVED_PROMPTS_FILE):
                with open(f, "w") as fd:
                    json.dump([], fd)
            else:
                open(f, "w").close()
            os.chmod(f, 0o664)
            logger.debug(f"Created {f}")
        except Exception as e:
            logger.error(f"Failed to create/chmod {f}: {e}")
            print(f"{red(f'Error: Failed to create/chmod {f}: {e}')}")
            sys.exit(1)

# Clear VIDEO_INFO_FILE on startup
try:
    with open(VIDEO_INFO_FILE, "w") as f:
        json.dump([], f)
    os.chmod(VIDEO_INFO_FILE, 0o664)
    logger.debug(f"Cleared {VIDEO_INFO_FILE}")
except Exception as e:
    logger.error(f"Failed to clear {VIDEO_INFO_FILE}: {e}")
    print(f"{red(f'Error: Failed to clear {VIDEO_INFO_FILE}: {e}')}")
    sys.exit(1)

# Queue clearing utility
def clear_queue(q):
    try:
        while True:
            if hasattr(q, "get_nowait"):
                q.get_nowait()
            else:
                break
    except queue.Empty:
        pass

# Prompt utilities
def get_last_prompts():
    try:
        return json.load(open(SAVED_PROMPTS_FILE))[-5:][::-1]
    except Exception as e:
        logger.error(f"Failed to load prompts from {SAVED_PROMPTS_FILE}: {e}")
        print(f"{red(f'Error: Failed to load prompts: {e}')}")
        return []

def save_prompt_fn(prompt, n_p):
    if not prompt:
        return f"{red('❌ No prompt')}"
    try:
        data = json.load(open(SAVED_PROMPTS_FILE))
        entry = {"prompt": prompt, "negative": n_p}
        if entry not in data:
            data.append(entry)
            with open(SAVED_PROMPTS_FILE, "w") as f:
                json.dump(data, f, indent=2)
            os.chmod(SAVED_PROMPTS_FILE, 0o664)
        return f"{green('✅ Saved')}"
    except Exception as e:
        logger.error(f"Failed to save prompt to {SAVED_PROMPTS_FILE}: {e}")
        print(f"{red(f'Error: Failed to save prompt: {e}')}")
        return f"{red('❌ Save failed')}"

def load_prompt_fn(idx):
    lst = get_last_prompts()
    return lst[idx]["prompt"] if idx < len(lst) else ""

# Cleanup utilities
def clear_temp_videos():
    try:
        for f in os.listdir(VIDEO_TMP_DIR):
            os.remove(os.path.join(VIDEO_TMP_DIR, f))
        return f"{green('✅ Temp cleared')}"
    except Exception as e:
        logger.error(f"Failed to clear temp videos in {VIDEO_TMP_DIR}: {e}")
        print(f"{red(f'Error: Failed to clear temp videos: {e}')}")
        return f"{red('❌ Clear failed')}"

def clear_old_files():
    cutoff = time.time() - 7 * 24 * 3600
    c = 0
    try:
        for d in (VIDEO_TMP_DIR, VIDEO_IMG_DIR, VIDEO_OUTPUT_DIR):
            for f in os.listdir(d):
                p = os.path.join(d, f)
                if os.path.isfile(p) and os.path.getmtime(p) < cutoff:
                    os.remove(p)
                    c += 1
        with open(LAST_CLEANUP_FILE, "w") as f:
            f.write(str(time.time()))
        os.chmod(LAST_CLEANUP_FILE, 0o664)
        return f"{green(f'✅ {c} old files removed')}"
    except Exception as e:
        logger.error(f"Failed to clear old files: {e}")
        print(f"{red(f'Error: Failed to clear old files: {e}')}")
        return f"{red('❌ Clear failed')}"

def clear_images():
    try:
        for f in os.listdir(VIDEO_IMG_DIR):
            os.remove(os.path.join(VIDEO_IMG_DIR, f))
        return f"{green('✅ Images cleared')}"
    except Exception as e:
        logger.error(f"Failed to clear images in {VIDEO_IMG_DIR}: {e}")
        print(f"{red(f'Error: Failed to clear images: {e}')}")
        return f"{red('❌ Clear failed')}"

def clear_videos():
    try:
        for f in os.listdir(VIDEO_OUTPUT_DIR):
            os.remove(os.path.join(VIDEO_OUTPUT_DIR, f))
        return f"{green('✅ Videos cleared')}"
    except Exception as e:
        logger.error(f"Failed to clear videos in {VIDEO_OUTPUT_DIR}: {e}")
        print(f"{red(f'Error: Failed to clear videos: {e}')}")
        return f"{red('❌ Clear failed')}"

def check_and_run_weekly_cleanup():
    try:
        with open(LAST_CLEANUP_FILE, "r") as f:
            last_cleanup = float(f.read().strip())
    except (FileNotFoundError, ValueError):
        last_cleanup = 0
    if time.time() - last_cleanup > 7 * 24 * 3600:
        return clear_old_files()
    return ""

# Video metadata utilities
def save_video_info(prompt, n_p, filename, seed, secs, additional_info, completed=False):
    if not completed:
        return
    try:
        video_info = json.load(open(VIDEO_INFO_FILE))
    except (FileNotFoundError, json.JSONDecodeError):
        video_info = []
    entry = {
        "prompt": prompt or "",
        "negative_prompt": n_p or "",
        "filename": filename,
        "location": os.path.join(VIDEO_OUTPUT_DIR, filename),
        "seed": seed,
        "duration_secs": secs,
        "timestamp": time.strftime("%Y%m%d_%H%M%S"),
        "completed": completed,
        "additional_info": additional_info or {},
    }
    video_info.append(entry)
    try:
        with open(VIDEO_INFO_FILE, "w") as f:
            json.dump(video_info, f, indent=2)
        os.chmod(VIDEO_INFO_FILE, 0o664)
        logger.debug(f"Saved video info to {VIDEO_INFO_FILE}")
    except Exception as e:
        logger.error(f"Failed to save video info to {VIDEO_INFO_FILE}: {e}")
        print(f"{red(f'Error: Failed to save video info to {VIDEO_INFO_FILE}: {e}')}")
        raise

# Gallery helpers
def list_images():
    return sorted(
        [os.path.join(VIDEO_IMG_DIR, f) for f in os.listdir(VIDEO_IMG_DIR) if f.lower().endswith((".png", ".jpg"))],
        key=os.path.getmtime,
    )

def list_videos():
    return sorted(
        [os.path.join(VIDEO_OUTPUT_DIR, f) for f in os.listdir(VIDEO_OUTPUT_DIR) if f.lower().endswith(".mp4")],
        key=os.path.getmtime,
    )

def load_image(sel):
    imgs = list_images()
    if sel in [os.path.basename(p) for p in imgs]:
        pth = imgs[[os.path.basename(p) for p in imgs].index(sel)]
        return gr.update(value=pth), gr.update(value=os.path.basename(pth))
    return gr.update(), gr.update()

def load_video(sel):
    vids = list_videos()
    if sel in [os.path.basename(p) for p in vids]:
        pth = vids[[os.path.basename(p) for p in vids].index(sel)]
        return gr.update(value=pth), gr.update(value=os.path.basename(pth))
    return gr.update(), gr.update()

def next_image_and_load(sel):
    imgs = list_images()
    if not imgs:
        return gr.update(), gr.update()
    names = [os.path.basename(i) for i in imgs]
    idx = (names.index(sel) + 1) % len(names) if sel in names else 0
    pth = imgs[idx]
    return gr.update(value=pth), gr.update(value=os.path.basename(pth))

def next_video_and_load(sel):
    vids = list_videos()
    if not vids:
        return gr.update(), gr.update()
    names = [os.path.basename(v) for v in vids]
    idx = (names.index(sel) + 1) % len(names) if sel in names else 0
    pth = vids[idx]
    return gr.update(value=pth), gr.update(value=os.path.basename(pth))

def gallery_image_select(evt: gr.SelectData):
    imgs = list_images()
    if evt.index is not None and evt.index < len(imgs):
        pth = imgs[evt.index]
        return gr.update(value=pth), gr.update(value=os.path.basename(pth))
    return gr.update(), gr.update()

def gallery_video_select(evt: gr.SelectData):
    vids = list_videos()
    if evt.index is not None and evt.index < len(vids):
        pth = vids[evt.index]
        return gr.update(value=pth), gr.update(value=os.path.basename(pth))
    return gr.update(), gr.update()

# Install status
def check_mod(n):
    return importlib.util.find_spec(n) is not None

def status_xformers():
    print(f"{green('✅ Xformers is installed!')}" if check_mod("xformers") else f"{red('❌ Xformers is not installed!')}")
    return f"{green('✅ xformers')}" if check_mod("xformers") else f"{red('❌ xformers')}"

def status_sage():
    print(f"{green('✅ Sage Attn is installed!')}" if check_mod("sageattention") else f"{red('❌ Sage Attn is not installed!')}")
    return f"{green('✅ sage-attn')}" if check_mod("sageattention") else f"{red('❌ sage-attn')}"

def status_flash():
    print(f"{yellow('⚠️ Flash Attn is not installed, performance may be reduced!')}" if not check_mod("flash_attn") else f"{green('✅ Flash Attn is installed!')}")
    return f"{yellow('⚠️ flash-attn')}" if not check_mod("flash_attn") else f"{green('✅ flash-attn')}"

def status_colorama():
    return f"{green('✅ colorama')}" if COLORAMA_AVAILABLE else f"{red('❌ colorama')}"

def install_pkg(pkg, warn=None):
    if warn:
        print(f"{yellow(warn)}")
        time.sleep(1)
    try:
        out = subprocess.check_output(
            [sys.executable, "-m", "pip", "install", pkg], stderr=subprocess.STDOUT, text=True
        )
        res = f"{green(f'✅ {pkg}')}\n{out}\n"
    except subprocess.CalledProcessError as e:
        res = f"{red(f'❌ {pkg}')}\n{e.output}\n"
    with open(INSTALL_LOG_FILE, "a") as f:
        f.write(f"[{pkg}] {res}")
    return res

install_xformers = lambda: install_pkg("xformers")
install_sage_attn = lambda: install_pkg("sage-attn")
install_flash_attn = lambda: install_pkg("flash-attn", "⚠️ long compile, optional for performance")
install_colorama = lambda: install_pkg("colorama")
refresh_logs = lambda: open(INSTALL_LOG_FILE).read()
clear_logs = lambda: open(INSTALL_LOG_FILE, "w").close() or f"{green('✅ Logs cleared')}"

# Model load
free_mem = get_cuda_free_memory_gb(gpu)
hv = free_mem > 60
logger.info(f"VRAM available: {free_mem:.2f} GB, High VRAM mode: {hv}")
print(f"{yellow(f'VRAM available: {free_mem:.2f} GB, High VRAM mode: {hv}')}")

try:
    print(f"{yellow('Loading models...')}")
    text_encoder = LlamaModel.from_pretrained(
        "hunyuanvideo-community/HunyuanVideo", subfolder="text_encoder", torch_dtype=torch.float16, token=HF_TOKEN, cache_dir="/tmp/hf_cache"
    ).cpu().eval()
    text_encoder_2 = CLIPTextModel.from_pretrained(
        "hunyuanvideo-community/HunyuanVideo", subfolder="text_encoder_2", torch_dtype=torch.float16, token=HF_TOKEN, cache_dir="/tmp/hf_cache"
    ).cpu().eval()
    tokenizer = LlamaTokenizerFast.from_pretrained(
        "hunyuanvideo-community/HunyuanVideo", subfolder="tokenizer", token=HF_TOKEN, cache_dir="/tmp/hf_cache"
    )
    tokenizer_2 = CLIPTokenizer.from_pretrained(
        "hunyuanvideo-community/HunyuanVideo", subfolder="tokenizer_2", token=HF_TOKEN, cache_dir="/tmp/hf_cache"
    )
    vae = AutoencoderKLHunyuanVideo.from_pretrained(
        "hunyuanvideo-community/HunyuanVideo", subfolder="vae", torch_dtype=torch.float16, token=HF_TOKEN, cache_dir="/tmp/hf_cache"
    ).cpu().eval()
    feature_extractor = SiglipImageProcessor.from_pretrained(
        "lllyasviel/flux_redux_bfl", subfolder="feature_extractor", token=HF_TOKEN, cache_dir="/tmp/hf_cache"
    )
    image_encoder = SiglipVisionModel.from_pretrained(
        "lllyasviel/flux_redux_bfl", subfolder="image_encoder", torch_dtype=torch.float16, token=HF_TOKEN, cache_dir="/tmp/hf_cache"
    ).cpu().eval()
    transformer = HunyuanVideoTransformer3DModelPacked.from_pretrained(
        "lllyasviel/FramePack_F1_I2V_HY_20250503", torch_dtype=torch.bfloat16, token=HF_TOKEN, cache_dir="/tmp/hf_cache"
    ).cpu().eval()
    logger.info("Models loaded successfully")
    print(f"{green('Models loaded successfully')}")
except Exception as e:
    logger.error(f"Failed to load models: {e}", exc_info=True)
    print(f"{red(f'Error: Failed to load models: {e}')}")
    raise

if not hv:
    vae.enable_slicing()
    vae.enable_tiling()

transformer.high_quality_fp32_output_for_inference = True
transformer.to(dtype=torch.bfloat16)
for m in (vae, image_encoder, text_encoder, text_encoder_2):
    m.to(dtype=torch.float16)
for m in (vae, image_encoder, text_encoder, text_encoder_2, transformer):
    m.requires_grad_(False)

if not hv:
    DynamicSwapInstaller.install_model(transformer, device=gpu)
    DynamicSwapInstaller.install_model(text_encoder, device=gpu)
else:
    for m in (vae, image_encoder, text_encoder, text_encoder_2, transformer):
        m.to(gpu)
logger.debug("Models configured and moved to device")
print(f"{green('Models configured and moved to device')}")

# FastAPI Setup
app = FastAPI(title="GhostPack F1 Pro API")
app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
)

async def verify_api_key(api_key: str = Security(api_key_header)):
    if api_key != API_KEY:
        raise HTTPException(
            status_code=status.HTTP_401_UNAUTHORIZED,
            detail="Invalid API key"
        )
    return api_key

class GenerateRequest(BaseModel):
    prompt: str
    negative_prompt: str
    seed: int
    video_length: float
    latent_window: int
    steps: int
    cfg: float
    distilled_cfg: float
    cfg_rescale: float
    gpu_keep: float
    crf: int
    use_teacache: bool
    camera_action: str
    disable_prompt_mods: bool
    link_steps_window: bool

@app.get("/health")
async def health_check():
    try:
        return JSONResponse(content={"status": "healthy"})
    except Exception as e:
        logger.error(f"Health check failed: {e}", exc_info=True)
        return JSONResponse(content={"error": str(e), "status": "error"}, status_code=500)

@app.get("/test")
async def test_server():
    try:
        report = {
            "server_status": {
                "version": VERSION,
                "host": args.server,
                "port": args.port,
                "uptime": time.time() - time.time() if job_status else 0,
                "active_jobs": len(active_jobs),
                "api_status": "running",
            },
            "system": {
                "vram_total": free_mem,
                "vram_free": get_cuda_free_memory_gb(gpu),
                "high_vram_mode": hv,
                "cuda_available": torch.cuda.is_available(),
                "cuda_device": torch.cuda.get_device_name(gpu) if torch.cuda.is_available() else "N/A",
            },
            "models": {
                "text_encoder": text_encoder is not None,
                "text_encoder_2": text_encoder_2 is not None,
                "vae": vae is not None,
                "image_encoder": image_encoder is not None,
                "transformer": transformer is not None,
                "tokenizer": tokenizer is not None,
                "tokenizer_2": tokenizer_2 is not None,
                "feature_extractor": feature_extractor is not None,
            },
            "paths": {
                "base": BASE,
                "images": VIDEO_IMG_DIR,
                "videos": VIDEO_OUTPUT_DIR,
                "temp": VIDEO_TMP_DIR,
                "data": DATA_DIR,
                "prompt_log": PROMPT_LOG_FILE,
                "saved_prompts": SAVED_PROMPTS_FILE,
                "install_log": INSTALL_LOG_FILE,
                "video_info": VIDEO_INFO_FILE,
            },
            "file_system": {
                "images_writable": os.access(VIDEO_IMG_DIR, os.W_OK),
                "videos_writable": os.access(VIDEO_OUTPUT_DIR, os.W_OK),
                "temp_writable": os.access(VIDEO_TMP_DIR, os.W_OK),
                "data_writable": os.access(DATA_DIR, os.W_OK),
            },
            "dependencies": {
                "xformers": status_xformers(),
                "sage_attn": status_sage(),
                "flash_attn": status_flash(),
                "colorama": status_colorama(),
            },
            "health_check": {"status": "pass", "details": ""}
        }

        try:
            dummy_img = np.zeros((64, 64, 3), dtype=np.uint8)
            img_pt = (torch.from_numpy(dummy_img).float() / 127.5 - 1).permute(2, 0, 1)[None, :, None]
            if not hv:
                load_model_as_complete(vae, gpu)
            _ = vae_encode(img_pt, vae)
            report["health_check"]["status"] = "pass"
        except Exception as e:
            report["health_check"]["status"] = "fail"
            report["health_check"]["details"] = str(e)
            logger.error(f"Health check failed: {e}", exc_info=True)

        logger.info("Test endpoint accessed successfully")
        print(f"{green(f'Test endpoint accessed: API running on {args.server}:{args.port}')}")
        return JSONResponse(content=report)
    except Exception as e:
        logger.error(f"Test endpoint error: {e}", exc_info=True)
        print(f"{red(f'Test endpoint error: {e}')}")
        return JSONResponse(
            content={"error": str(e), "status": "fail"},
            status_code=500
        )

@app.get("/status/{job_id}")
async def get_status(job_id: str, api_key: str = Depends(verify_api_key)):
    try:
        status = job_status.get(job_id, {"status": "not_found", "progress": 0.0, "render_time": 0})
        return JSONResponse(
            content={
                "job_id": job_id,
                "render_status": status["status"],
                "render_progress": status["progress"],
                "render_time": status["render_time"],
                "active_jobs": len(active_jobs),
                "api_status": "running",
            }
        )
    except Exception as e:
        logger.error(f"Status check failed for job {job_id}: {e}", exc_info=True)
        return JSONResponse(
            content={"error": str(e), "job_id": job_id, "status": "error"},
            status_code=500
        )

@app.post("/stop/{job_id}")
async def stop_render(job_id: str, api_key: str = Depends(verify_api_key)):
    if job_id not in active_jobs:
        logger.info(f"No active job {job_id} to stop")
        print(f"{yellow(f'No active job {job_id} to stop')}")
        return JSONResponse(content={"message": f"No active job {job_id}"})
    stream = active_jobs[job_id]
    stream.stop()
    active_jobs.pop(job_id, None)
    job_status[job_id]["status"] = "stopped"
    job_status[jid]["progress"] = 0.0
    logger.info(f"Stopped job {job_id}")
    print(f"{yellow(f'Stopped job {job_id}')}")
    return JSONResponse(content={"message": f"Job {job_id} stopped"})

@app.get("/videos")
async def get_videos(api_key: str = Depends(verify_api_key)):
    try:
        videos = [f for f in os.listdir(VIDEO_OUTPUT_DIR) if f.lower().endswith(".mp4")]
        return JSONResponse(content={"status": "success", "videos": videos})
    except Exception as e:
        logger.error(f"Failed to list videos: {e}", exc_info=True)
        return JSONResponse(content={"error": str(e), "status": "error"}, status_code=500)

@app.post("/generate")
async def generate_video(
    image_file: UploadFile = File(...),
    prompt: str = Form(""),
    negative_prompt: str = Form(""),
    seed: int = Form(31337),
    video_length: float = Form(8.0),
    latent_window: int = Form(3),
    steps: int = Form(12),
    cfg: float = Form(1.0),
    distilled_cfg: float = Form(7.0),
    cfg_rescale: float = Form(0.5),
    gpu_keep: float = Form(6.0),
    crf: int = Form(20),
    use_teacache: bool = Form(True),
    camera_action: str = Form("Static Camera"),
    disable_prompt_mods: bool = Form(False),
    link_steps_window: bool = Form(True),
    api_key: str = Depends(verify_api_key)
):
    params = {
        "prompt": prompt,
        "negative_prompt": negative_prompt,
        "seed": seed,
        "video_length": video_length,
        "latent_window": latent_window,
        "steps": steps,
        "cfg": cfg,
        "distilled_cfg": distilled_cfg,
        "cfg_rescale": cfg_rescale,
        "gpu_keep": gpu_keep,
        "crf": crf,
        "use_teacache": use_teacache,
        "camera_action": camera_action,
        "disable_prompt_mods": disable_prompt_mods,
        "link_steps_window": link_steps_window
    }
    logger.info(f"Received /generate request with parameters: {json.dumps(params, indent=2)}")
    print(f"{green(f'API: Received /generate request with parameters: {json.dumps(params, indent=2)}')}")

    if not render_on_off:
        logger.info("Render disabled by client")
        print(f"{red('API: Render disabled by client')}")
        return JSONResponse(content={"status": "render_disabled", "error": "Rendering disabled"}, status_code=403)

    jid = str(uuid.uuid4())
    logger.info(f"Starting job {jid} with prompt: {prompt}")
    print(f"{green(f'API: Starting job ID: {jid}')}")

    stream = AsyncStream()
    active_jobs[jid] = stream
    job_status[jid] = {"status": "rendering", "progress": 0.0, "render_time": 0}

    try:
        logger.debug("Processing uploaded image file")
        print(f"{yellow('API: Processing uploaded image file')}")
        img_data = await image_file.read()
        if not img_data:
            logger.error("Empty image file")
            print(f"{red('API: Empty image file')}")
            raise HTTPException(status_code=400, detail="Empty image file")

        try:
            img = Image.open(io.BytesIO(img_data)).convert('RGB')
            img_np = np.array(img)
            if img_np.shape[0] < 64 or img_np.shape[1] < 64:
                logger.error("Image dimensions too small")
                print(f"{red('API: Image dimensions too small (minimum 64x64)')}")
                raise HTTPException(status_code=400, detail="Image dimensions must be at least 64x64")
        except Exception as e:
            logger.error(f"Invalid image: {str(e)}")
            print(f"{red(f'API: Invalid image: {str(e)}')}")
            raise HTTPException(status_code=400, detail=f"Invalid image: {str(e)}")

        if get_cuda_free_memory_gb(gpu) < 2:
            logger.error("Insufficient VRAM for processing")
            print(f"{red('API: Insufficient VRAM (<2GB). Lower gpu_keep or latent_window.')}")
            raise HTTPException(status_code=500, detail="Low VRAM (<2GB). Lower 'gpu_keep' or 'latent_window'.")

        logger.info(f"Passing to worker: seed={seed}, video_length={video_length}, latent_window={latent_window}, steps={steps}, cfg={cfg}, distilled_cfg={distilled_cfg}")
        print(f"{yellow(f'API: Passing to worker: seed={seed}, video_length={video_length}, latent_window={latent_window}, steps={steps}, cfg={cfg}, distilled_cfg={distilled_cfg}')}")

        final_video_path = worker(
            img_np=img_np,
            prompt=prompt,
            negative_prompt=negative_prompt,
            seed=seed,
            secs=video_length,
            win=latent_window,
            stp=steps,
            cfg=cfg,
            gsc=distilled_cfg,
            rsc=cfg_rescale,
            keep=gpu_keep,
            tea=use_teacache,
            crf=crf,
            camera_action=camera_action,
            disable_prompt_mods=disable_prompt_mods,
            link_steps_window=link_steps_window,
            stream=stream,
            jid=jid
        )

        if final_video_path is None:
            logger.error("Render stopped or failed")
            print(f"{red('API: Render stopped or failed')}")
            raise HTTPException(status_code=500, detail="Render stopped or failed")

        final_filename = os.path.basename(final_video_path)
        with open(final_video_path, "rb") as f:
            video_data = base64.b64encode(f.read()).decode("utf-8")

        save_video_info(
            prompt=prompt,
            n_p=negative_prompt,
            filename=final_filename,
            seed=seed,
            secs=video_length,
            additional_info={"camera_action": camera_action, "job_id": jid},
            completed=True
        )

        response_info = {
            "status": "success",
            "job_id": jid,
            "video_data": video_data,
            "metadata": {
                "prompt": prompt,
                "negative_prompt": negative_prompt,
                "seed": seed,
                "duration_secs": video_length,
                "timestamp": time.strftime("%Y%m%d_%H%M%S"),
                "render_time_secs": job_status[jid]["render_time"],
                "camera_action": camera_action,
                "latent_window": latent_window,
                "steps": steps,
                "cfg": cfg,
                "distilled_cfg": distilled_cfg,
                "cfg_rescale": cfg_rescale,
                "gpu_keep": gpu_keep,
                "crf": crf,
                "use_teacache": use_teacache,
                "disable_prompt_mods": disable_prompt_mods,
                "link_steps_window": link_steps_window
            }
        }

        logger.info(f"Video generated: {final_video_path}")
        print(f"{green(f'API: Video generated: {final_video_path}')}")
        return JSONResponse(content=response_info)

    except Exception as e:
        logger.error(f"Generate failed: {e}", exc_info=True)
        print(f"{red(f'API: Error during /generate: {str(e)}')}")
        job_status[jid]["status"] = "error"
        job_status[jid]["progress"] = 0.0
        stream.output_queue.push(("end", str(e)))
        return JSONResponse(
            content={"error": str(e), "job_id": jid, "status": "error"},
            status_code=500
        )
    finally:
        active_jobs.pop(jid, None)
        clear_queue(stream.input_queue)
        clear_queue(stream.output_queue)
        if job_status.get(jid, {}).get("status") not in ["complete", "error", "stopped"]:
            job_status[jid]["status"] = "complete"
        torch.cuda.empty_cache()

@torch.no_grad()
def worker(img_np, prompt, negative_prompt, seed, secs, win, stp, cfg, gsc, rsc, keep, tea, crf, camera_action, disable_prompt_mods, link_steps_window, stream, jid):
    start_time = time.time()
    job_status[jid] = {"status": "rendering", "progress": 0.0, "render_time": 0}
    max_sections = 100

    logger.info(f"Worker started for job {jid} with secs={secs}, win={win}, cfg={cfg}, distilled_cfg={gsc}")
    print(f"{green(f'API: Starting video generation, job ID: {jid}, secs={secs}, win={win}, cfg={cfg}, distilled_cfg={gsc}')}")

    try:
        if img_np.shape[0] < 64 or img_np.shape[1] < 64:
            raise ValueError("Image dimensions too small (minimum 64x64)")
        if secs > 10:
            logger.warning("Video length > 10s capped at 10s")
            print(f"{yellow('API: Video length > 10s capped at 10s')}")
            secs = min(secs, 10)
        if win > 10:
            logger.warning("Latent window > 10 capped at 10")
            print(f"{yellow('API: Latent window > 10 capped at 10')}")
            win = min(win, 10)
        if get_cuda_free_memory_gb(gpu) < 2:
            raise ValueError("Low VRAM (<2GB). Lower 'gpu_keep' or 'latent_window'.")

        try:
            if hasattr(stream.input_queue, "qsize") and stream.input_queue.qsize() > 0:
                if stream.input_queue.get_nowait() == "end":
                    stream.output_queue.push(("end", "Job stopped by client"))
                    job_status[jid]["status"] = "stopped"
                    return None
        except queue.Empty:
            pass

        if not disable_prompt_mods:
            if "stop" not in prompt.lower() and secs > 3:
                prompt += " The subject stops moving after 3 seconds."
            if "smooth" not in prompt.lower():
                prompt = f"Smooth animation: {prompt}"
            if "silent" not in prompt.lower():
                prompt += ", silent"
            prompt = update_prompt(prompt, camera_action)
        if len(prompt.split()) > 50:
            logger.warning("Complex prompt may slow rendering")
            print(f"{yellow('API: Warning: Complex prompt may slow rendering')}")

        try:
            with open(PROMPT_LOG_FILE, "a") as f:
                f.write(f"{jid}\t{prompt}\t{negative_prompt}\n")
            os.chmod(PROMPT_LOG_FILE, 0o664)
        except Exception as e:
            logger.error(f"Failed to write to {PROMPT_LOG_FILE}: {e}")
            print(f"{red(f'API: Failed to write prompt log: {e}')}")
            raise

        stream.output_queue.push(('progress', (None, "", make_progress_bar_html(0, "Start"))))

        if not hv:
            unload_complete_models(text_encoder, text_encoder_2, image_encoder, vae, transformer)
            fake_diffusers_current_device(text_encoder, gpu)
            load_model_as_complete(text_encoder_2, gpu)
        lv, cp = encode_prompt_conds(prompt, text_encoder, text_encoder_2, tokenizer, tokenizer_2)
        if cfg == 1:
            lv_n = torch.zeros_like(lv)
            cp_n = torch.zeros_like(cp)
        else:
            lv_n, cp_n = encode_prompt_conds(negative_prompt, text_encoder, text_encoder_2, tokenizer, tokenizer_2)
        lv, m = crop_or_pad_yield_mask(lv, 512)
        lv_n, m_n = crop_or_pad_yield_mask(lv_n, 512)
        lv, cp, lv_n, cp_n = [x.to(torch.bfloat16) for x in (lv, cp, lv_n, cp_n)]
        logger.debug(f"Prompt embeddings: lv={lv.shape}, cp={cp.shape}, lv_n={lv_n.shape}, cp_n={cp_n.shape}")
        torch.cuda.empty_cache()

        H, W, _ = img_np.shape
        h, w = H, W
        img_filename = f"{jid}.png"
        try:
            Image.fromarray(img_np).save(os.path.join(VIDEO_IMG_DIR, img_filename))
            os.chmod(os.path.join(VIDEO_IMG_DIR, img_filename), 0o664)
        except Exception as e:
            logger.error(f"Failed to save image {img_filename}: {e}")
            print(f"{red(f'API: Failed to save image: {e}')}")
            raise

        img_pt = (torch.from_numpy(img_np).float() / 127.5 - 1).permute(2, 0, 1)[None, :, None]
        logger.debug(f"Image tensor shape: {img_pt.shape}")

        if not hv:
            load_model_as_complete(vae, gpu)
        start_lat = vae_encode(img_pt, vae)
        logger.debug(f"VAE encoded latent shape: {start_lat.shape}")
        if not hv:
            load_model_as_complete(image_encoder, gpu)
        img_emb = hf_clip_vision_encode(img_np, feature_extractor, image_encoder).last_hidden_state.to(torch.bfloat16)
        logger.debug(f"Image embedding shape: {img_emb.shape}")
        torch.cuda.empty_cache()

        gen = torch.Generator("cpu").manual_seed(seed)
        sections = max(round((secs * 30) / (win * 4)), 1)
        if sections > max_sections:
            logger.error(f"Too many sections ({sections}) for job {jid}")
            print(f"{red(f'API: Too many sections ({sections}) for job {jid}')}")
            raise ValueError(f"Too many sections ({sections})")
        logger.info(f"Job {jid} sections: {sections}, pad_seq: {[3] + [2] * (sections - 3) + [1, 0] if sections > 4 else list(reversed(range(sections)))}")
        hist_lat = torch.zeros((1, 16, 1 + 2 + 16, h // 8, w // 8), dtype=torch.float16).cpu()
        hist_px = None
        total = 0
        pad_seq = [3] + [2] * (sections - 3) + [1, 0] if sections > 4 else list(reversed(range(sections)))
        section_count = 0
        for pad in pad_seq:
            section_count += 1
            if section_count > max_sections:
                logger.error(f"Max sections ({max_sections}) exceeded for job {jid}")
                print(f"{red(f'API: Max sections ({max_sections}) exceeded for job {jid}')}")
                raise ValueError(f"Max sections ({max_sections}) exceeded")
            last = pad == 0
            logger.info(f"Job {jid} processing pad: {pad}, last: {last}")

            def cb(d):
                if job_status[jid]["status"] == "complete":
                    return
                pv = vae_decode_fake(d["denoised"])
                pv = (pv * 255).cpu().numpy().clip(0, 255).astype(np.uint8)
                pv = einops.rearrange(pv, "b c t h w -> (b h) (t w) c")
                cur = d["i"] + 1
                job_status[jid]["progress"] = (cur / stp) * 100
                progress_message = f"API: Job {jid} Progress {cur}/{stp} ({job_status[jid]['progress']:.1f}%)"
                logger.info(progress_message)
                print(yellow(progress_message))
                stream.output_queue.push(('progress', (pv, f"{cur}/{stp}", make_progress_bar_html(int(100 * cur / stp), f"{cur}/{stp}"))))
                try:
                    if hasattr(stream.input_queue, "qsize") and stream.input_queue.qsize() > 0:
                        if stream.input_queue.get_nowait() == "end":
                            stream.output_queue.push(("end", "Job stopped by client"))
                            raise KeyboardInterrupt
                except queue.Empty:
                    pass

            idx = torch.arange(0, sum([1, pad * win, win, 1, 2, 16]))[None].to(device=gpu)
            a, b, c, d, e, f = idx.split([1, pad * win, win, 1, 2, 16], 1)
            clean_idx = torch.cat([a, d], 1)
            pre = start_lat.to(hist_lat)
            post, two, four = hist_lat[:, :, :1 + 2 + 16].split([1, 2, 16], 2)
            clean = torch.cat([pre, post], 2)
            if not hv:
                unload_complete_models()
                move_model_to_device_with_memory_preservation(transformer, gpu, keep)
            transformer.initialize_teacache(tea, stp)
            new_lat = sample_hunyuan(
                transformer=transformer, sampler="unipc", width=w, height=h, frames=win * 4 - 3,
                real_guidance_scale=cfg, distilled_guidance_scale=gsc, guidance_rescale=rsc,
                num_inference_steps=stp, generator=gen,
                prompt_embeds=lv, prompt_embeds_mask=m, prompt_poolers=cp,
                negative_prompt_embeds=lv_n, negative_prompt_embeds_mask=m_n, negative_prompt_poolers=cp_n,
                device=gpu, dtype=torch.bfloat16, image_embeddings=img_emb,
                latent_indices=c, clean_latents=clean, clean_latent_indices=clean_idx,
                clean_latents_2x=two, clean_latent_2x_indices=e,
                clean_latents_4x=four, clean_latent_4x_indices=f, callback=cb
            )
            if last:
                new_lat = torch.cat([start_lat.to(new_lat), new_lat], 2)
            total += new_lat.shape[2]
            hist_lat = torch.cat([new_lat.to(hist_lat), hist_lat], 2)
            if not hv:
                offload_model_from_device_for_memory_preservation(transformer, gpu, 8)
                load_model_as_complete(vae, gpu)
            real = hist_lat[:, :, :total]
            if hist_px is None:
                hist_px = vae_decode(real, vae).cpu()
            else:
                overlap = win * 4 - 3
                curr = vae_decode(real[:, :, :win * 2], vae).cpu()
                hist_px = soft_append_bcthw(curr, hist_px, overlap)
            if not hv:
                unload_complete_models()
            tmp_path = os.path.join(VIDEO_TMP_DIR, f"{jid}_{total}.mp4")
            save_bcthw_as_mp4(hist_px, tmp_path, fps=30, crf=crf)
            os.chmod(tmp_path, 0o664)
            stream.output_queue.push(('file', tmp_path))
            if last:
                fin_path = os.path.join(VIDEO_OUTPUT_DIR, f"{jid}_{total}.mp4")
                try:
                    os.replace(tmp_path, fin_path)
                    os.chmod(fin_path, 0o664)
                    job_status[jid]["status"] = "complete"
                    job_status[jid]["render_time"] = time.time() - start_time
                    stream.output_queue.push(('complete', fin_path))
                    clear_queue(stream.input_queue)
                    clear_queue(stream.output_queue)
                    logger.info(f"Final video saved: {fin_path}, render time: {job_status[jid]['render_time']:.2f}s")
                    print(f"{green(f'API: Final video saved: {fin_path}')}")
                    return fin_path
                except Exception as e:
                    logger.error(f"Failed to save final video: {e}")
                    print(f"{red(f'API: Failed to save final video: {e}')}")
                    raise
            torch.cuda.empty_cache()
    except Exception as e:
        logger.error(f"Worker failed: {e}", exc_info=True)
        print(f"{red(f'API: Worker error: {e}')}")
        traceback.print_exc()
        job_status[jid]["status"] = "error"
        stream.output_queue.push(("end", str(e)))
        return None
    finally:
        if jid in active_jobs:
            active_jobs.pop(jid, None)
        clear_queue(stream.input_queue)
        clear_queue(stream.output_queue)
        if job_status.get(jid, {}).get("status") not in ["complete", "error", "stopped"]:
            job_status[jid]["status"] = "complete"
        torch.cuda.empty_cache()

@torch.no_grad()
def process(img, prm, npr, sd, sec, win, stp, cfg, gsc, rsc, kee, tea, crf, disable_prompt_mods, link_steps_window):
    if img is None:
        raise gr.Error("Upload an image")
    yield None, None, "", "", gr.update(interactive=False), gr.update(interactive=True)
    stream = AsyncStream()
    jid = str(uuid.uuid4())
    async_run(worker, img, prm, npr, sd, sec, win, stp, cfg, gsc, rsc, kee, tea, crf, disable_prompt_mods, link_steps_window, stream, jid)
    out, log = None, ""
    try:
        while True:
            flag, data = stream.output_queue.next()
            if job_status.get(jid, {}).get("status") == "complete":
                break
            if flag == "file":
                out = data
                yield out, gr.update(), gr.update(), log, gr.update(interactive=False), gr.update(interactive=True)
            if flag == "progress":
                pv, desc, html = data
                log = desc
                yield gr.update(), gr.update(visible=True, value=pv), desc, html, gr.update(interactive=False), gr.update(interactive=True)
            if flag == "complete":
                yield data, gr.update(visible=False), "Generation complete", "", gr.update(interactive=True), gr.update(interactive=False)
                break
            if flag == "end":
                yield out, gr.update(visible=False), f"Error: {data}", "", gr.update(interactive=True), gr.update(interactive=False)
                break
    except Exception as e:
        logger.error(f"Process loop failed: {e}")
        yield out, gr.update(visible=False), f"Error: {str(e)}", "", gr.update(interactive=True), gr.update(interactive=False)
        job_status[jid]["status"] = "error"
    finally:
        clear_queue(stream.input_queue)
        clear_queue(stream.output_queue)
        torch.cuda.empty_cache()

def end_process():
    global stream
    if stream:
        stream.input_queue.push("end")
        logger.info("Gradio: Render stop requested")
        print(f"{red('Gradio: Render stop requested')}")

# Gradio UI (same as original)
quick_prompts = [
    ["Smooth animation: A character waves for 3 seconds, then stands still for 2 seconds, static camera, silent."],
    ["Smooth animation: A character moves for 5 seconds, static camera, silent."]
]
css = make_progress_bar_css() + """
.orange-button{background:#ff6200;color:#fff;border-color:#ff6200;}
.load-button{background:#4CAF50;color:#fff;border-color:#4CAF50;margin-left:10px;}
.big-setting-button{background:#0066cc;color:#fff;border:none;padding:14px 24px;font-size:18px;width:100%;border-radius:6px;margin:8px 0;}
.styled-dropdown{width:250px;padding:5px;border-radius:4px;}
.viewer-column{width:100%;max-width:900px;margin:0 auto;}
.media-preview img,.media-preview video{max-width:100%;height:380px;object-fit:contain;border:1px solid #444;border-radius:6px;}
.media-container{display:flex;gap:20px;align-items:flex-start;}
.control-box{min-width:220px;}
.control-grid{display:grid;grid-template-columns:1fr 1fr;gap:10px;}
.image-gallery{display:grid!important;grid-template-columns:repeat(auto-fit,minmax(300px,1fr))!important;gap:10px;padding:10px!important;overflow-y:auto!important;max-height:360px!important;}
.image-gallery .gallery-item{padding:10px;height:360px!important;width:300px!important;}
.image-gallery img{object-fit:contain;height:360px!important;width:300px!important;}
.video-gallery{display:grid!important;grid-template-columns:repeat(auto-fit,minmax(300px,1fr))!important;gap:10px;padding:10px!important;overflow-y:auto!important;max-height:360px!important;}
.video-gallery .gallery-item{padding:10px;height:360px!important;width:300px!important;}
.video-gallery video{object-fit:contain;height:360px!important;width:300px!important;}
.stop-button {background-color: #ff4d4d !important; color: white !important;}
"""

blk = gr.Blocks(css=css, title="GhostPack F1 Pro").queue()
with blk:
    gr.Markdown("# 👻 GhostPack F1 Pro")
    with gr.Tabs():
        with gr.TabItem("👻 Generate"):
            with gr.Row():
                with gr.Column():
                    img_in = gr.Image(sources="upload", type="numpy", label="Image", height=320)
                    generate_button = gr.Button("Generate Video", elem_id="generate_button")
                    stop_button = gr.Button("Stop Generation", elem_id="stop_button", elem_classes="stop-button")
                    prm = gr.Textbox(
                        label="Prompt",
                        value="Smooth animation: A female stands with subtle, sensual micro-movements, breathing gently, slight head tilt, static camera, silent",
                        elem_id="prompt_input",
                    )
                    npr = gr.Textbox(
                        label="Negative Prompt",
                        value="low quality, blurry, speaking, talking, moaning, vocalizing, lip movement, mouth animation, sound, dialogue, speech, whispering, shouting, lip sync, facial animation, expressive face, verbal expression, animated mouth",
                        elem_id="negative_prompt_input",
                    )
                    save_msg = gr.Markdown("")
                    disable_prompt_mods = gr.Checkbox(label="Disable Prompt Modifications", value=False)
                    link_steps_window = gr.Checkbox(label="Link Steps and Latent Window", value=True)
                    btn_save = gr.Button("Save Prompt")
                    btn1, btn2, btn3 = (
                        gr.Button("Load Most Recent"),
                        gr.Button("Load 2nd Recent"),
                        gr.Button("Load 3rd Recent"),
                    )
                    ds = gr.Dataset(samples=quick_prompts, label="Quick List", components=[prm])
                    ds.click(lambda x: x[0], [ds], [prm])
                    btn_save.click(save_prompt_fn, [prm, npr], [save_msg])
                    btn1.click(lambda: load_prompt_fn(0), [], [prm])
                    btn2.click(lambda: load_prompt_fn(1), [], [prm])
                    btn3.click(lambda: load_prompt_fn(2), [], [prm])
                    camera_action_input = gr.Dropdown(
                        choices=[
                            "Static Camera", "Slight Orbit Left", "Slight Orbit Right",
                            "Slight Orbit Up", "Slight Orbit Down", "Top-Down View",
                            "Slight Zoom In", "Slight Zoom Out",
                        ],
                        label="Camera Action",
                        value="Static Camera",
                        elem_id="camera_action_input",
                        info="Select a camera movement to append to the prompt.",
                    )
                    camera_action_input.change(
                        fn=lambda prompt, camera_action: update_prompt(prompt, camera_action),
                        inputs=[prm, camera_action_input],
                        outputs=prm,
                    )
                with gr.Column():
                    pv = gr.Image(label="Next Latents", height=200, visible=False)
                    vid = gr.Video(label="Finished", autoplay=True, height=500, loop=True, show_share_button=False)
                    log_md = gr.Markdown("")
                    bar = gr.HTML("")
            with gr.Column():
                se = gr.Number(label="Seed", value=31337, precision=0, elem_id="seed_input")
                sec = gr.Slider(label="Video Length (s)", minimum=1, maximum=10, value=8.0, step=0.1, elem_id="video_length_input")
                win = gr.Slider(label="Latent Window", minimum=1, maximum=10, value=3, step=1, elem_id="latent_window_input")
                stp = gr.Slider(label="Steps", minimum=1, maximum=100, value=12, step=1, elem_id="steps_input")
                cfg = gr.Slider(label="CFG", minimum=1, maximum=32, value=1.7, step=0.01, elem_id="cfg_input")
                gsc = gr.Slider(label="Distilled CFG", minimum=1, maximum=32, value=4.0, step=0.01, elem_id="distilled_cfg_input")
                rsc = gr.Slider(label="CFG Re-Scale", minimum=0, maximum=1, value=0.5, step=0.01, elem_id="cfg_rescale_input")
                kee = gr.Slider(label="GPU Keep (GB)", minimum=6, maximum=free_mem, value=6.5, step=0.1, elem_id="gpu_keep_input")
                crf = gr.Slider(label="MP4 CRF", minimum=0, maximum=100, value=20, step=1, elem_id="mp4_crf_input")
                tea = gr.Checkbox(label="Use TeaCache", value=True, elem_id="use_teacache_input")
            generate_button.click(
                fn=process,
                inputs=[img_in, prm, npr, se, sec, win, stp, cfg, gsc, rsc, kee, tea, crf, disable_prompt_mods, link_steps_window],
                outputs=[vid, pv, log_md, bar, generate_button, stop_button],
            )
            stop_button.click(fn=end_process)
            gr.Button("Update Progress").click(fn=lambda: get_progress(), outputs=[log_md, bar])

        with gr.TabItem("🖼️ Image Gallery"):
            with gr.Row(elem_classes="media-container"):
                with gr.Column(scale=3):
                    image_preview = gr.Image(
                        label="Viewer", value=(list_images()[0] if list_images() else None),
                        interactive=False, elem_classes="media-preview",
                    )
                with gr.Column(elem_classes="control-box"):
                    image_dropdown = gr.Dropdown(
                        choices=[os.path.basename(i) for i in list_images()],
                        value=(os.path.basename(list_images()[0]) if list_images() else None),
                        label="Select", elem_classes="styled-dropdown",
                    )
                    with gr.Row(elem_classes="control-grid"):
                        load_btn = gr.Button("Load", elem_classes="load-button")
                        next_btn = gr.Button("Next", elem_classes="load-button")
                    with gr.Row(elem_classes="control-grid"):
                        refresh_btn = gr.Button("Refresh")
                        delete_btn = gr.Button("Delete", elem_classes="orange-button")
            image_gallery = gr.Gallery(
                value=list_images(), label="Thumbnails", columns=6, height=360,
                allow_preview=False, type="filepath", elem_classes="image-gallery",
            )
            load_btn.click(load_image, [image_dropdown], [image_preview, image_dropdown])
            next_btn.click(next_image_and_load, [image_dropdown], [image_preview, image_dropdown])
            refresh_btn.click(
                lambda: (
                    gr.update(choices=[os.path.basename(i) for i in list_images()], value=os.path.basename(list_images()[0]) if list_images() else None),
                    gr.update(value=list_images()[0] if list_images() else None),
                    gr.update(value=list_images()),
                ),
                [], [image_dropdown, image_preview, image_gallery],
            )
            delete_btn.click(
                lambda sel: (
                    os.remove(os.path.join(VIDEO_IMG_DIR, sel)) if sel and os.path.exists(os.path.join(VIDEO_IMG_DIR, sel)) else None
                ) or load_image(""),
                [image_dropdown], [image_preview, image_dropdown],
            )
            image_gallery.select(gallery_image_select, [], [image_preview, image_dropdown])

        with gr.TabItem("🎬 Video Gallery"):
            with gr.Row(elem_classes="media-container"):
                with gr.Column(scale=3):
                    video_preview = gr.Video(
                        label="Viewer", value=(list_videos()[0] if list_videos() else None),
                        autoplay=True, loop=True, interactive=False, elem_classes="media-preview",
                    )
                with gr.Column(elem_classes="control-box"):
                    video_dropdown = gr.Dropdown(
                        choices=[os.path.basename(v) for v in list_videos()],
                        value=(os.path.basename(list_videos()[0]) if list_videos() else None),
                        label="Select", elem_classes="styled-dropdown",
                    )
                    with gr.Row(elem_classes="control-grid"):
                        load_vbtn = gr.Button("Load", elem_classes="load-button")
                        next_vbtn = gr.Button("Next", elem_classes="load-button")
                    with gr.Row(elem_classes="control-grid"):
                        refresh_v = gr.Button("Refresh")
                        delete_v = gr.Button("Delete", elem_classes="orange-button")
            video_gallery = gr.Gallery(
                value=list_videos(), label="Thumbnails", columns=6, height=360,
                allow_preview=False, type="filepath", elem_classes="video-gallery",
            )
            load_vbtn.click(load_video, [video_dropdown], [video_preview, video_dropdown])
            next_vbtn.click(next_video_and_load, [video_dropdown], [video_preview, video_dropdown])
            refresh_v.click(
                lambda: (
                    gr.update(choices=[os.path.basename(v) for v in list_videos()], value=os.path.basename(list_videos()[0]) if list_videos() else None),
                    gr.update(value=list_videos()[0] if list_videos() else None),
                    gr.update(value=list_videos()),
                ),
                [], [video_dropdown, video_preview, video_gallery],
            )
            delete_v.click(
                lambda sel: (
                    os.remove(os.path.join(VIDEO_OUTPUT_DIR, sel)) if sel and os.path.exists(os.path.join(VIDEO_OUTPUT_DIR, sel)) else None
                ) or load_video(""),
                [video_dropdown], [video_preview, video_dropdown],
            )
            video_gallery.select(gallery_video_select, [], [video_preview, video_dropdown])

        with gr.TabItem("👻 About"):
            gr.Markdown("## GhostPack F1 Pro")
            with gr.Row():
                with gr.Column():
                    gr.Markdown("**🛠️ Description**\nImage-to-Video toolkit powered by HunyuanVideo & FramePack-F1")
                with gr.Column():
                    gr.Markdown(f"**📦 Version**\n{VERSION}")
                with gr.Column():
                    gr.Markdown("**✍️ Author**\nGhostAI")
                with gr.Column():
                    gr.Markdown("**🔗 Repo**\nhttps://huggingface.co/spaces/ghostai1/GhostPack")

        with gr.TabItem("⚙️ Settings"):
            ct = gr.Button("Clear Temp", elem_classes="big-setting-button")
            ctmsg = gr.Markdown("")
            co = gr.Button("Clear Old", elem_classes="big-setting-button")
            comsg = gr.Markdown("")
            ci = gr.Button("Clear Images", elem_classes="big-setting-button")
            cimg = gr.Markdown("")
            cv = gr.Button("Clear Videos", elem_classes="big-setting-button")
            cvid = gr.Markdown("")
            ct.click(clear_temp_videos, [], ctmsg)
            co.click(clear_old_files, [], comsg)
            ci.click(clear_images, [], cimg)
            cv.click(clear_videos, [], cvid)

        with gr.TabItem("🛠️ Install"):
            xs = gr.Textbox(value=status_xformers(), interactive=False, label="xformers")
            bx = gr.Button("Install xformers", elem_classes="big-setting-button")
            ss = gr.Textbox(value=status_sage(), interactive=False, label="sage-attn")
            bs = gr.Button("Install sage-attn", elem_classes="big-setting-button")
            fs = gr.Textbox(value=status_flash(), interactive=False, label="flash-attn")
            bf = gr.Button("Install flash-attn", elem_classes="big-setting-button")
            cs = gr.Textbox(value=status_colorama(), interactive=False, label="colorama")
            bc = gr.Button("Install colorama", elem_classes="big-setting-button")
            bx.click(install_xformers, [], xs)
            bs.click(install_sage_attn, [], ss)
            bf.click(install_flash_attn, [], fs)
            bc.click(install_colorama, [], cs)

        with gr.TabItem("📜 Logs"):
            logs = gr.Textbox(lines=20, interactive=False, label="Install Logs")
            rl = gr.Button("Refresh", elem_classes="big-setting-button")
            cl = gr.Button("Clear", elem_classes="big-setting-button")
            rl.click(refresh_logs, [], logs)
            cl.click(clear_logs, [], logs)

    gr.HTML(
        """
<script>
document.querySelectorAll('.video-gallery video').forEach(v => {
  v.addEventListener('loadedmetadata', () => {
    if (v.duration > 2) v.currentTime = 2;
  });
});
</script>
"""
    )

def update_prompt(prompt, camera_action):
    camera_actions = [
        "static camera", "slight camera orbit left", "slight camera orbit right",
        "slight camera orbit up", "slight camera orbit down", "top-down view",
        "slight camera zoom in", "slight camera zoom out",
    ]
    for action in camera_actions:
        prompt = re.sub(rf",\s*{re.escape(action)}\b", "", prompt, flags=re.IGNORECASE).strip()
    if camera_action and camera_action != "None":
        camera_phrase = f", {camera_action.lower()}"
        if len(prompt.split()) + len(camera_phrase.split()) <= 50:
            return prompt + camera_phrase
        else:
            logger.warning(f"Prompt exceeds 50 words after adding camera action: {prompt}")
            print(f"{yellow(f'API: Warning: Prompt exceeds 50 words with camera action')}")
    return prompt

def get_progress():
    return f"Status: {job_status.get('latest', {'status': 'idle'})['status']}\nProgress: {job_status.get('latest', {'progress': 0.0})['progress']:.1f}%\nLast Render Time: {job_status.get('latest', {'render_time': 0})['render_time']:.1f}s"

# Check for port conflicts
if is_port_in_use(args.port):
    logger.error(f"Port {args.port} is already in use")
    print(f"{red(f'Error: Port {args.port} is already in use. Please stop other instances or change ports.')}")
    sys.exit(1)

# Run FastAPI and optional Gradio
def run_api():
    try:
        logger.info(f"Starting FastAPI on {args.server}:{args.port}")
        print(f"{green(f'Starting FastAPI on {args.server}:{args.port}')}")
        uvicorn.run(app, host=args.server, port=args.port)
    except Exception as e:
        logger.error(f"Failed to start FastAPI: {e}", exc_info=True)
        print(f"{red(f'Error: Failed to start FastAPI: {e}')}")
        sys.exit(1)

if __name__ == "__main__":
    try:
        logger.info(f"Starting GhostPack F1 Pro Server version {VERSION}")
        print(f"Starting GhostPack F1 Pro Server version {VERSION}")
        api_thread = Thread(target=run_api)
        api_thread.daemon = True
        api_thread.start()
        time.sleep(5)
        try:
            response = requests.get(f"http://{args.server}:{args.port}/health", timeout=10)
            if response.status_code != 200:
                raise RuntimeError("FastAPI health check failed")
            logger.info("FastAPI health check passed")
            print(f"{green('FastAPI health check passed')}")
        except Exception as e:
            logger.error(f"FastAPI not ready: {e}")
            print(f"{red(f'Error: FastAPI not ready: {e}')}")
            sys.exit(1)

        if args.gradio:
            logger.info(f"Starting Gradio UI on {args.server}:7860")
            print(f"{green(f'Starting Gradio UI on {args.server}:7860')}")
            server = blk.launch(
                server_name=args.server,
                server_port=7860,
                share=args.share,
                inbrowser=args.inbrowser,
                prevent_thread_lock=True,
                allowed_paths=["/"]
            )
            if args.share and server.share_url:
                logger.info(f"Public Gradio URL: {server.share_url}")
                print(f"{yellow(f'Public Gradio URL: {server.share_url}')}")
            logger.info(f"Gradio UI running on http://{args.server}:7860")
            print(f"{green(f'Gradio UI running on http://{args.server}:7860')}")
        while True:
            time.sleep(1)
    except KeyboardInterrupt:
        logger.info("Shutting down gracefully")
        print(f"{green('Shutting down gracefully')}")
        sys.exit(0)