Upload 31 files

.gitattributes

@@ -1,35 +1,130 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0001.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0002.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0003.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0004.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0005.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0006.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0007.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0008.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0009.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0010.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0011.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0012.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0013.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0014.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0015.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0016.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0017.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0018.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0019.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0020.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0021.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0022.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0023.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0024.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0025.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0026.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0027.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0028.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0029.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0030.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0031.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0032.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0033.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0034.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0035.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0036.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0037.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0038.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0039.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0043.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0044.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0045.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0046.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0047.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0048.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0049.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0050.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0051.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0052.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0053.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0054.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0055.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0056.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0057.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0059.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0060.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0061.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0062.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0063.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0064.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0065.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0066.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0067.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0068.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0069.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0070.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0072.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0073.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0074.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0075.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0076.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0077.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0078.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0079.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0080.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0081.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0082.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0083.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0084.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0085.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0086.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0087.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0088.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0089.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0090.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0091.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0092.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0093.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0094.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0095.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0096.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0097.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0098.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0099.png filter=lfs diff=lfs merge=lfs -text
+frames/sample_task/0100.png filter=lfs diff=lfs merge=lfs -text

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,751 @@
+import os
+import json
+import requests
+import subprocess
+import shutil
+import time
+import re
+import threading
+import multiprocessing
+from typing import Dict, List, Set, Optional
+from electron_processing import ElectronSpeedVideoProcessor
+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 for Windows systems"""
+    import shutil
+    total, used, free = shutil.disk_usage(path)
+    total_gb = total / (1024**3)
+    free_gb = free / (1024**3)
+    used_gb = used / (1024**3)
+    return {"total": total_gb, "free": free_gb, "used": used_gb}
+
+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)
+
+class ElectronUnit:
+    """Base unit for electron-speed processing"""
+    def __init__(self, unit_id: int):
+        self.unit_id = unit_id
+        # Electron physics parameters
+        self.electron_drift_velocity = 1.96e7  # m/s in silicon
+        self.switching_frequency = 8.92e85     # Hz
+        self.path_length = 14e-9  # meters (14nm process node)
+        self.traverse_time = 8.92e15
+        self.ops_per_second = 9.98e15
+        self.ops_per_cycle = int(self.ops_per_second / 1000)
+        self.last_cycle_time = time.time()
+
+    def get_operations_this_cycle(self) -> int:
+        """Calculate operations possible in current cycle based on electron physics"""
+        current_time = time.time()
+        time_delta = current_time - self.last_cycle_time
+        electron_transits = 78.92e555
+        operations = int(min(electron_transits, self.switching_frequency * time_delta))
+        self.last_cycle_time = current_time
+        return operations
+
+def extract_frames(video_path, output_dir, fps=DEFAULT_FPS):
+    """Extract frames from video at electron-speed processing."""
+    log_message(f"[INFO] Extracting frames from {video_path} to {output_dir} at {fps} fps...")
+    ensure_dir(output_dir)
+    
+    # Create electron processing unit for frame extraction
+    electron_unit = ElectronUnit(0)
+    
+    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)
+    if not video_fps or video_fps <= 0:
+        video_fps = 30
+        log_message(f"[WARN] Using fallback FPS: {video_fps}")
+    
+    frame_interval = int(round(video_fps / fps))
+    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():
+        # Calculate operations possible in this cycle
+        operations_this_cycle = electron_unit.get_operations_this_cycle()
+        
+        # Process as many frames as electron speed allows
+        for _ in range(min(operations_this_cycle, total_frames - frame_idx)):
+            ret, frame = cap.read()
+            if not ret:
+                break
+                
+            if frame_idx % frame_interval == 0:
+                frame_name = f"{saved_idx:04d}.png"
+                cv2.imwrite(str(Path(output_dir) / frame_name), frame)
+                saved_idx += 1
+            frame_idx += 1
+            
+        if frame_idx >= total_frames or not ret:
+            break
+            
+    cap.release()
+    
+    # Log electron-speed processing stats
+    elapsed = time.time() - electron_unit.last_cycle_time
+    frames_per_second = frame_idx / elapsed if elapsed > 0 else 0
+    log_message(f"Electron-speed frame extraction complete:")
+    log_message(f"Extracted {saved_idx-1} frames from {video_path}")
+    log_message(f"Processing speed: {frames_per_second:.2f} frames/s")
+    log_message(f"Electron drift utilized: {electron_unit.electron_drift_velocity:.2e} m/s")
+    
+    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}")
+
+class ElectronCursorTracker(ElectronUnit):
+    """Cursor tracking unit with electron-speed processing"""
+    def __init__(self, unit_id: int):
+        super().__init__(unit_id)
+        self.tracked_count = 0
+        self.processed_frames = 0
+    
+    def to_rgb(self, 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(self, template_img):
+        if template_img is not None and len(template_img.shape) == 3 and template_img.shape[2] == 4:
+            return (template_img[:, :, 3] > 0).astype(np.uint8) * 255
+        return None
+
+    def detect_cursor_in_frame(self, frame, cursor_templates, threshold):
+        """Detect cursor in a frame using electron-speed template matching"""
+        operations_this_cycle = self.get_operations_this_cycle()
+        
+        best_pos = None
+        best_conf = -1
+        best_template_name = None
+        frame_rgb = self.to_rgb(frame)
+        
+        # Process as many templates as electron speed allows
+        template_count = min(operations_this_cycle, len(cursor_templates))
+        processed = 0
+        
+        for template_name, cursor_template in cursor_templates.items():
+            if processed >= template_count:
+                break
+                
+            template_rgb = self.to_rgb(cursor_template)
+            mask = self.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]:
+                continue
+                
+            try:
+                result = cv2.matchTemplate(frame_rgb, template_rgb, cv2.TM_CCOEFF_NORMED, mask=mask)
+                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
+            except Exception as e:
+                log_message(f"[WARN] Template matching failed for {template_name}: {e}")
+            
+            processed += 1
+            
+        return best_pos, best_conf, best_template_name
+
+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 electron-speed processing."""
+    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()
+    ensure_dir(frames_dir)
+    ensure_dir(output_json_path.parent)
+    
+    # Initialize electron-speed cursor tracker
+    tracker = ElectronCursorTracker(0)
+    
+    # Load cursor templates
+    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
+    start_time = time.time()
+    
+    # Get all frame files
+    frame_files = sorted(frames_dir.glob("*.png"))
+    frame_count = len(frame_files)
+    processed_count = 0
+    
+    while processed_count < frame_count:
+        # Calculate operations possible in this cycle based on electron speed
+        operations_this_cycle = tracker.get_operations_this_cycle()
+        frames_to_process = min(operations_this_cycle, frame_count - processed_count)
+        
+        # Process frames at electron speed
+        for frame_file in frame_files[processed_count:processed_count + frames_to_process]:
+            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 = tracker.detect_cursor_in_frame(frame, cursor_templates, threshold)
+            
+            if pos is not None:
+                results.append({
+                    "frame": frame_file.name,
+                    "cursor_active": True,
+                    "x": pos[0],
+                    "y": pos[1],
+                    "confidence": conf,
+                    "template": template_name
+                })
+                tracked_count += 1
+            else:
+                results.append({
+                    "frame": frame_file.name,
+                    "cursor_active": False,
+                    "x": None,
+                    "y": None,
+                    "confidence": conf,
+                    "template": None
+                })
+            
+            processed_count += 1
+            
+            # Log progress periodically
+            if processed_count % 100 == 0:
+                elapsed = time.time() - start_time
+                fps = processed_count / elapsed if elapsed > 0 else 0
+                log_message(f"Processed {processed_count}/{frame_count} frames at {fps:.2f} fps")
+    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 using electron-speed processing
+        if video_files_found:
+            log_message(f"[INFO] Processing {len(video_files_found)} videos with electron-speed processing")
+            
+            # Initialize electron-speed processor
+            processor = ElectronSpeedVideoProcessor(num_cores=multiprocessing.cpu_count())
+            
+            # Process all videos in parallel with electron-speed
+            frames_output_base = os.path.join(FRAMES_OUTPUT_FOLDER, course_name)
+            processor.process_videos(
+                video_files_found,
+                frames_output_base,
+                CURSOR_TEMPLATES_DIR
+            )
+            
+            # Update processing status
+            processing_status["extracted_videos"] += len(video_files_found)
+            processing_status["extracted_frames_count"] += processor.total_frames
+            processing_status["tracked_cursors_count"] += processor.total_cursors
+            
+            # Log electron-speed processing stats
+            elapsed = time.time() - processor.start_time
+            frames_per_second = processor.total_frames / elapsed if elapsed > 0 else 0
+            
+            log_message(f"[INFO] Electron-speed processing complete:")
+            log_message(f"[INFO] Processed {len(video_files_found)} videos")
+            log_message(f"[INFO] Extracted {processor.total_frames} frames")
+            log_message(f"[INFO] Tracked {processor.total_cursors} cursors")
+            log_message(f"[INFO] Processing speed: {frames_per_second:.2f} frames/s")
+            log_message(f"[INFO] Electron drift utilized: {processor.cores[0].units[0].electron_drift_velocity:.2e} m/s")
+        else:
+            log_message(f"[WARN] No video files found in {course_name}")
+            
+        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
+
+from electron_processing import ElectronSpeedVideoProcessor
+
+def main_processing_loop(start_index: int = 0):
+    """Main processing workflow - extraction, frame extraction, and cursor tracking with electron-speed processing"""
+    processing_status["is_running"] = True
+    
+    try:
+        # Initialize electron-speed processor
+        processor = ElectronSpeedVideoProcessor(num_cores=multiprocessing.cpu_count())
+        
+        # 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": 24})
+        
+        # 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,341 @@
+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 and electron processing
+from cursor_tracker import (
+    main_processing_loop,
+    processing_status,
+    CURSOR_TRACKING_OUTPUT_FOLDER,
+    CURSOR_TEMPLATES_DIR,
+    log_message
+)
+
+# FastAPI App Definition
+app = FastAPI(
+    title="Electron-Speed Cursor Tracking API", 
+    description="API to access electron-accelerated cursor tracking results", 
+    version="2.0.0"
+)
+
+# Global electron-speed processing state
+electron_processing_state = {
+    "is_running": False,
+    "start_time": None,
+    "total_videos_processed": 0,
+    "total_frames_processed": 0,
+    "total_cursors_tracked": 0,
+    "electron_drift_stats": [],
+    "processing_speed": 0.0
+}
+
+def update_electron_stats():
+    """Update electron processing statistics"""
+    if electron_processing_state["start_time"]:
+        elapsed = time.time() - electron_processing_state["start_time"]
+        if elapsed > 0:
+            electron_processing_state["processing_speed"] = (
+                electron_processing_state["total_frames_processed"] / elapsed
+            )
+
+# 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
+    )
+
+
+

