Merge 336a75812f into 28919bf37c

ui/src/hooks/stores.ts

@@ -116,7 +116,7 @@ export interface RTCState {
   peerConnection: RTCPeerConnection | null;
   setPeerConnection: (pc: RTCState["peerConnection"]) => void;
 
-  setRpcDataChannel: (channel: RTCDataChannel | null) => void;
+  setRpcDataChannel: (channel: RTCDataChannel) => void;
   rpcDataChannel: RTCDataChannel | null;
 
   hidRpcDisabled: boolean;
@@ -181,45 +181,44 @@ export const useRTCStore = create<RTCState>(set => ({
   setPeerConnection: (pc: RTCState["peerConnection"]) => set({ peerConnection: pc }),
 
   rpcDataChannel: null,
-  setRpcDataChannel: channel => set({ rpcDataChannel: channel }),
+  setRpcDataChannel: (channel: RTCDataChannel) => set({ rpcDataChannel: channel }),
 
   hidRpcDisabled: false,
-  setHidRpcDisabled: disabled => set({ hidRpcDisabled: disabled }),
+  setHidRpcDisabled: (disabled: boolean) => set({ hidRpcDisabled: disabled }),
 
   rpcHidProtocolVersion: null,
-  setRpcHidProtocolVersion: version => set({ rpcHidProtocolVersion: version }),
+  setRpcHidProtocolVersion: (version: number | null) => set({ rpcHidProtocolVersion: version }),
 
   rpcHidChannel: null,
-  setRpcHidChannel: channel => set({ rpcHidChannel: channel }),
+  setRpcHidChannel: (channel: RTCDataChannel) => set({ rpcHidChannel: channel }),
 
   rpcHidUnreliableChannel: null,
-  setRpcHidUnreliableChannel: channel => set({ rpcHidUnreliableChannel: channel }),
+  setRpcHidUnreliableChannel: (channel: RTCDataChannel) => set({ rpcHidUnreliableChannel: channel }),
 
   rpcHidUnreliableNonOrderedChannel: null,
-  setRpcHidUnreliableNonOrderedChannel: channel =>
+  setRpcHidUnreliableNonOrderedChannel: (channel: RTCDataChannel) => set({ rpcHidUnreliableNonOrderedChannel: channel }),
-    set({ rpcHidUnreliableNonOrderedChannel: channel }),
 
   transceiver: null,
-  setTransceiver: transceiver => set({ transceiver }),
+  setTransceiver: (transceiver: RTCRtpTransceiver) => set({ transceiver }),
 
   audioTransceiver: null,
   setAudioTransceiver: (transceiver: RTCRtpTransceiver) => set({ audioTransceiver: transceiver }),
 
   peerConnectionState: null,
-  setPeerConnectionState: state => set({ peerConnectionState: state }),
+  setPeerConnectionState: (state: RTCPeerConnectionState) => set({ peerConnectionState: state }),
 
   mediaStream: null,
-  setMediaStream: stream => set({ mediaStream: stream }),
+  setMediaStream: (stream: MediaStream) => set({ mediaStream: stream }),
 
   videoStreamStats: null,
-  appendVideoStreamStats: stats => set({ videoStreamStats: stats }),
+  appendVideoStreamStats: (stats: RTCInboundRtpStreamStats) => set({ videoStreamStats: stats }),
   videoStreamStatsHistory: new Map(),
 
   isTurnServerInUse: false,
-  setTurnServerInUse: inUse => set({ isTurnServerInUse: inUse }),
+  setTurnServerInUse: (inUse: boolean) => set({ isTurnServerInUse: inUse }),
 
   inboundRtpStats: new Map(),
-  appendInboundRtpStats: stats => {
+  appendInboundRtpStats: (stats: RTCInboundRtpStreamStats) => {
     set(prevState => ({
       inboundRtpStats: appendStatToMap(stats, prevState.inboundRtpStats),
     }));
@@ -227,7 +226,7 @@ export const useRTCStore = create<RTCState>(set => ({
   clearInboundRtpStats: () => set({ inboundRtpStats: new Map() }),
 
   candidatePairStats: new Map(),
-  appendCandidatePairStats: stats => {
+  appendCandidatePairStats: (stats: RTCIceCandidatePairStats) => {
     set(prevState => ({
       candidatePairStats: appendStatToMap(stats, prevState.candidatePairStats),
     }));
@@ -235,21 +234,21 @@ export const useRTCStore = create<RTCState>(set => ({
   clearCandidatePairStats: () => set({ candidatePairStats: new Map() }),
 
   localCandidateStats: new Map(),
-  appendLocalCandidateStats: stats => {
+  appendLocalCandidateStats: (stats: RTCIceCandidateStats) => {
     set(prevState => ({
       localCandidateStats: appendStatToMap(stats, prevState.localCandidateStats),
     }));
   },
 
   remoteCandidateStats: new Map(),
-  appendRemoteCandidateStats: stats => {
+  appendRemoteCandidateStats: (stats: RTCIceCandidateStats) => {
     set(prevState => ({
       remoteCandidateStats: appendStatToMap(stats, prevState.remoteCandidateStats),
     }));
   },
 
   diskDataChannelStats: new Map(),
-  appendDiskDataChannelStats: stats => {
+  appendDiskDataChannelStats: (stats: RTCDataChannelStats) => {
     set(prevState => ({
       diskDataChannelStats: appendStatToMap(stats, prevState.diskDataChannelStats),
     }));
@@ -257,7 +256,7 @@ export const useRTCStore = create<RTCState>(set => ({
 
   // Add these new properties to the store implementation
   terminalChannel: null,
-  setTerminalChannel: channel => set({ terminalChannel: channel }),
+  setTerminalChannel: (channel: RTCDataChannel) => set({ terminalChannel: channel }),
 }));
 
 export interface MouseMove {
@@ -277,20 +276,12 @@ export interface MouseState {
 export const useMouseStore = create<MouseState>(set => ({
   mouseX: 0,
   mouseY: 0,
-  setMouseMove: move => set({ mouseMove: move }),
+  setMouseMove: (move?: MouseMove) => set({ mouseMove: move }),
-  setMousePosition: (x, y) => set({ mouseX: x, mouseY: y }),
+  setMousePosition: (x: number, y: number) => set({ mouseX: x, mouseY: y }),
 }));
 
-export type HdmiStates =
+export type HdmiStates = "ready" | "no_signal" | "no_lock" | "out_of_range" | "connecting";
-  | "ready"
+export type HdmiErrorStates = Extract<VideoState["hdmiState"], "no_signal" | "no_lock" | "out_of_range">
-  | "no_signal"
-  | "no_lock"
-  | "out_of_range"
-  | "connecting";
-export type HdmiErrorStates = Extract<
-  VideoState["hdmiState"],
-  "no_signal" | "no_lock" | "out_of_range"
->;
 
 export interface HdmiState {
   ready: boolean;
@@ -305,7 +296,10 @@ export interface VideoState {
   setClientSize: (width: number, height: number) => void;
   setSize: (width: number, height: number) => void;
   hdmiState: HdmiStates;
-  setHdmiState: (state: { ready: boolean; error?: HdmiErrorStates }) => void;
+  setHdmiState: (state: {
+    ready: boolean;
+    error?: HdmiErrorStates;
+  }) => void;
 }
 
 export const useVideoStore = create<VideoState>(set => ({
@@ -316,8 +310,7 @@ export const useVideoStore = create<VideoState>(set => ({
   clientHeight: 0,
 
   // The video element's client size
-  setClientSize: (clientWidth: number, clientHeight: number) =>
+  setClientSize: (clientWidth: number, clientHeight: number) => set({ clientWidth, clientHeight }),
-    set({ clientWidth, clientHeight }),
 
   // Resolution
   setSize: (width: number, height: number) => set({ width, height }),
@@ -483,15 +476,13 @@ export interface MountMediaState {
 
 export const useMountMediaStore = create<MountMediaState>(set => ({
   remoteVirtualMediaState: null,
-  setRemoteVirtualMediaState: (state: MountMediaState["remoteVirtualMediaState"]) =>
+  setRemoteVirtualMediaState: (state: MountMediaState["remoteVirtualMediaState"]) => set({ remoteVirtualMediaState: state }),
-    set({ remoteVirtualMediaState: state }),
 
   modalView: "mode",
   setModalView: (view: MountMediaState["modalView"]) => set({ modalView: view }),
 
   isMountMediaDialogOpen: false,
-  setIsMountMediaDialogOpen: (isOpen: MountMediaState["isMountMediaDialogOpen"]) =>
+  setIsMountMediaDialogOpen: (isOpen: MountMediaState["isMountMediaDialogOpen"]) => set({ isMountMediaDialogOpen: isOpen }),
-    set({ isMountMediaDialogOpen: isOpen }),
 
   uploadedFiles: [],
   addUploadedFile: (file: { name: string; size: string; uploadedAt: string }) =>
@@ -508,7 +499,7 @@ export interface KeyboardLedState {
   compose: boolean;
   kana: boolean;
   shift: boolean; // Optional, as not all keyboards have a shift LED
-}
+};
 
 export const hidKeyBufferSize = 6;
 export const hidErrorRollOver = 0x01;
@@ -543,23 +534,14 @@ export interface HidState {
 }
 
 export const useHidStore = create<HidState>(set => ({
-  keyboardLedState: {
+  keyboardLedState: { num_lock: false, caps_lock: false, scroll_lock: false, compose: false, kana: false, shift: false } as KeyboardLedState,
-    num_lock: false,
+  setKeyboardLedState: (ledState: KeyboardLedState): void => set({ keyboardLedState: ledState }),
-    caps_lock: false,
-    scroll_lock: false,
-    compose: false,
-    kana: false,
-    shift: false,
-  } as KeyboardLedState,
-  setKeyboardLedState: (ledState: KeyboardLedState): void =>
-    set({ keyboardLedState: ledState }),
 
   keysDownState: { modifier: 0, keys: [0, 0, 0, 0, 0, 0] } as KeysDownState,
   setKeysDownState: (state: KeysDownState): void => set({ keysDownState: state }),
 
   isVirtualKeyboardEnabled: false,
-  setVirtualKeyboardEnabled: (enabled: boolean): void =>
+  setVirtualKeyboardEnabled: (enabled: boolean): void => set({ isVirtualKeyboardEnabled: enabled }),
-    set({ isVirtualKeyboardEnabled: enabled }),
 
   isPasteInProgress: false,
   setPasteModeEnabled: (enabled: boolean): void => set({ isPasteInProgress: enabled }),
@@ -611,7 +593,7 @@ export interface OtaState {
 
   systemUpdateProgress: number;
   systemUpdatedAt: string | null;
-}
+};
 
 export interface UpdateState {
   isUpdatePending: boolean;
@@ -623,7 +605,7 @@ export interface UpdateState {
   otaState: OtaState;
   setOtaState: (state: OtaState) => void;
 
-  modalView: UpdateModalViews;
+  modalView: UpdateModalViews
   setModalView: (view: UpdateModalViews) => void;
 
   updateErrorMessage: string | null;
@@ -663,11 +645,12 @@ export const useUpdateStore = create<UpdateState>(set => ({
   setModalView: (view: UpdateModalViews) => set({ modalView: view }),
 
   updateErrorMessage: null,
-  setUpdateErrorMessage: (errorMessage: string) =>
+  setUpdateErrorMessage: (errorMessage: string) => set({ updateErrorMessage: errorMessage }),
-    set({ updateErrorMessage: errorMessage }),
 }));
 
-export type UsbConfigModalViews = "updateUsbConfig" | "updateUsbConfigSuccess";
+export type UsbConfigModalViews =
+  | "updateUsbConfig"
+  | "updateUsbConfigSuccess";
 
 export interface UsbConfigModalState {
   modalView: UsbConfigModalViews;
@@ -1020,5 +1003,5 @@ export const useMacrosStore = create<MacrosState>((set, get) => ({
     } finally {
       set({ loading: false });
     }
-  },
+  }
 }));

ui/src/routes/devices.$id.tsx

@@ -651,9 +651,8 @@ export default function KvmIdRoute() {
       clearCandidatePairStats();
       setSidebarView(null);
       setPeerConnection(null);
-      setRpcDataChannel(null);
     };
-  }, [clearCandidatePairStats, clearInboundRtpStats, setPeerConnection, setSidebarView, setRpcDataChannel]);
+  }, [clearCandidatePairStats, clearInboundRtpStats, setPeerConnection, setSidebarView]);
 
   // TURN server usage detection
   useEffect(() => {

ui/src/utils/jsonrpc.ts

@@ -24,47 +24,17 @@ export interface JsonRpcCallResponse<T = unknown> {
 let rpcCallCounter = 0;
 
 // Helper: wait for RTC data channel to be ready
-// This waits indefinitely for the channel to be ready, only aborting via the signal
-// Throws if the channel instance changed while waiting (stale connection detected)
 async function waitForRtcReady(signal: AbortSignal): Promise<RTCDataChannel> {
   const pollInterval = 100;
-  let lastSeenChannel: RTCDataChannel | null = null;
 
   while (!signal.aborted) {
     const state = useRTCStore.getState();
-    const currentChannel = state.rpcDataChannel;
+    if (state.rpcDataChannel?.readyState === "open") {
-
+      return state.rpcDataChannel;
-    // Channel instance changed (new connection replaced old one)
-    if (lastSeenChannel && currentChannel && lastSeenChannel !== currentChannel) {
-      console.debug("[waitForRtcReady] Channel instance changed, aborting wait");
-      throw new Error("RTC connection changed while waiting for readiness");
     }
-
-    // Channel was removed from store (connection closed)
-    if (lastSeenChannel && !currentChannel) {
-      console.debug("[waitForRtcReady] Channel was removed from store, aborting wait");
-      throw new Error("RTC connection was closed while waiting for readiness");
-    }
-
-    // No channel yet, keep waiting
-    if (!currentChannel) {
-      await sleep(pollInterval);
-      continue;
-    }
-
-    // Track this channel instance
-    lastSeenChannel = currentChannel;
-
-    // Channel is ready!
-    if (currentChannel.readyState === "open") {
-      return currentChannel;
-    }
-
     await sleep(pollInterval);
   }
 
-  // Signal was aborted for some reason
-  console.debug("[waitForRtcReady] Aborted via signal");
   throw new Error("RTC readiness check aborted");
 }
 
@@ -127,26 +97,25 @@ export async function callJsonRpc<T = unknown>(
   const timeout = options.attemptTimeoutMs || 5000;
 
   for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const abortController = new AbortController();
+    const timeoutId = setTimeout(() => abortController.abort(), timeout);
+
     // Exponential backoff for retries that starts at 500ms up to a maximum of 10 seconds
     const backoffMs = Math.min(500 * Math.pow(2, attempt), 10000);
-    let timeoutId: ReturnType<typeof setTimeout> | null = null;
 
     try {
-      // Wait for RTC readiness without timeout - this allows time for WebRTC to connect
+      // Wait for RTC readiness
-      const readyAbortController = new AbortController();
+      const rpcDataChannel = await waitForRtcReady(abortController.signal);
-      const rpcDataChannel = await waitForRtcReady(readyAbortController.signal);
-
-      // Now apply timeout only to the actual RPC request/response
-      const rpcAbortController = new AbortController();
-      timeoutId = setTimeout(() => rpcAbortController.abort(), timeout);
 
       // Send RPC request and wait for response
       const response = await sendRpcRequest<T>(
         rpcDataChannel,
         options,
-        rpcAbortController.signal,
+        abortController.signal,
       );
 
+      clearTimeout(timeoutId);
+
       // Retry on error if attempts remain
       if (response.error && attempt < maxAttempts - 1) {
         await sleep(backoffMs);
@@ -155,6 +124,8 @@ export async function callJsonRpc<T = unknown>(
 
       return response;
     } catch (error) {
+      clearTimeout(timeoutId);
+
       // Retry on timeout/error if attempts remain
       if (attempt < maxAttempts - 1) {
         await sleep(backoffMs);
@@ -164,10 +135,6 @@ export async function callJsonRpc<T = unknown>(
       throw error instanceof Error
         ? error
         : new Error(`JSON-RPC call failed after ${timeout}ms`);
-    } finally {
-      if (timeoutId !== null) {
-        clearTimeout(timeoutId);
-      }
     }
   }