add 0.6.6

CHANGELOG.md

@@ -11,6 +11,21 @@ Sections:
 
 ---
 
+## [0.6.6] - 2026-01-18
+
+### Added
+- Source filter to limit repositories by origin: BCS Official, HACS, or Custom.
+- Visual source badges for repositories (BCS Official, HACS, Custom).
+- Restored HACS enable/disable toggle in the Store UI.
+
+### Changed
+- HACS repositories now display human-readable names and descriptions based on official HACS metadata.
+- Improved Store usability on mobile devices by fixing back navigation from repository detail view.
+
+### Fixed
+- Fixed missing HACS toggle after UI updates.
+- Fixed mobile browser back button exiting the Store instead of returning to the repository list.
+
 ## [0.6.5] - 2026-01-18
 
 ### Added

bcs.yaml

@@ -4,7 +4,7 @@ description: >
   Supports GitHub, GitLab, Gitea and Bahmcloud repositories with
   a central index, UI panel and API, similar to HACS but independent.
 
-category: integration
+category: Integrations
 
 author: Bahmcloud
 maintainer: Bahmcloud

custom_components/bahmcloud_store/__init__.py

@@ -67,7 +67,7 @@ async def async_setup(hass: HomeAssistant, config: dict) -> bool:
         frontend_url_path="bahmcloud-store",
         webcomponent_name="bahmcloud-store-panel",
         # IMPORTANT: bump v to avoid caching old JS
-        module_url="/api/bahmcloud_store_static/panel.js?v=107",
+        module_url="/api/bahmcloud_store_static/panel.js?v=108",
         sidebar_title="Bahmcloud Store",
         sidebar_icon="mdi:store",
         require_admin=True,

custom_components/bahmcloud_store/core.py

@@ -34,7 +34,9 @@ BACKUP_META_FILENAME = ".bcs_backup_meta.json"
 
 # Optional HACS integrations index (GitHub repositories only).
 HACS_INTEGRATIONS_URL = "https://data-v2.hacs.xyz/integration/repositories.json"
+HACS_INTEGRATIONS_DATA_URL = "https://data-v2.hacs.xyz/integration/data.json"
 HACS_DEFAULT_CATEGORY = "Integrations"
+HACS_CACHE_TTL_SECONDS = 60 * 60 * 24  # 24h
 
 
 class BCSError(Exception):
@@ -102,6 +104,11 @@ class BCSCore:
         # Persistent settings (UI toggles etc.)
         self.settings: dict[str, Any] = {"hacs_enabled": False}
 
+        # Cached HACS metadata (display names/descriptions). Loaded from storage.
+        self._hacs_meta_fetched_at: int = 0
+        self._hacs_meta: dict[str, dict[str, Any]] = {}
+        self._hacs_meta_lock = asyncio.Lock()
+
         # Phase F2: backups before install/update
         self._backup_root = Path(self.hass.config.path(".bcs_backups"))
         self._backup_keep_per_domain: int = 5
@@ -122,6 +129,19 @@ class BCSCore:
         # After a successful HA restart, restart-required is no longer relevant.
         self._clear_restart_required_issue()
 
+        # Load cached HACS metadata (optional; improves UX when HACS toggle is enabled).
+        try:
+            hc = await self.storage.get_hacs_cache()
+            if isinstance(hc, dict):
+                self._hacs_meta_fetched_at = int(hc.get("fetched_at") or 0)
+                repos = hc.get("repos")
+                if isinstance(repos, dict):
+                    # Normalize to string keys
+                    self._hacs_meta = {str(k): (v if isinstance(v, dict) else {}) for k, v in repos.items()}
+        except Exception:
+            self._hacs_meta_fetched_at = 0
+            self._hacs_meta = {}
+
     async def _read_manifest_version_async(self) -> str:
         def _read() -> str:
             try:
@@ -257,6 +277,14 @@ class BCSCore:
         for r in merged.values():
             r.provider = detect_provider(r.url)
 
+        # Apply cached HACS display metadata immediately (fast UX).
+        if hacs_enabled and hacs_repos:
+            self._apply_hacs_meta(merged)
+
+            # Refresh HACS metadata in the background if cache is missing/stale.
+            if self._hacs_meta_needs_refresh():
+                self.hass.async_create_task(self._refresh_hacs_meta_background())
+
         await self._enrich_installed_only(merged)
         self.repos = merged
 
