Add 0.5.2

revert custom_components/bahmcloud_store/core.py aktualisiert

CHANGELOG.md

@@ -11,6 +11,34 @@ Sections:
 
 ---
 
+## [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.

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: Store
+
+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,10 +4,8 @@ import logging
 from datetime import timedelta
 
 from homeassistant.core import HomeAssistant
-from homeassistant.const import Platform
-from homeassistant.helpers.discovery import async_load_platform
-from homeassistant.helpers.event import async_track_time_interval
 from homeassistant.components.panel_custom import async_register_panel
+from homeassistant.helpers.event import async_track_time_interval
 
 from .core import BCSCore, BCSConfig, BCSError
 
@@ -20,20 +18,38 @@ 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)
 
     core = BCSCore(hass, BCSConfig(store_url=store_url))
     hass.data[DOMAIN] = core
 
-    await core.register_http_views()
+    await core.async_initialize()
+
+    from .views import (
+        StaticAssetsView,
+        BCSApiView,
+        BCSReadmeView,
+        BCSCustomRepoView,
+        BCSInstallView,
+        BCSUpdateView,
+        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(BCSRestartView(core))
 
-    # RESTORE: keep the module_url pattern that worked for you
     await async_register_panel(
         hass,
         frontend_url_path="bahmcloud-store",
         webcomponent_name="bahmcloud-store-panel",
-        module_url="/api/bahmcloud_store_static/panel.js?v=42",
+        # IMPORTANT: bump v to avoid caching old JS
+        module_url="/api/bahmcloud_store_static/panel.js?v=101",
         sidebar_title="Bahmcloud Store",
         sidebar_icon="mdi:store",
         require_admin=True,
@@ -41,19 +57,19 @@ async def async_setup(hass: HomeAssistant, config: dict) -> bool:
     )
 
     try:
-        await core.refresh()
+        await core.full_refresh(source="startup")
     except BCSError as e:
         _LOGGER.error("Initial refresh failed: %s", e)
 
     async def periodic(_now) -> None:
         try:
-            await core.refresh()
+            await core.full_refresh(source="timer")
-            core.signal_updated()
         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)
 
-    interval = timedelta(seconds=int(core.refresh_seconds or 300))
+    interval_seconds = int(getattr(core, "refresh_seconds", 300) or 300)
-    async_track_time_interval(hass, periodic, interval)
+    async_track_time_interval(hass, periodic, timedelta(seconds=interval_seconds))
 
-    await async_load_platform(hass, Platform.UPDATE, DOMAIN, {}, config)
     return True

custom_components/bahmcloud_store/core.py

@@ -1,20 +1,24 @@
 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 urlparse
+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.components import persistent_notification
 from homeassistant.util import yaml as ha_yaml
 
 from .storage import BCSStorage, CustomRepo
-from .views import StaticAssetsView, BCSApiView, BCSReadmeView
-from .custom_repo_view import BCSCustomRepoView
 from .providers import fetch_repo_info, detect_provider, RepoInfo, fetch_readme_markdown
 from .metadata import fetch_repo_metadata, RepoMetadata
 
@@ -27,6 +31,10 @@ class BCSError(Exception):
     """BCS core error."""
 
 
+class BCSInstallError(BCSError):
+    """BCS installation/update error."""
+
+
 @dataclass
 class BCSConfig:
     store_url: str
@@ -66,9 +74,25 @@ class BCSCore:
         self.repos: dict[str, RepoItem] = {}
         self._listeners: list[callable] = []
 
-        self.version: str = self._read_manifest_version()
+        # Will be loaded asynchronously (no blocking IO in event loop)
+        self.version: str = "unknown"
 
-    def _read_manifest_version(self) -> str:
+        # 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()
+
+    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"))
@@ -77,6 +101,8 @@ class BCSCore:
             except Exception:
                 return "unknown"
 
+        return await self.hass.async_add_executor_job(_read)
+
     def add_listener(self, cb) -> None:
         self._listeners.append(cb)
 
@@ -87,11 +113,11 @@ class BCSCore:
             except Exception:
                 pass
 
-    async def register_http_views(self) -> None:
+    async def full_refresh(self, source: str = "manual") -> None:
-        self.hass.http.register_view(StaticAssetsView())
+        """Single refresh entry-point used by both timer and manual button."""
-        self.hass.http.register_view(BCSApiView(self))
+        _LOGGER.info("BCS full refresh triggered (source=%s)", source)
-        self.hass.http.register_view(BCSReadmeView(self))
+        await self.refresh()
-        self.hass.http.register_view(BCSCustomRepoView(self))
+        self.signal_updated()
 
     def get_repo(self, repo_id: str) -> RepoItem | None:
         return self.repos.get(repo_id)
