fix: multiple bug fixes

isolated users, db backup, weird disconnect issues for long voice sessions,

toju-app/src/app/infrastructure/realtime/README.md

@@ -121,6 +121,8 @@ Each signaling URL gets its own `SignalingManager` (one WebSocket each). `Signal
 
 Room affinity is authoritative at this layer as well. The renderer repairs each room's saved `sourceId` / `sourceUrl` from server-directory responses and routes `join_server`, `view_server`, and room-scoped signaling traffic to that room's signaling URL first. If that route fails, alternate endpoints can be tried temporarily, but server-scoped raw messages are no longer broadcast to every connected signaling manager when the route is unknown.
 
+In UI/debug conversations, a **chat-server** means one of the saved rooms navigated from the server rail. Each chat-server has its own assigned signal server via `sourceId` / `sourceUrl`, and room-scoped feature/config checks must prefer that signal server before considering any global active endpoint. For example, KLIPY GIF picker visibility is resolved against the currently viewed chat-server's signal server so an unrelated offline chat-server does not hide the button everywhere.
+
 Cold-start routing now waits for the initial server-directory health probes so same-backend aliases can collapse to one canonical signaling endpoint before any saved rooms reconnect. When a room is reconnected on a chosen socket, its background rooms are re-joined on that same socket as well so stale per-signal memberships do not keep orphan managers alive, and reconnect replay only sends `view_server` for rooms that manager still has joined.
 
 This is still a non-federated model. Different signaling servers do not share peer registries or relay WebRTC offers for each other, so users in the same room must converge on the same signaling endpoint to discover one another reliably.
@@ -152,6 +154,8 @@ sequenceDiagram
 
 When the WebSocket drops, `SignalingManager` schedules reconnection with exponential backoff (1s, 2s, 4s, ... up to 30s). On reconnect it replays the cached `identify` and `join_server` messages so presence is restored without the UI doing anything.
 
+The browser also sends a lightweight `keepalive` message on the signaling socket during long-lived sessions. The server treats both WebSocket pong frames and any inbound client message as liveness, so users who are still active in voice or chat are not removed from server presence just because control-frame pong delivery stalls behind a proxy or runtime quirk.
+
 ### Server-side connection hygiene
 
 Browsers do not reliably fire WebSocket close events during page refresh or navigation (especially Chromium). The server's `handleIdentify` now closes any existing connection that shares the same `oderId` but a different `connectionId`. This guarantees `findUserByOderId` always routes offers and presence events to the freshest socket, eliminating a class of bugs where signaling messages landed on a dead tab's socket and were silently lost.

toju-app/src/app/infrastructure/realtime/realtime.constants.ts

@@ -29,6 +29,8 @@ export const PEER_DISCONNECT_GRACE_MS = 10_000;
 
 /** Interval (ms) for broadcasting state heartbeats */
 export const STATE_HEARTBEAT_INTERVAL_MS = 5_000;
+/** Interval (ms) for application-level signaling keepalive messages */
+export const SIGNALING_KEEPALIVE_INTERVAL_MS = 25_000;
 /** Interval (ms) for broadcasting voice presence */
 export const VOICE_HEARTBEAT_INTERVAL_MS = 5_000;
 
@@ -85,6 +87,7 @@ export const SIGNALING_TYPE_SERVER_USERS = 'server_users';
 export const SIGNALING_TYPE_USER_JOINED = 'user_joined';
 export const SIGNALING_TYPE_USER_LEFT = 'user_left';
 export const SIGNALING_TYPE_ACCESS_DENIED = 'access_denied';
+export const SIGNALING_TYPE_KEEPALIVE = 'keepalive';
 
 export const P2P_TYPE_STATE_REQUEST = 'state-request';
 export const P2P_TYPE_VOICE_STATE_REQUEST = 'voice-state-request';

toju-app/src/app/infrastructure/realtime/signaling/signaling.manager.ts

@@ -17,8 +17,10 @@ import {
   SIGNALING_RECONNECT_MAX_DELAY_MS,
   SIGNALING_CONNECT_TIMEOUT_MS,
   STATE_HEARTBEAT_INTERVAL_MS,
+  SIGNALING_KEEPALIVE_INTERVAL_MS,
   SIGNALING_TYPE_IDENTIFY,
   SIGNALING_TYPE_JOIN_SERVER,
+  SIGNALING_TYPE_KEEPALIVE,
   SIGNALING_TYPE_VIEW_SERVER
 } from '../realtime.constants';
 
@@ -39,6 +41,7 @@ export class SignalingManager {
   private signalingReconnectAttempts = 0;
   private signalingReconnectTimer: ReturnType<typeof setTimeout> | null = null;
   private stateHeartbeatTimer: ReturnType<typeof setInterval> | null = null;
+  private lastKeepaliveSentAt = 0;
 
   /** Fires every heartbeat tick - the main service hooks this to broadcast state. */
   readonly heartbeatTick$ = new Subject<void>();
@@ -391,7 +394,11 @@ export class SignalingManager {
   /** Start the heartbeat interval that drives periodic state broadcasts. */
   private startHeartbeat(): void {
     this.stopHeartbeat();
-    this.stateHeartbeatTimer = setInterval(() => this.heartbeatTick$.next(), STATE_HEARTBEAT_INTERVAL_MS);
+    this.lastKeepaliveSentAt = Date.now();
+    this.stateHeartbeatTimer = setInterval(() => {
+      this.heartbeatTick$.next();
+      this.sendKeepaliveIfDue();
+    }, STATE_HEARTBEAT_INTERVAL_MS);
   }
 
   /** Stop the heartbeat interval. */
@@ -400,6 +407,28 @@ export class SignalingManager {
       clearInterval(this.stateHeartbeatTimer);
       this.stateHeartbeatTimer = null;
     }
+
+    this.lastKeepaliveSentAt = 0;
+  }
+
+  private sendKeepaliveIfDue(): void {
+    const now = Date.now();
+
+    if (now - this.lastKeepaliveSentAt < SIGNALING_KEEPALIVE_INTERVAL_MS) {
+      return;
+    }
+
+    this.lastKeepaliveSentAt = now;
+
+    try {
+      this.sendRawMessage({ type: SIGNALING_TYPE_KEEPALIVE });
+    } catch (error) {
+      this.logger.warn('[signaling] Failed to send signaling keepalive', {
+        error,
+        readyState: this.getSocketReadyStateLabel(),
+        url: this.lastSignalingUrl
+      });
+    }
   }
 
   /** Clean up all resources. */