jobs

app.py

@@ -5,8 +5,7 @@ import sqlite3
 import json
 import time
 from datetime import datetime, timezone
-from concurrent.futures import ThreadPoolExecutor, as_completed
-from flask import Flask, redirect, request, session, render_template, url_for, g
+from flask import Flask, redirect, request, session, render_template, url_for, g, jsonify
 import requests
 
 app = Flask(__name__)
@@ -83,6 +82,21 @@ def init_db():
                 expires_at REAL
             )
         """)
+        conn.execute("""
+            CREATE TABLE IF NOT EXISTS jobs (
+                id TEXT PRIMARY KEY,
+                type TEXT,
+                user_id TEXT,
+                status TEXT DEFAULT 'pending',
+                progress_current INTEGER DEFAULT 0,
+                progress_total INTEGER DEFAULT 0,
+                progress_stage TEXT DEFAULT '',
+                result TEXT,
+                error TEXT,
+                created_at REAL,
+                updated_at REAL
+            )
+        """)
         conn.commit()
 
 
@@ -112,108 +126,21 @@ def get_base_url():
     return f"https://{SPACE_HOST}"
 
 
-def fetch_user_spaces(username, token=None):
-    cache_key = f"spaces:{username}"
-    cached = cache_get(cache_key)
-    if cached is not None:
-        return cached
-
-    headers = {}
-    if token:
-        headers["Authorization"] = f"Bearer {token}"
-
-    spaces = []
-    url = f"https://huggingface.co/api/spaces?author={username}"
-
-    try:
-        resp = requests.get(url, headers=headers, timeout=10)
-        if resp.status_code == 200:
-            space_list = resp.json()
-            space_ids = [s.get("id", "") for s in space_list if s.get("id")]
-
-            # Fetch individual space details in parallel
-            with ThreadPoolExecutor(max_workers=10) as executor:
-                future_to_id = {
-                    executor.submit(fetch_space_detail, sid, token): sid
-                    for sid in space_ids
-                }
-                details_map = {}
-                for future in as_completed(future_to_id):
-                    sid = future_to_id[future]
-                    try:
-                        details_map[sid] = future.result()
-                    except Exception:
-                        details_map[sid] = None
-
-            # Build list and sort by likes
-            for space in space_list:
-                sid = space.get("id", "")
-                detail = details_map.get(sid)
-                spaces.append(detail if detail else space)
-
-            spaces.sort(key=lambda x: x.get("likes", 0), reverse=True)
-    except Exception:
-        pass
-
-    cache_set(cache_key, spaces)
-    return spaces
-
-
-def fetch_space_detail(space_id, token=None):
-    cache_key = f"space_detail:{space_id}"
-    cached = cache_get(cache_key)
-    if cached is not None:
-        return cached
-
-    headers = {}
-    if token:
-        headers["Authorization"] = f"Bearer {token}"
-
-    try:
-        url = f"https://huggingface.co/api/spaces/{space_id}"
-        resp = requests.get(url, headers=headers, timeout=10)
-        if resp.status_code == 200:
-            detail = resp.json()
-            cache_set(cache_key, detail)
-            return detail
-    except Exception:
-        pass
-
-    return None
-
-
-def fetch_space_discussions(space_id, token=None):
-    cache_key = f"discussions:{space_id}"
-    cached = cache_get(cache_key)
-    if cached is not None:
-        return cached
-
-    headers = {}
-    if token:
-        headers["Authorization"] = f"Bearer {token}"
-
-    discussions = []
-    url = f"https://huggingface.co/api/spaces/{space_id}/discussions"
-
-    try:
-        resp = requests.get(url, headers=headers, timeout=10)
-        if resp.status_code == 200:
-            data = resp.json()
-            discussions = data.get("discussions", [])
-    except Exception:
-        pass
-
-    cache_set(cache_key, discussions)
-    return discussions
+# Import jobs module after app is defined
+from jobs import (
+    create_job, get_job, update_job_progress, complete_job,
+    start_job_thread, run_initial_load_job, run_wake_job
+)
+from hf_api import HuggingFaceAPI
 
 
-def get_discussions_feed(username, token=None, logged_in_user=None):
-    spaces = fetch_user_spaces(username, token)
-
+def get_discussions_feed(spaces, discussions_map, logged_in_user=None):
+    """Build discussions feed from cached data."""
     all_discussions = []
+
     for space in spaces:
         space_id = space.get("id", "")
-        discussions = fetch_space_discussions(space_id, token)
+        discussions = discussions_map.get(space_id, [])
 
         for d in discussions:
             owner_responded = d.get("repoOwner", {}).get("isParticipating", False)
@@ -222,12 +149,11 @@ def get_discussions_feed(username, token=None, logged_in_user=None):
 
             base_score = d.get("numComments", 0) + d.get("numReactionUsers", 0) * 2
             score = base_score
-            # Demote if owner has responded
             if owner_responded:
                 score -= 100
-            # Heavily demote if user started it themselves
             if is_own_discussion:
                 score -= 1000
+
             all_discussions.append({
                 "space_id": space_id,
                 "space_name": space_id.split("/")[-1] if "/" in space_id else space_id,
@@ -333,10 +259,41 @@ def callback():
         "avatar_url": user_info.get("picture"),
     }
     session["access_token"] = access_token
-
     session.pop("oauth_state", None)
 
-    return redirect(url_for("dashboard"))
+    # Start background job to load data
+    username = session["user"]["username"]
+    job_id = create_job("initial_load", username)
+    session["loading_job_id"] = job_id
+
+    start_job_thread(run_initial_load_job, job_id, username, access_token)
+
+    return redirect(url_for("loading"))
+
+
+@app.route("/loading")
+def loading():
+    if "user" not in session:
+        return redirect(url_for("index"))
+
+    job_id = session.get("loading_job_id")
+    if not job_id:
+        return redirect(url_for("dashboard"))
+
+    job = get_job(job_id)
+    if job and job["status"] == "completed":
+        session.pop("loading_job_id", None)
+        return redirect(url_for("dashboard"))
+
+    return render_template("loading.html", job_id=job_id)
+
+
+@app.route("/api/job/<job_id>")
+def get_job_status(job_id):
+    job = get_job(job_id)
+    if not job:
+        return jsonify({"error": "Job not found"}), 404
+    return jsonify(job)
 
 
 @app.route("/dashboard")
@@ -344,14 +301,39 @@ def dashboard():
     if "user" not in session:
         return redirect(url_for("index"))
 
+    # Check if still loading
+    job_id = session.get("loading_job_id")
+    if job_id:
+        job = get_job(job_id)
+        if job and job["status"] not in ("completed", "failed"):
+            return redirect(url_for("loading"))
+        session.pop("loading_job_id", None)
+
     username = session["user"]["username"]
     token = session.get("access_token")
 
     sort_by = request.args.get("sort", "score")
     filter_status = request.args.get("status", "open")
 
-    spaces = fetch_user_spaces(username, token)
-    discussions = get_discussions_feed(username, token, logged_in_user=username)
+    # Try to get from cache first
+    spaces = cache_get(f"spaces:{username}")
+
+    # If no cache, trigger a reload
+    if spaces is None:
+        job_id = create_job("initial_load", username)
+        session["loading_job_id"] = job_id
+        start_job_thread(run_initial_load_job, job_id, username, token)
+        return redirect(url_for("loading"))
+
+    # Build discussions from cache
+    discussions_map = {}
+    for space in spaces:
+        space_id = space.get("id", "")
+        cached_discussions = cache_get(f"discussions:{space_id}")
+        if cached_discussions is not None:
+            discussions_map[space_id] = cached_discussions
+
+    discussions = get_discussions_feed(spaces, discussions_map, logged_in_user=username)
 
     # Filter by status
     if filter_status == "open":
@@ -386,48 +368,32 @@ def logout():
 @app.route("/api/wake-all", methods=["POST"])
 def wake_all_spaces():
     if "user" not in session:
-        return {"error": "Not authenticated"}, 401
+        return jsonify({"error": "Not authenticated"}), 401
 
     username = session["user"]["username"]
     token = session.get("access_token")
 
     if not token:
-        return {"error": "No access token"}, 401
+        return jsonify({"error": "No access token"}), 401
 
-    spaces = fetch_user_spaces(username, token)
-    sleeping_spaces = [
-        s for s in spaces
+    # Get sleeping spaces from cache
+    spaces = cache_get(f"spaces:{username}")
+    if not spaces:
+        return jsonify({"error": "No spaces cached, please refresh"}), 400
+
+    sleeping_space_ids = [
+        s.get("id", "") for s in spaces
         if s.get("runtime", {}).get("stage", "").upper() == "SLEEPING"
     ]
 
-    results = []
-    for space in sleeping_spaces:
-        space_id = space.get("id", "")
-        try:
-            resp = requests.post(
-                f"https://huggingface.co/api/spaces/{space_id}/restart",
-                headers={"Authorization": f"Bearer {token}"},
-                timeout=10,
-            )
-            results.append({
-                "id": space_id,
-                "success": resp.status_code == 200,
-                "status": resp.status_code,
-            })
-        except Exception as e:
-            results.append({
-                "id": space_id,
-                "success": False,
-                "error": str(e),
-            })
+    if not sleeping_space_ids:
+        return jsonify({"job_id": None, "total": 0, "message": "No sleeping spaces"})
 
-    # Clear cache so next load shows updated status
-    cache_key = f"spaces:{username}"
-    db = get_db()
-    db.execute("DELETE FROM cache WHERE key = ?", (cache_key,))
-    db.commit()
+    # Create background job
+    job_id = create_job("wake_spaces", username)
+    start_job_thread(run_wake_job, job_id, username, token, sleeping_space_ids)
 
-    return {"results": results, "total": len(sleeping_spaces)}
+    return jsonify({"job_id": job_id, "total": len(sleeping_space_ids)})
 
 
 # Initialize database on startup

hf_api.py

@@ -0,0 +1,122 @@
+import requests
+from tenacity import retry, stop_after_attempt, wait_exponential, retry_if_exception_type
+from concurrent.futures import ThreadPoolExecutor, as_completed
+
+
+class HuggingFaceAPI:
+    BASE_URL = "https://huggingface.co/api"
+
+    def __init__(self, token=None):
+        self.token = token
+        self.session = requests.Session()
+        if token:
+            self.session.headers["Authorization"] = f"Bearer {token}"
+
+    @retry(
+        stop=stop_after_attempt(3),
+        wait=wait_exponential(multiplier=1, min=1, max=10),
+        retry=retry_if_exception_type((requests.RequestException, requests.Timeout)),
+    )
+    def _request(self, method, endpoint, **kwargs):
+        kwargs.setdefault("timeout", 15)
+        url = f"{self.BASE_URL}/{endpoint}"
+        resp = self.session.request(method, url, **kwargs)
+        resp.raise_for_status()
+        return resp.json()
+
+    def _get(self, endpoint, **kwargs):
+        return self._request("GET", endpoint, **kwargs)
+
+    def _post(self, endpoint, **kwargs):
+        return self._request("POST", endpoint, **kwargs)
+
+    def list_spaces(self, author):
+        return self._get(f"spaces?author={author}")
+
+    def get_space(self, space_id):
+        return self._get(f"spaces/{space_id}")
+
+    def get_space_discussions(self, space_id):
+        data = self._get(f"spaces/{space_id}/discussions")
+        return data.get("discussions", [])
+
+    def restart_space(self, space_id):
+        return self._post(f"spaces/{space_id}/restart")
+
+    def fetch_spaces_with_details(self, author, progress_callback=None):
+        """Fetch all spaces for a user with full details (parallel)."""
+        space_list = self.list_spaces(author)
+        space_ids = [s.get("id", "") for s in space_list if s.get("id")]
+        total = len(space_ids)
+        spaces = []
+        completed = 0
+
+        with ThreadPoolExecutor(max_workers=10) as executor:
+            future_to_id = {
+                executor.submit(self._safe_get_space, sid): sid
+                for sid in space_ids
+            }
+            details_map = {}
+            for future in as_completed(future_to_id):
+                sid = future_to_id[future]
+                details_map[sid] = future.result()
+                completed += 1
+                if progress_callback:
+                    progress_callback("spaces", completed, total)
+
+        for space in space_list:
+            sid = space.get("id", "")
+            detail = details_map.get(sid)
+            spaces.append(detail if detail else space)
+
+        spaces.sort(key=lambda x: x.get("likes", 0), reverse=True)
+        return spaces
+
+    def _safe_get_space(self, space_id):
+        try:
+            return self.get_space(space_id)
+        except Exception:
+            return None
+
+    def fetch_all_discussions(self, spaces, progress_callback=None):
+        """Fetch discussions for all spaces (parallel)."""
+        total = len(spaces)
+        completed = 0
+        all_discussions = {}
+
+        with ThreadPoolExecutor(max_workers=10) as executor:
+            future_to_id = {
+                executor.submit(self._safe_get_discussions, s.get("id", "")): s.get("id", "")
+                for s in spaces
+            }
+            for future in as_completed(future_to_id):
+                sid = future_to_id[future]
+                all_discussions[sid] = future.result() or []
+                completed += 1
+                if progress_callback:
+                    progress_callback("discussions", completed, total)
+
+        return all_discussions
+
+    def _safe_get_discussions(self, space_id):
+        try:
+            return self.get_space_discussions(space_id)
+        except Exception:
+            return []
+
+    def wake_spaces(self, space_ids, progress_callback=None):
+        """Wake multiple spaces, returning results."""
+        total = len(space_ids)
+        results = []
+
+        for i, space_id in enumerate(space_ids):
+            try:
+                self.restart_space(space_id)
+                results.append({"id": space_id, "success": True})
+            except Exception as e:
+                results.append({"id": space_id, "success": False, "error": str(e)})
+
+            if progress_callback:
+                progress_callback("wake", i + 1, total)
+
+        return results

jobs.py

@@ -0,0 +1,168 @@
+import sqlite3
+import json
+import time
+import threading
+import uuid
+from datetime import datetime, timezone
+from hf_api import HuggingFaceAPI
+
+
+DB_PATH = "cache.db"
+
+
+def get_db_connection():
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row
+    return conn
+
+
+def init_jobs_table():
+    with get_db_connection() as conn:
+        conn.execute("""
+            CREATE TABLE IF NOT EXISTS jobs (
+                id TEXT PRIMARY KEY,
+                type TEXT,
+                user_id TEXT,
+                status TEXT DEFAULT 'pending',
+                progress_current INTEGER DEFAULT 0,
+                progress_total INTEGER DEFAULT 0,
+                progress_stage TEXT DEFAULT '',
+                result TEXT,
+                error TEXT,
+                created_at REAL,
+                updated_at REAL
+            )
+        """)
+        conn.commit()
+
+
+def create_job(job_type, user_id):
+    job_id = str(uuid.uuid4())
+    now = time.time()
+    with get_db_connection() as conn:
+        conn.execute(
+            """INSERT INTO jobs (id, type, user_id, status, created_at, updated_at)
+               VALUES (?, ?, ?, 'pending', ?, ?)""",
+            (job_id, job_type, user_id, now, now),
+        )
+        conn.commit()
+    return job_id
+
+
+def update_job_progress(job_id, stage, current, total):
+    with get_db_connection() as conn:
+        conn.execute(
+            """UPDATE jobs SET progress_stage = ?, progress_current = ?,
+               progress_total = ?, status = 'running', updated_at = ? WHERE id = ?""",
+            (stage, current, total, time.time(), job_id),
+        )
+        conn.commit()
+
+
+def complete_job(job_id, result=None, error=None):
+    status = "failed" if error else "completed"
+    with get_db_connection() as conn:
+        conn.execute(
+            """UPDATE jobs SET status = ?, result = ?, error = ?, updated_at = ? WHERE id = ?""",
+            (status, json.dumps(result) if result else None, error, time.time(), job_id),
+        )
+        conn.commit()
+
+
+def get_job(job_id):
+    with get_db_connection() as conn:
+        row = conn.execute("SELECT * FROM jobs WHERE id = ?", (job_id,)).fetchone()
+        if row:
+            return dict(row)
+    return None
+
+
+def get_user_job(user_id, job_type):
+    """Get the most recent job of a type for a user."""
+    with get_db_connection() as conn:
+        row = conn.execute(
+            """SELECT * FROM jobs WHERE user_id = ? AND type = ?
+               ORDER BY created_at DESC LIMIT 1""",
+            (user_id, job_type),
+        ).fetchone()
+        if row:
+            return dict(row)
+    return None
+
+
+def run_initial_load_job(job_id, username, token):
+    """Background job to load spaces and discussions."""
+    def progress_callback(stage, current, total):
+        update_job_progress(job_id, stage, current, total)
+
+    try:
+        api = HuggingFaceAPI(token)
+
+        # Fetch spaces with details
+        update_job_progress(job_id, "spaces", 0, 1)
+        spaces = api.fetch_spaces_with_details(username, progress_callback)
+
+        # Fetch discussions for all spaces
+        update_job_progress(job_id, "discussions", 0, len(spaces))
+        discussions_map = api.fetch_all_discussions(spaces, progress_callback)
+
+        # Store in cache
+        cache_result(username, spaces, discussions_map)
+
+        complete_job(job_id, {"spaces_count": len(spaces), "discussions_count": sum(len(d) for d in discussions_map.values())})
+    except Exception as e:
+        complete_job(job_id, error=str(e))
+
+
+def run_wake_job(job_id, username, token, space_ids):
+    """Background job to wake sleeping spaces."""
+    def progress_callback(stage, current, total):
+        update_job_progress(job_id, stage, current, total)
+
+    try:
+        api = HuggingFaceAPI(token)
+        results = api.wake_spaces(space_ids, progress_callback)
+
+        # Clear spaces cache
+        clear_user_cache(username)
+
+        succeeded = sum(1 for r in results if r["success"])
+        failed = sum(1 for r in results if not r["success"])
+        complete_job(job_id, {"results": results, "succeeded": succeeded, "failed": failed})
+    except Exception as e:
+        complete_job(job_id, error=str(e))
+
+
+def cache_result(username, spaces, discussions_map):
+    """Store fetched data in cache."""
+    import time
+    expires_at = time.time() + 300
+    with get_db_connection() as conn:
+        conn.execute(
+            "INSERT OR REPLACE INTO cache (key, value, expires_at) VALUES (?, ?, ?)",
+            (f"spaces:{username}", json.dumps(spaces), expires_at),
+        )
+        for space_id, discussions in discussions_map.items():
+            conn.execute(
+                "INSERT OR REPLACE INTO cache (key, value, expires_at) VALUES (?, ?, ?)",
+                (f"discussions:{space_id}", json.dumps(discussions), expires_at),
+            )
+        conn.commit()
+
+
+def clear_user_cache(username):
+    """Clear user's spaces cache."""
+    with get_db_connection() as conn:
+        conn.execute("DELETE FROM cache WHERE key = ?", (f"spaces:{username}",))
+        conn.commit()
+
+
+def start_job_thread(target, *args):
+    """Start a background thread for a job."""
+    thread = threading.Thread(target=target, args=args, daemon=True)
+    thread.start()
+    return thread
+
+
+# Initialize jobs table
+init_jobs_table()

