Update server.js

server.js

@@ -112,6 +112,7 @@ function genId(prefix) {
 // ─────────────────────────────────────────────────
 const connectedClients = new Map();
 const adminSessions    = new Map();
+const ownerSessions    = new Map(); // Map<ownerSID, {ws, clientId}>
 const wsRegistry       = new Map();
 
 // ─────────────────────────────────────────────────
@@ -226,6 +227,83 @@ async function handleMessage(ws, msg, ip) {
       break;
     }
 
+    // ════════════════════════════════════════
+    //  ENREGISTREMENT OWNER (propriétaire)
+    //  Le propriétaire se connecte avec son clientId
+    //  Il reçoit le flux WebRTC de son propre appareil
+    // ════════════════════════════════════════
+    case 'register_owner': {
+      const { clientId } = msg;
+      if (!clientId || !db.clients[clientId]) {
+        send(ws, { type: 'error', code: 'NOT_FOUND', message: 'Client ID inconnu' });
+        return;
+      }
+      const ownerSID = genId('OSID');
+      ownerSessions.set(ownerSID, { ws, clientId });
+      wsRegistry.set(ws, { type: 'owner', id: ownerSID, clientId });
+
+      send(ws, {
+        type: 'owner_registered',
+        ownerSID,
+        clientId,
+        client: buildClientInfo(clientId),
+      });
+      console.log(`[WS] Owner connecté: ${ownerSID} pour client(${clientId}) depuis ${ip}`);
+      break;
+    }
+
+    // ════════════════════════════════════════
+    //  CALL FROM OWNER → son propre client APK
+    // ════════════════════════════════════════
+    case 'owner_call_client': {
+      const info = wsRegistry.get(ws);
+      if (info?.type !== 'owner') return;
+      const { mode } = msg;
+      const { clientId } = info;
+      const clientWs = connectedClients.get(clientId);
+      if (!clientWs || clientWs.readyState !== WebSocket.OPEN) {
+        send(ws, { type: 'call_error', clientId, message: 'Appareil hors ligne' });
+        return;
+      }
+      send(clientWs, { type: 'incoming_call', mode: mode || 'manual', adminSID: info.id });
+      send(ws, { type: 'call_initiated', clientId });
+      console.log(`[CALL] Owner(${info.id}) → Client(${clientId}) mode=${mode}`);
+      break;
+    }
+
+    // ════════════════════════════════════════
+    //  WEBRTC OFFER (owner → son client APK)
+    // ════════════════════════════════════════
+    case 'owner_webrtc_offer': {
+      const info = wsRegistry.get(ws);
+      if (info?.type !== 'owner') return;
+      const { offer } = msg;
+      const { clientId, id: ownerSID } = info;
+      const clientWs = connectedClients.get(clientId);
+      if (!clientWs || clientWs.readyState !== WebSocket.OPEN) {
+        send(ws, { type: 'rtc_error', message: `Appareil ${clientId} non connecté` });
+        return;
+      }
+      send(clientWs, { type: 'webrtc_offer', offer, adminSID: ownerSID });
+      console.log(`[RTC] Offer: owner(${ownerSID}) → client(${clientId})`);
+      break;
+    }
+
+    // ════════════════════════════════════════
+    //  ICE depuis owner → son client APK
+    // ════════════════════════════════════════
+    case 'owner_webrtc_ice': {
+      const info = wsRegistry.get(ws);
+      if (info?.type !== 'owner') return;
+      const { candidate } = msg;
+      const { clientId } = info;
+      const clientWs = connectedClients.get(clientId);
+      if (clientWs && clientWs.readyState === WebSocket.OPEN) {
+        send(clientWs, { type: 'webrtc_ice', candidate });
+      }
+      break;
+    }
+
     // ════════════════════════════════════════
     //  HEARTBEAT CLIENT
     // ════════════════════════════════════════
@@ -280,20 +358,30 @@ async function handleMessage(ws, msg, ip) {
     }
 
     // ════════════════════════════════════════
-    //  WEBRTC ANSWER  (client → admin)
+    //  WEBRTC ANSWER  (client → admin ou owner)
     // ════════════════════════════════════════
     case 'webrtc_answer': {
       const { targetAdminSID, answer } = msg;
 
+      // Chercher d'abord dans adminSessions
       const adminWs = adminSessions.get(targetAdminSID);
       if (adminWs && adminWs.readyState === WebSocket.OPEN) {
         send(adminWs, { type: 'webrtc_answer', answer });
         console.log(`[RTC] Answer: client → admin(${targetAdminSID})`);
-      } else {
-        // Fallback: diffuser à tous les admins connectés
-        console.warn(`[RTC] Admin(${targetAdminSID}) introuvable, broadcast fallback`);
-        broadcastAdmins({ type: 'webrtc_answer', answer });
+        break;
       }
+
+      // Sinon chercher dans ownerSessions
+      const ownerEntry = ownerSessions.get(targetAdminSID);
+      if (ownerEntry && ownerEntry.ws.readyState === WebSocket.OPEN) {
+        send(ownerEntry.ws, { type: 'webrtc_answer', answer });
+        console.log(`[RTC] Answer: client → owner(${targetAdminSID})`);
+        break;
+      }
+
+      // Fallback: diffuser à tous les admins connectés
+      console.warn(`[RTC] Dest(${targetAdminSID}) introuvable, broadcast fallback`);
+      broadcastAdmins({ type: 'webrtc_answer', answer });
       break;
     }
 
@@ -310,11 +398,18 @@ async function handleMessage(ws, msg, ip) {
           send(dest, { type: 'webrtc_ice', candidate });
         }
       } else if (direction === 'to_admin') {
+        // Chercher admin d'abord
         const dest = adminSessions.get(targetId);
         if (dest && dest.readyState === WebSocket.OPEN) {
           send(dest, { type: 'webrtc_ice', candidate });
         } else {
-          broadcastAdmins({ type: 'webrtc_ice', candidate });
+          // Chercher owner ensuite
+          const ownerEntry = ownerSessions.get(targetId);
+          if (ownerEntry && ownerEntry.ws.readyState === WebSocket.OPEN) {
+            send(ownerEntry.ws, { type: 'webrtc_ice', candidate });
+          } else {
+            broadcastAdmins({ type: 'webrtc_ice', candidate });
+          }
         }
       }
       break;
