add 0.6.8

CHANGELOG.md

@@ -11,6 +11,103 @@ Sections:
 
 ---
 
+## 0.6.8 – Performance & Cache Stabilization (2026-01-19)
+
+### Fixed
+- Fixed excessive GitHub API requests causing rate limiting
+- Fixed missing persistence of repository versions and metadata
+- Fixed background enrichment re-running after Home Assistant restart
+
+### Changed
+- Repository metadata (versions, README, descriptions) is now fetched once in the background
+- Cached data is reused and only refreshed on explicit user interaction
+- Improved separation between startup refresh and on-demand updates
+
+### Improved
+- Significantly reduced Home Assistant startup time
+- Greatly reduced GitHub API usage
+- More reliable version selection for GitHub and HACS repositories
+
+### Notes
+- Background tasks may still appear in DEBUG logs (expected behavior)
+- No functional UI changes in this release
+
+## [0.6.7] - 2026-01-19
+
+### Fixed
+- Repository metadata loaded on demand is now persisted and restored after Home Assistant restart.
+- Background enrichment reliably updates latest versions and descriptions for HACS repositories.
+- Cached repository data is correctly restored on startup for non-installed repositories.
+
+### Changed
+- Repository details are only considered fully enriched once latest version information is available.
+- Improved reliability of background cache synchronization without impacting startup performance.
+
+## [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
+- Separate handling of HACS official repositories with an enable/disable toggle in the Store UI.
+- HACS repositories are now loaded independently from the main store index.
+
+### Changed
+- Store index can remain minimal and curated; HACS repositories are no longer required in store.yaml.
+- Improved Store performance and clarity by clearly separating repository sources.
+
+### Fixed
+- Browser cache issues resolved by proper panel cache-busting for UI updates.
+
+### Internal
+- No changes to install, update, backup, or restore logic.
+- Fully backward compatible with existing installations and configurations.
+
+## [0.6.4] - 2026-01-18
+
+### Fixed
+- Fixed long Home Assistant startup times caused by background repository enrichment running too early.
+
+### Changed
+- Background repository enrichment is now started only after Home Assistant has fully started.
+- Repository cache updates now run fully asynchronous without blocking Home Assistant startup.
+
+### Internal
+- Improved alignment with Home Assistant startup lifecycle.
+- No functional changes to store behavior or UI.
+
+## [0.6.3] - 2026-01-18
+
+### Changed
+- Improved Store performance for large indexes by avoiding full metadata enrichment during list refresh.
+- Repository details are loaded on demand, reducing initial load time and network requests.
+- Index refresh is skipped when the index content has not changed.
+
+## [0.6.2] - 2026-01-18
+
+### Added
+- Selectable install/update version per repository (install older releases/tags to downgrade when needed).
+- New API endpoint to list available versions for a repository: `GET /api/bcs/versions?repo_id=...`.
+
+## [0.6.1] - 2026-01-18
+
+### Fixed
+- Restored integrations now correctly report the restored version instead of the latest installed version.
+- Update availability is correctly recalculated after restoring a backup, allowing updates to be applied again.
+- Improved restore compatibility with backups created before version metadata was introduced.
+
 ## [0.6.0] - 2026-01-18
 
 ### Added

README.md

@@ -1,3 +1,50 @@
-# bahmcloud_store
+# Bahmcloud Store (BCS) for Home Assistant
 
-Bahmcloud Store for installing costum_components to Homeassistant
+Bahmcloud Store (BCS) is a provider-neutral store for Home Assistant custom integrations.
+It allows you to browse, install, update, downgrade, uninstall and restore integrations
+directly from the Home Assistant UI.
+
+This README is intended for **end users**.
+
+---
+
+## Installation
+
+### Option A: Home Assistant OS / Supervised (Add-on – recommended)
+
+1. Open **Settings → Add-ons → Add-on Store**
+2. Add the Bahmcloud Add-on repository
+   `https://git.bahmcloud.de/bahmcloud/addons`
+3. Install **Bahmcloud Store Installer**
+4. Start the add-on
+5. Restart Home Assistant
+
+Installed to:
+/config/custom_components/bahmcloud_store
+
+---
+
+### Option B: Manual Installation (Container / Core)
+
+1. Download the latest release
+2. Copy `custom_components/bahmcloud_store` to:
+   /config/custom_components/bahmcloud_store
+3. Restart Home Assistant
+
+---
+
+## Repository Sources
+
+- **BCS Official**
+- **HACS**
+- **Custom**
+
+---
+
+## Documentation
+
+Developer documentation:
+https://git.bahmcloud.de/bahmcloud/bahmcloud_store/src/branch/main/README_DEVELOPER.md
+
+Full technical documentation:
+https://git.bahmcloud.de/bahmcloud/bahmcloud_store/src/branch/main/README_FULL.md

README_DEVELOPER.md

@@ -0,0 +1,115 @@
+# Bahmcloud Store – Developer Documentation
+
+For contributors and maintainers.
+
+## Architecture
+
+Repositories:
+1) Installer Add-on (HAOS/Supervised) ```https://git.bahmcloud.de/bahmcloud/addons```
+2) Core Integration ```https://git.bahmcloud.de/bahmcloud/bahmcloud_store```
+3) Store Index (`store.yaml`) ```https://git.bahmcloud.de/bahmcloud/ha_store```
+
+### Integration Layout
+
+custom_components/bahmcloud_store/
+- __init__.py: setup, panel registration, schedule background after HA started
+- core.py: index merge, enrichment, install/update/uninstall, backups, restore, caching
+- providers.py: GitHub/GitLab/Gitea repo info + latest version helpers
+- metadata.py: read bcs.yaml / hacs.json / hacs.yaml
+- storage.py: persistent storage (installed, custom, repo cache, hacs cache)
+- views.py: HTTP API endpoints
+- update.py: UpdateEntity implementation
+- repairs.py: (optional) Repairs flow for restart
+- panel/: UI (panel.js, styles.css, etc.)
+- manifest.json
+
+## Runtime Model
+
+- RepoItem (merged)
+- Installed repos (storage)
+- Repo cache (persisted enrichment)
+- HACS meta cache (mapping owner/repo → name/description)
+
+## Background
+
+- Heavy work only after `homeassistant_started`
+- Refresh: if index unchanged → installed-only refresh + schedule enrichment
+- Opening a repo triggers `ensure_repo_details()` and persists to cache
+
+## Providers
+
+- GitHub: API/releases/tags/atom + raw readme
+- GitLab: API releases/tags + raw readme
+- Gitea: API releases/tags + raw readme
+- Custom: API or HTTPS Request to your Git Provider
+
+## Metadata
+
+- Prefer `bcs.yaml`, fallback `hacs.json` / `hacs.yaml`
+- Populate name/description/category/author/maintainer
+
+## HTTP API (excerpt)
+
+Base: /api/bcs
+
+- GET  /api/bcs
+- POST /api/bcs?action=refresh
+- GET  /api/bcs/readme?repo_id=...
+- GET  /api/bcs/versions?repo_id=...
+- POST /api/bcs/install?repo_id=...&version=...
+- POST /api/bcs/update?repo_id=...&version=...
+- POST /api/bcs/uninstall?repo_id=...
+- GET  /api/bcs/backups?repo_id=...
+- POST /api/bcs/restore?repo_id=...&backup_id=...
+- (optional) POST/DELETE custom_repo
+
+## Update Entities
+
+- Unique id bcs:<repo_id>
+- Compare installed ref vs latest ref
+- Dispatcher signal on refresh/install/update
+
+## Storage
+
+- JSON in HA `.storage`
+- async read/write helpers
+- repo cache applied on startup
+
+## Contributing to **BCS Official**
+
+1) Add pull request to `https://git.bahmcloud.de/bahmcloud/ha_store` (with your integration added to) `store.yaml`)  
+2) Add entry:
+```yaml
+- name: Your Integration Name
+  url: https://your-git-hoster.com/your-org/your-repo
+  category: Category (actually only "Integrations" are supported)
+```
+3) (Recommended) Add `bcs.yaml` to your repo:
+```yaml
+name: Your Integration Name
+description: One-liner for the store (optional, store information are also catched from git repository)
+category: Integrations (actually only supported)
+author: Your Name
+maintainer: Your Handle
+```
+4) Open PR; validation checks: reachable, has `custom_components/<domain>/manifest.json`, sensible metadata
+5) Merge → appears in **BCS Official** after refresh
+
+## Coding Guidelines
+
+- Async I/O, no blocking event loop
+- Respect provider rate limits
+- Clean logging around refresh/install/update/restore
+- Keep UI responsive; throttle updates
+
+---
+
+## Planed Features
+
+- Add Downloads and install for category "Dashboard"
+- Add Downloads and install for category "Template"
+- Add Downloads and install for category "Theme"
+- Add Downloads and install for category "Blueprint"
+- 
+
+

README_FULL.md