@@ -298,17 +326,158 @@ class BCSCore:
             if not full_name or "/" not in full_name:
                 continue
             repo_id = f"hacs:{full_name.lower()}"
+            owner = full_name.split("/", 1)[0].strip()
             items.append(
                 RepoItem(
                     id=repo_id,
+                    # Name is improved later via cached HACS meta (manifest.name).
                     name=full_name,
                     url=f"https://github.com/{full_name}",
                     source="hacs",
+                    owner=owner,
+                    provider_repo_name=full_name,  # keep stable owner/repo reference
                     meta_category=HACS_DEFAULT_CATEGORY,
                 )
             )
         return items
 
+    def _hacs_meta_needs_refresh(self) -> bool:
+        if not self._hacs_meta_fetched_at or not self._hacs_meta:
+            return True
+        age = int(time.time()) - int(self._hacs_meta_fetched_at)
+        return age > HACS_CACHE_TTL_SECONDS
+
+    def _apply_hacs_meta(self, merged: dict[str, RepoItem]) -> None:
+        """Apply cached HACS metadata to matching repos (no I/O)."""
+        if not self._hacs_meta:
+            return
+
+        def _full_name_from_repo(r: RepoItem) -> str | None:
+            # Prefer the original owner/repo (stable) if we kept it.
+            if r.provider_repo_name and "/" in str(r.provider_repo_name):
+                return str(r.provider_repo_name).strip()
+            # Fall back to URL path: https://github.com/owner/repo
+            try:
+                u = urlparse((r.url or "").strip())
+                parts = [p for p in (u.path or "").strip("/").split("/") if p]
+                if len(parts) >= 2:
+                    repo = parts[1]
+                    if repo.endswith(".git"):
+                        repo = repo[:-4]
+                    return f"{parts[0]}/{repo}"
+            except Exception:
+                pass
+            return None
+
+        for r in merged.values():
+            if r.source != "hacs":
+                continue
+
+            key = _full_name_from_repo(r)
+            if not key or "/" not in key:
+                continue
+
+            meta = self._hacs_meta.get(key)
+            if not isinstance(meta, dict) or not meta:
+                continue
+
+            # Prefer HACS manifest name as display name.
+            display_name = meta.get("name")
+            if isinstance(display_name, str) and display_name.strip():
+                r.name = display_name.strip()
+                r.meta_name = display_name.strip()
+
+            desc = meta.get("description")
+            if isinstance(desc, str) and desc.strip():
+                r.meta_description = desc.strip()
+
+            domain = meta.get("domain")
+            # We don't store domain in RepoItem fields, but keep it in meta_source for debugging.
+            # (Optional: extend RepoItem later if needed.)
+            if isinstance(domain, str) and domain.strip():
+                # Keep under meta_source marker to help identify source.
+                pass
+
+            r.meta_source = r.meta_source or "hacs"
+            r.meta_category = r.meta_category or HACS_DEFAULT_CATEGORY
+
+    async def _refresh_hacs_meta_background(self) -> None:
+        """Fetch and cache HACS integration metadata in the background.
+
+        Uses the official HACS data endpoint which includes manifest data.
+        This avoids per-repo GitHub calls and improves the UX (names/descriptions).
+        """
+        async with self._hacs_meta_lock:
+            # Another task might have refreshed already.
+            if not self._hacs_meta_needs_refresh():
+                return
+
+            session = async_get_clientsession(self.hass)
+            headers = {
+                "User-Agent": "BahmcloudStore (Home Assistant)",
+                "Cache-Control": "no-cache, no-store, max-age=0",
+                "Pragma": "no-cache",
+            }
+
+            try:
+                async with session.get(HACS_INTEGRATIONS_DATA_URL, timeout=120, headers=headers) as resp:
+                    if resp.status != 200:
+                        raise BCSError(f"HACS data.json returned {resp.status}")
+                    data = await resp.json()
+            except Exception as e:
+                _LOGGER.warning("BCS HACS meta refresh failed: %s", e)
+                return
+
+            # Build mapping owner/repo -> {name, description, domain}
+            meta_map: dict[str, dict[str, Any]] = {}
+            if isinstance(data, dict):
+                for _, obj in data.items():
+                    if not isinstance(obj, dict):
+                        continue
+                    full_name = obj.get("full_name")
+                    if not isinstance(full_name, str) or "/" not in full_name:
+                        continue
+
+                    manifest = obj.get("manifest")
+                    mname = None
+                    mdesc = None
+                    mdomain = None
+                    if isinstance(manifest, dict):
+                        mname = manifest.get("name")
+                        mdesc = manifest.get("description")
+                        mdomain = manifest.get("domain")
+
+                    entry: dict[str, Any] = {}
+                    if isinstance(mname, str) and mname.strip():
+                        entry["name"] = mname.strip()
+                    if isinstance(mdesc, str) and mdesc.strip():
+                        entry["description"] = mdesc.strip()
+                    if isinstance(mdomain, str) and mdomain.strip():
+                        entry["domain"] = mdomain.strip()
+
+                    if entry:
+                        meta_map[full_name.strip()] = entry
+
+            self._hacs_meta = meta_map
+            self._hacs_meta_fetched_at = int(time.time())
+
+            try:
+                await self.storage.set_hacs_cache({
+                    "fetched_at": self._hacs_meta_fetched_at,
+                    "repos": self._hacs_meta,
+                })
+            except Exception:
+                _LOGGER.debug("Failed to persist HACS cache", exc_info=True)
+
+            # Apply meta to current repos and notify UI.
+            try:
+                self._apply_hacs_meta(self.repos)
+            except Exception:
+                pass
+
+            _LOGGER.info("BCS HACS metadata cached: repos=%s", len(self._hacs_meta))
+            self.signal_updated()
+
     async def _enrich_and_resolve(self, merged: dict[str, RepoItem]) -> None:
         sem = asyncio.Semaphore(6)
 

