Remove stale update entities after uninstall

.gitignore

@@ -174,3 +174,6 @@ cython_debug/
 # PyPI configuration file
 .pypirc
 
+# Local project instructions
+.idea/start prompt.md
+

.idea/.gitignore

@@ -0,0 +1,10 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Ignored default folder with query files
+/queries/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml
+# Editor-based HTTP Client requests
+/httpRequests/

.idea/Projects.iml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="WEB_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/changes.md

@@ -0,0 +1,57 @@
+# Changes Log
+
+## 2026-03-23
+
+### Added
+- Created `.idea/start prompt.md` as a persistent project working prompt for future sessions.
+- Added `.idea/changes.md` as the preferred in-project location for the detailed session change log.
+- Added release notes support in the active Bahmcloud Store runtime path: backend provider fetching, a dedicated API endpoint, and panel display for the currently selected version when provider release notes are available.
+- Bumped the Home Assistant panel asset cache-buster from `v=109` to `v=110` so the updated frontend loads reliably after deployment.
+- Bumped the integration version from `0.7.2` to `0.7.3`.
+- Added the `0.7.3` release entry to `CHANGELOG.md` with the new release-notes and project-workflow changes.
+- Added a persistent rule that commit messages, pushes, release notes, and changelog entries must never mention prompts, AI/KI tools, or `.idea` folder files.
+- Added a persistent release rule that future git tags and release names must use plain version numbers without a leading `v`.
+- Added a broader persistent rule that internal workflow or prompt/process decisions must never appear in any public-facing project communication.
+- Added a persistent language rule that all project-facing repository content must stay in English regardless of the chat language.
+- Added persistent pinned repositories support: favorites are stored in settings, exposed by the backend, filterable and sortable in the store view, and toggleable from the detail view without forcing a full repository refresh.
+- Bumped the integration version from `0.7.3` to `0.7.4` and added the `0.7.4` release entry to `CHANGELOG.md` for the pinned-repositories feature.
+- Added the broader product roadmap to the persistent project prompt: blueprints, templates, Lovelace designs, and more category support as future store targets.
+- Started the blueprint/category-aware installer preparation: installation metadata now distinguishes install type and installed paths, repo payloads expose install targets, and the active panel shows install-target context for future non-integration categories.
+- Added initial blueprint install-path handling groundwork so the codebase is no longer fully hard-wired to `custom_components/`.
+- Bumped the integration version from `0.7.4` to `0.7.5` and added the `0.7.5` release entry to `CHANGELOG.md` for blueprint support and the documentation refresh.
+- Fixed blueprint update backups: blueprint file updates now create content backups before overwrite and can roll back copied blueprint files if installation fails.
+- Kept the no-restart behavior for blueprints, because blueprint deployment does not normally require a Home Assistant restart.
+- Restored blueprint backup/restore availability in the UI and backend: the restore button is visible again for blueprint installs, blueprint backups can be listed, and blueprint content can now be restored from backup without forcing a restart.
+- Fixed category-specific uninstall and restore messaging in the active panel: blueprints now reference `/config/blueprints` and explicitly state that no restart is required, while integrations keep the `/config/custom_components` restart warning.
+- Updated the public documentation set (`README.md`, `README_DEVELOPER.md`, `README_FULL.md`, and `CHANGELOG.md`) for the completed blueprint backup, restore, uninstall, and restart-behavior work, and bumped the integration version to `0.7.6` for the next release.
+- Fixed stale Home Assistant update entities after uninstall: BCS now removes orphaned update entities from the running platform state and entity registry when an installed repository or blueprint is uninstalled.
+
+### Documented
+- Captured the verified project identity from the repository and README files: Bahmcloud Store is a Home Assistant custom integration intended to behave like a provider-neutral store for custom integrations, similar to HACS but broader than GitHub-only workflows.
+- Recorded the actual active architecture from source analysis, including the config-entry-only setup, the fixed Bahmcloud store index, delayed startup refresh, periodic refresh, repo merge flow, cache usage, install/update/uninstall pipeline, backup/restore pipeline, update entities, and Repairs-based restart handling.
+- Recorded the current provider reality from code: GitHub, GitLab, and Gitea-compatible repositories are the concrete supported paths today, while truly generic "all git providers" support is still an intention and must be validated case by case.
+- Recorded the public API endpoints exposed by `views.py` so future work preserves the current backend contract unless a deliberate breaking change is approved.
+- Recorded storage facts from `storage.py`, including the `bcs_store` Home Assistant storage key and the persisted sections for custom repositories, installed repositories, settings, HACS cache, and repo enrichment cache.
+- Recorded frontend facts from the active panel registration in `__init__.py` and the active frontend implementation in `panel/panel.js`, including the cache-busting panel asset version query.
+- Updated the persistent start prompt to point future work to `.idea/changes.md` as the canonical detailed work log.
+- Release notes are intentionally tied to provider release objects, so tags or branches without release bodies now return a clear "not available" state instead of misleading fallback text.
+
+### Important findings from code analysis
+- Identified `custom_components/bahmcloud_store/panel/panel.js` as the active Home Assistant panel script currently loaded by the integration.
+- Identified `custom_components/bahmcloud_store/panel/app.js`, `custom_components/bahmcloud_store/panel/index.html`, and `custom_components/bahmcloud_store/panel/styles.css` as likely legacy or secondary assets that should not be treated as authoritative without verification.
+- Identified `custom_components/bahmcloud_store/store.py` as an older implementation with a different data model and API shape than the active `BCSCore` runtime.
+- Identified `custom_components/bahmcloud_store/custom_repo_view.py` as duplicate or legacy API code because the active custom-repo handling already exists in `views.py`.
+- Noted that the README set is directionally useful but not fully authoritative where it conflicts with current code behavior.
+- Noted that some repository files contain encoding or mojibake artifacts, so future edits should preserve valid UTF-8 and avoid spreading broken text.
+
+### Project rules written into the start prompt
+- Never push, commit, tag, or create a release without explicit user approval.
+- Always append a dated and detailed entry to `.idea/changes.md` for every change made.
+- When a release is created, collect all relevant changes since the last release into `CHANGELOG.md`.
+
+### Verification
+- Reviewed repository structure and current git status.
+- Read `README.md`, `README_DEVELOPER.md`, `README_FULL.md`, `bcs.yaml`, and the current `CHANGELOG.md`.
+- Analyzed the active backend files: `__init__.py`, `const.py`, `core.py`, `providers.py`, `metadata.py`, `storage.py`, `views.py`, `config_flow.py`, `update.py`, and `repairs.py`.
+- Checked panel and legacy-related files to distinguish the currently active UI path from older or duplicated files.
+- Verified that the active panel (`panel/panel.js`) now requests release notes from the new backend route and reloads them when the selected install version changes.

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/Projects.iml" filepath="$PROJECT_DIR$/.idea/Projects.iml" />
+    </modules>
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

CHANGELOG.md

@@ -11,6 +11,188 @@ Sections:
 
 ---
 
