fix(updater): propagate errors from apply update instead of silently failing

The "Restart to update" button had no visible effect when apply() failed
because errors were swallowed at every layer. Now apply() throws on
precondition failures, emits error status on extraction/swap failures,
the RPC handler returns { ok: false, error } instead of always { ok: true },
and the frontend shows error text with a loading state during the attempt.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: Vrtak-CZ

src/bun/index.ts

@@ -114,8 +114,12 @@ const rpc = BrowserView.defineRPC<KloviRPC>({
       },
       applyUpdate: async () => {
         const mgr = getUpdateManager();
-        await mgr.apply();
-        return { ok: true };
+        try {
+          await mgr.apply();
+          return { ok: true };
+        } catch (error) {
+          return { ok: false, error: error instanceof Error ? error.message : "Update failed" };
+        }
       },
       openExternal: (params) => {
         Utils.openExternal(params.url);

src/bun/updater.ts

@@ -355,7 +355,7 @@ export class UpdateManager {
 
   async apply(): Promise<void> {
     if (!this.downloadedAssetPath || !this.latestRelease) {
-      return;
+      throw new Error("No downloaded update to apply");
     }
 
     const stagingDir = join(this.updatesDir(), "staging");
@@ -388,6 +388,12 @@ export class UpdateManager {
       try {
         rmSync(stagingDir, { recursive: true });
       } catch {}
+      this.emitStatus({
+        status: "error",
+        currentVersion: this.currentVersion,
+        latestVersion: this.latestRelease.tag_name,
+        error: error instanceof Error ? error.message : "Update failed",
+      });
       throw error;
     }
   }

src/frontend/components/UpdateNotification.css

@@ -22,10 +22,15 @@
   cursor: pointer;
 }
 
-.update-notification-action:hover {
+.update-notification-action:hover:not(:disabled) {
   opacity: 0.9;
 }
 
+.update-notification-action:disabled {
+  opacity: 0.6;
+  cursor: default;
+}
+
 .update-notification-dismiss {
   background: none;
   border: none;

src/frontend/components/UpdateNotification.test.tsx

@@ -1,10 +1,13 @@
 import { afterEach, describe, expect, mock, test } from "bun:test";
-import { cleanup, fireEvent, render } from "@testing-library/react";
+import { cleanup, fireEvent, render, waitFor } from "@testing-library/react";
 import type { UpdateStatus } from "../../shared/rpc-types.ts";
 import { setupMockRPC } from "../test-helpers/mock-rpc.ts";
 import { UpdateNotification } from "./UpdateNotification.tsx";
 
 const VERSION_READY_PATTERN = /v2\.0\.0 is ready/;
+const EXTRACT_FAILED_PATTERN = /Extract failed/;
+const UPDATE_FAILED_PATTERN = /Update failed/;
+const NETWORK_TIMEOUT_PATTERN = /Network timeout/;
 
 function defaultProps() {
   return {
@@ -68,6 +71,44 @@ describe("UpdateNotification", () => {
     expect(applyUpdate).toHaveBeenCalled();
   });
 
+  test("shows Restarting text and disables button while applying", () => {
+    const applyUpdate = mock(() => new Promise<{ ok: boolean }>(() => {})); // never resolves
+    setupMockRPC({ applyUpdate });
+    const props = defaultProps();
+    props.status = { status: "ready", currentVersion: "1.0.0", latestVersion: "2.0.0" };
+    const { getByRole } = render(<UpdateNotification {...props} />);
+    fireEvent.click(getByRole("button", { name: "Restart to update" }));
+    const button = getByRole("button", { name: "Restarting…" });
+    expect(button).toBeDefined();
+    expect(button.hasAttribute("disabled")).toBe(true);
+  });
+
+  test("shows error when applyUpdate returns ok: false", async () => {
+    const applyUpdate = mock(() => Promise.resolve({ ok: false, error: "Extract failed" }));
+    setupMockRPC({ applyUpdate });
+    const props = defaultProps();
+    props.status = { status: "ready", currentVersion: "1.0.0", latestVersion: "2.0.0" };
+    const { getByRole, getByText } = render(<UpdateNotification {...props} />);
+    fireEvent.click(getByRole("button", { name: "Restart to update" }));
+    await waitFor(() => {
+      expect(getByText(EXTRACT_FAILED_PATTERN)).toBeDefined();
+    });
+    // Button should be re-enabled after error
+    expect(getByRole("button", { name: "Restart to update" }).hasAttribute("disabled")).toBe(false);
+  });
+
+  test("shows error when applyUpdate rejects", async () => {
+    const applyUpdate = mock(() => Promise.reject(new Error("RPC error")));
+    setupMockRPC({ applyUpdate });
+    const props = defaultProps();
+    props.status = { status: "ready", currentVersion: "1.0.0", latestVersion: "2.0.0" };
+    const { getByRole, getByText } = render(<UpdateNotification {...props} />);
+    fireEvent.click(getByRole("button", { name: "Restart to update" }));
+    await waitFor(() => {
+      expect(getByText(UPDATE_FAILED_PATTERN)).toBeDefined();
+    });
+  });
+
   test("shows up-to-date message for manual check result", () => {
     const props = defaultProps();
     props.manualCheckResult = { status: "up-to-date", currentVersion: "1.0.0" };
@@ -83,7 +124,7 @@ describe("UpdateNotification", () => {
       error: "Network timeout",
     };
     const { getByText } = render(<UpdateNotification {...props} />);
-    expect(getByText(/Network timeout/)).toBeDefined();
+    expect(getByText(NETWORK_TIMEOUT_PATTERN)).toBeDefined();
   });
 
   test("calls onDismissManualCheck when dismissing manual check result", () => {

src/frontend/components/UpdateNotification.tsx

@@ -1,3 +1,4 @@
+import { useState } from "react";
 import type { UpdateStatus } from "../../shared/rpc-types.ts";
 import { getRPC } from "../rpc.ts";
 import "./UpdateNotification.css";
@@ -59,19 +60,46 @@ export function UpdateNotification({
     return null;
   }
 
+  return <ReadyBanner latestVersion={status.latestVersion} onDismiss={onDismiss} />;
+}
+
+function ReadyBanner({
+  latestVersion,
+  onDismiss,
+}: {
+  latestVersion: string;
+  onDismiss: () => void;
+}) {
+  const [applying, setApplying] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  const handleApply = async () => {
+    setApplying(true);
+    setError(null);
+    try {
+      const result = await getRPC().request.applyUpdate({} as Record<string, never>);
+      if (!result.ok) {
+        setError(result.error ?? "Update failed");
+        setApplying(false);
+      }
+    } catch {
+      setError("Update failed");
+      setApplying(false);
+    }
+  };
+
   return (
     <div className="update-notification">
-      <span className="update-notification-text">Klovi v{status.latestVersion} is ready</span>
+      <span className="update-notification-text">
+        {error ? `Update failed: ${error}` : `Klovi v${latestVersion} is ready`}
+      </span>
       <button
         type="button"
         className="update-notification-action"
-        onClick={() => {
-          getRPC()
-            .request.applyUpdate({} as Record<string, never>)
-            .catch(() => {});
-        }}
+        disabled={applying}
+        onClick={handleApply}
       >
-        Restart to update
+        {applying ? "Restarting…" : "Restart to update"}
       </button>
       <button
         type="button"

src/frontend/rpc.ts

@@ -47,7 +47,7 @@ export interface RPCClient {
       autoDownload?: boolean;
     }) => Promise<UpdateSettingsInfo>;
     checkForUpdate: (params: Record<string, never>) => Promise<UpdateStatus>;
-    applyUpdate: (params: Record<string, never>) => Promise<{ ok: boolean }>;
+    applyUpdate: (params: Record<string, never>) => Promise<{ ok: boolean; error?: string }>;
     openExternal: (params: { url: string }) => Promise<{ ok: boolean }>;
     browseDirectory: (params: { startingFolder?: string }) => Promise<{ path: string | null }>;
   };

src/shared/rpc-types.ts

@@ -92,7 +92,7 @@ export interface KloviRPC {
       };
       applyUpdate: {
         params: Record<string, never>;
-        response: { ok: boolean };
+        response: { ok: boolean; error?: string };
       };
       openExternal: { params: { url: string }; response: { ok: boolean } };
       browseDirectory: {