@@ -0,0 +1,217 @@
+# Bahmcloud Store – Full User Guide
+
+This guide explains **all features** of Bahmcloud Store (BCS) for Home Assistant.
+It is written for users and admins who want a complete, practical reference.
+
+> BCS lets you install & manage custom integrations from **GitHub/GitLab/Gitea** and your own sources, with backups, restore, and version pinning.
+
+---
+
+## Contents
+- Concepts
+- Sources (BCS / HACS / Custom)
+- UI Overview
+- Finding Integrations
+- Installing
+- Selecting Versions / Downgrading
+- Updating
+- Uninstalling
+- Backups & Restore
+- Custom Repositories
+- HACS Repositories
+- Update Entities in Home Assistant
+- Background Caching & Performance
+- Restart Required
+- Troubleshooting
+- FAQ
+
+---
+
+## Concepts
+
+- **Sources**:
+  - **BCS Official** → entries from index (`store.yaml`) made and added from Bahmcloud
+  - **HACS** → official HACS integrations list (toggleable)
+  - **Custom** → manual entries you add locally
+- **Install location**: `/config/custom_components/<domain>`
+- **Backup**: BCS keeps pre‑update copies in `/config/.bcs_backups/<domain>/<timestamp>/`
+
+---
+
+## Sources (BCS / HACS / Custom)
+
+Each repository card shows a **source badge**:
+- **BCS Official** – from Bahmcloud index
+- **HACS** – from HACS official list (enable with the toggle)
+- **Custom** – added by you
+
+You can **filter by source** with the **Source** dropdown (All / BCS Official / HACS / Custom).
+
+---
+
+## UI Overview
+
+Top bar:
+- **Search** (name/description)
+- **Source** filter (All/BCS Official/HACS/Custom)
+- **Category** filter (actually only Integrations are supported)
+- **State-Filter** filter (All/Installed/Not installed/Update available/Custom repos)
+- **Sort** (name (A-Z)/Updates first/Installed first)
+- **HACS official** toggle (on/off)
+
+Repository card:
+- Name, description, badges (source, installed/update), category
+- Buttons: **Install / Update / Uninstall**
+- **Readme** expandable
+- **Open** to see details (available versions, metadata)
+
+---
+
+## Finding Integrations
+
+1. Use **Search** to filter by keywords.
+2. Combine with **Category** and **Source**.
+3. Sort to surface desired results.
+
+Descriptions and latest versions are filled progressively by a background process; opening a repo loads details on demand.
+
+---
+
+## Installing
+
+1. Open a repository.
+2. Optionally select **Install version** (default: **Latest**).
+3. Click **Install** and wait for confirmation.
+4. Follow the **Restart required** prompt. (or use restart toggle in HomeAssistant Settings)
+
+**What happens internally**
+- BCS downloads the repository ZIP for the selected version (release/tag/branch).
+- It extracts all integrations found under `custom_components/<domain>` and deploys them.
+- It saves the **installed version (ref)** to track updates reliably, even if the repo’s own `manifest.json` is wrong/outdated.
+
+---
+
+## Selecting Versions / Downgrading
+
+- Use the **Install version** dropdown in the detail view.
+- Choose **Latest** or a previous **release/tag**.
+- Installing a chosen ref **pins** the integration to that ref (no surprise updates).
+- You can upgrade again later by selecting **Latest** and clicking **Update**.
+
+---
+
+## Updating
+
+- The **Update** button appears when `latest_version` differs from your **installed version (ref)**.
+- Updates are also available via **Home Assistant → Settings → Updates** (native Update entity).
+- Clicking **Update** runs the same safe pipeline as **Install** (with backup).
+
+**Tip:** Opening a repository detail view forces an immediate check for the latest version for that repo.
+
+---
+
+## Uninstalling
+
+- Click **Uninstall** on the repository.
+- BCS removes the integration folders under `custom_components/<domain>`.
+- The installed state is cleared in the Store.
+- Restart Home Assistant if prompted.
+
+---
+
+## Backups & Restore
+
+Before an update/install over existing files, BCS creates a backup:
+
+```
+/config/.bcs_backups/<domain>/<timestamp>/
+```
+
+**Restore**:
+1. Open the repository in store.
+2. Select **Restore…**.
+3. Pick one of the **last backups** (up to retention limit). (Version details are showed in ())
+4. Confirm – BCS restores files and reconciles installed version to the restored ref.
+5. Restart Home Assistant if prompted.
+
+If the old backup lacks metadata, BCS best‑effort derives the installed version from the backup’s `manifest.json`, or marks the ref as `restored:<timestamp>` so updates remain possible.
+
+---
+
+## Custom Repositories
+
+You can add any public repository (GitHub/GitLab/Gitea/Any other Git Hoster). BCS will attempt to detect:
+- provider & default branch
+- latest version (release/tag/atom)
+- repo metadata (prefer `bcs.yaml`, fallback `hacs.json/hacs.yaml`)
+- readme (common filenames)
+
+**Add an custom repository**(typical flows):
+- From the Store UI
+  1. If you start up Bahmcloud Store, you are on tab "Store"
+  2. Go to tab "Manage" 
+  3. Add Repository URL (Example: ``https://git.bahmcloud.de/bahmcloud/bahmcloud_store``) and (optional) Name you want to show up (will be grabbed from GIT Repository)
+  4. Repository show up in Custom Repositories-list and in "Store" Tab, if available
+
+**Remove an custom repository**(typical flows):
+- From the Store UI
+  1. If you start up Bahmcloud Store, you are on tab "Store"
+  2. Go to tab "Manage" 
+  3. Your repository you want to remove (if its custom) show up in the list
+  4. Press "Remove" Button to delete from Store (Attention: If you Remove installed Repository, you won´t be able to Uninstall from Store, you have to remove by your own (Delete Folder from ```config/custom_components/*```))
+
+Custom repos get the **Custom** badge and can be filtered via **Source**.
+
+---
+
+## HACS Repositories
+
+Enable the **HACS official** toggle to include official HACS integrations.
+
+- BCS downloads the HACS integration list and maps **human‑readable names/descriptions** from HACS metadata.
+- HACS entries are **not** part of your BCS-Official Repositories (avoid duplicate entries).
+
+With many HACS repos, metadata loads in the background; names/descriptions appear progressively and are cached.
+
+---
+
+## Update Entities in Home Assistant
+
+BCS exposes update entities for installed repos:
+- Found under **Settings → Updates**
+- Clicking **Install** triggers BCS update pipeline
+- Shows **installed** and **latest** versions (BCS ref logic)
+
+---
+
+## Background Caching & Performance
+
+- **Fast initial list**: index + local cache only
+- **Background enrichment**: provider info, latest version, metadata, description, readme (best effort)
+- **On‑demand**: opening a repo triggers immediate enrichment; data is **persisted** to cache
+- **Persistent cache**: survives HA restarts; speeds up subsequent runs
+- **Refresh**: immediately rechecks installed repos and key metadata
+
+---
+
+## Restart Required
+
+After install, update, or restore, BCS raises a **Restart required** item in Home Assistant (Repairs). You can restart directly from there.
+
+---
+
+## Troubleshooting
+
+- **New release but no update**: Open the repo detail once; ensure it’s a **release/tag** (commits alone don’t change the ref).
+- **Descriptions/Latest missing**: Wait for background enrichment or open the repo detail (forces enrichment). Cached afterwards.
+(You also can Install new version by selecting in Version tab)
+- **Slow startup**: BCS schedules heavy work after HA started. Keep indexes reasonable.
+
+---
+
+## FAQ
+
+- **Backups path?** `/config/.bcs_backups/<domain>/<timestamp>/`
+- **Install path?** `/config/custom_components/<domain>`
+- **Downgrade?** Yes, pick an older version and install.
+- **Restart needed?** Yes, after install/update/restore.

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

@@ -5,7 +5,8 @@ from datetime import timedelta
 
 from homeassistant.core import HomeAssistant
 from homeassistant.components.panel_custom import async_register_panel
-from homeassistant.helpers.event import async_track_time_interval
+from homeassistant.helpers.event import async_track_time_interval, async_call_later
+from homeassistant.const import EVENT_HOMEASSISTANT_STARTED
 from homeassistant.helpers.discovery import async_load_platform
 
 from .core import BCSCore, BCSConfig, BCSError
@@ -34,7 +35,10 @@ async def async_setup(hass: HomeAssistant, config: dict) -> bool:
     from .views import (
         StaticAssetsView,
         BCSApiView,
+        BCSSettingsView,
         BCSReadmeView,
+        BCSVersionsView,
+        BCSRepoDetailView,
         BCSCustomRepoView,
         BCSInstallView,
         BCSUpdateView,
@@ -46,7 +50,10 @@ async def async_setup(hass: HomeAssistant, config: dict) -> bool:
 
     hass.http.register_view(StaticAssetsView())
     hass.http.register_view(BCSApiView(core))
+    hass.http.register_view(BCSSettingsView(core))
     hass.http.register_view(BCSReadmeView(core))
+    hass.http.register_view(BCSVersionsView(core))
+    hass.http.register_view(BCSRepoDetailView(core))
     hass.http.register_view(BCSCustomRepoView(core))
     hass.http.register_view(BCSInstallView(core))
     hass.http.register_view(BCSUpdateView(core))
@@ -60,17 +67,24 @@ 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=103",
+        module_url="/api/bahmcloud_store_static/panel.js?v=108",
         sidebar_title="Bahmcloud Store",
         sidebar_icon="mdi:store",
         require_admin=True,
         config={},
     )
 
-    try:
-        await core.full_refresh(source="startup")
-    except BCSError as e:
-        _LOGGER.error("Initial refresh failed: %s", e)
+    async def _do_startup_refresh(_now=None) -> None:
+        try:
+            await core.full_refresh(source="startup")
+        except BCSError as e:
+            _LOGGER.error("Initial refresh failed: %s", e)
+
+    # Do not block Home Assistant startup. Schedule the initial refresh after HA started.
+    def _on_ha_started(_event) -> None:
+        async_call_later(hass, 30, _do_startup_refresh)
+
+    hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STARTED, _on_ha_started)
 
     async def periodic(_now) -> None:
         try:

