Merge remote-tracking branch 'origin/master' into ab/self-chat

2026-03-31 14:06:05 +00:00 · 2024-01-02 14:56:50 +02:00
parent d49a7ff784 c9b1d54f13
commit 4eebb4e746
189 changed files with 9827 additions and 5620 deletions
--- a/src/Simplex/Chat.hs
+++ b/src/Simplex/Chat.hs
@@ -5,7 +5,6 @@
 {-# LANGUAGE LambdaCase #-}
 {-# LANGUAGE MultiWayIf #-}
 {-# LANGUAGE NamedFieldPuns #-}
-{-# LANGUAGE OverloadedRecordDot #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE RankNTypes #-}
 {-# LANGUAGE ScopedTypeVariables #-}
@@ -280,8 +279,9 @@ newChatController
    where
      configServers :: DefaultAgentServers
      configServers =
-        let smp' = fromMaybe (defaultServers.smp) (nonEmpty smpServers)
-            xftp' = fromMaybe (defaultServers.xftp) (nonEmpty xftpServers)
+        let DefaultAgentServers {smp = defSmp, xftp = defXftp} = defaultServers
+            smp' = fromMaybe defSmp (nonEmpty smpServers)
+            xftp' = fromMaybe defXftp (nonEmpty xftpServers)
         in defaultServers {smp = smp', xftp = xftp', netCfg = networkConfig}
      agentServers :: ChatConfig -> IO InitialAgentServers
      agentServers config@ChatConfig {defaultServers = defServers@DefaultAgentServers {ntf, netCfg}} = do
@@ -308,9 +308,9 @@ activeAgentServers ChatConfig {defaultServers} p =
    . filter (\ServerCfg {enabled} -> enabled)

 cfgServers :: UserProtocol p => SProtocolType p -> (DefaultAgentServers -> NonEmpty (ProtoServerWithAuth p))
-cfgServers p s = case p of
-  SPSMP -> s.smp
-  SPXFTP -> s.xftp
+cfgServers p DefaultAgentServers {smp, xftp} = case p of
+  SPSMP -> smp
+  SPXFTP -> xftp

 startChatController :: forall m. ChatMonad' m => Bool -> Bool -> Bool -> m (Async ())
 startChatController subConns enableExpireCIs startXFTPWorkers = do
@@ -1014,7 +1014,8 @@ processChatCommand' vr = \case
      pure $ CRContactConnectionDeleted user conn
    CTGroup -> do
      Group gInfo@GroupInfo {membership} members <- withStore $ \db -> getGroup db vr user chatId
-      let isOwner = membership.memberRole == GROwner
+      let GroupMember {memberRole = membershipMemRole} = membership
+      let isOwner = membershipMemRole == GROwner
          canDelete = isOwner || not (memberCurrent membership)
      unless canDelete $ throwChatError $ CEGroupUserRole gInfo GROwner
      filesInfo <- withStore' $ \db -> getGroupFileInfo db user gInfo
@@ -1666,11 +1667,12 @@ processChatCommand' vr = \case
        inv@ReceivedGroupInvitation {fromMember} <- getGroupInvitation db vr user groupId
        (inv,) <$> getContactViaMember db user fromMember
      let ReceivedGroupInvitation {fromMember, connRequest, groupInfo = g@GroupInfo {membership}} = invitation
+          GroupMember {memberId = membershipMemId} = membership
          Contact {activeConn} = ct
      case activeConn of
        Just Connection {peerChatVRange} -> do
          subMode <- chatReadVar subscriptionMode
-          dm <- directMessage $ XGrpAcpt membership.memberId
+          dm <- directMessage $ XGrpAcpt membershipMemId
          agentConnId <- withAgent $ \a -> joinConnection a (aUserId user) True connRequest dm subMode
          withStore' $ \db -> do
            createMemberConnection db userId fromMember agentConnId (fromJVersionRange peerChatVRange) subMode
@@ -1822,12 +1824,12 @@ processChatCommand' vr = \case
        pure $ CRNewMemberContact user ct g m
      _ -> throwChatError CEGroupMemberNotActive
  APISendMemberContactInvitation contactId msgContent_ -> withUser $ \user -> do
-    (g, m, ct, cReq) <- withStore $ \db -> getMemberContact db vr user contactId
+    (g@GroupInfo {groupId}, m, ct, cReq) <- withStore $ \db -> getMemberContact db vr user contactId
    when (contactGrpInvSent ct) $ throwChatError $ CECommandError "x.grp.direct.inv already sent"
    case memberConn m of
      Just mConn -> do
        let msg = XGrpDirectInv cReq msgContent_
-        (sndMsg, _) <- sendDirectMessage mConn msg (GroupId $ g.groupId)
+        (sndMsg, _) <- sendDirectMessage mConn msg $ GroupId groupId
        withStore' $ \db -> setContactGrpInvSent db ct True
        let ct' = ct {contactGrpInvSent = True}
        forM_ msgContent_ $ \mc -> do
@@ -2258,7 +2260,8 @@ processChatCommand' vr = \case
      when (displayName /= validName) $ throwChatError CEInvalidDisplayName {displayName, validName}
    assertUserGroupRole :: GroupInfo -> GroupMemberRole -> m ()
    assertUserGroupRole g@GroupInfo {membership} requiredRole = do
-      when (membership.memberRole < requiredRole) $ throwChatError $ CEGroupUserRole g requiredRole
+      let GroupMember {memberRole = membershipMemRole} = membership
+      when (membershipMemRole < requiredRole) $ throwChatError $ CEGroupUserRole g requiredRole
      when (memberStatus membership == GSMemInvited) $ throwChatError (CEGroupNotJoined g)
      when (memberRemoved membership) $ throwChatError CEGroupMemberUserRemoved
      unless (memberActive membership) $ throwChatError CEGroupMemberNotActive
@@ -2302,7 +2305,7 @@ processChatCommand' vr = \case
    forwardFile chatName fileId sendCommand = withUser $ \user -> do
      withStore (\db -> getFileTransfer db user fileId) >>= \case
        FTRcv RcvFileTransfer {fileStatus = RFSComplete RcvFileInfo {filePath}, cryptoArgs} -> forward filePath cryptoArgs
-        FTSnd {fileTransferMeta = FileTransferMeta {filePath, xftpSndFile}} -> forward filePath $ xftpSndFile >>= \f -> f.cryptoArgs
+        FTSnd {fileTransferMeta = FileTransferMeta {filePath, xftpSndFile}} -> forward filePath $ xftpSndFile >>= \XFTPSndFile {cryptoArgs} -> cryptoArgs
        _ -> throwChatError CEFileNotReceived {fileId}
      where
        forward path cfArgs = processChatCommand . sendCommand chatName $ CryptoFile path cfArgs
@@ -2394,7 +2397,7 @@ processChatCommand' vr = \case
        _ -> throwChatError $ CECommandError "not supported"
      processChatCommand $ APISetChatSettings (ChatRef cType chatId) $ updateSettings chatSettings
    connectPlan :: User -> AConnectionRequestUri -> m ConnectionPlan
-    connectPlan user (ACR SCMInvitation cReq) = do
+    connectPlan user (ACR SCMInvitation (CRInvitationUri crData e2e)) = do
      withStore' (\db -> getConnectionEntityByConnReq db vr user cReqSchemas) >>= \case
        Nothing -> pure $ CPInvitationLink ILPOk
        Just (RcvDirectMsgConnection conn ct_) -> do
@@ -2410,13 +2413,12 @@ processChatCommand' vr = \case
        Just _ -> throwChatError $ CECommandError "found connection entity is not RcvDirectMsgConnection"
      where
        cReqSchemas :: (ConnReqInvitation, ConnReqInvitation)
-        cReqSchemas = case cReq of
-          (CRInvitationUri crData e2e) ->
-            ( CRInvitationUri crData {crScheme = CRSSimplex} e2e,
-              CRInvitationUri crData {crScheme = simplexChat} e2e
-            )
-    connectPlan user (ACR SCMContact cReq) = do
-      let CRContactUri ConnReqUriData {crClientData} = cReq
+        cReqSchemas =
+          ( CRInvitationUri crData {crScheme = CRSSimplex} e2e,
+            CRInvitationUri crData {crScheme = simplexChat} e2e
+          )
+    connectPlan user (ACR SCMContact (CRContactUri crData)) = do
+      let ConnReqUriData {crClientData} = crData
          groupLinkId = crClientData >>= decodeJSON >>= \(CRDataGroup gli) -> Just gli
      case groupLinkId of
        -- contact address
@@ -2456,11 +2458,10 @@ processChatCommand' vr = \case
                  | otherwise -> pure $ CPGroupLink GLPOk
      where
        cReqSchemas :: (ConnReqContact, ConnReqContact)
-        cReqSchemas = case cReq of
-          (CRContactUri crData) ->
-            ( CRContactUri crData {crScheme = CRSSimplex},
-              CRContactUri crData {crScheme = simplexChat}
-            )
+        cReqSchemas =
+          ( CRContactUri crData {crScheme = CRSSimplex},
+            CRContactUri crData {crScheme = simplexChat}
+          )
        cReqHashes :: (ConnReqUriHash, ConnReqUriHash)
        cReqHashes = bimap hash hash cReqSchemas
        hash = ConnReqUriHash . C.sha256Hash . strEncode
@@ -3628,9 +3629,10 @@ processAgentMessageConn vr user@User {userId} corrId agentConnId agentMessage =
            case chatMsgEvent of
              XGrpMemInfo memId _memProfile
                | sameMemberId memId m -> do
+                    let GroupMember {memberId = membershipMemId} = membership
                    -- TODO update member profile
                    -- [async agent commands] no continuation needed, but command should be asynchronous for stability
-                    allowAgentConnectionAsync user conn' confId $ XGrpMemInfo membership.memberId (fromLocalProfile $ memberProfile membership)
+                    allowAgentConnectionAsync user conn' confId $ XGrpMemInfo membershipMemId (fromLocalProfile $ memberProfile membership)
                | otherwise -> messageError "x.grp.mem.info: memberId is different from expected"
              _ -> messageError "CONF from member must have x.grp.mem.info"
      INFO connInfo -> do
@@ -3660,7 +3662,11 @@ processAgentMessageConn vr user@User {userId} corrId agentConnId agentMessage =
            createGroupFeatureItems gInfo m
            let GroupInfo {groupProfile = GroupProfile {description}} = gInfo
            memberConnectedChatItem gInfo m
-            forM_ description $ groupDescriptionChatItem gInfo m
+            unless expectHistory $ forM_ description $ groupDescriptionChatItem gInfo m
+            where
+              expectHistory =
+                groupFeatureAllowed SGFHistory gInfo
+                  && isCompatibleRange (memberChatVRange' m) groupHistoryIncludeWelcomeVRange
          GCInviteeMember -> do
            memberConnectedChatItem gInfo m
            toView $ CRJoinedGroupMember user gInfo m {memberStatus = GSMemConnected}
@@ -3703,8 +3709,15 @@ processAgentMessageConn vr user@User {userId} corrId agentConnId agentMessage =
                  (errs', events) <- partitionEithers <$> mapM (tryChatError . itemForwardEvents) items
                  let errors = map ChatErrorStore errs <> errs'
                  unless (null errors) $ toView $ CRChatErrors (Just user) errors
-                  forM_ (L.nonEmpty $ concat events) $ \events' ->
-                    sendGroupMemberMessages user conn events' groupId
+                  let events' = maybe (concat events) (\x -> concat events <> [x]) descrEvent_
+                  forM_ (L.nonEmpty events') $ \events'' ->
+                    sendGroupMemberMessages user conn events'' groupId
+              descrEvent_ :: Maybe (ChatMsgEvent 'Json)
+              descrEvent_
+                | isCompatibleRange (memberChatVRange' m) groupHistoryIncludeWelcomeVRange = do
+                    let GroupInfo {groupProfile = GroupProfile {description}} = gInfo
+                    fmap (\descr -> XMsgNew $ MCSimple $ extMsgContent (MCText descr) Nothing) description
+                | otherwise = Nothing
              itemForwardEvents :: CChatItem 'CTGroup -> m [ChatMsgEvent 'Json]
              itemForwardEvents cci = case cci of
                (CChatItem SMDRcv ci@ChatItem {chatDir = CIGroupRcv sender, content = CIRcvMsgContent mc, file}) -> do
@@ -3745,7 +3758,7 @@ processAgentMessageConn vr user@User {userId} corrId agentConnId agentMessage =
                            fInv = xftpFileInvitation fileName fileSize fInvDescr
                         in Just (fInv, fileDescrText)
                    | otherwise = Nothing
-                  processContentItem :: GroupMember -> ChatItem 'CTGroup d -> MsgContent -> Maybe (FileInvitation, RcvFileDescrText) -> m [ChatMsgEvent Json]
+                  processContentItem :: GroupMember -> ChatItem 'CTGroup d -> MsgContent -> Maybe (FileInvitation, RcvFileDescrText) -> m [ChatMsgEvent 'Json]
                  processContentItem sender ChatItem {meta, quotedItem} mc fInvDescr_ =
                    if isNothing fInvDescr_ && not (msgContentHasText mc)
                      then pure []
@@ -3780,17 +3793,18 @@ processAgentMessageConn vr user@User {userId} corrId agentConnId agentMessage =
                    when (memCategory == GCPreMember) $ probeMatchingContactsAndMembers ct connectedIncognito True
            sendXGrpMemCon memCategory
            where
+              GroupMember {memberId} = m
              sendXGrpMemCon = \case
                GCPreMember ->
                  forM_ (invitedByGroupMemberId membership) $ \hostId -> do
                    host <- withStore $ \db -> getGroupMember db user groupId hostId
                    forM_ (memberConn host) $ \hostConn ->
-                      void $ sendDirectMessage hostConn (XGrpMemCon m.memberId) (GroupId groupId)
+                      void $ sendDirectMessage hostConn (XGrpMemCon memberId) (GroupId groupId)
                GCPostMember ->
                  forM_ (invitedByGroupMemberId m) $ \invitingMemberId -> do
                    im <- withStore $ \db -> getGroupMember db user groupId invitingMemberId
                    forM_ (memberConn im) $ \imConn ->
-                      void $ sendDirectMessage imConn (XGrpMemCon m.memberId) (GroupId groupId)
+                      void $ sendDirectMessage imConn (XGrpMemCon memberId) (GroupId groupId)
                _ -> messageWarning "sendXGrpMemCon: member category GCPreMember or GCPostMember is expected"
      MSG msgMeta _msgFlags msgBody -> do
        checkIntegrityCreateItem (CDGroupRcv gInfo m) msgMeta `catchChatError` \_ -> pure ()
@@ -3803,7 +3817,8 @@ processAgentMessageConn vr user@User {userId} corrId agentConnId agentMessage =
            Left e -> toView $ CRChatError (Just user) (ChatError . CEException $ "error parsing chat message: " <> e)
          checkSendRcpt $ rights aChatMsgs
        -- currently only a single message is forwarded
-        when (membership.memberRole >= GRAdmin) $ case aChatMsgs of
+        let GroupMember {memberRole = membershipMemRole} = membership
+        when (membershipMemRole >= GRAdmin) $ case aChatMsgs of
          [Right (ACMsg _ chatMsg)] -> forwardMsg_ chatMsg
          _ -> pure ()
        where
@@ -3863,8 +3878,9 @@ processAgentMessageConn vr user@User {userId} corrId agentConnId agentMessage =
                  else pure []
              -- invited members to which this member was introduced
              invitedMembers <- withStore' $ \db -> getForwardInvitedMembers db user m highlyAvailable
-              let ms = introducedMembers <> invitedMembers
-                  msg = XGrpMsgForward m.memberId chatMsg' brokerTs
+              let GroupMember {memberId} = m
+                  ms = introducedMembers <> invitedMembers
+                  msg = XGrpMsgForward memberId chatMsg' brokerTs
              unless (null ms) . void $
                sendGroupMessage user gInfo ms msg
      RCVD msgMeta msgRcpt ->
@@ -4125,8 +4141,8 @@ processAgentMessageConn vr user@User {userId} corrId agentConnId agentMessage =
                _ -> toView $ CRReceivedContactRequest user cReq

    memberCanSend :: GroupMember -> m () -> m ()
-    memberCanSend mem a
-      | mem.memberRole <= GRObserver = messageError "member is not allowed to send messages"
+    memberCanSend GroupMember {memberRole} a
+      | memberRole <= GRObserver = messageError "member is not allowed to send messages"
      | otherwise = a

    incAuthErrCounter :: ConnectionEntity -> Connection -> AgentErrorType -> m ()
@@ -4748,12 +4764,12 @@ processAgentMessageConn vr user@User {userId} corrId agentConnId agentMessage =
        when (fromRole < GRAdmin || fromRole < memRole) $ throwChatError (CEGroupContactRole c)
        when (fromMemId == memId) $ throwChatError CEGroupDuplicateMemberId
        -- [incognito] if direct connection with host is incognito, create membership using the same incognito profile
-        (gInfo@GroupInfo {groupId, localDisplayName, groupProfile, membership = membership@GroupMember {groupMemberId, memberId}}, hostId) <-
-          withStore $ \db -> createGroupInvitation db vr user ct inv customUserProfileId
+        (gInfo@GroupInfo {groupId, localDisplayName, groupProfile, membership}, hostId) <- withStore $ \db -> createGroupInvitation db vr user ct inv customUserProfileId
+        let GroupMember {groupMemberId, memberId = membershipMemId} = membership
        if sameGroupLinkId groupLinkId groupLinkId'
          then do
            subMode <- chatReadVar subscriptionMode
-            dm <- directMessage $ XGrpAcpt memberId
+            dm <- directMessage $ XGrpAcpt membershipMemId
            connIds <- joinAgentConnectionAsync user True connRequest dm subMode
            withStore' $ \db -> do
              setViaGroupLinkHash db groupId connId
@@ -4865,7 +4881,7 @@ processAgentMessageConn vr user@User {userId} corrId agentConnId agentMessage =

    createGroupFeatureItems :: GroupInfo -> GroupMember -> m ()
    createGroupFeatureItems g@GroupInfo {fullGroupPreferences} m =
-      forM_ allGroupFeatureItems $ \(AGF f) -> do
+      forM_ allGroupFeatures $ \(AGF f) -> do
        let p = getGroupPreference f fullGroupPreferences
            (_, param) = groupFeatureState p
        createInternalChatItem user (CDGroupRcv g m) (CIRcvGroupFeature (toGroupFeature f) (toGroupPreference p) param) Nothing
@@ -5184,6 +5200,7 @@ processAgentMessageConn vr user@User {userId} corrId agentConnId agentMessage =

    xGrpMemFwd :: GroupInfo -> GroupMember -> MemberInfo -> IntroInvitation -> m ()
    xGrpMemFwd gInfo@GroupInfo {membership, chatSettings} m memInfo@(MemberInfo memId memRole memChatVRange _) introInv@IntroInvitation {groupConnReq, directConnReq} = do
+      let GroupMember {memberId = membershipMemId} = membership
      checkHostRole m memRole
      toMember <-
        withStore' (\db -> runExceptT $ getGroupMemberByMemberId db user gInfo memId) >>= \case
@@ -5196,7 +5213,7 @@ processAgentMessageConn vr user@User {userId} corrId agentConnId agentMessage =
      withStore' $ \db -> saveMemberInvitation db toMember introInv
      subMode <- chatReadVar subscriptionMode
      -- [incognito] send membership incognito profile, create direct connection as incognito
-      dm <- directMessage $ XGrpMemInfo membership.memberId (fromLocalProfile $ memberProfile membership)
+      dm <- directMessage $ XGrpMemInfo membershipMemId (fromLocalProfile $ memberProfile membership)
      -- [async agent commands] no continuation needed, but commands should be asynchronous for stability
      groupConnIds <- joinAgentConnectionAsync user (chatHasNtfs chatSettings) groupConnReq dm subMode
      directConnIds <- forM directConnReq $ \dcr -> joinAgentConnectionAsync user True dcr dm subMode
@@ -5206,7 +5223,7 @@ processAgentMessageConn vr user@User {userId} corrId agentConnId agentMessage =

    xGrpMemRole :: GroupInfo -> GroupMember -> MemberId -> GroupMemberRole -> RcvMessage -> UTCTime -> m ()
    xGrpMemRole gInfo@GroupInfo {membership} m@GroupMember {memberRole = senderRole} memId memRole msg brokerTs
-      | membership.memberId == memId =
+      | membershipMemId == memId =
          let gInfo' = gInfo {membership = membership {memberRole = memRole}}
           in changeMemberRole gInfo' membership $ RGEUserRole memRole
      | otherwise =
@@ -5214,6 +5231,7 @@ processAgentMessageConn vr user@User {userId} corrId agentConnId agentMessage =
            Right member -> changeMemberRole gInfo member $ RGEMemberRole (groupMemberId' member) (fromLocalProfile $ memberProfile member) memRole
            Left _ -> messageError "x.grp.mem.role with unknown member ID"
      where
+        GroupMember {memberId = membershipMemId} = membership
        changeMemberRole gInfo' member@GroupMember {memberRole = fromRole} gEvent
          | senderRole < GRAdmin || senderRole < fromRole = messageError "x.grp.mem.role with insufficient member permissions"
          | otherwise = do
@@ -5267,7 +5285,8 @@ processAgentMessageConn vr user@User {userId} corrId agentConnId agentMessage =

    xGrpMemDel :: GroupInfo -> GroupMember -> MemberId -> RcvMessage -> UTCTime -> m ()
    xGrpMemDel gInfo@GroupInfo {membership} m@GroupMember {memberRole = senderRole} memId msg brokerTs = do
-      if membership.memberId == memId
+      let GroupMember {memberId = membershipMemId} = membership
+      if membershipMemId == memId
        then checkRole membership $ do
          deleteGroupLinkIfExists user gInfo
          -- member records are not deleted to keep history
@@ -5379,8 +5398,8 @@ processAgentMessageConn vr user@User {userId} corrId agentConnId agentMessage =
      createInternalChatItem user (CDDirectRcv ct) (CIRcvConnEvent RCEVerificationCodeReset) Nothing

    xGrpMsgForward :: GroupInfo -> GroupMember -> MemberId -> ChatMessage 'Json -> UTCTime -> m ()
-    xGrpMsgForward gInfo@GroupInfo {groupId} m memberId msg msgTs = do
-      when (m.memberRole < GRAdmin) $ throwChatError (CEGroupContactRole m.localDisplayName)
+    xGrpMsgForward gInfo@GroupInfo {groupId} m@GroupMember {memberRole, localDisplayName} memberId msg msgTs = do
+      when (memberRole < GRAdmin) $ throwChatError (CEGroupContactRole localDisplayName)
      author <- withStore $ \db -> getGroupMemberByMemberId db user gInfo memberId
      processForwardedMsg author msg
      where
@@ -5557,7 +5576,7 @@ parseFileChunk :: ChatMonad m => ByteString -> m FileChunk
 parseFileChunk = liftEither . first (ChatError . CEFileRcvChunk) . smpDecode

 appendFileChunk :: forall m. ChatMonad m => RcvFileTransfer -> Integer -> ByteString -> Bool -> m ()
-appendFileChunk ft@RcvFileTransfer {fileId, fileStatus, cryptoArgs} chunkNo chunk final =
+appendFileChunk ft@RcvFileTransfer {fileId, fileStatus, cryptoArgs, fileInvitation = FileInvitation {fileName}} chunkNo chunk final =
  case fileStatus of
    RFSConnected RcvFileInfo {filePath} -> append_ filePath
    -- sometimes update of file transfer status to FSConnected
@@ -5575,7 +5594,7 @@ appendFileChunk ft@RcvFileTransfer {fileId, fileStatus, cryptoArgs} chunkNo chun
      when final $ do
        closeFileHandle fileId rcvFiles
        forM_ cryptoArgs $ \cfArgs -> do
-          tmpFile <- getChatTempDirectory >>= (`uniqueCombine` ft.fileInvitation.fileName)
+          tmpFile <- getChatTempDirectory >>= (`uniqueCombine` fileName)
          tryChatError (liftError encryptErr $ encryptFile fsFilePath tmpFile cfArgs) >>= \case
            Right () -> do
              removeFile fsFilePath `catchChatError` \_ -> pure ()
@@ -5790,7 +5809,7 @@ sendGroupMessage user GroupInfo {groupId} members chatMsgEvent = do
 data MemberSendAction = MSASend Connection | MSAPending

 memberSendAction :: ChatMsgEvent e -> [GroupMember] -> GroupMember -> Maybe MemberSendAction
-memberSendAction chatMsgEvent members m = case memberConn m of
+memberSendAction chatMsgEvent members m@GroupMember {invitedByGroupMemberId} = case memberConn m of
  Nothing -> pendingOrForwarded
  Just conn@Connection {connStatus}
    | connDisabled conn || connStatus == ConnDeleted -> Nothing
@@ -5805,7 +5824,7 @@ memberSendAction chatMsgEvent members m = case memberConn m of
        forwardSupported =
          let mcvr = memberChatVRange' m
           in isCompatibleRange mcvr groupForwardVRange && invitingMemberSupportsForward
-        invitingMemberSupportsForward = case m.invitedByGroupMemberId of
+        invitingMemberSupportsForward = case invitedByGroupMemberId of
          Just invMemberId ->
            -- can be optimized for large groups by replacing [GroupMember] with Map GroupMemberId GroupMember
            case find (\m' -> groupMemberId' m' == invMemberId) members of
@@ -5860,34 +5879,33 @@ saveDirectRcvMSG conn@Connection {connId} agentMsgMeta agentAckCmdId msgBody =

 saveGroupRcvMsg :: (MsgEncodingI e, ChatMonad m) => User -> GroupId -> GroupMember -> Connection -> MsgMeta -> CommandId -> MsgBody -> ChatMessage e -> m (GroupMember, Connection, RcvMessage)
 saveGroupRcvMsg user groupId authorMember conn@Connection {connId} agentMsgMeta agentAckCmdId msgBody ChatMessage {chatVRange, msgId = sharedMsgId_, chatMsgEvent} = do
-  (am', conn') <- updateMemberChatVRange authorMember conn chatVRange
+  (am'@GroupMember {memberId = amMemId, groupMemberId = amGroupMemId}, conn') <- updateMemberChatVRange authorMember conn chatVRange
  let agentMsgId = fst $ recipient agentMsgMeta
      newMsg = NewRcvMessage {chatMsgEvent, msgBody}
      rcvMsgDelivery = RcvMsgDelivery {connId, agentMsgId, agentMsgMeta, agentAckCmdId}
-      amId = Just am'.groupMemberId
  msg <-
-    withStore (\db -> createNewMessageAndRcvMsgDelivery db (GroupId groupId) newMsg sharedMsgId_ rcvMsgDelivery amId)
+    withStore (\db -> createNewMessageAndRcvMsgDelivery db (GroupId groupId) newMsg sharedMsgId_ rcvMsgDelivery $ Just amGroupMemId)
      `catchChatError` \e -> case e of
        ChatErrorStore (SEDuplicateGroupMessage _ _ _ (Just forwardedByGroupMemberId)) -> do
          fm <- withStore $ \db -> getGroupMember db user groupId forwardedByGroupMemberId
          forM_ (memberConn fm) $ \fmConn ->
-            void $ sendDirectMessage fmConn (XGrpMemCon am'.memberId) (GroupId groupId)
+            void $ sendDirectMessage fmConn (XGrpMemCon amMemId) (GroupId groupId)
          throwError e
        _ -> throwError e
  pure (am', conn', msg)

 saveGroupFwdRcvMsg :: (MsgEncodingI e, ChatMonad m) => User -> GroupId -> GroupMember -> GroupMember -> MsgBody -> ChatMessage e -> m RcvMessage
-saveGroupFwdRcvMsg user groupId forwardingMember refAuthorMember msgBody ChatMessage {msgId = sharedMsgId_, chatMsgEvent} = do
+saveGroupFwdRcvMsg user groupId forwardingMember refAuthorMember@GroupMember {memberId = refMemberId} msgBody ChatMessage {msgId = sharedMsgId_, chatMsgEvent} = do
  let newMsg = NewRcvMessage {chatMsgEvent, msgBody}
      fwdMemberId = Just $ groupMemberId' forwardingMember
      refAuthorId = Just $ groupMemberId' refAuthorMember
  withStore (\db -> createNewRcvMessage db (GroupId groupId) newMsg sharedMsgId_ refAuthorId fwdMemberId)
    `catchChatError` \e -> case e of
      ChatErrorStore (SEDuplicateGroupMessage _ _ (Just authorGroupMemberId) Nothing) -> do
-        am <- withStore $ \db -> getGroupMember db user groupId authorGroupMemberId
-        if sameMemberId refAuthorMember.memberId am
+        am@GroupMember {memberId = amMemberId} <- withStore $ \db -> getGroupMember db user groupId authorGroupMemberId
+        if sameMemberId refMemberId am
          then forM_ (memberConn forwardingMember) $ \fmConn ->
-            void $ sendDirectMessage fmConn (XGrpMemCon am.memberId) (GroupId groupId)
+            void $ sendDirectMessage fmConn (XGrpMemCon amMemberId) (GroupId groupId)
          else toView $ CRMessageError user "error" "saveGroupFwdRcvMsg: referenced author member id doesn't match message member id"
        throwError e
      _ -> throwError e
@@ -6039,7 +6057,9 @@ createSndFeatureItems :: forall m. ChatMonad m => User -> Contact -> Contact ->
 createSndFeatureItems user ct ct' =
  createFeatureItems user ct ct' CDDirectSnd CISndChatFeature CISndChatPreference getPref
  where
-    getPref u = (userPreference u).preference
+    getPref ContactUserPreference {userPreference} = case userPreference of
+      CUPContact {preference} -> preference
+      CUPUser {preference} -> preference

 type FeatureContent a d = ChatFeature -> a -> Maybe Int -> CIContent d

@@ -6075,7 +6095,7 @@ createFeatureItems user Contact {mergedPreferences = cups} ct'@Contact {mergedPr

 createGroupFeatureChangedItems :: (MsgDirectionI d, ChatMonad m) => User -> ChatDirection 'CTGroup d -> (GroupFeature -> GroupPreference -> Maybe Int -> CIContent d) -> GroupInfo -> GroupInfo -> m ()
 createGroupFeatureChangedItems user cd ciContent GroupInfo {fullGroupPreferences = gps} GroupInfo {fullGroupPreferences = gps'} =
-  forM_ allGroupFeatureItems $ \(AGF f) -> do
+  forM_ allGroupFeatures $ \(AGF f) -> do
    let state = groupFeatureState $ getGroupPreference f gps
        pref' = getGroupPreference f gps'
        state'@(_, int') = groupFeatureState pref'
@@ -6131,8 +6151,8 @@ getCreateActiveUser st testView = do
            Left e -> putStrLn ("database error " <> show e) >> exitFailure
            Right user -> pure user
    selectUser :: [User] -> IO User
-    selectUser [user] = do
-      withTransaction st (`setActiveUser` user.userId)
+    selectUser [user@User {userId}] = do
+      withTransaction st (`setActiveUser` userId)
      pure user
    selectUser users = do
      putStrLn "Select user profile:"
@@ -6146,8 +6166,8 @@ getCreateActiveUser st testView = do
            Just n
              | n <= 0 || n > length users -> putStrLn "invalid user number" >> loop
              | otherwise -> do
-                  let user = users !! (n - 1)
-                  withTransaction st (`setActiveUser` user.userId)
+                  let user@User {userId} = users !! (n - 1)
+                  withTransaction st (`setActiveUser` userId)
                  pure user
    userStr :: User -> String
    userStr User {localDisplayName, profile = LocalProfile {fullName}} =
--- a/src/Simplex/Chat/Messages.hs
+++ b/src/Simplex/Chat/Messages.hs
@@ -5,7 +5,6 @@
 {-# LANGUAGE KindSignatures #-}
 {-# LANGUAGE LambdaCase #-}
 {-# LANGUAGE NamedFieldPuns #-}
-{-# LANGUAGE OverloadedRecordDot #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE StandaloneDeriving #-}
@@ -372,7 +371,9 @@ contactTimedTTL Contact {mergedPreferences = ContactUserPreferences {timedMessag
  | forUser enabled && forContact enabled = Just ttl
  | otherwise = Nothing
  where
-    TimedMessagesPreference {ttl} = userPreference.preference
+    TimedMessagesPreference {ttl} = case userPreference of
+      CUPContact {preference} -> preference
+      CUPUser {preference} -> preference

 groupTimedTTL :: GroupInfo -> Maybe (Maybe Int)
 groupTimedTTL GroupInfo {fullGroupPreferences = FullGroupPreferences {timedMessages = TimedMessagesGroupPreference {enable, ttl}}}
--- a/src/Simplex/Chat/Messages/Batch.hs
+++ b/src/Simplex/Chat/Messages/Batch.hs
@@ -16,7 +16,6 @@ import Simplex.Chat.Controller (ChatError (..), ChatErrorType (..))
 import Simplex.Chat.Messages

 data MsgBatch = MsgBatch Builder [SndMessage]
-  deriving (Show)

 -- | Batches [SndMessage] into batches of ByteString builders in form of JSON arrays.
 -- Does not check if the resulting batch is a valid JSON.
--- a/src/Simplex/Chat/Mobile/Shared.hs
+++ b/src/Simplex/Chat/Mobile/Shared.hs
@@ -16,12 +16,12 @@ type JSONByteString = LB.ByteString
 getByteString :: Ptr Word8 -> CInt -> IO ByteString
 getByteString ptr len = do
  fp <- newForeignPtr_ ptr
-  pure $ BS fp $ fromIntegral len
+  pure $ PS fp 0 (fromIntegral len)
 {-# INLINE getByteString #-}

 putByteString :: Ptr Word8 -> ByteString -> IO ()
-putByteString ptr (BS fp len) =
-  withForeignPtr fp $ \p -> memcpy ptr p len
+putByteString ptr (PS fp offset len) =
+  withForeignPtr fp $ \p -> memcpy ptr (p `plusPtr` offset) len
 {-# INLINE putByteString #-}

 putLazyByteString :: Ptr Word8 -> LB.ByteString -> IO ()
--- a/src/Simplex/Chat/Protocol.hs
+++ b/src/Simplex/Chat/Protocol.hs
@@ -56,7 +56,7 @@ import Simplex.Messaging.Version hiding (version)
 -- This indirection is needed for backward/forward compatibility testing.
 -- Testing with real app versions is still needed, as tests use the current code with different version ranges, not the old code.
 currentChatVersion :: Version
-currentChatVersion = 5
+currentChatVersion = 6

 -- This should not be used directly in code, instead use `chatVRange` from ChatConfig (see comment above)
 supportedChatVRange :: VersionRange
@@ -82,6 +82,10 @@ groupForwardVRange = mkVersionRange 4 currentChatVersion
 batchSendVRange :: VersionRange
 batchSendVRange = mkVersionRange 5 currentChatVersion

+-- version range that supports sending group welcome message in group history
+groupHistoryIncludeWelcomeVRange :: VersionRange
+groupHistoryIncludeWelcomeVRange = mkVersionRange 6 currentChatVersion
+
 data ConnectionEntity
  = RcvDirectMsgConnection {entityConnection :: Connection, contact :: Maybe Contact}
  | RcvGroupMsgConnection {entityConnection :: Connection, groupInfo :: GroupInfo, groupMember :: GroupMember}
--- a/src/Simplex/Chat/Store/Direct.hs
+++ b/src/Simplex/Chat/Store/Direct.hs
@@ -2,7 +2,6 @@
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE LambdaCase #-}
 {-# LANGUAGE NamedFieldPuns #-}
-{-# LANGUAGE OverloadedRecordDot #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE QuasiQuotes #-}
 {-# LANGUAGE ScopedTypeVariables #-}
@@ -490,7 +489,7 @@ createOrUpdateContactRequest db user@User {userId} userContactLinkId invId (Vers
        ExceptT $
          maybeM getContactRequestByXContactId xContactId_ >>= \case
            Nothing -> createContactRequest
-            Just cr -> updateContactRequest cr $> Right cr.contactRequestId
+            Just cr@UserContactRequest {contactRequestId} -> updateContactRequest cr $> Right contactRequestId
      getContactRequest db user cReqId
    createContactRequest :: IO (Either StoreError Int64)
    createContactRequest = do
--- a/src/Simplex/Chat/Store/Files.hs
+++ b/src/Simplex/Chat/Store/Files.hs
@@ -3,7 +3,6 @@
 {-# LANGUAGE GADTs #-}
 {-# LANGUAGE LambdaCase #-}
 {-# LANGUAGE NamedFieldPuns #-}
-{-# LANGUAGE OverloadedRecordDot #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE QuasiQuotes #-}
 {-# LANGUAGE ScopedTypeVariables #-}
@@ -978,7 +977,7 @@ getLocalCryptoFile db userId fileId sent =
    [(Just _, Nothing, _)] -> do
      unless sent $ throwError $ SEFileNotFound fileId
      FileTransferMeta {filePath, xftpSndFile} <- getFileTransferMeta_ db userId fileId
-      pure $ CryptoFile filePath $ xftpSndFile >>= \f -> f.cryptoArgs
+      pure $ CryptoFile filePath $ xftpSndFile >>= \XFTPSndFile {cryptoArgs} -> cryptoArgs
    [(Nothing, Nothing, FPLocal)] -> do
      LocalFileMeta {filePath, fileCryptoArgs} <- getLocalFileMeta db userId fileId
      pure $ CryptoFile filePath fileCryptoArgs
--- a/src/Simplex/Chat/Store/Groups.hs
+++ b/src/Simplex/Chat/Store/Groups.hs
@@ -2,7 +2,6 @@
 {-# LANGUAGE DuplicateRecordFields #-}
 {-# LANGUAGE LambdaCase #-}
 {-# LANGUAGE NamedFieldPuns #-}
-{-# LANGUAGE OverloadedRecordDot #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE QuasiQuotes #-}
 {-# LANGUAGE RecordWildCards #-}
@@ -320,7 +319,7 @@ createNewGroup db vr gVar user@User {userId} groupProfile incognitoProfile = Exc
 -- | creates a new group record for the group the current user was invited to, or returns an existing one
 createGroupInvitation :: DB.Connection -> VersionRange -> User -> Contact -> GroupInvitation -> Maybe ProfileId -> ExceptT StoreError IO (GroupInfo, GroupMemberId)
 createGroupInvitation _ _ _ Contact {localDisplayName, activeConn = Nothing} _ _ = throwError $ SEContactNotReady localDisplayName
-createGroupInvitation db vr user@User {userId} contact@Contact {contactId, activeConn = Just hostConn@Connection {customUserProfileId}} GroupInvitation {fromMember, invitedMember, connRequest, groupProfile} incognitoProfileId = do
+createGroupInvitation db vr user@User {userId} contact@Contact {contactId, activeConn = Just Connection {customUserProfileId, peerChatVRange}} GroupInvitation {fromMember, invitedMember, connRequest, groupProfile} incognitoProfileId = do
  liftIO getInvitationGroupId_ >>= \case
    Nothing -> createGroupInvitation_
    Just gId -> do
@@ -358,7 +357,7 @@ createGroupInvitation db vr user@User {userId} contact@Contact {contactId, activ
              "INSERT INTO groups (group_profile_id, local_display_name, inv_queue_info, host_conn_custom_user_profile_id, user_id, enable_ntfs, created_at, updated_at, chat_ts) VALUES (?,?,?,?,?,?,?,?,?)"
              (profileId, localDisplayName, connRequest, customUserProfileId, userId, True, currentTs, currentTs, currentTs)
            insertedRowId db
-          let JVersionRange hostVRange = hostConn.peerChatVRange
+          let JVersionRange hostVRange = peerChatVRange
          GroupMember {groupMemberId} <- createContactMemberInv_ db user groupId Nothing contact fromMember GCHostMember GSMemInvited IBUnknown Nothing currentTs hostVRange
          membership <- createContactMemberInv_ db user groupId (Just groupMemberId) user invitedMember GCUserMember GSMemInvited (IBContact contactId) incognitoProfileId currentTs vr
          let chatSettings = ChatSettings {enableNtfs = MFAll, sendRcpts = Nothing, favorite = False}
@@ -1041,7 +1040,7 @@ updateIntroStatus db introId introStatus = do
    [":intro_status" := introStatus, ":updated_at" := currentTs, ":intro_id" := introId]

 saveIntroInvitation :: DB.Connection -> GroupMember -> GroupMember -> IntroInvitation -> ExceptT StoreError IO GroupMemberIntro
-saveIntroInvitation db reMember toMember introInv = do
+saveIntroInvitation db reMember toMember introInv@IntroInvitation {groupConnReq} = do
  intro <- getIntroduction db reMember toMember
  liftIO $ do
    currentTs <- getCurrentTime
@@ -1056,7 +1055,7 @@ saveIntroInvitation db reMember toMember introInv = do
        WHERE group_member_intro_id = :intro_id
      |]
      [ ":intro_status" := GMIntroInvReceived,
-        ":group_queue_info" := introInv.groupConnReq,
+        ":group_queue_info" := groupConnReq,
        ":direct_queue_info" := directConnReq introInv,
        ":updated_at" := currentTs,
        ":intro_id" := introId intro
--- a/src/Simplex/Chat/Terminal.hs
+++ b/src/Simplex/Chat/Terminal.hs
@@ -1,12 +1,16 @@
 {-# LANGUAGE DuplicateRecordFields #-}
 {-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE NamedFieldPuns #-}
 {-# LANGUAGE OverloadedStrings #-}

 module Simplex.Chat.Terminal where

 import Control.Exception (handle, throwIO)
 import Control.Monad
+import qualified Data.ByteArray as BA
 import qualified Data.List.NonEmpty as L
+import qualified Data.Text as T
+import Data.Text.Encoding (encodeUtf8)
 import Database.SQLite.Simple (SQLError (..))
 import qualified Database.SQLite.Simple as DB
 import Simplex.Chat (defaultChatConfig)
@@ -19,7 +23,7 @@ import Simplex.Chat.Terminal.Output
 import Simplex.FileTransfer.Client.Presets (defaultXFTPServers)
 import Simplex.Messaging.Client (defaultNetworkConfig)
 import Simplex.Messaging.Util (raceAny_)
-import System.Exit (exitFailure)
+import System.IO (hFlush, hSetEcho, stdin, stdout)

 terminalChatConfig :: ChatConfig
 terminalChatConfig =
@@ -40,18 +44,29 @@ terminalChatConfig =
    }

 simplexChatTerminal :: WithTerminal t => ChatConfig -> ChatOpts -> t -> IO ()
-simplexChatTerminal cfg opts t =
-  handle checkDBKeyError . simplexChatCore cfg opts $ \u cc -> do
-    ct <- newChatTerminal t opts
-    when (firstTime cc) . printToTerminal ct $ chatWelcome u
-    runChatTerminal ct cc opts
-
-checkDBKeyError :: SQLError -> IO ()
-checkDBKeyError e = case sqlError e of
-  DB.ErrorNotADatabase -> do
-    putStrLn "Database file is invalid or you passed an incorrect encryption key"
-    exitFailure
-  _ -> throwIO e
+simplexChatTerminal cfg options t = run options
+  where
+    run opts@ChatOpts {coreOptions = coreOptions@CoreChatOpts {dbKey}} =
+      handle checkDBKeyError . simplexChatCore cfg opts $ \u cc -> do
+        ct <- newChatTerminal t opts
+        when (firstTime cc) . printToTerminal ct $ chatWelcome u
+        runChatTerminal ct cc opts
+      where
+        checkDBKeyError :: SQLError -> IO ()
+        checkDBKeyError e = case sqlError e of
+          DB.ErrorNotADatabase -> do
+            putStrLn $ "Database file is invalid or " <> if BA.null dbKey then "encrypted." else "you passed an incorrect encryption key."
+            run =<< getKeyOpts
+          _ -> throwIO e
+        getKeyOpts :: IO ChatOpts
+        getKeyOpts = do
+          putStr "Enter database encryption key (Ctrl-C to exit):"
+          hFlush stdout
+          hSetEcho stdin False
+          key <- getLine
+          hSetEcho stdin True
+          putStrLn ""
+          pure opts {coreOptions = coreOptions {dbKey = BA.convert $ encodeUtf8 $ T.pack key}}

 runChatTerminal :: ChatTerminal -> ChatController -> ChatOpts -> IO ()
 runChatTerminal ct cc opts = raceAny_ [runTerminalInput ct cc, runTerminalOutput ct cc opts, runInputLoop ct cc]
--- a/src/Simplex/Chat/Types.hs
+++ b/src/Simplex/Chat/Types.hs
@@ -9,7 +9,6 @@
 {-# LANGUAGE LambdaCase #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
 {-# LANGUAGE NamedFieldPuns #-}
-{-# LANGUAGE OverloadedRecordDot #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE PatternSynonyms #-}
 {-# LANGUAGE ScopedTypeVariables #-}
@@ -61,21 +60,21 @@ class IsContact a where
  preferences' :: a -> Maybe Preferences

 instance IsContact User where
-  contactId' u = u.userContactId
+  contactId' User {userContactId} = userContactId
  {-# INLINE contactId' #-}
-  profile' u = u.profile
+  profile' User {profile} = profile
  {-# INLINE profile' #-}
-  localDisplayName' u = u.localDisplayName
+  localDisplayName' User {localDisplayName} = localDisplayName
  {-# INLINE localDisplayName' #-}
  preferences' User {profile = LocalProfile {preferences}} = preferences
  {-# INLINE preferences' #-}

 instance IsContact Contact where
-  contactId' c = c.contactId
+  contactId' Contact {contactId} = contactId
  {-# INLINE contactId' #-}
-  profile' c = c.profile
+  profile' Contact {profile} = profile
  {-# INLINE profile' #-}
-  localDisplayName' c = c.localDisplayName
+  localDisplayName' Contact {localDisplayName} = localDisplayName
  {-# INLINE localDisplayName' #-}
  preferences' Contact {profile = LocalProfile {preferences}} = preferences
  {-# INLINE preferences' #-}
@@ -196,7 +195,7 @@ directOrUsed ct@Contact {contactUsed} =
  contactDirect ct || contactUsed

 anyDirectOrUsed :: Contact -> Bool
-anyDirectOrUsed Contact {contactUsed, activeConn} = ((\c -> c.connLevel) <$> activeConn) == Just 0 || contactUsed
+anyDirectOrUsed Contact {contactUsed, activeConn} = ((\Connection {connLevel} -> connLevel) <$> activeConn) == Just 0 || contactUsed

 contactReady :: Contact -> Bool
 contactReady Contact {activeConn} = maybe False connReady activeConn
--- a/src/Simplex/Chat/Types/Preferences.hs
+++ b/src/Simplex/Chat/Types/Preferences.hs
@@ -7,7 +7,6 @@
 {-# LANGUAGE LambdaCase #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
 {-# LANGUAGE NamedFieldPuns #-}
-{-# LANGUAGE OverloadedRecordDot #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE StandaloneDeriving #-}
@@ -79,12 +78,12 @@ allChatFeatures =
  ]

 chatPrefSel :: SChatFeature f -> Preferences -> Maybe (FeaturePreference f)
-chatPrefSel f ps = case f of
-  SCFTimedMessages -> ps.timedMessages
-  SCFFullDelete -> ps.fullDelete
-  SCFReactions -> ps.reactions
-  SCFVoice -> ps.voice
-  SCFCalls -> ps.calls
+chatPrefSel f Preferences {timedMessages, fullDelete, reactions, voice, calls} = case f of
+  SCFTimedMessages -> timedMessages
+  SCFFullDelete -> fullDelete
+  SCFReactions -> reactions
+  SCFVoice -> voice
+  SCFCalls -> calls

 chatFeature :: SChatFeature f -> ChatFeature
 chatFeature = \case
@@ -104,12 +103,12 @@ instance PreferenceI (Maybe Preferences) where
  getPreference f prefs = fromMaybe (getPreference f defaultChatPrefs) (chatPrefSel f =<< prefs)

 instance PreferenceI FullPreferences where
-  getPreference f ps = case f of
-    SCFTimedMessages -> ps.timedMessages
-    SCFFullDelete -> ps.fullDelete
-    SCFReactions -> ps.reactions
-    SCFVoice -> ps.voice
-    SCFCalls -> ps.calls
+  getPreference f FullPreferences {timedMessages, fullDelete, reactions, voice, calls} = case f of
+    SCFTimedMessages -> timedMessages
+    SCFFullDelete -> fullDelete
+    SCFReactions -> reactions
+    SCFVoice -> voice
+    SCFCalls -> calls
  {-# INLINE getPreference #-}

 setPreference :: forall f. FeatureI f => SChatFeature f -> Maybe FeatureAllowed -> Maybe Preferences -> Preferences
@@ -184,28 +183,26 @@ groupFeatureAllowed' :: GroupFeatureI f => SGroupFeature f -> FullGroupPreferenc
 groupFeatureAllowed' feature prefs =
  getField @"enable" (getGroupPreference feature prefs) == FEOn

-allGroupFeatureItems :: [AGroupFeature]
-allGroupFeatureItems =
+allGroupFeatures :: [AGroupFeature]
+allGroupFeatures =
  [ AGF SGFTimedMessages,
    AGF SGFDirectMessages,
    AGF SGFFullDelete,
    AGF SGFReactions,
    AGF SGFVoice,
-    AGF SGFFiles
+    AGF SGFFiles,
+    AGF SGFHistory
  ]

-allGroupFeatures :: [AGroupFeature]
-allGroupFeatures = allGroupFeatureItems <> [AGF SGFHistory]
-
 groupPrefSel :: SGroupFeature f -> GroupPreferences -> Maybe (GroupFeaturePreference f)
-groupPrefSel f ps = case f of
-  SGFTimedMessages -> ps.timedMessages
-  SGFDirectMessages -> ps.directMessages
-  SGFFullDelete -> ps.fullDelete
-  SGFReactions -> ps.reactions
-  SGFVoice -> ps.voice
-  SGFFiles -> ps.files
-  SGFHistory -> ps.history
+groupPrefSel f GroupPreferences {timedMessages, directMessages, fullDelete, reactions, voice, files, history} = case f of
+  SGFTimedMessages -> timedMessages
+  SGFDirectMessages -> directMessages
+  SGFFullDelete -> fullDelete
+  SGFReactions -> reactions
+  SGFVoice -> voice
+  SGFFiles -> files
+  SGFHistory -> history

 toGroupFeature :: SGroupFeature f -> GroupFeature
 toGroupFeature = \case
@@ -227,14 +224,14 @@ instance GroupPreferenceI (Maybe GroupPreferences) where
  getGroupPreference pt prefs = fromMaybe (getGroupPreference pt defaultGroupPrefs) (groupPrefSel pt =<< prefs)

 instance GroupPreferenceI FullGroupPreferences where
-  getGroupPreference f ps = case f of
-    SGFTimedMessages -> ps.timedMessages
-    SGFDirectMessages -> ps.directMessages
-    SGFFullDelete -> ps.fullDelete
-    SGFReactions -> ps.reactions
-    SGFVoice -> ps.voice
-    SGFFiles -> ps.files
-    SGFHistory -> ps.history
+  getGroupPreference f FullGroupPreferences {timedMessages, directMessages, fullDelete, reactions, voice, files, history} = case f of
+    SGFTimedMessages -> timedMessages
+    SGFDirectMessages -> directMessages
+    SGFFullDelete -> fullDelete
+    SGFReactions -> reactions
+    SGFVoice -> voice
+    SGFFiles -> files
+    SGFHistory -> history
  {-# INLINE getGroupPreference #-}

 -- collection of optional group preferences
@@ -384,19 +381,19 @@ class (Eq (FeaturePreference f), HasField "allow" (FeaturePreference f) FeatureA
  prefParam :: FeaturePreference f -> Maybe Int

 instance HasField "allow" TimedMessagesPreference FeatureAllowed where
-  hasField p = (\allow -> p {allow}, p.allow)
+  hasField p@TimedMessagesPreference {allow} = (\a -> p {allow = a}, allow)

 instance HasField "allow" FullDeletePreference FeatureAllowed where
-  hasField p = (\allow -> p {allow}, p.allow)
+  hasField p@FullDeletePreference {allow} = (\a -> p {allow = a}, allow)

 instance HasField "allow" ReactionsPreference FeatureAllowed where
-  hasField p = (\allow -> p {allow}, p.allow)
+  hasField p@ReactionsPreference {allow} = (\a -> p {allow = a}, allow)

 instance HasField "allow" VoicePreference FeatureAllowed where
-  hasField p = (\allow -> p {allow}, p.allow)
+  hasField p@VoicePreference {allow} = (\a -> p {allow = a}, allow)

 instance HasField "allow" CallsPreference FeatureAllowed where
-  hasField p = (\allow -> p {allow}, p.allow)
+  hasField p@CallsPreference {allow} = (\a -> p {allow = a}, allow)

 instance FeatureI 'CFTimedMessages where
  type FeaturePreference 'CFTimedMessages = TimedMessagesPreference
@@ -463,28 +460,28 @@ class (Eq (GroupFeaturePreference f), HasField "enable" (GroupFeaturePreference
  groupPrefParam :: GroupFeaturePreference f -> Maybe Int

 instance HasField "enable" GroupPreference GroupFeatureEnabled where
-  hasField p = (\enable -> p {enable}, p.enable)
+  hasField p@GroupPreference {enable} = (\e -> p {enable = e}, enable)

 instance HasField "enable" TimedMessagesGroupPreference GroupFeatureEnabled where
-  hasField p = (\enable -> p {enable}, p.enable)
+  hasField p@TimedMessagesGroupPreference {enable} = (\e -> p {enable = e}, enable)

 instance HasField "enable" DirectMessagesGroupPreference GroupFeatureEnabled where
-  hasField p = (\enable -> p {enable}, p.enable)
+  hasField p@DirectMessagesGroupPreference {enable} = (\e -> p {enable = e}, enable)

 instance HasField "enable" ReactionsGroupPreference GroupFeatureEnabled where
-  hasField p = (\enable -> p {enable}, p.enable)
+  hasField p@ReactionsGroupPreference {enable} = (\e -> p {enable = e}, enable)

 instance HasField "enable" FullDeleteGroupPreference GroupFeatureEnabled where
-  hasField p = (\enable -> p {enable}, p.enable)
+  hasField p@FullDeleteGroupPreference {enable} = (\e -> p {enable = e}, enable)

 instance HasField "enable" VoiceGroupPreference GroupFeatureEnabled where
-  hasField p = (\enable -> p {enable}, p.enable)
+  hasField p@VoiceGroupPreference {enable} = (\e -> p {enable = e}, enable)

 instance HasField "enable" FilesGroupPreference GroupFeatureEnabled where
-  hasField p = (\enable -> p {enable}, p.enable)
+  hasField p@FilesGroupPreference {enable} = (\e -> p {enable = e}, enable)

 instance HasField "enable" HistoryGroupPreference GroupFeatureEnabled where
-  hasField p = (\enable -> p {enable}, p.enable)
+  hasField p@HistoryGroupPreference {enable} = (\e -> p {enable = e}, enable)

 instance GroupFeatureI 'GFTimedMessages where
  type GroupFeaturePreference 'GFTimedMessages = TimedMessagesGroupPreference
@@ -722,12 +719,12 @@ preferenceState pref =
   in (allow, param)

 getContactUserPreference :: SChatFeature f -> ContactUserPreferences -> ContactUserPreference (FeaturePreference f)
-getContactUserPreference f ps = case f of
-  SCFTimedMessages -> ps.timedMessages
-  SCFFullDelete -> ps.fullDelete
-  SCFReactions -> ps.reactions
-  SCFVoice -> ps.voice
-  SCFCalls -> ps.calls
+getContactUserPreference f ContactUserPreferences {timedMessages, fullDelete, reactions, voice, calls} = case f of
+  SCFTimedMessages -> timedMessages
+  SCFFullDelete -> fullDelete
+  SCFReactions -> reactions
+  SCFVoice -> voice
+  SCFCalls -> calls

 $(J.deriveJSON (enumJSON $ dropPrefix "CF") ''ChatFeature)

--- a/src/Simplex/Chat/View.hs
+++ b/src/Simplex/Chat/View.hs
@@ -3,7 +3,6 @@
 {-# LANGUAGE GADTs #-}
 {-# LANGUAGE LambdaCase #-}
 {-# LANGUAGE NamedFieldPuns #-}
-{-# LANGUAGE OverloadedRecordDot #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE PatternSynonyms #-}
 {-# LANGUAGE ScopedTypeVariables #-}
@@ -213,7 +212,9 @@ responseToView hu@(currentRH, user_) ChatConfig {logLevel, showReactions, showRe
  CRContactConnecting u _ -> ttyUser u []
  CRContactConnected u ct userCustomProfile -> ttyUser u $ viewContactConnected ct userCustomProfile testView
  CRContactAnotherClient u c -> ttyUser u [ttyContact' c <> ": contact is connected to another client"]
-  CRSubscriptionEnd u acEntity -> ttyUser u [sShow ((entityConnection acEntity).connId) <> ": END"]
+  CRSubscriptionEnd u acEntity ->
+    let Connection {connId} = entityConnection acEntity
+     in ttyUser u [sShow connId <> ": END"]
  CRContactsDisconnected srv cs -> [plain $ "server disconnected " <> showSMPServer srv <> " (" <> contactList cs <> ")"]
  CRContactsSubscribed srv cs -> [plain $ "server connected " <> showSMPServer srv <> " (" <> contactList cs <> ")"]
  CRContactSubError u c e -> ttyUser u [ttyContact' c <> ": contact error " <> sShow e]
@@ -496,7 +497,7 @@ viewGroupSubscribed :: GroupInfo -> [StyledString]
 viewGroupSubscribed g = [membershipIncognito g <> ttyFullGroup g <> ": connected to server(s)"]

 showSMPServer :: SMPServer -> String
-showSMPServer srv = B.unpack $ strEncode srv.host
+showSMPServer ProtocolServer {host} = B.unpack $ strEncode host

 viewHostEvent :: AProtocolType -> TransportHost -> String
 viewHostEvent p h = map toUpper (B.unpack $ strEncode p) <> " host " <> B.unpack (strEncode h)
@@ -980,7 +981,7 @@ viewGroupMembers (Group GroupInfo {membership} members) = map groupMember . filt
    removedOrLeft m = let s = memberStatus m in s == GSMemRemoved || s == GSMemLeft
    groupMember m = memIncognito m <> ttyFullMember m <> ": " <> plain (intercalate ", " $ [role m] <> category m <> status m <> muted m)
    role :: GroupMember -> String
-    role m = B.unpack . strEncode $ m.memberRole
+    role GroupMember {memberRole} = B.unpack $ strEncode memberRole
    category m = case memberCategory m of
      GCUserMember -> ["you"]
      GCInviteeMember -> ["invited"]
@@ -1018,7 +1019,7 @@ viewGroupsList [] = ["you have no groups!", "to create: " <> highlight' "/g <nam
 viewGroupsList gs = map groupSS $ sortOn (ldn_ . fst) gs
  where
    ldn_ :: GroupInfo -> Text
-    ldn_ g = T.toLower g.localDisplayName
+    ldn_ GroupInfo {localDisplayName} = T.toLower localDisplayName
    groupSS (g@GroupInfo {membership, chatSettings = ChatSettings {enableNtfs}}, GroupSummary {currentMembers}) =
      case memberStatus membership of
        GSMemInvited -> groupInvitation' g
@@ -1942,7 +1943,7 @@ viewChatError logLevel testView = \case
          "[" <> connEntityLabel entity <> ", userContactLinkId: " <> sShow userContactLinkId <> ", connId: " <> cId conn <> "] "
        Nothing -> ""
      cId :: Connection -> StyledString
-      cId conn = sShow conn.connId
+      cId Connection {connId} = sShow connId
  ChatErrorRemoteCtrl e -> [plain $ "remote controller error: " <> show e]
  ChatErrorRemoteHost RHNew e -> [plain $ "new remote host error: " <> show e]
  ChatErrorRemoteHost (RHId rhId) e -> [plain $ "remote host " <> show rhId <> " error: " <> show e]