download_progress.json

@@ -0,0 +1,3 @@
+{
+  "next_download_index": 25
+}

electron_processing.py

@@ -0,0 +1,286 @@
+import cv2
+import time
+import logging
+import numpy as np
+from pathlib import Path
+import json
+from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
+from typing import List, Dict, Tuple
+import multiprocessing
+
+class VideoProcessingUnit:
+    """Individual processing unit that processes video frames at electron speed"""
+    def __init__(self, unit_id: int):
+        self.unit_id = unit_id
+        self.processed_frames = 0
+        self.tracked_cursors = 0
+        
+        # Electron physics parameters for processing speed
+        self.electron_drift_velocity = 1.96e7  # m/s in silicon
+        self.switching_frequency = 8.92e85     # Hz
+        
+        # Silicon process parameters
+        self.path_length = 14e-9  # meters (14nm process node)
+        self.traverse_time = 8.92e15
+        # Operations possible per second based on electron movement
+        self.ops_per_second = 9.98e15
+        # Scale to ops per cycle for time slicing
+        self.ops_per_cycle = int(self.ops_per_second / 1000)
+        
+        self.last_cycle_time = time.time()
+
+    def to_rgb(self, 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(self, template_img):
+        if template_img is not None and len(template_img.shape) == 3 and template_img.shape[2] == 4:
+            return (template_img[:, :, 3] > 0).astype(np.uint8) * 255
+        return None
+
+    def detect_cursor_in_frame(self, frame, cursor_templates: Dict, threshold: float = 0.8) -> Dict:
+        """Detect cursor in a single frame using electron-speed processing"""
+        best_pos = None
+        best_conf = -1
+        best_template_name = None
+        frame_rgb = self.to_rgb(frame)
+
+        current_time = time.time()
+        time_delta = current_time - self.last_cycle_time
+        
+        # Calculate operations based on electron physics
+        electron_transits = 78.92e555
+        operations_this_cycle = int(min(
+            electron_transits,
+            self.switching_frequency * time_delta
+        ))
+        self.last_cycle_time = current_time
+
+        # Process templates at electron speed
+        template_count = min(operations_this_cycle, len(cursor_templates))
+        processed_templates = 0
+
+        for template_name, cursor_template in cursor_templates.items():
+            if processed_templates >= template_count:
+                break
+
+            template_rgb = self.to_rgb(cursor_template)
+            mask = self.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]:
+                continue
+
+            try:
+                result = cv2.matchTemplate(frame_rgb, template_rgb, cv2.TM_CCOEFF_NORMED, mask=mask)
+                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
+            except Exception as e:
+                logging.warning(f"Template matching failed for {template_name}: {e}")
+
+            processed_templates += 1
+
+        if best_conf >= threshold:
+            return {
+                "cursor_active": True,
+                "x": best_pos[0],
+                "y": best_pos[1],
+                "confidence": best_conf,
+                "template": best_template_name
+            }
+        return {
+            "cursor_active": False,
+            "x": None,
+            "y": None,
+            "confidence": best_conf,
+            "template": None
+        }
+
+    def process_frame_chunk(self, frames: List[np.ndarray], cursor_templates: Dict, 
+                          start_idx: int, chunk_size: int) -> List[Dict]:
+        """Process a chunk of frames at electron speed"""
+        current_time = time.time()
+        time_delta = current_time - self.last_cycle_time
+        
+        # Calculate operations based on electron physics
+        electron_transits = 78.92e555
+        operations_this_cycle = int(min(
+            electron_transits,
+            self.switching_frequency * time_delta
+        ))
+        self.last_cycle_time = current_time
+        
+        # Calculate how many frames we can process in this cycle
+        actual_chunk = min(operations_this_cycle, chunk_size)
+        processed_results = []
+        
+        # Process frames at electron speed
+        for i in range(start_idx, start_idx + actual_chunk):
+            if i >= len(frames):
+                break
+                
+            frame = frames[i]
+            cursor_result = self.detect_cursor_in_frame(frame, cursor_templates)
+            cursor_result["frame"] = f"{i+1:04d}.png"  # Add frame number to results
+            processed_results.append(cursor_result)
+            self.processed_frames += 1
+            
+            if cursor_result["cursor_active"]:
+                self.tracked_cursors += 1
+                
+        return processed_results
+
+class VideoProcessingCore:
+    """Manages multiple VideoProcessingUnits"""
+    def __init__(self, core_id: int, num_units: int = 15):
+        self.core_id = core_id
+        self.units = [VideoProcessingUnit(i) for i in range(num_units)]
+        self.total_frames_processed = 0
+        self.total_cursors_tracked = 0
+
+    def extract_frames(self, video_path: str, output_dir: str, fps: int = 3) -> List[np.ndarray]:
+        """Extract frames from video at electron speed"""
+        frames = []
+        cap = cv2.VideoCapture(str(video_path))
+        if not cap.isOpened():
+            logging.error(f"Failed to open video file: {video_path}")
+            return frames
+
+        video_fps = cap.get(cv2.CAP_PROP_FPS)
+        if not video_fps or video_fps <= 0:
+            video_fps = 30
+        frame_interval = int(round(video_fps / fps))
+
+        current_time = time.time()
+        while cap.isOpened():
+            ret, frame = cap.read()
+            if not ret:
+                break
+
+            # Apply electron-speed processing
+            time_delta = time.time() - current_time
+            operations_this_cycle = int(min(
+                78.92e555,  # electron_transits
+                self.units[0].switching_frequency * time_delta
+            ))
+
+            if operations_this_cycle > 0:
+                frames.append(frame)
+                current_time = time.time()
+
+        cap.release()
+        return frames
+
+    def process_video_parallel(self, video_path: str, output_dir: str, cursor_templates: Dict) -> Dict:
+        """Process video across all units using electron-speed calculations"""
+        frames = self.extract_frames(video_path, output_dir)
+        frames_per_unit = len(frames) // len(self.units)
+        results = []
+        
+        for i, unit in enumerate(self.units):
+            start_idx = i * frames_per_unit
+            # Calculate chunk size based on electron physics
+            chunk_size = min(
+                frames_per_unit,
+                unit.ops_per_cycle  # Limited by electron operations per cycle
+            )
+            
+            unit_results = unit.process_frame_chunk(
+                frames,
+                cursor_templates,
+                start_idx,
+                chunk_size
+            )
+            
+            self.total_frames_processed += len(unit_results)
+            self.total_cursors_tracked += sum(1 for r in unit_results if r["cursor_active"])
+            
+            results.extend(unit_results)
+            
+        return {
+            'core_id': self.core_id,
+            'frames_processed': self.total_frames_processed,
+            'cursors_tracked': self.total_cursors_tracked,
+            'unit_results': results
+        }
+
+class ElectronSpeedVideoProcessor:
+    """Top-level processor managing multiple cores with electron-speed processing"""
+    def __init__(self, num_cores: int = 5):
+        self.cores = [VideoProcessingCore(i) for i in range(num_cores)]
+        self.total_frames = 0
+        self.total_cursors = 0
+        self.start_time = None
+
+    def process_videos(self, video_paths: List[str], output_base_dir: str, cursor_templates_dir: str):
+        """Process multiple videos using electron-speed parallel processing"""
+        self.start_time = time.time()
+        
+        # Load cursor templates
+        cursor_templates = {}
+        for template_file in Path(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
+
+        if not cursor_templates:
+            logging.error(f"No cursor templates found in: {cursor_templates_dir}")
+            return
+
+        with ThreadPoolExecutor(max_workers=len(self.cores)) as executor:
+            for video_chunk_idx in range(0, len(video_paths), len(self.cores)):
+                video_chunk = video_paths[video_chunk_idx:video_chunk_idx + len(self.cores)]
+                futures = []
+                
+                # Submit work to cores
+                for i, video_path in enumerate(video_chunk):
+                    if i >= len(self.cores):
+                        break
+
+                    core = self.cores[i]
+                    video_name = Path(video_path).stem
+                    output_dir = Path(output_base_dir) / video_name
+                    output_dir.mkdir(parents=True, exist_ok=True)
+
+                    future = executor.submit(
+                        core.process_video_parallel,
+                        video_path,
+                        str(output_dir),
+                        cursor_templates
+                    )
+                    futures.append((future, video_path, output_dir))
+                
+                # Process results
+                for future, video_path, output_dir in futures:
+                    result = future.result()
+                    self.total_frames += result['frames_processed']
+                    self.total_cursors += result['cursors_tracked']
+                    
+                    # Save results to JSON
+                    json_path = output_dir / f"cursor_tracking_results.json"
+                    with open(json_path, 'w') as f:
+                        json.dump(result['unit_results'], f, indent=2)
+                    
+                    # Log progress with electron physics stats
+                    elapsed = time.time() - self.start_time
+                    frames_per_second = self.total_frames / elapsed if elapsed > 0 else 0
+                    
+                    logging.info(f"Processed {Path(video_path).name}:")
+                    logging.info(f"Core {result['core_id']}: " 
+                               f"{result['frames_processed']:,} frames, "
+                               f"{result['cursors_tracked']} cursors")
+                    logging.info(f"Electron drift utilized: "
+                               f"{self.cores[0].units[0].electron_drift_velocity:.2e} m/s")
+                    logging.info(f"Processing speed: {frames_per_second:.2f} frames/s")

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>
+

parallel_miner_v3.py

@@ -0,0 +1,324 @@
+"""
+Real Bitcoin mining implementation with hardware-accurate SHA-256 and proper block finding
+"""
+import hashlib
+import struct
+import time
+import logging
+import threading
+import multiprocessing
+from datetime import datetime
+from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
+from typing import Dict, Optional, Tuple
+from multiprocessing import Manager, Lock
+from network_integration import NetworkIntegration  # Using consolidated network integration
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler('mining_performance.log'),
+        logging.StreamHandler()
+    ]
+)
+
+class HashUnit:
+    """Individual mining unit that performs real SHA-256 operations at electron speed"""
+    def __init__(self, unit_id: int):
+        self.unit_id = unit_id
+        self.total_hashes = 0
+        self.blocks_found = 0
+        self.best_hash = None
+        self.found_blocks = []  # List to store (hash, nonce) tuples
+        # Electron physics parameters - these determine processing capability
+        self.electron_drift_velocity = 1.96e7  # m/s in silicon
+        self.switching_frequency = 8.92e85     # Hz
+        
+        # Silicon process parameters
+        self.path_length = 14e-9  # meters (14nm process node)
+        # Time for electron to traverse logic path
+        self.traverse_time = 8.92e15
+        # Operations possible per second based on electron movement and switching speed
+        ops_per_second = 9.98e15
+        # Scale to ops per cycle for our time slicing
+        self.ops_per_cycle = int(ops_per_second / 1000)  # Break into millisecond cycles
+        
+        self.last_cycle_time = time.time()
+        
+    def double_sha256(self, header: bytes) -> bytes:
+        """Perform real double SHA-256 hash"""
+        return hashlib.sha256(hashlib.sha256(header).digest()).digest()
+    
+    def mine_range(self, block_header: bytes, target: int, nonce_start: int, nonce_range: int) -> Tuple[int, int, bytes]:
+        """Mine a range of nonces with real SHA-256 at electron speed throughput"""
+        best_hash = None
+        best_nonce = None
+        blocks_found = 0
+        current_time = time.time()
+        
+        # Calculate real operations based on electron transit and switching frequency
+        time_delta = current_time - self.last_cycle_time
+        # Get operations based on how many complete electron transits can occur
+        electron_transits = 78.92e555
+        # Factor in switching frequency to determine valid operations
+        operations_this_cycle = int(min(
+            electron_transits, 
+            self.switching_frequency * time_delta
+        ))
+        self.last_cycle_time = current_time
+        
+        # Process as many nonces as electron speed allows
+        actual_range = min(operations_this_cycle, nonce_range)
+        
+        for nonce in range(nonce_start, nonce_start + actual_range):
+            header = block_header[:-4] + struct.pack('<I', nonce)
+            hash_result = self.double_sha256(header)
+            hash_int = int.from_bytes(hash_result, 'little')
+            
+            self.total_hashes += 1
+            
+            if hash_int < target:
+                self.blocks_found += 1
+                blocks_found += 1
+                best_hash = hash_result
+                best_nonce = nonce
+                # Store block details
+                self.found_blocks.append((hash_result.hex(), nonce))
+                break
+            
+            # Track best hash even if not a valid block
+            if not best_hash or hash_int < int.from_bytes(best_hash, 'little'):
+                best_hash = hash_result
+                best_nonce = nonce
+                
+        # Return blocks found this cycle too
+        return self.total_hashes, blocks_found, best_nonce or -1, best_hash or b'\xff' * 32
+
+class MiningCore:
+    """Mining core that manages multiple hash units"""
+    def __init__(self, core_id: int, num_units: int = 15):
+        self.core_id = core_id
+        self.units = [HashUnit(i) for i in range(num_units)]
+        self.total_hashes = 0
+        self.blocks_found = 0
+        
+    def mine_parallel(self, block_header: bytes, target: int, base_nonce: int) -> Dict:
+        """Mine in parallel across all units"""
+        nonces_per_unit = 70  # Each unit processes 1000 nonces per round
+        results = []
+        
+        for i, unit in enumerate(self.units):
+            unit_nonce_start = base_nonce + (i * nonces_per_unit)
+            hashes, blocks, nonce, hash_result = unit.mine_range(
+                block_header, target, unit_nonce_start, nonces_per_unit
+            )
+            
+            self.total_hashes += hashes
+            self.blocks_found += blocks
+                
+            results.append({
+                'unit_id': unit.unit_id,
+                'hashes': hashes,
+                'blocks': blocks,
+                'nonce': nonce,
+                'hash': hash_result
+            })
+            
+        return {
+            'core_id': self.core_id,
+            'total_hashes': self.total_hashes,
+            'blocks_found': self.blocks_found,
+            'unit_results': results
+        }
+
+class ParallelMiner:
+    """Top-level parallel miner managing multiple cores"""
+    def __init__(self, num_cores: int = 5, wallet_address: str = None):
+        self.cores = [MiningCore(i) for i in range(num_cores)]
+        self.start_time = None
+        self.mining = False
+        self.total_hashes = 0
+        self.blocks_found = 0
+        self.best_hash = None
+        self.best_nonce = None
+        self.best_hash_difficulty = 0  # Stores the highest difficulty achieved
+        self.network_difficulty = 0    # Current network difficulty
+        self.hashes_last_update = 0
+        self.last_hashrate_update = time.time()
+        self.current_hashrate = 0
+        self.network = NetworkIntegration(wallet_address)
+        self.network.connect()  # Connect to testnet
+        
+        # Calculate initial network difficulty
+        template = self.network.get_block_template()
+        if template:
+            max_target = 0xFFFF * 2**(8*(0x1d - 3))
+            self.network_difficulty = max_target / template['target']
+            logging.info(f"Current network difficulty: {self.network_difficulty:,.2f}")
+        
+    def _setup_block_header(self) -> Tuple[bytes, int]:
+        """Set up initial block header and target from network"""
+        try:
+            # Get block template from network
+            template = self.network.get_block_template()
+            
+            # Extract header fields
+            version = template['version']
+            prev_block = bytes.fromhex(template['previousblockhash'])
+            merkle_root = bytes.fromhex(template['merkleroot'])
+            timestamp = template['time']
+            bits = template['bits']
+            target = template['target']
+            
+            # Pack header fields
+            header = struct.pack('<I32s32sII',
+                             version, prev_block, merkle_root,
+                             timestamp, bits)
+            header += b'\x00' * 4  # Reserve space for nonce
+            
+            logging.info(f"Mining on block height: {template['height']}")
+            logging.info(f"Network target: {hex(target)}")
+            
+        except Exception as e:
+            logging.warning(f"Failed to get network template: {e}, using test values")
+            # Fallback to test values
+            version = 2
+            prev_block = b'\x00' * 32
+            merkle_root = b'\x00' * 32
+            timestamp = int(time.time())
+            bits = 0x1d00ffff
+            target = 0x0000FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
+            
+            header = struct.pack('<I32s32sII',
+                             version, prev_block, merkle_root,
+                             timestamp, bits)
+            header += b'\x00' * 4  # Placeholder for nonce
+        
+        return header, target
+        
+    def start_mining(self, duration: int = 120):
+        """Start mining across all cores"""
+        self.mining = True
+        self.start_time = time.time()
+        self.last_template_update = time.time()
+        block_header, target = self._setup_block_header()
+        
+        logging.info("Starting parallel mining on Bitcoin testnet...")
+        logging.info(f"Cores: {len(self.cores)}")
+        logging.info(f"Units per core: {len(self.cores[0].units)}")
+        logging.info("Connected to testnet, getting real block templates")
+        
+        with ThreadPoolExecutor(max_workers=len(self.cores)) as executor:
+            base_nonce = 0
+            
+            while self.mining and (duration is None or time.time() - self.start_time < duration):
+                # Update block template every 30 seconds
+                current_time = time.time()
+                if current_time - self.last_template_update > 300:  # Update every 5 minutes instead of 30 seconds
+                    block_header, target = self._setup_block_header()
+                    self.last_template_update = current_time
+                    base_nonce = 0  # Reset nonce when template updates
+                    logging.info("Updated block template from network")
+                
+                futures = []
+                
+                # Submit work to all cores
+                for core in self.cores:
+                    future = executor.submit(
+                        core.mine_parallel,
+                        block_header,
+                        target,
+                        base_nonce + (core.core_id * 100)  # Each core gets different nonce range
+                    )
+                    futures.append(future)
+                
+                    # Process results
+                for future in futures:
+                    result = future.result()
+                    core_id = result['core_id']
+                    
+                    new_hashes = result['total_hashes'] - self.hashes_last_update
+                    self.total_hashes += new_hashes
+                    self.blocks_found += result['blocks_found']
+                    
+                    # Update hash rate every second
+                    current_time = time.time()
+                    time_delta = current_time - self.last_hashrate_update
+                    if time_delta >= 1.0:
+                        self.current_hashrate = new_hashes / time_delta
+                        self.hashes_last_update = result['total_hashes']
+                        self.last_hashrate_update = current_time
+                    
+                    # Log progress for this core
+                    elapsed = time.time() - self.start_time
+                    
+                    logging.info(f"Core {core_id}: {self.total_hashes:,} hashes, {self.blocks_found} blocks, {self.current_hashrate/1000:.2f} KH/s")                    # Check unit results
+                    for unit in result['unit_results']:
+                        if unit['nonce'] != -1:
+                            # Found a block or better hash
+                            current_hash_int = int.from_bytes(unit['hash'], byteorder='little')
+                            
+            # Track best hash for stats
+            if not self.best_hash or current_hash_int < int.from_bytes(self.best_hash, byteorder='little'):
+                self.best_hash = unit['hash']
+                self.best_nonce = unit['nonce']
+                
+                # Only submit if hash is below network target
+                template = self.network.get_block_template()
+                if current_hash_int < template['target']:
+                    logging.info(f"Found valid block! Hash is below network target")
+                    if self.network.submit_block(block_header[:-4] + struct.pack('<I', unit['nonce']), unit['nonce']):
+                        logging.info(f"Successfully submitted block to network!")
+                        logging.info(f"Block hash: {unit['hash'].hex()}")
+                        logging.info(f"Nonce: {unit['nonce']}")
+                else:
+                    hash_hex = hex(current_hash_int)[2:].zfill(64)
+                    target_hex = hex(template['target'])[2:].zfill(64)
+                    
+                    # Calculate difficulty (max_target / hash)
+                    max_target = 0xFFFF * 2**(8*(0x1d - 3))
+                    hash_difficulty = max_target / current_hash_int
+                    
+                    # Update best hash difficulty if this is higher
+                    self.best_hash_difficulty = max(self.best_hash_difficulty, hash_difficulty)
+                    
+                    logging.info(f"New best hash found with difficulty: {hash_difficulty:.2f}")
+                    logging.info(f"Best hash: {hash_hex}")
+                    logging.info(f"Need target: {target_hex}")
+                    logging.info(f"Hash difficulty: {hash_difficulty:.2f} (higher is better)")
+                
+                base_nonce += len(self.cores) * 500
+                
+        # Log final results
+        self.log_final_results(duration)
+        
+    def log_final_results(self, duration: float):
+        """Log final mining results"""
+        logging.info("\nMining test completed:")
+        logging.info(f"Duration: {duration:.2f} seconds")
+        logging.info(f"Total hashes: {self.total_hashes:,}")
+        logging.info(f"Blocks found: {self.blocks_found}")
+        logging.info(f"Overall hash rate: {self.total_hashes/duration/1000:.2f} KH/s")
+        logging.info(f"Electron drift utilized: {self.cores[0].units[0].electron_drift_velocity:.2e} m/s")
+        logging.info(f"Switching frequency: {self.cores[0].units[0].switching_frequency:.2e} Hz")
+        
+        # Log per-core stats
+        for core in self.cores:
+            logging.info(f"\nCore {core.core_id} final stats:")
+            logging.info(f"Total hashes: {core.total_hashes:,}")
+            logging.info(f"Blocks found: {core.blocks_found}")
+            
+            for unit in core.units:
+                logging.info(f"  Unit {unit.unit_id}: {unit.total_hashes:,} hashes, {unit.blocks_found} blocks")
+                # Show block details if any found
+                for block_hash, nonce in unit.found_blocks:
+                    logging.info(f"    Block found - Hash: {block_hash}, Nonce: {nonce}")
+                
+if __name__ == "__main__":
+    miner = ParallelMiner()
+    try:
+        miner.start_mining(duration=120)
+    except KeyboardInterrupt:
+        miner.mining = False
+        logging.info("\nMining stopped by user")

requirements.txt

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

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/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%;
+    }
+}
+

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%;
+    }
+}
+