add 0.5.9

revert custom_components/bahmcloud_store/core.py aktualisiert

CHANGELOG.md

@@ -0,0 +1,218 @@
+# Changelog
+
+All notable changes to this repository will be documented in this file.
+
+Sections:
+- Added
+- Changed
+- Fixed
+- Removed
+- Security
+
+---
+
+## [0.5.9] - 2026-01-17
+
+### Changed
+- README is now collapsible with a preview by default (Show more / Show less).
+- Improved mobile readability by keeping long README content contained without affecting the page layout.
+
+## [0.5.8] - 2026-01-17
+
+### Changed
+- Mobile UI layout stabilized to prevent horizontal shifting.
+- README rendering no longer expands the page width on mobile devices.
+- Tables and code blocks inside README now scroll within their container.
+- Floating action buttons removed to avoid UI overlap on small screens.
+- Header icon buttons improved for better visibility in light and dark mode.
+
+## [0.5.7] - 2026-01-17
+
+### Changed
+- Mobile UI improvements: removed floating action buttons to prevent overlay issues.
+- Improved responsive layout to avoid horizontal overflow (badges, URLs, descriptions).
+- README rendering on mobile is more stable (better wrapping and image scaling).
+- Header icon buttons are more readable in both light and dark mode.
+
+## [0.5.6] - 2026-01-17
+
+### Added
+- Repository uninstall support directly from the Store UI.
+- New backend API endpoint: `POST /api/bcs/uninstall`.
+- Automatic **reconcile**: repositories are marked as not installed when their `custom_components` directories are removed manually.
+
+### Changed
+- Installation & Updates section extended with an Uninstall button.
+- Store state now remains consistent even after manual file system changes.
+
+### Fixed
+- Repositories remained marked as installed after manual deletion of their domains.
+- UI cache issues caused by outdated static assets.
+
+## [0.5.5] - 2026-01-16
+
+### Fixed
+- Update entities now refresh their displayed name after store refreshes, so repository names replace fallback IDs (e.g. `index:1`) reliably.
+
+## [0.5.4] - 2026-01-16
+
+### Added
+- Native **Repair fix flow** for restart-required situations.
+- “Restart required” issues are now **fixable** and provide a confirmation dialog with a real restart action.
+
+### Changed
+- Restart-required issues are automatically cleared after Home Assistant restarts.
+- Update entities now fully align with official Home Assistant behavior (Updates screen + Repairs integration).
+
+### Fixed
+- Fixed integration startup issues caused by incorrect file placement.
+- Resolved circular import and missing setup errors during Home Assistant startup.
+- Ensured YAML-based setup remains fully supported.
+
+## [0.5.3] - 2026-01-16
+
+### Added
+- Native Home Assistant Update entities for installed repositories (shown under **Settings → System → Updates**).
+- Human-friendly update names based on repository name (instead of internal repo IDs like `index:1`).
+
+### Changed
+- Update UI now behaves like official Home Assistant integrations (update action is triggered via the HA Updates screen).
+
+## [0.5.2] - 2026-01-16
+
+### Added
+- Install and update backend endpoints (`POST /api/bcs/install`, `POST /api/bcs/update`) to install repositories into `/config/custom_components`.
+- Installed version tracking based on the actually installed ref (tag/release/branch), stored persistently to support repositories with outdated/`0.0.0` manifest versions.
+- API fields `installed_version` (installed ref) and `installed_manifest_version` (informational) to improve transparency in the UI.
+
+### Changed
+- Update availability is now evaluated using the stored installed ref (instead of `manifest.json` version), preventing false-positive updates when repositories do not maintain manifest versions.
+
+### Fixed
+- Repositories with `manifest.json` version `0.0.0` (or stale versions) no longer appear as constantly requiring updates after installing the latest release/tag.
+
+## [0.5.0] - 2026-01-15
+
+### Added
+- Manual refresh button that triggers a full backend refresh (store index + provider data).
+- Unified refresh pipeline: startup, timer and UI now use the same refresh logic.
+- Cache-busting for store index requests to always fetch the latest store.yaml.
+
+### Improved
+- Logging for store index loading and parsing.
+- Refresh behavior now deterministic and verifiable via logs.
+
+### Fixed
+- Refresh button previously only reloaded cached data.
+- Store index was not always reloaded immediately on user action.
+
+## [0.4.1] - 2026-01-15
+### Fixed
+- Fixed GitLab README loading by using robust raw file endpoints.
+- Added support for nested GitLab groups when resolving README paths.
+- Added fallback handling for multiple README filenames (`README.md`, `README`, `README.rst`, etc.).
+- Added branch fallback logic for README loading (`default`, `main`, `master`).
+- Improved error resilience so README loading failures never break the store core.
+- No behavior change for GitHub and Gitea providers.
+
+## [0.4.0] - 2026-01-15
+
+### Added
+- Initial public release of the Bahmcloud Store integration.
+- Sidebar panel with repository browser UI.
+- Support for loading repositories from a central `store.yaml` index.
+- Support for custom repositories added by the user.
+- Provider abstraction for GitHub, GitLab and Gitea:
+  - Fetch repository information (name, description, default branch).
+  - Resolve latest version from:
+    - Releases
+    - Tags
+    - Fallback mechanisms.
+- Repository metadata support via:
+  - `bcs.yaml`
+  - `hacs.yaml`
+  - `hacs.json`
+- README loading and rendering pipeline:
+  - Fetch raw README files.
+  - Server-side Markdown rendering.
+  - Sanitized HTML output for the panel UI.
+- Auto refresh mechanism for store index and repository metadata.
+- API endpoints:
+  - List repositories
+  - Add custom repository
+  - Remove repository  
+  Persisted via Home Assistant storage (`.storage/bcs_store`).
+- Public static asset endpoint for panel JS (`/api/bahmcloud_store_static/...`) without auth (required for HA custom panels).
+- Initial API namespace:
+  - `GET /api/bcs` list merged repositories (index + custom)
+  - `POST /api/bcs` add custom repository
+  - `DELETE /api/bcs/custom_repo` remove custom repository
+
+### Changed
+- Repository cards are now clickable to open the detail view.
+
+## [0.3.2] - 2026-01-15
+
+### Added
+- Metadata resolver:
+  - Reads `bcs.yaml` (preferred), then `hacs.yaml`, then `hacs.json` from repository root.
+  - Extracts `name`, `description`, `category`, `author`, `maintainer` (best-effort).
+- UI now prefers metadata description over provider description.
+- Provider repository name is now only used as a fallback if no metadata name is provided.
+
+### Changed
+- Repo display name priority:
+  1) metadata (`bcs.yaml` / `hacs.*`)
+  2) store index name (store.yaml)
+  3) provider repo name
+  4) repository URL
+
+## [0.3.1] - 2026-01-15
+
+### Fixed
+- Panel header version is now derived from `manifest.json` via backend API (no more hardcoded version strings).
+- Mobile navigation/header visibility improved by explicitly disabling iframe embedding for the custom panel.
+- When adding a custom repository without a display name, the name is now fetched from the git provider (GitHub/Gitea) and shown automatically.
+
+## [0.3.0] - 2026-01-15
+
+### Added
+- Repository enrichment for the Store UI:
+  - GitHub: fetch owner and description via GitHub REST API.
+  - Gitea: fetch owner and description via Gitea REST API (`/api/v1`).
+- Provider detection for GitHub/GitLab/Gitea (best-effort).
+- Automatic UI description line populated from provider data (when available).
+
+### Changed
+- Panel module URL cache-busting updated to avoid stale frontend assets.
+
+### Fixed
+- Store "Refresh" now triggers immediate backend refresh (from 0.2.0).
+- Avoided circular imports by using TYPE_CHECKING for type references.
+
+### Notes
+- Installation/README details view/update entities will be added in later versions.
+
+
+## [0.2.0] - 2026-01-15
+
+### Added
+- Foundation architecture for BCS (Bahmcloud Component Store) inside a Home Assistant custom component.
+- Custom panel (no iframe) using `hass.callApi()` to avoid authentication issues.
+- Store index loader (`store.yaml`) with periodic refresh (data only).
+- Manual repository management:
+  - Add repository
+  - List repositories
+  - Remove repository
+  Persisted via Home Assistant storage (`.storage/bcs_store`).
+- Public static asset endpoint for panel JS (`/api/bahmcloud_store_static/...`) without auth (required for HA custom panels).
+- Initial API namespace:
+  - `GET /api/bcs` list merged repositories (index + custom)
+  - `POST /api/bcs` add custom repository
+  - `DELETE /api/bcs/custom_repo` remove custom repository
+
+### Changed
+- Store API/UI terminology standardized to "BCS" (Bahmcloud Component Store), while integration domain remains `bahmcloud_store` for compatibility.
+
+### Notes
+- Installation, README rendering, provider enrichment (GitHub/Gitea/GitLab), and Update entities will be implemented in later versions.

README.md

@@ -1,3 +1,3 @@
 # bahmcloud_store
 
-Bahmcloud Store für installing costum_components to Homeassistant
+Bahmcloud Store for installing costum_components to Homeassistant

bcs.yaml

@@ -0,0 +1,19 @@
+name: Bahmcloud Store
+description: >
+  Provider-neutral custom integration store for Home Assistant.
+  Supports GitHub, GitLab, Gitea and Bahmcloud repositories with
+  a central index, UI panel and API, similar to HACS but independent.
+
+category: integration
+
+author: Bahmcloud
+maintainer: Bahmcloud
+
+domains:
+  - bahmcloud_store
+
+min_ha_version: "2024.1.0"
+
+homepage: https://git.bahmcloud.de/bahmcloud/bahmcloud_store
+issues: https://git.bahmcloud.de/bahmcloud/bahmcloud_store/issues
+source: https://git.bahmcloud.de/bahmcloud/bahmcloud_store

custom_components/bahmcloud_store/__init__.py

@@ -4,12 +4,11 @@ import logging
 from datetime import timedelta
 
 from homeassistant.core import HomeAssistant
-from homeassistant.const import Platform
+from homeassistant.components.panel_custom import async_register_panel
 from homeassistant.helpers.event import async_track_time_interval
 from homeassistant.helpers.discovery import async_load_platform
-from homeassistant.components.panel_custom import async_register_panel
 
-from .store import BahmcloudStore, StoreConfig, StoreError
+from .core import BCSCore, BCSConfig, BCSError
 
 _LOGGER = logging.getLogger(__name__)
 
@@ -20,46 +19,64 @@ CONF_STORE_URL = "store_url"
 
 
 async def async_setup(hass: HomeAssistant, config: dict) -> bool:
-    cfg = config.get(DOMAIN, {})
+    cfg = config.get(DOMAIN, {}) or {}
     store_url = cfg.get(CONF_STORE_URL, DEFAULT_STORE_URL)
 
-    store = BahmcloudStore(hass, StoreConfig(store_url=store_url))
-    hass.data[DOMAIN] = store
+    core = BCSCore(hass, BCSConfig(store_url=store_url))
+    hass.data[DOMAIN] = core
 
-    # HTTP Views (Panel static + JSON API)
-    await store.register_http_views()
+    await core.async_initialize()
+
+    # Provide native Update entities in Settings -> System -> Updates.
+    # 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,
+        BCSReadmeView,
+        BCSCustomRepoView,
+        BCSInstallView,
+        BCSUpdateView,
+        BCSUninstallView,
+        BCSRestartView,
+    )
+
+    hass.http.register_view(StaticAssetsView())
+    hass.http.register_view(BCSApiView(core))
+    hass.http.register_view(BCSReadmeView(core))
+    hass.http.register_view(BCSCustomRepoView(core))
+    hass.http.register_view(BCSInstallView(core))
+    hass.http.register_view(BCSUpdateView(core))
+    hass.http.register_view(BCSUninstallView(core))
+    hass.http.register_view(BCSRestartView(core))
 
