Upload 25 files

Dockerfile

@@ -0,0 +1,43 @@
+FROM nvidia/cuda:11.8.0-runtime-ubuntu22.04
+
+FROM python:3.11-slim-bullseye
+
+WORKDIR /app
+
+# Enable contrib and non-free repos, and install system dependencies
+RUN sed -i 's/main/main contrib non-free/' /etc/apt/sources.list && \
+    apt-get update && \
+    apt-get install -y --no-install-recommends \
+    unrar \
+    libgl1 \
+    libglib2.0-0 \
+    && rm -rf /var/lib/apt/lists/*
+
+
+ENV DEBIAN_FRONTEND=noninteractive
+
+# Python + dependencies
+RUN apt-get update && apt-get install -y python3 python3-pip git && \
+    pip3 install --upgrade pip
+
+# Set working dir
+WORKDIR /app
+
+# Copy and install requirements
+COPY requirements.txt ./
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy app code
+COPY . .
+
+# ybyjngamhtcuaupc gsmt
+
+# Make the entire /app directory fully writeable for all users
+RUN chmod -R 777 /app
+
+# Ensure the app runs as the same user as the Space UI
+RUN useradd -m -u 1000 user
+USER user
+
+# Launch FastAPI download server on container start
+CMD ["uvicorn", "download_api:app", "--host", "0.0.0.0", "--port", "7860"]

annotations/readme.md

@@ -0,0 +1 @@
+#Hi there

cursor_tracker.py

@@ -0,0 +1,601 @@
+import os
+import json
+import requests
+import subprocess
+import shutil
+import time
+import re
+import threading
+from typing import Dict, List, Set, Optional
+from huggingface_hub import HfApi, list_repo_files
+
+import cv2
+import numpy as np
+from pathlib import Path
+import smtplib
+from email.message import EmailMessage
+
+# ==== CONFIGURATION ====
+HF_TOKEN = os.getenv("HF_TOKEN", "")
+SOURCE_REPO_ID = os.getenv("SOURCE_REPO", "Fred808/BG1")
+
+# Path Configuration
+DOWNLOAD_FOLDER = "downloads"
+EXTRACT_FOLDER = "extracted"
+FRAMES_OUTPUT_FOLDER = "extracted_frames" # New folder for extracted frames
+CURSOR_TRACKING_OUTPUT_FOLDER = "cursor_tracking_results" # New folder for cursor tracking results
+CURSOR_TEMPLATES_DIR = "cursors"
+
+os.makedirs(DOWNLOAD_FOLDER, exist_ok=True)
+os.makedirs(EXTRACT_FOLDER, exist_ok=True)
+os.makedirs(FRAMES_OUTPUT_FOLDER, exist_ok=True)
+os.makedirs(CURSOR_TRACKING_OUTPUT_FOLDER, exist_ok=True)
+os.makedirs(CURSOR_TEMPLATES_DIR, exist_ok=True) # Ensure cursor templates directory exists
+
+# State Files
+DOWNLOAD_STATE_FILE = "download_progress.json"
+PROCESS_STATE_FILE = "process_progress.json"
+FAILED_FILES_LOG = "failed_files.log"
+
+# Processing Parameters
+CHUNK_SIZE = 1
+PROCESSING_DELAY = 2
+MAX_RETRIES = 3
+MIN_FREE_SPACE_GB = 2  # Minimum free space in GB before processing
+
+# Frame Extraction Parameters
+DEFAULT_FPS = 3 # Default frames per second for extraction
+
+# Cursor Tracking Parameters
+CURSOR_THRESHOLD = 0.8
+
+# Initialize HF API
+hf_api = HfApi(token=HF_TOKEN)
+
+# Global State
+processing_status = {
+    "is_running": False,
+    "current_file": None,
+    "total_files": 0,
+    "processed_files": 0,
+    "failed_files": 0,
+    "extracted_courses": 0,
+    "extracted_videos": 0,
+    "extracted_frames_count": 0,
+    "tracked_cursors_count": 0,
+    "last_update": None,
+    "logs": []
+}
+
+def log_message(message: str):
+    """Log messages with timestamp"""
+    timestamp = time.strftime("%Y-%m-%d %H:%M:%S")
+    log_entry = f"[{timestamp}] {message}"
+    print(log_entry)
+    processing_status["logs"].append(log_entry)
+    processing_status["last_update"] = timestamp
+    if len(processing_status["logs"]) > 100:
+        processing_status["logs"] = processing_status["logs"][-100:]
+
+def log_failed_file(filename: str, error: str):
+    """Log failed files to persistent file"""
+    with open(FAILED_FILES_LOG, "a") as f:
+        f.write(f"{time.strftime('%Y-%m-%d %H:%M:%S')} - {filename}: {error}\n")
+
+def get_disk_usage(path: str) -> Dict[str, float]:
+    """Get disk usage statistics in GB"""
+    statvfs = os.statvfs(path)
+    total = statvfs.f_frsize * statvfs.f_blocks / (1024**3)
+    free = statvfs.f_frsize * statvfs.f_bavail / (1024**3)
+    used = total - free
+    return {"total": total, "free": free, "used": used}
+
+def check_disk_space(path: str = ".") -> bool:
+    """Check if there's enough disk space"""
+    disk_info = get_disk_usage(path)
+    if disk_info["free"] < MIN_FREE_SPACE_GB:
+        log_message(f'⚠️ Low disk space: {disk_info["free"]:.2f}GB free, {disk_info["used"]:.2f}GB used')
+        return False
+    return True
+
+def cleanup_temp_files():
+    """Clean up temporary files to free space"""
+    log_message("🧹 Cleaning up temporary files...")
+    
+    # Clean old downloads (keep only current processing file)
+    current_file = processing_status.get("current_file")
+    for file in os.listdir(DOWNLOAD_FOLDER):
+        if file != current_file and file.endswith((".rar", ".zip")):
+            try:
+                os.remove(os.path.join(DOWNLOAD_FOLDER, file))
+                log_message(f"🗑️ Removed old download: {file}")
+            except:
+                pass
+
+def load_json_state(file_path: str, default_value):
+    """Load state from JSON file"""
+    if os.path.exists(file_path):
+        try:
+            with open(file_path, "r") as f:
+                return json.load(f)
+        except json.JSONDecodeError:
+            log_message(f"⚠️ Corrupted state file: {file_path}")
+    return default_value
+
+def save_json_state(file_path: str, data):
+    """Save state to JSON file"""
+    with open(file_path, "w") as f:
+        json.dump(data, f, indent=2)
+
+def download_with_retry(url: str, dest_path: str, max_retries: int = 3) -> bool:
+    """Download file with retry logic and disk space checking"""
+    if not check_disk_space():
+        cleanup_temp_files()
+        if not check_disk_space():
+            log_message("❌ Insufficient disk space even after cleanup")
+            return False
+    
+    headers = {"Authorization": f"Bearer {HF_TOKEN}"}
+    for attempt in range(max_retries):
+        try:
+            with requests.get(url, headers=headers, stream=True) as r:
+                r.raise_for_status()
+                
+                # Check content length if available
+                content_length = r.headers.get("content-length")
+                if content_length:
+                    size_gb = int(content_length) / (1024**3)
+                    disk_info = get_disk_usage(".")
+                    if size_gb > disk_info["free"] - 0.5:  # Leave 0.5GB buffer
+                        log_message(f'❌ File too large: {size_gb:.2f}GB, only {disk_info["free"]:.2f}GB free')
+                        return False
+                
+                with open(dest_path, "wb") as f:
+                    for chunk in r.iter_content(chunk_size=8192):
+                        f.write(chunk)
+            return True
+        except Exception as e:
+            if attempt < max_retries - 1:
+                time.sleep(2 ** attempt)
+                continue
+            log_message(f"❌ Download failed after {max_retries} attempts: {e}")
+            return False
+    return False
+
+def is_multipart_rar(filename: str) -> bool:
+    """Check if this is a multi-part RAR file"""
+    return ".part" in filename.lower() and filename.lower().endswith(".rar")
+
+def get_rar_part_base(filename: str) -> str:
+    """Get the base name for multi-part RAR files"""
+    if ".part" in filename.lower():
+        return filename.split(".part")[0]
+    return filename.replace(".rar", "")
+
+def extract_with_retry(rar_path: str, output_dir: str, max_retries: int = 2) -> bool:
+    """Extract RAR with retry and recovery, handling multi-part archives"""
+    filename = os.path.basename(rar_path)
+    
+    # For multi-part RARs, we need the first part
+    if is_multipart_rar(filename):
+        base_name = get_rar_part_base(filename)
+        first_part = f"{base_name}.part01.rar"
+        first_part_path = os.path.join(os.path.dirname(rar_path), first_part)
+        
+        if not os.path.exists(first_part_path):
+            log_message(f"⚠️ Multi-part RAR detected but first part not found: {first_part}")
+            return False
+        
+        rar_path = first_part_path
+        log_message(f"📦 Processing multi-part RAR starting with: {first_part}")
+    
+    for attempt in range(max_retries):
+        try:
+            # Test RAR first
+            test_cmd = ["unrar", "t", rar_path]
+            test_result = subprocess.run(test_cmd, capture_output=True, text=True)
+            if test_result.returncode != 0:
+                log_message(f"⚠️ RAR test failed: {test_result.stderr}")
+                if attempt == max_retries - 1:
+                    return False
+                continue
+            
+            # Extract RAR
+            cmd = ["unrar", "x", "-o+", rar_path, output_dir]
+            if attempt > 0:  # Try recovery on subsequent attempts
+                cmd.insert(2, "-kb")
+            
+            result = subprocess.run(cmd, capture_output=True, text=True)
+            if result.returncode == 0:
+                log_message(f"✅ Successfully extracted: {os.path.basename(rar_path)}")
+                return True
+            else:
+                error_msg = result.stderr or result.stdout
+                log_message(f"⚠️ Extraction attempt {attempt + 1} failed: {error_msg}")
+                
+                if "checksum error" in error_msg.lower() or "CRC failed" in error_msg:
+                    log_message(f"⚠️ Data corruption detected, attempt {attempt + 1}")
+                elif result.returncode == 10:
+                    log_message(f"⚠️ No files to extract (exit code 10)")
+                    return False
+                elif result.returncode == 1:
+                    log_message(f"⚠️ Non-fatal error (exit code 1)")
+                    
+        except Exception as e:
+            log_message(f"❌ Extraction exception: {str(e)}")
+            if attempt == max_retries - 1:
+                return False
+            time.sleep(1)
+    
+    return False
+        
+# --- Frame Extraction Utilities ---
+def ensure_dir(path):
+    os.makedirs(path, exist_ok=True)
+
+def extract_frames(video_path, output_dir, fps=DEFAULT_FPS):
+    """Extract frames from video at the specified frames per second (fps)."""
+    log_message(f"[INFO] Extracting frames from {video_path} to {output_dir} at {fps} fps...")
+    ensure_dir(output_dir)
+    cap = cv2.VideoCapture(str(video_path))
+    if not cap.isOpened():
+        log_message(f"[ERROR] Failed to open video file: {video_path}")
+        return 0
+    video_fps = cap.get(cv2.CAP_PROP_FPS)
+    # log_message(f"[DEBUG] Video FPS: {video_fps}")
+    if not video_fps or video_fps <= 0:
+        video_fps = 30  # fallback if FPS is not available
+        log_message(f"[WARN] Using fallback FPS: {video_fps}")
+    frame_interval = int(round(video_fps / fps))
+    # log_message(f"[DEBUG] Frame interval: {frame_interval}")
+    frame_idx = 0
+    saved_idx = 1
+    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
+    log_message(f"[DEBUG] Total frames in video: {total_frames}")
+    while cap.isOpened():
+        ret, frame = cap.read()
+        if not ret:
+            # log_message(f"[DEBUG] No more frames to read at frame_idx {frame_idx}.")
+            break
+        if frame_idx % frame_interval == 0:
+            frame_name = f"{saved_idx:04d}.png"
+            cv2.imwrite(str(Path(output_dir) / frame_name), frame)
+            # log_message(f"[DEBUG] Saved frame {frame_idx} as {frame_name}")
+            saved_idx += 1
+        frame_idx += 1
+    cap.release()
+    log_message(f"Extracted {saved_idx-1} frames from {video_path} to {output_dir}")
+    return saved_idx - 1
+
+# --- Cursor Tracking Utilities ---
+def to_rgb(img):
+    if img is None:
+        return None
+    if len(img.shape) == 2:
+        return cv2.cvtColor(img, cv2.COLOR_GRAY2BGR)
+    if img.shape[2] == 4:
+        return cv2.cvtColor(img, cv2.COLOR_BGRA2BGR)
+    return img
+
+def get_mask_from_alpha(template_img):
+    if template_img is not None and len(template_img.shape) == 3 and template_img.shape[2] == 4:
+        # Use alpha channel as mask (nonzero alpha = 255)
+        return (template_img[:, :, 3] > 0).astype(np.uint8) * 255
+    return None
+
+def detect_cursor_in_frame_multi(frame, cursor_templates, threshold=CURSOR_THRESHOLD):
+    """Detect cursor position in a frame using multiple templates. Returns best match above threshold."""
+    best_pos = None
+    best_conf = -1
+    best_template_name = None
+    frame_rgb = to_rgb(frame)
+    for template_name, cursor_template in cursor_templates.items():
+        template_rgb = to_rgb(cursor_template)
+        mask = get_mask_from_alpha(cursor_template)
+        if template_rgb is None or frame_rgb is None or template_rgb.shape[2] != frame_rgb.shape[2]:
+            log_message(f"[WARN] Skipping template {template_name} due to channel mismatch or load error.")
+            continue
+        try:
+            result = cv2.matchTemplate(frame_rgb, template_rgb, cv2.TM_CCOEFF_NORMED, mask=mask)
+        except Exception as e:
+            log_message(f"[WARN] matchTemplate failed for {template_name}: {e}")
+            continue
+        min_val, max_val, min_loc, max_loc = cv2.minMaxLoc(result)
+        if max_val > best_conf:
+            best_conf = max_val
+            if max_val >= threshold:
+                cursor_w, cursor_h = template_rgb.shape[1], template_rgb.shape[0]
+                cursor_x = max_loc[0] + cursor_w // 2
+                cursor_y = max_loc[1] + cursor_h // 2
+                best_pos = (cursor_x, cursor_y)
+                best_template_name = template_name
+    if best_conf >= threshold:
+        return best_pos, best_conf, best_template_name
+    return None, best_conf, None
+
+def send_email_with_attachment(subject, body, to_email, from_email, app_password, attachment_path):
+    msg = EmailMessage()
+    msg["Subject"] = subject
+    msg["From"] = from_email
+    msg["To"] = to_email
+    msg.set_content(body)
+    with open(attachment_path, "rb") as f:
+        file_data = f.read()
+        file_name = Path(attachment_path).name
+    msg.add_attachment(file_data, maintype="application", subtype="octet-stream", filename=file_name)
+    try:
+        with smtplib.SMTP_SSL("smtp.gmail.com", 465) as smtp:
+            smtp.login(from_email, app_password)
+            smtp.send_message(msg)
+        log_message(f"[SUCCESS] Email sent to {to_email}")
+    except Exception as e:
+        log_message(f"[ERROR] Failed to send email: {e}")
+
+def track_cursor(frames_dir, cursor_templates_dir, output_json_path, threshold=CURSOR_THRESHOLD, start_frame=1, email_results=False):
+    """Detect cursor in each frame using multiple templates, print status, and write positions to a JSON file."""
+    log_message(f"[INFO] Tracking cursors in {frames_dir}...")
+    frames_dir = Path(frames_dir).resolve()
+    output_json_path = Path(output_json_path).resolve()
+    cursor_templates_dir = Path(cursor_templates_dir).resolve()
+    # log_message(f"[DEBUG] frames_dir: {frames_dir}")
+    # log_message(f"[DEBUG] cursor_templates_dir: {cursor_templates_dir}")
+    # log_message(f"[DEBUG] output_json_path: {output_json_path}")
+    ensure_dir(frames_dir)
+    ensure_dir(output_json_path.parent)
+    # Load all PNG templates from the cursor_templates_dir
+    cursor_templates = {}
+    for template_file in cursor_templates_dir.glob("*.png"):
+        template_img = cv2.imread(str(template_file), cv2.IMREAD_UNCHANGED)
+        if template_img is not None:
+            cursor_templates[template_file.name] = template_img
+        else:
+            log_message(f"[WARN] Could not load template: {template_file}")
+    if not cursor_templates:
+        log_message(f"[ERROR] No cursor templates found in: {cursor_templates_dir}")
+        return 0
+    results = []
+    tracked_count = 0
+    for frame_file in sorted(frames_dir.glob("*.png")):
+        frame_num = int(frame_file.stem)
+        if frame_num < start_frame:
+            continue
+        frame = cv2.imread(str(frame_file), cv2.IMREAD_UNCHANGED)
+        if frame is None:
+            log_message(f"[WARN] Could not load frame: {frame_file}")
+            continue
+        pos, conf, template_name = detect_cursor_in_frame_multi(frame, cursor_templates, threshold)
+        if pos is not None:
+            # log_message(f"{frame_file.name}: Cursor at {pos} (template: {template_name})")
+            results.append({
+                "frame": frame_file.name,
+                "cursor_active": True,
+                "x": pos[0],
+                "y": pos[1],
+                "confidence": conf,
+                "template": template_name
+            })
+            tracked_count += 1
+        else:
+            # log_message(f"{frame_file.name}: Cursor disabled")
+            results.append({
+                "frame": frame_file.name,
+                "cursor_active": False,
+                "x": None,
+                "y": None,
+                "confidence": conf,
+                "template": None
+            })
+    try:
+        with open(output_json_path, "w") as f:
+            json.dump(results, f, indent=2)
+        log_message(f"[SUCCESS] Cursor tracking results saved to {output_json_path}")
+        if email_results:
+            log_message("[INFO] Preparing to email results...")
+            to_email = os.environ.get("TO_EMAIL")
+            from_email = os.environ.get("FROM_EMAIL")
+            app_password = os.environ.get("GMAIL_APP_PASSWORD")
+            if not (to_email and from_email and app_password):
+                log_message("[ERROR] Email environment variables not set. Please set TO_EMAIL, FROM_EMAIL, and GMAIL_APP_PASSWORD.")
+                # return tracked_count # Don't return here, just log error
+            else:
+                send_email_with_attachment(
+                    subject="Cursor Tracking Results",
+                    body="See attached JSON results.",
+                    to_email=to_email,
+                    from_email=from_email,
+                    app_password=app_password,
+                    attachment_path=output_json_path
+                )
+    except Exception as e:
+        log_message(f"[ERROR] Failed to write output JSON: {e}")
+        # raise # Don't raise, just log error
+    return tracked_count
+
+def process_rar_file(rar_path: str) -> bool:
+    """Process a single RAR file - extract, then process videos for frames and cursor tracking"""
+    filename = os.path.basename(rar_path)
+    processing_status["current_file"] = filename
+    
+    # Handle multi-part RAR naming
+    if is_multipart_rar(filename):
+        course_name = get_rar_part_base(filename)
+    else:
+        course_name = filename.replace(".rar", "")
+    
+    extract_dir = os.path.join(EXTRACT_FOLDER, course_name)
+    
+    try:
+        log_message(f"🔄 Processing: {filename}")
+        
+        # Clean up any existing directory
+        if os.path.exists(extract_dir):
+            shutil.rmtree(extract_dir, ignore_errors=True)
+        
+        # Extract RAR
+        os.makedirs(extract_dir, exist_ok=True)
+        if not extract_with_retry(rar_path, extract_dir):
+            raise Exception("RAR extraction failed")
+        
+        # Count extracted files
+        file_count = 0
+        video_files_found = []
+        for root, dirs, files in os.walk(extract_dir):
+            for file in files:
+                file_count += 1
+                if file.lower().endswith((".mp4", ".avi", ".mov", ".mkv")):
+                    video_files_found.append(os.path.join(root, file))
+        
+        processing_status["extracted_courses"] += 1
+        log_message(f"✅ Successfully extracted \'{course_name}\' ({file_count} files, {len(video_files_found)} videos)")
+
+        # Process video files for frame extraction and cursor tracking
+        for video_path in video_files_found:
+            video_filename = Path(video_path).name
+            # Create a unique output directory for frames for each video
+            frames_output_dir = os.path.join(FRAMES_OUTPUT_FOLDER, f"{course_name}_{video_filename.replace('.', '_')}_frames")
+            ensure_dir(frames_output_dir)
+            
+            extracted_frames_count = extract_frames(video_path, frames_output_dir, fps=DEFAULT_FPS)
+            processing_status["extracted_frames_count"] += extracted_frames_count
+            if extracted_frames_count > 0:
+                processing_status["extracted_videos"] += 1
+                log_message(f"[INFO] Extracted {extracted_frames_count} frames from {video_filename}")
+
+                # Perform cursor tracking on the extracted frames
+                cursor_output_json = os.path.join(CURSOR_TRACKING_OUTPUT_FOLDER, f"{course_name}_{video_filename.replace('.', '_')}_cursor_data.json")
+                tracked_cursors = track_cursor(frames_output_dir, CURSOR_TEMPLATES_DIR, cursor_output_json, threshold=CURSOR_THRESHOLD)
+                processing_status["tracked_cursors_count"] += tracked_cursors
+                log_message(f"[INFO] Tracked {tracked_cursors} cursors in frames from {video_filename}")
+            else:
+                log_message(f"[WARN] No frames extracted from {video_filename}")
+
+        return True
+    
+    except Exception as e:
+        error_msg = str(e)
+        log_message(f"❌ Processing failed: {error_msg}")
+        log_failed_file(filename, error_msg)
+        return False
+    
+    finally:
+        processing_status["current_file"] = None
+
+def main_processing_loop(start_index: int = 0):
+    """Main processing workflow - extraction, frame extraction, and cursor tracking"""
+    processing_status["is_running"] = True
+    
+    try:
+        # Load state
+        processed_rars = load_json_state(PROCESS_STATE_FILE, {"processed_rars": []})["processed_rars"]
+        download_state = load_json_state(DOWNLOAD_STATE_FILE, {"next_download_index": 0})
+        
+        # Use start_index if provided, otherwise use the saved state
+        next_index = start_index if start_index > 0 else download_state["next_download_index"]
+        
+        log_message(f"📊 Starting from index {next_index}")
+        log_message(f"📊 Previously processed: {len(processed_rars)} files")
+        
+        # Get file list
+        try:
+            files = list(hf_api.list_repo_files(repo_id=SOURCE_REPO_ID, repo_type="dataset"))
+            rar_files = sorted([f for f in files if f.endswith(".rar")])
+            
+            processing_status["total_files"] = len(rar_files)
+            log_message(f"📁 Found {len(rar_files)} RAR files in repository")
+            
+            if next_index >= len(rar_files):
+                log_message("✅ All files have been processed!")
+                return
+                
+        except Exception as e:
+            log_message(f"❌ Failed to get file list: {str(e)}")
+            return
+        
+        # Process only one file per run
+        if next_index < len(rar_files):
+            rar_file = rar_files[next_index]
+            filename = os.path.basename(rar_file)
+            
+            if filename in processed_rars:
+                log_message(f"⏭️ Skipping already processed: {filename}")
+                processing_status["processed_files"] += 1
+                # Move to next file
+                next_index += 1
+                save_json_state(DOWNLOAD_STATE_FILE, {"next_download_index": next_index})
+                log_message(f"📊 Moving to next file. Progress: {next_index}/{len(rar_files)}")
+                return
+            
+            log_message(f"📥 Downloading: {filename}")
+            dest_path = os.path.join(DOWNLOAD_FOLDER, filename)
+            
+            # Download file
+            download_url = f"https://huggingface.co/datasets/{SOURCE_REPO_ID}/resolve/main/{rar_file}"
+            if download_with_retry(download_url, dest_path):
+                # Process file
+                if process_rar_file(dest_path):
+                    processed_rars.append(filename)
+                    save_json_state(PROCESS_STATE_FILE, {"processed_rars": processed_rars})
+                    log_message(f"✅ Successfully processed: {filename}")
+                    processing_status["processed_files"] += 1
+                else:
+                    log_message(f"❌ Failed to process: {filename}")
+                    processing_status["failed_files"] += 1
+                
+                # Clean up downloaded file
+                try:
+                    os.remove(dest_path)
+                    log_message(f"🗑️ Cleaned up download: {filename}")
+                except:
+                    pass
+            else:
+                log_message(f"❌ Failed to download: {filename}")
+                processing_status["failed_files"] += 1
+            
+            # Update download state for next run
+            next_index += 1
+            save_json_state(DOWNLOAD_STATE_FILE, {"next_download_index": next_index})
+            
+            # Status update
+            log_message(f"📊 Progress: {next_index}/{len(rar_files)} files processed")
+            log_message(f'📊 Extracted: {processing_status["extracted_courses"]} courses')
+            log_message(f'📊 Videos Processed: {processing_status["extracted_videos"]}')
+            log_message(f'📊 Frames Extracted: {processing_status["extracted_frames_count"]}')
+            log_message(f'📊 Cursors Tracked: {processing_status["tracked_cursors_count"]}')
+            log_message(f'📊 Failed: {processing_status["failed_files"]} files')
+            
+            if next_index < len(rar_files):
+                log_message(f"🔄 Run the script again to process the next file: {os.path.basename(rar_files[next_index])}")
+            else:
+                log_message("🎉 All files have been processed!")
+        else:
+            log_message("✅ All files have been processed!")
+        
+        log_message("🎉 Processing complete!")
+        log_message(f'📊 Final stats: {processing_status["extracted_courses"]} courses extracted, {processing_status["extracted_videos"]} videos processed, {processing_status["extracted_frames_count"]} frames extracted, {processing_status["tracked_cursors_count"]} cursors tracked')
+        
+    except KeyboardInterrupt:
+        log_message("⏹️ Processing interrupted by user")
+    except Exception as e:
+        log_message(f"❌ Fatal error: {str(e)}")
+    finally:
+        processing_status["is_running"] = False
+        cleanup_temp_files()
+
+# Expose necessary functions and variables for download_api.py
+__all__ = [
+    "main_processing_loop",
+    "processing_status",
+    "CURSOR_TRACKING_OUTPUT_FOLDER",
+    "CURSOR_TEMPLATES_DIR",
+    "log_message",
+    "send_email_with_attachment",
+    "track_cursor",
+    "extract_frames",
+    "DEFAULT_FPS",
+    "CURSOR_THRESHOLD",
+    "ensure_dir"
+]
+
+
+
+

download_api.py

@@ -0,0 +1,319 @@
+import os
+import json
+import time
+import threading
+from fastapi import FastAPI, HTTPException, BackgroundTasks
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+import uvicorn
+from typing import Dict
+from pathlib import Path
+from datetime import datetime
+from fastapi.responses import FileResponse
+
+# Import from cursor_tracker
+from cursor_tracker import (
+    main_processing_loop,
+    processing_status,
+    CURSOR_TRACKING_OUTPUT_FOLDER,
+    CURSOR_TEMPLATES_DIR,
+    log_message
+)
+
+
+
+# FastAPI App Definition
+app = FastAPI(title="Cursor Tracking API", description="API to access cursor tracking results", version="1.0.0")
+
+# Add CORS middleware to allow cross-origin requests
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  # Allows all origins
+    allow_credentials=True,
+    allow_methods=["*"],  # Allows all methods
+    allow_headers=["*"],
+)
+
+# Global variable to track if processing is running
+processing_thread = None
+
+def log_message(message):
+    """Add a log message with timestamp"""
+    timestamp = datetime.now().strftime("%H:%M:%S")
+    log_entry = f"[{timestamp}] {message}"
+    processing_status["logs"].append(log_entry)
+    
+    # Keep only the last 100 logs
+    if len(processing_status["logs"]) > 100:
+        processing_status["logs"] = processing_status["logs"][-100:]
+    
+    print(log_entry)
+
+@app.on_event("startup")
+async def startup_event():
+    """Run the processing loop in the background when the API starts"""
+    global processing_thread
+    if not (processing_thread and processing_thread.is_alive()):
+        log_message("🚀 Starting RAR extraction, frame extraction, and cursor tracking pipeline in background...")
+        processing_thread = threading.Thread(target=main_processing_loop)
+        processing_thread.daemon = True
+        processing_thread.start()
+
+from fastapi.staticfiles import StaticFiles
+
+# app.mount("/static", StaticFiles(directory="static"), name="static")
+
+# Serve your main HTML file
+@app.get("/")
+async def root():
+    return ()
+    
+    # return FileResponse("index.html")
+
+# # Optional: If you need to serve other static files individually
+# @app.get("/{filename}")
+# async def serve_file(filename: str):
+#     if filename in ['style.css', 'script.js']:
+#         return FileResponse(f"static/{filename}")
+#     return FileResponse(f"static/{filename}")
+
+
+
+@app.get("/status")
+async def get_status():
+    """Get current processing status"""
+    return {
+        "processing_status": processing_status,
+        "cursor_tracking_folder": CURSOR_TRACKING_OUTPUT_FOLDER,
+        "folder_exists": os.path.exists(CURSOR_TRACKING_OUTPUT_FOLDER)
+    }
+
+@app.get("/cursor-data")
+async def list_cursor_data():
+    """List all available cursor tracking JSON files"""
+    if not os.path.exists(CURSOR_TRACKING_OUTPUT_FOLDER):
+        return {"files": [], "message": "Cursor tracking output folder does not exist yet"}
+    
+    json_files = []
+    for file in os.listdir(CURSOR_TRACKING_OUTPUT_FOLDER):
+        if file.endswith(".json"):
+            file_path = os.path.join(CURSOR_TRACKING_OUTPUT_FOLDER, file)
+            file_stats = os.stat(file_path)
+            json_files.append({
+                "filename": file,
+                "size_bytes": file_stats.st_size,
+                "modified_time": time.ctime(file_stats.st_mtime),
+                "download_url": f"/cursor-data/{file}"
+            })
+    
+    return {
+        "files": json_files,
+        "total_files": len(json_files),
+        "folder_path": CURSOR_TRACKING_OUTPUT_FOLDER
+    }
+
+from fastapi.encoders import jsonable_encoder
+
+def get_disk_usage(path: str) -> Dict[str, float]:
+    """Get disk usage statistics in GB"""
+    statvfs = os.statvfs(path)
+    total = statvfs.f_frsize * statvfs.f_blocks / (1024**3)
+    free = statvfs.f_frsize * statvfs.f_bavail / (1024**3)
+    used = total - free
+    return {"total": total, "free": free, "used": used}
+
+class SafeJSONEncoder(json.JSONEncoder):
+    def default(self, obj):
+        try:
+            if isinstance(obj, float):
+                if obj != obj:  # Check for NaN
+                    return None
+                if obj == float('inf') or obj == float('-inf'):
+                    return None
+            return super().default(obj)
+        except:
+            return None
+
+@app.get("/cursor-data/{filename}")
+async def get_cursor_data(filename: str):
+    """Get specific cursor tracking data by filename"""
+    if not filename.endswith(".json"):
+        raise HTTPException(status_code=400, detail="File must be a JSON file")
+    
+    file_path = os.path.join(CURSOR_TRACKING_OUTPUT_FOLDER, filename)
+    
+    if not os.path.exists(file_path):
+        raise HTTPException(status_code=404, detail=f"File {filename} not found")
+    
+    try:
+        with open(file_path, "r") as f:
+            data = json.load(f)
+        
+        # Clean the data of any NaN or infinity values
+        def clean_floats(obj):
+            if isinstance(obj, float):
+                if obj != obj:  # NaN
+                    return None
+                if obj == float('inf') or obj == float('-inf'):
+                    return None
+                return obj
+            elif isinstance(obj, dict):
+                return {k: clean_floats(v) for k, v in obj.items()}
+            elif isinstance(obj, list):
+                return [clean_floats(v) for v in obj]
+            return obj
+        
+        cleaned_data = clean_floats(data)
+        
+        # Add metadata
+        file_stats = os.stat(file_path)
+        response_data = {
+            "filename": filename,
+            "file_size_bytes": file_stats.st_size,
+            "modified_time": time.ctime(file_stats.st_mtime),
+            "total_frames": len(cleaned_data),
+            "cursor_active_frames": len([frame for frame in cleaned_data if frame.get("cursor_active", False)]),
+            "data": cleaned_data
+        }
+        
+        return JSONResponse(content=jsonable_encoder(response_data))
+        
+    except json.JSONDecodeError:
+        raise HTTPException(status_code=500, detail=f"Invalid JSON in file {filename}")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error reading file {filename}: {str(e)}")
+
+@app.post("/start-processing")
+async def start_processing(background_tasks: BackgroundTasks, start_index: int = 0):
+    """Start the RAR processing pipeline in the background"""
+    global processing_thread
+    
+    if processing_thread and processing_thread.is_alive():
+        return {"message": "Processing is already running", "status": "already_running"}
+    
+    if processing_status["is_running"]:
+        return {"message": "Processing is already running", "status": "already_running"}
+    
+    # Start processing in a background thread
+    processing_thread = threading.Thread(target=main_processing_loop, args=(start_index,))
+    processing_thread.daemon = True
+    processing_thread.start()
+    
+    return {"message": f"Processing started in background from index {start_index}", "status": "started"}
+
+@app.post("/stop-processing")
+async def stop_processing():
+    """Stop the RAR processing pipeline"""
+    global processing_thread
+    
+    if not processing_status["is_running"] and (not processing_thread or not processing_thread.is_alive()):
+        return {"message": "No processing is currently running", "status": "not_running"}
+    
+    # Note: This is a graceful stop request. The actual stopping depends on the processing loop
+    # checking the processing_status["is_running"] flag
+    processing_status["is_running"] = False
+    
+    return {"message": "Stop signal sent to processing pipeline", "status": "stop_requested"}
+
+@app.get("/cursor-data/{filename}/summary")
+async def get_cursor_data_summary(filename: str):
+    """Get a summary of cursor tracking data without the full frame data"""
+    if not filename.endswith(".json"):
+        raise HTTPException(status_code=400, detail="File must be a JSON file")
+    
+    file_path = os.path.join(CURSOR_TRACKING_OUTPUT_FOLDER, filename)
+    
+    if not os.path.exists(file_path):
+        raise HTTPException(status_code=404, detail=f"File {filename} not found")
+    
+    try:
+        with open(file_path, "r") as f:
+            data = json.load(f)
+        
+        # Clean the data first
+        def clean_floats(obj):
+            if isinstance(obj, float):
+                if obj != obj:  # NaN
+                    return None
+                if obj == float('inf') or obj == float('-inf'):
+                    return None
+                return obj
+            elif isinstance(obj, dict):
+                return {k: clean_floats(v) for k, v in obj.items()}
+            elif isinstance(obj, list):
+                return [clean_floats(v) for v in obj]
+            return obj
+        
+        cleaned_data = clean_floats(data)
+        
+        # Calculate summary statistics
+        total_frames = len(cleaned_data)
+        cursor_active_frames = len([frame for frame in cleaned_data if frame.get("cursor_active", False)])
+        cursor_inactive_frames = total_frames - cursor_active_frames
+        
+        # Get unique templates used
+        templates_used = set()
+        confidence_scores = []
+        
+        for frame in cleaned_data:
+            if frame.get("cursor_active", False) and frame.get("template"):
+                templates_used.add(frame["template"])
+                if frame.get("confidence") is not None:
+                    # Ensure confidence is a valid number
+                    try:
+                        conf = float(frame["confidence"])
+                        if not (conf != conf or conf == float('inf') or conf == float('-inf')):
+                            confidence_scores.append(conf)
+                    except (ValueError, TypeError):
+                        pass
+        
+        # Calculate confidence statistics
+        avg_confidence = sum(confidence_scores) / len(confidence_scores) if confidence_scores else 0
+        max_confidence = max(confidence_scores) if confidence_scores else 0
+        min_confidence = min(confidence_scores) if confidence_scores else 0
+        
+        file_stats = os.stat(file_path)
+        
+        summary = {
+            "filename": filename,
+            "file_size_bytes": file_stats.st_size,
+            "modified_time": time.ctime(file_stats.st_mtime),
+            "total_frames": total_frames,
+            "cursor_active_frames": cursor_active_frames,
+            "cursor_inactive_frames": cursor_inactive_frames,
+            "cursor_detection_rate": cursor_active_frames / total_frames if total_frames > 0 else 0,
+            "templates_used": list(templates_used),
+            "confidence_stats": {
+                "average": avg_confidence,
+                "maximum": max_confidence,
+                "minimum": min_confidence,
+                "total_measurements": len(confidence_scores)
+            }
+        }
+        
+        return JSONResponse(content=jsonable_encoder(summary))
+        
+    except json.JSONDecodeError:
+        raise HTTPException(status_code=500, detail=f"Invalid JSON in file {filename}")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error reading file {filename}: {str(e)}")
+
+if __name__ == "__main__":
+    # Start the FastAPI server
+    print("Starting Cursor Tracking FastAPI Server...")
+    print("API Documentation will be available at: http://localhost:8000/docs")
+    print("API Root endpoint: http://localhost:8000/")
+    
+    # Ensure the cursor tracking output folder exists
+    os.makedirs(CURSOR_TRACKING_OUTPUT_FOLDER, exist_ok=True)
+    
+    uvicorn.run(
+        app, 
+        host="0.0.0.0", 
+        port=8000, 
+        log_level="info",
+        reload=False  # Set to False for production
+    )
+
+
+

index.html

@@ -0,0 +1,203 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <meta name="description" content="Advanced web-based dashboard for monitoring and managing cursor tracking operations on video datasets. Real-time processing status, file management, and control interface.">
+    <meta name="keywords" content="cursor tracking, video processing, dashboard, monitoring, API interface">
+    <meta name="author" content="Cursor Tracking Dashboard">
+    <title>Cursor Tracking Dashboard - Real-time Video Processing Monitor</title>
+        <link rel="stylesheet" href="/static/style.css">
+    <link href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/6.4.0/css/all.min.css" rel="stylesheet">
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&display=swap" rel="stylesheet">
+</head>
+<body>
+    <div class="container">
+        <!-- Header -->
+        <header class="header">
+            <div class="header-content">
+                <div class="logo">
+                    <i class="fas fa-mouse-pointer"></i>
+                    <h1>Cursor Tracking Dashboard</h1>
+                </div>
+                <div class="header-actions">
+                    <button id="refreshBtn" class="btn btn-secondary">
+                        <i class="fas fa-sync-alt"></i>
+                        Refresh
+                    </button>
+                    <div class="theme-toggle">
+                        <button id="themeToggle" class="btn btn-icon">
+                            <i class="fas fa-moon"></i>
+                        </button>
+                    </div>
+                </div>
+            </div>
+        </header>
+
+        <!-- Main Content -->
+        <main class="main-content">
+            <!-- Status Section -->
+            <section class="status-section">
+                <div class="card">
+                    <div class="card-header">
+                        <h2><i class="fas fa-chart-line"></i> Processing Status</h2>
+                        <div class="status-indicator" id="statusIndicator">
+                            <span class="status-dot"></span>
+                            <span class="status-text">Loading...</span>
+                        </div>
+                    </div>
+                    <div class="card-content">
+                        <div class="stats-grid">
+                            <div class="stat-item">
+                                <div class="stat-value" id="totalFiles">-</div>
+                                <div class="stat-label">Total Files</div>
+                            </div>
+                            <div class="stat-item">
+                                <div class="stat-value" id="processedFiles">-</div>
+                                <div class="stat-label">Processed</div>
+                            </div>
+                            <div class="stat-item">
+                                <div class="stat-value" id="extractedCourses">-</div>
+                                <div class="stat-label">Courses</div>
+                            </div>
+                            <div class="stat-item">
+                                <div class="stat-value" id="extractedVideos">-</div>
+                                <div class="stat-label">Videos</div>
+                            </div>
+                            <div class="stat-item">
+                                <div class="stat-value" id="extractedFrames">-</div>
+                                <div class="stat-label">Frames</div>
+                            </div>
+                            <div class="stat-item">
+                                <div class="stat-value" id="trackedCursors">-</div>
+                                <div class="stat-label">Cursors Tracked</div>
+                            </div>
+                        </div>
+                        
+                        <div class="progress-section">
+                            <div class="progress-info">
+                                <span>Current File:</span>
+                                <span id="currentFile" class="current-file">None</span>
+                            </div>
+                            <div class="progress-bar">
+                                <div class="progress-fill" id="progressFill"></div>
+                            </div>
+                            <div class="progress-text" id="progressText">0%</div>
+                        </div>
+                    </div>
+                </div>
+            </section>
+
+            <!-- Control Section -->
+            <section class="control-section">
+                <div class="card">
+                    <div class="card-header">
+                        <h2><i class="fas fa-cogs"></i> Processing Controls</h2>
+                    </div>
+                    <div class="card-content">
+                        <div class="control-group">
+                            <div class="input-group">
+                                <label for="startIndex">Start Index for RAR Fetching:</label>
+                                <input type="number" id="startIndex" min="0" value="0" class="input">
+                                <span class="input-help">Specify which index to start processing from</span>
+                            </div>
+                            <div class="button-group">
+                                <button id="startProcessing" class="btn btn-primary">
+                                    <i class="fas fa-play"></i>
+                                    Start Processing
+                                </button>
+                                <button id="stopProcessing" class="btn btn-danger">
+                                    <i class="fas fa-stop"></i>
+                                    Stop Processing
+                                </button>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </section>
+
+            <!-- Cursor Data Files Section -->
+            <section class="files-section">
+                <div class="card">
+                    <div class="card-header">
+                        <h2><i class="fas fa-file-alt"></i> Cursor Tracking Results</h2>
+                        <div class="file-count" id="fileCount">0 files</div>
+                    </div>
+                    <div class="card-content">
+                        <div class="files-grid" id="filesGrid">
+                            <!-- Files will be populated here -->
+                        </div>
+                    </div>
+                </div>
+            </section>
+
+            <!-- Logs Section -->
+            <section class="logs-section">
+                <div class="card">
+                    <div class="card-header">
+                        <h2><i class="fas fa-terminal"></i> Processing Logs</h2>
+                        <div class="log-controls">
+                            <button id="clearLogs" class="btn btn-secondary btn-sm">
+                                <i class="fas fa-trash"></i>
+                                Clear
+                            </button>
+                            <button id="autoScroll" class="btn btn-secondary btn-sm active">
+                                <i class="fas fa-arrow-down"></i>
+                                Auto-scroll
+                            </button>
+                        </div>
+                    </div>
+                    <div class="card-content">
+                        <div class="logs-container" id="logsContainer">
+                            <div class="log-entry">
+                                <span class="log-time">[Loading...]</span>
+                                <span class="log-message">Initializing dashboard...</span>
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </section>
+        </main>
+    </div>
+
+    <!-- File Details Modal -->
+    <div id="fileModal" class="modal">
+        <div class="modal-content">
+            <div class="modal-header">
+                <h3 id="modalTitle">File Details</h3>
+                <button class="modal-close" id="modalClose">
+                    <i class="fas fa-times"></i>
+                </button>
+            </div>
+            <div class="modal-body" id="modalBody">
+                <!-- File details will be populated here -->
+            </div>
+            <div class="modal-footer">
+                <button id="downloadFile" class="btn btn-primary">
+                    <i class="fas fa-download"></i>
+                    Download JSON
+                </button>
+                <button id="viewFrames" class="btn btn-secondary">
+                    <i class="fas fa-images"></i>
+                    View Frames
+                </button>
+            </div>
+        </div>
+    </div>
+
+    <!-- Loading Overlay -->
+    <div id="loadingOverlay" class="loading-overlay">
+        <div class="loading-spinner">
+            <i class="fas fa-spinner fa-spin"></i>
+            <p>Loading...</p>
+        </div>
+    </div>
+
+    <!-- Toast Notifications -->
+    <div id="toastContainer" class="toast-container"></div>
+
+
+<script src="/static/script.js"></script>
+</body>
+</html>
+

requirements.txt

@@ -0,0 +1,10 @@
+torch
+transformers
+accelerate
+fastapi
+uvicorn
+opencv-python-headless
+numpy
+pathlib
+huggingface_hub
+pillow

static/script.js

@@ -0,0 +1,655 @@
+// Configuration
+const API_BASE_URL = window.location.origin; // Use same origin as the UI
+const REFRESH_INTERVAL = 10000; // 10 seconds (increased for demo)
+const MAX_LOGS = 100;
+
+// Global state
+let refreshInterval;
+let autoScrollEnabled = true;
+let currentFiles = [];
+let selectedFile = null;
+let apiConnected = false;
+
+// DOM Elements
+const elements = {
+    statusIndicator: document.getElementById('statusIndicator'),
+    totalFiles: document.getElementById('totalFiles'),
+    processedFiles: document.getElementById('processedFiles'),
+    extractedCourses: document.getElementById('extractedCourses'),
+    extractedVideos: document.getElementById('extractedVideos'),
+    extractedFrames: document.getElementById('extractedFrames'),
+    trackedCursors: document.getElementById('trackedCursors'),
+    currentFile: document.getElementById('currentFile'),
+    progressFill: document.getElementById('progressFill'),
+    progressText: document.getElementById('progressText'),
+    startIndex: document.getElementById('startIndex'),
+    startProcessing: document.getElementById('startProcessing'),
+    stopProcessing: document.getElementById('stopProcessing'),
+    refreshBtn: document.getElementById('refreshBtn'),
+    themeToggle: document.getElementById('themeToggle'),
+    fileCount: document.getElementById('fileCount'),
+    filesGrid: document.getElementById('filesGrid'),
+    logsContainer: document.getElementById('logsContainer'),
+    clearLogs: document.getElementById('clearLogs'),
+    autoScroll: document.getElementById('autoScroll'),
+    fileModal: document.getElementById('fileModal'),
+    modalTitle: document.getElementById('modalTitle'),
+    modalBody: document.getElementById('modalBody'),
+    modalClose: document.getElementById('modalClose'),
+    downloadFile: document.getElementById('downloadFile'),
+    viewFrames: document.getElementById('viewFrames'),
+    loadingOverlay: document.getElementById('loadingOverlay'),
+    toastContainer: document.getElementById('toastContainer')
+};
+
+// Initialize the application
+document.addEventListener('DOMContentLoaded', function() {
+    initializeTheme();
+    setupEventListeners();
+    startAutoRefresh();
+    fetchInitialData();
+});
+
+// Theme Management
+function initializeTheme() {
+    const savedTheme = localStorage.getItem('theme') || 'light';
+    document.documentElement.setAttribute('data-theme', savedTheme);
+    updateThemeIcon(savedTheme);
+}
+
+function toggleTheme() {
+    const currentTheme = document.documentElement.getAttribute('data-theme');
+    const newTheme = currentTheme === 'dark' ? 'light' : 'dark';
+    document.documentElement.setAttribute('data-theme', newTheme);
+    localStorage.setItem('theme', newTheme);
+    updateThemeIcon(newTheme);
+}
+
+function updateThemeIcon(theme) {
+    const icon = elements.themeToggle.querySelector('i');
+    icon.className = theme === 'dark' ? 'fas fa-sun' : 'fas fa-moon';
+}
+
+// Event Listeners
+function setupEventListeners() {
+    elements.themeToggle.addEventListener('click', toggleTheme);
+    elements.refreshBtn.addEventListener('click', () => {
+        showToast('Refreshing data...', 'info');
+        fetchAllData();
+    });
+    
+    elements.startProcessing.addEventListener('click', startProcessing);
+    elements.stopProcessing.addEventListener('click', stopProcessing);
+    
+    elements.clearLogs.addEventListener('click', clearLogs);
+    elements.autoScroll.addEventListener('click', toggleAutoScroll);
+    
+    elements.modalClose.addEventListener('click', closeModal);
+    elements.fileModal.addEventListener('click', (e) => {
+        if (e.target === elements.fileModal) closeModal();
+    });
+    
+    elements.downloadFile.addEventListener('click', downloadSelectedFile);
+    elements.viewFrames.addEventListener('click', viewFrames);
+    
+    // Keyboard shortcuts
+    document.addEventListener('keydown', (e) => {
+        if (e.key === 'Escape') closeModal();
+        if (e.key === 'F5') {
+            e.preventDefault();
+            fetchAllData();
+        }
+    });
+}
+
+// API Functions
+async function apiRequest(endpoint, options = {}) {
+    try {
+        showLoading();
+        const response = await fetch(`${API_BASE_URL}${endpoint}`, {
+            headers: {
+                'Content-Type': 'application/json',
+                ...options.headers
+            },
+            ...options
+        });
+        
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        
+        apiConnected = true;
+        return await response.json();
+    } catch (error) {
+        console.error('API request failed:', error);
+        apiConnected = false;
+        
+        // Show different messages based on error type
+        if (error.name === 'TypeError' && error.message.includes('fetch')) {
+            showToast('API server not running. Please start the cursor tracking API on port 8000.', 'warning');
+        } else {
+            showToast(`API Error: ${error.message}`, 'error');
+        }
+        throw error;
+    } finally {
+        hideLoading();
+    }
+}
+
+async function fetchStatus() {
+    try {
+        const data = await apiRequest('/status');
+        updateStatusDisplay(data.processing_status);
+        return data;
+    } catch (error) {
+        // Show demo data when API is not connected
+        const demoStatus = {
+            is_running: false,
+            total_files: 150,
+            processed_files: 45,
+            extracted_courses: 12,
+            extracted_videos: 89,
+            extracted_frames_count: 15420,
+            tracked_cursors_count: 8934,
+            current_file: null,
+            logs: [
+                '[Demo Mode] API server not connected',
+                '[Demo Mode] This is a demonstration of the UI',
+                '[Demo Mode] Start the API server on port 8000 to see real data'
+            ]
+        };
+        updateStatusDisplay(demoStatus);
+    }
+}
+
+async function fetchCursorData() {
+    try {
+        const data = await apiRequest('/cursor-data');
+        currentFiles = data.files || [];
+        updateFilesDisplay(currentFiles);
+        return data;
+    } catch (error) {
+        // Show demo files when API is not connected
+        const demoFiles = [
+            {
+                filename: 'course_1_video_1_mp4_cursor_data.json',
+                size_bytes: 45678,
+                modified_time: 'Sun Jul 13 19:30:15 2025'
+            },
+            {
+                filename: 'course_2_video_3_mp4_cursor_data.json',
+                size_bytes: 67890,
+                modified_time: 'Sun Jul 13 18:45:22 2025'
+            },
+            {
+                filename: 'course_3_video_2_mp4_cursor_data.json',
+                size_bytes: 34567,
+                modified_time: 'Sun Jul 13 17:20:10 2025'
+            }
+        ];
+        currentFiles = demoFiles;
+        updateFilesDisplay(demoFiles);
+    }
+}
+
+async function fetchFileDetails(filename) {
+    try {
+        const data = await apiRequest(`/cursor-data/${filename}/summary`);
+        return data;
+    } catch (error) {
+        showToast(`Failed to fetch details for ${filename}`, 'error');
+        return null;
+    }
+}
+
+async function startProcessing() {
+    try {
+        const startIndex = parseInt(elements.startIndex.value) || 0;
+        const data = await apiRequest('/start-processing', {
+            method: 'POST',
+            body: JSON.stringify({ start_index: startIndex })
+        });
+        
+        showToast(data.message, data.status === 'started' ? 'success' : 'info');
+        
+        if (data.status === 'started') {
+            elements.startProcessing.disabled = true;
+            elements.stopProcessing.disabled = false;
+        }
+    } catch (error) {
+        showToast('Failed to start processing', 'error');
+    }
+}
+
+async function stopProcessing() {
+    try {
+        const data = await apiRequest('/stop-processing', {
+            method: 'POST'
+        });
+        
+        showToast(data.message, 'info');
+        elements.startProcessing.disabled = false;
+        elements.stopProcessing.disabled = true;
+    } catch (error) {
+        showToast('Failed to stop processing', 'error');
+    }
+}
+
+// Display Update Functions
+function updateStatusDisplay(status) {
+    // Update status indicator
+    const statusDot = elements.statusIndicator.querySelector('.status-dot');
+    const statusText = elements.statusIndicator.querySelector('.status-text');
+    
+    if (status.is_running) {
+        statusDot.className = 'status-dot running';
+        statusText.textContent = 'Processing';
+        elements.startProcessing.disabled = true;
+        elements.stopProcessing.disabled = false;
+    } else {
+        statusDot.className = 'status-dot stopped';
+        statusText.textContent = 'Idle';
+        elements.startProcessing.disabled = false;
+        elements.stopProcessing.disabled = true;
+    }
+    
+    // Update statistics
+    elements.totalFiles.textContent = status.total_files || 0;
+    elements.processedFiles.textContent = status.processed_files || 0;
+    elements.extractedCourses.textContent = status.extracted_courses || 0;
+    elements.extractedVideos.textContent = status.extracted_videos || 0;
+    elements.extractedFrames.textContent = status.extracted_frames_count || 0;
+    elements.trackedCursors.textContent = status.tracked_cursors_count || 0;
+    
+    // Update current file and progress
+    const currentFile = status.current_file || 'None';
+    elements.currentFile.textContent = currentFile;
+    
+    const progress = status.total_files > 0 ? 
+        Math.round((status.processed_files / status.total_files) * 100) : 0;
+    elements.progressFill.style.width = `${progress}%`;
+    elements.progressText.textContent = `${progress}%`;
+    
+    // Update logs
+    if (status.logs && status.logs.length > 0) {
+        updateLogs(status.logs);
+    }
+}
+
+function updateFilesDisplay(files) {
+    elements.fileCount.textContent = `${files.length} files`;
+    
+    if (files.length === 0) {
+        elements.filesGrid.innerHTML = `
+            <div class="no-files">
+                <i class="fas fa-folder-open" style="font-size: 3rem; color: var(--text-muted); margin-bottom: 1rem;"></i>
+                <p style="color: var(--text-muted);">No cursor tracking files found yet.</p>
+                <p style="color: var(--text-muted); font-size: 0.875rem;">Files will appear here after processing completes.</p>
+            </div>
+        `;
+        return;
+    }
+    
+    elements.filesGrid.innerHTML = files.map(file => `
+        <div class="file-card" onclick="openFileModal('${file.filename}')">
+            <div class="file-header">
+                <div class="file-name">${file.filename}</div>
+                <div class="file-size">${formatFileSize(file.size_bytes)}</div>
+            </div>
+            <div class="file-stats">
+                <div class="file-stat">
+                    <span class="file-stat-label">Modified:</span>
+                    <span class="file-stat-value">${formatDate(file.modified_time)}</span>
+                </div>
+            </div>
+            <div class="file-actions">
+                <button class="btn btn-primary btn-sm" onclick="event.stopPropagation(); downloadFile('${file.filename}')">
+                    <i class="fas fa-download"></i>
+                    Download
+                </button>
+                <button class="btn btn-secondary btn-sm" onclick="event.stopPropagation(); openFileModal('${file.filename}')">
+                    <i class="fas fa-eye"></i>
+                    Details
+                </button>
+            </div>
+        </div>
+    `).join('');
+}
+
+function updateLogs(logs) {
+    const container = elements.logsContainer;
+    
+    // Clear existing logs if we have new ones
+    if (logs.length > 0) {
+        container.innerHTML = '';
+    }
+    
+    logs.slice(-MAX_LOGS).forEach(log => {
+        const logEntry = document.createElement('div');
+        logEntry.className = 'log-entry';
+        
+        // Determine log type based on content
+        let logType = '';
+        if (log.includes('❌') || log.includes('ERROR') || log.includes('Failed')) {
+            logType = 'error';
+        } else if (log.includes('✅') || log.includes('SUCCESS') || log.includes('Successfully')) {
+            logType = 'success';
+        } else if (log.includes('⚠️') || log.includes('WARN')) {
+            logType = 'warning';
+        }
+        
+        if (logType) {
+            logEntry.classList.add(logType);
+        }
+        
+        // Extract timestamp and message
+        const timestampMatch = log.match(/^\[([^\]]+)\]/);
+        const timestamp = timestampMatch ? timestampMatch[1] : new Date().toLocaleTimeString();
+        const message = timestampMatch ? log.substring(timestampMatch[0].length).trim() : log;
+        
+        logEntry.innerHTML = `
+            <span class="log-time">[${timestamp}]</span>
+            <span class="log-message">${escapeHtml(message)}</span>
+        `;
+        
+        container.appendChild(logEntry);
+    });
+    
+    // Auto-scroll to bottom if enabled
+    if (autoScrollEnabled) {
+        container.scrollTop = container.scrollHeight;
+    }
+}
+
+// Modal Functions
+async function openFileModal(filename) {
+    selectedFile = filename;
+    elements.modalTitle.textContent = `File Details: ${filename}`;
+    
+    showModal();
+    
+    const details = await fetchFileDetails(filename);
+    if (details) {
+        elements.modalBody.innerHTML = `
+            <div class="file-details">
+                <div class="detail-section">
+                    <h4>File Information</h4>
+                    <div class="detail-grid">
+                        <div class="detail-item">
+                            <span class="detail-label">File Size:</span>
+                            <span class="detail-value">${formatFileSize(details.file_size_bytes)}</span>
+                        </div>
+                        <div class="detail-item">
+                            <span class="detail-label">Modified:</span>
+                            <span class="detail-value">${details.modified_time}</span>
+                        </div>
+                    </div>
+                </div>
+                
+                <div class="detail-section">
+                    <h4>Frame Statistics</h4>
+                    <div class="detail-grid">
+                        <div class="detail-item">
+                            <span class="detail-label">Total Frames:</span>
+                            <span class="detail-value">${details.total_frames}</span>
+                        </div>
+                        <div class="detail-item">
+                            <span class="detail-label">Cursor Active:</span>
+                            <span class="detail-value">${details.cursor_active_frames}</span>
+                        </div>
+                        <div class="detail-item">
+                            <span class="detail-label">Cursor Inactive:</span>
+                            <span class="detail-value">${details.cursor_inactive_frames}</span>
+                        </div>
+                        <div class="detail-item">
+                            <span class="detail-label">Detection Rate:</span>
+                            <span class="detail-value">${(details.cursor_detection_rate * 100).toFixed(1)}%</span>
+                        </div>
+                    </div>
+                </div>
+                
+                <div class="detail-section">
+                    <h4>Confidence Statistics</h4>
+                    <div class="detail-grid">
+                        <div class="detail-item">
+                            <span class="detail-label">Average:</span>
+                            <span class="detail-value">${details.confidence_stats.average.toFixed(3)}</span>
+                        </div>
+                        <div class="detail-item">
+                            <span class="detail-label">Maximum:</span>
+                            <span class="detail-value">${details.confidence_stats.maximum.toFixed(3)}</span>
+                        </div>
+                        <div class="detail-item">
+                            <span class="detail-label">Minimum:</span>
+                            <span class="detail-value">${details.confidence_stats.minimum.toFixed(3)}</span>
+                        </div>
+                        <div class="detail-item">
+                            <span class="detail-label">Measurements:</span>
+                            <span class="detail-value">${details.confidence_stats.total_measurements}</span>
+                        </div>
+                    </div>
+                </div>
+                
+                <div class="detail-section">
+                    <h4>Templates Used</h4>
+                    <div class="template-list">
+                        ${details.templates_used.length > 0 ? 
+                            details.templates_used.map(template => `<span class="template-tag">${template}</span>`).join('') :
+                            '<span class="no-templates">No templates detected</span>'
+                        }
+                    </div>
+                </div>
+            </div>
+            
+            <style>
+                .file-details { font-size: 0.875rem; }
+                .detail-section { margin-bottom: 1.5rem; }
+                .detail-section h4 { 
+                    margin-bottom: 0.75rem; 
+                    color: var(--accent-primary); 
+                    font-weight: 600;
+                }
+                .detail-grid { 
+                    display: grid; 
+                    grid-template-columns: 1fr 1fr; 
+                    gap: 0.5rem; 
+                }
+                .detail-item { 
+                    display: flex; 
+                    justify-content: space-between; 
+                    padding: 0.5rem; 
+                    background: var(--bg-secondary); 
+                    border-radius: var(--radius); 
+                }
+                .detail-label { color: var(--text-secondary); }
+                .detail-value { font-weight: 500; }
+                .template-list { 
+                    display: flex; 
+                    flex-wrap: wrap; 
+                    gap: 0.5rem; 
+                }
+                .template-tag { 
+                    background: var(--accent-primary); 
+                    color: white; 
+                    padding: 0.25rem 0.5rem; 
+                    border-radius: var(--radius); 
+                    font-size: 0.75rem; 
+                }
+                .no-templates { 
+                    color: var(--text-muted); 
+                    font-style: italic; 
+                }
+            </style>
+        `;
+    } else {
+        elements.modalBody.innerHTML = '<p>Failed to load file details.</p>';
+    }
+}
+
+function showModal() {
+    elements.fileModal.classList.add('show');
+    document.body.style.overflow = 'hidden';
+}
+
+function closeModal() {
+    elements.fileModal.classList.remove('show');
+    document.body.style.overflow = '';
+    selectedFile = null;
+}
+
+// File Operations
+async function downloadFile(filename) {
+    try {
+        const response = await fetch(`${API_BASE_URL}/cursor-data/${filename}`);
+        if (!response.ok) throw new Error('Download failed');
+        
+        const blob = await response.blob();
+        const url = window.URL.createObjectURL(blob);
+        const a = document.createElement('a');
+        a.href = url;
+        a.download = filename;
+        document.body.appendChild(a);
+        a.click();
+        document.body.removeChild(a);
+        window.URL.revokeObjectURL(url);
+        
+        showToast(`Downloaded ${filename}`, 'success');
+    } catch (error) {
+        showToast(`Failed to download ${filename}`, 'error');
+    }
+}
+
+function downloadSelectedFile() {
+    if (selectedFile) {
+        downloadFile(selectedFile);
+    }
+}
+
+function viewFrames() {
+    if (selectedFile) {
+        showToast('Frame viewer feature coming soon!', 'info');
+    }
+}
+
+// Utility Functions
+function formatFileSize(bytes) {
+    if (bytes === 0) return '0 B';
+    const k = 1024;
+    const sizes = ['B', 'KB', 'MB', 'GB'];
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}
+
+function formatDate(dateString) {
+    try {
+        return new Date(dateString).toLocaleDateString();
+    } catch {
+        return dateString;
+    }
+}
+
+function escapeHtml(text) {
+    const div = document.createElement('div');
+    div.textContent = text;
+    return div.innerHTML;
+}
+
+// Log Management
+function clearLogs() {
+    elements.logsContainer.innerHTML = '<div class="log-entry"><span class="log-time">[' + 
+        new Date().toLocaleTimeString() + ']</span><span class="log-message">Logs cleared</span></div>';
+    showToast('Logs cleared', 'info');
+}
+
+function toggleAutoScroll() {
+    autoScrollEnabled = !autoScrollEnabled;
+    elements.autoScroll.classList.toggle('active', autoScrollEnabled);
+    
+    if (autoScrollEnabled) {
+        elements.logsContainer.scrollTop = elements.logsContainer.scrollHeight;
+    }
+}
+
+// Loading and Toast Functions
+function showLoading() {
+    elements.loadingOverlay.classList.add('show');
+}
+
+function hideLoading() {
+    elements.loadingOverlay.classList.remove('show');
+}
+
+function showToast(message, type = 'info', duration = 5000) {
+    const toast = document.createElement('div');
+    toast.className = `toast ${type}`;
+    
+    const icons = {
+        success: 'fas fa-check-circle',
+        error: 'fas fa-exclamation-circle',
+        warning: 'fas fa-exclamation-triangle',
+        info: 'fas fa-info-circle'
+    };
+    
+    toast.innerHTML = `
+        <i class="toast-icon ${icons[type]}"></i>
+        <div class="toast-content">
+            <div class="toast-message">${escapeHtml(message)}</div>
+        </div>
+        <button class="toast-close">
+            <i class="fas fa-times"></i>
+        </button>
+    `;
+    
+    const closeBtn = toast.querySelector('.toast-close');
+    closeBtn.addEventListener('click', () => removeToast(toast));
+    
+    elements.toastContainer.appendChild(toast);
+    
+    // Auto-remove after duration
+    setTimeout(() => removeToast(toast), duration);
+}
+
+function removeToast(toast) {
+    if (toast && toast.parentNode) {
+        toast.style.animation = 'slideInRight 0.3s ease reverse';
+        setTimeout(() => {
+            if (toast.parentNode) {
+                toast.parentNode.removeChild(toast);
+            }
+        }, 300);
+    }
+}
+
+// Auto-refresh Management
+function startAutoRefresh() {
+    fetchAllData(); // Initial fetch
+    refreshInterval = setInterval(fetchAllData, REFRESH_INTERVAL);
+}
+
+function stopAutoRefresh() {
+    if (refreshInterval) {
+        clearInterval(refreshInterval);
+        refreshInterval = null;
+    }
+}
+
+async function fetchInitialData() {
+    await fetchAllData();
+}
+
+async function fetchAllData() {
+    try {
+        await Promise.all([
+            fetchStatus(),
+            fetchCursorData()
+        ]);
+    } catch (error) {
+        console.error('Failed to fetch data:', error);
+    }
+}
+
+// Cleanup on page unload
+window.addEventListener('beforeunload', () => {
+    stopAutoRefresh();
+});
+

static/style.css

@@ -0,0 +1,770 @@
+/* Reset and Base Styles */
+* {
+    margin: 0;
+    padding: 0;
+    box-sizing: border-box;
+}
+
+:root {
+    /* Light theme colors */
+    --bg-primary: #ffffff;
+    --bg-secondary: #f8fafc;
+    --bg-tertiary: #f1f5f9;
+    --text-primary: #1e293b;
+    --text-secondary: #64748b;
+    --text-muted: #94a3b8;
+    --border-color: #e2e8f0;
+    --accent-primary: #3b82f6;
+    --accent-secondary: #8b5cf6;
+    --success: #10b981;
+    --warning: #f59e0b;
+    --danger: #ef4444;
+    --shadow: 0 1px 3px 0 rgb(0 0 0 / 0.1), 0 1px 2px -1px rgb(0 0 0 / 0.1);
+    --shadow-lg: 0 10px 15px -3px rgb(0 0 0 / 0.1), 0 4px 6px -4px rgb(0 0 0 / 0.1);
+    --radius: 8px;
+    --radius-lg: 12px;
+    --transition: all 0.2s ease-in-out;
+}
+
+[data-theme="dark"] {
+    --bg-primary: #0f172a;
+    --bg-secondary: #1e293b;
+    --bg-tertiary: #334155;
+    --text-primary: #f8fafc;
+    --text-secondary: #cbd5e1;
+    --text-muted: #64748b;
+    --border-color: #334155;
+    --shadow: 0 1px 3px 0 rgb(0 0 0 / 0.3), 0 1px 2px -1px rgb(0 0 0 / 0.3);
+    --shadow-lg: 0 10px 15px -3px rgb(0 0 0 / 0.3), 0 4px 6px -4px rgb(0 0 0 / 0.3);
+}
+
+body {
+    font-family: 'Inter', -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif;
+    background: var(--bg-secondary);
+    color: var(--text-primary);
+    line-height: 1.6;
+    transition: var(--transition);
+}
+
+/* Container */
+.container {
+    max-width: 1400px;
+    margin: 0 auto;
+    padding: 0 1rem;
+}
+
+/* Header */
+.header {
+    background: var(--bg-primary);
+    border-bottom: 1px solid var(--border-color);
+    padding: 1rem 0;
+    position: sticky;
+    top: 0;
+    z-index: 100;
+    backdrop-filter: blur(10px);
+}
+
+.header-content {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.logo {
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+}
+
+.logo i {
+    font-size: 1.5rem;
+    color: var(--accent-primary);
+}
+
+.logo h1 {
+    font-size: 1.5rem;
+    font-weight: 600;
+    color: var(--text-primary);
+}
+
+.header-actions {
+    display: flex;
+    align-items: center;
+    gap: 1rem;
+}
+
+/* Main Content */
+.main-content {
+    padding: 2rem 0;
+    display: flex;
+    flex-direction: column;
+    gap: 2rem;
+}
+
+/* Cards */
+.card {
+    background: var(--bg-primary);
+    border: 1px solid var(--border-color);
+    border-radius: var(--radius-lg);
+    box-shadow: var(--shadow);
+    overflow: hidden;
+    transition: var(--transition);
+}
+
+.card:hover {
+    box-shadow: var(--shadow-lg);
+}
+
+.card-header {
+    padding: 1.5rem;
+    border-bottom: 1px solid var(--border-color);
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.card-header h2 {
+    font-size: 1.25rem;
+    font-weight: 600;
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+}
+
+.card-header i {
+    color: var(--accent-primary);
+}
+
+.card-content {
+    padding: 1.5rem;
+}
+
+/* Status Section */
+.status-indicator {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    font-size: 0.875rem;
+    font-weight: 500;
+}
+
+.status-dot {
+    width: 8px;
+    height: 8px;
+    border-radius: 50%;
+    background: var(--text-muted);
+    animation: pulse 2s infinite;
+}
+
+.status-dot.running {
+    background: var(--success);
+}
+
+.status-dot.stopped {
+    background: var(--danger);
+}
+
+.status-dot.idle {
+    background: var(--warning);
+}
+
+@keyframes pulse {
+    0%, 100% { opacity: 1; }
+    50% { opacity: 0.5; }
+}
+
+.stats-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(120px, 1fr));
+    gap: 1.5rem;
+    margin-bottom: 2rem;
+}
+
+.stat-item {
+    text-align: center;
+    padding: 1rem;
+    background: var(--bg-secondary);
+    border-radius: var(--radius);
+    transition: var(--transition);
+}
+
+.stat-item:hover {
+    transform: translateY(-2px);
+    box-shadow: var(--shadow);
+}
+
+.stat-value {
+    font-size: 2rem;
+    font-weight: 700;
+    color: var(--accent-primary);
+    margin-bottom: 0.25rem;
+}
+
+.stat-label {
+    font-size: 0.875rem;
+    color: var(--text-secondary);
+    font-weight: 500;
+}
+
+.progress-section {
+    background: var(--bg-secondary);
+    padding: 1.5rem;
+    border-radius: var(--radius);
+}
+
+.progress-info {
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+    margin-bottom: 1rem;
+    font-size: 0.875rem;
+}
+
+.current-file {
+    font-weight: 600;
+    color: var(--accent-primary);
+    max-width: 300px;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    white-space: nowrap;
+}
+
+.progress-bar {
+    height: 8px;
+    background: var(--bg-tertiary);
+    border-radius: 4px;
+    overflow: hidden;
+    margin-bottom: 0.5rem;
+}
+
+.progress-fill {
+    height: 100%;
+    background: linear-gradient(90deg, var(--accent-primary), var(--accent-secondary));
+    border-radius: 4px;
+    transition: width 0.3s ease;
+    width: 0%;
+}
+
+.progress-text {
+    text-align: center;
+    font-size: 0.875rem;
+    font-weight: 600;
+    color: var(--text-secondary);
+}
+
+/* Control Section */
+.control-group {
+    display: flex;
+    flex-direction: column;
+    gap: 1.5rem;
+}
+
+.input-group {
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+}
+
+.input-group label {
+    font-weight: 500;
+    color: var(--text-primary);
+}
+
+.input {
+    padding: 0.75rem;
+    border: 1px solid var(--border-color);
+    border-radius: var(--radius);
+    background: var(--bg-primary);
+    color: var(--text-primary);
+    font-size: 0.875rem;
+    transition: var(--transition);
+    max-width: 200px;
+}
+
+.input:focus {
+    outline: none;
+    border-color: var(--accent-primary);
+    box-shadow: 0 0 0 3px rgb(59 130 246 / 0.1);
+}
+
+.input-help {
+    font-size: 0.75rem;
+    color: var(--text-muted);
+}
+
+.button-group {
+    display: flex;
+    gap: 1rem;
+    flex-wrap: wrap;
+}
+
+/* Buttons */
+.btn {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.75rem 1.5rem;
+    border: none;
+    border-radius: var(--radius);
+    font-size: 0.875rem;
+    font-weight: 500;
+    cursor: pointer;
+    transition: var(--transition);
+    text-decoration: none;
+    white-space: nowrap;
+}
+
+.btn:disabled {
+    opacity: 0.5;
+    cursor: not-allowed;
+}
+
+.btn-primary {
+    background: var(--accent-primary);
+    color: white;
+}
+
+.btn-primary:hover:not(:disabled) {
+    background: #2563eb;
+    transform: translateY(-1px);
+    box-shadow: var(--shadow);
+}
+
+.btn-secondary {
+    background: var(--bg-secondary);
+    color: var(--text-primary);
+    border: 1px solid var(--border-color);
+}
+
+.btn-secondary:hover:not(:disabled) {
+    background: var(--bg-tertiary);
+    transform: translateY(-1px);
+}
+
+.btn-danger {
+    background: var(--danger);
+    color: white;
+}
+
+.btn-danger:hover:not(:disabled) {
+    background: #dc2626;
+    transform: translateY(-1px);
+    box-shadow: var(--shadow);
+}
+
+.btn-sm {
+    padding: 0.5rem 1rem;
+    font-size: 0.75rem;
+}
+
+.btn-icon {
+    padding: 0.75rem;
+    width: auto;
+    height: auto;
+}
+
+.btn.active {
+    background: var(--accent-primary);
+    color: white;
+}
+
+/* Files Section */
+.file-count {
+    font-size: 0.875rem;
+    color: var(--text-secondary);
+    font-weight: 500;
+}
+
+.files-grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
+    gap: 1rem;
+}
+
+.file-card {
+    background: var(--bg-secondary);
+    border: 1px solid var(--border-color);
+    border-radius: var(--radius);
+    padding: 1rem;
+    transition: var(--transition);
+    cursor: pointer;
+}
+
+.file-card:hover {
+    transform: translateY(-2px);
+    box-shadow: var(--shadow);
+    border-color: var(--accent-primary);
+}
+
+.file-header {
+    display: flex;
+    justify-content: space-between;
+    align-items: flex-start;
+    margin-bottom: 0.75rem;
+}
+
+.file-name {
+    font-weight: 600;
+    color: var(--text-primary);
+    font-size: 0.875rem;
+    word-break: break-word;
+    flex: 1;
+    margin-right: 0.5rem;
+}
+
+.file-size {
+    font-size: 0.75rem;
+    color: var(--text-muted);
+    white-space: nowrap;
+}
+
+.file-stats {
+    display: grid;
+    grid-template-columns: 1fr 1fr;
+    gap: 0.5rem;
+    margin-bottom: 0.75rem;
+}
+
+.file-stat {
+    display: flex;
+    justify-content: space-between;
+    font-size: 0.75rem;
+}
+
+.file-stat-label {
+    color: var(--text-secondary);
+}
+
+.file-stat-value {
+    color: var(--text-primary);
+    font-weight: 500;
+}
+
+.file-actions {
+    display: flex;
+    gap: 0.5rem;
+}
+
+.file-actions .btn {
+    padding: 0.5rem 0.75rem;
+    font-size: 0.75rem;
+}
+
+/* Logs Section */
+.log-controls {
+    display: flex;
+    gap: 0.5rem;
+}
+
+.logs-container {
+    background: var(--bg-secondary);
+    border: 1px solid var(--border-color);
+    border-radius: var(--radius);
+    height: 300px;
+    overflow-y: auto;
+    padding: 1rem;
+    font-family: 'Monaco', 'Menlo', 'Ubuntu Mono', monospace;
+    font-size: 0.75rem;
+    line-height: 1.4;
+}
+
+.log-entry {
+    margin-bottom: 0.5rem;
+    display: flex;
+    gap: 0.5rem;
+}
+
+.log-time {
+    color: var(--text-muted);
+    white-space: nowrap;
+}
+
+.log-message {
+    color: var(--text-primary);
+    word-break: break-word;
+}
+
+.log-entry.error .log-message {
+    color: var(--danger);
+}
+
+.log-entry.success .log-message {
+    color: var(--success);
+}
+
+.log-entry.warning .log-message {
+    color: var(--warning);
+}
+
+/* Modal */
+.modal {
+    display: none;
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background: rgba(0, 0, 0, 0.5);
+    z-index: 1000;
+    backdrop-filter: blur(4px);
+}
+
+.modal.show {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    animation: fadeIn 0.2s ease;
+}
+
+.modal-content {
+    background: var(--bg-primary);
+    border-radius: var(--radius-lg);
+    box-shadow: var(--shadow-lg);
+    max-width: 600px;
+    width: 90%;
+    max-height: 80vh;
+    overflow: hidden;
+    animation: slideUp 0.2s ease;
+}
+
+.modal-header {
+    padding: 1.5rem;
+    border-bottom: 1px solid var(--border-color);
+    display: flex;
+    justify-content: space-between;
+    align-items: center;
+}
+
+.modal-header h3 {
+    font-size: 1.25rem;
+    font-weight: 600;
+}
+
+.modal-close {
+    background: none;
+    border: none;
+    font-size: 1.25rem;
+    cursor: pointer;
+    color: var(--text-muted);
+    padding: 0.25rem;
+    border-radius: var(--radius);
+    transition: var(--transition);
+}
+
+.modal-close:hover {
+    background: var(--bg-secondary);
+    color: var(--text-primary);
+}
+
+.modal-body {
+    padding: 1.5rem;
+    max-height: 400px;
+    overflow-y: auto;
+}
+
+.modal-footer {
+    padding: 1.5rem;
+    border-top: 1px solid var(--border-color);
+    display: flex;
+    gap: 1rem;
+    justify-content: flex-end;
+}
+
+/* Loading Overlay */
+.loading-overlay {
+    display: none;
+    position: fixed;
+    top: 0;
+    left: 0;
+    width: 100%;
+    height: 100%;
+    background: rgba(0, 0, 0, 0.3);
+    z-index: 2000;
+    backdrop-filter: blur(2px);
+}
+
+.loading-overlay.show {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.loading-spinner {
+    background: var(--bg-primary);
+    padding: 2rem;
+    border-radius: var(--radius-lg);
+    text-align: center;
+    box-shadow: var(--shadow-lg);
+}
+
+.loading-spinner i {
+    font-size: 2rem;
+    color: var(--accent-primary);
+    margin-bottom: 1rem;
+}
+
+.loading-spinner p {
+    color: var(--text-secondary);
+    font-weight: 500;
+}
+
+/* Toast Notifications */
+.toast-container {
+    position: fixed;
+    top: 1rem;
+    right: 1rem;
+    z-index: 3000;
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+}
+
+.toast {
+    background: var(--bg-primary);
+    border: 1px solid var(--border-color);
+    border-radius: var(--radius);
+    padding: 1rem;
+    box-shadow: var(--shadow-lg);
+    min-width: 300px;
+    animation: slideInRight 0.3s ease;
+    display: flex;
+    align-items: center;
+    gap: 0.75rem;
+}
+
+.toast.success {
+    border-left: 4px solid var(--success);
+}
+
+.toast.error {
+    border-left: 4px solid var(--danger);
+}
+
+.toast.warning {
+    border-left: 4px solid var(--warning);
+}
+
+.toast.info {
+    border-left: 4px solid var(--accent-primary);
+}
+
+.toast-icon {
+    font-size: 1.25rem;
+}
+
+.toast.success .toast-icon {
+    color: var(--success);
+}
+
+.toast.error .toast-icon {
+    color: var(--danger);
+}
+
+.toast.warning .toast-icon {
+    color: var(--warning);
+}
+
+.toast.info .toast-icon {
+    color: var(--accent-primary);
+}
+
+.toast-content {
+    flex: 1;
+}
+
+.toast-title {
+    font-weight: 600;
+    margin-bottom: 0.25rem;
+}
+
+.toast-message {
+    font-size: 0.875rem;
+    color: var(--text-secondary);
+}
+
+.toast-close {
+    background: none;
+    border: none;
+    color: var(--text-muted);
+    cursor: pointer;
+    padding: 0.25rem;
+    border-radius: var(--radius);
+    transition: var(--transition);
+}
+
+.toast-close:hover {
+    background: var(--bg-secondary);
+    color: var(--text-primary);
+}
+
+/* Animations */
+@keyframes fadeIn {
+    from { opacity: 0; }
+    to { opacity: 1; }
+}
+
+@keyframes slideUp {
+    from { transform: translateY(20px); opacity: 0; }
+    to { transform: translateY(0); opacity: 1; }
+}
+
+@keyframes slideInRight {
+    from { transform: translateX(100%); opacity: 0; }
+    to { transform: translateX(0); opacity: 1; }
+}
+
+/* Responsive Design */
+@media (max-width: 768px) {
+    .container {
+        padding: 0 0.5rem;
+    }
+    
+    .header-content {
+        flex-direction: column;
+        gap: 1rem;
+        align-items: flex-start;
+    }
+    
+    .stats-grid {
+        grid-template-columns: repeat(2, 1fr);
+    }
+    
+    .button-group {
+        flex-direction: column;
+    }
+    
+    .files-grid {
+        grid-template-columns: 1fr;
+    }
+    
+    .modal-content {
+        width: 95%;
+        margin: 1rem;
+    }
+    
+    .toast {
+        min-width: 280px;
+    }
+    
+    .toast-container {
+        left: 1rem;
+        right: 1rem;
+    }
+}
+
+@media (max-width: 480px) {
+    .stats-grid {
+        grid-template-columns: 1fr;
+    }
+    
+    .progress-info {
+        flex-direction: column;
+        align-items: flex-start;
+        gap: 0.5rem;
+    }
+    
+    .current-file {
+        max-width: 100%;
+    }
+}
+