0.6.0

CHANGELOG.md

@@ -11,6 +11,29 @@ Sections:
 
 ---
 
+## [0.6.0] - 2026-01-18
+
+### Added
+- Restore feature with selection of the last available backups (up to 5 per domain).
+- New API endpoints to list and restore backups:
+  - `GET /api/bcs/backups?repo_id=...`
+  - `POST /api/bcs/restore?repo_id=...&backup_id=...`
+
+### Safety
+- Restoring a backup triggers a “restart required” prompt to apply the recovered integration state.
+
+### Notes
+- This is a major release milestone consolidating install/update/uninstall, backup/rollback, and restore workflows.
+
+## [0.5.11] - 2026-01-18
+
+### Added
+- Automatic backup of existing custom components before install or update.
+- Backup retention with a configurable limit per domain.
+
+### Safety
+- Automatic rollback is triggered if an install or update fails after a backup was created.
+
 ## [0.5.10] - 2026-01-17
 
 ### Added

custom_components/bahmcloud_store/__init__.py

@@ -39,6 +39,8 @@ async def async_setup(hass: HomeAssistant, config: dict) -> bool:
         BCSInstallView,
         BCSUpdateView,
         BCSUninstallView,
+        BCSBackupsView,
+        BCSRestoreView,
         BCSRestartView,
     )
 
@@ -49,6 +51,8 @@ async def async_setup(hass: HomeAssistant, config: dict) -> bool:
     hass.http.register_view(BCSInstallView(core))
     hass.http.register_view(BCSUpdateView(core))
     hass.http.register_view(BCSUninstallView(core))