+## 0.7.6 - 2026-03-23
+
+### Added
+- Blueprint backup listing and restore support in the repository detail view.
+
+### Changed
+- Install, update, uninstall, and restore feedback now reflects whether a restart is actually required for the selected content type.
+- Blueprint restore dialogs and action messages now reference `/config/blueprints` instead of integration-only paths.
+
+### Fixed
+- Blueprint updates now create usable content backups before overwriting files.
+- Blueprint backups can be restored again from the active store UI after the previous restore-button regression.
+- Blueprint uninstall confirmation text now matches the real uninstall behavior and no longer incorrectly warns about `/config/custom_components` or mandatory restarts.
+
+## 0.7.5 - 2026-03-23
+
+### Added
+- Initial blueprint install support with deployment to the Home Assistant blueprints folder.
+- Category-aware install metadata including install type, install target, and installed paths.
+- Install target details in the repository view for supported content categories.
+
+### Changed
+- Store documentation refreshed to match the current feature set, including pinned repositories, release notes, and blueprint support.
+- Non-integration content handling is now prepared for category-specific install strategies instead of assuming `custom_components` only.
+- Frontend asset version updated so the latest store UI changes load immediately after deployment.
+
+## 0.7.4 - 2026-03-23
+
+### Added
+- Pinned repositories support to let admins keep important integrations easy to find.
+- Pin and unpin actions in the repository detail view.
+- Store filtering and sorting options for pinned repositories.
+
+### Changed
+- Repository favorites are now persisted in settings and restored across reloads.
+- Pinned repositories are highlighted in the store overview with a dedicated badge.
+- Frontend asset version updated so the latest panel changes load immediately after deployment.
+
+## 0.7.3 - 2026-03-23
+
+### Added
+- Release notes support in the repository detail view for provider releases.
+- New backend endpoint to fetch release notes for the selected repository version.
+
+
+### Changed
+- Home Assistant panel asset cache-buster bumped to ensure updated frontend assets load after deployment.
+- Release-note lookups now clearly report when a selected version has no provider release body instead of implying notes exist for plain tags or branches.
+
+## 0.7.2 – 2026-01-20
+
+### Fixed
+- When Bahmcloud Store is installed via an external installer (files copied into /config/custom_components), it now reconciles itself as "installed" in BCS storage so update checks work immediately.
+
+## 0.7.1 – 2026-01-20
+
+### Fixed
+- GitHub version provider now reliably fetches the latest 20 releases/tags using authenticated API requests.
+- Repositories that were previously fetched in a degraded state (only `latest` and `branch`) are now automatically refreshed on repository view.
+- Cached version lists with incomplete data are no longer reused and are re-fetched from the provider.
+
+## [0.7.0] - 2026-01-20
+
+### Added
+- Options dialog (gear icon) for the Bahmcloud Store integration.
+- Optional GitHub token can now be set, changed or removed via the Home Assistant UI.
+
+### Fixed
+- Fixed missing options flow when clicking the integration settings button.
+
+## [0.6.9] – 2026-01-19
+### Added
+- New Home Assistant **GUI setup** (Config Flow) – no YAML configuration required.
+- Optional **GitHub Token** support to increase API limits (up to 5000 req/h).  
+  Configurable via *Integration → Options*.
+- Clear setup guidance and warning about GitHub rate limits.
+- Automatic detection and warning if YAML setup is still present (ignored safely).
+
+### Changed
+- **store.yaml** URL is now fixed to the official Bahmcloud Store index:
+  https://git.bahmcloud.de/bahmcloud/ha_store/raw/branch/main/store.yaml
+- Installation workflow fully aligned with standard HA integrations.
+- Update platform migrated to `async_setup_entry`.
+
+### Fixed
+- Minor stability and persistence improvements in startup sequence.
+- Prevented duplicate background initialization when HA reloads the integration.
+
+### Notes
+- To enable extended GitHub access, create a fine-grained personal access token
+  (read-only) at https://github.com/settings/tokens and add it via the integration options.
+
+## 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

README.md

@@ -1,3 +1,86 @@
-# 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 content hosted on git platforms.
+It currently supports installing and managing:
+
+- Integrations
+- Blueprints
+
+Supported providers today:
+
+- GitHub
+- GitLab
+- Gitea / Forgejo-style hosts
+- Custom repositories added by URL when the host behaves compatibly
+
+This README is for end users.
+
+---
+
+## Features
+
+- Browse repositories from the official BCS index, HACS integration source, and custom repository URLs
+- Install, update, downgrade, and uninstall integrations directly from Home Assistant
+- Install blueprint repositories directly into the Home Assistant blueprints folder
+- Read repository README files inside the store UI
+- View release notes for provider releases
+- Pin repositories so important items stay easy to find
+- Use native Home Assistant update entities for installed integrations
+- Create and restore backups for integration installs and updates
+- Create and restore blueprint content backups during blueprint updates and restore actions
+
+---
+
+## Installation
+
+### Option A: Home Assistant OS / Supervised
+
+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
+
+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**: repositories from the Bahmcloud store index
+- **HACS**: optional official HACS integration source
+- **Custom**: repositories you add manually by URL
+
+---
+
+## Current Content Support
+
+### Integrations
+
+- Expected repository content: `custom_components/<domain>/...`
+- Install target: `/config/custom_components/<domain>`
+- Supports install, update, uninstall, backup, restore, version selection, and update entities
+- Restart required after install, update, uninstall, or restore
+
+### Blueprints
+
+- Expected repository content: `blueprints/...`
+- Install target: `/config/blueprints/...`
+- Supports install, update, uninstall, backup, and restore through the store
+- No restart is normally required for blueprint deployment
+
+---
+
+## Documentation
+
+- Developer documentation: `README_DEVELOPER.md`
+- Full user guide: `README_FULL.md`

README_DEVELOPER.md

@@ -0,0 +1,159 @@
+# Bahmcloud Store - Developer Documentation
+
+For contributors and maintainers.
+
+## Project Scope
+
+Bahmcloud Store is evolving from an integration-only store into a broader Home Assistant git-based content store.
+
+Currently supported install categories:
+
+- Integrations
+- Blueprints
+
+Planned categories:
+
+- Templates
+- Lovelace / dashboard designs
+- Additional content types with category-specific install logic
+
+## Repository Layout
+
+Repositories related to the project:
+
+1. Installer add-on:
+   `https://git.bahmcloud.de/bahmcloud/addons`
+2. Core integration:
+   `https://git.bahmcloud.de/bahmcloud/bahmcloud_store`
+3. Store index:
+   `https://git.bahmcloud.de/bahmcloud/ha_store`
+
+## Integration Layout
+
+`custom_components/bahmcloud_store/`
+
+- `__init__.py`: setup, panel registration, delayed startup refresh, periodic refresh
+- `core.py`: index merge, repo enrichment, install/update/uninstall, backup/restore, category-aware install groundwork
+- `providers.py`: provider detection, latest version lookup, release notes, README fetching
+- `metadata.py`: reads `bcs.yaml`, `hacs.json`, and `hacs.yaml`
+- `storage.py`: persistent storage for installed repos, settings, caches
+- `views.py`: HTTP API
+- `update.py`: Home Assistant update entities
+- `repairs.py`: restart-required repair flow
+- `panel/`: active frontend panel
+- `manifest.json`
+
+## Runtime Model
+
+- `RepoItem`: merged repository model used by the UI and backend
+- Installed repositories: persisted in Home Assistant storage
+- Settings: persistent UI and behavior settings such as HACS enablement and pinned repositories
+- Repo cache: provider and metadata enrichment cache
+- HACS cache: display metadata cache for HACS integration repositories
+
+## Metadata
+
+Metadata priority:
+
+1. `bcs.yaml`
+2. `hacs.yaml`
+3. `hacs.json`
+
+Common fields:
+
+```yaml
+name: Example Project
+description: Short description
+category: Integrations
+author: Example Author
+maintainer: Example Maintainer
+```
+
+Category currently matters operationally:
+
+- `Integrations` -> install from `custom_components/...`
+- `Blueprint` / `Blueprints` -> install from `blueprints/...`
+
+## Supported Install Categories
+
+### Integrations
+
+- Expected source layout: `custom_components/<domain>/manifest.json`
+- Install target: `/config/custom_components/<domain>`
+- Supports backup, restore, update entities, and restart-required flow
+
+### Blueprints
+
+- Expected source layout: `blueprints/...`
+- Install target: `/config/blueprints/...`
+- Supports install, update, uninstall, content backup, and content restore
+- Restores and uninstalls are path-based and operate on the recorded installed blueprint files
+- Category-aware groundwork is in place so future content types can use their own install strategies
+
+## HTTP API
+
+Base path: `/api/bcs`
+
+- `GET /api/bcs`
+- `POST /api/bcs?action=refresh`
+- `GET /api/bcs/settings`
+- `POST /api/bcs/settings`
+- `GET /api/bcs/readme?repo_id=...`
+- `GET /api/bcs/release_notes?repo_id=...&ref=...`
+- `GET /api/bcs/versions?repo_id=...`
+- `GET /api/bcs/repo?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=...`
+- `POST /api/bcs/restart`
+- `DELETE /api/bcs/custom_repo?id=...`
+
+## Current UI Features
+
+- Search, source filter, category filter, state filter, sorting
+- HACS integration source toggle
+- Pinned repositories
+- README rendering
+- Release notes rendering
+- Version selection
+- Backup restore UI for integrations and blueprints
+
+## Contributing to the Official Store Index
+
+Add a repository to the BCS store index in `ha_store`.
+
+Example index entry:
+
+```yaml
+- name: Example Project
+  url: https://your-git-hoster.example/org/repo
+  category: Blueprint
+```
+
+Recommended repository metadata:
+
+```yaml
+name: Example Project
+description: One-line description
+category: Blueprint
+author: Example Author
+maintainer: Example Maintainer
+```
+
+Validation should match the category:
+
+- Integrations: verify `custom_components/<domain>/manifest.json`
+- Blueprints: verify `blueprints/...`
+
+## Design Direction
+
+The long-term architecture should remain category-aware:
+
+- category -> validation strategy
+- category -> install target
+- category -> backup / restore behavior
+- category -> UI affordances
+
+This is especially important before Templates and Lovelace support are added, because those should stay compatible with established HACS expectations where possible.