-    # Sidebar Panel (Custom Panel + JS module)
     await async_register_panel(
         hass,
         frontend_url_path="bahmcloud-store",
         webcomponent_name="bahmcloud-store-panel",
-        module_url="/api/bahmcloud_store_static/panel.js",
+        # IMPORTANT: bump v to avoid caching old JS
+        module_url="/api/bahmcloud_store_static/panel.js?v=102",
         sidebar_title="Bahmcloud Store",
         sidebar_icon="mdi:store",
         require_admin=True,
         config={},
     )
 
-    # Initialer Index-Load
     try:
-        await store.refresh()
-    except StoreError as e:
-        _LOGGER.error("Initial store refresh failed: %s", e)
+        await core.full_refresh(source="startup")
+    except BCSError as e:
+        _LOGGER.error("Initial refresh failed: %s", e)
 
-    # Nur Liste + Latest-Versionen regelmäßig aktualisieren (keine Auto-Install)
     async def periodic(_now) -> None:
         try:
-            await store.refresh()
-            store.signal_entities_updated()
-        except StoreError as e:
+            await core.full_refresh(source="timer")
+        except BCSError as e:
             _LOGGER.warning("Periodic refresh failed: %s", e)
+        except Exception as e:  # pylint: disable=broad-exception-caught
+            _LOGGER.exception("Unexpected error during periodic refresh: %s", e)
 
-    # Falls store.yaml refresh_seconds enthält, nutze das, sonst 300s
-    interval_seconds = store.refresh_seconds if getattr(store, "refresh_seconds", None) else 300
-    async_track_time_interval(hass, periodic, timedelta(seconds=int(interval_seconds)))
-
-    # Update platform laden (damit Updates in Settings erscheinen)
-    await async_load_platform(hass, Platform.UPDATE, DOMAIN, {}, config)
+    interval_seconds = int(getattr(core, "refresh_seconds", 300) or 300)
+    async_track_time_interval(hass, periodic, timedelta(seconds=interval_seconds))
 
     return True

custom_components/bahmcloud_store/core.py

