feat: per-plugin settings pages and multi-repo plugin catalog

Plugin settings UI:
- Settings → Plugins now shows a clean list (status dot, name, enabled badge)
  with a Settings button per plugin linking to its own detail page
- Per-plugin detail page at /settings/plugins/<name>/ shows enable toggle,
  all config fields, load status, and failure notice if the plugin errored
- Config saving now scoped per-plugin via POST /settings/plugins/<name>/;
  removes the monolithic save-all-plugins form

Plugin repositories:
- Replace single Plugin Index URL field with a managed list of repositories
  (HTMX add/edit/remove per entry, same pattern as Ansible sources)
- plugin_index.py: fetch_catalog() now accepts a list of URLs, caches per-URL,
  and merges results deduplicating by plugin name (first repo wins)
- Legacy plugins.index_url is auto-migrated to the new list format on first
  access so existing installs don't lose their configured URL

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

fabledscryer/core/plugin_index.py

@@ -8,7 +8,8 @@ from typing import Any
 logger = logging.getLogger(__name__)
 
 _CACHE_TTL = 300  # seconds
-_cache: tuple[dict, float] | None = None  # (raw_data, fetched_at monotonic)
+# Per-URL cache: url → (raw_data, fetched_at monotonic)
+_url_cache: dict[str, tuple[dict, float]] = {}
 
 
 class CatalogPlugin:
@@ -34,44 +35,59 @@ class CatalogPlugin:
         self.tags: list[str] = data.get("tags", [])
 
 
-async def fetch_catalog(index_url: str, force: bool = False) -> list[CatalogPlugin]:
-    """Fetch and parse the remote plugin catalog.
-
-    Results are cached in-process for _CACHE_TTL seconds. Pass force=True to
-    bypass the cache. On network failure, stale cached data is returned if
-    available; otherwise an empty list is returned.
-    """
-    global _cache
+async def _fetch_one(url: str, force: bool = False) -> list[CatalogPlugin]:
+    """Fetch a single index URL, using per-URL cache."""
     import httpx
     import yaml
 
     now = time.monotonic()
-    if not force and _cache is not None:
-        raw, fetched_at = _cache
+    if not force and url in _url_cache:
+        raw, fetched_at = _url_cache[url]
         if now - fetched_at < _CACHE_TTL:
             return [CatalogPlugin(p) for p in raw.get("plugins", [])]
 
     try:
         async with httpx.AsyncClient(timeout=10) as client:
-            resp = await client.get(index_url)
+            resp = await client.get(url)
             resp.raise_for_status()
         raw = yaml.safe_load(resp.text) or {}
-        _cache = (raw, now)
-        logger.info(
-            "Plugin catalog fetched from %s: %d plugin(s)",
-            index_url, len(raw.get("plugins", [])),
-        )
+        _url_cache[url] = (raw, now)
+        logger.info("Plugin catalog fetched from %s: %d plugin(s)", url, len(raw.get("plugins", [])))
         return [CatalogPlugin(p) for p in raw.get("plugins", [])]
     except Exception:
-        logger.exception("Failed to fetch plugin catalog from %s", index_url)
-        if _cache is not None:
-            raw, _ = _cache
-            logger.warning("Returning stale cached catalog")
+        logger.exception("Failed to fetch plugin catalog from %s", url)
+        if url in _url_cache:
+            raw, _ = _url_cache[url]
+            logger.warning("Returning stale cached catalog for %s", url)
             return [CatalogPlugin(p) for p in raw.get("plugins", [])]
         return []
 
 
+async def fetch_catalog(
+    index_urls: str | list[str],
+    force: bool = False,
+) -> list[CatalogPlugin]:
+    """Fetch and merge plugin catalogs from one or more index URLs.
+
+    Results are cached per-URL for _CACHE_TTL seconds. Plugins with the same
+    name across repos are deduplicated — the first occurrence (repo list order)
+    wins. Pass force=True to bypass all caches.
+    """
+    if isinstance(index_urls, str):
+        index_urls = [index_urls]
+
+    seen: dict[str, CatalogPlugin] = {}
+    for url in index_urls:
+        url = url.strip()
+        if not url:
+            continue
+        for plugin in await _fetch_one(url, force=force):
+            if plugin.name not in seen:
+                seen[plugin.name] = plugin
+
+    return list(seen.values())
+
+
 def clear_catalog_cache() -> None:
-    """Invalidate the in-process catalog cache."""
-    global _cache
-    _cache = None
+    """Invalidate all in-process catalog caches."""
+    _url_cache.clear()