custom_components/bahmcloud_store/manifest.json

@@ -1,7 +1,7 @@
 {
   "domain": "bahmcloud_store",
   "name": "Bahmcloud Store",
-  "version": "0.6.5",
+  "version": "0.6.6",
   "documentation": "https://git.bahmcloud.de/bahmcloud/bahmcloud_store",
   "platforms": ["update"],
   "requirements": [],

custom_components/bahmcloud_store/panel/panel.js

@@ -18,6 +18,12 @@ class BahmcloudStorePanel extends HTMLElement {
     this._filter = "all"; // all|installed|not_installed|updates|custom
     this._sort = "az"; // az|updates_first|installed_first
 
+    // Source filter (all|bcs|hacs|custom)
+    this._sourceFilter = "all";
+
+    // HACS toggle (settings)
+    this._hacsEnabled = false;
+
     this._detailRepoId = null;
     this._detailRepo = null;
     this._readmeLoading = false;
@@ -50,6 +56,10 @@ class BahmcloudStorePanel extends HTMLElement {
     this._versionsCache = {}; // repo_id -> [{ref,label,source}, ...]
     this._versionsLoadingRepoId = null;
     this._selectedVersionByRepoId = {}; // repo_id -> ref ("" means latest)
+
+    // History handling (mobile back button should go back to list, not exit panel)
+    this._historyBound = false;
+    this._handlingPopstate = false;
   }
 
   set hass(hass) {
@@ -57,10 +67,43 @@ class BahmcloudStorePanel extends HTMLElement {
     if (!this._rendered) {
       this._rendered = true;
       this._render();
+      this._ensureHistory();
       this._load();
     }
   }
 
+  _ensureHistory() {
+    if (this._historyBound) return;
+    this._historyBound = true;
+
+    try {
+      // Keep an internal history state for this panel.
+      const current = window.history.state || {};
+      if (!current || current.__bcs !== true) {
+        window.history.replaceState({ __bcs: true, view: "store" }, "");
+      }
+    } catch (e) {
+      // ignore
+    }
+
+    window.addEventListener("popstate", (ev) => {
+      const st = ev?.state;
+      if (!st || st.__bcs !== true) return;
+
+      this._handlingPopstate = true;
+      try {
+        const view = st.view || "store";
+        if (view === "detail" && st.repo_id) {
+          this._openRepoDetail(st.repo_id, false);
+        } else {
+          this._closeDetail(false);
+        }
+      } finally {
+        this._handlingPopstate = false;
+      }
+    });
+  }
+
   async _load() {
     if (!this._hass) return;
 
@@ -72,6 +115,12 @@ class BahmcloudStorePanel extends HTMLElement {
       const data = await this._hass.callApi("get", "bcs");
       this._data = data;
 
+      // Persistent settings (e.g. HACS toggle)
+      this._hacsEnabled = !!data?.settings?.hacs_enabled;
+
+      // Sync settings from backend (e.g. HACS toggle)
+      this._hacsEnabled = !!data?.settings?.hacs_enabled;
+
       if (this._view === "detail" && this._detailRepoId && Array.isArray(data?.repos)) {
         const fresh = data.repos.find((r) => this._safeId(r?.id) === this._detailRepoId);
         if (fresh) this._detailRepo = fresh;
@@ -84,6 +133,19 @@ class BahmcloudStorePanel extends HTMLElement {
     }
   }
 
+  async _setSettings(updates) {
+    if (!this._hass) return;
+    try {
+      const resp = await this._hass.callApi("post", "bcs/settings", updates || {});
+      if (resp?.ok) {
+        this._hacsEnabled = !!resp?.settings?.hacs_enabled;
+      }
+    } catch (e) {
+      // Do not fail UI for settings.
+      this._error = e?.message ? String(e.message) : String(e);
+    }
+  }
+
   async _refreshAll() {
     if (!this._hass) return;
     if (this._refreshing) return;
@@ -308,21 +370,15 @@ class BahmcloudStorePanel extends HTMLElement {
   }
 
   _goBack() {
-    if (this._view === "detail") {
-      this._view = "store";
-      this._detailRepoId = null;
-      this._detailRepo = null;
-      this._readmeText = null;
-      this._readmeHtml = null;
-      this._readmeError = null;
-      this._readmeExpanded = false;
-      this._update();
-      return;
-    }
     try {
+      // Prefer browser history so mobile back behaves as expected.
       history.back();
     } catch (_) {
-      window.location.href = "/";
+      if (this._view === "detail") {
+        this._closeDetail(true);
+      } else {
+        window.location.href = "/";
+      }
     }
   }
 
@@ -368,11 +424,15 @@ class BahmcloudStorePanel extends HTMLElement {
     }
   }
 
-  _openRepoDetail(repoId) {
+  _openRepoDetail(repoId, pushHistory = true) {
     const repos = Array.isArray(this._data?.repos) ? this._data.repos : [];
     const repo = repos.find((r) => this._safeId(r?.id) === repoId);
     if (!repo) return;
 
+    if (pushHistory) {
+      this._pushHistory({ view: "detail", repo_id: repoId });
+    }
+
     this._view = "detail";
     this._detailRepoId = repoId;
     this._detailRepo = repo;
@@ -561,6 +621,24 @@ class BahmcloudStorePanel extends HTMLElement {
           box-shadow: 0 0 0 2px rgba(30,136,229,.15);
         }
 
+        .toggle{
+          display:inline-flex;
+          align-items:center;
+          gap:8px;
+          padding:10px 12px;
+          border-radius:14px;
+          border:1px solid var(--divider-color);
+          background: var(--card-background-color);
+          color: var(--primary-text-color);
+          user-select:none;
+          cursor:pointer;
+        }
+        .toggle input{
+          margin:0;
+          width:18px;
+          height:18px;
+        }
+
         button{
           padding:10px 12px;
           border-radius:14px;
@@ -859,6 +937,11 @@ class BahmcloudStorePanel extends HTMLElement {
         const cat = this._safeText(r?.category) || "";
         if (this._category !== "all" && this._category !== cat) return false;
 
+        // Source filter
+        if (this._sourceFilter === "bcs" && r?.source !== "index") return false;
+        if (this._sourceFilter === "hacs" && r?.source !== "hacs") return false;
+        if (this._sourceFilter === "custom" && r?.source !== "custom") return false;
+
         const latest = this._safeText(r?.latest_version);
         const installed = this._asBoolStrict(r?.installed);
         const installedVersion = this._safeText(r?.installed_version);
@@ -913,7 +996,11 @@ class BahmcloudStorePanel extends HTMLElement {
         const updateAvailable = installed && !!latest && (!installedVersion || latest !== installedVersion);
 
         const badges = [];
-        if (r?.source === "custom") badges.push("Custom");
+        // Source badges
+        if (r?.source === "index") badges.push("BCS Official");
+        else if (r?.source === "hacs") badges.push("HACS");
+        else if (r?.source === "custom") badges.push("Custom");
+
         if (installed) badges.push("Installed");
         if (updateAvailable) badges.push("Update");
 
@@ -939,6 +1026,18 @@ class BahmcloudStorePanel extends HTMLElement {
     return `
       <div class="filters">
         <input id="q" placeholder="Search…" value="${this._esc(this._search)}" />
+
+        <label class="toggle" title="Show official HACS repositories">
+          <input id="hacs_toggle" type="checkbox" ${this._hacsEnabled ? "checked" : ""} />
+          <span>HACS</span>
+        </label>
+
+        <select id="src">
+          <option value="all" ${this._sourceFilter === "all" ? "selected" : ""}>All sources</option>
+          <option value="bcs" ${this._sourceFilter === "bcs" ? "selected" : ""}>BCS Official</option>
+          <option value="hacs" ${this._sourceFilter === "hacs" ? "selected" : ""}>HACS</option>
+          <option value="custom" ${this._sourceFilter === "custom" ? "selected" : ""}>Custom</option>
+        </select>
         <select id="cat">
           <option value="all">All categories</option>
           ${categories.map((c) => `<option value="${this._esc(c)}" ${this._category === c ? "selected" : ""}>${this._esc(c)}</option>`).join("")}
@@ -972,6 +1071,8 @@ class BahmcloudStorePanel extends HTMLElement {
     const cat = root.getElementById("cat");
     const filter = root.getElementById("filter");
     const sort = root.getElementById("sort");
+    const src = root.getElementById("src");
+    const hacsToggle = root.getElementById("hacs_toggle");
 
     if (q) {
       q.addEventListener("input", (e) => {
@@ -998,12 +1099,51 @@ class BahmcloudStorePanel extends HTMLElement {
       });
     }
 
+    if (src) {
+      src.addEventListener("change", (e) => {
+        this._sourceFilter = e?.target?.value || "all";
+        this._update();
+      });
+    }
+
+    if (hacsToggle) {
+      hacsToggle.addEventListener("change", async (e) => {
+        const enabled = !!e?.target?.checked;
+        this._hacsEnabled = enabled;
+        this._update();
+        await this._setSettings({ hacs_enabled: enabled });
+        await this._load();
+      });
+    }
+
     root.querySelectorAll("[data-open]").forEach((el) => {
       const id = el.getAttribute("data-open");
-      el.addEventListener("click", () => this._openRepoDetail(id));
+      el.addEventListener("click", () => this._openRepoDetail(id, true));
     });
   }
 
+  _pushHistory(state) {
+    if (this._handlingPopstate) return;
+    try {
+      window.history.pushState({ __bcs: true, ...(state || {}) }, "");
+    } catch (e) {
+      // ignore
+    }
+  }
+
+  _closeDetail(pushHistory = true) {
+    this._view = "store";
+    this._detailRepoId = null;
+    this._detailRepo = null;
+    this._readmeText = null;
+    this._readmeHtml = null;
+    this._readmeError = null;
+    this._readmeExpanded = false;
+    this._readmeCanToggle = false;
+    if (pushHistory) this._pushHistory({ view: "store" });
+    this._update();
+  }
+
   _renderAbout() {
     return `
       <div class="card">

custom_components/bahmcloud_store/storage.py

@@ -37,6 +37,7 @@ class BCSStorage:
     - custom_repos: list of manually added repositories
     - installed_repos: mapping repo_id -> installed metadata
     - settings: persistent user settings (e.g. toggles in the UI)
+    - hacs_cache: cached HACS metadata to improve UX (display names/descriptions)
     """
 
     def __init__(self, hass: HomeAssistant) -> None:
@@ -57,8 +58,30 @@ class BCSStorage:
         if "settings" not in data or not isinstance(data.get("settings"), dict):
             data["settings"] = {}
 
+        if "hacs_cache" not in data or not isinstance(data.get("hacs_cache"), dict):
+            data["hacs_cache"] = {}
+
         return data
 
+    async def get_hacs_cache(self) -> dict[str, Any]:
+        """Return cached HACS metadata.
+
+        Shape:
+        {
+          "fetched_at": <unix_ts>,
+          "repos": {"owner/repo": {"name": "...", "description": "...", "domain": "..."}}
+        }
+        """
+        data = await self._load()
+        cache = data.get("hacs_cache", {})
+        return cache if isinstance(cache, dict) else {}
+
+    async def set_hacs_cache(self, cache: dict[str, Any]) -> None:
+        """Persist cached HACS metadata."""
+        data = await self._load()
+        data["hacs_cache"] = cache if isinstance(cache, dict) else {}
+        await self._save(data)
+
     async def get_settings(self) -> dict[str, Any]:
         """Return persistent settings.