fix: Major bug cleanup pass 1

toju-app/src/app/infrastructure/realtime/realtime-session.service.ts

@@ -40,8 +40,11 @@ import { ServerSignalingCoordinator } from './signaling/server-signaling-coordin
 import { SignalingManager } from './signaling/signaling.manager';
 import { SignalingTransportHandler } from './signaling/signaling-transport-handler';
 import { WebRtcStateController } from './state/webrtc-state-controller';
-import { AuthTokenStoreService } from '../../domains/authentication';
+import { SignalServerAuthService } from '../../domains/authentication/application/services/signal-server-auth.service';
 import { ClientInstanceService } from '../../core/platform/client-instance.service';
+import { Store } from '@ngrx/store';
+import { UsersActions } from '../../store/users/users.actions';
+import { selectCurrentUser } from '../../store/users/users.selectors';
 
 @Injectable({
   providedIn: 'root'
@@ -51,8 +54,10 @@ export class WebRTCService implements OnDestroy {
   private readonly debugging = inject(DebuggingService);
   private readonly screenShareSourcePicker = inject(ScreenShareSourcePickerService);
   private readonly iceServerSettings = inject(IceServerSettingsService);
-  private readonly authTokenStore = inject(AuthTokenStoreService);
+  private readonly signalServerAuth = inject(SignalServerAuthService);
+  private readonly store = inject(Store);
   private readonly clientInstance = inject(ClientInstanceService);
+  private currentHomeUser: { id: string; homeSignalServerUrl?: string; displayName: string } | null = null;
 
   private readonly logger = new WebRTCLogger(() => this.debugging.enabled());
   private readonly state = new WebRtcStateController();
@@ -110,6 +115,16 @@ export class WebRTCService implements OnDestroy {
   private readonly remoteScreenShareRequestController: RemoteScreenShareRequestController;
 
   constructor() {
+    this.store.select(selectCurrentUser).subscribe((user) => {
+      this.currentHomeUser = user
+        ? {
+          id: user.id,
+          homeSignalServerUrl: user.homeSignalServerUrl,
+          displayName: user.displayName
+        }
+        : null;
+    });
+
     // Create managers with null callbacks first to break circular initialization
     this.peerManager = new PeerConnectionManager(this.logger, null!);
 
@@ -133,9 +148,9 @@ export class WebRTCService implements OnDestroy {
     });
 
     this.signalingCoordinator = new ServerSignalingCoordinator({
-      createManager: (_signalUrl, getLastJoinedServer, getMemberServerIds) => new SignalingManager(
+      createManager: (signalUrl, getLastJoinedServer, getMemberServerIds) => new SignalingManager(
         this.logger,
-        () => this.signalingTransportHandler.getIdentifyCredentials(),
+        () => this.signalingTransportHandler.getIdentifyCredentialsForSignalUrl(signalUrl),
         getLastJoinedServer,
         getMemberServerIds
       ),
@@ -149,20 +164,21 @@ export class WebRTCService implements OnDestroy {
       signalingCoordinator: this.signalingCoordinator,
       logger: this.logger,
       getLocalPeerId: () => this.state.getLocalPeerId(),
-      resolveSessionToken: (signalUrl) => {
-        if (signalUrl) {
-          return this.authTokenStore.getToken(signalUrl.replace(/^ws/, 'http'));
+      resolveCredential: (signalUrl) => {
+        if (!signalUrl) {
+          return null;
         }
 
-        for (const { signalUrl: connectedUrl } of this.signalingCoordinator.getConnectedSignalingManagers()) {
-          const token = this.authTokenStore.getToken(connectedUrl.replace(/^ws/, 'http'));
+        return this.signalServerAuth.resolveCredentialForSignalUrl(signalUrl, this.currentHomeUser);
+      },
+      getHomeCredential: () => {
+        const homeSignalServerUrl = this.currentHomeUser?.homeSignalServerUrl;
 
-          if (token) {
-            return token;
-          }
+        if (!homeSignalServerUrl) {
+          return null;
         }
 
-        return null;
+        return this.signalServerAuth.resolveCredentialForSignalUrl(homeSignalServerUrl, this.currentHomeUser);
       },
       getClientInstanceId: () => this.clientInstance.getClientInstanceId()
     });
@@ -283,6 +299,11 @@ export class WebRTCService implements OnDestroy {
   }
 
   private handleSignalingMessage(message: IncomingSignalingMessage, signalUrl: string): void {
+    if (message.type === 'auth_required' || message.type === 'auth_error') {
+      this.store.dispatch(UsersActions.signalServerAuthFailed({ signalUrl }));
+      return;
+    }
+
     this.signalingMessage$.next(message);
     this.signalingMessageHandler.handleMessage(message, signalUrl);
   }