fix: abort in-flight mutations in UpdatesDashboard on unmount

handleAction fires prepare/execute/automated/delete against the gateway
without an abort signal. If the user navigates away while a mutation is
in-flight, the promise resolves and fires toast.success + setBusyIds on
an unmounted component.

Add an AbortController created in a mount effect and aborted in its
cleanup, thread its signal through the four mutation helpers, and
short-circuit post-await side effects when the signal is aborted.

The polling path in useUpdatesPolling already had this treatment; this
brings mutations to parity.

Tests assert (a) signal is an AbortSignal, (b) it becomes aborted on
unmount, (c) a late-resolving mutation does not fire a success toast.

Author: bburda

src/components/UpdatesDashboard.test.tsx

@@ -199,4 +199,54 @@ describe('UpdatesDashboard', () => {
 
         expect(toast.error).toHaveBeenCalled();
     });
+
+    it('passes an AbortSignal to mutation actions', async () => {
+        const user = userEvent.setup();
+        mockTriggerPrepare.mockResolvedValue(undefined);
+        mockUseUpdatesPolling.mockReturnValue(makeResult({ updates: [makeEntry('fw-v2', 'pending')] }));
+
+        render(<UpdatesDashboard />);
+
+        const prepareBtn = screen.getByRole('button', { name: /prepare/i });
+        await user.click(prepareBtn);
+
+        // triggerPrepare is called with (baseUrl, id, data, signal) - assert signal is an AbortSignal
+        const call = mockTriggerPrepare.mock.calls[0]!;
+        const signal = call[3];
+        expect(signal).toBeInstanceOf(AbortSignal);
+    });
+
+    it('aborts in-flight mutations on unmount', async () => {
+        const user = userEvent.setup();
+        let resolvePrepare: () => void = () => {};
+        mockTriggerPrepare.mockImplementation(
+            () =>
+                new Promise<void>((resolve) => {
+                    resolvePrepare = resolve;
+                })
+        );
+        mockUseUpdatesPolling.mockReturnValue(makeResult({ updates: [makeEntry('fw-v2', 'pending')] }));
+        const { toast } = await import('react-toastify');
+        vi.mocked(toast.success).mockClear();
+
+        const { unmount } = render(<UpdatesDashboard />);
+
+        const prepareBtn = screen.getByRole('button', { name: /prepare/i });
+        await user.click(prepareBtn);
+
+        // Capture the signal before unmount
+        const signal = mockTriggerPrepare.mock.calls[0]![3] as AbortSignal;
+        expect(signal.aborted).toBe(false);
+
+        unmount();
+
+        expect(signal.aborted).toBe(true);
+
+        // Late-resolve the prepare call - must NOT fire a success toast on
+        // the unmounted component.
+        resolvePrepare();
+        await new Promise((r) => setTimeout(r, 0));
+
+        expect(toast.success).not.toHaveBeenCalled();
+    });
 });

src/components/UpdatesDashboard.tsx

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-import { useCallback, useMemo, useState } from 'react';
+import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { useShallow } from 'zustand/shallow';
 import { Package, RefreshCw, AlertTriangle, Server } from 'lucide-react';
 import { toast } from 'react-toastify';
@@ -39,6 +39,16 @@ export function UpdatesDashboard() {
     const { updates, isLoading, error, notAvailable, refresh } = useUpdatesPolling(baseUrl);
     const [busyIds, setBusyIds] = useState<Set<string>>(new Set());
 
+    // AbortController for mutation actions (prepare/execute/automated/delete).
+    // Aborted on unmount so in-flight requests don't resolve into setBusyIds
+    // on an unmounted component or issue stale toast notifications.
+    const actionAbortRef = useRef<AbortController | null>(null);
+    useEffect(() => {
+        const controller = new AbortController();
+        actionAbortRef.current = controller;
+        return () => controller.abort();
+    }, []);
+
     const summary = useMemo(() => {
         let active = 0;
         let failed = 0;
@@ -59,22 +69,27 @@ export function UpdatesDashboard() {
                 const confirmed = window.confirm(`Delete update "${id}"? This cannot be undone.`);
                 if (!confirmed) return;
             }
+            const signal = actionAbortRef.current?.signal;
             setBusyIds((prev) => new Set(prev).add(id));
             try {
-                if (action === 'prepare') await triggerPrepare(baseUrl, id);
-                else if (action === 'execute') await triggerExecute(baseUrl, id);
-                else if (action === 'automated') await triggerAutomated(baseUrl, id);
-                else if (action === 'delete') await deleteUpdate(baseUrl, id);
+                if (action === 'prepare') await triggerPrepare(baseUrl, id, undefined, signal);
+                else if (action === 'execute') await triggerExecute(baseUrl, id, undefined, signal);
+                else if (action === 'automated') await triggerAutomated(baseUrl, id, undefined, signal);
+                else if (action === 'delete') await deleteUpdate(baseUrl, id, signal);
+                if (signal?.aborted) return;
                 toast.success(`${action} triggered for ${id}`);
                 refresh();
             } catch (err) {
+                if (signal?.aborted || (err as { name?: string })?.name === 'AbortError') return;
                 toast.error(err instanceof Error ? err.message : String(err));
             } finally {
-                setBusyIds((prev) => {
-                    const next = new Set(prev);
-                    next.delete(id);
-                    return next;
-                });
+                if (!signal?.aborted) {
+                    setBusyIds((prev) => {
+                        const next = new Set(prev);
+                        next.delete(id);
+                        return next;
+                    });
+                }
             }
         },
         [baseUrl, refresh]