README_FULL.md

@@ -0,0 +1,324 @@
+# Bahmcloud Store - Full User Guide
+
+This guide explains the current feature set of Bahmcloud Store (BCS) for Home Assistant.
+
+BCS is a git-based store UI that can currently manage integrations and blueprints from multiple repository providers.
+
+---
+
+## Contents
+
+- Concepts
+- Sources
+- Supported Content Types
+- UI Overview
+- Finding Repositories
+- Installing
+- Selecting Versions
+- Updating
+- Uninstalling
+- Pinned Repositories
+- Release Notes
+- Backups and Restore
+- Custom Repositories
+- HACS Repositories
+- Update Entities
+- Performance and Caching
+- Restart Behavior
+- Troubleshooting
+- FAQ
+
+---
+
+## Concepts
+
+### Sources
+
+- **BCS Official**: repositories from the official Bahmcloud index
+- **HACS**: optional HACS integration source
+- **Custom**: repositories you add manually by URL
+
+### Installed Ref
+
+BCS stores the installed ref separately from any version declared inside the repository itself.
+That makes update checks more reliable when a repository uses tags or releases that do not exactly match its internal manifest version.
+
+---
+
+## Supported Content Types
+
+### Integrations
+
+- Source layout: `custom_components/<domain>/...`
+- Install target: `/config/custom_components/<domain>`
+- Supports install, update, downgrade, uninstall, backups, restore, and update entities
+- Restart required after install, update, uninstall, or restore
+
+### Blueprints
+
+- Source layout: `blueprints/...`
+- Install target: `/config/blueprints/...`
+- Supports install, update, uninstall, backup, and restore through the store
+- Intended for blueprint repositories without integration-specific folder structures
+
+---
+
+## UI Overview
+
+Store view:
+
+- Search
+- Source filter
+- Category filter
+- State filter
+- Sorting
+- HACS source toggle
+- Pinned repository filtering and sorting
+
+Repository detail view:
+
+- README rendering
+- Release notes for provider releases
+- Version selector
+- Install / Update / Uninstall actions
+- Pin / Unpin action
+- Backup restore action for integrations
+- Category and install target information
+
+---
+
+## Finding Repositories
+
+1. Use **Search** to filter by name, description, or URL.
+2. Use **Source** to switch between BCS Official, HACS, and Custom repositories.
+3. Use **Category** to focus on a specific content type.
+4. Use **Pinned** filtering or sorting to surface repositories you watch often.
+
+Descriptions, metadata, and latest versions may appear progressively because BCS enriches repository information in the background.
+
+---
+
+## Installing
+
+### Integration Install
+
+1. Open a repository.
+2. Optionally select a version.
+3. Click **Install**.
+4. Restart Home Assistant when prompted.
+
+Internally, BCS:
+
+- downloads the selected repository archive
+- extracts `custom_components/...`
+- installs every valid integration found there
+- stores the installed ref
+- creates backups before overwriting existing integration folders
+
+### Blueprint Install
+
+1. Open a blueprint repository.
+2. Optionally select a version.
+3. Click **Install**.
+
+Internally, BCS:
+
+- downloads the selected repository archive
+- extracts `blueprints/...`
+- copies blueprint files into `/config/blueprints/...`
+
+Blueprint installs normally do not require a Home Assistant restart.
+
+---
+
+## Selecting Versions
+
+- Use the version selector in the detail view.
+- `Latest` uses the newest provider release or tag BCS can determine.
+- You can install an older release or tag when available.
+- Release notes are shown when the selected version is a provider release with a body.
+
+---
+
+## Updating
+
+### Integrations
+
+- The **Update** button appears when the latest ref differs from the installed ref.
+- Updates are also available through **Settings -> Updates** via native Home Assistant update entities.
+- Integration updates create backups before overwriting files.
+
+### Blueprints
+
+- Blueprint repositories can also be updated or reinstalled from another selected version.
+- Blueprint updates create content backups before overwriting files.
+- The current blueprint path handling is focused on direct deployment to the blueprints folder.
+
+---
+
+## Uninstalling
+
+### Integrations
+
+- Removes the installed integration directories from `/config/custom_components`
+- Clears the installed state in BCS
+- Usually requires a restart
+
+### Blueprints
+
+- Removes the installed blueprint files recorded by BCS
+- Cleans up empty directories below `/config/blueprints` when possible
+- Does not require a restart under normal conditions
+
+---
+
+## Pinned Repositories
+
+You can pin repositories to keep important items easy to find.
+
+Current behavior:
+
+- Pin or unpin from the detail view
+- Filter the store by pinned repositories
+- Sort the store with pinned repositories first
+- Pinned repositories show a dedicated badge in the store overview
+- Pinned state is persisted in settings
+
+---
+
+## Release Notes
+
+When a provider release has a release body, BCS can show release notes in the detail view for the selected version.
+
+Notes:
+
+- Release notes are available for real releases, not every tag or branch
+- If no provider release body exists, BCS shows a clear not-available state
+
+---
+
+## Backups and Restore
+
+Integration installs and updates create backups before overwriting existing files.
+Blueprint updates also create content backups before overwriting deployed blueprint files.
+
+Backup path:
+
+`/config/.bcs_backups/<domain>/<timestamp>/`
+
+Restore flow:
+
+1. Open the repository detail
+2. Click **Restore**
+3. Select a backup
+4. Confirm restore
+5. Restart Home Assistant if prompted
+
+Restore is available for integrations and blueprints.
+
+Blueprint restore flow:
+
+1. Open the blueprint repository detail
+2. Click **Restore**
+3. Select a backup
+4. Confirm restore
+
+Blueprint restores overwrite the recorded installed files under `/config/blueprints/...` and normally do not require a restart.
+
+---
+
+## Custom Repositories
+
+You can add any public repository URL that matches a supported provider style and contains supported content.
+
+BCS attempts to detect:
+
+- provider
+- default branch
+- latest version
+- metadata from `bcs.yaml`, `hacs.yaml`, or `hacs.json`
+- README content
+
+Custom repositories get a **Custom** badge and can be filtered separately.
+
+---
+
+## HACS Repositories
+
+Enable the HACS toggle to include official HACS integration repositories.
+
+Current scope:
+
+- HACS source support is currently focused on integrations
+- HACS metadata is used to improve naming and descriptions
+
+---
+
+## Update Entities
+
+BCS exposes Home Assistant update entities for installed integrations.
+
+- Found under **Settings -> Updates**
+- Shows installed ref and latest ref
+- Lets Home Assistant trigger the BCS update pipeline
+
+Blueprint repositories do not currently use the integration-style update entity flow.
+
+---
+
+## Performance and Caching
+
+BCS is designed to keep startup responsive.
+
+- Heavy work runs after Home Assistant startup
+- Repo data is enriched in the background
+- Repository details are cached
+- Version lists are cached
+- HACS metadata is cached
+
+Opening a repository detail view can force immediate enrichment for that repository.
+
+---
+
+## Restart Behavior
+
+Restart usually matters only for integration changes.
+
+- Integration install/update/uninstall/restore: restart expected
+- Blueprint install/update/uninstall/restore: restart usually not needed
+
+BCS uses a Home Assistant repair flow to surface restart requirements for integration changes.
+
+---
+
+## Troubleshooting
+
+- **Latest version missing**: open the repository detail once to force a recheck
+- **Release notes missing**: the selected version may be a tag or branch without a provider release body
+- **Blueprint install fails**: verify the repository really contains a `blueprints/` folder
+- **Integration install fails**: verify the repository contains `custom_components/<domain>/manifest.json`
+- **Repo appears but cannot install**: metadata can describe the category, but the repository layout still has to match that category
+
+---
+
+## FAQ
+
+### Where are integrations installed?
+
+`/config/custom_components/<domain>`
+
+### Where are blueprints installed?
+
+`/config/blueprints/...`
+
+### Are pinned repositories persistent?
+
+Yes.
+
+### Do blueprints require a restart?
+
+Usually no.
+
+### Do integrations require a restart?
+
+Yes, normally after install, update, uninstall, or 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

@@ -3,38 +3,64 @@ from __future__ import annotations
 import logging
 from datetime import timedelta
 
+from homeassistant.config_entries import ConfigEntry
 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.const import EVENT_HOMEASSISTANT_STARTED
-from homeassistant.helpers.discovery import async_load_platform
+from homeassistant.helpers.event import async_call_later, async_track_time_interval
 