requirements.txt

@@ -1,2 +1,3 @@
 flask
-requests
+requests
+tenacity

templates/dashboard.html

@@ -693,7 +693,8 @@
             wakeAllBtn.disabled = true;
             wakeProgress.classList.add('active');
             wakeProgressFill.style.width = '0%';
-            wakeProgressText.textContent = 'Waking spaces...';
+            wakeProgressFill.style.background = '#22c55e';
+            wakeProgressText.textContent = 'Starting...';
             wakeResults.innerHTML = '';
 
             try {
@@ -704,29 +705,65 @@
                     wakeProgressText.textContent = 'Error: ' + data.error;
                     wakeProgressFill.style.background = '#ef4444';
                     wakeProgressFill.style.width = '100%';
-                } else if (data.total === 0) {
+                    wakeAllBtn.disabled = false;
+                    return;
+                }
+
+                if (data.total === 0 || !data.job_id) {
                     wakeProgressText.textContent = 'No sleeping spaces found';
                     wakeProgressFill.style.width = '100%';
-                } else {
-                    const succeeded = data.results.filter(r => r.success).length;
-                    const failed = data.results.filter(r => !r.success).length;
-                    wakeProgressFill.style.width = '100%';
-                    wakeProgressText.textContent = `Done: ${succeeded} succeeded, ${failed} failed`;
-
-                    data.results.forEach(r => {
-                        const div = document.createElement('div');
-                        div.className = 'progress-result ' + (r.success ? 'success' : 'error');
-                        div.innerHTML = `<span>${r.id.split('/')[1]}</span><span>${r.success ? 'OK' : 'Failed'}</span>`;
-                        wakeResults.appendChild(div);
-                    });
+                    wakeAllBtn.disabled = false;
+                    return;
                 }