@@ -329,12 +424,23 @@ async function handleMessage(ws, msg, ip) {
         const dest = connectedClients.get(targetId);
         if (dest) send(dest, { type: 'webrtc_end' });
       } else {
-        const dest = adminSessions.get(targetId);
-        if (dest) send(dest, { type: 'webrtc_end' });
+        const destAdmin = adminSessions.get(targetId);
+        if (destAdmin) { send(destAdmin, { type: 'webrtc_end' }); return; }
+        const destOwner = ownerSessions.get(targetId);
+        if (destOwner) send(destOwner.ws, { type: 'webrtc_end' });
       }
       break;
     }
 
+    // FIN SESSION OWNER → client
+    case 'owner_webrtc_end': {
+      const info = wsRegistry.get(ws);
+      if (info?.type !== 'owner') return;
+      const clientWs = connectedClients.get(info.clientId);
+      if (clientWs) send(clientWs, { type: 'webrtc_end' });
+      break;
+    }
+
     default:
       console.log('[WS] Message inconnu:', type);
   }
@@ -359,6 +465,9 @@ function handleDisconnect(ws) {
     dbAddHistory(id, 'disconnect');
     notifyAdmins({ type: 'client_disconnected', clientId: id });
     console.log(`[WS] Client déconnecté: ${id}`);
+  } else if (info.type === 'owner') {
+    ownerSessions.delete(info.id);
+    console.log(`[WS] Owner déconnecté: ${info.id} (client: ${info.clientId})`);
   } else if (info.type === 'admin') {
     adminSessions.delete(info.id);
     console.log(`[WS] Admin déconnecté: ${info.id}`);