-from .core import BCSCore, BCSConfig, BCSError
+from .const import CONF_GITHUB_TOKEN, DEFAULT_STORE_URL, DOMAIN
+from .core import BCSError, BCSConfig, BCSCore
 
 _LOGGER = logging.getLogger(__name__)
 
-DOMAIN = "bahmcloud_store"
+PLATFORMS: list[str] = ["update"]
-
-DEFAULT_STORE_URL = "https://git.bahmcloud.de/bahmcloud/ha_store/raw/branch/main/store.yaml"
-CONF_STORE_URL = "store_url"
 
 
 async def async_setup(hass: HomeAssistant, config: dict) -> bool:
-    cfg = config.get(DOMAIN, {}) or {}
+    """Set up Bahmcloud Store.
-    store_url = cfg.get(CONF_STORE_URL, DEFAULT_STORE_URL)
 
-    core = BCSCore(hass, BCSConfig(store_url=store_url))
+    We intentionally do NOT support YAML configuration.
-    hass.data[DOMAIN] = core
+    This method is kept so we can log a helpful message if someone tries.
+    """
+    if DOMAIN in (config or {}):
+        _LOGGER.warning(
+            "BCS YAML configuration is no longer supported. "
+            "Please remove 'bahmcloud_store:' from configuration.yaml and set up the integration via the UI."
+        )
+    return True
+
+
+async def async_setup_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    """Set up Bahmcloud Store from a config entry (UI setup)."""
+    # Only one instance.
+    hass.data.setdefault(DOMAIN, {})
+
+    github_token = (entry.options.get(CONF_GITHUB_TOKEN) or "").strip() or None
+
+    core = BCSCore(
+        hass,
+        BCSConfig(
+            store_url=DEFAULT_STORE_URL,
+            github_token=github_token,
+        ),
+    )
+
+    hass.data[DOMAIN][entry.entry_id] = core
+    # Keep a convenient shortcut for platforms that previously used hass.data[DOMAIN] directly.
+    hass.data[DOMAIN]["_core"] = core
 
     await core.async_initialize()
 