+
+                // Poll for job progress
+                const jobId = data.job_id;
+                const pollJob = async () => {
+                    const jobResp = await fetch('/api/job/' + jobId);
+                    const job = await jobResp.json();
+
+                    if (job.status === 'completed') {
+                        wakeProgressFill.style.width = '100%';
+                        const result = JSON.parse(job.result || '{}');
+                        wakeProgressText.textContent = `Done: ${result.succeeded || 0} succeeded, ${result.failed || 0} failed`;
+
+                        if (result.results) {
+                            result.results.forEach(r => {
+                                const div = document.createElement('div');
+                                div.className = 'progress-result ' + (r.success ? 'success' : 'error');
+                                div.innerHTML = `<span>${r.id.split('/')[1]}</span><span>${r.success ? 'OK' : 'Failed'}</span>`;
+                                wakeResults.appendChild(div);
+                            });
+                        }
+                        wakeAllBtn.disabled = false;
+                        return;
+                    }
+
+                    if (job.status === 'failed') {
+                        wakeProgressText.textContent = 'Error: ' + (job.error || 'Unknown error');
+                        wakeProgressFill.style.background = '#ef4444';
+                        wakeProgressFill.style.width = '100%';
+                        wakeAllBtn.disabled = false;
+                        return;
+                    }
+
+                    // Update progress
+                    if (job.progress_total > 0) {
+                        const pct = Math.round((job.progress_current / job.progress_total) * 100);
+                        wakeProgressFill.style.width = pct + '%';
+                        wakeProgressText.textContent = `Waking ${job.progress_current} / ${job.progress_total}`;
+                    }
+
+                    setTimeout(pollJob, 500);
+                };
+
+                pollJob();
             } catch (err) {
                 wakeProgressText.textContent = 'Error: ' + err.message;
                 wakeProgressFill.style.background = '#ef4444';
                 wakeProgressFill.style.width = '100%';
+                wakeAllBtn.disabled = false;
             }
