Improve native interactions and secure device connectivity

src/__tests__/integration/network-scan-modal.test.tsx

@@ -8,6 +8,22 @@ import {
   type ZeroConfService,
 } from "../../../__mocks__/capacitor-zeroconf";
 
+const { mockT } = vi.hoisted(() => ({
+  mockT: vi.fn((key: string) => key),
+}));
+
+vi.mock("react-i18next", () => ({
+  useTranslation: () => ({
+    t: mockT,
+    i18n: {
+      changeLanguage: vi.fn(() => Promise.resolve()),
+      language: "en",
+    },
+  }),
+  Trans: ({ children }: { children: React.ReactNode }) => children,
+  initReactI18next: { type: "3rdParty", init: () => {} },
+}));
+
 // Helper to create mock ZeroConf services
 const createMockService = (
   overrides: Partial<ZeroConfService> = {},
@@ -236,9 +252,17 @@ describe("NetworkScanModal", () => {
         );
       });
 
-      // Assert - mDNS hostname is preferred and default port is hidden
+      // Assert - show both stable-looking hostname and concrete route so the
+      // user can verify which host the app is about to contact.
       await waitFor(() => {
         expect(screen.getByText("test-device.local")).toBeInTheDocument();
+        expect(
+          screen.getByText("settings.networkScan.addresses"),
+        ).toBeInTheDocument();
+        expect(mockT).toHaveBeenCalledWith("settings.networkScan.addresses", {
+          addresses: "192.168.1.100",
+          count: 1,
+        });
       });
     });
 

src/__tests__/unit/components/ConnectionProvider.test.tsx

@@ -34,6 +34,7 @@ import type { NotificationRequest } from "@/lib/coreApi";
 import { ClientCapability, InboxSeverity, Notification } from "@/lib/models";
 import { logger } from "@/lib/logger";
 import { invalidateLibraryImageCache } from "@/lib/libraryImageCache";