@@ -0,0 +1,681 @@
+from __future__ import annotations
+
+import asyncio
+import hashlib
+import json
+import logging
+import time
+import shutil
+import tempfile
+import zipfile
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+from urllib.parse import parse_qsl, urlencode, urlsplit, urlunsplit, urlparse
+
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.helpers.dispatcher import async_dispatcher_send
+from homeassistant.helpers import issue_registry as ir
+from homeassistant.util import yaml as ha_yaml
+
+from .storage import BCSStorage, CustomRepo
+from .providers import fetch_repo_info, detect_provider, RepoInfo, fetch_readme_markdown
+from .metadata import fetch_repo_metadata, RepoMetadata
+
+_LOGGER = logging.getLogger(__name__)
+
+DOMAIN = "bahmcloud_store"
+
+SIGNAL_UPDATED = f"{DOMAIN}_updated"
+RESTART_REQUIRED_ISSUE_ID = "restart_required"
+
+
+class BCSError(Exception):
+    """BCS core error."""
+
+
+class BCSInstallError(BCSError):
+    """BCS installation/update error."""
+
+
+@dataclass
+class BCSConfig:
+    store_url: str
+
+
+@dataclass
+class RepoItem:
+    id: str
+    name: str
+    url: str
+    source: str  # "index" | "custom"
+
+    owner: str | None = None
+    provider: str | None = None
+    provider_repo_name: str | None = None
+    provider_description: str | None = None
+    default_branch: str | None = None
+
+    latest_version: str | None = None
+    latest_version_source: str | None = None  # "release" | "tag" | "atom" | None
+
+    meta_source: str | None = None
+    meta_name: str | None = None
+    meta_description: str | None = None
+    meta_category: str | None = None
+    meta_author: str | None = None
+    meta_maintainer: str | None = None
+
+
+class BCSCore:
+    def __init__(self, hass: HomeAssistant, config: BCSConfig) -> None:
+        self.hass = hass
+        self.config = config
+        self.storage = BCSStorage(hass)
+
+        self.refresh_seconds: int = 300
+        self.repos: dict[str, RepoItem] = {}
+        self._listeners: list[callable] = []
+
+        # Will be loaded asynchronously (no blocking IO in event loop)
+        self.version: str = "unknown"
+
+        # Diagnostics (helps verify refresh behavior)
+        self.last_index_url: str | None = None
+        self.last_index_bytes: int | None = None
+        self.last_index_hash: str | None = None
+        self.last_index_loaded_at: float | None = None
+
+        self._install_lock = asyncio.Lock()
+        self._installed_cache: dict[str, Any] = {}
+
+    async def async_initialize(self) -> None:
+        """Async initialization that avoids blocking file IO."""
+        self.version = await self._read_manifest_version_async()
+        await self._refresh_installed_cache()
+
+        # After a successful HA restart, restart-required is no longer relevant.
+        self._clear_restart_required_issue()
+
+    async def _read_manifest_version_async(self) -> str:
+        def _read() -> str:
+            try:
+                manifest_path = Path(__file__).resolve().parent / "manifest.json"
+                data = json.loads(manifest_path.read_text(encoding="utf-8"))
+                v = data.get("version")
+                return str(v) if v else "unknown"
+            except Exception:
+                return "unknown"
+
+        return await self.hass.async_add_executor_job(_read)
+
+    def add_listener(self, cb) -> None:
+        self._listeners.append(cb)
+
+    def signal_updated(self) -> None:
+        # Notify entities/platforms (e.g. update entities) that BCS data changed.
+        async_dispatcher_send(self.hass, SIGNAL_UPDATED)
+        for cb in list(self._listeners):
+            try:
+                cb()
+            except Exception:
+                pass
+
+    def _mark_restart_required(self) -> None:
+        """Show a 'restart required' issue in Home Assistant Settings.
+
+        IMPORTANT:
+        - is_fixable=True enables the "Fix/OK" button
+        - the real action is implemented in repairs.py (fix flow)
+        """
+        try:
+            ir.async_create_issue(
+                self.hass,
+                DOMAIN,
+                RESTART_REQUIRED_ISSUE_ID,
+                is_fixable=True,     # <-- IMPORTANT: show "Fix" button
+                is_persistent=False,
+                severity=ir.IssueSeverity.WARNING,
+                translation_key=RESTART_REQUIRED_ISSUE_ID,
+            )
+        except Exception:
+            _LOGGER.debug("Failed to create restart required issue", exc_info=True)
+
+    def _clear_restart_required_issue(self) -> None:
+        """Remove restart required issue after HA restarted."""
+        try:
+            if hasattr(ir, "async_delete_issue"):
+                ir.async_delete_issue(self.hass, DOMAIN, RESTART_REQUIRED_ISSUE_ID)
+            elif hasattr(ir, "async_remove_issue"):
+                ir.async_remove_issue(self.hass, DOMAIN, RESTART_REQUIRED_ISSUE_ID)
+        except Exception:
+            _LOGGER.debug("Failed to clear restart required issue", exc_info=True)
+
+    async def full_refresh(self, source: str = "manual") -> None:
+        """Single refresh entry-point used by both timer and manual button."""
+        _LOGGER.info("BCS full refresh triggered (source=%s)", source)
+        await self.refresh()
+        self.signal_updated()
+
+    def get_repo(self, repo_id: str) -> RepoItem | None:
+        return self.repos.get(repo_id)
+
+    def get_installed(self, repo_id: str) -> dict[str, Any] | None:
+        """Return cached installation info for a repo_id (no I/O)."""
+        data = (self._installed_cache or {}).get(repo_id)
+        return data if isinstance(data, dict) else None
+
+    async def refresh(self) -> None:
+        index_repos, refresh_seconds = await self._load_index_repos()
+        self.refresh_seconds = refresh_seconds
+
+        custom_repos = await self.storage.list_custom_repos()
+
+        merged: dict[str, RepoItem] = {}
+
+        for item in index_repos:
+            merged[item.id] = item
+
+        for c in custom_repos:
+            merged[c.id] = RepoItem(
+                id=c.id,
+                name=(c.name or c.url),
+                url=c.url,
+                source="custom",
+            )
+
+        for r in merged.values():
+            r.provider = detect_provider(r.url)
+
+        await self._enrich_and_resolve(merged)
+        self.repos = merged
+
+        _LOGGER.info(
+            "BCS refresh complete: repos=%s (index=%s, custom=%s)",
+            len(self.repos),
+            len([r for r in self.repos.values() if r.source == "index"]),
+            len([r for r in self.repos.values() if r.source == "custom"]),
+        )
+
+    async def _enrich_and_resolve(self, merged: dict[str, RepoItem]) -> None:
+        sem = asyncio.Semaphore(6)
+
+        async def process_one(r: RepoItem) -> None:
+            async with sem:
+                info: RepoInfo = await fetch_repo_info(self.hass, r.url)
+
+                r.provider = info.provider or r.provider
+                r.owner = info.owner or r.owner
+                r.provider_repo_name = info.repo_name
+                r.provider_description = info.description
+                r.default_branch = info.default_branch or r.default_branch
+
+                r.latest_version = info.latest_version
+                r.latest_version_source = info.latest_version_source
+
+                md: RepoMetadata = await fetch_repo_metadata(self.hass, r.url, r.default_branch)
+                r.meta_source = md.source
+                r.meta_name = md.name
+                r.meta_description = md.description
+                r.meta_category = md.category
+                r.meta_author = md.author
+                r.meta_maintainer = md.maintainer
+
+                has_user_or_index_name = bool(r.name) and (r.name != r.url) and (not str(r.name).startswith("http"))
+                if r.meta_name:
+                    r.name = r.meta_name
+                elif not has_user_or_index_name and r.provider_repo_name:
+                    r.name = r.provider_repo_name
+                elif not r.name:
+                    r.name = r.url
+
+        await asyncio.gather(*(process_one(r) for r in merged.values()), return_exceptions=True)
+
+    def _add_cache_buster(self, url: str) -> str:
+        parts = urlsplit(url)
+        q = dict(parse_qsl(parts.query, keep_blank_values=True))
+        q["t"] = str(int(time.time()))
+        new_query = urlencode(q)
+        return urlunsplit((parts.scheme, parts.netloc, parts.path, new_query, parts.fragment))
+
+    def _gitea_src_to_raw(self, url: str) -> str:
+        parts = urlsplit(url)
+        path = parts.path
+        path2 = path.replace("/src/branch/", "/raw/branch/")
+        if path2 == path:
+            return url
+        return urlunsplit((parts.scheme, parts.netloc, path2, parts.query, parts.fragment))
+
+    async def _fetch_store_text(self, url: str) -> str:
+        session = async_get_clientsession(self.hass)
+
+        headers = {
+            "User-Agent": "BahmcloudStore (Home Assistant)",
+            "Cache-Control": "no-cache, no-store, max-age=0",
+            "Pragma": "no-cache",
+            "Expires": "0",
+        }
+
+        async with session.get(url, timeout=30, headers=headers) as resp:
+            if resp.status != 200:
+                raise BCSError(f"store_url returned {resp.status}")
+            return await resp.text()
+
+    async def _load_index_repos(self) -> tuple[list[RepoItem], int]:
+        store_url = (self.config.store_url or "").strip()
+        if not store_url:
+            raise BCSError("store_url is empty")
+
+        url = self._add_cache_buster(store_url)
+
+        try:
+            raw = await self._fetch_store_text(url)
+
+            # If we fetched a HTML page (wrong endpoint), attempt raw conversion.
+            if "<html" in raw.lower() or "<!doctype html" in raw.lower():
+                fallback = self._add_cache_buster(self._gitea_src_to_raw(store_url))
+                if fallback != url:
+                    _LOGGER.warning("BCS store index looked like HTML, retrying raw URL")
+                    raw = await self._fetch_store_text(fallback)
+                    url = fallback
+
+        except Exception as e:
+            raise BCSError(f"Failed fetching store index: {e}") from e
+
+        # Diagnostics
+        b = raw.encode("utf-8", errors="replace")
+        h = hashlib.sha256(b).hexdigest()[:12]
+        self.last_index_url = url
+        self.last_index_bytes = len(b)
+        self.last_index_hash = h
+        self.last_index_loaded_at = time.time()
+
+        _LOGGER.info(
+            "BCS index loaded: url=%s bytes=%s sha=%s",
+            self.last_index_url,
+            self.last_index_bytes,
+            self.last_index_hash,
+        )
+
+        try:
+            data = ha_yaml.parse_yaml(raw)
+            if not isinstance(data, dict):
+                raise BCSError("store.yaml must be a mapping")
+
+            refresh_seconds = int(data.get("refresh_seconds", 300))
+            repos = data.get("repos", [])
+            if not isinstance(repos, list):
+                raise BCSError("store.yaml 'repos' must be a list")
+
+            items: list[RepoItem] = []
+            for i, r in enumerate(repos):
+                if not isinstance(r, dict):
+                    continue
+                repo_url = str(r.get("url", "")).strip()
+                if not repo_url:
+                    continue
+                name = str(r.get("name") or repo_url).strip()
+
+                items.append(
+                    RepoItem(
+                        id=f"index:{i}",
+                        name=name,
+                        url=repo_url,
+                        source="index",
+                    )
+                )
+
+            _LOGGER.info("BCS index parsed: repos=%s refresh_seconds=%s", len(items), refresh_seconds)
+            return items, refresh_seconds
+        except Exception as e:
+            raise BCSError(f"Invalid store.yaml: {e}") from e
+
+    async def add_custom_repo(self, url: str, name: str | None) -> CustomRepo:
+        url = str(url or "").strip()
+        if not url:
+            raise BCSError("Missing url")
+
+        c = await self.storage.add_custom_repo(url, name)
+        await self.full_refresh(source="custom_repo_add")
+        return c
+
+    async def remove_custom_repo(self, repo_id: str) -> None:
+        await self.storage.remove_custom_repo(repo_id)
+        await self.full_refresh(source="custom_repo_remove")
+
+    async def list_custom_repos(self) -> list[CustomRepo]:
+        return await self.storage.list_custom_repos()
+
+    def list_repos_public(self) -> list[dict[str, Any]]:
+        out: list[dict[str, Any]] = []
+
+        installed_map: dict[str, Any] = getattr(self, "_installed_cache", {}) or {}
+        if not isinstance(installed_map, dict):
+            installed_map = {}
+
+        for r in self.repos.values():
+            inst = installed_map.get(r.id)
+            installed = bool(inst)
+            installed_domains: list[str] = []
+            installed_version: str | None = None
+            installed_manifest_version: str | None = None
+
+            if isinstance(inst, dict):
+                d = inst.get("domains") or []
+                if isinstance(d, list):
+                    installed_domains = [str(x) for x in d if str(x).strip()]
+
+                v = inst.get("installed_version")
+                installed_version = str(v) if v is not None else None
+
+                mv = inst.get("installed_manifest_version")
+                installed_manifest_version = str(mv) if mv is not None else None
+
+            out.append(
+                {
+                    "id": r.id,
+                    "name": r.name,
+                    "url": r.url,
+                    "source": r.source,
+                    "owner": r.owner,
+                    "provider": r.provider,
+                    "repo_name": r.provider_repo_name,
+                    "description": r.provider_description or r.meta_description,
+                    "default_branch": r.default_branch,
+                    "latest_version": r.latest_version,
+                    "latest_version_source": r.latest_version_source,
+                    "category": r.meta_category,
+                    "meta_author": r.meta_author,
+                    "meta_maintainer": r.meta_maintainer,
+                    "meta_source": r.meta_source,
+                    "installed": installed,
+                    "installed_version": installed_version,
+                    "installed_manifest_version": installed_manifest_version,
+                    "installed_domains": installed_domains,
+                }
+            )
+        return out
+
+    async def fetch_readme_markdown(self, repo_id: str) -> str | None:
+        repo = self.get_repo(repo_id)
+        if not repo:
+            return None
+
+        return await fetch_readme_markdown(
+            self.hass,
+            repo.url,
+            provider=repo.provider,
+            default_branch=repo.default_branch,
+        )
+
+    def _pick_ref_for_install(self, repo: RepoItem) -> str:
+        if repo.latest_version and str(repo.latest_version).strip():
+            return str(repo.latest_version).strip()
+        if repo.default_branch and str(repo.default_branch).strip():
+            return str(repo.default_branch).strip()
+        return "main"
+
+    def _build_zip_url(self, repo_url: str, ref: str) -> str:
+        ref = (ref or "").strip()
+        if not ref:
+            raise BCSInstallError("Missing ref for ZIP download")
+
+        u = urlparse(repo_url.rstrip("/"))
+        host = (u.netloc or "").lower()
+        parts = [p for p in u.path.strip("/").split("/") if p]
+        if len(parts) < 2:
+            raise BCSInstallError("Invalid repository URL (missing owner/repo)")
+
+        owner = parts[0]
+        repo = parts[1]
+        if repo.endswith(".git"):
+            repo = repo[:-4]
+
+        if "github.com" in host:
+            return f"https://codeload.github.com/{owner}/{repo}/zip/{ref}"
+
+        if "gitlab" in host:
+            base = f"{u.scheme}://{u.netloc}"
+            path = u.path.strip("/")
+            if path.endswith(".git"):
+                path = path[:-4]
+            return f"{base}/{path}/-/archive/{ref}/{repo}-{ref}.zip"
+
+        base = f"{u.scheme}://{u.netloc}"
+        path = u.path.strip("/")
+        if path.endswith(".git"):
+            path = path[:-4]
+        return f"{base}/{path}/archive/{ref}.zip"
+
+    async def _download_zip(self, url: str, dest: Path) -> None:
+        session = async_get_clientsession(self.hass)
+        headers = {
+            "User-Agent": "BahmcloudStore (Home Assistant)",
+            "Cache-Control": "no-cache, no-store, max-age=0",
+            "Pragma": "no-cache",
+        }
+
+        async with session.get(url, timeout=120, headers=headers) as resp:
+            if resp.status != 200:
+                raise BCSInstallError(f"zip_url returned {resp.status}")
+            data = await resp.read()
+
+        await self.hass.async_add_executor_job(dest.write_bytes, data)
+
+    async def _extract_zip(self, zip_path: Path, extract_dir: Path) -> None:
+        def _extract() -> None:
+            with zipfile.ZipFile(zip_path, "r") as zf:
+                zf.extractall(extract_dir)
+
+        await self.hass.async_add_executor_job(_extract)
+
+    @staticmethod
+    def _find_custom_components_root(extract_root: Path) -> Path | None:
+        direct = extract_root / "custom_components"
+        if direct.exists() and direct.is_dir():
+            return direct
+
+        for child in extract_root.iterdir():
+            candidate = child / "custom_components"
+            if candidate.exists() and candidate.is_dir():
+                return candidate
+        return None
+
+    async def _copy_domain_dir(self, src_domain_dir: Path, domain: str) -> None:
+        dest_root = Path(self.hass.config.path("custom_components"))
+        target = dest_root / domain
+        tmp_target = dest_root / f".bcs_tmp_{domain}_{int(time.time())}"
+
+        def _copy() -> None:
+            if tmp_target.exists():
+                shutil.rmtree(tmp_target, ignore_errors=True)
+
+            shutil.copytree(src_domain_dir, tmp_target, dirs_exist_ok=True)
+
+            if target.exists():
+                shutil.rmtree(target, ignore_errors=True)
+
+            tmp_target.rename(target)
+
+        await self.hass.async_add_executor_job(_copy)
+
+    async def _read_installed_manifest_version(self, domain: str) -> str | None:
+        def _read() -> str | None:
+            try:
+                p = Path(self.hass.config.path("custom_components", domain, "manifest.json"))
+                if not p.exists():
+                    return None
+                data = json.loads(p.read_text(encoding="utf-8"))
+                v = data.get("version")
+                return str(v) if v else None
+            except Exception:
+                return None
+
+        return await self.hass.async_add_executor_job(_read)
+
+    async def _refresh_installed_cache(self) -> None:
+        """Refresh installed cache and reconcile with filesystem.
+
+        If a user manually deletes a domain folder under /config/custom_components,
+        we automatically remove the installed flag from our storage so the Store UI
+        does not show stale "installed" state.
+        """
+        try:
+            items = await self.storage.list_installed_repos()
+            cache: dict[str, Any] = {}
+
+            # Determine which installed repos still exist on disk.
+            cc_root = Path(self.hass.config.path("custom_components"))
+            to_remove: list[str] = []
+
+            for it in items:
+                domains = [str(d) for d in (it.domains or []) if str(d).strip()]
+
+                # A repo is considered "present" if at least one of its domains
+                # exists and contains a manifest.json.
+                present = False
+                for d in domains:
+                    p = cc_root / d
+                    if p.is_dir() and (p / "manifest.json").exists():
+                        present = True
+                        break
+
+                if not present:
+                    to_remove.append(it.repo_id)
+                    continue
+
+                cache[it.repo_id] = {
+                    "installed": True,
+                    "domains": domains,
+                    "installed_version": it.installed_version,
+                    "installed_manifest_version": it.installed_manifest_version,
+                    "ref": it.ref,
+                    "installed_at": it.installed_at,
+                }
+
+            # Remove stale installed entries from storage.
+            for rid in to_remove:
+                try:
+                    await self.storage.remove_installed_repo(rid)
+                    _LOGGER.info("BCS reconcile: removed stale installed repo_id=%s", rid)
+                except Exception:
+                    _LOGGER.debug("BCS reconcile: failed removing stale repo_id=%s", rid, exc_info=True)
+
+            self._installed_cache = cache
+        except Exception:
+            self._installed_cache = {}
+
+    async def uninstall_repo(self, repo_id: str) -> dict[str, Any]:
+        """Uninstall a repository by deleting its installed domains and clearing storage."""
+        async with self._install_lock:
+            inst = await self.storage.get_installed_repo(repo_id)
+            if not inst:
+                # Already uninstalled.
+                await self._refresh_installed_cache()
+                self.signal_updated()
+                return {"ok": True, "repo_id": repo_id, "removed": [], "restart_required": False}
+
+            cc_root = Path(self.hass.config.path("custom_components"))
+            removed: list[str] = []
+
+            def _remove_dir(path: Path) -> None:
+                if path.exists() and path.is_dir():
+                    shutil.rmtree(path, ignore_errors=True)
+
+            for domain in inst.domains:
+                d = str(domain).strip()
+                if not d:
+                    continue
+                target = cc_root / d
+                await self.hass.async_add_executor_job(_remove_dir, target)
+                removed.append(d)
+
+            await self.storage.remove_installed_repo(repo_id)
+            await self._refresh_installed_cache()
+
+            # Show restart required in Settings.
+            if removed:
+                self._mark_restart_required()
+
+            _LOGGER.info("BCS uninstall complete: repo_id=%s removed_domains=%s", repo_id, removed)
+            self.signal_updated()
+            return {"ok": True, "repo_id": repo_id, "removed": removed, "restart_required": bool(removed)}
+
+    async def install_repo(self, repo_id: str) -> dict[str, Any]:
+        repo = self.get_repo(repo_id)
+        if not repo:
+            raise BCSInstallError(f"repo_id not found: {repo_id}")
+
+        async with self._install_lock:
+            ref = self._pick_ref_for_install(repo)
+            zip_url = self._build_zip_url(repo.url, ref)
+
+            _LOGGER.info("BCS install started: repo_id=%s ref=%s zip_url=%s", repo_id, ref, zip_url)
+
+            with tempfile.TemporaryDirectory(prefix="bcs_install_") as td:
+                tmp = Path(td)
+                zip_path = tmp / "repo.zip"
+                extract_dir = tmp / "extract"
+                extract_dir.mkdir(parents=True, exist_ok=True)
+
+                await self._download_zip(zip_url, zip_path)
+                await self._extract_zip(zip_path, extract_dir)
+
+                cc_root = self._find_custom_components_root(extract_dir)
+                if not cc_root:
+                    raise BCSInstallError("custom_components folder not found in repository ZIP")
+
+                installed_domains: list[str] = []
+                for domain_dir in cc_root.iterdir():
+                    if not domain_dir.is_dir():
+                        continue
+                    manifest = domain_dir / "manifest.json"
+                    if not manifest.exists():
+                        continue
+
+                    domain = domain_dir.name
+                    await self._copy_domain_dir(domain_dir, domain)
+                    installed_domains.append(domain)
+
+                if not installed_domains:
+                    raise BCSInstallError("No integrations found under custom_components/ (missing manifest.json)")
+
+            installed_manifest_version = await self._read_installed_manifest_version(installed_domains[0])
+            installed_version = ref
+
+            await self.storage.set_installed_repo(
+                repo_id=repo_id,
+                url=repo.url,
+                domains=installed_domains,
+                installed_version=installed_version,
+                installed_manifest_version=installed_manifest_version,
+                ref=ref,
+            )
+            await self._refresh_installed_cache()
+
+            self._mark_restart_required()
+
+            _LOGGER.info(
+                "BCS install complete: repo_id=%s domains=%s installed_ref=%s manifest_version=%s",
+                repo_id,
+                installed_domains,
+                installed_version,
+                installed_manifest_version,
+            )
+            self.signal_updated()
+            return {
+                "ok": True,
+                "repo_id": repo_id,
+                "domains": installed_domains,
+                "installed_version": installed_version,
+                "installed_manifest_version": installed_manifest_version,
+                "restart_required": True,
+            }
+
+    async def update_repo(self, repo_id: str) -> dict[str, Any]:
+        _LOGGER.info("BCS update started: repo_id=%s", repo_id)
+        return await self.install_repo(repo_id)
+
+    async def request_restart(self) -> None:
+        await self.hass.services.async_call("homeassistant", "restart", {}, blocking=False)