custom_components/bahmcloud_store/core.py

@@ -20,7 +20,7 @@ from homeassistant.helpers import issue_registry as ir
 from homeassistant.util import yaml as ha_yaml
 
 from .storage import BCSStorage, CustomRepo
-from .providers import fetch_repo_info, detect_provider, RepoInfo, fetch_readme_markdown
+from .providers import fetch_repo_info, detect_provider, RepoInfo, fetch_readme_markdown, fetch_repo_versions
 from .metadata import fetch_repo_metadata, RepoMetadata
 
 _LOGGER = logging.getLogger(__name__)
@@ -30,6 +30,22 @@ DOMAIN = "bahmcloud_store"
 SIGNAL_UPDATED = f"{DOMAIN}_updated"
 RESTART_REQUIRED_ISSUE_ID = "restart_required"
 
+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
+
+# Repo enrichment cache:
+# - persists across restarts
+# - keeps UI populated (name/description/latest) without blocking startup
+REPO_CACHE_TTL_SECONDS = 6 * 60 * 60  # 6h
+# Release/tag lists change rarely and can be expensive for some providers (e.g. GitHub rate limits).
+# Cache them longer and refresh only on-demand (when the user opens the version selector).
+VERSIONS_CACHE_TTL_SECONDS = 7 * 24 * 60 * 60  # 7d
+
 
 class BCSError(Exception):
     """BCS core error."""
@@ -87,9 +103,26 @@ class BCSCore:
         self.last_index_hash: str | None = None
         self.last_index_loaded_at: float | None = None
 
+        # Fast refresh: skip expensive processing when index/custom repos unchanged
+        self._last_refresh_signature: str | None = None
+
         self._install_lock = asyncio.Lock()
         self._installed_cache: dict[str, Any] = {}
 
+        # 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()
+
+        # Persistent per-repo enrichment cache (name/description/latest). Loaded from storage.
+        self._repo_cache_fetched_at: int = 0
+        self._repo_cache: dict[str, dict[str, Any]] = {}
+        self._repo_cache_lock = asyncio.Lock()
+        self._repo_enrich_task: asyncio.Task | None = None
+
         # Phase F2: backups before install/update
         self._backup_root = Path(self.hass.config.path(".bcs_backups"))
         self._backup_keep_per_domain: int = 5
@@ -99,9 +132,42 @@ class BCSCore:
         self.version = await self._read_manifest_version_async()
         await self._refresh_installed_cache()
 
+        # Load persistent settings (do not fail startup)
+        try:
+            s = await self.storage.get_settings()
+            if isinstance(s, dict):
+                self.settings.update(s)
+        except Exception:
+            pass
+
         # 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 = {}
+
+        # Load persisted per-repo enrichment cache (keeps UI populated after restart).
+        try:
+            rc = await self.storage.get_repo_cache()
+            if isinstance(rc, dict):
+                self._repo_cache_fetched_at = int(rc.get("fetched_at") or 0)
+                repos = rc.get("repos")
+                if isinstance(repos, dict):
+                    self._repo_cache = {str(k): (v if isinstance(v, dict) else {}) for k, v in repos.items()}
+        except Exception:
+            self._repo_cache_fetched_at = 0
+            self._repo_cache = {}
+
     async def _read_manifest_version_async(self) -> str:
         def _read() -> str:
             try:
@@ -170,17 +236,71 @@ class BCSCore:
         data = (self._installed_cache or {}).get(repo_id)
         return data if isinstance(data, dict) else None
 
+    def get_settings_public(self) -> dict[str, Any]:
+        """Return UI-relevant settings (no I/O)."""
+        return {
+            "hacs_enabled": bool(self.settings.get("hacs_enabled", False)),
+        }
+
+    async def set_settings(self, updates: dict[str, Any]) -> dict[str, Any]:
+        """Persist settings and apply them."""
+        safe_updates: dict[str, Any] = {}
+        if "hacs_enabled" in (updates or {}):
+            safe_updates["hacs_enabled"] = bool(updates.get("hacs_enabled"))
+
+        merged = await self.storage.set_settings(safe_updates)
+        if isinstance(merged, dict):
+            self.settings.update(merged)
+
+        # Reload repo list after changing settings.
+        await self.full_refresh(source="settings")
+        return self.get_settings_public()
+
     async def refresh(self) -> None:
         index_repos, refresh_seconds = await self._load_index_repos()
         self.refresh_seconds = refresh_seconds
 
+        hacs_enabled = bool(self.settings.get("hacs_enabled", False))
+        hacs_repos: list[RepoItem] = []
+        if hacs_enabled:
+            try:
+                hacs_repos = await self._load_hacs_repos()
+            except Exception as e:
+                _LOGGER.warning("BCS HACS index load failed: %s", e)
+
         custom_repos = await self.storage.list_custom_repos()
 
+        # Fast path: if index + custom repos did not change, skip expensive work.
+        try:
+            custom_sig = [(c.id, (c.url or '').strip(), (c.name or '').strip()) for c in (custom_repos or [])]
+            custom_sig.sort()
+            hacs_sig = len(hacs_repos) if hacs_enabled else 0
+            refresh_signature = json.dumps({"index_hash": self.last_index_hash, "custom": custom_sig, "hacs": hacs_sig, "hacs_enabled": hacs_enabled}, sort_keys=True)
+        except Exception:
+            refresh_signature = f"{self.last_index_hash}:{len(custom_repos or [])}:{'h' if hacs_enabled else 'n'}:{len(hacs_repos)}"
+
+        if self._last_refresh_signature and refresh_signature == self._last_refresh_signature and self.repos:
+            _LOGGER.debug("BCS refresh fast-path (no repo list changes)")
+
+            # Even if the repo list is unchanged, we still want fresh versions/descriptions
+            # for installed repos and we still want background enrichment to keep the
+            # overview populated.
+            if hacs_enabled and self._hacs_meta_needs_refresh():
+                self.hass.async_create_task(self._refresh_hacs_meta_background())
+
+            await self._enrich_installed_only(self.repos)
+            self._schedule_repo_enrich_background()
+            return
+
+
         merged: dict[str, RepoItem] = {}
 
         for item in index_repos:
             merged[item.id] = item
 