@@ -121,6 +147,13 @@ class BCSCore:
         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)
 
@@ -155,16 +188,72 @@ class BCSCore:
 
         await asyncio.gather(*(process_one(r) for r in merged.values()), return_exceptions=True)
 
-    async def _load_index_repos(self) -> tuple[list[RepoItem], int]:
+    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)
-        try:
+
-            async with session.get(self.config.store_url, timeout=20) as resp:
+        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}")
-                raw = await resp.text()
+            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):
@@ -179,20 +268,21 @@ class BCSCore:
             for i, r in enumerate(repos):
                 if not isinstance(r, dict):
                     continue
-                url = str(r.get("url", "")).strip()
+                repo_url = str(r.get("url", "")).strip()
-                if not url:
+                if not repo_url:
                     continue
-                name = str(r.get("name") or url).strip()
+                name = str(r.get("name") or repo_url).strip()
 
                 items.append(
                     RepoItem(
                         id=f"index:{i}",
                         name=name,
-                        url=url,
+                        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
@@ -203,21 +293,42 @@ class BCSCore:
             raise BCSError("Missing url")
 
         c = await self.storage.add_custom_repo(url, name)
-        await self.refresh()
+        await self.full_refresh(source="custom_repo_add")
-        self.signal_updated()
         return c
 
     async def remove_custom_repo(self, repo_id: str) -> None:
         await self.storage.remove_custom_repo(repo_id)
-        await self.refresh()
+        await self.full_refresh(source="custom_repo_remove")
-        self.signal_updated()
 
     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()]
+
+                # IMPORTANT: this is the ref we installed (tag/release/branch)
+                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,
@@ -235,6 +346,10 @@ class BCSCore:
                     "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
@@ -250,3 +365,219 @@ class BCSCore:
             provider=repo.provider,
             default_branch=repo.default_branch,
         )