-
-            wakeAllBtn.disabled = false;
         });
     </script>
 </body>

templates/loading.html

@@ -0,0 +1,147 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Loading - Spaces Dashboard</title>
+    <style>
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+        }
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Oxygen, Ubuntu, sans-serif;
+            background: #0a0a0a;
+            color: #e5e5e5;
+            min-height: 100vh;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+        }
+        .container {
+            text-align: center;
+            max-width: 400px;
+            width: 90%;
+        }
+        h1 {
+            font-size: 1.25rem;
+            font-weight: 500;
+            margin-bottom: 0.5rem;
+        }
+        .subtitle {
+            color: #666;
+            font-size: 0.875rem;
+            margin-bottom: 2rem;
+        }
+        .progress-container {
+            margin-bottom: 1.5rem;
+        }
+        .progress-bar {
+            height: 4px;
+            background: #222;
+            border-radius: 2px;
+            overflow: hidden;
+            margin-bottom: 0.75rem;
+        }
+        .progress-fill {
+            height: 100%;
+            background: #22c55e;
+            width: 0%;
+            transition: width 0.3s;
+        }
+        .progress-text {
+            font-size: 0.875rem;
+            color: #888;
+        }
+        .stage {
+            font-size: 0.75rem;
+            color: #555;
+            text-transform: uppercase;
+            letter-spacing: 0.05em;
+            margin-bottom: 0.5rem;
+        }
+        .error {
+            color: #ef4444;
+            margin-top: 1rem;
+        }
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>Loading your spaces</h1>
+        <p class="subtitle">Fetching data from Hugging Face...</p>
+        <div class="progress-container">
+            <div class="stage" id="stage">Initializing</div>
+            <div class="progress-bar">
+                <div class="progress-fill" id="progress-fill"></div>
+            </div>
+            <div class="progress-text" id="progress-text">0%</div>
+        </div>
+        <div class="error" id="error" style="display: none;"></div>
+    </div>
+
+    <script>
+        const jobId = "{{ job_id }}";
+        const progressFill = document.getElementById('progress-fill');
+        const progressText = document.getElementById('progress-text');
+        const stageEl = document.getElementById('stage');
+        const errorEl = document.getElementById('error');
+
+        const stageNames = {
+            'spaces': 'Fetching spaces',
+            'discussions': 'Loading discussions',
+            'pending': 'Initializing',
+            '': 'Initializing'
+        };
+
+        async function poll() {
+            try {
+                const resp = await fetch('/api/job/' + jobId);
+                const job = await resp.json();
+
+                if (job.error) {
+                    errorEl.textContent = 'Error: ' + job.error;
+                    errorEl.style.display = 'block';
+                    return;
+                }
+
+                if (job.status === 'completed') {
+                    progressFill.style.width = '100%';
+                    progressText.textContent = 'Done!';
+                    stageEl.textContent = 'Complete';
+                    setTimeout(() => {
+                        window.location.href = '/dashboard';
+                    }, 500);
+                    return;
+                }
+
+                if (job.status === 'failed') {
+                    errorEl.textContent = 'Error: ' + (job.error || 'Unknown error');
+                    errorEl.style.display = 'block';
+                    progressFill.style.background = '#ef4444';
+                    return;
+                }
+
+                // Update progress
+                const stage = job.progress_stage || '';
+                stageEl.textContent = stageNames[stage] || stage;
+
+                if (job.progress_total > 0) {
+                    const pct = Math.round((job.progress_current / job.progress_total) * 100);
+                    progressFill.style.width = pct + '%';
+                    progressText.textContent = `${job.progress_current} / ${job.progress_total}`;
+                }
+
+                setTimeout(poll, 500);
+            } catch (err) {
+                errorEl.textContent = 'Connection error: ' + err.message;
+                errorEl.style.display = 'block';
+                setTimeout(poll, 2000);
+            }
+        }
+
+        poll();
+    </script>
+</body>
+</html>