+        for item in hacs_repos:
+            merged[item.id] = item
+
         for c in custom_repos:
             merged[c.id] = RepoItem(
                 id=c.id,
@@ -192,16 +312,385 @@ class BCSCore:
         for r in merged.values():
             r.provider = detect_provider(r.url)
 
-        await self._enrich_and_resolve(merged)
+        # 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())
+
+        # Apply persisted per-repo enrichment cache (instant UI after restart).
+        self._apply_repo_cache(merged)
+
+        await self._enrich_installed_only(merged)
         self.repos = merged
 
+        # Enrich remaining repos in the background and persist results (non-blocking).
+        self._schedule_repo_enrich_background()
+
+        self._last_refresh_signature = refresh_signature
+
         _LOGGER.info(
-            "BCS refresh complete: repos=%s (index=%s, custom=%s)",
+            "BCS refresh complete: repos=%s (index=%s, hacs=%s, custom=%s)",
             len(self.repos),
             len([r for r in self.repos.values() if r.source == "index"]),
+            len([r for r in self.repos.values() if r.source == "hacs"]),
             len([r for r in self.repos.values() if r.source == "custom"]),
         )
 
+    async def _load_hacs_repos(self) -> list[RepoItem]:
+        """Load the official HACS integrations repository list.
+
+        This is used as an optional additional source to keep the local store index small.
+        We only parse owner/repo strings and map them to GitHub URLs.
+        """
+        session = async_get_clientsession(self.hass)
+        headers = {
+            "User-Agent": "BahmcloudStore (Home Assistant)",
+            "Cache-Control": "no-cache, no-store, max-age=0",
+            "Pragma": "no-cache",
+        }
+        async with session.get(HACS_INTEGRATIONS_URL, timeout=60, headers=headers) as resp:
+            if resp.status != 200:
+                raise BCSError(f"HACS index returned {resp.status}")
+            data = await resp.json()
+
+        if not isinstance(data, list):
+            raise BCSError("HACS repositories.json must be a list")
+
+        items: list[RepoItem] = []
+        for entry in data:
+            if not isinstance(entry, str):
+                continue
+            full_name = entry.strip().strip("/")
+            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()
+
+    # ---------- Persistent per-repo enrichment cache ----------
+
+    def _apply_repo_cache(self, merged: dict[str, RepoItem]) -> None:
+        """Apply persisted per-repo enrichment cache to RepoItem objects.
+
+        This is a fast, no-I/O operation used to keep the UI populated immediately
+        after a Home Assistant restart.
+        """
+        if not self._repo_cache:
+            return
+
+        for repo_id, r in merged.items():
+            cached = self._repo_cache.get(str(repo_id))
+            if not isinstance(cached, dict) or not cached:
+                continue
+
+            cached_url = cached.get("url")
+            if isinstance(cached_url, str) and cached_url and r.url and cached_url != r.url:
+                # Repo id reused for different URL; ignore.
+                continue
+
+            # Fill gaps only; never override fresh values from current refresh.
+            if (not r.name or r.name == r.url) and isinstance(cached.get("name"), str) and cached.get("name"):
+                r.name = str(cached.get("name"))
+
+            for attr, key in (
+                ("owner", "owner"),
+                ("provider_repo_name", "provider_repo_name"),
+                ("provider_description", "provider_description"),
+                ("default_branch", "default_branch"),
+                ("latest_version", "latest_version"),
+                ("latest_version_source", "latest_version_source"),
+                ("meta_source", "meta_source"),
+                ("meta_name", "meta_name"),
+                ("meta_description", "meta_description"),
+                ("meta_category", "meta_category"),
+                ("meta_author", "meta_author"),
+                ("meta_maintainer", "meta_maintainer"),
+            ):
+                if getattr(r, attr, None):
+                    continue
+                v = cached.get(key)
+                if v is None:
+                    continue
+                if isinstance(v, str):
+                    vv = v.strip()
+                    if vv:
+                        setattr(r, attr, vv)
+
+    def _repo_needs_enrich(self, repo_id: str, r: RepoItem) -> bool:
+        """Return True if this repo should be enriched in background."""
+        cached = self._repo_cache.get(str(repo_id)) if isinstance(self._repo_cache, dict) else None
+        ts = 0
+        if isinstance(cached, dict):
+            ts = int(cached.get("ts") or 0)
+
+            # Background enrichment should be a one-time best-effort pass.
+            # If we already attempted it once for this repo, do not keep retrying on every refresh.
+            # On-demand (opening repo details / version selector) can still refresh and persist.
+            if bool(cached.get("bg_done")):
+                return False
+
+        # Missing key fields -> enrich.
+        if not r.latest_version:
+            return True
+        if not (r.meta_description or r.provider_description):
+            return True
+
+        # Stale cache -> enrich.
+        if ts <= 0:
+            return True
+        age = int(time.time()) - ts
+        return age > REPO_CACHE_TTL_SECONDS
+
+    def _update_repo_cache_from_repo(self, repo_id: str, r: RepoItem) -> None:
+        self._repo_cache[str(repo_id)] = {
+            "ts": int(time.time()),
+            "url": r.url,
+            "name": r.name,
+            "owner": r.owner,
+            "provider_repo_name": r.provider_repo_name,
+            "provider_description": r.provider_description,
+            "default_branch": r.default_branch,
+            "latest_version": r.latest_version,
+            "latest_version_source": r.latest_version_source,
+            "meta_source": r.meta_source,
+            "meta_name": r.meta_name,
+            "meta_description": r.meta_description,
+            "meta_category": r.meta_category,
+            "meta_author": r.meta_author,
+            "meta_maintainer": r.meta_maintainer,
+        }
+
+    def _schedule_repo_enrich_background(self) -> None:
+        """Schedule background enrichment for repo details.
+
+        This is non-blocking and safe to call repeatedly.
+        """
+        if self._repo_enrich_task and not self._repo_enrich_task.done():
+            return
+        self._repo_enrich_task = self.hass.async_create_task(self._repo_enrich_background())
+
+    async def _repo_enrich_background(self) -> None:
+        # Small delay to avoid competing with critical startup work.
+        await asyncio.sleep(2)
+
+        repo_ids = list(self.repos.keys())
+        updated = 0
+
+        # Keep it conservative to avoid rate limits.
+        sem = asyncio.Semaphore(4)
+
+        async def process_one(repo_id: str) -> None:
+            nonlocal updated
+            r = self.repos.get(repo_id)
+            if not r:
+                return
+            if not self._repo_needs_enrich(repo_id, r):
+                return
+            async with sem:
+                try:
+                    await self._enrich_one_repo(r)
+                except Exception:
+                    _LOGGER.debug("BCS background enrich failed for %s", repo_id, exc_info=True)
+                    # Mark as attempted so we don't keep hammering the provider.
+                    async with self._repo_cache_lock:
+                        cached = self._repo_cache.setdefault(str(repo_id), {})
+                        if isinstance(cached, dict):
+                            cached["bg_done"] = True
+                            cached["bg_done_ts"] = int(time.time())
+                    return
+
+            async with self._repo_cache_lock:
+                self._update_repo_cache_from_repo(repo_id, r)
+                cached = self._repo_cache.setdefault(str(repo_id), {})
+                if isinstance(cached, dict):
+                    cached["bg_done"] = True
+                    cached["bg_done_ts"] = int(time.time())
+                updated += 1
+
+        # Process sequentially but allow limited concurrency.
+        tasks: list[asyncio.Task] = []
+        for repo_id in repo_ids:
+            tasks.append(self.hass.async_create_task(process_one(repo_id)))
+
+            # Flush in batches to limit memory/connection churn.
+            if len(tasks) >= 25:
+                await asyncio.gather(*tasks, return_exceptions=True)
+                tasks = []
+                if updated:
+                    await self._persist_repo_cache()
+                    self.signal_updated()
+                await asyncio.sleep(0)
+
+        if tasks:
+            await asyncio.gather(*tasks, return_exceptions=True)
+
+        if updated:
+            await self._persist_repo_cache()
+            self.signal_updated()
+
+    async def _persist_repo_cache(self) -> None:
+        async with self._repo_cache_lock:
+            payload = {
+                "fetched_at": int(time.time()),
+                "repos": self._repo_cache,
+            }
+        try:
+            await self.storage.set_repo_cache(payload)
+        except Exception:
+            _LOGGER.debug("BCS failed to persist repo cache", exc_info=True)
+
     async def _enrich_and_resolve(self, merged: dict[str, RepoItem]) -> None:
         sem = asyncio.Semaphore(6)
 
@@ -236,6 +725,130 @@ class BCSCore:
 
         await asyncio.gather(*(process_one(r) for r in merged.values()), return_exceptions=True)
 
+
+    async def _enrich_installed_only(self, merged: dict[str, RepoItem]) -> None:
+        """Enrich only installed repos (fast refresh for large indexes).
+
+        This keeps the backend responsive even with thousands of repositories.
+        Details for non-installed repos are fetched on-demand.
+        """
+        installed_map: dict[str, Any] = getattr(self, "_installed_cache", {}) or {}
+        if not isinstance(installed_map, dict) or not installed_map:
+            return
+
+        to_process: list[RepoItem] = []
+        for rid in installed_map.keys():
+            r = merged.get(str(rid))
+            if r:
+                to_process.append(r)
+
+        if not to_process:
+            return
+
+        sem = asyncio.Semaphore(6)
+
+        async def process_one(r: RepoItem) -> None:
+            async with sem:
+                await self._enrich_one_repo(r)
+
+        await asyncio.gather(*(process_one(r) for r in to_process), return_exceptions=True)
+
+    async def _enrich_one_repo(self, r: RepoItem) -> None:
+        """Fetch provider info + metadata for a single repo item."""
+        info: RepoInfo = await fetch_repo_info(self.hass, r.url)
+
+        r.provider = info.provider or r.provider
+        r.owner = info.owner or r.owner
+        r.provider_repo_name = info.repo_name
+        r.provider_description = info.description
+        r.default_branch = info.default_branch or r.default_branch
+
+        r.latest_version = info.latest_version
+        r.latest_version_source = info.latest_version_source
+
+        md: RepoMetadata = await fetch_repo_metadata(self.hass, r.url, r.default_branch)
+        r.meta_source = md.source
+        if md.name:
+            r.meta_name = md.name
+            r.name = md.name
+        r.meta_description = md.description
+        if md.category:
+            r.meta_category = md.category
+        r.meta_author = md.author
+        r.meta_maintainer = md.maintainer
+
+        # Keep a stable name fallback
+        if not r.name:
+            r.name = r.provider_repo_name or r.url
+
+    async def ensure_repo_details(self, repo_id: str) -> RepoItem | None:
+        """Ensure provider/meta/latest fields are loaded for a repo.
+
+        Used by the UI when a repo detail view is opened.
+        """
+        r = self.get_repo(repo_id)
+        if not r:
+            return None
+
+        # Consider it enriched only if we already have a latest_version and at least
+        # some descriptive info (meta/provider). HACS repos often have meta_source set
+        # early, but still need provider latest_version.
+        if r.latest_version and (r.provider_description or r.meta_description or r.meta_source):
+            return r
+
+        try:
+            await self._enrich_one_repo(r)
+
+            # Persist the newly fetched details so they survive a Home Assistant restart.
+            async with self._repo_cache_lock:
+                self._update_repo_cache_from_repo(repo_id, r)
+            await self._persist_repo_cache()
+        except Exception:
+            _LOGGER.debug("BCS ensure_repo_details failed for %s", repo_id, exc_info=True)
+        return r
+
+    async def list_repo_versions(self, repo_id: str) -> list[dict[str, Any]]:
+        repo = self.get_repo(repo_id)
+        if not repo:
+            return []
+
+        # Prefer cached version lists to avoid hammering provider APIs (notably GitHub unauthenticated
+        # rate limits). We refresh on-demand when the user opens the selector.
+        cached = None
+        cached_ts = 0
+        async with self._repo_cache_lock:
+            cached = self._repo_cache.get(str(repo_id)) if isinstance(self._repo_cache, dict) else None
+            if isinstance(cached, dict):
+                cached_ts = int(cached.get("versions_ts", 0) or 0)
+
+        now = int(time.time())
+        if isinstance(cached, dict) and cached.get("versions") and (now - cached_ts) < VERSIONS_CACHE_TTL_SECONDS:
+            return list(cached.get("versions") or [])
+
+        try:
+            versions = await fetch_repo_versions(self.hass, repo.url)
+        except Exception:
+            versions = []
+
+        # If the provider fetch returned only the basic fallbacks ("Latest" + "Branch") but we have
+        # a previously cached richer list, keep using the cached list.
+        if (
+            isinstance(cached, dict)
+            and cached.get("versions")
+            and len(list(cached.get("versions") or [])) > 2
+            and len(versions) <= 2
+        ):
+            return list(cached.get("versions") or [])
+
+        # Persist whatever we got (even if small) to avoid repeated calls when rate-limited.
+        async with self._repo_cache_lock:
+            entry = self._repo_cache.setdefault(str(repo_id), {}) if isinstance(self._repo_cache, dict) else {}
+            if isinstance(entry, dict):
+                entry["versions"] = versions
+                entry["versions_ts"] = now
+        await self._persist_repo_cache()
+        return versions
+
     def _add_cache_buster(self, url: str) -> str:
         parts = urlsplit(url)
         q = dict(parse_qsl(parts.query, keep_blank_values=True))
@@ -327,6 +940,7 @@ class BCSCore:
                         name=name,
                         url=repo_url,
                         source="index",
+                        meta_category=str(r.get("category")) if r.get("category") else None,
                     )
                 )
 
