Add warning screen when server is added after community creation

CHANGELOG.md

@@ -118,6 +118,7 @@
 ### Features
 
 * Adds hcaptcha verification for protected QSS actions [#2908](https://github.com/TryQuiet/quiet/issues/2908)
+* Added warning popup when a server was unexpectedly added to chain [#2907](https://github.com/TryQuiet/quiet/issues/2907)
 * Messages can now be relayed using QSS [#2805](https://github.com/TryQuiet/quiet/issues/2805)
 * Messages can be retrieved from QSS stores [#2806](https://github.com/TryQuiet/quiet/issues/2806)
 * Profile photos are now uploaded via IPFS [#3048](https://github.com/TryQuiet/quiet/issues/3048)

packages/backend/src/nest/auth/sigchain.service.ts

@@ -13,7 +13,7 @@ import {
 import { KeyMetadata } from '@localfirst/crdx'
 import { LocalDbService } from '../local-db/local-db.service'
 import { createLogger } from '../common/logger'
-import { SocketEvents, StorableKey } from '@quiet/types'
+import { SocketEvents, StorableKey, type User } from '@quiet/types'
 import { type RoleService } from './services/roles/role.service'
 import { type DeviceService } from './services/members/device.service'
 import { type InviteService } from './services/invites/invite.service'
@@ -144,8 +144,17 @@ export class SigChainService extends EventEmitter {
   }
 
   private handleChainUpdate = async (teamId: string) => {
-    this.saveChain(teamId)
-    this.logger.info('Chain updated, emitted updated event')
+    const chain = this.getChain(teamId, false)
+    if (chain?.team != null) {
+      const users = chain.team.members().map(user => ({
+        userId: user.userId,
+        roles: user.roles,
+        isRegistered: true,
+        isDuplicated: false,
+      })) as User[]
+      this.serverIoProvider.io.emit(SocketEvents.USERS_UPDATED, { users })
+    }
+
     void this._updateKeysOnChainUpdate(teamId).catch(err => {
       this.logger.error('Failed to update iOS keychain on chain update', err)
     })
@@ -155,6 +164,20 @@ export class SigChainService extends EventEmitter {
     })
     this.emit(SigchainEvents.UPDATED, teamId)
     this.logger.info('Chain updated, emitted updated event')
+
+    if (chain?.team != null) {
+      const community = await this.localDbService.getCurrentCommunity()
+      if (community) {
+        const teamServerHosts = chain.team.servers().map(s => s.host)
+        const communityHostsSet = new Set(community.serverHosts?.map(sh => sh.hostUrl) || [])
+        const teamHostsSet = new Set(teamServerHosts)
+        const setsAreEqual =
+          communityHostsSet.size === teamHostsSet.size && [...communityHostsSet].every(h => teamHostsSet.has(h))
+        if (!setsAreEqual && teamServerHosts.length > 0) {
+          this.serverIoProvider.io.emit(SocketEvents.SERVER_ADDED, { id: community.id, serverHosts: teamServerHosts })
+        }
+      }
+    }
   }
 
   /**

packages/backend/src/nest/connections-manager/connections-manager.service.spec.ts

@@ -4,7 +4,7 @@ import fs from 'fs'
 import path from 'path'
 import { Test, TestingModule } from '@nestjs/testing'
 import { getReduxStoreFactory, prepareStore, type Store } from '@quiet/state-manager'
-import { CommunityOwnership, SocketActions, type Community, type Identity } from '@quiet/types'
+import { CommunityOwnership, SocketActions, SocketEvents, type Community, type Identity } from '@quiet/types'
 import { type FactoryGirl } from 'factory-girl'
 import { TestModule } from '../common/test.module'
 import { removeFilesFromDir } from '../common/utils'
@@ -630,4 +630,71 @@ describe('ConnectionsManagerService', () => {
     expect(leaveCommunitySpy).toHaveBeenCalledTimes(1)
     expect(callback).toHaveBeenCalledWith(false)
   })
+
+  it('adds a debug server to the sigchain while marking it as known locally', async () => {
+    const originalIsE2E = process.env.IS_E2E
+    process.env.IS_E2E = 'true'
+    const serverHost = 'unknown-server.example.com'
+
+    try {
+      await localDbService.setCommunity({ ...community, serverHosts: [] })
+      await localDbService.setCurrentCommunityId(community.id)
+      await sigChainService.loadChain(community.teamId, true)
+      connectionsManagerService['attachSocketServiceListeners']()
+      const emitSpy = jest.spyOn(connectionsManagerService.serverIoProvider.io, 'emit')
+
+      connectionsManagerService['socketService'].emit(SocketActions.DEBUG_ADD_SERVER, {
+        serverHosts: [serverHost],
+      })
+
+      await waitForExpect(async () => {
+        expect(sigChainService.activeChain.team?.hasServer(serverHost)).toBe(true)
+        expect(await localDbService.getCommunity(community.id)).toMatchObject({
+          serverHosts: [{ hostUrl: serverHost, accepted: true }],
+        })
+        expect(emitSpy).toHaveBeenCalledWith(SocketEvents.COMMUNITY_UPDATED, {
+          id: community.id,
+          updates: { serverHosts: [{ hostUrl: serverHost, accepted: true }] },
+        })
+      })
+    } finally {
+      if (originalIsE2E == null) {
+        delete process.env.IS_E2E
+      } else {
+        process.env.IS_E2E = originalIsE2E
+      }
+    }
+  })
+
+  it('persists ToS and starts QSS when an unexpected server is accepted', async () => {
+    const qssEndpoint = 'wss://qss.example.com'
+    await localDbService.setCommunity({
+      ...community,
+      qssEnabled: false,
+      tosAccepted: false,
+      qssEndpoint,
+      serverHosts: [{ hostUrl: 'qss.example.com', accepted: false }],
+    })
+    await localDbService.setCurrentCommunityId(community.id)
+    await connectionsManagerService.init()
+    const connectSpy = jest.spyOn(qssService, 'connect').mockResolvedValue(QSSOperationResult.SUCCESS)
+
+    connectionsManagerService['socketService'].emit(SocketActions.UPDATE_COMMUNITY, {
+      id: community.id,
+      updates: {
+        qssEnabled: true,
+        tosAccepted: true,
+        serverHosts: [{ hostUrl: 'qss.example.com', accepted: true }],
+      },
+    })
+
+    await waitForExpect(async () => {
+      expect(await localDbService.getCommunity(community.id)).toMatchObject({
+        qssEnabled: true,
+        tosAccepted: true,
+        serverHosts: [{ hostUrl: 'qss.example.com', accepted: true }],
+      })
+      expect(connectSpy).toHaveBeenCalledWith(qssEndpoint)
+    })
+  })
 })

packages/backend/src/nest/connections-manager/connections-manager.service.ts

@@ -6,6 +6,7 @@ import { EventEmitter } from 'events'
 import getPort from 'get-port'
 import { Agent } from 'https'
 import { CryptoEngine, setEngine } from 'pkijs'
+import * as url from 'node:url'
 import { createPeerId, generateLibp2pPSK } from '../common/utils'
 
 import { createLibp2pAddress, isPSKcodeValid } from '@quiet/common'
@@ -49,13 +50,15 @@ import {
   DeleteChannelPayload,
   SetUserProfilePayload,
   SetUserProfileResponse,
+  ServerHost,
   AddMembersChannelPayload,
   AddMembersChannelResponse,
   PublicChannel,
   User,
   UserProfilesUpdatedPayload,
   UpdateCommunityPayload,
   ChannelOperationStatus,
+  DebugAddServerPayload,
 } from '@quiet/types'
 import { CONFIG_OPTIONS, QSS_ALLOWED, QSS_ENDPOINT, SERVER_IO_PROVIDER, SOCKS_PROXY_AGENT } from '../const'
 import { Libp2pService, Libp2pState } from '../libp2p/libp2p.service'
@@ -81,6 +84,7 @@ import { SigchainEvents } from '../auth/types'
 import { QPSService } from '../qps/qps.service'
 import { CaptchaService } from '../captcha/captcha.service'
 import { SigChain } from '../auth/sigchain'
+import { createKeyset, redactKeys, type Server } from '@localfirst/auth'
 
 /**
  * A monolith service that handles lots of events received from the state-manager.
@@ -637,7 +641,7 @@ export class ConnectionsManagerService extends EventEmitter implements OnModuleI
       psk: generateLibp2pPSK().psk,
       ownership: CommunityOwnership.Owner,
       teamId: sigchain.teamId!,
-      qssEnabled: this.qssAllowed && payload.useServer,
+      qssEnabled: this.qssAllowed && payload.useServer && payload.tosAccepted,
       qssEndpoint: this.qssEndpoint,
       tosAccepted: payload.tosAccepted,
     }
@@ -736,6 +740,19 @@ export class ConnectionsManagerService extends EventEmitter implements OnModuleI
       ownership: CommunityOwnership.User,
       qssEnabled: inviteData.version === InvitationDataVersion.v5 ? inviteData.qssEnabled : undefined,
       qssEndpoint: inviteData.version === InvitationDataVersion.v5 ? inviteData.qssEndpoint : undefined,
+      tosAccepted: payload.tosAccepted,
+    }
+
+    if (community.qssEnabled && payload.tosAccepted && community.qssEndpoint) {
+      if (this.qssEndpoint) {
+        let host = url.parse(this.qssEndpoint).hostname
+        if (host === '127.0.0.1') {
+          host = 'localhost'
+        }
+        if (host) {
+          community.serverHosts = [{ hostUrl: host, accepted: true } as ServerHost]
+        }
+      }
     }
 
     await this.localDbService.setCommunity(community)
@@ -1066,6 +1083,32 @@ export class ConnectionsManagerService extends EventEmitter implements OnModuleI
       }
     })
 
+    this.socketService.on(SocketActions.UPDATE_COMMUNITY, async (payload: UpdateCommunityPayload) => {
+      this.logger.info(`socketService - ${SocketActions.UPDATE_COMMUNITY}`)
+      const community = await this.localDbService.getCommunity(payload.id)
+      if (!community) {
+        this.logger.error(`No community found with id ${payload.id}`)
+        return
+      }
+      const updatedCommunity = { ...community, ...payload.updates }
+      await this.localDbService.setCommunity(updatedCommunity)
+
+      const qssBecameUsable =
+        updatedCommunity.qssEnabled && updatedCommunity.tosAccepted && (!community.qssEnabled || !community.tosAccepted)
+      if (qssBecameUsable) {
+        await this.qssService.connect(updatedCommunity.qssEndpoint)
+      }
+    })
+
+    this.socketService.on(SocketActions.DEBUG_ADD_SERVER, async (payload: DebugAddServerPayload) => {
+      this.logger.info(`socketService - ${SocketActions.DEBUG_ADD_SERVER}`)
+      try {
+        await this.debugAddServer(payload)
+      } catch (e) {
+        this.logger.error('Error while adding a debug server', e)
+      }
+    })
+
     // Local First Auth
 
     this.socketService.on(
@@ -1205,6 +1248,53 @@ export class ConnectionsManagerService extends EventEmitter implements OnModuleI
     })
   }
 
+  private async debugAddServer(payload: DebugAddServerPayload): Promise<void> {
+    if (process.env.NODE_ENV !== 'development' && process.env.IS_E2E !== 'true') {
+      this.logger.warn('Ignoring debug server request outside development and E2E')
+      return
+    }
+
+    const community = await this.localDbService.getCurrentCommunity()
+    if (!community) {
+      this.logger.warn('No active community found for debug server request')
+      return
+    }
+
+    const sigChain = this.sigChainService.getActiveChain(false)
+    if (!sigChain?.team || sigChain.teamId !== community.teamId) {
+      this.logger.warn(`No active sigchain found for community ${community.id}`)
+      return
+    }
+
+    const serverHosts = [...new Set(payload.serverHosts.map(host => host.trim()).filter(Boolean))]
+    if (serverHosts.length === 0) {
+      return
+    }
+
+    const knownHosts = new Map(community.serverHosts?.map(server => [server.hostUrl, server]) ?? [])
+    for (const hostUrl of serverHosts) {
+      knownHosts.set(hostUrl, { hostUrl, accepted: true })
+    }
+    const updatedServerHosts = [...knownHosts.values()]
+
+    await this.localDbService.setCommunity({ ...community, serverHosts: updatedServerHosts })
+    this.serverIoProvider.io.emit(SocketEvents.COMMUNITY_UPDATED, {
+      id: community.id,
+      updates: { serverHosts: updatedServerHosts },
+    })
+
+    for (const host of serverHosts) {
+      if (sigChain.team.hasServer(host)) {
+        continue
+      }
+      const server: Server = {
+        host,
+        keys: redactKeys(createKeyset({ type: 'SERVER', name: host })),
+      }
+      sigChain.server.addServer(server)
+    }
+  }
+
   /**
    * Handle events from the sigchain service and update data in the state manager
    */

packages/backend/src/nest/qss/qss-sync-manager.service.ts

@@ -986,6 +986,7 @@ export class QSSSyncManager implements OnModuleDestroy, OnModuleInit {
       communityInitialized: false,
       qssEnabled: false,
       qssSetup: false,
+      tosAccepted: false,
       community,
     }
     if (community == null) {
@@ -994,8 +995,9 @@ export class QSSSyncManager implements OnModuleDestroy, OnModuleInit {
 
     return {
       ...status,
-      qssEnabled: (community as any).qssEnabled ?? false,
-      qssSetup: (community as any).qssSetup ?? false,
+      qssEnabled: community.qssEnabled ?? false,
+      qssSetup: community.qssSetup ?? false,
+      tosAccepted: community.tosAccepted ?? false,
       communityInitialized: true,
     }
   }

packages/backend/src/nest/qss/qss.service.spec.ts

@@ -203,14 +203,16 @@ describe('QSSService', () => {
   })
 
   interface InitCommunitySettings {
-    qssEnabled: boolean
-    qssSetup: boolean
+    qssEnabled?: boolean
+    qssSetup?: boolean
+    tosAccepted?: boolean
   }
-  const initCommunity = async (
-    settings: InitCommunitySettings = { qssEnabled: true, qssSetup: false }
-  ): Promise<Community> => {
+  const initCommunity = async (settings: InitCommunitySettings = {}): Promise<Community> => {
     await localDbService.setCommunity({
       ...community,
+      qssEnabled: true,
+      qssSetup: false,
+      tosAccepted: true,
       ...settings,
     })
     await localDbService.setCurrentCommunityId(community.id)
@@ -312,6 +314,14 @@ describe('QSSService', () => {
       expect(qssService.canConnect).toBeFalsy()
     })
 
+    it(`doesn't connect to QSS when enabled but TOS isn't accepted`, async () => {
+      await initCommunity({ tosAccepted: false, qssEnabled: true, qssSetup: false })
+      mockedAllowed = jest.spyOn(qssService, 'qssAllowed', 'get').mockReturnValue(true)
+      await qssService.connect('ws://localhost:3000')
+      expect(qssService.connected).toBeFalsy()
+      expect(qssService.canConnect).toBeTruthy()
+    })
+
     it('reconnects when the requested QSS endpoint changes', async () => {
       await initCommunity()
       mockedAllowed = jest.spyOn(qssService, 'qssAllowed', 'get').mockReturnValue(true)
@@ -815,6 +825,7 @@ describe('QSSService', () => {
           ...community,
           teamId: 'team-id',
           qssEnabled: true,
+          tosAccepted: true,
         })
         await localDbService.setCurrentCommunityId(community.id)
         await localDbService.setIdentity(userIdentity)
@@ -844,6 +855,7 @@ describe('QSSService', () => {
           ...community,
           teamId: 'team-id',
           qssEnabled: true,
+          tosAccepted: true,
         })
         await localDbService.setCurrentCommunityId(community.id)
         await localDbService.setIdentity(userIdentity)
@@ -873,6 +885,7 @@ describe('QSSService', () => {
           ...community,
           teamId: 'team-id',
           qssEnabled: true,
+          tosAccepted: true,
         })
         await localDbService.setCurrentCommunityId(community.id)
         await localDbService.setIdentity(userIdentity)
@@ -903,6 +916,7 @@ describe('QSSService', () => {
           ...community,
           teamId: 'team-id',
           qssEnabled: true,
+          tosAccepted: true,
         })
         await localDbService.setCurrentCommunityId(community.id)
         await localDbService.setIdentity(userIdentity)
@@ -1034,7 +1048,7 @@ describe('QSSService', () => {
 
   describe('sendLogEntrySyncMessage', () => {
     it(`sends a successful log sync to QSS`, async () => {
-      await initCommunity({ qssEnabled: true, qssSetup: true })
+      await initCommunity({ qssEnabled: true, qssSetup: true, tosAccepted: true })
       const initStatusOrig = await qssService.getQssInitStatus()
       expect(initStatusOrig.qssSetup).toBeTruthy()
       const syncSeq = 41
@@ -1282,7 +1296,7 @@ describe('QSSService', () => {
     })
 
     it(`fails to send log sync to QSS and writes pending message to local DB`, async () => {
-      await initCommunity({ qssEnabled: true, qssSetup: true })
+      await initCommunity({ qssEnabled: true, qssSetup: true, tosAccepted: true })
       const initStatusOrig = await qssService.getQssInitStatus()
       expect(initStatusOrig.qssSetup).toBeTruthy()