custom_components/bahmcloud_store/custom_repo_view.py

@@ -0,0 +1,28 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from homeassistant.components.http import HomeAssistantView
+
+if TYPE_CHECKING:
+    from .core import BCSCore
+
+
+class BCSCustomRepoView(HomeAssistantView):
+    """
+    DELETE /api/bcs/custom_repo?id=...
+    """
+    requires_auth = True
+    name = "bcs_custom_repo_api"
+    url = "/api/bcs/custom_repo"
+
+    def __init__(self, core: "BCSCore") -> None:
+        self.core = core
+
+    async def delete(self, request):
+        repo_id = request.query.get("id", "").strip()
+        if not repo_id:
+            return self.json({"error": "id missing"}, status_code=400)
+
+        await self.core.remove_custom_repo(repo_id)
+        return self.json({"ok": True})

custom_components/bahmcloud_store/manifest.json

@@ -1,9 +1,10 @@
 {
   "domain": "bahmcloud_store",
   "name": "Bahmcloud Store",
-  "version": "0.1.0",
-  "documentation": "https://git.bahmcloud.de/bahmcloud/ha_store",
+  "version": "0.5.9",
+  "documentation": "https://git.bahmcloud.de/bahmcloud/bahmcloud_store",
+  "platforms": ["update"],
   "requirements": [],
-  "codeowners": [],
+  "codeowners": ["@bahmcloud"],
   "iot_class": "local_polling"
 }

custom_components/bahmcloud_store/metadata.py

@@ -0,0 +1,168 @@
+from __future__ import annotations
+
+import json
+import logging
+from dataclasses import dataclass
+from urllib.parse import urlparse
+
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+from homeassistant.util import yaml as ha_yaml
+
+_LOGGER = logging.getLogger(__name__)
+
+
+@dataclass
+class RepoMetadata:
+    source: str | None = None  # "bcs.yaml" | "hacs.yaml" | "hacs.json" | None
+    name: str | None = None
+    description: str | None = None
+    category: str | None = None
+    author: str | None = None
+    maintainer: str | None = None
+
+
+def _normalize_repo_name(name: str | None) -> str | None:
+    if not name:
+        return None
+    n = name.strip()
+    if n.endswith(".git"):
+        n = n[:-4]
+    return n or None
+
+
+def _split_owner_repo(repo_url: str) -> tuple[str | None, str | None]:
+    u = urlparse(repo_url.rstrip("/"))
+    parts = [p for p in u.path.strip("/").split("/") if p]
+    if len(parts) < 2:
+        return None, None
+    owner = parts[0].strip() or None
+    repo = _normalize_repo_name(parts[1])
+    return owner, repo
+
+
+def _is_github(repo_url: str) -> bool:
+    return "github.com" in urlparse(repo_url).netloc.lower()
+
+
+def _is_gitlab(repo_url: str) -> bool:
+    return "gitlab" in urlparse(repo_url).netloc.lower()
+
+
+def _is_gitea(repo_url: str) -> bool:
+    host = urlparse(repo_url).netloc.lower()
+    return host and ("github.com" not in host) and ("gitlab" not in host)
+
+
+async def _fetch_text(hass: HomeAssistant, url: str) -> str | None:
+    session = async_get_clientsession(hass)
+    try:
+        async with session.get(url, timeout=20) as resp:
+            if resp.status != 200:
+                return None
+            return await resp.text()
+    except Exception:
+        return None
+
+
+def _parse_meta_yaml(raw: str, source: str) -> RepoMetadata:
+    try:
+        data = ha_yaml.parse_yaml(raw)
+        if not isinstance(data, dict):
+            return RepoMetadata(source=source)
+
+        return RepoMetadata(
+            source=source,
+            name=data.get("name"),
+            description=data.get("description"),
+            category=data.get("category"),
+            author=data.get("author"),
+            maintainer=data.get("maintainer"),
+        )
+    except Exception:
+        return RepoMetadata(source=source)
+
+
+def _parse_meta_hacs_json(raw: str) -> RepoMetadata:
+    try:
+        data = json.loads(raw)
+        if not isinstance(data, dict):
+            return RepoMetadata(source="hacs.json")
+
+        name = data.get("name")
+        description = data.get("description")
+        author = data.get("author")
+        maintainer = data.get("maintainer")
+        category = data.get("category") or data.get("type")
+
+        return RepoMetadata(
+            source="hacs.json",
+            name=name if isinstance(name, str) else None,
+            description=description if isinstance(description, str) else None,
+            category=category if isinstance(category, str) else None,
+            author=author if isinstance(author, str) else None,
+            maintainer=maintainer if isinstance(maintainer, str) else None,
+        )
+    except Exception:
+        return RepoMetadata(source="hacs.json")
+
+
+async def fetch_repo_metadata(hass: HomeAssistant, repo_url: str, default_branch: str | None) -> RepoMetadata:
+    owner, repo = _split_owner_repo(repo_url)
+    if not owner or not repo:
+        return RepoMetadata()
+
+    branch = default_branch or "main"
+
+    # Priority:
+    # 1) bcs.yaml
+    # 2) hacs.yaml
+    # 3) hacs.json
+    filenames = ["bcs.yaml", "hacs.yaml", "hacs.json"]
+
+    candidates: list[tuple[str, str]] = []
+
+    if _is_github(repo_url):
+        base = f"https://raw.githubusercontent.com/{owner}/{repo}/{branch}"
+        for fn in filenames:
+            candidates.append((fn, f"{base}/{fn}"))
+
+    elif _is_gitlab(repo_url):
+        u = urlparse(repo_url.rstrip("/"))
+        root = f"{u.scheme}://{u.netloc}/{owner}/{repo}"
+        # GitLab raw format
+        # https://gitlab.com/<owner>/<repo>/-/raw/<branch>/<file>
+        for fn in filenames:
+            candidates.append((fn, f"{root}/-/raw/{branch}/{fn}"))
+
+    elif _is_gitea(repo_url):
+        u = urlparse(repo_url.rstrip("/"))
+        root = f"{u.scheme}://{u.netloc}/{owner}/{repo}"
+
+        bases = [
+            f"{root}/raw/branch/{branch}",
+            f"{root}/raw/{branch}",
+        ]
+        for fn in filenames:
+            for b in bases:
+                candidates.append((fn, f"{b}/{fn}"))
+
+    else:
+        return RepoMetadata()
+
+    for fn, url in candidates:
+        raw = await _fetch_text(hass, url)
+        if not raw:
+            continue
+
+        if fn.endswith(".json"):
+            meta = _parse_meta_hacs_json(raw)
+            if meta.source:
+                return meta
+            continue
+
+        meta = _parse_meta_yaml(raw, fn)
+        if meta.source:
+            return meta
+
+    return RepoMetadata()

custom_components/bahmcloud_store/panel/index.html

@@ -9,12 +9,18 @@
   <div class="wrap">
     <h1>Bahmcloud Store</h1>
     <p class="muted">
-      Installation & Updates laufen manuell über <b>Einstellungen → System → Updates</b>.<br/>
-      Diese Seite zeigt nur die Paketliste aus store.yaml (auto-refresh).
+      Installation erfolgt hier im Store (Buttons).<br/>
+      Updates erscheinen danach zusätzlich unter <b>Einstellungen → System → Updates</b>.
     </p>
+
+    <div class="actions">
       <button id="refresh">Refresh</button>
+    </div>
+
+    <div id="status" class="muted"></div>
     <div id="list"></div>
   </div>
+
   <script src="/api/bahmcloud_store_static/app.js"></script>
 </body>
 </html>

custom_components/bahmcloud_store/panel/styles.css