@@ -413,6 +1027,23 @@ class BCSCore:
             default_branch=repo.default_branch,
         )
 
+    async def list_repo_versions(self, repo_id: str, *, limit: int = 20) -> list[dict[str, str]]:
+        """List installable versions/refs for a repo.
+
+        This is used by the UI to allow selecting an older tag/release.
+        """
+        repo = self.get_repo(repo_id)
+        if not repo:
+            raise BCSInstallError(f"repo_id not found: {repo_id}")
+
+        return await fetch_repo_versions(
+            self.hass,
+            repo.url,
+            provider=repo.provider,
+            default_branch=repo.default_branch,
+            limit=limit,
+        )
+
     def _pick_ref_for_install(self, repo: RepoItem) -> str:
         if repo.latest_version and str(repo.latest_version).strip():
             return str(repo.latest_version).strip()
@@ -493,7 +1124,19 @@ class BCSCore:
 
         await self.hass.async_add_executor_job(_mkdir)
 
-    async def _backup_domain(self, domain: str) -> Path | None:
+    def _build_backup_meta(self, repo_id: str, domain: str) -> dict[str, object]:
+        """Build metadata for backup folders so restores can recover the stored version."""
+        inst = self.get_installed(repo_id) or {}
+        return {
+            "repo_id": repo_id,
+            "domain": domain,
+            "installed_version": inst.get("installed_version") or inst.get("ref"),
+            "installed_manifest_version": inst.get("installed_manifest_version"),
+            "ref": inst.get("ref") or inst.get("installed_version"),
+            "created_at": time.strftime("%Y-%m-%dT%H:%M:%S"),
+        }
+
+    async def _backup_domain(self, domain: str, *, meta: dict[str, object] | None = None) -> Path | None:
         """Backup an existing domain folder.
 
         Returns the created backup path, or None if the domain folder does not exist.
@@ -515,6 +1158,13 @@ class BCSCore:
             if backup_path.exists():
                 shutil.rmtree(backup_path, ignore_errors=True)
             shutil.copytree(target, backup_path, dirs_exist_ok=True)
+            # Store backup metadata (kept inside backup folder; removed from target after restore).
+            if meta:
+                try:
+                    meta_path = backup_path / BACKUP_META_FILENAME
+                    meta_path.write_text(json.dumps(meta, ensure_ascii=False, indent=2), encoding='utf-8')
+                except Exception:
+                    pass
 
             # Retention: keep only the newest N backups per domain.
             try:
@@ -541,6 +1191,28 @@ class BCSCore:
             if target.exists():
                 shutil.rmtree(target, ignore_errors=True)
             shutil.copytree(backup_path, target, dirs_exist_ok=True)
+            try:
+                meta_file = target / BACKUP_META_FILENAME
+                if meta_file.exists():
+                    meta_file.unlink(missing_ok=True)
+            except Exception:
+                pass
+
+            # Do not leave backup metadata inside the restored integration folder.
+            try:
+                meta_p = target / BACKUP_META_FILENAME
+                if meta_p.exists():
+                    meta_p.unlink()
+            except Exception:
+                pass
+
+            # Do not leave backup metadata inside the live integration folder.
+            try:
+                m = target / BACKUP_META_FILENAME
+                if m.exists():
+                    m.unlink()
+            except Exception:
+                pass
 
         await self.hass.async_add_executor_job(_restore)
         _LOGGER.info("BCS rollback applied: domain=%s from=%s", domain, backup_path)
@@ -579,7 +1251,13 @@ class BCSCore:
         for bid, present in id_map.items():
             complete = present == all_domains
             label = self._format_backup_id(bid)
-            items.append({"id": bid, "label": label, "complete": complete, "domains": sorted(present)})
+            meta = await self._read_backup_meta(dom_list[0], bid)
+            ver = None
+            if isinstance(meta, dict):
+                ver = meta.get("installed_version") or meta.get("ref")
+            if ver:
+                label = f"{label} ({ver})"
+            items.append({"id": bid, "label": label, "complete": complete, "domains": sorted(present), "installed_version": str(ver) if ver else None})
 
         # Sort newest first by id (lexicographic works for timestamp format).
         items.sort(key=lambda x: str(x.get("id") or ""), reverse=True)
@@ -631,12 +1309,87 @@ class BCSCore:
             for d in dom_list:
                 await self._restore_domain_from_backup(d, self._backup_root / d / backup_id)
 
+            # Update stored installed version to the restored one (so UI shows the restored state).
+            #
+            # Backups created before 0.6.1 may not have metadata. For those legacy backups we fall back to:
+            # 1) version from the backup's manifest.json (best-effort), else
+            # 2) a synthetic marker (restored:<backup_id>) so the UI reflects a restored state and updates
+            #    remain available.
+            restored_meta = await self._read_backup_meta(dom_list[0], backup_id)
+            restored_version: str | None = None
+            restored_manifest_version: str | None = None
+
+            if isinstance(restored_meta, dict):
+                rv = restored_meta.get("installed_version") or restored_meta.get("ref")
+                if rv is not None and str(rv).strip():
+                    restored_version = str(rv).strip()
+                mv = restored_meta.get("installed_manifest_version")
+                if mv is not None and str(mv).strip():
+                    restored_manifest_version = str(mv).strip()
+
+            # Legacy backups (no meta): try to read manifest.json version from the backup folder.
+            if not restored_manifest_version:
+                restored_manifest_version = await self._read_backup_manifest_version(dom_list[0], backup_id)
+
+            # Use manifest version as a fallback display value if we don't have the exact installed ref.
+            if not restored_version and restored_manifest_version:
+                restored_version = restored_manifest_version
+
+            # Last resort: ensure the installed version changes so the UI does not keep showing the newest version.
+            if not restored_version:
+                restored_version = f"restored:{backup_id}"
+
+            repo = self.get_repo(repo_id)
+            repo_url = getattr(repo, "url", None) or ""
+
+            await self.storage.set_installed_repo(
+                repo_id=repo_id,
+                url=repo_url,
+                domains=dom_list,
+                installed_version=restored_version,
+                installed_manifest_version=restored_manifest_version,
+                ref=restored_version,
+            )
+
             await self._refresh_installed_cache()
             self._mark_restart_required()
             self.signal_updated()
 
             _LOGGER.info("BCS restore complete: repo_id=%s backup_id=%s", repo_id, backup_id)
-            return {"ok": True, "repo_id": repo_id, "backup_id": backup_id, "domains": dom_list, "restart_required": True}
+            return {"ok": True, "repo_id": repo_id, "backup_id": backup_id, "domains": dom_list, "restored_version": restored_version, "restart_required": True}
+
+    async def _read_backup_meta(self, domain: str, backup_id: str) -> dict[str, Any] | None:
+        """Read backup metadata for a domain backup.
+
+        Metadata is stored inside the backup folder and will be removed from the
+        live folder after restore.
+        """
+        try:
+            p = self._backup_root / domain / backup_id / BACKUP_META_FILENAME
+            if not p.exists():
+                return None
+            txt = await self.hass.async_add_executor_job(p.read_text, 'utf-8')
+            data = json.loads(txt)
+            return data if isinstance(data, dict) else None
+        except Exception:
+            return None
+
+
+    async def _read_backup_manifest_version(self, domain: str, backup_id: str) -> str | None:
+        """Best-effort: read manifest.json version from a legacy backup (no metadata)."""
+
+        def _read() -> str | None:
+            try:
+                p = self._backup_root / domain / backup_id / 'manifest.json'
+                if not p.exists():
+                    return None
+                data = json.loads(p.read_text(encoding='utf-8'))
+                v = data.get('version')
+                return str(v) if v else None
+            except Exception:
+                return None
+
+        return await self.hass.async_add_executor_job(_read)
 
     async def _list_domain_backup_ids(self, domain: str) -> list[str]:
         """List backup ids for a domain (newest->oldest)."""
@@ -789,19 +1542,28 @@ class BCSCore:
             self.signal_updated()
             return {"ok": True, "repo_id": repo_id, "removed": removed, "restart_required": bool(removed)}
 
-    async def install_repo(self, repo_id: str) -> dict[str, Any]:
+    async def install_repo(self, repo_id: str, *, version: str | None = None) -> dict[str, Any]:
         repo = self.get_repo(repo_id)
         if not repo:
             raise BCSInstallError(f"repo_id not found: {repo_id}")
 
         async with self._install_lock:
-            ref = self._pick_ref_for_install(repo)
+            requested = (version or "").strip()
+            ref = requested if requested else self._pick_ref_for_install(repo)
             zip_url = self._build_zip_url(repo.url, ref)
 
             _LOGGER.info("BCS install started: repo_id=%s ref=%s zip_url=%s", repo_id, ref, zip_url)
 
             installed_domains: list[str] = []
             backups: dict[str, Path] = {}
+
+            inst_before = self.get_installed(repo_id) or {}
+            backup_meta = {
+                "repo_id": repo_id,
+                "installed_version": inst_before.get("installed_version") or inst_before.get("ref"),
+                "installed_manifest_version": inst_before.get("installed_manifest_version"),
+                "ref": inst_before.get("ref") or inst_before.get("installed_version"),
+            }
             created_new: set[str] = set()
 
             try:
@@ -832,7 +1594,9 @@ class BCSCore:
 
                         # Backup only if we are going to overwrite an existing domain.
                         if target.exists() and target.is_dir():
-                            bkp = await self._backup_domain(domain)
+                            m = dict(backup_meta)
+                            m["domain"] = domain
+                            bkp = await self._backup_domain(domain, meta=m)
                             if bkp:
                                 backups[domain] = bkp
                         else:
@@ -905,9 +1669,9 @@ class BCSCore:
                     raise
                 raise BCSInstallError(str(e)) from e
 
-    async def update_repo(self, repo_id: str) -> dict[str, Any]:
+    async def update_repo(self, repo_id: str, *, version: str | None = None) -> dict[str, Any]:
         _LOGGER.info("BCS update started: repo_id=%s", repo_id)
-        return await self.install_repo(repo_id)
+        return await self.install_repo(repo_id, version=version)
 
     async def request_restart(self) -> None:
         await self.hass.services.async_call("homeassistant", "restart", {}, blocking=False)

custom_components/bahmcloud_store/manifest.json

@@ -1,7 +1,7 @@
 {
   "domain": "bahmcloud_store",
   "name": "Bahmcloud Store",
-  "version": "0.6.0",
+  "version": "0.6.8",
   "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;
@@ -45,6 +51,15 @@ class BahmcloudStorePanel extends HTMLElement {
     this._restoreSelected = "";
     this._restoring = false;
     this._restoreError = null;
+
+    // Phase C1: selectable install version
+    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) {
@@ -52,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;
 
@@ -67,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;
@@ -79,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;
@@ -114,7 +181,13 @@ class BahmcloudStorePanel extends HTMLElement {
     this._update();
 
     try {
-      const resp = await this._hass.callApi("post", `bcs/install?repo_id=${encodeURIComponent(repoId)}`, {});
+      const sel = this._safeText(this._selectedVersionByRepoId?.[repoId] || "").trim();
+      const qv = sel ? `&version=${encodeURIComponent(sel)}` : "";
+      const resp = await this._hass.callApi(
+        "post",
+        `bcs/install?repo_id=${encodeURIComponent(repoId)}${qv}`,
+        {},
+      );
       if (!resp?.ok) {
         this._error = this._safeText(resp?.message) || "Install failed.";
       } else {
@@ -140,7 +213,13 @@ class BahmcloudStorePanel extends HTMLElement {
     this._update();
 
     try {
-      const resp = await this._hass.callApi("post", `bcs/update?repo_id=${encodeURIComponent(repoId)}`, {});
+      const sel = this._safeText(this._selectedVersionByRepoId?.[repoId] || "").trim();
+      const qv = sel ? `&version=${encodeURIComponent(sel)}` : "";
+      const resp = await this._hass.callApi(
+        "post",
+        `bcs/update?repo_id=${encodeURIComponent(repoId)}${qv}`,
+        {},
+      );
       if (!resp?.ok) {
         this._error = this._safeText(resp?.message) || "Update failed.";
       } else {
@@ -291,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 = "/";
+      }
     }
   }
 
@@ -351,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;
@@ -366,8 +443,60 @@ class BahmcloudStorePanel extends HTMLElement {
     this._readmeExpanded = false;
     this._readmeCanToggle = false;
 
+    // Versions dropdown
+    if (!(repoId in this._selectedVersionByRepoId)) {
+      this._selectedVersionByRepoId[repoId] = ""; // default = latest
+    }
+
     this._update();
+    this._loadRepoDetails(repoId);
     this._loadReadme(repoId);
+    this._loadVersions(repoId);
+  }
+
+
+  async _loadRepoDetails(repoId) {
+    if (!this._hass || !repoId) return;
+    try {
+      const resp = await this._hass.callApi("get", `bcs/repo?repo_id=${encodeURIComponent(repoId)}`);
+      if (resp?.ok && resp.repo) {
+        this._detailRepo = resp.repo;
+        // Also update the cached list item if present
+        const repos = Array.isArray(this._data?.repos) ? this._data.repos : [];
+        const idx = repos.findIndex((r) => this._safeId(r?.id) === repoId);
+        if (idx >= 0) repos[idx] = resp.repo;
+        this._update();
+      }
+    } catch (e) {
+      // ignore: details are optional
+    }
+  }
+
+  async _loadVersions(repoId) {
+    if (!this._hass) return;
+    if (!repoId) return;
+
+    // Cache: avoid re-fetching repeatedly in the same session.
+    if (Array.isArray(this._versionsCache?.[repoId]) && this._versionsCache[repoId].length) {
+      return;
+    }
+
+    this._versionsLoadingRepoId = repoId;
+    this._update();
+
+    try {
+      const resp = await this._hass.callApi("get", `bcs/versions?repo_id=${encodeURIComponent(repoId)}`);
+      if (resp?.ok && Array.isArray(resp.versions)) {
+        this._versionsCache[repoId] = resp.versions;
+      } else {
+        this._versionsCache[repoId] = [];
+      }
+    } catch (e) {
+      this._versionsCache[repoId] = [];
+    } finally {
+      this._versionsLoadingRepoId = null;
+      this._update();
+    }
   }
 
   async _loadReadme(repoId) {
@@ -492,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;
@@ -790,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);
@@ -844,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");
 
@@ -870,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("")}
@@ -903,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) => {
@@ -929,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">
@@ -953,6 +1162,8 @@ class BahmcloudStorePanel extends HTMLElement {
     const r = this._detailRepo;
     if (!r) return `<div class="card">No repository selected.</div>`;
 
+    const repoId = this._safeId(r?.id) || this._detailRepoId || "";
+
     const name = this._safeText(r?.name) || "Unnamed repository";
     const url = this._safeText(r?.url) || "";
     const desc = this._safeText(r?.description) || "";
@@ -1001,8 +1212,6 @@ class BahmcloudStorePanel extends HTMLElement {
         </div>
       `;
 
-    const repoId = this._safeId(r?.id);
-
     const installed = this._asBoolStrict(r?.installed);
     const installedVersion = this._safeText(r?.installed_version);
     const installedDomains = Array.isArray(r?.installed_domains) ? r.installed_domains : [];
@@ -1015,6 +1224,32 @@ class BahmcloudStorePanel extends HTMLElement {
 
     const updateAvailable = installed && !!latestVersion && (!installedVersion || latestVersion !== installedVersion);
 
+    const versions = Array.isArray(this._versionsCache?.[repoId]) ? this._versionsCache[repoId] : [];
+    const versionsLoading = this._versionsLoadingRepoId === repoId;
+    const selectedRef = this._safeText(this._selectedVersionByRepoId?.[repoId] || "").trim();
+
+    let versionOptions = `<option value="">Latest (recommended)</option>`;
+    if (selectedRef && !versions.some((v) => this._safeText(v?.ref) === selectedRef)) {
+      versionOptions += `<option value="${this._esc(selectedRef)}" selected>Selected: ${this._esc(selectedRef)}</option>`;
+    }
+    for (const v of versions) {
+      const ref = this._safeText(v?.ref);
+      if (!ref) continue;
+      const label = this._safeText(v?.label) || ref;
+      const sel = selectedRef === ref ? "selected" : "";
+      versionOptions += `<option value="${this._esc(ref)}" ${sel}>${this._esc(label)}</option>`;
+    }
+
+    const versionSelect = `
+      <div style="margin-top:12px;">
+        <div class="muted small" style="margin-bottom:6px;"><strong>Install version:</strong></div>
+        <select id="selVersion" ${busy ? "disabled" : ""} style="width:100%;">
+          ${versionOptions}
+        </select>
+        ${versionsLoading ? `<div class="muted small" style="margin-top:6px;">Loading versions…</div>` : ``}
+      </div>
+    `;
+
     const installBtn = `<button class="primary" id="btnInstall" ${installed || busy ? "disabled" : ""}>${busyInstall ? "Installing…" : installed ? "Installed" : "Install"}</button>`;
     const updateBtn = `<button class="primary" id="btnUpdate" ${!updateAvailable || busy ? "disabled" : ""}>${busyUpdate ? "Updating…" : updateAvailable ? "Update" : "Up to date"}</button>`;
     const uninstallBtn = `<button class="primary" id="btnUninstall" ${!installed || busy ? "disabled" : ""}>${busyUninstall ? "Uninstalling…" : "Uninstall"}</button>`;
@@ -1067,6 +1302,8 @@ class BahmcloudStorePanel extends HTMLElement {
               <div style="margin-top:6px;"><strong>Domains:</strong> ${installedDomains.length ? this._esc(installedDomains.join(", ")) : "-"}</div>
             </div>
 
+            ${versionSelect}
+
             <div class="row" style="margin-top:14px; gap:10px; flex-wrap:wrap;">
               ${installBtn}
               ${updateBtn}
@@ -1091,6 +1328,7 @@ class BahmcloudStorePanel extends HTMLElement {
     const btnRestore = root.getElementById("btnRestore");
     const btnRestart = root.getElementById("btnRestart");
     const btnReadmeToggle = root.getElementById("btnReadmeToggle");
+    const selVersion = root.getElementById("selVersion");
 
     if (btnInstall) {
       btnInstall.addEventListener("click", () => {
@@ -1099,6 +1337,14 @@ class BahmcloudStorePanel extends HTMLElement {
       });
     }
 
+    if (selVersion) {
+      selVersion.addEventListener("change", () => {
+        if (!this._detailRepoId) return;
+        const v = selVersion.value != null ? String(selVersion.value) : "";
+        this._selectedVersionByRepoId[this._detailRepoId] = v;
+      });
+    }
+
     if (btnUpdate) {
       btnUpdate.addEventListener("click", () => {
         if (btnUpdate.disabled) return;

custom_components/bahmcloud_store/providers.py

@@ -504,4 +504,160 @@ async def fetch_readme_markdown(
         except Exception:
             continue
 
-    return None
+    return None
+
+
+async def fetch_repo_versions(
+    hass: HomeAssistant,
+    repo_url: str,
+    *,
+    provider: str | None = None,
+    default_branch: str | None = None,
+    limit: int = 20,
+) -> list[dict[str, str]]:
+    """List available versions/refs for a repository.
+
+    Returns a list of dicts with keys:
+      - ref: the ref to install (tag/release/branch)
+      - label: human-friendly label
+      - source: release|tag|branch
+
+    Notes:
+    - Uses public endpoints (no tokens) for public repositories.
+    - We prefer releases first (if available), then tags.
+    """
+
+    repo_url = (repo_url or "").strip()
+    if not repo_url:
+        return []
+
+    prov = (provider or "").strip().lower() if provider else ""
+    if not prov:
+        prov = detect_provider(repo_url)
+
+    owner, repo = _split_owner_repo(repo_url)
+    if not owner or not repo:
+        return []
+
+    session = async_get_clientsession(hass)
+    headers = {"User-Agent": UA}
+
+    out: list[dict[str, str]] = []
+    seen: set[str] = set()
+
+    def _add(ref: str | None, label: str, source: str) -> None:
+        r = (ref or "").strip()
+        if not r or r in seen:
+            return
+        seen.add(r)
+        out.append({"ref": r, "label": label, "source": source})
+
+    # Always offer default branch as an explicit option.
+    if default_branch and str(default_branch).strip():
+        b = str(default_branch).strip()
+        _add(b, f"Branch: {b}", "branch")
+
+    try:
+        if prov == "github":
+            # Releases
+            gh_headers = {"Accept": "application/vnd.github+json", "User-Agent": UA}
+            data, _ = await _safe_json(
+                session,
+                f"https://api.github.com/repos/{owner}/{repo}/releases?per_page={int(limit)}",
+                headers=gh_headers,
+            )
+            if isinstance(data, list):
+                for r in data:
+                    if not isinstance(r, dict):
+                        continue
+                    tag = r.get("tag_name")
+                    name = r.get("name")
+                    if tag:
+                        lbl = str(tag)
+                        if isinstance(name, str) and name.strip() and name.strip() != str(tag):
+                            lbl = f"{tag} — {name.strip()}"
+                        _add(str(tag), lbl, "release")
+
+            # Tags
+            data, _ = await _safe_json(
+                session,
+                f"https://api.github.com/repos/{owner}/{repo}/tags?per_page={int(limit)}",
+                headers=gh_headers,
+            )
+            if isinstance(data, list):
+                for t in data:
+                    if isinstance(t, dict) and t.get("name"):
+                        _add(str(t["name"]), str(t["name"]), "tag")
+
+            return out
+
+        if prov == "gitlab":
+            u = urlparse(repo_url.rstrip("/"))
+            base = f"{u.scheme}://{u.netloc}"
+            project = quote_plus(f"{owner}/{repo}")
+
+            data, _ = await _safe_json(
+                session,
+                f"{base}/api/v4/projects/{project}/releases?per_page={int(limit)}",
+                headers=headers,
+            )
+            if isinstance(data, list):
+                for r in data:
+                    if not isinstance(r, dict):
+                        continue
+                    tag = r.get("tag_name")
+                    name = r.get("name")
+                    if tag:
+                        lbl = str(tag)
+                        if isinstance(name, str) and name.strip() and name.strip() != str(tag):
+                            lbl = f"{tag} — {name.strip()}"
+                        _add(str(tag), lbl, "release")
+
+            data, _ = await _safe_json(
+                session,
+                f"{base}/api/v4/projects/{project}/repository/tags?per_page={int(limit)}",
+                headers=headers,
+            )
+            if isinstance(data, list):
+                for t in data:
+                    if isinstance(t, dict) and t.get("name"):
+                        _add(str(t["name"]), str(t["name"]), "tag")
+
+            return out
+
+        # gitea (incl. Bahmcloud)
+        u = urlparse(repo_url.rstrip("/"))
+        base = f"{u.scheme}://{u.netloc}"
+
+        data, _ = await _safe_json(
+            session,
+            f"{base}/api/v1/repos/{owner}/{repo}/releases?limit={int(limit)}",
+            headers=headers,
+        )
+        if isinstance(data, list):
+            for r in data:
+                if not isinstance(r, dict):
+                    continue
+                tag = r.get("tag_name")
+                name = r.get("name")
+                if tag:
+                    lbl = str(tag)
+                    if isinstance(name, str) and name.strip() and name.strip() != str(tag):
+                        lbl = f"{tag} — {name.strip()}"
+                    _add(str(tag), lbl, "release")
+
+        data, _ = await _safe_json(
+            session,
+            f"{base}/api/v1/repos/{owner}/{repo}/tags?limit={int(limit)}",
+            headers=headers,
+        )
+        if isinstance(data, list):
+            for t in data:
+                if isinstance(t, dict) and t.get("name"):
+                    _add(str(t["name"]), str(t["name"]), "tag")
+
+        return out
+
+    except Exception:
+        _LOGGER.debug("fetch_repo_versions failed for %s", repo_url, exc_info=True)
+        return out

custom_components/bahmcloud_store/storage.py

@@ -36,6 +36,9 @@ class BCSStorage:
     Keys:
     - 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)
+    - repo_cache: cached per-repo enrichment (names/descriptions/versions) to keep the UI populated after restart
     """
 
     def __init__(self, hass: HomeAssistant) -> None:
