Update main.py

main.py

@@ -1,588 +1,96 @@
-"""
-FastAPI — DrivePurge Release Automation
-========================================
-HF Spaces ready (port 7860).
-Endpoints
----------
-GET  /health
-POST /update-file
-GET  /releases
-GET  /releases/{tag}
-GET  /links                   ← ALL release download links, every OS, flat + grouped
-GET  /links/latest            ← latest release only, same format
-GET  /links/{tag}             ← one specific tag, same format
-POST /process-release/{tag}
-POST /trigger                 ← full pipeline (6 steps — see docstring)
-"""
-
-from __future__ import annotations
-
-import base64
-import json
+import gradio as gr
+import sqlite3
+import requests
 import os
-import re
-from datetime import datetime, timezone
-from pathlib import Path
-from typing import Optional
-
-import httpx
-from fastapi import FastAPI, HTTPException
-from fastapi.middleware.cors import CORSMiddleware
-from pydantic import BaseModel, Field
-
-# ── Config ────────────────────────────────────────────────────────────────────
-GITHUB_TOKEN = os.getenv("GITHUB_TOKEN", "")
-
-# Repo that holds the app + releases + version.json
-REPO_OWNER   = os.getenv("REPO_OWNER",   "Drive-Purge")
-REPO_NAME    = os.getenv("REPO_NAME",    "DrivePurge_")
-
-# Repo that holds the website (download.html lives here)
-WEBSITE_OWNER = os.getenv("WEBSITE_OWNER", "Drive-Purge")
-WEBSITE_REPO  = os.getenv("WEBSITE_REPO",  "drive-purge.github.io")
-
-OUTPUT_DIR = Path(os.getenv("OUTPUT_DIR", "/tmp/releases"))   # /tmp is writable on HF Spaces
-
-BASE_URL = "https://api.github.com"
-
-def _gh_headers() -> dict:
-    h = {
-        "Accept":               "application/vnd.github+json",
-        "X-GitHub-Api-Version": "2022-11-28",
-    }
-    if GITHUB_TOKEN:
-        h["Authorization"] = f"Bearer {GITHUB_TOKEN}"
-    return h
-
-OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
-
-# ── OS / arch detection ───────────────────────────────────────────────────────
-_OS_RULES: list[tuple[str, str, str]] = [
-    (r"windows.*amd64|win.*x64|win.*amd64",    "windows", "x86_64"),
-    (r"windows.*arm64|win.*arm64",              "windows", "arm64"),
-    (r"windows.*arm\b|win.*arm\b",              "windows", "arm"),
-    (r"\.exe$|windows|win\b",                   "windows", "x86_64"),
-    (r"macos.*arm64|mac.*arm64|darwin.*arm64",  "macos",   "arm64"),
-    (r"macos.*amd64|mac.*amd64|darwin.*amd64",  "macos",   "x86_64"),
-    (r"macos.*arm\b|mac.*arm\b",                "macos",   "arm64"),
-    (r"macos|darwin|osx",                       "macos",   "universal"),
-    (r"linux.*amd64|linux.*x86_64",             "linux",   "x86_64"),
-    (r"linux.*arm64|linux.*aarch64",            "linux",   "arm64"),
-    (r"linux.*arm\b",                           "linux",   "arm"),
-    (r"linux.*386\b|linux.*x86\b",              "linux",   "x86"),
-    (r"linux",                                  "linux",   "x86_64"),
-    (r"checksums?|sha256|md5|hash",             "all",     "all"),
-]
-
-def _detect_platform(filename: str) -> tuple[str, str]:
-    lower = filename.lower()
-    for pattern, platform, arch in _OS_RULES:
-        if re.search(pattern, lower):
-            return platform, arch
-    return "unknown", "unknown"
-
-
-# ── FastAPI app ───────────────────────────────────────────────────────────────
-app = FastAPI(
-    title="DrivePurge Release Automation",
-    description=(
-        "Automates version tracking, release scanning, per-OS asset mirroring, "
-        "metadata JSON generation, and **website download-link patching** for DrivePurge.\n\n"
-        "Deploy on Hugging Face Spaces (Docker, port 7860) or run locally."
-    ),
-    version="1.0.0",
-    docs_url="/docs",
-    redoc_url="/redoc",
-)
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# ── Request models ────────────────────────────────────────────────────────────
-class UpdateFileRequest(BaseModel):
-    path:    str               = Field(...,   example="version.json")
-    content: dict | list | str = Field(...,   description="dict/list → JSON; str → raw")
-    message: str               = Field(...,   example="chore: bump version")
-    branch:  str               = Field("main")
-
-class TriggerRequest(BaseModel):
-    version:         str  = Field(...,  example="1.1")
-    details:         str  = Field("",   example="Bug fixes and performance improvements",
-                                        description="Release notes written into version.json")
-    download_assets: bool = Field(True, description="Also stream binaries to /tmp?")
-    branch:          str  = Field("main")
-
-class ProcessReleaseRequest(BaseModel):
-    download_assets: bool = Field(True)
-
-# ── Generic GitHub helpers ────────────────────────────────────────────────────
-
-async def gh_get(client: httpx.AsyncClient, path: str) -> dict | list:
-    r = await client.get(f"{BASE_URL}{path}", headers=_gh_headers())
-    if r.status_code == 404:
-        raise HTTPException(404, f"Not found: {path}")
-    if r.status_code not in (200, 201):
-        raise HTTPException(r.status_code, f"GitHub API: {r.text[:400]}")
-    return r.json()
-
-async def gh_put(client: httpx.AsyncClient, path: str, payload: dict) -> dict:
-    r = await client.put(f"{BASE_URL}{path}", headers=_gh_headers(), json=payload)
-    if r.status_code not in (200, 201):
-        raise HTTPException(r.status_code, f"GitHub API: {r.text[:400]}")
-    return r.json()
-
-def _b64_json(content: dict | list | str) -> str:
-    """Encode content to base64 for the GitHub Contents API."""
-    raw = json.dumps(content, indent=2) if isinstance(content, (dict, list)) else str(content)
-    return base64.b64encode(raw.encode()).decode()
 