+    hass.http.register_view(BCSBackupsView(core))
+    hass.http.register_view(BCSRestoreView(core))
     hass.http.register_view(BCSRestartView(core))
 
     await async_register_panel(
@@ -56,7 +60,7 @@ async def async_setup(hass: HomeAssistant, config: dict) -> bool:
         frontend_url_path="bahmcloud-store",
         webcomponent_name="bahmcloud-store-panel",
         # IMPORTANT: bump v to avoid caching old JS
-        module_url="/api/bahmcloud_store_static/panel.js?v=102",
+        module_url="/api/bahmcloud_store_static/panel.js?v=103",
         sidebar_title="Bahmcloud Store",
         sidebar_icon="mdi:store",
         require_admin=True,

custom_components/bahmcloud_store/core.py

@@ -90,6 +90,10 @@ class BCSCore:
         self._install_lock = asyncio.Lock()
         self._installed_cache: dict[str, Any] = {}
 
+        # Phase F2: backups before install/update
+        self._backup_root = Path(self.hass.config.path(".bcs_backups"))
+        self._backup_keep_per_domain: int = 5
+
     async def async_initialize(self) -> None:
         """Async initialization that avoids blocking file IO."""
         self.version = await self._read_manifest_version_async()
@@ -482,6 +486,189 @@ class BCSCore:
                 return candidate
         return None
 
+    async def _ensure_backup_root(self) -> None:
+        """Create backup root directory if needed."""
+        def _mkdir() -> None:
+            self._backup_root.mkdir(parents=True, exist_ok=True)
+
+        await self.hass.async_add_executor_job(_mkdir)
+
+    async def _backup_domain(self, domain: str) -> Path | None:
+        """Backup an existing domain folder.
+
+        Returns the created backup path, or None if the domain folder does not exist.
+        """
+        dest_root = Path(self.hass.config.path("custom_components"))
+        target = dest_root / domain
+
+        if not target.exists() or not target.is_dir():
+            return None
+
+        await self._ensure_backup_root()
+
+        ts = time.strftime("%Y%m%d_%H%M%S")
+        domain_root = self._backup_root / domain
+        backup_path = domain_root / ts
+
+        def _do_backup() -> None:
+            domain_root.mkdir(parents=True, exist_ok=True)
+            if backup_path.exists():
+                shutil.rmtree(backup_path, ignore_errors=True)
+            shutil.copytree(target, backup_path, dirs_exist_ok=True)
+
+            # Retention: keep only the newest N backups per domain.
+            try:
+                backups = [p for p in domain_root.iterdir() if p.is_dir()]
+                backups.sort(key=lambda p: p.name, reverse=True)
+                for old in backups[self._backup_keep_per_domain :]:
+                    shutil.rmtree(old, ignore_errors=True)
+            except Exception:
+                # Never fail install/update because of retention cleanup.
+                pass
+
+        await self.hass.async_add_executor_job(_do_backup)
+        _LOGGER.info("BCS backup created: domain=%s path=%s", domain, backup_path)
+        return backup_path
+
+    async def _restore_domain_from_backup(self, domain: str, backup_path: Path) -> None:
+        """Restore a domain folder from a backup."""
+        dest_root = Path(self.hass.config.path("custom_components"))
+        target = dest_root / domain
+
+        def _restore() -> None:
+            if not backup_path.exists() or not backup_path.is_dir():
+                return
+            if target.exists():
+                shutil.rmtree(target, ignore_errors=True)
+            shutil.copytree(backup_path, target, dirs_exist_ok=True)
+
+        await self.hass.async_add_executor_job(_restore)
+        _LOGGER.info("BCS rollback applied: domain=%s from=%s", domain, backup_path)
+
+    async def list_repo_backups(self, repo_id: str) -> list[dict[str, Any]]:
+        """List available backup sets for an installed repository.
+
+        Returns a list of items sorted newest->oldest:
+        {"id": "YYYYMMDD_HHMMSS", "label": "YYYY-MM-DD HH:MM:SS", "complete": bool, "domains": [...] }
+
+        A backup set is considered *complete* if the timestamp exists for all
+        domains of the repository.
+        """
+        inst = self.get_installed(repo_id) or {}
+        domains = inst.get("domains") or []
+        if not isinstance(domains, list) or not domains:
+            return []
+
+        dom_list = [str(d) for d in domains if str(d).strip()]
+        if not dom_list:
+            return []
+
+        # Collect timestamps per domain.
+        per_domain: dict[str, list[str]] = {}
+        for d in dom_list:
+            per_domain[d] = await self._list_domain_backup_ids(d)
+
+        # Build a map id -> domains where it exists
+        id_map: dict[str, set[str]] = {}
+        for d, ids in per_domain.items():
+            for bid in ids:
+                id_map.setdefault(bid, set()).add(d)
+
+        all_domains = set(dom_list)
+        items: list[dict[str, Any]] = []
+        for bid, present in id_map.items():
+            complete = present == all_domains
+            label = self._format_backup_id(bid)
+            items.append({"id": bid, "label": label, "complete": complete, "domains": sorted(present)})
+
+        # Sort newest first by id (lexicographic works for timestamp format).
+        items.sort(key=lambda x: str(x.get("id") or ""), reverse=True)
+
+        # Keep newest 5 entries overall (UI expects up to 5).
+        return items[: self._backup_keep_per_domain]
+
+    async def restore_repo_backup(self, repo_id: str, backup_id: str) -> dict[str, Any]:
+        """Restore a previously created backup set for a repository."""
+        repo_id = str(repo_id or "").strip()
+        backup_id = str(backup_id or "").strip()
+        if not repo_id:
+            raise BCSInstallError("Missing repo_id")
+        if not backup_id:
+            raise BCSInstallError("Missing backup_id")
+
+        inst = self.get_installed(repo_id)
+        if not inst:
+            raise BCSInstallError("Repository is not installed")
+
+        domains = inst.get("domains") or []
+        if not isinstance(domains, list) or not domains:
+            raise BCSInstallError("No installed domains found")
+
+        dom_list = [str(d) for d in domains if str(d).strip()]
+        if not dom_list:
+            raise BCSInstallError("No installed domains found")
+
+        # Ensure the backup exists for all domains.
+        missing: list[str] = []
+        for d in dom_list:
+            p = self._backup_root / d / backup_id
+            if not p.exists() or not p.is_dir():
+                missing.append(d)
+        if missing:
+            raise BCSInstallError(f"Selected backup is not available for all domains: missing={missing}")
+
+        async with self._install_lock:
+            _LOGGER.info("BCS restore started: repo_id=%s backup_id=%s domains=%s", repo_id, backup_id, dom_list)
+
+            # Safety: create a new backup of current state before restoring.
+            for d in dom_list:
+                try:
+                    await self._backup_domain(d)
+                except Exception:
+                    _LOGGER.debug("BCS pre-restore backup failed for domain=%s", d, exc_info=True)
+
+            # Apply restore.
+            for d in dom_list:
+                await self._restore_domain_from_backup(d, self._backup_root / d / backup_id)
+
+            await self._refresh_installed_cache()
+            self._mark_restart_required()
+            self.signal_updated()
+
+            _LOGGER.info("BCS restore complete: repo_id=%s backup_id=%s", repo_id, backup_id)
+            return {"ok": True, "repo_id": repo_id, "backup_id": backup_id, "domains": dom_list, "restart_required": True}
+
+    async def _list_domain_backup_ids(self, domain: str) -> list[str]:
+        """List backup ids for a domain (newest->oldest)."""
+        domain = str(domain or "").strip()
+        if not domain:
+            return []
+
+        root = self._backup_root / domain
+
+        def _list() -> list[str]:
+            if not root.exists() or not root.is_dir():
+                return []
+            ids = [p.name for p in root.iterdir() if p.is_dir()]
+            ids.sort(reverse=True)
+            return ids
+
+        ids = await self.hass.async_add_executor_job(_list)
+        return ids[: self._backup_keep_per_domain]
+
+    @staticmethod
+    def _format_backup_id(backup_id: str) -> str:
+        """Format backup id YYYYMMDD_HHMMSS -> YYYY-MM-DD HH:MM:SS."""
+        s = str(backup_id or "").strip()
+        if len(s) != 15 or "_" not in s:
+            return s
+        try:
+            d, t = s.split("_", 1)
+            return f"{d[0:4]}-{d[4:6]}-{d[6:8]} {t[0:2]}:{t[2:4]}:{t[4:6]}"
+        except Exception:
+            return s
+
+
     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
@@ -613,6 +800,11 @@ class BCSCore:
 
             _LOGGER.info("BCS install started: repo_id=%s ref=%s zip_url=%s", repo_id, ref, zip_url)
 
+            installed_domains: list[str] = []
+            backups: dict[str, Path] = {}
+            created_new: set[str] = set()
+
+            try:
                 with tempfile.TemporaryDirectory(prefix="bcs_install_") as td:
                     tmp = Path(td)
                     zip_path = tmp / "repo.zip"
@@ -626,7 +818,8 @@ class BCSCore:
                     if not cc_root:
                         raise BCSInstallError("custom_components folder not found in repository ZIP")
 
-                installed_domains: list[str] = []
+                    dest_root = Path(self.hass.config.path("custom_components"))
+
                     for domain_dir in cc_root.iterdir():
                         if not domain_dir.is_dir():
                             continue
@@ -635,6 +828,16 @@ class BCSCore:
                             continue
 
                         domain = domain_dir.name
+                        target = dest_root / domain
+
+                        # Backup only if we are going to overwrite an existing domain.
+                        if target.exists() and target.is_dir():
+                            bkp = await self._backup_domain(domain)
+                            if bkp:
+                                backups[domain] = bkp
+                        else:
+                            created_new.add(domain)
+
                         await self._copy_domain_dir(domain_dir, domain)
                         installed_domains.append(domain)
 
@@ -673,6 +876,35 @@ class BCSCore:
                     "restart_required": True,
                 }
 