@@ -53,8 +56,92 @@ class BCSStorage:
         if "installed_repos" not in data or not isinstance(data.get("installed_repos"), dict):
             data["installed_repos"] = {}
 
+        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"] = {}
+
+        if "repo_cache" not in data or not isinstance(data.get("repo_cache"), dict):
+            data["repo_cache"] = {}
+
         return data
 
+    async def get_repo_cache(self) -> dict[str, Any]:
+        """Return cached per-repo enrichment data.
+
+        Shape:
+        {
+          "fetched_at": <unix_ts>,
+          "repos": {
+             "<repo_id>": {
+                "ts": <unix_ts>,
+                "url": "...",
+                "name": "...",
+                "provider_description": "...",
+                "meta_name": "...",
+                "meta_description": "...",
+                "meta_category": "...",
+                "meta_source": "...",
+                "latest_version": "...",
+                "latest_version_source": "...",
+                "default_branch": "...",
+                "owner": "...",
+                "provider_repo_name": "..."
+             }
+          }
+        }
+        """
+        data = await self._load()
+        cache = data.get("repo_cache", {})
+        return cache if isinstance(cache, dict) else {}
+
+    async def set_repo_cache(self, cache: dict[str, Any]) -> None:
+        """Persist cached per-repo enrichment data."""
+        data = await self._load()
+        data["repo_cache"] = cache if isinstance(cache, dict) else {}
+        await self._save(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.
+
+        Currently used for UI/behavior toggles.
+        """
+        data = await self._load()
+        settings = data.get("settings", {})
+        return settings if isinstance(settings, dict) else {}
+
+    async def set_settings(self, updates: dict[str, Any]) -> dict[str, Any]:
+        """Update persistent settings and return the merged settings."""
+        data = await self._load()
+        settings = data.get("settings", {})
+        if not isinstance(settings, dict):
+            settings = {}
+        for k, v in (updates or {}).items():
+            settings[str(k)] = v
+        data["settings"] = settings
+        await self._save(data)
+        return settings
+
     async def _save(self, data: dict[str, Any]) -> None:
         await self._store.async_save(data)
 

custom_components/bahmcloud_store/views.py

@@ -215,7 +215,12 @@ class BCSApiView(HomeAssistantView):
 
     async def get(self, request: web.Request) -> web.Response:
         return web.json_response(
-            {"ok": True, "version": self.core.version, "repos": self.core.list_repos_public()}
+            {
+                "ok": True,
+                "version": self.core.version,
+                "settings": self.core.get_settings_public(),
+                "repos": self.core.list_repos_public(),
+            }
         )
 
     async def post(self, request: web.Request) -> web.Response:
@@ -248,6 +253,37 @@ class BCSApiView(HomeAssistantView):
         return web.json_response({"ok": False, "message": "Unknown operation"}, status=400)
 
 
+class BCSSettingsView(HomeAssistantView):
+    """Persistent UI settings (e.g. toggles)."""
+
+    url = "/api/bcs/settings"
+    name = "api:bcs_settings"
+    requires_auth = True
+
+    def __init__(self, core: Any) -> None:
+        self.core: BCSCore = core
+
+    async def get(self, request: web.Request) -> web.Response:
+        return web.json_response({"ok": True, "settings": self.core.get_settings_public()})
+
+    async def post(self, request: web.Request) -> web.Response:
+        try:
+            data = await request.json()
+        except Exception:
+            data = {}
+
+        updates: dict[str, Any] = {}
+        if "hacs_enabled" in data:
+            updates["hacs_enabled"] = bool(data.get("hacs_enabled"))
+
+        try:
+            settings = await self.core.set_settings(updates)
+            return web.json_response({"ok": True, "settings": settings})
+        except Exception as e:
+            _LOGGER.exception("BCS set settings failed: %s", e)
+            return web.json_response({"ok": False, "message": str(e) or "Failed"}, status=500)
+
+
 class BCSCustomRepoView(HomeAssistantView):
     url = "/api/bcs/custom_repo"
     name = "api:bcs_custom_repo"
@@ -292,6 +328,27 @@ class BCSReadmeView(HomeAssistantView):
         return web.json_response({"ok": True, "readme": md_str, "html": html})
 
 
+class BCSVersionsView(HomeAssistantView):
+    url = "/api/bcs/versions"
+    name = "api:bcs_versions"
+    requires_auth = True
+
+    def __init__(self, core: Any) -> None:
+        self.core: BCSCore = core
+
+    async def get(self, request: web.Request) -> web.Response:
+        repo_id = request.query.get("repo_id")
+        if not repo_id:
+            return web.json_response({"ok": False, "message": "Missing repo_id"}, status=400)
+
+        try:
+            versions = await self.core.list_repo_versions(repo_id)
+            return web.json_response({"ok": True, "repo_id": repo_id, "versions": versions}, status=200)
+        except Exception as e:
+            _LOGGER.exception("BCS list versions failed: %s", e)
+            return web.json_response({"ok": False, "message": str(e) or "List versions failed"}, status=500)
+
+
 class BCSInstallView(HomeAssistantView):
     url = "/api/bcs/install"
     name = "api:bcs_install"
@@ -302,11 +359,13 @@ class BCSInstallView(HomeAssistantView):
 
     async def post(self, request: web.Request) -> web.Response:
         repo_id = request.query.get("repo_id")
+        version = request.query.get("version")
         if not repo_id:
             return web.json_response({"ok": False, "message": "Missing repo_id"}, status=400)
 
         try:
-            result = await self.core.install_repo(repo_id)
+            v = str(version).strip() if version is not None else None
+            result = await self.core.install_repo(repo_id, version=v)
             return web.json_response(result, status=200)
         except Exception as e:
             _LOGGER.exception("BCS install failed: %s", e)
@@ -323,11 +382,13 @@ class BCSUpdateView(HomeAssistantView):
 
     async def post(self, request: web.Request) -> web.Response:
         repo_id = request.query.get("repo_id")
+        version = request.query.get("version")
         if not repo_id:
             return web.json_response({"ok": False, "message": "Missing repo_id"}, status=400)
 
         try:
-            result = await self.core.update_repo(repo_id)
+            v = str(version).strip() if version is not None else None
+            result = await self.core.update_repo(repo_id, version=v)
             return web.json_response(result, status=200)
         except Exception as e:
             _LOGGER.exception("BCS update failed: %s", e)
@@ -416,4 +477,56 @@ class BCSRestartView(HomeAssistantView):
             return web.json_response({"ok": True})
         except Exception as e:
             _LOGGER.exception("BCS restart failed: %s", e)
-            return web.json_response({"ok": False, "message": str(e) or "Restart failed"}, status=500)
+            return web.json_response({"ok": False, "message": str(e) or "Restart failed"}, status=500)
+
+class BCSRepoDetailView(HomeAssistantView):
+    url = "/api/bcs/repo"
+    name = "api:bcs_repo"
+    requires_auth = True
+
+    def __init__(self, core: Any) -> None:
+        self.core: BCSCore = core
+
+    async def get(self, request: web.Request) -> web.Response:
+        repo_id = (request.query.get("repo_id") or "").strip()
+        if not repo_id:
+            return web.json_response({"ok": False, "message": "Missing repo_id"}, status=400)
+
+        try:
+            repo = await self.core.ensure_repo_details(repo_id)
+            if not repo:
+                return web.json_response({"ok": False, "message": "Repo not found"}, status=404)
+
+            inst = self.core.get_installed(repo_id) or {}
+            installed = bool(inst)
+            domains = inst.get("domains") or []
+            if not isinstance(domains, list):
+                domains = []
+
+            return web.json_response({
+                "ok": True,
+                "repo": {
+                    "id": repo.id,
+                    "name": repo.name,
+                    "url": repo.url,
+                    "source": repo.source,
+                    "owner": repo.owner,
+                    "provider": repo.provider,
+                    "repo_name": repo.provider_repo_name,
+                    "description": repo.provider_description or repo.meta_description,
+                    "default_branch": repo.default_branch,
+                    "latest_version": repo.latest_version,
+                    "latest_version_source": repo.latest_version_source,
+                    "category": repo.meta_category,
+                    "meta_author": repo.meta_author,
+                    "meta_maintainer": repo.meta_maintainer,
+                    "meta_source": repo.meta_source,
+                    "installed": installed,
+                    "installed_version": inst.get("installed_version"),
+                    "installed_manifest_version": inst.get("installed_manifest_version"),
+                    "installed_domains": domains,
+                }
+            }, status=200)
+        except Exception as e:
+            _LOGGER.exception("BCS repo details failed: %s", e)
+            return web.json_response({"ok": False, "message": str(e) or "Repo details failed"}, status=500)