@phystack/hub-client 4.5.19-dev → 4.5.20-dev

package/src/services/webrtc/peer-connection-ice.ts

@@ -1,689 +0,0 @@
-// Initialize WebRTC globals if we're in Node environment
-(async function initializeWebRTCGlobals() {
-  // Only run in Node environment
-  if (typeof window !== 'undefined') return;
-
-  try {
-    // Dynamically import wrtc
-    const wrtc = require('@roamhq/wrtc');
-
-    // Set all WebRTC globals
-    if (typeof global.MediaStream === 'undefined' && wrtc.MediaStream) {
-      global.MediaStream = wrtc.MediaStream;
-      console.log('Global MediaStream initialized');
-    }
-
-    if (typeof global.RTCDataChannel === 'undefined' && wrtc.RTCDataChannel) {
-      global.RTCDataChannel = wrtc.RTCDataChannel;
-      console.log('Global RTCDataChannel initialized');
-    }
-
-    if (typeof global.RTCPeerConnection === 'undefined' && wrtc.RTCPeerConnection) {
-      global.RTCPeerConnection = wrtc.RTCPeerConnection;
-      console.log('Global RTCPeerConnection initialized');
-    }
-
-    if (typeof global.RTCSessionDescription === 'undefined' && wrtc.RTCSessionDescription) {
-      global.RTCSessionDescription = wrtc.RTCSessionDescription;
-      console.log('Global RTCSessionDescription initialized');
-    }
-
-    if (typeof global.RTCIceCandidate === 'undefined' && wrtc.RTCIceCandidate) {
-      global.RTCIceCandidate = wrtc.RTCIceCandidate;
-      console.log('Global RTCIceCandidate initialized');
-    }
-
-    console.log('WebRTC globals successfully initialized');
-  } catch (error) {
-    console.error('Failed to initialize WebRTC globals:', error);
-  }
-})().catch(err => console.error('Error in WebRTC globals initialization:', err));
-
-import { WebRTCConnectionOptions } from '../../types/webrtc.types';
-
-export interface PeerConnectionState {
-  pc: RTCPeerConnection | null;
-  isShuttingDown: boolean;
-  isReconnecting: boolean;
-  currentConnectionId: number;
-  pendingCandidates: RTCIceCandidateInit[];
-  activeDataChannel: RTCDataChannel | null;
-  activeMediaStream?: MediaStream | null;
-  useStun?: boolean;
-  channelPrefix?: string;
-  targetTwinId?: string;
-  isInitiator?: boolean;
-  connectionType?: 'datachannel' | 'mediastream';
-}
-
-export interface PeerConnectionCallbacks {
-  onCreateConnection: (
-    pc: RTCPeerConnection,
-    connectionId: number,
-    isInitiator: boolean
-  ) => Promise<RTCDataChannel | MediaStream | null>;
-
-  onCloseCleanup: () => void;
-  onSubscribe: () => Promise<void>;
-  sendSignalingMessage: (type: string, data: any) => Promise<void>;
-  setupMessageHandling: (messageHandler: (message: any) => void) => void;
-  removeMessageHandling: (messageHandler: (message: any) => void) => void;
-  reportConnectionState: (info: string) => void;
-  reportError: (info: string, error?: any) => void;
-  retryConnection: (retryCount: number, useStun?: boolean, delay?: number) => Promise<unknown>;
-  safeReject: (error: Error) => void;
-}
-
-/**
- * Interface for RTCPeerConnection with optional experimental properties
- */
-interface ExtendedRTCPeerConnection extends RTCPeerConnection {
-  // This is an experimental property that might not be available in all browsers/environments
-  onicecandidatepairchange?: (event: Event) => void;
-}
-
-/**
- * Create a new RTCPeerConnection with or without STUN servers based on flags.
- */
-export function createPeerConnection(useStun: boolean): RTCPeerConnection {
-  const pc = new RTCPeerConnection({
-    iceServers: useStun
-      ? [{ urls: 'stun:stun.l.google.com:19302' }, { urls: 'stun:stun1.l.google.com:19302' }]
-      : [],
-  });
-  return pc;
-}
-
-/**
- * Set up ICE candidate handlers and connection state handlers
- * on the newly created RTCPeerConnection.
- */
-export function handleIceAndConnectionState(
-  state: PeerConnectionState,
-  pc: RTCPeerConnection,
-  callbacks: PeerConnectionCallbacks,
-  connectionId: number
-) {
-  const extendedPc = pc as ExtendedRTCPeerConnection;
-
-  pc.onicecandidate = async event => {
-    if (!pc) return;
-    // Only send ICE if this is still the active connection
-    if (event.candidate && state.currentConnectionId === connectionId) {
-      try {
-        // Log local ICE candidate info
-        logIceCandidate('Local ICE candidate', event.candidate);
-        await callbacks.sendSignalingMessage('ice', event.candidate);
-      } catch (err) {
-        // Swallow errors from ICE sending attempts
-        callbacks.reportError('Error sending ICE candidate:', err);
-      }
-    } else if (event.candidate === null) {
-      callbacks.reportConnectionState('ICE gathering complete');
-    }
-  };
-
-  // Add event handler for ICE candidate pair selection - this is an experimental feature
-  // and might not be available in all browsers/environments
-  extendedPc.onicecandidatepairchange = (_event: Event) => {
-    callbacks.reportConnectionState('ICE candidate pair changed');
-
-    // Get stats to determine the selected candidate pair
-    pc.getStats()
-      .then(stats => {
-        // Use any type for the stats objects to avoid TypeScript errors
-        // The RTCStatsReport interface varies across browsers and environments
-        const statsValues: any[] = [];
-        (stats as any).forEach((stat: any) => {
-          statsValues.push(stat);
-        });
-
-        // Find candidate pair and transport stats
-        const transportStats = statsValues.find(s => s.type === 'transport');
-        if (transportStats) {
-          callbacks.reportConnectionState(
-            `Transport selected: ${transportStats.selectedCandidatePairId}`
-          );
-        }
-
-        const selectedPair = statsValues.find(s => s.type === 'candidate-pair' && s.selected);
-        if (selectedPair) {
-          callbacks.reportConnectionState(`Selected ICE candidate pair [${selectedPair.id}]:
-          local=${selectedPair.localCandidateId},
-          remote=${selectedPair.remoteCandidateId},
-          state=${selectedPair.state},
-          priority=${selectedPair.priority}`);
-
-          // Find the local and remote candidate details
-          const localCandidate = statsValues.find(
-            s => s.type === 'local-candidate' && s.id === selectedPair.localCandidateId
-          );
-
-          const remoteCandidate = statsValues.find(
-            s => s.type === 'remote-candidate' && s.id === selectedPair.remoteCandidateId
-          );
-
-          if (localCandidate) {
-            logIceCandidateStats('Selected local ICE candidate', localCandidate);
-          }
-
-          if (remoteCandidate) {
-            logIceCandidateStats('Selected remote ICE candidate', remoteCandidate);
-          }
-        }
-      })
-      .catch(err => {
-        callbacks.reportError('Error getting ICE candidate stats:', err);
-      });
-  };
-
-  pc.onconnectionstatechange = () => {
-    if (!pc) return;
-    callbacks.reportConnectionState(`Connection state: ${pc.connectionState}`);
-  };
-
-  pc.oniceconnectionstatechange = () => {
-    if (!pc) return;
-    callbacks.reportConnectionState(`ICE connection state: ${pc.iceConnectionState}`);
-
-    // When ICE connection state becomes 'connected', log the selected candidate pair
-    if (pc.iceConnectionState === 'connected') {
-      pc.getStats()
-        .then(stats => {
-          // Convert stats to array for easier processing
-          const statsValues: any[] = [];
-          (stats as any).forEach((stat: any) => {
-            statsValues.push(stat);
-          });
-
-          const selectedPair = statsValues.find(s => s.type === 'candidate-pair' && s.selected);
-          if (!selectedPair) return;
-
-          const localCandidate = statsValues.find(
-            s => s.type === 'local-candidate' && s.id === selectedPair.localCandidateId
-          );
-
-          const remoteCandidate = statsValues.find(
-            s => s.type === 'remote-candidate' && s.id === selectedPair.remoteCandidateId
-          );
-
-          if (selectedPair && localCandidate && remoteCandidate) {
-            callbacks.reportConnectionState('*** ICE CONNECTION ESTABLISHED ***');
-            callbacks.reportConnectionState(`Selected candidates:
-            Local: ${localCandidate.ip}:${localCandidate.port} (${localCandidate.protocol}) [${localCandidate.candidateType}]
-            Remote: ${remoteCandidate.ip}:${remoteCandidate.port} (${remoteCandidate.protocol}) [${remoteCandidate.candidateType}]
-            Round-trip time: ${selectedPair.currentRoundTripTime ? (selectedPair.currentRoundTripTime * 1000).toFixed(2) + 'ms' : 'unknown'}`);
-          }
-        })
-        .catch(err => {
-          callbacks.reportError('Error getting ICE candidate stats:', err);
-        });
-    }
-  };
-}
-
-/**
- * Helper function to log ICE candidate details from RTCIceCandidate object
- */
-function logIceCandidate(label: string, candidate: RTCIceCandidate) {
-  console.log(`${label}: ${candidate.candidate}`);
-
-  // Extract additional details for more verbose logging
-  // Example format: candidate:1467250027 1 udp 2122260223 192.168.0.1 56789 typ host generation 0
-  try {
-    const parts = candidate.candidate.split(' ');
-    if (parts.length > 7) {
-      const protocol = parts[2];
-      const ip = parts[4];
-      const port = parts[5];
-      const type = parts[7];
-      console.log(`Details: IP=${ip}, Port=${port}, Protocol=${protocol}, Type=${type}`);
-    }
-  } catch (e) {
-    // Ignore parsing errors
-  }
-}
-
-/**
- * Helper function to log ICE candidate details from stats object
- */
-function logIceCandidateStats(label: string, candidate: any) {
-  if (!candidate) return;
-
-  // Log basic information
-  console.log(
-    `${label}: ${candidate.ip}:${candidate.port} (${candidate.protocol}) [${candidate.candidateType}]`
-  );
-
-  // Log additional details if available
-  if (candidate.url) console.log(`STUN/TURN server: ${candidate.url}`);
-  if (candidate.priority) console.log(`Priority: ${candidate.priority}`);
-  if (candidate.networkType) console.log(`Network type: ${candidate.networkType}`);
-}
-
-/**
- * Attempts to start a WebRTC connection, sets up the PeerConnection,
- * and calls data-channel creation logic when needed.
- */
-export async function attemptConnection(
-  state: PeerConnectionState,
-  options: WebRTCConnectionOptions,
-  retryCount: number,
-  currentUseStun: boolean,
-  delay: number,
-  INITIAL_RETRY_DELAY: number,
-  CONNECTION_TIMEOUT: number,
-  MAX_RETRY_DELAY: number,
-  callbacks: PeerConnectionCallbacks
-): Promise<any> {
-  if (state.isShuttingDown) {
-    throw new Error('Connection attempt cancelled - shutting down');
-  }
-
-  return new Promise((resolve, reject) => {
-    let connectionEstablished = false;
-    let timeoutId: NodeJS.Timeout | null = null;
-    let localConnection: RTCDataChannel | MediaStream | null = null;
-    const connectionId = ++state.currentConnectionId;
-    const isInitiator = state.isInitiator ?? options.isInitiator ?? true;
-    const connectionType =
-      state.connectionType ||
-      (options.mediaOptions?.isMediaConnection ? 'mediastream' : 'datachannel');
-
-    // Create message handler for WebRTC signaling
-    const messageHandler = async (message: any) => {
-      try {
-        if (state.isShuttingDown) {
-          return; // Don't process messages if shutting down
-        }
-
-        const channelId = `${state.channelPrefix}-${state.targetTwinId}`;
-        const messageType = message.data?.type;
-
-        switch (messageType) {
-          case `${channelId}:answer`:
-            if (isInitiator && state.pc) {
-              callbacks.reportConnectionState(
-                'Received answer, current signaling state: ' + state.pc.signalingState
-              );
-              if (state.pc.signalingState === 'have-local-offer') {
-                await state.pc.setRemoteDescription(message.data.data);
-                callbacks.reportConnectionState('Set remote description successfully');
-
-                // Apply any pending ICE candidates now that we have a remote description
-                if (state.pendingCandidates.length > 0) {
-                  callbacks.reportConnectionState(
-                    `Applying ${state.pendingCandidates.length} pending ICE candidates after answer`
-                  );
-                  for (const candidate of state.pendingCandidates) {
-                    try {
-                      await state.pc.addIceCandidate(candidate);
-                    } catch (err) {
-                      callbacks.reportError('Error applying pending ICE candidate:', err);
-                    }
-                  }
-                  state.pendingCandidates = [];
-                }
-              } else {
-                callbacks.reportConnectionState(
-                  `Ignoring answer - wrong state: ${state.pc.signalingState}`
-                );
-              }
-            }
-            break;
-
-          case `${channelId}:offer`:
-            if (!isInitiator && state.pc) {
-              callbacks.reportConnectionState(
-                'Received offer, current signaling state: ' + state.pc.signalingState
-              );
-
-              // Only process the offer if we're in a stable state or have-remote-offer
-              if (
-                state.pc.signalingState === 'stable' ||
-                state.pc.signalingState === 'have-remote-offer'
-              ) {
-                // If we already have a remote offer, we need to rollback first
-                if (state.pc.signalingState === 'have-remote-offer') {
-                  callbacks.reportConnectionState('Rolling back previous offer');
-                  await state.pc.setLocalDescription({ type: 'rollback' });
-                }
-
-                await state.pc.setRemoteDescription(message.data.data);
-                callbacks.reportConnectionState('Set remote description successfully');
-
-                callbacks.reportConnectionState('Creating answer...');
-                const answer = await state.pc.createAnswer();
-                await state.pc.setLocalDescription(answer);
-
-                await callbacks.sendSignalingMessage('answer', answer);
-
-                // Apply any pending ICE candidates now that we have a remote description
-                if (state.pendingCandidates.length > 0) {
-                  callbacks.reportConnectionState(
-                    `Applying ${state.pendingCandidates.length} pending ICE candidates after offer`
-                  );
-                  for (const candidate of state.pendingCandidates) {
-                    try {
-                      await state.pc.addIceCandidate(candidate);
-                    } catch (err) {
-                      callbacks.reportError('Error applying pending ICE candidate:', err);
-                    }
-                  }
-                  state.pendingCandidates = [];
-                }
-              } else {
-                callbacks.reportConnectionState(
-                  `Ignoring offer - wrong state: ${state.pc.signalingState}`
-                );
-              }
-            }
-            break;
-
-          case `${channelId}:ice`:
-            if (state.pc) {
-              if (state.pc.remoteDescription) {
-                try {
-                  await state.pc.addIceCandidate(message.data.data);
-                } catch (err) {
-                  callbacks.reportError('Error adding ICE candidate:', err);
-                }
-              } else {
-                callbacks.reportConnectionState('Storing ICE candidate for later');
-                state.pendingCandidates.push(message.data.data);
-              }
-            }
-            break;
-        }
-      } catch (error) {
-        callbacks.reportError('Error handling WebRTC message:', error);
-      }
-    };
-
-    const cleanup = () => {
-      callbacks.reportConnectionState('Running cleanup...');
-      if (timeoutId) clearTimeout(timeoutId);
-      callbacks.removeMessageHandling(messageHandler);
-      if (localConnection instanceof RTCDataChannel) {
-        localConnection.onopen = null;
-        localConnection.onclose = null;
-        localConnection.onerror = null;
-        localConnection.close();
-      } else if (localConnection instanceof MediaStream) {
-        localConnection.getTracks().forEach(track => track.stop());
-      }
-      if (state.pc) {
-        state.pc.onicecandidate = null;
-        state.pc.onconnectionstatechange = null;
-        state.pc.oniceconnectionstatechange = null;
-        try {
-          (state.pc as RTCPeerConnection).close();
-        } catch (err) {
-          callbacks.reportError('Error closing peer connection', err);
-        }
-        state.pc = null;
-      }
-      state.pendingCandidates = [];
-      state.activeDataChannel = null;
-      state.activeMediaStream = null;
-
-      // Also do any local cleanup
-      callbacks.onCloseCleanup();
-    };
-
-    const safeReject = (error: Error) => {
-      cleanup();
-      reject(error);
-    };
-
-    const retryConnection = () => {
-      if (state.isShuttingDown) {
-        safeReject(new Error('Connection attempt cancelled - shutting down'));
-        return;
-      }
-      callbacks.reportConnectionState(
-        `Connection attempt ${retryCount + 1} failed ${currentUseStun ? 'with' : 'without'} STUN`
-      );
-      cleanup();
-
-      // The original code manipulates STUN usage on first retry,
-      // then uses exponential backoff.
-      if (retryCount === 0) {
-        callbacks.reportConnectionState(
-          `Retrying with ${!currentUseStun ? 'STUN' : 'direct'} connection...`
-        );
-        callbacks
-          .retryConnection(retryCount + 1, !currentUseStun)
-          .then(res => resolve(res))
-          .catch(err => reject(err));
-        return;
-      }
-
-      // Otherwise, wait and retry with original STUN setting
-      callbacks.reportConnectionState(
-        `Retrying in ${Math.floor(delay / 1000)} seconds... (attempt ${retryCount + 1})`
-      );
-      setTimeout(() => {
-        const nextDelay = Math.min(MAX_RETRY_DELAY, INITIAL_RETRY_DELAY * Math.pow(2, retryCount));
-        callbacks
-          .retryConnection(retryCount + 1, currentUseStun, Math.min(nextDelay, MAX_RETRY_DELAY))
-          .then(res => resolve(res))
-          .catch(err => reject(err));
-      }, delay);
-    };
-
-    const initConnection = async () => {
-      if (typeof RTCPeerConnection === 'undefined') {
-        callbacks.reportError(
-          'RTCPeerConnection is not available. WebRTC globals initialization may have failed.'
-        );
-        throw new Error(
-          'RTCPeerConnection is not available. Cannot proceed with WebRTC connection.'
-        );
-      }
-
-      // Set up message handling for signaling
-      callbacks.setupMessageHandling(messageHandler);
-
-      // Original code: await subscribeTwin(targetTwinId)
-      // delegated to callback
-      await callbacks.onSubscribe();
-
-      callbacks.reportConnectionState(
-        `Attempting data connection ${currentUseStun ? 'with' : 'without'} STUN servers...`
-      );
-      state.pc = createPeerConnection(currentUseStun);
-      const pc = state.pc!;
-
-      // Set up ICE handling
-      handleIceAndConnectionState(state, pc, callbacks, connectionId);
-
-      // Defer connection creation to original file (keeping specific code there)
-      try {
-        localConnection = await callbacks.onCreateConnection(pc, connectionId, isInitiator);
-
-        if (localConnection instanceof RTCDataChannel) {
-          state.activeDataChannel = localConnection;
-        } else if (localConnection instanceof MediaStream) {
-          state.activeMediaStream = localConnection;
-        }
-
-        // Monitor connection state changes
-        pc.onconnectionstatechange = () => {
-          if (!pc) return;
-          callbacks.reportConnectionState(`Connection state: ${pc.connectionState}`);
-          if (pc.connectionState === 'connected') {
-            connectionEstablished = true;
-            if (timeoutId) clearTimeout(timeoutId);
-
-            // For MediaStreams, we need to wait for tracks to be received
-            if (connectionType === 'mediastream') {
-              // Check if we have received any tracks
-              const hasTracks = pc.getReceivers().some(receiver => receiver.track);
-              if (!hasTracks) {
-                callbacks.reportConnectionState('Connected but no tracks received yet');
-                return;
-              }
-            }
-
-            // If we have an active connection, resolve the promise
-            if (connectionEstablished && !state.isShuttingDown) {
-              const result = {
-                _rawPeerConnection: pc,
-                close: () => {
-                  state.isShuttingDown = true;
-                  cleanup();
-                },
-              };
-
-              // Add connection-specific properties
-              if (connectionType === 'datachannel') {
-                Object.assign(result, {
-                  dataChannel: {
-                    send: () => {}, // This will be replaced by the persistent channel
-                    onMessage: () => {}, // This will be replaced by the persistent channel
-                    offMessage: () => {}, // This will be replaced by the persistent channel
-                    onClose: () => {}, // This will be replaced by the persistent channel
-                    offClose: () => {}, // This will be replaced by the persistent channel
-                    close: () => {
-                      state.isShuttingDown = true;
-                      cleanup();
-                    },
-                  },
-                  _rawDataChannel: state.activeDataChannel,
-                });
-              } else if (connectionType === 'mediastream') {
-                Object.assign(result, {
-                  mediaStream: {
-                    getTracks: () => [], // This will be replaced by the persistent media stream
-                    onTrack: () => {}, // This will be replaced by the persistent media stream
-                    offTrack: () => {}, // This will be replaced by the persistent media stream
-                    onClose: () => {}, // This will be replaced by the persistent media stream
-                    offClose: () => {}, // This will be replaced by the persistent media stream
-                    close: () => {
-                      state.isShuttingDown = true;
-                      cleanup();
-                    },
-                    addTrack: () => {}, // This will be replaced by the persistent media stream
-                  },
-                  _rawMediaStream: state.activeMediaStream,
-                });
-              }
-
-              resolve(result);
-            }
-          } else if (
-            pc.connectionState === 'failed' ||
-            pc.connectionState === 'disconnected' ||
-            pc.connectionState === 'closed'
-          ) {
-            if (connectionEstablished) {
-              callbacks.reportConnectionState('Connection lost, initiating retry...');
-              retryConnection();
-            }
-          }
-        };
-
-        // Set up ICE connection state monitoring
-        pc.oniceconnectionstatechange = () => {
-          if (!pc) return;
-          callbacks.reportConnectionState(`ICE connection state: ${pc.iceConnectionState}`);
-          if (pc.iceConnectionState === 'failed' && connectionEstablished) {
-            callbacks.reportConnectionState('ICE Connection failed, initiating retry...');
-            retryConnection();
-          }
-        };
-
-        // Create and send offer for initiator
-        if (isInitiator) {
-          try {
-            callbacks.reportConnectionState('Creating offer...');
-            const offer = await pc.createOffer();
-            callbacks.reportConnectionState('Setting local description...');
-            await pc.setLocalDescription(offer);
-            callbacks.reportConnectionState('Sending offer...');
-            await callbacks.sendSignalingMessage('offer', offer);
-          } catch (error) {
-            callbacks.reportError('Error creating/sending offer:', error);
-            retryConnection();
-            return;
-          }
-        }
-
-        // Timeout to detect initial connection failure
-        timeoutId = setTimeout(() => {
-          if (!connectionEstablished) {
-            callbacks.reportConnectionState(
-              `Connection attempt timed out ${currentUseStun ? 'with' : 'without'} STUN`
-            );
-            retryConnection();
-          }
-        }, CONNECTION_TIMEOUT);
-      } catch (error) {
-        callbacks.reportError('Error creating connection in callback', error);
-        retryConnection();
-        return;
-      }
-    };
-
-    // Start everything
-    initConnection().catch(error => {
-      callbacks.reportError('Unhandled error in connection attempt', error);
-      safeReject(error);
-    });
-  });
-}
-
-/**
- * The reconnect trigger logic, abstracted here.
- */
-export function triggerReconnect(
-  state: PeerConnectionState,
-  attempt: number,
-  RECONNECT_DELAY: number,
-  callbacks: PeerConnectionCallbacks
-) {
-  // These checks are now handled in the webrtc-datachannel.ts file
-  // to maintain consistent state between the two files
-
-  state.currentConnectionId++;
-  callbacks.reportConnectionState(`Starting reconnection process (attempt ${attempt})`);
-
-  // Force close any active data channel
-  if (state.activeDataChannel && typeof state.activeDataChannel.close === 'function') {
-    try {
-      state.activeDataChannel.close();
-    } catch (err) {
-      callbacks.reportError('Error closing active data channel:', err);
-    }
-    state.activeDataChannel = null;
-  }
-
-  // Clean up any existing peer connection
-  if (state.pc) {
-    try {
-      (state.pc as RTCPeerConnection).close();
-    } catch (err) {
-      callbacks.reportError('Error closing old peer connection:', err);
-    }
-    state.pc = null;
-  }
-
-  const reconnectAttempt = () => {
-    // The original code tries with toggled useStun or direct
-    callbacks
-      .retryConnection(0, !(state.useStun ?? true))
-      .then(() => {
-        callbacks.reportConnectionState(`Reconnection successful (attempt ${attempt})`);
-      })
-      .catch(error => {
-        callbacks.reportError(`Reconnection failed (attempt ${attempt})`, error);
-        setTimeout(
-          reconnectAttempt,
-          Math.min(100 * Math.pow(2, attempt), 5000) // backoff
-        );
-      });
-  };
-
-  setTimeout(reconnectAttempt, RECONNECT_DELAY);
-}