+            except Exception as e:
+                # Roll back any domains we touched.
+                _LOGGER.error("BCS install failed, attempting rollback: repo_id=%s error=%s", repo_id, e)
+
+                dest_root = Path(self.hass.config.path("custom_components"))
+
+                # Restore backed-up domains.
+                for domain, bkp in backups.items():
+                    try:
+                        await self._restore_domain_from_backup(domain, bkp)
+                    except Exception:
+                        _LOGGER.debug("BCS rollback failed for domain=%s", domain, exc_info=True)
+
+                # Remove newly created domains if the install did not complete.
+                for domain in created_new:
+                    try:
+                        target = dest_root / domain
+                        def _rm() -> None:
+                            if target.exists() and target.is_dir():
+                                shutil.rmtree(target, ignore_errors=True)
+                        await self.hass.async_add_executor_job(_rm)
+                    except Exception:
+                        _LOGGER.debug("BCS cleanup failed for new domain=%s", domain, exc_info=True)
+
+                # Re-raise as install error for clean API response.
+                if isinstance(e, BCSInstallError):
+                    raise
+                raise BCSInstallError(str(e)) from e
+
     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)

custom_components/bahmcloud_store/manifest.json

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

custom_components/bahmcloud_store/panel/panel.js

@@ -36,6 +36,15 @@ class BahmcloudStorePanel extends HTMLElement {
     this._uninstallingRepoId = null;
     this._restartRequired = false;
     this._lastActionMsg = null;
+
+    // Phase F2.1: restore from backups
+    this._restoreOpen = false;
+    this._restoreRepoId = null;
+    this._restoreLoading = false;
+    this._restoreOptions = [];
+    this._restoreSelected = "";
+    this._restoring = false;
+    this._restoreError = null;
   }
 
   set hass(hass) {
@@ -175,6 +184,90 @@ class BahmcloudStorePanel extends HTMLElement {
     }
   }
 