+import { reconcileCredentialProvenAliases } from "@/lib/devices/credentialProof";
 
 // Capture event handlers for notification testing
 let capturedEventHandlers: {
@@ -54,6 +55,10 @@ vi.mock("@/lib/libraryImageCache", () => ({
   invalidateLibraryImageCache: vi.fn(),
 }));
 
+vi.mock("@/lib/devices/credentialProof", () => ({
+  reconcileCredentialProvenAliases: vi.fn().mockResolvedValue([]),
+}));
+
 vi.mock("../../../lib/transport", () => {
   const mockTransport = {
     deviceId: "test-device",
@@ -431,18 +436,20 @@ describe("ConnectionProvider", () => {
       ...overrides,
     });
 
-    async function seedMdnsDevice() {
-      await seedDeviceRegistry(
-        [
-          mockDeviceRecord({
-            recordId: MDNS_RECORD_ID,
-            address: "steamdeck.local",
-            source: "mdns",
-            discoveryId: "core-id",
-          }),
-        ],
-        MDNS_RECORD_ID,
-      );
+    async function seedMdnsDevice(resolvedAddresses?: string[]) {
+      const record = mockDeviceRecord({
+        recordId: MDNS_RECORD_ID,
+        address: "steamdeck.local",
+        source: "mdns",
+        discoveryId: "core-id",
+      });
+      if (resolvedAddresses) {
+        record.endpoints = record.endpoints.map((endpoint) => ({
+          ...endpoint,
+          resolvedAddresses,
+        }));
+      }
+      await seedDeviceRegistry([record], MDNS_RECORD_ID);
     }
 
     beforeEach(async () => {
@@ -509,6 +516,96 @@ describe("ConnectionProvider", () => {
       expect(deviceRegistry.activeEndpoint()?.address).toBe("steamdeck.local");
     });
 
+    it("should pass every resolved address to the transport", async () => {
+      render(
+        <ConnectionProvider>
+          <div>Test</div>
+        </ConnectionProvider>,
+      );
+
+      await waitFor(() => {
+        expect(ZeroConf.watch).toHaveBeenCalled();
+      });
+      act(() => {
+        __simulateDeviceDiscovered(
+          advertise({ ipv4Addresses: ["10.0.0.206", "10.0.0.218"] }),
+        );
+      });
+
+      await waitFor(() => {
+        expect(connectionManager.addDevice).toHaveBeenCalledWith(
+          expect.objectContaining({
+            address: "ws://10.0.0.206:7497/api/v0.1",
+            fallbackAddresses: [
+              "ws://10.0.0.218:7497/api/v0.1",
+              "ws://steamdeck.local:7497/api/v0.1",
+            ],
+          }),
+        );
+      });
+    });
+
+    it("should retry after mDNS confirms an already-known route", async () => {
+      await seedMdnsDevice(["10.0.0.206"]);
+
+      render(
+        <ConnectionProvider>
+          <div>Test</div>
+        </ConnectionProvider>,
+      );
+
+      await waitFor(() => {
+        expect(connectionManager.addDevice).toHaveBeenCalledWith(
+          expect.objectContaining({ address: "ws://10.0.0.206:7497/api/v0.1" }),
+        );
+      });
+      vi.mocked(connectionManager.immediateReconnectActive).mockClear();
+
+      act(() => {
+        __simulateDeviceDiscovered(advertise());
+      });
+
+      await waitFor(() => {
+        expect(
+          connectionManager.immediateReconnectActive,
+        ).toHaveBeenCalledTimes(1);
+      });
+    });
+
+    it("should retry when mDNS confirms a fallback route", async () => {
+      await seedMdnsDevice(["10.0.0.205", "10.0.0.206"]);
+
+      render(
+        <ConnectionProvider>
+          <div>Test</div>
+        </ConnectionProvider>,
+      );
+
+      await waitFor(() => {
+        expect(connectionManager.addDevice).toHaveBeenCalledWith(
+          expect.objectContaining({
+            address: "ws://10.0.0.205:7497/api/v0.1",
+            fallbackAddresses: expect.arrayContaining([
+              "ws://10.0.0.206:7497/api/v0.1",
+            ]),
+          }),
+        );
+      });
+      vi.mocked(connectionManager.immediateReconnectActive).mockClear();
+
+      act(() => {
+        __simulateDeviceDiscovered(
+          advertise({ ipv4Addresses: ["10.0.0.206"] }),
+        );
+      });
+
+      await waitFor(() => {
+        expect(
+          connectionManager.immediateReconnectActive,
+        ).toHaveBeenCalledTimes(1);
+      });
+    });
+
     it("should follow the hostname to a new address", async () => {
       render(
         <ConnectionProvider>
@@ -633,6 +730,53 @@ describe("ConnectionProvider", () => {
       });
     });
 
+    it("should retry immediately when a resolved mDNS connection drops", async () => {
+      render(
+        <ConnectionProvider>
+          <div>Test</div>
+        </ConnectionProvider>,
+      );
+
+      await waitFor(() => {
+        expect(ZeroConf.watch).toHaveBeenCalled();
+      });
+      act(() => {
+        __simulateDeviceDiscovered(advertise());
+      });
+      await waitFor(() => {
+        expect(connectionManager.addDevice).toHaveBeenCalledWith(
+          expect.objectContaining({ address: "ws://10.0.0.206:7497/api/v0.1" }),
+        );
+      });
+
+      act(() => {
+        capturedEventHandlers.onConnectionChange!(MDNS_RECORD_ID, {
+          state: "connected",
+          hasData: true,
+          hasConnectedBefore: true,
+        });
+      });
+      await waitFor(() => {
+        expect(ZeroConf.unwatch).toHaveBeenCalled();
+      });
+      vi.mocked(connectionManager.immediateReconnectActive).mockClear();
+
+      act(() => {
+        capturedEventHandlers.onConnectionChange!(MDNS_RECORD_ID, {
+          state: "reconnecting",
+          hasData: true,
+          hasConnectedBefore: true,
+        });
+      });
+
+      await waitFor(() => {
+        expect(ZeroConf.watch).toHaveBeenCalledTimes(2);
+        expect(
+          connectionManager.immediateReconnectActive,
+        ).toHaveBeenCalledTimes(1);
+      });
+    });
+
     it("should keep browsing while the connection is still down", async () => {
       render(
         <ConnectionProvider>
@@ -2863,6 +3007,7 @@ describe("connection event handling", () => {
       const record = deviceRegistry.getSnapshot().records[RECORD_ID];
       expect(record?.lastConnectedAt).toBeGreaterThanOrEqual(before);
     });
+    expect(reconcileCredentialProvenAliases).not.toHaveBeenCalled();
   });
 
   it("should move a pre-V2 pairing onto the record once the peer authenticates with it", async () => {
@@ -2910,6 +3055,10 @@ describe("connection event handling", () => {
       expect(
         deviceRegistry.getSnapshot().records[RECORD_ID]?.legacyCredentialKey,
       ).toBeUndefined();
+      expect(reconcileCredentialProvenAliases).toHaveBeenCalledWith(
+        RECORD_ID,
+        expect.objectContaining({ authToken: "token-abc" }),
+      );
     });
   });
 

src/__tests__/unit/components/wui/Button.test.tsx

@@ -2,12 +2,15 @@ import { render, screen, fireEvent, act } from "../../../../test-utils";
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
 import { Button } from "@/components/wui/Button";
 
-// Mock useHaptics hook
+// Mock touch-only haptic press handling
 const mockImpact = vi.fn();
-vi.mock("@/hooks/useHaptics", () => ({
-  useHaptics: () => ({
-    impact: mockImpact,
-  }),
+vi.mock("@/hooks/useHapticPress", () => ({
+  useHapticPress:
+    (style: string, enabled: boolean) => (event: { pointerType: string }) => {
+      if (enabled && event.pointerType === "touch") {
+        mockImpact(style);
+      }
+    },
 }));
 
 describe("Button", () => {
@@ -111,46 +114,55 @@ describe("Button", () => {
   });
 
   describe("haptic feedback", () => {
-    it("should trigger light haptic feedback on touch start for default intent", () => {
-      render(<Button label="Test button" />);
+    it("should trigger light haptic feedback when a default press completes", () => {
+      render(<Button label="Test button" onClick={() => {}} />);
 
-      const button = screen.getByRole("button");
-      fireEvent.touchStart(button, {
-        touches: [{ clientX: 0, clientY: 0 }],
-      });
+      fireEvent.pointerUp(screen.getByRole("button"), { pointerType: "touch" });
 
       expect(mockImpact).toHaveBeenCalledWith("light");
     });
 
-    it("should trigger medium haptic feedback on touch start for primary intent", () => {
-      render(<Button label="Test button" intent="primary" />);
+    it("should trigger medium haptic feedback when a primary press completes", () => {
+      render(
+        <Button label="Test button" intent="primary" onClick={() => {}} />,
+      );
 
-      const button = screen.getByRole("button", { name: "Test button" });
-      fireEvent.touchStart(button, {
-        touches: [{ clientX: 0, clientY: 0 }],
-      });
+      fireEvent.pointerUp(screen.getByRole("button"), { pointerType: "touch" });
 
       expect(mockImpact).toHaveBeenCalledWith("medium");
     });
 
-    it("should trigger heavy haptic feedback on touch start for destructive intent", () => {
-      render(<Button label="Test button" intent="destructive" />);
+    it("should trigger heavy haptic feedback when a destructive press completes", () => {
+      render(
+        <Button label="Test button" intent="destructive" onClick={() => {}} />,
+      );
 
-      const button = screen.getByRole("button");
-      fireEvent.touchStart(button, {
-        touches: [{ clientX: 0, clientY: 0 }],
-      });
+      fireEvent.pointerUp(screen.getByRole("button"), { pointerType: "touch" });
 
       expect(mockImpact).toHaveBeenCalledWith("heavy");
     });
 
     it("should not trigger haptic feedback when disabled", () => {
-      render(<Button label="Test button" intent="primary" disabled />);
+      render(
+        <Button
+          label="Test button"
+          intent="primary"
+          disabled
+          onClick={() => {}}
+        />,
+      );
 
-      const button = screen.getByRole("button", { name: "Test button" });
-      fireEvent.touchStart(button, {
-        touches: [{ clientX: 0, clientY: 0 }],
-      });
+      fireEvent.pointerUp(screen.getByRole("button"), { pointerType: "touch" });
+
+      expect(mockImpact).not.toHaveBeenCalled();
+    });
+
+    it("should not trigger haptic feedback for decorative buttons", () => {
+      render(<Button icon={<span>Icon</span>} decorative />);
+
+      const button = screen.getByText("Icon").closest("button");
+      if (!button) throw new Error("Expected decorative button");
+      fireEvent.pointerUp(button, { pointerType: "touch" });
 
       expect(mockImpact).not.toHaveBeenCalled();
     });