-def _b64_html(html: str) -> str:
-    return base64.b64encode(html.encode("utf-8")).decode()
-
-async def _file_sha(
-    client: httpx.AsyncClient,
-    path: str,
-    branch: str,
-    owner: str = "",
-    repo: str = "",
-) -> Optional[str]:
-    """Return the current SHA of a file in any repo. None if it doesn't exist."""
-    o = owner or REPO_OWNER
-    r = repo  or REPO_NAME
+def fetch_data(db_path, limit_links=None):
+    if not os.path.exists(db_path):
+        return [], []
+    conn = sqlite3.connect(db_path)
+    cursor = conn.cursor()
+
+    cursor.execute('''CREATE TABLE IF NOT EXISTS links (
+                        id INTEGER PRIMARY KEY,
+                        url TEXT,
+                        status TEXT DEFAULT 'pending'
+                    )''')
     try:
-        d = await gh_get(client, f"/repos/{o}/{r}/contents/{path}?ref={branch}")
-        return d.get("sha")                         # type: ignore[union-attr]
-    except HTTPException as e:
-        if e.status_code == 404:
-            return None
-        raise
-
-def _slug(tag: str) -> str:
-    return re.sub(r"[^a-zA-Z0-9_\-]", "_", tag.lstrip("v"))
-
-# ── Asset / links builders ────────────────────────────────────────────────────
-
-def _asset_entry(asset: dict, local_path: Optional[str] = None) -> dict:
-    platform, arch = _detect_platform(asset["name"])
-    return {
-        "name":         asset["name"],
-        "os":           platform,
-        "arch":         arch,
-        "size_bytes":   asset["size"],
-        "download_url": asset["browser_download_url"],
-        "content_type": asset["content_type"],
-        "created_at":   asset["created_at"],
-        "local_path":   local_path,
-    }
-
-def _links_for_release(release: dict) -> dict:
-    """
-    Return clean download-links payload for one release.
-    Shape
-    -----
-    {
-      tag, name, published_at, html_url, total_assets,
-      all:   [ {name, os, arch, download_url, size_bytes, content_type, created_at} ],
-      by_os: { "windows": {"x86_64": [...]}, "macos": {"arm64": [...]}, ... }
-    }
-    """
-    flat: list[dict] = []
-    by_os: dict[str, dict[str, list]] = {}
-
-    for asset in release.get("assets", []):
-        platform, arch = _detect_platform(asset["name"])
-        entry = {
-            "name":         asset["name"],
-            "os":           platform,
-            "arch":         arch,
-            "download_url": asset["browser_download_url"],
-            "size_bytes":   asset["size"],
-            "content_type": asset["content_type"],
-            "created_at":   asset["created_at"],
-        }
-        flat.append(entry)
-        by_os.setdefault(platform, {}).setdefault(arch, []).append(entry)
-
-    return {
-        "tag":          release["tag_name"],
-        "name":         release["name"],
-        "published_at": release.get("published_at"),
-        "html_url":     release["html_url"],
-        "total_assets": len(flat),
-        "all":          flat,
-        "by_os":        by_os,
-    }
-
-def _build_metadata(release: dict, downloaded: list[dict]) -> dict:
-    dl_map = {d["name"]: d["path"] for d in downloaded}
-    assets = [_asset_entry(a, dl_map.get(a["name"])) for a in release.get("assets", [])]
-    by_os: dict[str, list] = {}
-    for a in assets:
-        by_os.setdefault(a["os"], []).append(a)
-    return {
-        "repo":         f"{REPO_OWNER}/{REPO_NAME}",
-        "tag":          release["tag_name"],
-        "name":         release["name"],
-        "body":         release.get("body", ""),
-        "published_at": release.get("published_at"),
-        "html_url":     release["html_url"],
-        "assets":       assets,
-        "by_os":        by_os,
-        "generated_at": datetime.now(timezone.utc).isoformat(),
-    }
-
-def _pick_zip_url(by_os: dict, os_name: str) -> Optional[str]:
-    """Return the first .zip download URL for the given OS."""
-    for _arch, assets in by_os.get(os_name, {}).items():
-        for asset in assets:
-            if asset["name"].lower().endswith(".zip"):
-                return asset["download_url"]
-    return None
-
-# ── HTML patcher ──────────────────────────────────────────────────────────────
-
-def _patch_download_html(html: str, linux_url: Optional[str], macos_url: Optional[str], windows_url: Optional[str]) -> str:
-    """
-    Replace placeholder href="#" + btn--coming-soon class on each OS download
-    button with the real .zip URL.  Skips an OS if its URL is None.
-    Targets these exact patterns from download.html:
-        href="#" class="btn-dl btn-dl--linux   btn--coming-soon"
-        href="#" class="btn-dl btn-dl--mac     btn--coming-soon"
-        href="#" class="btn-dl btn-dl--windows btn--coming-soon"
-    """
-    replacements = [
-        ("linux",   linux_url),
-        ("mac",     macos_url),
-        ("windows", windows_url),
-    ]
-    for css_key, url in replacements:
-        if not url:
-            continue
-        # Match: href="#" class="btn-dl btn-dl--{key} btn--coming-soon"
-        # Replace with: href="URL" class="btn-dl btn-dl--{key}"
-        html = re.sub(
-            rf'href="#"\s+class="(btn-dl\s+btn-dl--{css_key})\s+btn--coming-soon"',
-            f'href="{url}" class="\\1"',
-            html,
-        )
-    return html
-
-# ── Binary download helper ────────────────────────────────────────────────────
-
-async def _download_assets(client: httpx.AsyncClient, release: dict, folder: Path) -> list[dict]:
-    folder.mkdir(parents=True, exist_ok=True)
-    results = []
-    for asset in release.get("assets", []):
-        dest = folder / asset["name"]
-        async with client.stream("GET", asset["browser_download_url"], follow_redirects=True) as resp:
-            resp.raise_for_status()
-            with open(dest, "wb") as f:
-                async for chunk in resp.aiter_bytes(65536):
-                    f.write(chunk)
-        results.append({"name": asset["name"], "path": str(dest), "size_bytes": dest.stat().st_size})
-    return results
-
-# ── Routes ────────────────────────────────────────────────────────────────────
-
-@app.get("/health", summary="Health check", tags=["Misc"])
-async def health():
-    return {
-        "status":       "ok",
-        "app_repo":     f"{REPO_OWNER}/{REPO_NAME}",
-        "website_repo": f"{WEBSITE_OWNER}/{WEBSITE_REPO}",
-        "output_dir":   str(OUTPUT_DIR),
-    }
-
-
-@app.post("/update-file", summary="Create or update any file in the app repo", tags=["Repo"])
-async def update_file(req: UpdateFileRequest):
-    async with httpx.AsyncClient(timeout=30) as client:
-        sha = await _file_sha(client, req.path, req.branch)
-        payload: dict = {
-            "message": req.message,
-            "content": _b64_json(req.content),
-            "branch":  req.branch,
-        }
-        if sha:
-            payload["sha"] = sha
-        result = await gh_put(client, f"/repos/{REPO_OWNER}/{REPO_NAME}/contents/{req.path}", payload)
-
-    return {
-        "action":   "updated" if sha else "created",
-        "path":     req.path,
-        "branch":   req.branch,
-        "commit":   result.get("commit", {}).get("sha"),
-        "html_url": result.get("content", {}).get("html_url"),
-    }
-
-
-@app.get("/releases", summary="List all releases with per-OS asset URLs", tags=["Releases"])
-async def list_releases():
-    async with httpx.AsyncClient(timeout=30) as client:
-        releases = await gh_get(client, f"/repos/{REPO_OWNER}/{REPO_NAME}/releases")
-    out = []
-    for r in releases:                                              # type: ignore[union-attr]
-        out.append({
-            "tag":          r["tag_name"],
-            "name":         r["name"],
-            "published_at": r.get("published_at"),
-            "html_url":     r["html_url"],
-            "assets":       [_asset_entry(a) for a in r.get("assets", [])],
-        })
-    return {"count": len(out), "releases": out}
-
-
-@app.get("/releases/{tag}", summary="Full detail for one release tag", tags=["Releases"])
-async def get_release(tag: str):
-    async with httpx.AsyncClient(timeout=30) as client:
-        release = await gh_get(client, f"/repos/{REPO_OWNER}/{REPO_NAME}/releases/tags/{tag}")
-    assets = [_asset_entry(a) for a in release.get("assets", [])]  # type: ignore[union-attr]
-    by_os: dict[str, list] = {}
-    for a in assets:
-        by_os.setdefault(a["os"], []).append(a)
-    return {
-        "tag":          release["tag_name"],                        # type: ignore[index]
-        "name":         release["name"],
-        "body":         release.get("body"),
-        "published_at": release.get("published_at"),
-        "html_url":     release["html_url"],
-        "assets":       assets,
-        "by_os":        by_os,
-    }
-
-
-# ── /links ────────────────────────────────────────────────────────────────────
-
-@app.get("/links", summary="Direct download links for every asset across all releases", tags=["Download Links"])
-async def all_download_links():
-    async with httpx.AsyncClient(timeout=30) as client:
-        releases = await gh_get(client, f"/repos/{REPO_OWNER}/{REPO_NAME}/releases")
-    return {
-        "repo":           f"{REPO_OWNER}/{REPO_NAME}",
-        "total_releases": len(releases),                            # type: ignore[arg-type]
-        "fetched_at":     datetime.now(timezone.utc).isoformat(),
-        "releases":       [_links_for_release(r) for r in releases],  # type: ignore[union-attr]
-    }
-
-
-@app.get("/links/latest", summary="Download links for the latest release", tags=["Download Links"])
-async def latest_download_links():
-    async with httpx.AsyncClient(timeout=30) as client:
-        release = await gh_get(client, f"/repos/{REPO_OWNER}/{REPO_NAME}/releases/latest")
-    return {
-        "repo":       f"{REPO_OWNER}/{REPO_NAME}",
-        "fetched_at": datetime.now(timezone.utc).isoformat(),
-        **_links_for_release(release),                              # type: ignore[arg-type]
-    }
-
-
-@app.get("/links/{tag}", summary="Download links for a specific release tag", tags=["Download Links"])
-async def tag_download_links(tag: str):
-    async with httpx.AsyncClient(timeout=30) as client:
-        release = await gh_get(client, f"/repos/{REPO_OWNER}/{REPO_NAME}/releases/tags/{tag}")
-    return {
-        "repo":       f"{REPO_OWNER}/{REPO_NAME}",
-        "fetched_at": datetime.now(timezone.utc).isoformat(),
-        **_links_for_release(release),                              # type: ignore[arg-type]
-    }
-
-
-@app.post("/process-release/{tag}", summary="Download assets + write release JSON", tags=["Releases"])
-async def process_release(tag: str, req: ProcessReleaseRequest = ProcessReleaseRequest()):
-    slug   = _slug(tag)
-    folder = OUTPUT_DIR / f"release{slug}"
-
-    async with httpx.AsyncClient(timeout=600, follow_redirects=True) as client:
-        release    = await gh_get(client, f"/repos/{REPO_OWNER}/{REPO_NAME}/releases/tags/{tag}")
-        downloaded = await _download_assets(client, release, folder) if req.download_assets else []  # type: ignore[arg-type]
-        if not req.download_assets:
-            folder.mkdir(parents=True, exist_ok=True)
-
-    metadata  = _build_metadata(release, downloaded)               # type: ignore[arg-type]
-    json_path = folder / f"release{slug}.json"
-    json_path.write_text(json.dumps(metadata, indent=2))
-
-    return {
-        "release_folder":    str(folder),
-        "assets_downloaded": len(downloaded),
-        "metadata_json":     str(json_path),
-        "metadata":          metadata,
-    }
-
-
-# ── /trigger — full 6-step pipeline ──────────────────────────────────────────
-@app.post(
-    "/trigger",
-    summary="Full pipeline — version.json · v{ver}.json · local mirrors · download.html",
-    tags=["Pipeline"],
-)
-async def trigger(req: TriggerRequest):
-    """
-    Six-step pipeline
-    -----------------
-    1. Push **version.json** to `DrivePurge_` (bump version string).
-    2. Push **v{version}.json** to `DrivePurge_` (full download-links payload
-       identical to what `/links/latest` returns — zip URLs per OS/arch).
-    3. Fetch the latest release's download links and embed them in the response.
-    4. Mirror all release binaries to `/tmp/releases/release{ver}/` (optional).
-    5. Write a local **release{ver}.json** metadata file for each release.
-    6. Fetch, patch, and push **download.html** in `drive-purge.github.io`
-       — replaces `href="#"` + `btn--coming-soon` on each OS button with the
-       real `.zip` download URL for that platform.
-    """
-    results: dict = {}
-
-    async with httpx.AsyncClient(timeout=600, follow_redirects=True) as client:
-
-        # ── Step 1: push version.json ─────────────────────────────────────────
-        now_iso = datetime.now(timezone.utc).isoformat()
-        # Schema: { "version", "details", "download-link" }  — exactly as required
-        new_vj = {
-            "version":       req.version,
-            "details":       req.details or "No details provided.",
-            "download-link": "https://drive-purge.github.io/download.html",
-        }
-        sha_vj = await _file_sha(client, "version.json", req.branch)
-        vj_payload: dict = {
-            "message": f"chore: bump version to {req.version}",
-            "content": _b64_json(new_vj),
-            "branch":  req.branch,
-        }
-        if sha_vj:
-            vj_payload["sha"] = sha_vj
-        cr_vj = await gh_put(client, f"/repos/{REPO_OWNER}/{REPO_NAME}/contents/version.json", vj_payload)
-        results["step1_version_json"] = {
-            "file":     "version.json",
-            "action":   "updated" if sha_vj else "created",
-            "commit":   cr_vj.get("commit", {}).get("sha"),
-            "html_url": cr_vj.get("content", {}).get("html_url"),
-        }
-
-        # ── Step 2: push v{version}.json with full download links ─────────────
-        latest_release = await gh_get(client, f"/repos/{REPO_OWNER}/{REPO_NAME}/releases/latest")
-        links_payload  = _links_for_release(latest_release)        # type: ignore[arg-type]
-        links_payload["generated_at"] = now_iso                    # stamp it
-
-        ver_json_name = f"v{req.version}.json"
-        sha_vlink = await _file_sha(client, ver_json_name, req.branch)
-        vlink_payload: dict = {
-            "message": f"chore: add {ver_json_name} download links",
-            "content": _b64_json(links_payload),
-            "branch":  req.branch,
-        }
-        if sha_vlink:
-            vlink_payload["sha"] = sha_vlink
-        cr_vlink = await gh_put(
-            client,
-            f"/repos/{REPO_OWNER}/{REPO_NAME}/contents/{ver_json_name}",
-            vlink_payload,
-        )
-        results["step2_version_links_json"] = {
-            "file":     ver_json_name,
-            "action":   "updated" if sha_vlink else "created",
-            "commit":   cr_vlink.get("commit", {}).get("sha"),
-            "html_url": cr_vlink.get("content", {}).get("html_url"),
-        }
-
-        # ── Step 3: embed download links in response ──────────────────────────
-        results["step3_download_links"] = {
-            "repo":       f"{REPO_OWNER}/{REPO_NAME}",
-            "fetched_at": now_iso,
-            **links_payload,
-        }
-
-        # ── Step 4 + 5: mirror releases locally ──────────────────────────────
-        all_releases = await gh_get(client, f"/repos/{REPO_OWNER}/{REPO_NAME}/releases")
-        results["step4_5_releases_found"] = len(all_releases)      # type: ignore[arg-type]
-        results["step4_5_releases"] = []
-
-        for release in all_releases:                                # type: ignore[union-attr]
-            r_tag    = release["tag_name"]
-            r_slug   = _slug(r_tag)
-            r_folder = OUTPUT_DIR / f"release{r_slug}"
-
-            downloaded = (
-                await _download_assets(client, release, r_folder)
-                if req.download_assets else []
-            )
-            if not req.download_assets:
-                r_folder.mkdir(parents=True, exist_ok=True)
-
-            metadata  = _build_metadata(release, downloaded)
-            json_path = r_folder / f"release{r_slug}.json"
-            json_path.write_text(json.dumps(metadata, indent=2))
-
-            results["step4_5_releases"].append({
-                "tag":               r_tag,
-                "folder":            str(r_folder),
-                "assets_downloaded": len(downloaded),
-                "json_written":      str(json_path),
-                "os_breakdown":      {k: len(v) for k, v in metadata["by_os"].items()},
-            })
-
-        # ── Step 6: patch download.html in drive-purge.github.io ─────────────
-        by_os      = links_payload["by_os"]
-        linux_url  = _pick_zip_url(by_os, "linux")
-        macos_url  = _pick_zip_url(by_os, "macos")
-        win_url    = _pick_zip_url(by_os, "windows")
-
-        # Fetch current download.html
-        html_file_data = await gh_get(
-            client,
-            f"/repos/{WEBSITE_OWNER}/{WEBSITE_REPO}/contents/download.html?ref=main",
-        )
-        current_sha_html = html_file_data.get("sha")               # type: ignore[union-attr]
-        raw_html = base64.b64decode(                                # type: ignore[union-attr]
-            html_file_data["content"].replace("\n", "")             # type: ignore[index]
-        ).decode("utf-8")
-
-        # Patch the three OS buttons
-        patched_html = _patch_download_html(raw_html, linux_url, macos_url, win_url)
-
-        # Count how many substitutions were actually made
-        subs_made = sum(
-            1 for url in (linux_url, macos_url, win_url) if url
-        )
-
-        html_push_payload: dict = {
-            "message": f"chore: update download links for v{req.version}",
-            "content": _b64_html(patched_html),
-            "branch":  "main",
-        }
-        if current_sha_html:
-            html_push_payload["sha"] = current_sha_html
-
-        cr_html = await gh_put(
-            client,
-            f"/repos/{WEBSITE_OWNER}/{WEBSITE_REPO}/contents/download.html",
-            html_push_payload,
-        )
-        results["step6_download_html"] = {
-            "repo":        f"{WEBSITE_OWNER}/{WEBSITE_REPO}",
-            "file":        "download.html",
-            "buttons_updated": {
-                "linux":   linux_url,
-                "macos":   macos_url,
-                "windows": win_url,
-            },
-            "substitutions_made": subs_made,
-            "commit":   cr_html.get("commit", {}).get("sha"),
-            "html_url": cr_html.get("content", {}).get("html_url"),
+        cursor.execute("SELECT api_key FROM accounts")
+        api_keys = [row[0] for row in cursor.fetchall() if row[0]]
+    except Exception as e:
+        api_keys = []
+        
+    try:
+        query = "SELECT id, url FROM links WHERE status='pending'"
+        if limit_links:
+            query += f" LIMIT {limit_links}"
+            
+        cursor.execute(query)
+        link_records = cursor.fetchall()
+        links = [row[1] for row in link_records if row[1]]
+        
+        if link_records:
+            ids = [str(row[0]) for row in link_records]
+            cursor.execute(f"UPDATE links SET status='processing' WHERE id IN ({','.join(ids)})")
+            conn.commit()
+    except Exception as e:
+        links = []
+        
+    conn.close()
+    return api_keys, links
+
+def trigger_workers(db_path, worker_urls_str, links_per_worker):
+    worker_urls = [u.strip() for u in worker_urls_str.split(',') if u.strip()]
+    if not worker_urls:
+        return "Error: No worker URLs provided."
+        
+    api_keys, links = fetch_data(db_path, limit_links=int(links_per_worker) * len(worker_urls))
+    if not api_keys:
+        return "Error: No API keys found in DB."
+    if not links:
+        return "Error: No pending links found in DB."
+        
+    link_chunks = [links[i:i + int(links_per_worker)] for i in range(0, len(links), int(links_per_worker))]
+    
+    logs = []
+    logs.append(f"Loaded {len(api_keys)} API keys and {len(links)} links.")
+    logs.append(f"Divided into {len(link_chunks)} worker chunks.")
+    
+    for idx, chunk in enumerate(link_chunks):
+        if idx >= len(worker_urls):
+            logs.append("More chunks than workers. Remaining chunks won't be sent.")
+            break
+            
+        worker_url = worker_urls[idx]
+        api_key = api_keys[idx % len(api_keys)]
+        
+        payload = {
+            "links": chunk,
+            "api_key": api_key
         }
+        
+        endpoint = f"{worker_url.rstrip('/')}/process"
+        try:
+            resp = requests.post(endpoint, json=payload, timeout=10)
+            logs.append(f"Sent {len(chunk)} links to {worker_url}: {resp.status_code} - {resp.text}")
+        except Exception as e:
+            logs.append(f"Failed to send to {worker_url}: {str(e)}")
+            
+    return "\n".join(logs)
+
+with gr.Blocks() as app:
+    gr.Markdown("# YouTube Video Orchestrator Host")
+    gr.Markdown("Deploy this to Hugging Face Spaces or run locally. It fetches pending links from your database and delegates them to FastAPI workers.")
+    
+    with gr.Row():
+        db_input = gr.Textbox(label="DB Path", value="data/db/accounts.db")
+        workers_input = gr.Textbox(label="Worker URLs (comma separated)", placeholder="http://localhost:7860, https://your-worker.hf.space")
+        links_per_worker = gr.Number(label="Links per worker", value=2)
+        
+    run_btn = gr.Button("Run Orchestration", variant="primary")
+    output_log = gr.Textbox(label="Logs", lines=10)
+    
+    run_btn.click(fn=trigger_workers, inputs=[db_input, workers_input, links_per_worker], outputs=output_log)
 
-    return results
-
-
-# ── Entry-point ───────────────────────────────────────────────────────────────
 if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run(
-        "main:app",
-        host="0.0.0.0",
-        port=int(os.getenv("PORT", "7860")),
-        reload=False,
-    )
+    app.launch(server_name="0.0.0.0", server_port=7860)