+
+
+  async _openRestore(repoId) {
+    if (!this._hass) return;
+    if (!repoId) return;
+    if (this._installingRepoId || this._updatingRepoId || this._uninstallingRepoId) return;
+
+    this._restoreRepoId = repoId;
+    this._restoreOpen = true;
+    this._restoreLoading = true;
+    this._restoreError = null;
+    this._restoreOptions = [];
+    this._restoreSelected = "";
+    this._update();
+
+    try {
+      const resp = await this._hass.callApi("get", `bcs/backups?repo_id=${encodeURIComponent(repoId)}`);
+      const list = Array.isArray(resp?.backups) ? resp.backups : [];
+      this._restoreOptions = list;
+      const firstComplete = list.find((x) => x && x.complete);
+      const firstAny = list[0];
+      const pick = firstComplete || firstAny;
+      if (pick && pick.id) this._restoreSelected = String(pick.id);
+
+      if (!list.length) {
+        this._restoreError = "No backups found for this repository.";
+      }
+    } catch (e) {
+      this._restoreError = e?.message ? String(e.message) : String(e);
+    } finally {
+      this._restoreLoading = false;
+      this._update();
+    }
+  }
+
+  _closeRestore() {
+    this._restoreOpen = false;
+    this._restoreRepoId = null;
+    this._restoreLoading = false;
+    this._restoreError = null;
+    this._restoreOptions = [];
+    this._restoreSelected = "";
+    this._restoring = false;
+    this._update();
+  }
+
+  async _restoreSelectedBackup() {
+    if (!this._hass) return;
+    if (!this._restoreRepoId) return;
+    const bid = String(this._restoreSelected || "").trim();
+    if (!bid) return;
+    if (this._restoring) return;
+
+    const chosen = (this._restoreOptions || []).find((x) => String(x?.id) === bid);
+    if (chosen && chosen.complete === false) {
+      this._restoreError = "Selected backup is not available for all domains of this repository.";
+      this._update();
+      return;
+    }
+
+    const ok = window.confirm("Restore selected backup? This will overwrite the installed files under /config/custom_components and requires a restart.");
+    if (!ok) return;
+
+    this._restoring = true;
+    this._restoreError = null;
+    this._update();
+
+    try {
+      const resp = await this._hass.callApi("post", `bcs/restore?repo_id=${encodeURIComponent(this._restoreRepoId)}&backup_id=${encodeURIComponent(bid)}`, {});
+      if (!resp?.ok) {
+        this._restoreError = this._safeText(resp?.message) || "Restore failed.";
+      } else {
+        this._restartRequired = !!resp.restart_required;
+        this._lastActionMsg = "Restore finished. Restart required.";
+        this._closeRestore();
+      }
+    } catch (e) {
+      this._restoreError = e?.message ? String(e.message) : String(e);
+    } finally {
+      this._restoring = false;
+      await this._load();
+    }
+  }
+
   async _restartHA() {
     if (!this._hass) return;
     try {
@@ -413,6 +506,22 @@ class BahmcloudStorePanel extends HTMLElement {
         }
         button:disabled{ opacity: .55; cursor: not-allowed; }
 
+        .modalOverlay{
+          position:fixed; inset:0; z-index:999;
+          background: rgba(0,0,0,0.45);
+          display:flex; align-items:center; justify-content:center;
+          padding:16px;
+        }
+        .modal{
+          width: min(520px, 100%);
+          background: var(--card-background-color);
+          border:1px solid var(--divider-color);
+          border-radius:18px;
+          padding:16px;
+          box-shadow: 0 10px 30px rgba(0,0,0,0.25);
+        }
+        .modalTitle{ font-size:16px; font-weight:700; }
+
         .err{
           margin:12px 0;
           padding:12px 14px;
@@ -617,7 +726,8 @@ class BahmcloudStorePanel extends HTMLElement {
     else if (this._view === "about") html = this._renderAbout();
     else if (this._view === "detail") html = this._renderDetail();
 
-    content.innerHTML = `${err}${html}`;
+    const modal = this._renderRestoreModal();
+    content.innerHTML = `${err}${html}${modal}`;
 
     if (this._view === "store") this._wireStore();
     if (this._view === "manage") this._wireManage();
@@ -625,6 +735,8 @@ class BahmcloudStorePanel extends HTMLElement {
       this._wireDetail(); // now always wires buttons
     }
 
+    this._wireRestoreModal();
+
     // Restore focus and cursor for the search field after re-render.
     if (restore.id && this._view === "store") {
       const el = root.getElementById(restore.id);
@@ -906,6 +1018,7 @@ class BahmcloudStorePanel extends HTMLElement {
     const installBtn = `<button class="primary" id="btnInstall" ${installed || busy ? "disabled" : ""}>${busyInstall ? "Installing…" : installed ? "Installed" : "Install"}</button>`;
     const updateBtn = `<button class="primary" id="btnUpdate" ${!updateAvailable || busy ? "disabled" : ""}>${busyUpdate ? "Updating…" : updateAvailable ? "Update" : "Up to date"}</button>`;
     const uninstallBtn = `<button class="primary" id="btnUninstall" ${!installed || busy ? "disabled" : ""}>${busyUninstall ? "Uninstalling…" : "Uninstall"}</button>`;
+    const restoreBtn = `<button class="primary" id="btnRestore" ${!installed || busy ? "disabled" : ""}>Restore</button>`;
 
     const restartHint = this._restartRequired
       ? `
@@ -958,6 +1071,7 @@ class BahmcloudStorePanel extends HTMLElement {
               ${installBtn}
               ${updateBtn}
               ${uninstallBtn}
+              ${restoreBtn}
             </div>
 
             ${restartHint}
@@ -974,6 +1088,7 @@ class BahmcloudStorePanel extends HTMLElement {
     const btnInstall = root.getElementById("btnInstall");
     const btnUpdate = root.getElementById("btnUpdate");
     const btnUninstall = root.getElementById("btnUninstall");
+    const btnRestore = root.getElementById("btnRestore");
     const btnRestart = root.getElementById("btnRestart");
     const btnReadmeToggle = root.getElementById("btnReadmeToggle");
 
@@ -998,6 +1113,15 @@ class BahmcloudStorePanel extends HTMLElement {
       });
     }
 
+    if (btnRestore) {
+      btnRestore.addEventListener("click", () => {
+        if (btnRestore.disabled) return;
+        if (this._detailRepoId) this._openRestore(this._detailRepoId);
+      });
+    }
+
+    
+
     if (btnRestart) {
       btnRestart.addEventListener("click", () => this._restartHA());
     }
@@ -1024,6 +1148,45 @@ class BahmcloudStorePanel extends HTMLElement {
     }
   }
 
+  _wireRestoreModal() {
+    const root = this.shadowRoot;
+    if (!root) return;
+
+    const overlay = root.getElementById("restoreOverlay");
+    if (!overlay) return;
+
+    // Click outside modal closes it
+    overlay.addEventListener("click", (ev) => {
+      if (ev.target === overlay) this._closeRestore();
+    });
+
+    const sel = root.getElementById("restoreSelect");
+    if (sel) {
+      try {
+        if (this._restoreSelected) sel.value = String(this._restoreSelected);
+      } catch (_) {}
+      sel.addEventListener("change", () => {
+        this._restoreSelected = String(sel.value || "");
+      });
+    }
+
+    const btnCancel = root.getElementById("btnRestoreCancel");
+    if (btnCancel) {
+      btnCancel.addEventListener("click", () => this._closeRestore());
+    }
+
+    const btnApply = root.getElementById("btnRestoreApply");
+    if (btnApply) {
+      btnApply.addEventListener("click", () => {
+        if (btnApply.disabled) return;
+        const v = root.getElementById("restoreSelect")?.value;
+        if (v) this._restoreSelected = String(v);
+        this._restoreSelectedBackup();
+      });
+    }
+  }
+
+
   _postprocessRenderedMarkdown(container) {
     if (!container) return;
     try {
@@ -1036,6 +1199,52 @@ class BahmcloudStorePanel extends HTMLElement {
   }
 
 
+  _renderRestoreModal() {
+    if (!this._restoreOpen) return "";
+
+    const opts = Array.isArray(this._restoreOptions) ? this._restoreOptions : [];
+    const disabled = this._restoreLoading || this._restoring || !opts.length;
+
+    const optionsHtml = opts
+      .map((o) => {
+        const id = this._safeText(o?.id) || "";
+        const label = this._safeText(o?.label) || id;
+        return `<option value="${this._esc(id)}">${this._esc(label)}</option>`;
+      })
+      .join("");
+
+    const msg = this._restoreLoading
+      ? "Loading backups…"
+      : this._restoreError
+      ? this._safeText(this._restoreError)
+      : opts.length
+      ? "Select a backup to restore. This will overwrite files under /config/custom_components and requires a restart."
+      : "No backups found.";
+
+    return `
+      <div class="modalOverlay" id="restoreOverlay">
+        <div class="modal">
+          <div class="modalTitle">Restore from backup</div>
+          <div class="muted" style="margin-top:8px;">${this._esc(msg)}</div>
+
+          <div style="margin-top:14px;">
+            <label class="muted small" for="restoreSelect">Backup</label><br/>
+            <select id="restoreSelect" ${disabled ? "disabled" : ""} style="width:100%; margin-top:6px;">
+              ${optionsHtml}
+            </select>
+          </div>
+
+          <div class="row" style="margin-top:16px; justify-content:flex-end; gap:10px;">
+            <button id="btnRestoreCancel">Cancel</button>
+            <button class="primary" id="btnRestoreApply" ${disabled ? "disabled" : ""}>${this._restoring ? "Restoring…" : "Restore"}</button>
+          </div>
+        </div>
+      </div>
+    `;
+  }
+
+
+
   _renderManage() {
     const repos = Array.isArray(this._data.repos) ? this._data.repos : [];
     const custom = repos.filter((r) => r?.source === "custom");

custom_components/bahmcloud_store/views.py

@@ -355,6 +355,53 @@ class BCSUninstallView(HomeAssistantView):
             return web.json_response({"ok": False, "message": str(e) or "Uninstall failed"}, status=500)
 
 
+
+
+class BCSBackupsView(HomeAssistantView):
+    url = "/api/bcs/backups"
+    name = "api:bcs_backups"
+    requires_auth = True
+
+    def __init__(self, core: Any) -> None:
+        self.core: BCSCore = core
+
+    async def get(self, request: web.Request) -> web.Response:
+        repo_id = request.query.get("repo_id")
+        if not repo_id:
+            return web.json_response({"ok": False, "message": "Missing repo_id"}, status=400)
+
+        try:
+            backups = await self.core.list_repo_backups(repo_id)
+            return web.json_response({"ok": True, "repo_id": repo_id, "backups": backups}, status=200)
+        except Exception as e:
+            _LOGGER.exception("BCS list backups failed: %s", e)
+            return web.json_response({"ok": False, "message": str(e) or "List backups failed"}, status=500)
+
+
+class BCSRestoreView(HomeAssistantView):
+    url = "/api/bcs/restore"
+    name = "api:bcs_restore"
+    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")
+        backup_id = request.query.get("backup_id")
+        if not repo_id:
+            return web.json_response({"ok": False, "message": "Missing repo_id"}, status=400)
+        if not backup_id:
+            return web.json_response({"ok": False, "message": "Missing backup_id"}, status=400)
+
+        try:
+            result = await self.core.restore_repo_backup(repo_id, backup_id)
+            return web.json_response(result, status=200)
+        except Exception as e:
+            _LOGGER.exception("BCS restore failed: %s", e)
+            return web.json_response({"ok": False, "message": str(e) or "Restore failed"}, status=500)
+
+
 class BCSRestartView(HomeAssistantView):
     url = "/api/bcs/restart"
     name = "api:bcs_restart"