FRE-600: Fix code review blockers

- Consolidated duplicate UndoManagers to single instance
- Fixed connection promise to only resolve on 'connected' status
- Fixed WebSocketProvider import (WebsocketProvider)
- Added proper doc.destroy() cleanup
- Renamed isPresenceInitialized property to avoid conflict

Co-Authored-By: Paperclip <noreply@paperclip.ing>

src/lib/video/webrtc-video-manager.ts

@@ -21,7 +21,7 @@ export interface WebRTCVideoManagerOptions {
 
 export interface PeerConnection {
   peerId: string;
-  connection: DataConnection;
+  connection: MediaConnection;
   stream: MediaStream | null;
   state: PeerConnectionState;
   quality: ConnectionQuality;
@@ -37,14 +37,12 @@ export interface VideoManagerEvents {
   'state:changed': (state: PeerConnectionState) => void;
 }
 
-class DataConnection {
-  private peer: Peer;
+class MediaConnection {
   private conn: any;
   private stream: MediaStream | null = null;
   private listeners: Map<string, Set<(...args: any[]) => void>> = new Map();
 
-  constructor(peer: Peer, conn: any) {
-    this.peer = peer;
+  constructor(conn: any) {
     this.conn = conn;
 
     this.conn.on('stream', (stream: MediaStream) => {
@@ -73,11 +71,6 @@ class DataConnection {
     this.conn.send(data);
   }
 
-  pushStream(stream: MediaStream): void {
-    this.stream = stream;
-    this.conn.sendStream(stream);
-  }
-
   getStream(): MediaStream | null {
     return this.stream;
   }
@@ -105,7 +98,7 @@ class DataConnection {
 export class WebRTCVideoManager extends EventEmitter {
   private peer: Peer | null = null;
   private options: WebRTCVideoManagerOptions;
-  private connections: Map<string, DataConnection> = new Map();
+  private connections: Map<string, MediaConnection> = new Map();
   private localStream: MediaStream | null = null;
   private state: PeerConnectionState = 'disconnected';
   private qualityMetrics: Map<string, ConnectionQuality> = new Map();
@@ -130,27 +123,23 @@ export class WebRTCVideoManager extends EventEmitter {
       await this.acquireLocalStream();
 
       // Initialize PeerJS
-      this.peer = new Peer(this.options.peerId, {
-        host: new URL(this.options.serverUrl).hostname,
-        port: new URL(this.options.serverUrl).port || 443,
+      const serverUrl = new URL(this.options.serverUrl ?? 'https://0.peerjs.com:443');
+      this.peer = new Peer(this.options.peerId ?? 'unknown', {
+        host: serverUrl.hostname,
+        port: Number(serverUrl.port || 443),
         path: '/webrtc',
-        secure: true,
+        secure: serverUrl.protocol === 'https:',
         config: {
           iceServers: this.options.turnServers,
         },
       });
 
       // Handle incoming connections
-      this.peer.on('connection', (conn: any) => {
-        const dataConn = new DataConnection(this.peer!, conn);
-        this.connections.set(conn.peer, dataConn);
+      this.peer.on('call', (conn: any) => {
+        const mediaConn = new MediaConnection(conn);
+        this.connections.set(conn.peer, mediaConn);
 
-        // Send local stream to new peer
-        if (this.localStream) {
-          dataConn.pushStream(this.localStream);
-        }
-
-        this.emit('peer:connected', conn.peer, this.localStream!);
+        this.emit('peer:connected', conn.peer, conn.stream);
         this.updateState('connected');
       });
 
@@ -196,44 +185,33 @@ export class WebRTCVideoManager extends EventEmitter {
     }
   }
 
-  connectToPeer(peerId: string): DataConnection {
+  connectToPeer(peerId: string, stream?: MediaStream): MediaConnection {
     if (!this.peer) {
       throw new Error('Peer not initialized. Call initialize() first.');
     }
 
-    const conn = this.peer.connect(peerId, {
-      metadata: {
-        peerId: this.peer.id,
-        timestamp: Date.now(),
-      },
-    });
-
-    const dataConn = new DataConnection(this.peer, conn);
-    this.connections.set(peerId, dataConn);
-
-    // Send local stream
-    if (this.localStream) {
-      dataConn.pushStream(this.localStream);
-    }
+    const conn = this.peer.call(peerId, stream ?? this.localStream!);
+    const mediaConn = new MediaConnection(conn);
+    this.connections.set(peerId, mediaConn);
 
     // Monitor connection quality
-    dataConn.on('open', () => {
-      this.startQualityMonitoring(peerId, dataConn);
+    mediaConn.on('open', () => {
+      this.startQualityMonitoring(peerId, mediaConn);
     });
 
-    dataConn.on('close', () => {
+    mediaConn.on('close', () => {
       this.qualityMetrics.delete(peerId);
       this.emit('peer:disconnected', peerId);
     });
 
-    return dataConn;
+    return mediaConn;
   }
 
-  getPeerConnection(peerId: string): DataConnection | undefined {
+  getPeerConnection(peerId: string): MediaConnection | undefined {
     return this.connections.get(peerId);
   }
 
-  getAllConnections(): Map<string, DataConnection> {
+  getAllConnections(): Map<string, MediaConnection> {
     return new Map(this.connections);
   }
 
@@ -308,17 +286,12 @@ export class WebRTCVideoManager extends EventEmitter {
     return this.qualityMetrics.get(peerId) || 'fair';
   }
 
-  private startQualityMonitoring(peerId: string, conn: DataConnection): void {
-    let packetLoss = 0;
-    let latencySamples: number[] = [];
-
+  private startQualityMonitoring(peerId: string, conn: MediaConnection): void {
     const checkQuality = () => {
-      // Simple quality estimation based on connection state
-      if (conn) {
-        const quality: ConnectionQuality = 'good';
-        this.qualityMetrics.set(peerId, quality);
-        this.emit('connection:quality', peerId, quality);
-      }
+      // TODO: Implement actual RTCPeerConnection stats via getStats()
+      const quality: ConnectionQuality = 'good';
+      this.qualityMetrics.set(peerId, quality);
+      this.emit('connection:quality', peerId, quality);
     };
 
     // Check quality every 5 seconds