-    # Provide native Update entities in Settings -> System -> Updates.
+    # HTTP views + panel (registered once per entry; we only allow one entry).
-    # This integration is YAML-based (async_setup), therefore we load the platform manually.
-    await async_load_platform(hass, "update", DOMAIN, {}, config)
-
     from .views import (
         StaticAssetsView,
         BCSApiView,
+        BCSSettingsView,
         BCSReadmeView,
+        BCSVersionsView,
+        BCSReleaseNotesView,
+        BCSRepoDetailView,
         BCSCustomRepoView,
         BCSInstallView,
         BCSUpdateView,
@@ -46,7 +72,11 @@ 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(BCSReleaseNotesView(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 +90,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=112",
         sidebar_title="Bahmcloud Store",
         sidebar_icon="mdi:store",
         require_admin=True,
         config={},
     )
 
-    try:
+    async def _do_startup_refresh(_now=None) -> None:
-        await core.full_refresh(source="startup")
+        try:
-    except BCSError as e:
+            await core.full_refresh(source="startup")
-        _LOGGER.error("Initial refresh failed: %s", e)
+        except BCSError as e:
+            _LOGGER.error("Initial refresh failed: %s", e)
+
+    # Do not block startup; refresh after HA is up.
+    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:
@@ -83,4 +120,16 @@ async def async_setup(hass: HomeAssistant, config: dict) -> bool:
     interval_seconds = int(getattr(core, "refresh_seconds", 300) or 300)
     async_track_time_interval(hass, periodic, timedelta(seconds=interval_seconds))
 
-    return True
+    await hass.config_entries.async_forward_entry_setups(entry, PLATFORMS)
+    return True
+
+
+async def async_unload_entry(hass: HomeAssistant, entry: ConfigEntry) -> bool:
+    """Unload a config entry."""
+    unload_ok = await hass.config_entries.async_unload_platforms(entry, PLATFORMS)
+    if unload_ok:
+        try:
+            hass.data.get(DOMAIN, {}).pop(entry.entry_id, None)
+        except Exception:
+            pass
+    return unload_ok

custom_components/bahmcloud_store/config_flow.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+import logging
+
+import voluptuous as vol
+
+from homeassistant import config_entries
+from homeassistant.core import callback
+
+from .const import CONF_GITHUB_TOKEN, DOMAIN
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def _schema(default_token: str | None = None) -> vol.Schema:
+    default_token = (default_token or "").strip()
+    return vol.Schema({vol.Optional(CONF_GITHUB_TOKEN, default=default_token): str})
+
+
+class BahmcloudStoreConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
+    """Config flow for Bahmcloud Store.
+
+    The store index URL is fixed and not user-configurable.
+    The only optional setting is a GitHub token to increase API rate limits.
+    """
+
+    VERSION = 1
+
+    async def async_step_user(self, user_input: dict | None = None):
+        # Allow only one instance.
+        await self.async_set_unique_id(DOMAIN)
+        self._abort_if_unique_id_configured()
+
+        if user_input is None:
+            return self.async_show_form(step_id="user", data_schema=_schema(None))
+
+        token = str(user_input.get(CONF_GITHUB_TOKEN, "")).strip() or None
+
+        return self.async_create_entry(
+            title="Bahmcloud Store",
+            data={},
+            options={CONF_GITHUB_TOKEN: token} if token else {},
+        )
+
+    @staticmethod
+    @callback
+    def async_get_options_flow(config_entry: config_entries.ConfigEntry):
+        return BahmcloudStoreOptionsFlowHandler(config_entry)
+
+
+class BahmcloudStoreOptionsFlowHandler(config_entries.OptionsFlow):
+    """Options flow to manage optional GitHub token."""
+
+    def __init__(self, config_entry: config_entries.ConfigEntry) -> None:
+        self._config_entry = config_entry
+
+    async def async_step_init(self, user_input: dict | None = None):
+        if user_input is None:
+            current = self._config_entry.options.get(CONF_GITHUB_TOKEN) or ""
+            return self.async_show_form(step_id="init", data_schema=_schema(str(current)))
+
+        token = str(user_input.get(CONF_GITHUB_TOKEN, "")).strip() or None
+        options = dict(self._config_entry.options)
+
+        # Allow clearing the token.
+        if token:
+            options[CONF_GITHUB_TOKEN] = token
+        else:
+            options.pop(CONF_GITHUB_TOKEN, None)
+
+        return self.async_create_entry(title="", data=options)

custom_components/bahmcloud_store/const.py

@@ -0,0 +1,11 @@
+"""Constants for Bahmcloud Store."""
+
+from __future__ import annotations
+
+DOMAIN = "bahmcloud_store"
+
+# Fixed store index URL (not user-configurable).
+DEFAULT_STORE_URL = "https://git.bahmcloud.de/bahmcloud/ha_store/raw/branch/main/store.yaml"
+
+# Config entry option keys
+CONF_GITHUB_TOKEN = "github_token"

custom_components/bahmcloud_store/manifest.json

@@ -1,10 +1,11 @@
 {
   "domain": "bahmcloud_store",
   "name": "Bahmcloud Store",
-  "version": "0.6.1",
+  "version": "0.7.6",
   "documentation": "https://git.bahmcloud.de/bahmcloud/bahmcloud_store",
+  "config_flow": true,
   "platforms": ["update"],
   "requirements": [],
   "codeowners": ["@bahmcloud"],
   "iot_class": "local_polling"
-}
+}

custom_components/bahmcloud_store/panel/panel.js

@@ -18,6 +18,13 @@ 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._favoriteRepoIds = [];
+
     this._detailRepoId = null;
     this._detailRepo = null;
     this._readmeLoading = false;
@@ -45,6 +52,19 @@ 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)
+    this._releaseNotesLoading = false;
+    this._releaseNotesText = null;
+    this._releaseNotesHtml = null;
+    this._releaseNotesError = null;
+
+    // History handling (mobile back button should go back to list, not exit panel)
+    this._historyBound = false;
+    this._handlingPopstate = false;
   }
 
   set hass(hass) {
@@ -52,10 +72,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 +120,18 @@ 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;
+      this._favoriteRepoIds = Array.isArray(data?.settings?.favorite_repo_ids)
+        ? data.settings.favorite_repo_ids.map((x) => String(x))
+        : [];
+
+      // Sync settings from backend (e.g. HACS toggle)
+      this._hacsEnabled = !!data?.settings?.hacs_enabled;
+      this._favoriteRepoIds = Array.isArray(data?.settings?.favorite_repo_ids)
+        ? data.settings.favorite_repo_ids.map((x) => String(x))
+        : [];
+
       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 +144,22 @@ 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;
+        this._favoriteRepoIds = Array.isArray(resp?.settings?.favorite_repo_ids)
+          ? resp.settings.favorite_repo_ids.map((x) => String(x))
+          : [];
+      }
+    } 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,12 +195,20 @@ 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 {
         this._restartRequired = !!resp.restart_required;
-        this._lastActionMsg = "Installation finished. Restart required.";
+        this._lastActionMsg = resp?.restart_required
+          ? "Installation finished. Restart required."
+          : "Installation finished. No restart required.";
       }
     } catch (e) {
       this._error = e?.message ? String(e.message) : String(e);
@@ -140,12 +229,20 @@ 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 {
         this._restartRequired = !!resp.restart_required;
-        this._lastActionMsg = "Update finished. Restart required.";
+        this._lastActionMsg = resp?.restart_required
+          ? "Update finished. Restart required."
+          : "Update finished. No restart required.";
       }
     } catch (e) {
       this._error = e?.message ? String(e.message) : String(e);
@@ -160,7 +257,11 @@ class BahmcloudStorePanel extends HTMLElement {
     if (!repoId) return;
     if (this._installingRepoId || this._updatingRepoId || this._uninstallingRepoId) return;
 
-    const ok = window.confirm("Really uninstall this repository? This will remove its files from /config/custom_components and requires a restart.");
+    const details = this._getInstallTypeDetails(repoId);
+    const uninstallText = details.restartRequired
+      ? `Really uninstall this repository? This will remove its files from ${details.targetPath} and requires a restart.`
+      : `Really uninstall this repository? This will remove its files from ${details.targetPath}. No restart is required.`;
+    const ok = window.confirm(uninstallText);
     if (!ok) return;
 
     this._uninstallingRepoId = repoId;
@@ -174,7 +275,9 @@ class BahmcloudStorePanel extends HTMLElement {
         this._error = this._safeText(resp?.message) || "Uninstall failed.";
       } else {
         this._restartRequired = !!resp.restart_required;
-        this._lastActionMsg = "Uninstall finished. Restart required.";
+        this._lastActionMsg = resp?.restart_required
+          ? "Uninstall finished. Restart required."
+          : "Uninstall finished. No restart required.";
       }
     } catch (e) {
       this._error = e?.message ? String(e.message) : String(e);
@@ -244,7 +347,11 @@ class BahmcloudStorePanel extends HTMLElement {
       return;
     }
 
-    const ok = window.confirm("Restore selected backup? This will overwrite the installed files under /config/custom_components and requires a restart.");
+    const details = this._getInstallTypeDetails(this._restoreRepoId);
+    const restoreText = details.restartRequired
+      ? `Restore selected backup? This will overwrite the installed files under ${details.targetPath} and requires a restart.`
+      : `Restore selected backup? This will overwrite the installed files under ${details.targetPath}. No restart is required.`;
+    const ok = window.confirm(restoreText);
     if (!ok) return;
 
     this._restoring = true;
@@ -257,7 +364,9 @@ class BahmcloudStorePanel extends HTMLElement {
         this._restoreError = this._safeText(resp?.message) || "Restore failed.";
       } else {
         this._restartRequired = !!resp.restart_required;
-        this._lastActionMsg = "Restore finished. Restart required.";
+        this._lastActionMsg = resp?.restart_required
+          ? "Restore finished. Restart required."
+          : "Restore finished. No restart required.";
         this._closeRestore();
       }
     } catch (e) {
@@ -291,21 +400,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 +454,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;
@@ -365,9 +472,101 @@ class BahmcloudStorePanel extends HTMLElement {
     this._readmeError = null;
     this._readmeExpanded = false;
     this._readmeCanToggle = false;
+    this._releaseNotesLoading = false;
+    this._releaseNotesText = null;
+    this._releaseNotesHtml = null;
+    this._releaseNotesError = null;
+
+    // Versions dropdown
+    if (!(repoId in this._selectedVersionByRepoId)) {
+      this._selectedVersionByRepoId[repoId] = ""; // default = latest
+    }
 
     this._update();
+    this._loadRepoDetails(repoId);
     this._loadReadme(repoId);
+    this._loadVersions(repoId);
+    this._loadReleaseNotes(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 _loadReleaseNotes(repoId) {
+    if (!this._hass || !repoId) return;
+
+    this._releaseNotesLoading = true;
+    this._releaseNotesText = null;
+    this._releaseNotesHtml = null;
+    this._releaseNotesError = null;
+    this._update();
+
+    try {
+      const sel = this._safeText(this._selectedVersionByRepoId?.[repoId] || "").trim();
+      const qv = sel ? `&ref=${encodeURIComponent(sel)}` : "";
+      const resp = await this._hass.callApi(
+        "get",
+        `bcs/release_notes?repo_id=${encodeURIComponent(repoId)}${qv}`,
+      );
+
+      if (resp?.ok && typeof resp.release_notes === "string" && resp.release_notes.trim()) {
+        this._releaseNotesText = resp.release_notes;
+        this._releaseNotesHtml =
+          typeof resp.html === "string" && resp.html.trim() ? resp.html : null;
+      } else {
+        this._releaseNotesError =
+          this._safeText(resp?.message) || "Release notes not available for this version.";
+      }
+    } catch (e) {
+      this._releaseNotesError = e?.message
+        ? String(e.message)
+        : "Release notes not available for this version.";
+    } finally {
+      this._releaseNotesLoading = false;
+      this._update();
+    }
   }
 
   async _loadReadme(repoId) {
@@ -492,6 +691,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;
@@ -775,6 +992,58 @@ class BahmcloudStorePanel extends HTMLElement {
     return v === true;
   }
 
+  _isFavoriteRepo(repoId) {
+    const id = this._safeId(repoId);
+    return !!id && Array.isArray(this._favoriteRepoIds) && this._favoriteRepoIds.includes(id);
+  }
+
+  _getRepoById(repoId) {
+    const id = this._safeId(repoId);
+    if (!id || !Array.isArray(this._data?.repos)) return null;
+    return this._data.repos.find((r) => this._safeId(r?.id) === id) || null;
+  }
+
+  _getInstallTypeDetails(repoOrId) {
+    const repo = typeof repoOrId === "string" ? this._getRepoById(repoOrId) : repoOrId;
+    const installType = this._safeText(repo?.install_type) || "integration";
+    if (installType === "blueprint") {
+      return { installType, targetPath: "/config/blueprints", restartRequired: false };
+    }
+    if (installType === "template") {
+      return { installType, targetPath: "/config", restartRequired: false };
+    }
+    if (installType === "lovelace") {
+      return { installType, targetPath: "/config/www", restartRequired: false };
+    }
+    return { installType: "integration", targetPath: "/config/custom_components", restartRequired: true };
+  }
+
+  async _toggleFavorite(repoId) {
+    if (!this._hass || !repoId) return;
+
+    const id = this._safeId(repoId);
+    const current = Array.isArray(this._favoriteRepoIds) ? this._favoriteRepoIds.slice() : [];
+    const next = current.includes(id)
+      ? current.filter((x) => x !== id)
+      : current.concat([id]);
+
+    this._favoriteRepoIds = next;
+
+    if (Array.isArray(this._data?.repos)) {
+      this._data.repos = this._data.repos.map((r) => {
+        if (this._safeId(r?.id) !== id) return r;
+        return { ...r, favorite: next.includes(id) };
+      });
+    }
+    if (this._detailRepo && this._safeId(this._detailRepo?.id) === id) {
+      this._detailRepo = { ...this._detailRepo, favorite: next.includes(id) };
+    }
+
+    this._update();
+    await this._setSettings({ favorite_repo_ids: next });
+    await this._load();
+  }
+
   _renderStore() {
     const repos = Array.isArray(this._data.repos) ? this._data.repos : [];
 
@@ -790,15 +1059,22 @@ 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);
         const updateAvailable = installed && !!latest && (!installedVersion || latest !== installedVersion);
+        const favorite = this._asBoolStrict(r?.favorite) || this._isFavoriteRepo(r?.id);
 
         if (this._filter === "installed" && !installed) return false;
         if (this._filter === "not_installed" && installed) return false;
         if (this._filter === "updates" && !updateAvailable) return false;
         if (this._filter === "custom" && r?.source !== "custom") return false;
+        if (this._filter === "favorites" && !favorite) return false;
 
         return true;
       })
@@ -810,16 +1086,22 @@ class BahmcloudStorePanel extends HTMLElement {
         const ainstalled = this._asBoolStrict(a?.installed);
         const ainstalledVersion = this._safeText(a?.installed_version);
         const aupdate = ainstalled && !!alatest && (!ainstalledVersion || alatest !== ainstalledVersion);
+        const afavorite = this._asBoolStrict(a?.favorite) || this._isFavoriteRepo(a?.id);
 
         const blatest = this._safeText(b?.latest_version);
         const binstalled = this._asBoolStrict(b?.installed);
         const binstalledVersion = this._safeText(b?.installed_version);
         const bupdate = binstalled && !!blatest && (!binstalledVersion || blatest !== binstalledVersion);
+        const bfavorite = this._asBoolStrict(b?.favorite) || this._isFavoriteRepo(b?.id);
 
         if (this._sort === "updates_first") {
           if (aupdate !== bupdate) return aupdate ? -1 : 1;
           return an.localeCompare(bn);
         }
+        if (this._sort === "favorites_first") {
+          if (afavorite !== bfavorite) return afavorite ? -1 : 1;
+          return an.localeCompare(bn);
+        }
         if (this._sort === "installed_first") {
           if (ainstalled !== binstalled) return ainstalled ? -1 : 1;
           return an.localeCompare(bn);
@@ -842,9 +1124,15 @@ class BahmcloudStorePanel extends HTMLElement {
         const installed = this._asBoolStrict(r?.installed);
         const installedVersion = this._safeText(r?.installed_version);
         const updateAvailable = installed && !!latest && (!installedVersion || latest !== installedVersion);
+        const favorite = this._asBoolStrict(r?.favorite) || this._isFavoriteRepo(r?.id);
 
         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 (favorite) badges.push("Pinned");
         if (installed) badges.push("Installed");
         if (updateAvailable) badges.push("Update");
 
@@ -870,12 +1158,25 @@ 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("")}
         </select>
         <select id="filter">
           <option value="all" ${this._filter === "all" ? "selected" : ""}>All</option>
+          <option value="favorites" ${this._filter === "favorites" ? "selected" : ""}>Pinned</option>
           <option value="installed" ${this._filter === "installed" ? "selected" : ""}>Installed</option>
           <option value="not_installed" ${this._filter === "not_installed" ? "selected" : ""}>Not installed</option>
           <option value="updates" ${this._filter === "updates" ? "selected" : ""}>Updates available</option>
@@ -883,6 +1184,7 @@ class BahmcloudStorePanel extends HTMLElement {
         </select>
         <select id="sort">
           <option value="az" ${this._sort === "az" ? "selected" : ""}>A–Z</option>
+          <option value="favorites_first" ${this._sort === "favorites_first" ? "selected" : ""}>Pinned first</option>
           <option value="updates_first" ${this._sort === "updates_first" ? "selected" : ""}>Updates first</option>
           <option value="installed_first" ${this._sort === "installed_first" ? "selected" : ""}>Installed first</option>
         </select>
@@ -903,6 +1205,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 +1233,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 +1296,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) || "";
@@ -962,6 +1307,7 @@ class BahmcloudStorePanel extends HTMLElement {
       this._safeText(r?.latest_version) ? `Latest: ${this._safeText(r?.latest_version)}` : "Latest: -",
       this._safeText(r?.provider) ? `Provider: ${this._safeText(r?.provider)}` : null,
       this._safeText(r?.category) ? `Category: ${this._safeText(r?.category)}` : null,
+      this._safeText(r?.install_target) ? `Target: ${this._safeText(r?.install_target)}` : null,
       this._safeText(r?.meta_author) ? `Author: ${this._safeText(r?.meta_author)}` : null,
       this._safeText(r?.meta_maintainer) ? `Maintainer: ${this._safeText(r?.meta_maintainer)}` : null,
       this._safeText(r?.meta_source) ? `Meta: ${this._safeText(r?.meta_source)}` : null,
@@ -1001,12 +1347,13 @@ 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 : [];
+    const installedPaths = Array.isArray(r?.installed_paths) ? r.installed_paths : [];
     const latestVersion = this._safeText(r?.latest_version);
+    const favorite = this._asBoolStrict(r?.favorite) || this._isFavoriteRepo(repoId);
+    const installType = this._safeText(r?.install_type) || "integration";
 
     const busyInstall = this._installingRepoId === repoId;
     const busyUpdate = this._updatingRepoId === repoId;
@@ -1015,10 +1362,62 @@ 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 releaseNotesBlock = this._releaseNotesLoading
+      ? `<div class="card" style="margin-top:12px;">Loading release notes...</div>`
+      : this._releaseNotesText
+      ? `
+        <div class="card" style="margin-top:12px;">
+          <div class="row" style="align-items:center;">
+            <div><strong>Release Notes</strong></div>
+            <div class="muted small">${this._esc(selectedRef || latestVersion || "-")}</div>
+          </div>
+          <div id="releaseNotesPretty" class="md" style="margin-top:12px;"></div>
+          <details>
+            <summary>Show raw release notes</summary>
+            <div style="margin-top:10px;">
+              <pre class="readme">${this._esc(this._releaseNotesText)}</pre>
+            </div>
+          </details>
+        </div>
+      `
+      : `
+        <div class="card" style="margin-top:12px;">
+          <div><strong>Release Notes</strong></div>
+          <div class="muted" style="margin-top:8px;">${this._esc(this._releaseNotesError || "Release notes not available for this version.")}</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>`;
     const restoreBtn = `<button class="primary" id="btnRestore" ${!installed || busy ? "disabled" : ""}>Restore</button>`;
+    const favoriteBtn = `<button id="btnFavorite">${favorite ? "Unpin" : "Pin"}</button>`;
 
     const restartHint = this._restartRequired
       ? `
@@ -1065,9 +1464,14 @@ class BahmcloudStorePanel extends HTMLElement {
               <div><strong>Installed version:</strong> ${this._esc(installedVersion || "-")}</div>
               <div><strong>Latest version:</strong> ${this._esc(latestVersion || "-")}</div>
               <div style="margin-top:6px;"><strong>Domains:</strong> ${installedDomains.length ? this._esc(installedDomains.join(", ")) : "-"}</div>
+              <div style="margin-top:6px;"><strong>Installed paths:</strong> ${installedPaths.length ? this._esc(installedPaths.join(", ")) : "-"}</div>
             </div>
 
+            ${versionSelect}
+            ${releaseNotesBlock}
+
             <div class="row" style="margin-top:14px; gap:10px; flex-wrap:wrap;">
+              ${favoriteBtn}
               ${installBtn}
               ${updateBtn}
               ${uninstallBtn}
@@ -1091,6 +1495,14 @@ class BahmcloudStorePanel extends HTMLElement {
     const btnRestore = root.getElementById("btnRestore");
     const btnRestart = root.getElementById("btnRestart");
     const btnReadmeToggle = root.getElementById("btnReadmeToggle");
+    const selVersion = root.getElementById("selVersion");
+    const btnFavorite = root.getElementById("btnFavorite");
+
+    if (btnFavorite) {
+      btnFavorite.addEventListener("click", () => {
+        if (this._detailRepoId) this._toggleFavorite(this._detailRepoId);
+      });
+    }
 
     if (btnInstall) {
       btnInstall.addEventListener("click", () => {
@@ -1099,6 +1511,15 @@ 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;
+        this._loadReleaseNotes(this._detailRepoId);
+      });
+    }
+
     if (btnUpdate) {
       btnUpdate.addEventListener("click", () => {
         if (btnUpdate.disabled) return;
@@ -1134,7 +1555,22 @@ class BahmcloudStorePanel extends HTMLElement {
     }
 
     const mount = root.getElementById("readmePretty");
-    if (!mount) return;
+    if (!mount) {
+      const releaseMount = root.getElementById("releaseNotesPretty");
+      if (releaseMount) {
+        if (this._releaseNotesText) {
+          if (this._releaseNotesHtml) {
+            releaseMount.innerHTML = this._releaseNotesHtml;
+            this._postprocessRenderedMarkdown(releaseMount);
+          } else {
+            releaseMount.innerHTML = `<div class="muted">Rendered HTML not available. Use "Show raw release notes".</div>`;
+          }
+        } else {
+          releaseMount.innerHTML = "";
+        }
+      }
+      return;
+    }
 
     if (this._readmeText) {
       if (this._readmeHtml) {
@@ -1146,6 +1582,20 @@ class BahmcloudStorePanel extends HTMLElement {
     } else {
       mount.innerHTML = "";
     }
+
+    const releaseMount = root.getElementById("releaseNotesPretty");
+    if (releaseMount) {
+      if (this._releaseNotesText) {
+        if (this._releaseNotesHtml) {
+          releaseMount.innerHTML = this._releaseNotesHtml;
+          this._postprocessRenderedMarkdown(releaseMount);
+        } else {
+          releaseMount.innerHTML = `<div class="muted">Rendered HTML not available. Use "Show raw release notes".</div>`;
+        }
+      } else {
+        releaseMount.innerHTML = "";
+      }
+    }
   }
 
   _wireRestoreModal() {
@@ -1213,12 +1663,16 @@ class BahmcloudStorePanel extends HTMLElement {
       })
       .join("");
 
+    const restoreDetails = this._getInstallTypeDetails(this._restoreRepoId);
+    const actionHint = restoreDetails.restartRequired
+      ? `Select a backup to restore. This will overwrite files under ${restoreDetails.targetPath} and requires a restart.`
+      : `Select a backup to restore. This will overwrite files under ${restoreDetails.targetPath}. No restart is required.`;
     const msg = this._restoreLoading
       ? "Loading backups…"
       : this._restoreError
       ? this._safeText(this._restoreError)
       : opts.length
-      ? "Select a backup to restore. This will overwrite files under /config/custom_components and requires a restart."
+      ? actionHint
       : "No backups found.";
 
     return `
@@ -1308,4 +1762,4 @@ class BahmcloudStorePanel extends HTMLElement {
   }
 }
 
-customElements.define("bahmcloud-store-panel", BahmcloudStorePanel);
+customElements.define("bahmcloud-store-panel", BahmcloudStorePanel);

custom_components/bahmcloud_store/providers.py

@@ -189,9 +189,11 @@ async def _github_latest_version_redirect(hass: HomeAssistant, owner: str, repo:
     return None, None
 
 
-async def _github_latest_version_api(hass: HomeAssistant, owner: str, repo: str) -> tuple[str | None, str | None]:
+async def _github_latest_version_api(
+    hass: HomeAssistant, owner: str, repo: str, *, github_token: str | None = None
+) -> tuple[str | None, str | None]:
     session = async_get_clientsession(hass)
-    headers = {"Accept": "application/vnd.github+json", "User-Agent": UA}
+    headers = _github_headers(github_token)
 
     data, status = await _safe_json(session, f"https://api.github.com/repos/{owner}/{repo}/releases/latest", headers=headers)
     if isinstance(data, dict) and data.get("tag_name"):
@@ -217,12 +219,14 @@ async def _github_latest_version_api(hass: HomeAssistant, owner: str, repo: str)
     return None, None
 
 
-async def _github_latest_version(hass: HomeAssistant, owner: str, repo: str) -> tuple[str | None, str | None]:
+async def _github_latest_version(
+    hass: HomeAssistant, owner: str, repo: str, *, github_token: str | None = None
+) -> tuple[str | None, str | None]:
     tag, src = await _github_latest_version_redirect(hass, owner, repo)
     if tag:
         return tag, src
 
-    tag, src = await _github_latest_version_api(hass, owner, repo)
+    tag, src = await _github_latest_version_api(hass, owner, repo, github_token=github_token)
     if tag:
         return tag, src
 
@@ -316,7 +320,16 @@ async def _gitlab_latest_version(
     return None, None
 
 
-async def fetch_repo_info(hass: HomeAssistant, repo_url: str) -> RepoInfo:
+def _github_headers(github_token: str | None = None) -> dict:
+    headers = {"Accept": "application/vnd.github+json", "User-Agent": UA}
+    token = (github_token or "").strip()
+    if token:
+        # PAT or fine-grained token
+        headers["Authorization"] = f"Bearer {token}"
+    return headers
+
+
+async def fetch_repo_info(hass: HomeAssistant, repo_url: str, *, github_token: str | None = None) -> RepoInfo:
     provider = detect_provider(repo_url)
     owner, repo = _split_owner_repo(repo_url)
 
@@ -337,7 +350,7 @@ async def fetch_repo_info(hass: HomeAssistant, repo_url: str) -> RepoInfo:
 
     try:
         if provider == "github":
-            headers = {"Accept": "application/vnd.github+json", "User-Agent": UA}
+            headers = _github_headers(github_token)
             data, status = await _safe_json(session, f"https://api.github.com/repos/{owner}/{repo}", headers=headers)
 
             if isinstance(data, dict):
@@ -356,7 +369,7 @@ async def fetch_repo_info(hass: HomeAssistant, repo_url: str) -> RepoInfo:
                 if desc:
                     info.description = desc
 
-            ver, src = await _github_latest_version(hass, owner, repo)
+            ver, src = await _github_latest_version(hass, owner, repo, github_token=github_token)
             info.latest_version = ver
             info.latest_version_source = src
             return info
@@ -504,4 +517,239 @@ 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,
+    github_token: str | None = None,
+) -> 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 provider APIs; for GitHub we include the configured token (if any) to avoid unauthenticated rate limits.
+    - 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}
+    if prov == "github":
+        headers = _github_headers(github_token)
+
+    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 (prefer these over tags)
+            # Use the configured GitHub token (if any) to avoid unauthenticated rate limits.
+            gh_headers = _github_headers(github_token)
+            per_page = max(1, min(int(limit), 100))
+            data, _ = await _safe_json(
+                session,
+                f"https://api.github.com/repos/{owner}/{repo}/releases?per_page={per_page}",
+                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={per_page}",
+                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
+
+
+async def fetch_release_notes_markdown(
+    hass: HomeAssistant,
+    repo_url: str,
+    *,
+    ref: str | None,
+    provider: str | None = None,
+    github_token: str | None = None,
+) -> str | None:
+    """Fetch release notes for a specific release tag."""
+
+    repo_url = (repo_url or "").strip()
+    target_ref = (ref or "").strip()
+    if not repo_url or not target_ref:
+        return None
+
+    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 None
+
+    session = async_get_clientsession(hass)
+
+    try:
+        if prov == "github":
+            data, status = await _safe_json(
+                session,
+                f"https://api.github.com/repos/{owner}/{repo}/releases/tags/{quote_plus(target_ref)}",
+                headers=_github_headers(github_token),
+            )
+            if status == 200 and isinstance(data, dict):
+                body = data.get("body")
+                if isinstance(body, str) and body.strip():
+                    return body
+            return None
+
+        if prov == "gitlab":
+            u = urlparse(repo_url.rstrip("/"))
+            base = f"{u.scheme}://{u.netloc}"
+            project = quote_plus(f"{owner}/{repo}")
+            data, status = await _safe_json(
+                session,
+                f"{base}/api/v4/projects/{project}/releases/{quote_plus(target_ref)}",
+                headers={"User-Agent": UA},
+            )
+            if status == 200 and isinstance(data, dict):
+                body = data.get("description")
+                if isinstance(body, str) and body.strip():
+                    return body
+            return None
+
+        u = urlparse(repo_url.rstrip("/"))
+        base = f"{u.scheme}://{u.netloc}"
+        data, status = await _safe_json(
+            session,
+            f"{base}/api/v1/repos/{owner}/{repo}/releases/tags/{quote_plus(target_ref)}",
+            headers={"User-Agent": UA},
+        )
+        if status == 200 and isinstance(data, dict):
+            body = data.get("body")
+            if isinstance(body, str) and body.strip():
+                return body
+            note = data.get("note")
+            if isinstance(note, str) and note.strip():
+                return note
+        return None
+
+    except Exception:
+        _LOGGER.debug("fetch_release_notes_markdown failed for %s ref=%s", repo_url, target_ref, exc_info=True)
+        return None

custom_components/bahmcloud_store/storage.py

@@ -25,6 +25,8 @@ class InstalledRepo:
     url: str
     domains: list[str]
     installed_at: int
+    install_type: str = "integration"
+    installed_paths: list[str] | None = None
     installed_version: str | None = None  # BCS "installed ref" (tag/release/branch)
     installed_manifest_version: str | None = None  # informational only
     ref: str | None = None  # kept for backward compatibility / diagnostics
@@ -36,6 +38,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 +58,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)
 
@@ -110,6 +199,11 @@ class BCSStorage:
             if not isinstance(domains, list):
                 domains = []
             domains = [str(d) for d in domains if str(d).strip()]
+            installed_paths = entry.get("installed_paths") or []
+            if not isinstance(installed_paths, list):
+                installed_paths = []
+            installed_paths = [str(p) for p in installed_paths if str(p).strip()]
+            install_type = str(entry.get("install_type") or "integration").strip() or "integration"
 
             installed_version = entry.get("installed_version")
             ref = entry.get("ref")
@@ -126,6 +220,8 @@ class BCSStorage:
                 url=str(entry.get("url") or ""),
                 domains=domains,
                 installed_at=int(entry.get("installed_at") or 0),
+                install_type=install_type,
+                installed_paths=installed_paths,
                 installed_version=str(installed_version) if installed_version else None,
                 installed_manifest_version=str(installed_manifest_version) if installed_manifest_version else None,
                 ref=str(ref) if ref else None,
@@ -151,9 +247,11 @@ class BCSStorage:
         repo_id: str,
         url: str,
         domains: list[str],
-        installed_version: str | None,
+        installed_version: str | None = None,
         installed_manifest_version: str | None = None,
-        ref: str | None,
+        ref: str | None = None,
+        install_type: str = "integration",
+        installed_paths: list[str] | None = None,
     ) -> None:
         data = await self._load()
         installed = data.get("installed_repos", {})
@@ -165,6 +263,8 @@ class BCSStorage:
             "repo_id": str(repo_id),
             "url": str(url),
             "domains": [str(d) for d in (domains or []) if str(d).strip()],
+            "install_type": str(install_type or "integration"),
+            "installed_paths": [str(p) for p in (installed_paths or []) if str(p).strip()],
             "installed_at": int(time.time()),
             # IMPORTANT: this is what BCS uses as "installed version" (ref/tag/branch)
             "installed_version": installed_version,
@@ -181,4 +281,4 @@ class BCSStorage:
         if isinstance(installed, dict) and repo_id in installed:
             installed.pop(repo_id, None)
             data["installed_repos"] = installed
-            await self._save(data)
+            await self._save(data)

custom_components/bahmcloud_store/strings.json

@@ -1,4 +1,29 @@
 {
+  "config": {
+    "abort": {
+      "single_instance_allowed": "Only one Bahmcloud Store instance can be configured."
+    },
+    "step": {
+      "user": {
+        "title": "Bahmcloud Store",
+        "description": "Bahmcloud Store uses a fixed official store index. You can optionally add a GitHub token to increase API rate limits.",
+        "data": {
+          "github_token": "GitHub token (optional)"
+        }
+      }
+    }
+  },
+  "options": {
+    "step": {
+      "init": {
+        "title": "Bahmcloud Store Options",
+        "description": "Optionally set or clear your GitHub token to reduce rate limiting.",
+        "data": {
+          "github_token": "GitHub token (optional)"
+        }
+      }
+    }
+  },
   "issues": {
     "restart_required": {
       "title": "Restart required",
@@ -15,4 +40,4 @@
       }
     }
   }
-}
+}

custom_components/bahmcloud_store/update.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import inspect
 import logging
 from dataclasses import dataclass
 from typing import Any
@@ -9,12 +10,23 @@ from homeassistant.core import HomeAssistant, callback
 from homeassistant.helpers.dispatcher import async_dispatcher_connect
 from homeassistant.helpers.entity_platform import AddEntitiesCallback
 from homeassistant.helpers.entity import EntityCategory
+from homeassistant.helpers import entity_registry as er
 
-from .core import DOMAIN, SIGNAL_UPDATED, BCSCore
+from .const import DOMAIN
+from .core import SIGNAL_UPDATED, BCSCore
 
 _LOGGER = logging.getLogger(__name__)
 
 
+def _get_core(hass: HomeAssistant) -> BCSCore | None:
+    data = hass.data.get(DOMAIN)
+    if isinstance(data, dict):
+        c = data.get("_core")
+        return c if isinstance(c, BCSCore) else None
+    # Backwards compatibility (older versions used hass.data[DOMAIN] = core)
+    return data if isinstance(data, BCSCore) else None
+
+
 def _pretty_repo_name(core: BCSCore, repo_id: str) -> str:
     """Return a human-friendly name for a repo update entity."""
     try:
@@ -117,8 +129,36 @@ class BCSRepoUpdateEntity(UpdateEntity):
 def _sync_entities(core: BCSCore, existing: dict[str, BCSRepoUpdateEntity], async_add_entities: AddEntitiesCallback) -> None:
     """Ensure there is one update entity per installed repo AND keep names in sync."""
     installed_map = getattr(core, "_installed_cache", {}) or {}
+    installed_repo_ids = {repo_id for repo_id, data in installed_map.items() if isinstance(data, dict)}
     new_entities: list[BCSRepoUpdateEntity] = []
 
+    stale_repo_ids = [repo_id for repo_id in list(existing) if repo_id not in installed_repo_ids]
+    if stale_repo_ids:
+        registry = er.async_get(core.hass)
+        for repo_id in stale_repo_ids:
+            ent = existing.pop(repo_id, None)
+            if not ent:
+                continue
+
+            try:
+                entity_id = getattr(ent, "entity_id", None)
+                if not entity_id:
+                    for entry in registry.entities.values():
+                        if getattr(entry, "platform", None) == DOMAIN and getattr(entry, "unique_id", None) == ent.unique_id:
+                            entity_id = entry.entity_id
+                            break
+                if entity_id:
+                    registry.async_remove(entity_id)
+            except Exception as exc:  # pylint: disable=broad-exception-caught
+                _LOGGER.debug("BCS could not remove stale update entity for %s: %s", repo_id, exc)
+
+            try:
+                result = ent.async_remove()
+                if inspect.isawaitable(result):
+                    core.hass.async_create_task(result)
+            except Exception as exc:  # pylint: disable=broad-exception-caught
+                _LOGGER.debug("BCS could not detach stale update entity for %s: %s", repo_id, exc)
+
     for repo_id, data in installed_map.items():
         if not isinstance(data, dict):
             continue
@@ -146,7 +186,7 @@ async def async_setup_platform(
     discovery_info=None,
 ):
     """Set up BCS update entities."""
-    core: BCSCore | None = hass.data.get(DOMAIN)
+    core: BCSCore | None = _get_core(hass)
     if not core:
         _LOGGER.debug("BCS core not available, skipping update platform setup")
         return
@@ -159,4 +199,13 @@ async def async_setup_platform(
     def _handle_update() -> None:
         _sync_entities(core, entities, async_add_entities)
 
-    async_dispatcher_connect(hass, SIGNAL_UPDATED, _handle_update)
+    async_dispatcher_connect(hass, SIGNAL_UPDATED, _handle_update)
+
+
+async def async_setup_entry(
+    hass: HomeAssistant,
+    entry,
+    async_add_entities: AddEntitiesCallback,
+) -> None:
+    """Set up BCS update entities from a config entry."""
+    await async_setup_platform(hass, {}, async_add_entities, None)

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,40 @@ 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"))
+        if "favorite_repo_ids" in data:
+            raw = data.get("favorite_repo_ids") or []
+            updates["favorite_repo_ids"] = raw if isinstance(raw, list) else []
+
+        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 +331,62 @@ 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 BCSReleaseNotesView(HomeAssistantView):
+    url = "/api/bcs/release_notes"
+    name = "api:bcs_release_notes"
+    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)
+
+        ref = request.query.get("ref")
+        ref = str(ref).strip() if ref is not None else None
+
+        try:
+            notes = await self.core.fetch_release_notes_markdown(repo_id, ref=ref)
+            if not notes or not str(notes).strip():
+                return web.json_response(
+                    {"ok": False, "message": "Release notes not found for this version."},
+                    status=404,
+                )
+
+            notes_str = str(notes)
+            html = _render_markdown_server_side(notes_str)
+            return web.json_response(
+                {"ok": True, "ref": ref, "release_notes": notes_str, "html": html},
+                status=200,
+            )
+        except Exception as e:
+            _LOGGER.exception("BCS release notes failed: %s", e)
+            return web.json_response({"ok": False, "message": str(e) or "Release notes failed"}, status=500)
+
+
 class BCSInstallView(HomeAssistantView):
     url = "/api/bcs/install"
     name = "api:bcs_install"
@@ -302,11 +397,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 +420,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 +515,64 @@ 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 = []
+            installed_paths = inst.get("installed_paths") or []
+            if not isinstance(installed_paths, list):
+                installed_paths = []
+
+            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,
+                    "category_key": self.core._repo_install_type(repo),
+                    "install_target": self.core._repo_install_target(repo),
+                    "meta_author": repo.meta_author,
+                    "meta_maintainer": repo.meta_maintainer,
+                    "meta_source": repo.meta_source,
+                    "installed": installed,
+                    "install_type": inst.get("install_type") or self.core._repo_install_type(repo),
+                    "installed_version": inst.get("installed_version"),
+                    "installed_manifest_version": inst.get("installed_manifest_version"),
+                    "installed_domains": domains,
+                    "installed_paths": installed_paths,
+                    "favorite": self.core.is_favorite_repo(repo.id),
+                }
+            }, 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)