+
+    def _pick_ref_for_install(self, repo: RepoItem) -> str:
+        # Prefer latest_version (release/tag/atom-derived), fallback to default branch, then main.
+        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:
+        """Build a public ZIP download URL (provider-neutral, no tokens).
+
+        Supports:
+        - GitHub: codeload
+        - GitLab: /-/archive/
+        - Gitea (incl. Bahmcloud): /archive/<ref>.zip
+        """
+        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:
+        try:
+            items = await self.storage.list_installed_repos()
+            cache: dict[str, Any] = {}
+            for it in items:
+                cache[it.repo_id] = {
+                    "domains": it.domains,
+                    "installed_version": it.installed_version,  # BCS ref
+                    "installed_manifest_version": it.installed_manifest_version,
+                    "ref": it.ref,
+                    "installed_at": it.installed_at,
+                }
+            self._installed_cache = cache
+        except Exception:
+            self._installed_cache = {}
+
+    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)")
+
+            # informational only (many repos are wrong here)
+            installed_manifest_version = await self._read_installed_manifest_version(installed_domains[0])
+
+            # IMPORTANT: BCS "installed_version" is the ref we installed (tag/release/branch),
+            # so update logic won't break when manifest.json is 0.0.0 or outdated.
+            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()
+
+            persistent_notification.async_create(
+                self.hass,
+                "Bahmcloud Store installation finished. A Home Assistant restart is required to load the integration.",
+                title="Bahmcloud Store",
+                notification_id="bcs_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/manifest.json

@@ -1,7 +1,7 @@
 {
   "domain": "bahmcloud_store",
   "name": "Bahmcloud Store",
-  "version": "0.4.1",
+  "version": "0.5.2",
   "documentation": "https://git.bahmcloud.de/bahmcloud/bahmcloud_store",
   "requirements": [],
   "codeowners": ["@bahmcloud"],

custom_components/bahmcloud_store/providers.py

@@ -6,6 +6,8 @@ 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
 
@@ -97,6 +99,36 @@ def _extract_meta(html: str, *, prop: str | None = None, name: str | None = None
     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}"
@@ -165,12 +197,22 @@ async def _github_latest_version_api(hass: HomeAssistant, owner: str, repo: str)
     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=1", headers=headers)
+        data, _ = await _safe_json(session, f"https://api.github.com/repos/{owner}/{repo}/tags?per_page=100", headers=headers)
-        if isinstance(data, list) and data:
+        tags: list[str] = []
-            t = data[0]
+        if isinstance(data, list):
+            for t in data:
                 if isinstance(t, dict) and t.get("name"):
-                return str(t["name"]), "tag"
+                    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
 
@@ -190,17 +232,33 @@ async def _github_latest_version(hass: HomeAssistant, owner: str, repo: str) ->
 async def _gitea_latest_version(hass: HomeAssistant, base: str, owner: str, repo: str) -> tuple[str | None, str | None]:
     session = async_get_clientsession(hass)
 
-    data, _ = await _safe_json(session, f"{base}/api/v1/repos/{owner}/{repo}/releases?limit=1")
+    # releases: fetch multiple, pick highest semver (instead of limit=1)
-    if isinstance(data, list) and data:
+    data, _ = await _safe_json(session, f"{base}/api/v1/repos/{owner}/{repo}/releases?limit=50")
-        r = data[0]
+    rel_tags: list[str] = []
+    if isinstance(data, list):
+        for r in data:
             if isinstance(r, dict) and r.get("tag_name"):
-            return str(r["tag_name"]), "release"
+                rel_tags.append(str(r["tag_name"]))
 
-    data, _ = await _safe_json(session, f"{base}/api/v1/repos/{owner}/{repo}/tags?limit=1")
+    best_rel = _pick_highest_semver(rel_tags)
-    if isinstance(data, list) and data:
+    if best_rel:
-        t = data[0]
+        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"):
-            return str(t["name"]), "tag"
+                tags.append(str(t["name"]))
+
+    best = _pick_highest_semver(tags)
+    if best:
+        return best, "tag"
+    if tags:
+        return tags[0], "tag"
 
     return None, None
 
@@ -213,18 +271,35 @@ async def _gitlab_latest_version(
 
     project = quote_plus(f"{owner}/{repo}")
 
-    data, _ = await _safe_json(session, f"{base}/api/v4/projects/{project}/releases?per_page=1", headers=headers)
+    # releases: fetch multiple, pick highest semver (instead of per_page=1)
-    if isinstance(data, list) and data:
+    data, _ = await _safe_json(session, f"{base}/api/v4/projects/{project}/releases?per_page=50", headers=headers)
-        r = data[0]
+    rel_tags: list[str] = []
+    if isinstance(data, list):
+        for r in data:
             if isinstance(r, dict) and r.get("tag_name"):
-            return str(r["tag_name"]), "release"
+                rel_tags.append(str(r["tag_name"]))
 
-    data, _ = await _safe_json(session, f"{base}/api/v4/projects/{project}/repository/tags?per_page=1", headers=headers)
+    best_rel = _pick_highest_semver(rel_tags)
-    if isinstance(data, list) and data:
+    if best_rel:
-        t = data[0]
+        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"):
-            return str(t["name"]), "tag"
+                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:

custom_components/bahmcloud_store/storage.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import time
 import uuid
 from dataclasses import dataclass
 from typing import Any
@@ -18,19 +19,40 @@ class CustomRepo:
     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 manually added repositories."""
+    """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(hass, _STORAGE_VERSION, _STORAGE_KEY)
+        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()
+        data = await self._store.async_load() or {}
-        if not data:
+        if not isinstance(data, dict):
-            return {"custom_repos": []}
+            data = {}
-        if "custom_repos" not in 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:
@@ -43,24 +65,20 @@ class BCSStorage:
         for r in repos:
             if not isinstance(r, dict):
                 continue
-            rid = str(r.get("id") or "")
+            rid = r.get("id")
-            url = str(r.get("url") or "")
+            url = r.get("url")
-            name = r.get("name")
+            if not rid or not url:
-            if rid and url:
+                continue
-                out.append(CustomRepo(id=rid, url=url, name=str(name) if name else None))
+            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", [])
 
-        # Deduplicate by URL
+        # De-duplicate by URL
         for r in repos:
-            if isinstance(r, dict) and str(r.get("url", "")).strip() == url.strip():
+            if isinstance(r, dict) and str(r.get("url") or "").strip() == url.strip():
-                # Update name if provided
-                if name:
-                    r["name"] = name
-                    await self._save(data)
                 return CustomRepo(id=str(r["id"]), url=str(r["url"]), name=r.get("name"))
 
         rid = f"custom:{uuid.uuid4().hex[:10]}"
@@ -73,6 +91,94 @@ class BCSStorage:
     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)]
+        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/views.py

@@ -16,14 +16,12 @@ _LOGGER = logging.getLogger(__name__)
 
 
 def _render_markdown_server_side(md: str) -> str | None:
-    """Render Markdown -> sanitized HTML (server-side)."""
     text = (md or "").strip()
     if not text:
         return None
 
     html: str | None = None
 
-    # 1) python-markdown
     try:
         import markdown as mdlib  # type: ignore
 
@@ -39,7 +37,6 @@ def _render_markdown_server_side(md: str) -> str | None:
     if not html:
         return None
 
-    # 2) Sanitize via bleach
     try:
         import bleach  # type: ignore
 
@@ -124,16 +121,6 @@ def _maybe_decode_base64(content: str, encoding: Any) -> str | None:
 
 
 def _extract_text_recursive(obj: Any, depth: int = 0) -> str | None:
-    """
-    Robust extraction for README markdown.
-
-    Handles:
-    - str / bytes
-    - dict with:
-        - {content: "...", encoding: "base64"} (possibly nested)
-        - {readme: "..."} etc.
-    - list of dicts (pick first matching)
-    """
     if obj is None:
         return None
 
@@ -150,21 +137,16 @@ def _extract_text_recursive(obj: Any, depth: int = 0) -> str | None:
         return None
 
     if isinstance(obj, dict):
-        # 1) If it looks like "file content"
         content = obj.get("content")
         encoding = obj.get("encoding")
 
-        # Base64 decode if possible
         decoded = _maybe_decode_base64(content, encoding)
         if decoded:
             return decoded
 
-        # content may already be plain text
         if isinstance(content, str) and (not isinstance(encoding, str) or not encoding.strip()):
-            # Heuristic: treat as markdown if it has typical markdown chars, otherwise still return
             return content
 
-        # 2) direct text keys (readme/markdown/text/body/data)
         for k in _TEXT_KEYS:
             v = obj.get(k)
             if isinstance(v, str):
@@ -175,7 +157,6 @@ def _extract_text_recursive(obj: Any, depth: int = 0) -> str | None:
                 except Exception:
                     pass
 
-        # 3) Sometimes nested under "file" / "result" / "payload" etc.
         for v in obj.values():
             out = _extract_text_recursive(v, depth + 1)
             if out:
@@ -198,7 +179,7 @@ class StaticAssetsView(HomeAssistantView):
     name = "api:bahmcloud_store_static"
     requires_auth = False
 
-    async def get(self, request: web.Request, path: str) -> web.Response:
+    async def get(self, request: web.Request, path: str) -> web.StreamResponse:
         base = Path(__file__).resolve().parent / "panel"
         base_resolved = base.resolve()
 
@@ -218,24 +199,7 @@ class StaticAssetsView(HomeAssistantView):
             _LOGGER.error("BCS static asset not found: %s", target)
             return web.Response(status=404)
 
-        content_type = "text/plain"
+        resp = web.FileResponse(path=target)
-        charset = None
-
-        if target.suffix == ".js":
-            content_type = "application/javascript"
-            charset = "utf-8"
-        elif target.suffix == ".html":
-            content_type = "text/html"
-            charset = "utf-8"
-        elif target.suffix == ".css":
-            content_type = "text/css"
-            charset = "utf-8"
-        elif target.suffix == ".svg":
-            content_type = "image/svg+xml"
-        elif target.suffix == ".png":
-            content_type = "image/png"
-
-        resp = web.Response(body=target.read_bytes(), content_type=content_type, charset=charset)
         resp.headers["Cache-Control"] = "no-store, no-cache, must-revalidate, max-age=0"
         resp.headers["Pragma"] = "no-cache"
         return resp
@@ -247,7 +211,7 @@ class BCSApiView(HomeAssistantView):
     requires_auth = True
 
     def __init__(self, core: Any) -> None:
-        self.core = core
+        self.core: BCSCore = core
 
     async def get(self, request: web.Request) -> web.Response:
         return web.json_response(
@@ -255,7 +219,21 @@ class BCSApiView(HomeAssistantView):
         )
 
     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":
@@ -276,7 +254,7 @@ class BCSCustomRepoView(HomeAssistantView):
     requires_auth = True
 
     def __init__(self, core: Any) -> None:
-        self.core = core
+        self.core: BCSCore = core
 
     async def delete(self, request: web.Request) -> web.Response:
         repo_id = request.query.get("id")
@@ -292,7 +270,7 @@ class BCSReadmeView(HomeAssistantView):
     requires_auth = True
 
     def __init__(self, core: Any) -> None:
-        self.core = core
+        self.core: BCSCore = core
 
     async def get(self, request: web.Request) -> web.Response:
         repo_id = request.query.get("repo_id")
@@ -309,8 +287,65 @@ class BCSReadmeView(HomeAssistantView):
                 status=404,
             )
 
-        # Ensure strict JSON string output (avoid accidental objects)
         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 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)