@@ -1,8 +1,24 @@
 body { font-family: system-ui, sans-serif; margin:0; }
 .wrap { padding: 16px; max-width: 1000px; margin: 0 auto; }
 .card { border: 1px solid #ddd; border-radius: 10px; padding: 12px; margin: 10px 0; }
-.row { display:flex; justify-content:space-between; gap: 12px; }
-.badge { border: 1px solid #bbb; border-radius: 999px; padding: 2px 8px; font-size: 12px; }
-.muted { color: #666; font-size: 13px; }
+.row { display:flex; justify-content:space-between; gap: 12px; align-items: flex-start; flex-wrap: wrap; min-width:0; }
+.badge { border: 1px solid #bbb; border-radius: 999px; padding: 2px 8px; font-size: 12px; height: fit-content; }
+.muted { color: #666; font-size: 13px; margin-top: 4px; }
+.actions { display:flex; gap: 8px; margin-top: 10px; }
 button { padding: 8px 12px; cursor:pointer; }
+button[disabled] { opacity: 0.6; cursor: not-allowed; }
 a { color: inherit; }
+
+/* Basic markdown safety (in case styles.css is used by older panels) */
+.md { max-width: 100%; overflow-x: auto; }
+.md table { display:block; max-width:100%; overflow-x:auto; }
+.md img { max-width: 100%; height: auto; }
+
+/* README UX (E2): collapsible preview (standalone page only) */
+.readmeWrap{ border:1px solid #ddd; border-radius:10px; padding:12px; background: #f7f7f7; max-width:100%; }
+.readmeWrap.collapsed{ max-height:260px; overflow:hidden; position:relative; }
+.readmeWrap.collapsed::after{ content:""; position:absolute; left:0; right:0; bottom:0; height:56px; background: linear-gradient(to bottom, rgba(247,247,247,0), #f7f7f7); pointer-events:none; }
+.readmeWrap.expanded{ max-height:70vh; overflow:auto; }
+.readmeActions{ display:flex; justify-content:flex-end; margin-top:10px; }
+button.link{ border:none; background:transparent; padding:6px 10px; color:#1E88E5; }
+button.link:hover{ text-decoration:underline; }

custom_components/bahmcloud_store/providers.py

@@ -0,0 +1,507 @@
+from __future__ import annotations
+
+import logging
+import re
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass
+from urllib.parse import quote_plus, urlparse
+
+from packaging.version import InvalidVersion, Version
+
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.aiohttp_client import async_get_clientsession
+
+_LOGGER = logging.getLogger(__name__)
+
+UA = "BahmcloudStore (Home Assistant)"
+
+
+@dataclass
+class RepoInfo:
+    owner: str | None = None
+    repo_name: str | None = None
+    description: str | None = None
+    provider: str | None = None
+    default_branch: str | None = None
+
+    latest_version: str | None = None
+    latest_version_source: str | None = None  # "release" | "tag" | "atom" | None
+
+
+def _normalize_repo_name(name: str | None) -> str | None:
+    if not name:
+        return None
+    n = name.strip()
+    if n.endswith(".git"):
+        n = n[:-4]
+    return n or None
+
+
+def _split_owner_repo(repo_url: str) -> tuple[str | None, str | None]:
+    u = urlparse(repo_url.rstrip("/"))
+    parts = [p for p in u.path.strip("/").split("/") if p]
+    if len(parts) < 2:
+        return None, None
+    owner = parts[0].strip() or None
+    repo = _normalize_repo_name(parts[1])
+    return owner, repo
+
+
+def detect_provider(repo_url: str) -> str:
+    host = urlparse(repo_url).netloc.lower()
+    if "github.com" in host:
+        return "github"
+    if "gitlab" in host:
+        return "gitlab"
+    return "gitea"
+
+
+async def _safe_json(session, url: str, *, headers: dict | None = None, timeout: int = 20):
+    try:
+        async with session.get(url, timeout=timeout, headers=headers) as resp:
+            status = resp.status
+            if status != 200:
+                return None, status
+            return await resp.json(), status
+    except Exception:
+        return None, None
+
+
+async def _safe_text(session, url: str, *, headers: dict | None = None, timeout: int = 20):
+    try:
+        async with session.get(url, timeout=timeout, headers=headers) as resp:
+            status = resp.status
+            if status != 200:
+                return None, status
+            return await resp.text(), status
+    except Exception:
+        return None, None
+
+
+def _extract_tag_from_github_url(url: str) -> str | None:
+    m = re.search(r"/releases/tag/([^/?#]+)", url or "")
+    if not m:
+        return None
+    return m.group(1).strip() or None
+
+
+def _extract_meta(html: str, *, prop: str | None = None, name: str | None = None) -> str | None:
+    if not html:
+        return None
+    if prop:
+        m = re.search(rf'<meta\s+property="{re.escape(prop)}"\s+content="([^"]+)"', html)
+        if m:
+            return m.group(1).strip()
+    if name:
+        m = re.search(rf'<meta\s+name="{re.escape(name)}"\s+content="([^"]+)"', html)
+        if m:
+            return m.group(1).strip()
+    return None
+
+
+def _semver_key(tag: str) -> Version | None:
+    t = (tag or "").strip()
+    if not t:
+        return None
+    if t.startswith(("v", "V")):
+        t = t[1:]
+    try:
+        return Version(t)
+    except InvalidVersion:
+        return None
+
+
+def _pick_highest_semver(tags: list[str]) -> str | None:
+    parsed: list[tuple[Version, str]] = []
+    for t in tags:
+        if not isinstance(t, str):
+            continue
+        ts = t.strip()
+        if not ts:
+            continue
+        v = _semver_key(ts)
+        if v is not None:
+            parsed.append((v, ts))
+
+    if not parsed:
+        return None
+    parsed.sort(key=lambda x: x[0], reverse=True)
+    return parsed[0][1]
+
+
+async def _github_description_html(hass: HomeAssistant, owner: str, repo: str) -> str | None:
+    session = async_get_clientsession(hass)
+    url = f"https://github.com/{owner}/{repo}"
+    html, status = await _safe_text(session, url, headers={"User-Agent": UA})
+    if status != 200 or not html:
+        return None
+
+    desc = _extract_meta(html, prop="og:description")
+    if desc:
+        return desc
+
+    return _extract_meta(html, name="description")
+
+
+async def _github_latest_version_atom(hass: HomeAssistant, owner: str, repo: str) -> tuple[str | None, str | None]:
+    session = async_get_clientsession(hass)
+    url = f"https://github.com/{owner}/{repo}/releases.atom"
+    atom, status = await _safe_text(session, url, headers={"User-Agent": UA})
+    if status != 200 or not atom:
+        return None, None
+
+    try:
+        root = ET.fromstring(atom)
+        ns = {"a": "http://www.w3.org/2005/Atom"}
+        entry = root.find("a:entry", ns)
+        if entry is None:
+            return None, None
+        link = entry.find("a:link", ns)
+        if link is not None and link.attrib.get("href"):
+            tag = _extract_tag_from_github_url(link.attrib["href"])
+            if tag:
+                return tag, "atom"
+        title = entry.find("a:title", ns)
+        if title is not None and title.text:
+            t = title.text.strip()
+            if t:
+                return t, "atom"
+    except Exception:
+        return None, None
+
+    return None, None
+
+
+async def _github_latest_version_redirect(hass: HomeAssistant, owner: str, repo: str) -> tuple[str | None, str | None]:
+    session = async_get_clientsession(hass)
+    url = f"https://github.com/{owner}/{repo}/releases/latest"
+    try:
+        async with session.get(url, timeout=20, headers={"User-Agent": UA}, allow_redirects=True) as resp:
+            if resp.status != 200:
+                return None, None
+            final = str(resp.url)
+            tag = _extract_tag_from_github_url(final)
+            if tag:
+                return tag, "release"
+    except Exception:
+        return None, None
+
+    return None, None
+
+
+async def _github_latest_version_api(hass: HomeAssistant, owner: str, repo: str) -> tuple[str | None, str | None]:
+    session = async_get_clientsession(hass)
+    headers = {"Accept": "application/vnd.github+json", "User-Agent": UA}
+
+    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"):
+        return str(data["tag_name"]), "release"
+
+    # No releases -> pick highest semver from many tags (instead of per_page=1)
+    if status == 404:
+        data, _ = await _safe_json(session, f"https://api.github.com/repos/{owner}/{repo}/tags?per_page=100", headers=headers)
+        tags: list[str] = []
+        if isinstance(data, list):
+            for t in data:
+                if isinstance(t, dict) and t.get("name"):
+                    tags.append(str(t["name"]))
+
+        best = _pick_highest_semver(tags)
+        if best:
+            return best, "tag"
+
+        # fallback: keep old behavior (first tag)
+        if tags:
+            return tags[0], "tag"
+
+    return None, None
+
+
+async def _github_latest_version(hass: HomeAssistant, owner: str, repo: str) -> 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)
+    if tag:
+        return tag, src
+
+    return await _github_latest_version_atom(hass, owner, repo)
+
+
+async def _gitea_latest_version(hass: HomeAssistant, base: str, owner: str, repo: str) -> tuple[str | None, str | None]:
+    session = async_get_clientsession(hass)
+
+    # releases: fetch multiple, pick highest semver (instead of limit=1)
+    data, _ = await _safe_json(session, f"{base}/api/v1/repos/{owner}/{repo}/releases?limit=50")
+    rel_tags: list[str] = []
+    if isinstance(data, list):
+        for r in data:
+            if isinstance(r, dict) and r.get("tag_name"):
+                rel_tags.append(str(r["tag_name"]))
+
+    best_rel = _pick_highest_semver(rel_tags)
+    if best_rel:
+        return best_rel, "release"
+    if rel_tags:
+        return rel_tags[0], "release"
+
+    # tags: fetch multiple, pick highest semver (instead of limit=1)
+    data, _ = await _safe_json(session, f"{base}/api/v1/repos/{owner}/{repo}/tags?limit=50")
+    tags: list[str] = []
+    if isinstance(data, list):
+        for t in data:
+            if isinstance(t, dict) and t.get("name"):
+                tags.append(str(t["name"]))
+
+    best = _pick_highest_semver(tags)
+    if best:
+        return best, "tag"
+    if tags:
+        return tags[0], "tag"
+
+    return None, None
+
+
+async def _gitlab_latest_version(
+    hass: HomeAssistant, base: str, owner: str, repo: str
+) -> tuple[str | None, str | None]:
+    session = async_get_clientsession(hass)
+    headers = {"User-Agent": UA}
+
+    project = quote_plus(f"{owner}/{repo}")
+
+    # releases: fetch multiple, pick highest semver (instead of per_page=1)
+    data, _ = await _safe_json(session, f"{base}/api/v4/projects/{project}/releases?per_page=50", headers=headers)
+    rel_tags: list[str] = []
+    if isinstance(data, list):
+        for r in data:
+            if isinstance(r, dict) and r.get("tag_name"):
+                rel_tags.append(str(r["tag_name"]))
+
+    best_rel = _pick_highest_semver(rel_tags)
+    if best_rel:
+        return best_rel, "release"
+    if rel_tags:
+        return rel_tags[0], "release"
+
+    # tags: fetch multiple, pick highest semver (instead of per_page=1)
+    data, _ = await _safe_json(session, f"{base}/api/v4/projects/{project}/repository/tags?per_page=50", headers=headers)
+    tags: list[str] = []
+    if isinstance(data, list):
+        for t in data:
+            if isinstance(t, dict) and t.get("name"):
+                tags.append(str(t["name"]))
+
+    best = _pick_highest_semver(tags)
+    if best:
+        return best, "tag"
+    if tags:
+        return tags[0], "tag"
+
+    # atom fallback
+    atom, status = await _safe_text(session, f"{base}/{owner}/{repo}/-/tags?format=atom", headers=headers)
+    if status == 200 and atom:
+        try:
+            root = ET.fromstring(atom)
+            ns = {"a": "http://www.w3.org/2005/Atom"}
+            entry = root.find("a:entry", ns)
+            if entry is not None:
+                title = entry.find("a:title", ns)
+                if title is not None and title.text:
+                    return title.text.strip(), "atom"
+        except Exception:
+            pass
+
+    return None, None
+
+
+async def fetch_repo_info(hass: HomeAssistant, repo_url: str) -> RepoInfo:
+    provider = detect_provider(repo_url)
+    owner, repo = _split_owner_repo(repo_url)
+
+    info = RepoInfo(
+        owner=owner,
+        repo_name=repo,
+        description=None,
+        provider=provider,
+        default_branch=None,
+        latest_version=None,
+        latest_version_source=None,
+    )
+
+    if not owner or not repo:
+        return info
+
+    session = async_get_clientsession(hass)
+
+    try:
+        if provider == "github":
+            headers = {"Accept": "application/vnd.github+json", "User-Agent": UA}
+            data, status = await _safe_json(session, f"https://api.github.com/repos/{owner}/{repo}", headers=headers)
+
+            if isinstance(data, dict):
+                info.description = data.get("description")
+                info.repo_name = _normalize_repo_name(data.get("name")) or repo
+                info.default_branch = data.get("default_branch") or "main"
+                if isinstance(data.get("owner"), dict) and data["owner"].get("login"):
+                    info.owner = data["owner"]["login"]
+            else:
+                if status == 403:
+                    _LOGGER.debug("GitHub API blocked/rate-limited for repo info %s/%s", owner, repo)
+                info.default_branch = "main"
+
+            if not info.description:
+                desc = await _github_description_html(hass, owner, repo)
+                if desc:
+                    info.description = desc
+
+            ver, src = await _github_latest_version(hass, owner, repo)
+            info.latest_version = ver
+            info.latest_version_source = src
+            return info
+
+        if provider == "gitlab":
+            u = urlparse(repo_url.rstrip("/"))
+            base = f"{u.scheme}://{u.netloc}"
+            headers = {"User-Agent": UA}
+            project = quote_plus(f"{owner}/{repo}")
+
+            data, _ = await _safe_json(session, f"{base}/api/v4/projects/{project}", headers=headers)
+            if isinstance(data, dict):
+                info.description = data.get("description")
+                info.repo_name = _normalize_repo_name(data.get("path")) or repo
+                info.default_branch = data.get("default_branch") or "main"
+                ns = data.get("namespace")
+                if isinstance(ns, dict) and ns.get("path"):
+                    info.owner = ns.get("path")
+
+            ver, src = await _gitlab_latest_version(hass, base, owner, repo)
+            info.latest_version = ver
+            info.latest_version_source = src
+            return info
+
+        if provider == "gitea":
+            u = urlparse(repo_url.rstrip("/"))
+            base = f"{u.scheme}://{u.netloc}"
+
+            data, _ = await _safe_json(session, f"{base}/api/v1/repos/{owner}/{repo}")
+            if isinstance(data, dict):
+                info.description = data.get("description")
+                info.repo_name = _normalize_repo_name(data.get("name")) or repo
+                info.default_branch = data.get("default_branch") or "main"
+                if isinstance(data.get("owner"), dict) and data["owner"].get("login"):
+                    info.owner = data["owner"]["login"]
+
+            ver, src = await _gitea_latest_version(hass, base, owner, repo)
+            info.latest_version = ver
+            info.latest_version_source = src
+            return info
+
+    except Exception as e:
+        _LOGGER.debug("fetch_repo_info failed for %s: %s", repo_url, e)
+
+    return info
+
+
+async def fetch_readme_markdown(
+    hass: HomeAssistant,
+    repo_url: str,
+    *,
+    provider: str | None = None,
+    default_branch: str | None = None,
+) -> str | None:
+    """Fetch README Markdown for public repositories (GitHub/GitLab/Gitea).
+
+    Defensive behavior:
+    - tries multiple common README filenames
+    - tries multiple branches (default, main, master)
+    - uses public raw endpoints (no tokens required for public repositories)
+    """
+    repo_url = (repo_url or "").strip()
+    if not repo_url:
+        return None
+
+    prov = (provider or "").strip().lower() if provider else ""
+    if not prov:
+        prov = detect_provider(repo_url)
+
+    branch_candidates: list[str] = []
+    if default_branch and str(default_branch).strip():
+        branch_candidates.append(str(default_branch).strip())
+    for b in ("main", "master"):
+        if b not in branch_candidates:
+            branch_candidates.append(b)
+
+    filenames = ["README.md", "readme.md", "README.MD", "README.rst", "README"]
+
+    session = async_get_clientsession(hass)
+    headers = {"User-Agent": UA}
+
+    def _normalize_gitlab_path(path: str) -> str | None:
+        p = (path or "").strip().strip("/")
+        if not p:
+            return None
+        parts = [x for x in p.split("/") if x]
+        if len(parts) < 2:
+            return None
+        if parts[-1].endswith(".git"):
+            parts[-1] = parts[-1][:-4]
+        return "/".join(parts)
+
+    candidates: list[str] = []
+
+    if prov == "github":
+        owner, repo = _split_owner_repo(repo_url)
+        if not owner or not repo:
+            return None
+        for branch in branch_candidates:
+            base = f"https://raw.githubusercontent.com/{owner}/{repo}/{branch}"
+            for fn in filenames:
+                candidates.append(f"{base}/{fn}")
+
+    elif prov == "gitea":
+        owner, repo = _split_owner_repo(repo_url)
+        if not owner or not repo:
+            return None
+        u = urlparse(repo_url.rstrip("/"))
+        root = f"{u.scheme}://{u.netloc}/{owner}/{repo}"
+        for branch in branch_candidates:
+            bases = [
+                f"{root}/raw/branch/{branch}",
+                f"{root}/raw/{branch}",
+            ]
+            for b in bases:
+                for fn in filenames:
+                    candidates.append(f"{b}/{fn}")
+
+    elif prov == "gitlab":
+        u = urlparse(repo_url.rstrip("/"))
+        path_repo = _normalize_gitlab_path(u.path)
+        if not path_repo:
+            return None
+        root = f"{u.scheme}://{u.netloc}/{path_repo}"
+        for branch in branch_candidates:
+            bases = [
+                f"{root}/-/raw/{branch}",
+                f"{root}/raw/{branch}",
+            ]
+            for b in bases:
+                for fn in filenames:
+                    candidates.append(f"{b}/{fn}")
+
+    else:
+        return None
+
+    for url in candidates:
+        try:
+            async with session.get(url, timeout=20, headers=headers) as resp:
+                if resp.status != 200:
+                    continue
+                txt = await resp.text()
+                if txt and txt.strip():
+                    return txt
+        except Exception:
+            continue
+
+    return None

custom_components/bahmcloud_store/repairs.py

@@ -0,0 +1,55 @@
+from __future__ import annotations
+
+import logging
+
+import voluptuous as vol
+
+from homeassistant.components.repairs import RepairsFlow
+from homeassistant.core import HomeAssistant
+from homeassistant import data_entry_flow
+
+from .core import RESTART_REQUIRED_ISSUE_ID
+
+_LOGGER = logging.getLogger(__name__)
+
+
+class BCSRestartRequiredFlow(RepairsFlow):
+    """Repairs flow to restart Home Assistant after BCS install/update."""
+
+    def __init__(self, hass: HomeAssistant) -> None:
+        self.hass = hass
+
+    async def async_step_init(
+        self, user_input: dict[str, str] | None = None
+    ) -> data_entry_flow.FlowResult:
+        return await self.async_step_confirm(user_input)
+
+    async def async_step_confirm(
+        self, user_input: dict[str, str] | None = None
+    ) -> data_entry_flow.FlowResult:
+        if user_input is not None:
+            _LOGGER.info("BCS repairs flow: restarting Home Assistant (user confirmed)")
+            await self.hass.services.async_call(
+                "homeassistant",
+                "restart",
+                {},
+                blocking=False,
+            )
+            return self.async_create_entry(title="", data={})
+
+        return self.async_show_form(
+            step_id="confirm",
+            data_schema=vol.Schema({}),
+        )
+
+
+async def async_create_fix_flow(
+    hass: HomeAssistant,
+    issue_id: str,
+    data: dict[str, str | int | float | None] | None,
+) -> RepairsFlow:
+    """Create a repairs flow for BCS fixable issues."""
+    if issue_id == RESTART_REQUIRED_ISSUE_ID:
+        return BCSRestartRequiredFlow(hass)
+
+    raise data_entry_flow.UnknownHandler

custom_components/bahmcloud_store/storage.py

@@ -0,0 +1,184 @@
+from __future__ import annotations
+
+import time
+import uuid
+from dataclasses import dataclass
+from typing import Any
+
+from homeassistant.core import HomeAssistant
+from homeassistant.helpers.storage import Store
+
+_STORAGE_VERSION = 1
+_STORAGE_KEY = "bcs_store"
+
+
+@dataclass
+class CustomRepo:
+    id: str
+    url: str
+    name: str | None = None
+
+
+@dataclass
+class InstalledRepo:
+    repo_id: str
+    url: str
+    domains: list[str]
+    installed_at: int
+    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
+
+
+class BCSStorage:
+    """Persistent storage for Bahmcloud Store.
+
+    Keys:
+    - custom_repos: list of manually added repositories
+    - installed_repos: mapping repo_id -> installed metadata
+    """
+
+    def __init__(self, hass: HomeAssistant) -> None:
+        self.hass = hass
+        self._store: Store[dict[str, Any]] = Store(hass, _STORAGE_VERSION, _STORAGE_KEY)
+
+    async def _load(self) -> dict[str, Any]:
+        data = await self._store.async_load() or {}
+        if not isinstance(data, dict):
+            data = {}
+
+        if "custom_repos" not in data or not isinstance(data.get("custom_repos"), list):
+            data["custom_repos"] = []
+
+        if "installed_repos" not in data or not isinstance(data.get("installed_repos"), dict):
+            data["installed_repos"] = {}
+
+        return data
+
+    async def _save(self, data: dict[str, Any]) -> None:
+        await self._store.async_save(data)
+
+    async def list_custom_repos(self) -> list[CustomRepo]:
+        data = await self._load()
+        repos = data.get("custom_repos", [])
+        out: list[CustomRepo] = []
+        for r in repos:
+            if not isinstance(r, dict):
+                continue
+            rid = r.get("id")
+            url = r.get("url")
+            if not rid or not url:
+                continue
+            out.append(CustomRepo(id=str(rid), url=str(url), name=r.get("name")))
+        return out
+
+    async def add_custom_repo(self, url: str, name: str | None) -> CustomRepo:
+        data = await self._load()
+        repos = data.get("custom_repos", [])
+
+        # De-duplicate by URL
+        for r in repos:
+            if isinstance(r, dict) and str(r.get("url") or "").strip() == url.strip():
+                return CustomRepo(id=str(r["id"]), url=str(r["url"]), name=r.get("name"))
+
+        rid = f"custom:{uuid.uuid4().hex[:10]}"
+        entry = {"id": rid, "url": url.strip(), "name": name.strip() if name else None}
+        repos.append(entry)
+        data["custom_repos"] = repos
+        await self._save(data)
+        return CustomRepo(id=rid, url=entry["url"], name=entry["name"])
+
+    async def remove_custom_repo(self, repo_id: str) -> None:
+        data = await self._load()
+        repos = data.get("custom_repos", [])
+        data["custom_repos"] = [
+            r for r in repos if not (isinstance(r, dict) and r.get("id") == repo_id)
+        ]
+        await self._save(data)
+
+    async def get_installed_repo(self, repo_id: str) -> InstalledRepo | None:
+        data = await self._load()
+        installed = data.get("installed_repos", {})
+        if not isinstance(installed, dict):
+            return None
+        entry = installed.get(repo_id)
+        if not isinstance(entry, dict):
+            return None
+
+        try:
+            domains = entry.get("domains") or []
+            if not isinstance(domains, list):
+                domains = []
+            domains = [str(d) for d in domains if str(d).strip()]
+
+            installed_version = entry.get("installed_version")
+            ref = entry.get("ref")
+
+            # Backward compatibility:
+            # If installed_version wasn't stored, fall back to ref.
+            if (not installed_version) and ref:
+                installed_version = ref
+
+            installed_manifest_version = entry.get("installed_manifest_version")
+
+            return InstalledRepo(
+                repo_id=str(entry.get("repo_id") or repo_id),
+                url=str(entry.get("url") or ""),
+                domains=domains,
+                installed_at=int(entry.get("installed_at") or 0),
+                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,
+            )
+        except Exception:
+            return None
+
+    async def list_installed_repos(self) -> list[InstalledRepo]:
+        data = await self._load()
+        installed = data.get("installed_repos", {})
+        out: list[InstalledRepo] = []
+        if not isinstance(installed, dict):
+            return out
+        for rid in list(installed.keys()):
+            item = await self.get_installed_repo(str(rid))
+            if item:
+                out.append(item)
+        return out
+
+    async def set_installed_repo(
+        self,
+        *,
+        repo_id: str,
+        url: str,
+        domains: list[str],
+        installed_version: str | None,
+        installed_manifest_version: str | None = None,
+        ref: str | None,
+    ) -> None:
+        data = await self._load()
+        installed = data.get("installed_repos", {})
+        if not isinstance(installed, dict):
+            installed = {}
+            data["installed_repos"] = installed
+
+        installed[str(repo_id)] = {
+            "repo_id": str(repo_id),
+            "url": str(url),
+            "domains": [str(d) for d in (domains or []) if str(d).strip()],
+            "installed_at": int(time.time()),
+            # IMPORTANT: this is what BCS uses as "installed version" (ref/tag/branch)
+            "installed_version": installed_version,
+            # informational only
+            "installed_manifest_version": installed_manifest_version,
+            # keep ref too (debug/backward compatibility)
+            "ref": ref,
+        }
+        await self._save(data)
+
+    async def remove_installed_repo(self, repo_id: str) -> None:
+        data = await self._load()
+        installed = data.get("installed_repos", {})
+        if isinstance(installed, dict) and repo_id in installed:
+            installed.pop(repo_id, None)
+            data["installed_repos"] = installed
+            await self._save(data)

custom_components/bahmcloud_store/store.py

@@ -35,7 +35,7 @@ class StoreConfig:
 class Package:
     id: str
     name: str
-    type: str
+    type: str  # "integration" | "store"
     domain: str
     repo: str
     owner: str
@@ -76,12 +76,19 @@ class BahmcloudStore:
         u = urlparse(repo_url.rstrip("/"))
         return f"{u.scheme}://{u.netloc}"
 
+    @staticmethod
+    def _raw_manifest_url(repo: str, branch: str, source_path: str) -> str:
+        # Example:
+        # https://git.bahmcloud.de/bahmcloud/easy_proxmox/raw/branch/main/custom_components/easy_proxmox/manifest.json
+        return f"{repo.rstrip('/')}/raw/branch/{branch}/{source_path.rstrip('/')}/manifest.json"
+
     async def _fetch_latest_version(self, pkg: Package) -> tuple[str | None, str | None]:
         """
         Returns (latest_version, release_url)
         Strategy:
           1) releases/latest -> tag_name
           2) tags?limit=1 -> first tag name
+          3) fallback: read manifest.json from repo (version field)
         """
         session = async_get_clientsession(self.hass)
         base = self._base_from_repo(pkg.repo)
@@ -94,7 +101,8 @@ class BahmcloudStore:
                     data = await resp.json()
                     tag = data.get("tag_name")
                     html_url = data.get("html_url")
-                    return (str(tag) if tag else None, str(html_url) if html_url else None)
+                    if tag:
+                        return (str(tag), str(html_url) if html_url else None)
         except Exception:
             pass
 
@@ -106,7 +114,21 @@ class BahmcloudStore:
                     tags = await resp.json()
                     if tags and isinstance(tags, list):
                         name = tags[0].get("name")
-                        return (str(name) if name else None, None)
+                        if name:
+                            return (str(name), None)
+        except Exception:
+            pass
+
+        # 3) fallback: manifest.json version from repo
+        try:
+            manifest_url = self._raw_manifest_url(pkg.repo, pkg.branch, pkg.source_path)
+            async with session.get(manifest_url, timeout=20) as resp:
+                if resp.status == 200:
+                    text = await resp.text()
+                    data = json.loads(text)
+                    ver = data.get("version")
+                    if ver:
+                        return (str(ver), None)
         except Exception:
             pass
 
@@ -198,6 +220,9 @@ class BahmcloudStore:
                 shutil.rmtree(target)
             shutil.copytree(src, target)
 
+        # Nach Installation: Entities neu aufbauen (damit es als Update auftaucht)
+        self.signal_entities_updated()
+
         persistent_notification.async_create(
             self.hass,
             (
@@ -228,7 +253,7 @@ class BahmcloudStore:
     async def register_http_views(self) -> None:
         """Register HTTP views for static panel assets and JSON API."""
         self.hass.http.register_view(_StaticView())
-        self.hass.http.register_view(_APIListView(self))
+        self.hass.http.register_view(_APIView(self))
 
 
 class _StaticView(HomeAssistantView):
@@ -236,12 +261,6 @@ class _StaticView(HomeAssistantView):
     IMPORTANT:
     Custom Panel JS modules are loaded WITHOUT Authorization headers.
     Therefore static panel assets must be publicly accessible (no auth).
-
-    Serves:
-      /api/bahmcloud_store_static/index.html
-      /api/bahmcloud_store_static/panel.js
-      /api/bahmcloud_store_static/app.js
-      /api/bahmcloud_store_static/styles.css
     """
     requires_auth = False
     name = "bahmcloud_store_static"
@@ -254,7 +273,6 @@ class _StaticView(HomeAssistantView):
 
         f = (base / path).resolve()
 
-        # Prevent path traversal
         if not str(f).startswith(str(base)) or not f.exists() or not f.is_file():
             return web.Response(status=404, text="Not found")
 
@@ -269,10 +287,11 @@ class _StaticView(HomeAssistantView):
         return web.Response(body=f.read_bytes(), content_type="application/octet-stream")
 
 
-class _APIListView(HomeAssistantView):
+class _APIView(HomeAssistantView):
     """
-    Store API MUST stay protected.
-    UI loads data via fetch() with HA auth handled by frontend.
+    Auth-protected API:
+      GET  /api/bahmcloud_store           -> list packages
+      POST /api/bahmcloud_store {op:...}  -> install/update a package
     """
     requires_auth = True
     name = "bahmcloud_store_api"
@@ -300,3 +319,20 @@ class _APIListView(HomeAssistantView):
                 }
             )
         return self.json({"packages": items, "store_url": self.store.config.store_url})
+
+    async def post(self, request):
+        data = await request.json()
+        op = data.get("op")
+        package_id = data.get("package_id")
+
+        if op not in ("install", "update"):
+            return self.json({"error": "unknown op"}, status_code=400)
+        if not package_id:
+            return self.json({"error": "package_id missing"}, status_code=400)
+
+        pkg = self.store.packages.get(package_id)
+        if not pkg:
+            return self.json({"error": "unknown package_id"}, status_code=404)
+
+        await self.store.install_from_zip(pkg)
+        return self.json({"ok": True})

custom_components/bahmcloud_store/strings.json

@@ -0,0 +1,18 @@
+{
+  "issues": {
+    "restart_required": {
+      "title": "Restart required",
+      "description": "One or more integrations were installed or updated by Bahmcloud Store. Restart Home Assistant to load the changes."
+    }
+  },
+  "repair_flow": {
+    "restart_required": {
+      "step": {
+        "confirm": {
+          "title": "Restart Home Assistant",
+          "description": "Bahmcloud Store installed or updated integrations. Restart Home Assistant now to apply the changes."
+        }
+      }
+    }
+  }
+}

custom_components/bahmcloud_store/update.py

@@ -1,11 +1,142 @@
 from __future__ import annotations
 
-from homeassistant.components.update import UpdateEntity, UpdateEntityFeature
-from homeassistant.core import HomeAssistant
-from homeassistant.helpers.entity_platform import AddEntitiesCallback
+import logging
+from dataclasses import dataclass
+from typing import Any
 
-from . import DOMAIN
-from .store import BahmcloudStore, Package
+from homeassistant.components.update import UpdateEntity, UpdateEntityFeature
+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 .core import DOMAIN, SIGNAL_UPDATED, BCSCore
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def _pretty_repo_name(core: BCSCore, repo_id: str) -> str:
+    """Return a human-friendly name for a repo update entity."""
+    try:
+        repo = core.get_repo(repo_id)
+        if repo and getattr(repo, "name", None):
+            name = str(repo.name).strip()
+            if name:
+                return name
+    except Exception:
+        pass
+
+    if repo_id.startswith("index:"):
+        return f"BCS Index {repo_id.split(':', 1)[1]}"
+    if repo_id.startswith("custom:"):
+        return f"BCS Custom {repo_id.split(':', 1)[1]}"
+    return f"BCS {repo_id}"
+
+
+@dataclass(frozen=True)
+class _RepoKey:
+    repo_id: str
+
+
+class BCSRepoUpdateEntity(UpdateEntity):
+    """Update entity representing a BCS-managed repository."""
+
+    _attr_entity_category = EntityCategory.DIAGNOSTIC
+    _attr_supported_features = UpdateEntityFeature.INSTALL
+
+    def __init__(self, core: BCSCore, repo_id: str) -> None:
+        self._core = core
+        self._repo_id = repo_id
+        self._in_progress = False
+
+        # Stable unique id (do NOT change)
+        self._attr_unique_id = f"{DOMAIN}:{repo_id}"
+
+        self._refresh_display_name()
+
+    def _refresh_display_name(self) -> None:
+        pretty = _pretty_repo_name(self._core, self._repo_id)
+        self._attr_name = pretty
+        self._attr_title = pretty
+
+    @property
+    def available(self) -> bool:
+        repo = self._core.get_repo(self._repo_id)
+        installed = self._core.get_installed(self._repo_id)
+        return repo is not None and installed is not None
+
+    @property
+    def in_progress(self) -> bool | None:
+        return self._in_progress
+
+    @property
+    def installed_version(self) -> str | None:
+        installed = self._core.get_installed(self._repo_id) or {}
+        v = installed.get("installed_version") or installed.get("ref")
+        return str(v) if v else None
+
+    @property
+    def latest_version(self) -> str | None:
+        repo = self._core.get_repo(self._repo_id)
+        if not repo:
+            return None
+        v = getattr(repo, "latest_version", None)
+        return str(v) if v else None
+
+    @property
+    def update_available(self) -> bool:
+        latest = self.latest_version
+        installed = self.installed_version
+        if not latest or not installed:
+            return False
+        return latest != installed
+
+    def version_is_newer(self, latest_version: str, installed_version: str) -> bool:
+        return latest_version != installed_version
+
+    @property
+    def release_url(self) -> str | None:
+        repo = self._core.get_repo(self._repo_id)
+        return getattr(repo, "url", None) if repo else None
+
+    async def async_install(self, version: str | None, backup: bool, **kwargs: Any) -> None:
+        if version is not None:
+            _LOGGER.debug("BCS update entity requested specific version=%s (ignored)", version)
+
+        self._in_progress = True
+        self.async_write_ha_state()
+
+        try:
+            await self._core.update_repo(self._repo_id)
+        finally:
+            self._in_progress = False
+            self.async_write_ha_state()
+
+
+@callback
+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 {}
+    new_entities: list[BCSRepoUpdateEntity] = []
+
+    for repo_id, data in installed_map.items():
+        if not isinstance(data, dict):
+            continue
+
+        if repo_id in existing:
+            # IMPORTANT: Update display name after refresh, when repo.name becomes available.
+            existing[repo_id]._refresh_display_name()
+            continue
+
+        ent = BCSRepoUpdateEntity(core, repo_id)
+        existing[repo_id] = ent
+        new_entities.append(ent)
+
+    if new_entities:
+        async_add_entities(new_entities)
+
+    for ent in existing.values():
+        ent.async_write_ha_state()
 
 
 async def async_setup_platform(
@@ -14,71 +145,18 @@ async def async_setup_platform(
     async_add_entities: AddEntitiesCallback,
     discovery_info=None,
 ):
-    store: BahmcloudStore = hass.data[DOMAIN]
-    entities: dict[str, BahmcloudPackageUpdate] = {}
-
-    def rebuild_entities() -> None:
-        # create entities for any new package in store.yaml
-        for pkg in store.packages.values():
-            uid = f"{DOMAIN}:{pkg.id}"
-            if uid not in entities:
-                ent = BahmcloudPackageUpdate(store, pkg.id)
-                entities[uid] = ent
-                async_add_entities([ent], update_before_add=True)
-
-        # refresh states
-        for ent in entities.values():
-            ent.async_write_ha_state()
-
-    store.add_listener(rebuild_entities)
-    rebuild_entities()
-
-
-class BahmcloudPackageUpdate(UpdateEntity):
-    _attr_supported_features = UpdateEntityFeature.INSTALL
-
-    def __init__(self, store: BahmcloudStore, package_id: str) -> None:
-        self.store = store
-        self.package_id = package_id
-
-        self._attr_unique_id = f"{DOMAIN}_{package_id}"
-        self._attr_name = f"{package_id} update"
-
-    @property
-    def _pkg(self) -> Package | None:
-        return self.store.packages.get(self.package_id)
-
-    @property
-    def title(self) -> str | None:
-        pkg = self._pkg
-        return pkg.name if pkg else None
-
-    @property
-    def installed_version(self) -> str | None:
-        pkg = self._pkg
-        if not pkg:
-            return None
-        if not self.store.is_installed(pkg.domain):
-            return None
-        return self.store.installed_version(pkg.domain)
-
-    @property
-    def latest_version(self) -> str | None:
-        pkg = self._pkg
-        return pkg.latest_version if pkg else None
-
-    @property
-    def release_summary(self) -> str | None:
-        pkg = self._pkg
-        if not pkg:
-            return None
-        if pkg.release_url:
-            return f"Release: {pkg.release_url}"
-        return f"Repo: {pkg.repo}"
-
-    async def async_install(self, version: str | None, backup: bool, **kwargs) -> None:
-        pkg = self._pkg
-        if not pkg:
+    """Set up BCS update entities."""
+    core: BCSCore | None = hass.data.get(DOMAIN)
+    if not core:
+        _LOGGER.debug("BCS core not available, skipping update platform setup")
         return
-        await self.store.install_from_zip(pkg)
-        self.async_write_ha_state()
+
+    entities: dict[str, BCSRepoUpdateEntity] = {}
+
+    _sync_entities(core, entities, async_add_entities)
+
+    @callback
+    def _handle_update() -> None:
+        _sync_entities(core, entities, async_add_entities)
+
+    async_dispatcher_connect(hass, SIGNAL_UPDATED, _handle_update)

custom_components/bahmcloud_store/views.py

@@ -0,0 +1,372 @@
+from __future__ import annotations
+
+import base64
+import logging
+from dataclasses import asdict
+from pathlib import Path
+from typing import Any, TYPE_CHECKING
+
+from aiohttp import web
+from homeassistant.components.http import HomeAssistantView
+
+if TYPE_CHECKING:
+    from .core import BCSCore  # typing only
+
+_LOGGER = logging.getLogger(__name__)
+
+
+def _render_markdown_server_side(md: str) -> str | None:
+    text = (md or "").strip()
+    if not text:
+        return None
+
+    html: str | None = None
+
+    try:
+        import markdown as mdlib  # type: ignore
+
+        html = mdlib.markdown(
+            text,
+            extensions=["fenced_code", "tables", "sane_lists", "toc"],
+            output_format="html5",
+        )
+    except Exception as e:
+        _LOGGER.debug("python-markdown render failed: %s", e)
+        html = None
+
+    if not html:
+        return None
+
+    try:
+        import bleach  # type: ignore
+
+        allowed_tags = [
+            "p",
+            "br",
+            "hr",
+            "div",
+            "span",
+            "blockquote",
+            "pre",
+            "code",
+            "h1",
+            "h2",
+            "h3",
+            "h4",
+            "h5",
+            "h6",
+            "ul",
+            "ol",
+            "li",
+            "strong",
+            "em",
+            "b",
+            "i",
+            "u",
+            "s",
+            "a",
+            "img",
+            "table",
+            "thead",
+            "tbody",
+            "tr",
+            "th",
+            "td",
+        ]
+
+        allowed_attrs = {
+            "a": ["href", "title", "target", "rel"],
+            "img": ["src", "alt", "title"],
+            "th": ["align"],
+            "td": ["align"],
+            "*": ["class"],
+        }
+
+        sanitized = bleach.clean(
+            html,
+            tags=allowed_tags,
+            attributes=allowed_attrs,
+            protocols=["http", "https", "mailto"],
+            strip=True,
+        )
+
+        sanitized = sanitized.replace(
+            '<a href="',
+            '<a rel="noreferrer noopener" target="_blank" href="',
+        )
+        return sanitized
+
+    except Exception as e:
+        _LOGGER.debug("bleach sanitize failed/unavailable: %s", e)
+
+    return html
+
+
+_TEXT_KEYS = ("readme", "markdown", "text", "content", "data", "body")
+
+
+def _maybe_decode_base64(content: str, encoding: Any) -> str | None:
+    if not isinstance(content, str):
+        return None
+    enc = ""
+    if isinstance(encoding, str):
+        enc = encoding.strip().lower()
+    if "base64" not in enc:
+        return None
+    try:
+        raw = base64.b64decode(content.encode("utf-8"), validate=False)
+        return raw.decode("utf-8", errors="replace")
+    except Exception:
+        return None
+
+
+def _extract_text_recursive(obj: Any, depth: int = 0) -> str | None:
+    if obj is None:
+        return None
+
+    if isinstance(obj, bytes):
+        try:
+            return obj.decode("utf-8", errors="replace")
+        except Exception:
+            return None
+
+    if isinstance(obj, str):
+        return obj
+
+    if depth > 8:
+        return None
+
+    if isinstance(obj, dict):
+        content = obj.get("content")
+        encoding = obj.get("encoding")
+
+        decoded = _maybe_decode_base64(content, encoding)
+        if decoded:
+            return decoded
+
+        if isinstance(content, str) and (not isinstance(encoding, str) or not encoding.strip()):
+            return content
+
+        for k in _TEXT_KEYS:
+            v = obj.get(k)
+            if isinstance(v, str):
+                return v
+            if isinstance(v, bytes):
+                try:
+                    return v.decode("utf-8", errors="replace")
+                except Exception:
+                    pass
+
+        for v in obj.values():
+            out = _extract_text_recursive(v, depth + 1)
+            if out:
+                return out
+
+        return None
+
+    if isinstance(obj, list):
+        for item in obj:
+            out = _extract_text_recursive(item, depth + 1)
+            if out:
+                return out
+        return None
+
+    return None
+
+
+class StaticAssetsView(HomeAssistantView):
+    url = "/api/bahmcloud_store_static/{path:.*}"
+    name = "api:bahmcloud_store_static"
+    requires_auth = False
+
+    async def get(self, request: web.Request, path: str) -> web.StreamResponse:
+        base = Path(__file__).resolve().parent / "panel"
+        base_resolved = base.resolve()
+
+        req_path = (path or "").lstrip("/")
+        if req_path == "":
+            req_path = "index.html"
+
+        target = (base / req_path).resolve()
+
+        if not str(target).startswith(str(base_resolved)):
+            return web.Response(status=404)
+
+        if target.is_dir():
+            target = (target / "index.html").resolve()
+
+        if not target.exists():
+            _LOGGER.error("BCS static asset not found: %s", target)
+            return web.Response(status=404)
+
+        resp = web.FileResponse(path=target)
+        resp.headers["Cache-Control"] = "no-store, no-cache, must-revalidate, max-age=0"
+        resp.headers["Pragma"] = "no-cache"
+        return resp
+
+
+class BCSApiView(HomeAssistantView):
+    url = "/api/bcs"
+    name = "api:bcs"
+    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, "version": self.core.version, "repos": self.core.list_repos_public()}
+        )
+
+    async def post(self, request: web.Request) -> web.Response:
+        action = request.query.get("action")
+        if action == "refresh":
+            _LOGGER.info("BCS manual refresh triggered via API")
+            try:
+                await self.core.full_refresh(source="manual")
+                return web.json_response({"ok": True})
+            except Exception as e:
+                _LOGGER.error("BCS manual refresh failed: %s", e)
+                return web.json_response({"ok": False, "message": "Refresh failed"}, status=500)
+
+        try:
+            data = await request.json()
+        except Exception:
+            data = {}
+
+        op = data.get("op")
+
+        if op == "add_custom_repo":
+            url = str(data.get("url") or "").strip()
+            name = data.get("name")
+            name = str(name).strip() if name else None
+            if not url:
+                return web.json_response({"ok": False, "message": "Missing url"}, status=400)
+            repo = await self.core.add_custom_repo(url=url, name=name)
+            return web.json_response({"ok": True, "repo": asdict(repo)})
+
+        return web.json_response({"ok": False, "message": "Unknown operation"}, status=400)
+
+
+class BCSCustomRepoView(HomeAssistantView):
+    url = "/api/bcs/custom_repo"
+    name = "api:bcs_custom_repo"
+    requires_auth = True
+
+    def __init__(self, core: Any) -> None:
+        self.core: BCSCore = core
+
+    async def delete(self, request: web.Request) -> web.Response:
+        repo_id = request.query.get("id")
+        if not repo_id:
+            return web.json_response({"ok": False, "message": "Missing id"}, status=400)
+        await self.core.remove_custom_repo(repo_id)
+        return web.json_response({"ok": True})
+
+
+class BCSReadmeView(HomeAssistantView):
+    url = "/api/bcs/readme"
+    name = "api:bcs_readme"
+    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)
+
+        maybe_md = await self.core.fetch_readme_markdown(repo_id)
+
+        md = _extract_text_recursive(maybe_md)
+        if not md or not md.strip():
+            t = type(maybe_md).__name__
+            return web.json_response(
+                {"ok": False, "message": f"README not found or unsupported format (got {t})."},
+                status=404,
+            )
+
+        md_str = str(md)
+        html = _render_markdown_server_side(md_str)
+        return web.json_response({"ok": True, "readme": md_str, "html": html})
+
+
+class BCSInstallView(HomeAssistantView):
+    url = "/api/bcs/install"
+    name = "api:bcs_install"
+    requires_auth = True
+
+    def __init__(self, core: Any) -> None:
+        self.core: BCSCore = core
+
+    async def post(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:
+            result = await self.core.install_repo(repo_id)
+            return web.json_response(result, status=200)
+        except Exception as e:
+            _LOGGER.exception("BCS install failed: %s", e)
+            return web.json_response({"ok": False, "message": str(e) or "Install failed"}, status=500)
+
+
+class BCSUpdateView(HomeAssistantView):
+    url = "/api/bcs/update"
+    name = "api:bcs_update"
+    requires_auth = True
+
+    def __init__(self, core: Any) -> None:
+        self.core: BCSCore = core
+
+    async def post(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:
+            result = await self.core.update_repo(repo_id)
+            return web.json_response(result, status=200)
+        except Exception as e:
+            _LOGGER.exception("BCS update failed: %s", e)
+            return web.json_response({"ok": False, "message": str(e) or "Update failed"}, status=500)
+
+
+class BCSUninstallView(HomeAssistantView):
+    url = "/api/bcs/uninstall"
+    name = "api:bcs_uninstall"
+    requires_auth = True
+
+    def __init__(self, core: Any) -> None:
+        self.core: BCSCore = core
+
+    async def post(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:
+            result = await self.core.uninstall_repo(repo_id)
+            return web.json_response(result, status=200)
+        except Exception as e:
+            _LOGGER.exception("BCS uninstall failed: %s", e)
+            return web.json_response({"ok": False, "message": str(e) or "Uninstall failed"}, status=500)
+
+
+class BCSRestartView(HomeAssistantView):
+    url = "/api/bcs/restart"
+    name = "api:bcs_restart"
+    requires_auth = True
+
+    def __init__(self, core: Any) -> None:
+        self.core: BCSCore = core
+
+    async def post(self, request: web.Request) -> web.Response:
+        try:
+            await self.core.request_restart()
+            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)