send files to contacts (#94)

* schema for sending files

* send file "invitation"

* receive file "invitation"

* send/receive file flow (with stubs)

* update simplexmq

* send and receive the file (WIP - only the first chunk)

* sending and receiving file works (but it is slow)

* use correct terminal output for file sending/receiving

* improve file transfer, support cancellation

* command to show file transfer status and progress

* file transfer tests

* resume file transfer on restart (WIP)

* stabilize test of recipient cancelling file transfer

* trying to improve file transfer on restart

* update SMP block size and file chunk size

* acquire agent lock before chat lock to test whether it avoids deadlock

* fix resuming sending file on client restart

* manual message ACK (prevents losing messages between agent and chat client and stabilizes resuming file reception after restart)

* do NOT send file chunk after receiving it before it is appended to the file

* update file chunk size for SMP block size 8192 (set in smpDefaultConfig)

* save received files to ~/Downloads folder by default; create empty file when file is accepted

* keep file handle used to create empty file

* check message integrity

* fix trying to resume sending file when it was not yet accepted

* fix subscribing to pending connections on start

* update simplexmq (fixes smp-server syntax parser)

src/Simplex/Chat/Controller.hs

@@ -11,15 +11,27 @@ import Control.Monad.Except
 import Control.Monad.IO.Unlift
 import Control.Monad.Reader
 import Crypto.Random (ChaChaDRG)
+import Data.Int (Int64)
+import Data.Map.Strict (Map)
+import Numeric.Natural
 import Simplex.Chat.Notification
 import Simplex.Chat.Store (StoreError)
 import Simplex.Chat.Terminal
 import Simplex.Chat.Types
 import Simplex.Messaging.Agent (AgentClient)
+import Simplex.Messaging.Agent.Env.SQLite (AgentConfig)
 import Simplex.Messaging.Agent.Protocol (AgentErrorType)
 import Simplex.Messaging.Agent.Store.SQLite (SQLiteStore)
+import System.IO (Handle)
 import UnliftIO.STM
 
+data ChatConfig = ChatConfig
+  { agentConfig :: AgentConfig,
+    dbPoolSize :: Int,
+    tbqSize :: Natural,
+    fileChunkSize :: Integer
+  }
+
 data ChatController = ChatController
   { currentUser :: TVar User,
     smpAgent :: AgentClient,
@@ -29,7 +41,10 @@ data ChatController = ChatController
     inputQ :: TBQueue InputEvent,
     notifyQ :: TBQueue Notification,
     sendNotification :: Notification -> IO (),
-    chatLock :: TMVar ()
+    chatLock :: TMVar (),
+    sndFiles :: TVar (Map Int64 Handle),
+    rcvFiles :: TVar (Map Int64 Handle),
+    config :: ChatConfig
   }
 
 data InputEvent = InputCommand String | InputControl Char
@@ -51,6 +66,14 @@ data ChatErrorType
   | CEGroupMemberUserRemoved
   | CEGroupMemberNotFound ContactName
   | CEGroupInternal String
+  | CEFileNotFound String
+  | CEFileAlreadyReceiving String
+  | CEFileAlreadyExists FilePath
+  | CEFileRead FilePath SomeException
+  | CEFileWrite FilePath SomeException
+  | CEFileSend Int64 AgentErrorType
+  | CEFileRcvChunk String
+  | CEFileInternal String
   deriving (Show, Exception)
 
 type ChatMonad m = (MonadUnliftIO m, MonadReader ChatController m, MonadError ChatError m)

src/Simplex/Chat/Protocol.hs

@@ -23,7 +23,10 @@ import qualified Data.ByteString.Lazy.Char8 as LB
 import Data.Int (Int64)
 import Data.List (find)
 import Data.Text (Text)
+import qualified Data.Text as T
+import Data.Text.Encoding (encodeUtf8)
 import Simplex.Chat.Types
+import Simplex.Chat.Util (safeDecodeUtf8)
 import Simplex.Messaging.Agent.Protocol
 import Simplex.Messaging.Parsers (parseAll)
 import Simplex.Messaging.Util (bshow)
@@ -33,6 +36,8 @@ data ChatDirection (p :: AParty) where
   SentDirectMessage :: Contact -> ChatDirection 'Client
   ReceivedGroupMessage :: Connection -> GroupName -> GroupMember -> ChatDirection 'Agent
   SentGroupMessage :: GroupName -> ChatDirection 'Client
+  SndFileConnection :: Connection -> SndFileTransfer -> ChatDirection 'Agent
+  RcvFileConnection :: Connection -> RcvFileTransfer -> ChatDirection 'Agent
 
 deriving instance Eq (ChatDirection p)
 
@@ -42,9 +47,13 @@ fromConnection :: ChatDirection 'Agent -> Connection
 fromConnection = \case
   ReceivedDirectMessage conn _ -> conn
   ReceivedGroupMessage conn _ _ -> conn
+  SndFileConnection conn _ -> conn
+  RcvFileConnection conn _ -> conn
 
 data ChatMsgEvent
   = XMsgNew MsgContent
+  | XFile FileInvitation
+  | XFileAcpt String
   | XInfo Profile
   | XGrpInv GroupInvitation
   | XGrpAcpt MemberId
@@ -100,6 +109,13 @@ toChatMessage RawChatMessage {chatMsgId, chatMsgEvent, chatMsgParams, chatMsgBod
       t <- toMsgType mt
       files <- mapM (toContentInfo <=< parseAll contentInfoP) rawFiles
       chatMsg . XMsgNew $ MsgContent {messageType = t, files, content = body}
+    ("x.file", [name, size, qInfo]) -> do
+      let fileName = T.unpack $ safeDecodeUtf8 name
+      fileSize <- parseAll A.decimal size
+      fileQInfo <- parseAll smpQueueInfoP qInfo
+      chatMsg . XFile $ FileInvitation {fileName, fileSize, fileQInfo}
+    ("x.file.acpt", [name]) ->
+      chatMsg . XFileAcpt . T.unpack $ safeDecodeUtf8 name
     ("x.info", []) -> do
       profile <- getJSON body
       chatMsg $ XInfo profile
@@ -174,6 +190,10 @@ rawChatMessage ChatMessage {chatMsgId, chatMsgEvent, chatDAG} =
     XMsgNew MsgContent {messageType = t, files, content} ->
       let rawFiles = map (serializeContentInfo . rawContentInfo) files
        in rawMsg "x.msg.new" (rawMsgType t : rawFiles) content
+    XFile FileInvitation {fileName, fileSize, fileQInfo} ->
+      rawMsg "x.file" [encodeUtf8 $ T.pack fileName, bshow fileSize, serializeSmpQueueInfo fileQInfo] []
+    XFileAcpt fileName ->
+      rawMsg "x.file.acpt" [encodeUtf8 $ T.pack fileName] []
     XInfo profile ->
       rawMsg "x.info" [] [jsonBody profile]
     XGrpInv (GroupInvitation (fromMemId, fromRole) (memId, role) qInfo groupProfile) ->

src/Simplex/Chat/Store.hs

@@ -7,6 +7,7 @@
 {-# LANGUAGE NamedFieldPuns #-}
 {-# LANGUAGE OverloadedStrings #-}
 {-# LANGUAGE QuasiQuotes #-}
+{-# LANGUAGE RecordWildCards #-}
 {-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE TemplateHaskell #-}
 {-# LANGUAGE TupleSections #-}
@@ -27,6 +28,9 @@ module Simplex.Chat.Store
     updateUserProfile,
     updateContactProfile,
     getUserContacts,
+    getLiveSndFileTransfers,
+    getLiveRcvFileTransfers,
+    getPendingSndChunks,
     getPendingConnections,
     getContactConnections,
     getConnectionChatDirection,
@@ -58,6 +62,19 @@ module Simplex.Chat.Store
     matchReceivedProbeHash,
     matchSentProbe,
     mergeContactRecords,
+    createSndFileTransfer,
+    updateSndFileStatus,
+    createSndFileChunk,
+    updateSndFileChunkMsg,
+    updateSndFileChunkSent,
+    createRcvFileTransfer,
+    getRcvFileTransfer,
+    acceptRcvFileTransfer,
+    updateRcvFileStatus,
+    createRcvFileChunk,
+    updatedRcvFileChunkStored,
+    getFileTransfer,
+    getFileTransferProgress,
   )
 where
 
@@ -85,11 +102,11 @@ import qualified Database.SQLite.Simple as DB
 import Database.SQLite.Simple.QQ (sql)
 import Simplex.Chat.Protocol
 import Simplex.Chat.Types
-import Simplex.Messaging.Agent.Protocol (AParty (..), ConnId, SMPQueueInfo)
+import Simplex.Messaging.Agent.Protocol (AParty (..), AgentMsgId, ConnId, SMPQueueInfo)
 import Simplex.Messaging.Agent.Store.SQLite (SQLiteStore (..), createSQLiteStore, withTransaction)
 import Simplex.Messaging.Agent.Store.SQLite.Migrations (Migration (..))
 import qualified Simplex.Messaging.Crypto as C
-import Simplex.Messaging.Util (bshow, liftIOEither)
+import Simplex.Messaging.Util (bshow, liftIOEither, (<$$>))
 import System.FilePath (takeBaseName, takeExtension)
 import UnliftIO.STM
 
@@ -315,7 +332,7 @@ getContact_ db userId localDisplayName = do
           db
           [sql|
             SELECT c.connection_id, c.agent_conn_id, c.conn_level, c.via_contact,
-              c.conn_status, c.conn_type, c.contact_id, c.group_member_id, c.created_at
+              c.conn_status, c.conn_type, c.contact_id, c.group_member_id, c.snd_file_id, c.rcv_file_id, c.created_at
             FROM connections c
             WHERE c.user_id = :user_id AND c.contact_id == :contact_id
             ORDER BY c.connection_id DESC
@@ -334,9 +351,58 @@ getContact_ db userId localDisplayName = do
 getUserContacts :: MonadUnliftIO m => SQLiteStore -> User -> m [Contact]
 getUserContacts st User {userId} =
   liftIO . withTransaction st $ \db -> do
-    contactNames <- liftIO $ map fromOnly <$> DB.query db "SELECT local_display_name FROM contacts WHERE user_id = ?" (Only userId)
+    contactNames <- map fromOnly <$> DB.query db "SELECT local_display_name FROM contacts WHERE user_id = ?" (Only userId)
     rights <$> mapM (runExceptT . getContact_ db userId) contactNames
 
+getLiveSndFileTransfers :: MonadUnliftIO m => SQLiteStore -> User -> m [SndFileTransfer]
+getLiveSndFileTransfers st User {userId} =
+  liftIO . withTransaction st $ \db -> do
+    fileIds :: [Int64] <-
+      map fromOnly
+        <$> DB.query
+          db
+          [sql|
+            SELECT DISTINCT f.file_id
+            FROM files f
+            JOIN snd_files s
+            WHERE f.user_id = ? AND s.file_status IN (?, ?, ?)
+          |]
+          (userId, FSNew, FSAccepted, FSConnected)
+    concatMap (filter liveTransfer) . rights <$> mapM (getSndFileTransfers_ db userId) fileIds
+  where
+    liveTransfer :: SndFileTransfer -> Bool
+    liveTransfer SndFileTransfer {fileStatus} = fileStatus `elem` [FSNew, FSAccepted, FSConnected]
+
+getLiveRcvFileTransfers :: MonadUnliftIO m => SQLiteStore -> User -> m [RcvFileTransfer]
+getLiveRcvFileTransfers st User {userId} =
+  liftIO . withTransaction st $ \db -> do
+    fileIds :: [Int64] <-
+      map fromOnly
+        <$> DB.query
+          db
+          [sql|
+            SELECT f.file_id
+            FROM files f
+            JOIN rcv_files r
+            WHERE f.user_id = ? AND r.file_status IN (?, ?)
+          |]
+          (userId, FSAccepted, FSConnected)
+    rights <$> mapM (getRcvFileTransfer_ db userId) fileIds
+
+getPendingSndChunks :: MonadUnliftIO m => SQLiteStore -> Int64 -> Int64 -> m [Integer]
+getPendingSndChunks st fileId connId =
+  liftIO . withTransaction st $ \db ->
+    map fromOnly
+      <$> DB.query
+        db
+        [sql|
+          SELECT chunk_number
+          FROM snd_file_chunks
+          WHERE file_id = ? AND connection_id = ? AND chunk_agent_msg_id IS NULL
+          ORDER BY chunk_number
+        |]
+        (fileId, connId)
+
 getPendingConnections :: MonadUnliftIO m => SQLiteStore -> User -> m [Connection]
 getPendingConnections st User {userId} =
   liftIO . withTransaction st $ \db ->
@@ -344,12 +410,12 @@ getPendingConnections st User {userId} =
       <$> DB.queryNamed
         db
         [sql|
-          SELECT c.connection_id, c.agent_conn_id, c.conn_level, c.via_contact,
-            c.conn_status, c.conn_type, c.contact_id, c.group_member_id, c.created_at
-          FROM connections c
-          WHERE c.user_id = :user_id
-            AND c.conn_type = :conn_type
-            AND c.contact_id IS NULL
+          SELECT connection_id, agent_conn_id, conn_level, via_contact,
+            conn_status, conn_type, contact_id, group_member_id, snd_file_id, rcv_file_id, created_at
+          FROM connections
+          WHERE user_id = :user_id
+            AND conn_type = :conn_type
+            AND contact_id IS NULL
         |]
         [":user_id" := userId, ":conn_type" := ConnContact]
 
@@ -361,7 +427,7 @@ getContactConnections st userId displayName =
         db
         [sql|
           SELECT c.connection_id, c.agent_conn_id, c.conn_level, c.via_contact,
-            c.conn_status, c.conn_type, c.contact_id, c.group_member_id, c.created_at
+            c.conn_status, c.conn_type, c.contact_id, c.group_member_id, c.snd_file_id, c.rcv_file_id, c.created_at
           FROM connections c
           JOIN contacts cs ON c.contact_id == cs.contact_id
           WHERE c.user_id = :user_id
@@ -373,22 +439,24 @@ getContactConnections st userId displayName =
     connections [] = Left $ SEContactNotFound displayName
     connections rows = Right $ map toConnection rows
 
-type ConnectionRow = (Int64, ConnId, Int, Maybe Int64, ConnStatus, ConnType, Maybe Int64, Maybe Int64, UTCTime)
+type ConnectionRow = (Int64, ConnId, Int, Maybe Int64, ConnStatus, ConnType, Maybe Int64, Maybe Int64, Maybe Int64, Maybe Int64, UTCTime)
 
-type MaybeConnectionRow = (Maybe Int64, Maybe ConnId, Maybe Int, Maybe Int64, Maybe ConnStatus, Maybe ConnType, Maybe Int64, Maybe Int64, Maybe UTCTime)
+type MaybeConnectionRow = (Maybe Int64, Maybe ConnId, Maybe Int, Maybe Int64, Maybe ConnStatus, Maybe ConnType, Maybe Int64, Maybe Int64, Maybe Int64, Maybe Int64, Maybe UTCTime)
 
 toConnection :: ConnectionRow -> Connection
-toConnection (connId, agentConnId, connLevel, viaContact, connStatus, connType, contactId, groupMemberId, createdAt) =
+toConnection (connId, agentConnId, connLevel, viaContact, connStatus, connType, contactId, groupMemberId, sndFileId, rcvFileId, createdAt) =
   let entityId = entityId_ connType
    in Connection {connId, agentConnId, connLevel, viaContact, connStatus, connType, entityId, createdAt}
   where
     entityId_ :: ConnType -> Maybe Int64
     entityId_ ConnContact = contactId
     entityId_ ConnMember = groupMemberId
+    entityId_ ConnRcvFile = rcvFileId
+    entityId_ ConnSndFile = sndFileId
 
 toMaybeConnection :: MaybeConnectionRow -> Maybe Connection
-toMaybeConnection (Just connId, Just agentConnId, Just connLevel, viaContact, Just connStatus, Just connType, contactId, groupMemberId, Just createdAt) =
-  Just $ toConnection (connId, agentConnId, connLevel, viaContact, connStatus, connType, contactId, groupMemberId, createdAt)
+toMaybeConnection (Just connId, Just agentConnId, Just connLevel, viaContact, Just connStatus, Just connType, contactId, groupMemberId, sndFileId, rcvFileId, Just createdAt) =
+  Just $ toConnection (connId, agentConnId, connLevel, viaContact, connStatus, connType, contactId, groupMemberId, sndFileId, rcvFileId, createdAt)
 toMaybeConnection _ = Nothing
 
 getMatchingContacts :: MonadUnliftIO m => SQLiteStore -> UserId -> Contact -> m [Contact]
@@ -515,15 +583,17 @@ getConnectionChatDirection :: StoreMonad m => SQLiteStore -> User -> ConnId -> m
 getConnectionChatDirection st User {userId, userContactId} agentConnId =
   liftIOEither . withTransaction st $ \db -> runExceptT $ do
     c@Connection {connType, entityId} <- getConnection_ db
-    case connType of
-      ConnMember ->
-        case entityId of
-          Nothing -> throwError $ SEInternal "group member without connection"
-          Just groupMemberId -> uncurry (ReceivedGroupMessage c) <$> getGroupAndMember_ db groupMemberId c
-      ConnContact ->
-        ReceivedDirectMessage c <$> case entityId of
-          Nothing -> pure Nothing
-          Just contactId -> Just <$> getContactRec_ db contactId c
+    case entityId of
+      Nothing ->
+        if connType == ConnContact
+          then pure $ ReceivedDirectMessage c Nothing
+          else throwError $ SEInternal $ "connection " <> bshow connType <> " without entity"
+      Just entId ->
+        case connType of
+          ConnMember -> uncurry (ReceivedGroupMessage c) <$> getGroupAndMember_ db entId c
+          ConnContact -> ReceivedDirectMessage c . Just <$> getContactRec_ db entId c
+          ConnSndFile -> SndFileConnection c <$> getConnSndFileTransfer_ db entId c
+          ConnRcvFile -> RcvFileConnection c <$> ExceptT (getRcvFileTransfer_ db userId entId)
   where
     getConnection_ :: DB.Connection -> ExceptT StoreError IO Connection
     getConnection_ db = ExceptT $ do
@@ -532,7 +602,7 @@ getConnectionChatDirection st User {userId, userContactId} agentConnId =
           db
           [sql|
             SELECT connection_id, agent_conn_id, conn_level, via_contact,
-              conn_status, conn_type, contact_id, group_member_id, created_at
+              conn_status, conn_type, contact_id, group_member_id, snd_file_id, rcv_file_id, created_at
             FROM connections
             WHERE user_id = ? AND agent_conn_id = ?
           |]
@@ -578,6 +648,22 @@ getConnectionChatDirection st User {userId, userContactId} agentConnId =
       let member = toGroupMember userContactId memberRow
        in Right (groupName, (member :: GroupMember) {activeConn = Just c})
     toGroupAndMember _ _ = Left $ SEInternal "referenced group member not found"
+    getConnSndFileTransfer_ :: DB.Connection -> Int64 -> Connection -> ExceptT StoreError IO SndFileTransfer
+    getConnSndFileTransfer_ db fileId Connection {connId} =
+      ExceptT $
+        sndFileTransfer_ fileId connId
+          <$> DB.query
+            db
+            [sql|
+              SELECT s.file_status, f.file_name, f.file_size, f.chunk_size, f.file_path
+              FROM snd_files s
+              JOIN files f USING (file_id)
+              WHERE f.user_id = ? AND f.file_id = ? AND s.connection_id = ?
+            |]
+            (userId, fileId, connId)
+    sndFileTransfer_ :: Int64 -> Int64 -> [(FileStatus, String, Integer, Integer, FilePath)] -> Either StoreError SndFileTransfer
+    sndFileTransfer_ fileId connId [(fileStatus, fileName, fileSize, chunkSize, filePath)] = Right SndFileTransfer {..}
+    sndFileTransfer_ fileId _ _ = Left $ SESndFileNotFound fileId
 
 updateConnectionStatus :: MonadUnliftIO m => SQLiteStore -> Connection -> ConnStatus -> m ()
 updateConnectionStatus st Connection {connId} connStatus =
@@ -655,7 +741,7 @@ getGroup_ db User {userId, userContactId} localDisplayName = do
               m.group_member_id, m.member_id, m.member_role, m.member_category, m.member_status,
               m.invited_by, m.local_display_name, m.contact_id, p.display_name, p.full_name,
               c.connection_id, c.agent_conn_id, c.conn_level, c.via_contact,
-              c.conn_status, c.conn_type, c.contact_id, c.group_member_id, c.created_at
+              c.conn_status, c.conn_type, c.contact_id, c.group_member_id, c.snd_file_id, c.rcv_file_id, c.created_at
             FROM group_members m
             JOIN contact_profiles p ON p.contact_profile_id = m.contact_profile_id
             LEFT JOIN connections c ON c.connection_id = (
@@ -1011,7 +1097,7 @@ getViaGroupMember st User {userId, userContactId} Contact {contactId} =
             m.group_member_id, m.member_id, m.member_role, m.member_category, m.member_status,
             m.invited_by, m.local_display_name, m.contact_id, p.display_name, p.full_name,
             c.connection_id, c.agent_conn_id, c.conn_level, c.via_contact,
-            c.conn_status, c.conn_type, c.contact_id, c.group_member_id, c.created_at
+            c.conn_status, c.conn_type, c.contact_id, c.group_member_id, c.snd_file_id, c.rcv_file_id, c.created_at
           FROM group_members m
           JOIN contacts ct ON ct.contact_id = m.contact_id
           JOIN contact_profiles p ON p.contact_profile_id = m.contact_profile_id
@@ -1041,7 +1127,7 @@ getViaGroupContact st User {userId} GroupMember {groupMemberId} =
           SELECT
             ct.contact_id, ct.local_display_name, p.display_name, p.full_name, ct.via_group,
             c.connection_id, c.agent_conn_id, c.conn_level, c.via_contact,
-            c.conn_status, c.conn_type, c.contact_id, c.group_member_id, c.created_at
+            c.conn_status, c.conn_type, c.contact_id, c.group_member_id, c.snd_file_id, c.rcv_file_id, c.created_at
           FROM contacts ct
           JOIN contact_profiles p ON ct.contact_profile_id = p.contact_profile_id
           JOIN connections c ON c.connection_id = (
@@ -1062,6 +1148,225 @@ getViaGroupContact st User {userId} GroupMember {groupMemberId} =
        in Just Contact {contactId, localDisplayName, profile, activeConn, viaGroup}
     toContact _ = Nothing
 
+createSndFileTransfer :: MonadUnliftIO m => SQLiteStore -> UserId -> Int64 -> FilePath -> FileInvitation -> ConnId -> Integer -> m SndFileTransfer
+createSndFileTransfer st userId contactId filePath FileInvitation {fileName, fileSize} agentConnId chunkSize =
+  liftIO . withTransaction st $ \db -> do
+    DB.execute db "INSERT INTO files (user_id, contact_id, file_name, file_path, file_size, chunk_size) VALUES (?, ?, ?, ?, ?, ?)" (userId, contactId, fileName, filePath, fileSize, chunkSize)
+    fileId <- insertedRowId db
+    Connection {connId} <- createSndFileConnection_ db userId fileId agentConnId
+    let fileStatus = FSNew
+    DB.execute db "INSERT INTO snd_files (file_id, file_status, connection_id) VALUES (?, ?, ?)" (fileId, fileStatus, connId)
+    pure SndFileTransfer {..}
+
+createSndFileConnection_ :: DB.Connection -> UserId -> Int64 -> ConnId -> IO Connection
+createSndFileConnection_ db userId fileId agentConnId = do
+  createdAt <- getCurrentTime
+  let connType = ConnSndFile
+      connStatus = ConnNew
+  DB.execute
+    db
+    [sql|
+      INSERT INTO connections
+        (user_id, snd_file_id, agent_conn_id, conn_status, conn_type, created_at) VALUES (?,?,?,?,?,?)
+    |]
+    (userId, fileId, agentConnId, connStatus, connType, createdAt)
+  connId <- insertedRowId db
+  pure Connection {connId, agentConnId, connType, entityId = Just fileId, viaContact = Nothing, connLevel = 0, connStatus, createdAt}
+
+updateSndFileStatus :: MonadUnliftIO m => SQLiteStore -> SndFileTransfer -> FileStatus -> m ()
+updateSndFileStatus st SndFileTransfer {fileId, connId} status =
+  liftIO . withTransaction st $ \db ->
+    DB.execute db "UPDATE snd_files SET file_status = ? WHERE file_id = ? AND connection_id = ?" (status, fileId, connId)
+
+createSndFileChunk :: MonadUnliftIO m => SQLiteStore -> SndFileTransfer -> m (Maybe Integer)
+createSndFileChunk st SndFileTransfer {fileId, connId, fileSize, chunkSize} =
+  liftIO . withTransaction st $ \db -> do
+    chunkNo <- getLastChunkNo db
+    insertChunk db chunkNo
+    pure chunkNo
+  where
+    getLastChunkNo db = do
+      ns <- DB.query db "SELECT chunk_number FROM snd_file_chunks WHERE file_id = ? AND connection_id = ? AND chunk_sent = 1 ORDER BY chunk_number DESC LIMIT 1" (fileId, connId)
+      pure $ case map fromOnly ns of
+        [] -> Just 1
+        n : _ -> if n * chunkSize >= fileSize then Nothing else Just (n + 1)
+    insertChunk db = \case
+      Just chunkNo -> DB.execute db "INSERT OR REPLACE INTO snd_file_chunks (file_id, connection_id, chunk_number) VALUES (?, ?, ?)" (fileId, connId, chunkNo)
+      Nothing -> pure ()
+
+updateSndFileChunkMsg :: MonadUnliftIO m => SQLiteStore -> SndFileTransfer -> Integer -> AgentMsgId -> m ()
+updateSndFileChunkMsg st SndFileTransfer {fileId, connId} chunkNo msgId =
+  liftIO . withTransaction st $ \db ->
+    DB.execute
+      db
+      [sql|
+        UPDATE snd_file_chunks
+        SET chunk_agent_msg_id = ?
+        WHERE file_id = ? AND connection_id = ? AND chunk_number = ?
+      |]
+      (msgId, fileId, connId, chunkNo)
+
+updateSndFileChunkSent :: MonadUnliftIO m => SQLiteStore -> SndFileTransfer -> AgentMsgId -> m ()
+updateSndFileChunkSent st SndFileTransfer {fileId, connId} msgId =
+  liftIO . withTransaction st $ \db ->
+    DB.execute
+      db
+      [sql|
+        UPDATE snd_file_chunks
+        SET chunk_sent = 1
+        WHERE file_id = ? AND connection_id = ? AND chunk_agent_msg_id = ?
+      |]
+      (fileId, connId, msgId)
+
+createRcvFileTransfer :: MonadUnliftIO m => SQLiteStore -> UserId -> Int64 -> FileInvitation -> Integer -> m RcvFileTransfer
+createRcvFileTransfer st userId contactId f@FileInvitation {fileName, fileSize, fileQInfo} chunkSize =
+  liftIO . withTransaction st $ \db -> do
+    DB.execute db "INSERT INTO files (user_id, contact_id, file_name, file_size, chunk_size) VALUES (?, ?, ?, ?, ?)" (userId, contactId, fileName, fileSize, chunkSize)
+    fileId <- insertedRowId db
+    DB.execute db "INSERT INTO rcv_files (file_id, file_status, file_queue_info) VALUES (?, ?, ?)" (fileId, FSNew, fileQInfo)
+    pure RcvFileTransfer {fileId, fileInvitation = f, fileStatus = RFSNew, chunkSize}
+
+getRcvFileTransfer :: StoreMonad m => SQLiteStore -> UserId -> Int64 -> m RcvFileTransfer
+getRcvFileTransfer st userId fileId =
+  liftIOEither . withTransaction st $ \db ->
+    getRcvFileTransfer_ db userId fileId
+
+getRcvFileTransfer_ :: DB.Connection -> UserId -> Int64 -> IO (Either StoreError RcvFileTransfer)
+getRcvFileTransfer_ db userId fileId =
+  rcvFileTransfer
+    <$> DB.query
+      db
+      [sql|
+          SELECT r.file_status, r.file_queue_info, f.file_name,
+            f.file_size, f.chunk_size, f.file_path, c.connection_id, c.agent_conn_id
+          FROM rcv_files r
+          JOIN files f USING (file_id)
+          LEFT JOIN connections c ON r.file_id = c.rcv_file_id
+          WHERE f.user_id = ? AND f.file_id = ?
+        |]
+      (userId, fileId)
+  where
+    rcvFileTransfer ::
+      [(FileStatus, SMPQueueInfo, String, Integer, Integer, Maybe FilePath, Maybe Int64, Maybe ConnId)] ->
+      Either StoreError RcvFileTransfer
+    rcvFileTransfer [(fileStatus', fileQInfo, fileName, fileSize, chunkSize, filePath_, connId_, agentConnId_)] =
+      let fileInv = FileInvitation {fileName, fileSize, fileQInfo}
+          fileInfo = (filePath_, connId_, agentConnId_)
+       in case fileStatus' of
+            FSNew -> Right RcvFileTransfer {fileId, fileInvitation = fileInv, fileStatus = RFSNew, chunkSize}
+            FSAccepted -> ft fileInv RFSAccepted fileInfo
+            FSConnected -> ft fileInv RFSConnected fileInfo
+            FSComplete -> ft fileInv RFSComplete fileInfo
+            FSCancelled -> ft fileInv RFSCancelled fileInfo
+      where
+        ft fileInvitation rfs = \case
+          (Just filePath, Just connId, Just agentConnId) ->
+            let fileStatus = rfs RcvFileInfo {filePath, connId, agentConnId}
+             in Right RcvFileTransfer {..}
+          _ -> Left $ SERcvFileInvalid fileId
+    rcvFileTransfer _ = Left $ SERcvFileNotFound fileId
+
+acceptRcvFileTransfer :: StoreMonad m => SQLiteStore -> UserId -> Int64 -> ConnId -> FilePath -> m ()
+acceptRcvFileTransfer st userId fileId agentConnId filePath =
+  liftIO . withTransaction st $ \db -> do
+    DB.execute db "UPDATE files SET file_path = ? WHERE user_id = ? AND file_id = ?" (filePath, userId, fileId)
+    DB.execute db "UPDATE rcv_files SET file_status = ? WHERE file_id = ?" (FSAccepted, fileId)
+
+    DB.execute db "INSERT INTO connections (agent_conn_id, conn_status, conn_type, rcv_file_id, user_id) VALUES (?, ?, ?, ?, ?)" (agentConnId, ConnJoined, ConnRcvFile, fileId, userId)
+
+updateRcvFileStatus :: MonadUnliftIO m => SQLiteStore -> RcvFileTransfer -> FileStatus -> m ()
+updateRcvFileStatus st RcvFileTransfer {fileId} status =
+  liftIO . withTransaction st $ \db ->
+    DB.execute db "UPDATE rcv_files SET file_status = ? WHERE file_id = ?" (status, fileId)
+
+createRcvFileChunk :: MonadUnliftIO m => SQLiteStore -> RcvFileTransfer -> Integer -> AgentMsgId -> m RcvChunkStatus
+createRcvFileChunk st RcvFileTransfer {fileId, fileInvitation = FileInvitation {fileSize}, chunkSize} chunkNo msgId =
+  liftIO . withTransaction st $ \db -> do
+    status <- getLastChunkNo db
+    unless (status == RcvChunkError) $
+      DB.execute db "INSERT OR REPLACE INTO rcv_file_chunks (file_id, chunk_number, chunk_agent_msg_id) VALUES (?, ?, ?)" (fileId, chunkNo, msgId)
+    pure status
+  where
+    getLastChunkNo db = do
+      ns <- DB.query db "SELECT chunk_number FROM rcv_file_chunks WHERE file_id = ? ORDER BY chunk_number DESC LIMIT 1" (Only fileId)
+      pure $ case map fromOnly ns of
+        [] -> if chunkNo == 1 then RcvChunkOk else RcvChunkError
+        n : _
+          | chunkNo == n -> RcvChunkDuplicate
+          | chunkNo == n + 1 ->
+            let prevSize = n * chunkSize
+             in if prevSize >= fileSize
+                  then RcvChunkError
+                  else
+                    if prevSize + chunkSize >= fileSize
+                      then RcvChunkFinal
+                      else RcvChunkOk
+          | otherwise -> RcvChunkError
+
+updatedRcvFileChunkStored :: MonadUnliftIO m => SQLiteStore -> RcvFileTransfer -> Integer -> m ()
+updatedRcvFileChunkStored st RcvFileTransfer {fileId} chunkNo =
+  liftIO . withTransaction st $ \db ->
+    DB.execute
+      db
+      [sql|
+        UPDATE rcv_file_chunks
+        SET chunk_stored = 1
+        WHERE file_id = ? AND chunk_number = ?
+      |]
+      (fileId, chunkNo)
+
+getFileTransfer :: StoreMonad m => SQLiteStore -> UserId -> Int64 -> m FileTransfer
+getFileTransfer st userId fileId =
+  liftIOEither . withTransaction st $ \db ->
+    getFileTransfer_ db userId fileId
+
+getFileTransferProgress :: StoreMonad m => SQLiteStore -> UserId -> Int64 -> m (FileTransfer, [Integer])
+getFileTransferProgress st userId fileId =
+  liftIOEither . withTransaction st $ \db -> runExceptT $ do
+    ft <- ExceptT $ getFileTransfer_ db userId fileId
+    liftIO $
+      (ft,) . map fromOnly <$> case ft of
+        FTSnd _ -> DB.query db "SELECT COUNT(*) FROM snd_file_chunks WHERE file_id = ? and chunk_sent = 1 GROUP BY connection_id" (Only fileId)
+        FTRcv _ -> DB.query db "SELECT COUNT(*) FROM rcv_file_chunks WHERE file_id = ? AND chunk_stored = 1" (Only fileId)
+
+getFileTransfer_ :: DB.Connection -> UserId -> Int64 -> IO (Either StoreError FileTransfer)
+getFileTransfer_ db userId fileId =
+  fileTransfer
+    =<< DB.query
+      db
+      [sql|
+        SELECT s.file_id, r.file_id
+        FROM files f
+        LEFT JOIN snd_files s ON s.file_id = f.file_id
+        LEFT JOIN rcv_files r ON r.file_id = f.file_id
+        WHERE user_id = ? AND f.file_id = ?
+      |]
+      (userId, fileId)
+  where
+    fileTransfer :: [(Maybe Int64, Maybe Int64)] -> IO (Either StoreError FileTransfer)
+    fileTransfer ((Just _, Nothing) : _) = FTSnd <$$> getSndFileTransfers_ db userId fileId
+    fileTransfer [(Nothing, Just _)] = FTRcv <$$> getRcvFileTransfer_ db userId fileId
+    fileTransfer _ = pure . Left $ SEFileNotFound fileId
+
+getSndFileTransfers_ :: DB.Connection -> UserId -> Int64 -> IO (Either StoreError [SndFileTransfer])
+getSndFileTransfers_ db userId fileId =
+  sndFileTransfers
+    <$> DB.query
+      db
+      [sql|
+        SELECT s.file_status, f.file_name, f.file_size, f.chunk_size, f.file_path, s.connection_id, c.agent_conn_id
+        FROM snd_files s
+        JOIN files f USING (file_id)
+        JOIN connections c USING (connection_id)
+        WHERE f.user_id = ? AND f.file_id = ?
+      |]
+      (userId, fileId)
+  where
+    sndFileTransfers :: [(FileStatus, String, Integer, Integer, FilePath, Int64, ConnId)] -> Either StoreError [SndFileTransfer]
+    sndFileTransfers [] = Left $ SESndFileNotFound fileId
+    sndFileTransfers fts = Right $ map sndFileTransfer fts
+    sndFileTransfer (fileStatus, fileName, fileSize, chunkSize, filePath, connId, agentConnId) = SndFileTransfer {..}
+
 -- | Saves unique local display name based on passed displayName, suffixed with _N if required.
 -- This function should be called inside transaction.
 withLocalDisplayName :: forall a. DB.Connection -> UserId -> Text -> (Text -> IO a) -> IO (Either StoreError a)
@@ -1126,6 +1431,10 @@ data StoreError
   | SEDuplicateGroupMember
   | SEGroupAlreadyJoined
   | SEGroupInvitationNotFound
+  | SESndFileNotFound Int64
+  | SERcvFileNotFound Int64
+  | SEFileNotFound Int64
+  | SERcvFileInvalid Int64
   | SEConnectionNotFound ConnId
   | SEIntroNotFound
   | SEUniqueID

src/Simplex/Chat/Styled.hs

@@ -7,6 +7,7 @@ module Simplex.Chat.Styled
     styleMarkdown,
     styleMarkdownText,
     sLength,
+    sShow,
   )
 where
 
@@ -54,6 +55,9 @@ instance StyledFormat Text where
   styled f = styled f . T.unpack
   plain = Styled [] . T.unpack
 
+sShow :: Show a => a -> StyledString
+sShow = plain . show
+
 sgr :: Format -> [SGR]
 sgr = \case
   Bold -> [SetConsoleIntensity BoldIntensity]

src/Simplex/Chat/Types.hs

@@ -299,6 +299,76 @@ serializeMemberStatus = \case
   GSMemComplete -> "complete"
   GSMemCreator -> "creator"
 
+data SndFileTransfer = SndFileTransfer
+  { fileId :: Int64,
+    fileName :: String,
+    filePath :: String,
+    fileSize :: Integer,
+    chunkSize :: Integer,
+    connId :: Int64,
+    agentConnId :: ConnId,
+    fileStatus :: FileStatus
+  }
+  deriving (Eq, Show)
+
+data FileInvitation = FileInvitation
+  { fileName :: String,
+    fileSize :: Integer,
+    fileQInfo :: SMPQueueInfo
+  }
+  deriving (Eq, Show)
+
+data RcvFileTransfer = RcvFileTransfer
+  { fileId :: Int64,
+    fileInvitation :: FileInvitation,
+    fileStatus :: RcvFileStatus,
+    chunkSize :: Integer
+  }
+  deriving (Eq, Show)
+
+data RcvFileStatus
+  = RFSNew
+  | RFSAccepted RcvFileInfo
+  | RFSConnected RcvFileInfo
+  | RFSComplete RcvFileInfo
+  | RFSCancelled RcvFileInfo
+  deriving (Eq, Show)
+
+data RcvFileInfo = RcvFileInfo
+  { filePath :: FilePath,
+    connId :: Int64,
+    agentConnId :: ConnId
+  }
+  deriving (Eq, Show)
+
+data FileTransfer = FTSnd [SndFileTransfer] | FTRcv RcvFileTransfer
+
+data FileStatus = FSNew | FSAccepted | FSConnected | FSComplete | FSCancelled deriving (Eq, Show)
+
+instance FromField FileStatus where fromField = fromTextField_ fileStatusT
+
+instance ToField FileStatus where toField = toField . serializeFileStatus
+
+fileStatusT :: Text -> Maybe FileStatus
+fileStatusT = \case
+  "new" -> Just FSNew
+  "accepted" -> Just FSAccepted
+  "connected" -> Just FSConnected
+  "complete" -> Just FSComplete
+  "cancelled" -> Just FSCancelled
+  _ -> Nothing
+
+serializeFileStatus :: FileStatus -> Text
+serializeFileStatus = \case
+  FSNew -> "new"
+  FSAccepted -> "accepted"
+  FSConnected -> "connected"
+  FSComplete -> "complete"
+  FSCancelled -> "cancelled"
+
+data RcvChunkStatus = RcvChunkOk | RcvChunkFinal | RcvChunkDuplicate | RcvChunkError
+  deriving (Eq, Show)
+
 data Connection = Connection
   { connId :: Int64,
     agentConnId :: ConnId,
@@ -306,7 +376,7 @@ data Connection = Connection
     viaContact :: Maybe Int64,
     connType :: ConnType,
     connStatus :: ConnStatus,
-    entityId :: Maybe Int64, -- contact or group member ID
+    entityId :: Maybe Int64, -- contact, group member or file ID
     createdAt :: UTCTime
   }
   deriving (Eq, Show)
@@ -353,7 +423,7 @@ serializeConnStatus = \case
   ConnReady -> "ready"
   ConnDeleted -> "deleted"
 
-data ConnType = ConnContact | ConnMember
+data ConnType = ConnContact | ConnMember | ConnSndFile | ConnRcvFile
   deriving (Eq, Show)
 
 instance FromField ConnType where fromField = fromTextField_ connTypeT
@@ -364,12 +434,16 @@ connTypeT :: Text -> Maybe ConnType
 connTypeT = \case
   "contact" -> Just ConnContact
   "member" -> Just ConnMember
+  "snd_file" -> Just ConnSndFile
+  "rcv_file" -> Just ConnRcvFile
   _ -> Nothing
 
 serializeConnType :: ConnType -> Text
 serializeConnType = \case
   ConnContact -> "contact"
   ConnMember -> "member"
+  ConnSndFile -> "snd_file"
+  ConnRcvFile -> "rcv_file"
 
 data NewConnection = NewConnection
   { agentConnId :: ByteString,

src/Simplex/Chat/Util.hs

@@ -8,3 +8,9 @@ safeDecodeUtf8 :: ByteString -> Text
 safeDecodeUtf8 = decodeUtf8With onError
   where
     onError _ _ = Just '?'
+
+ifM :: Monad m => m Bool -> m a -> m a -> m a
+ifM ba t f = ba >>= \b -> if b then t else f
+
+unlessM :: Monad m => m Bool -> m () -> m ()
+unlessM b = ifM b $ pure ()

src/Simplex/Chat/View.hs

@@ -24,6 +24,20 @@ module Simplex.Chat.View
     showReceivedGroupMessage,
     showSentMessage,
     showSentGroupMessage,
+    showSentFileInvitation,
+    showSndFileStart,
+    showSndFileComplete,
+    showSndFileCancelled,
+    showSndFileRcvCancelled,
+    showReceivedFileInvitation,
+    showRcvFileAccepted,
+    showRcvFileStart,
+    showRcvFileComplete,
+    showRcvFileCancelled,
+    showRcvFileSndCancelled,
+    showFileTransferStatus,
+    showSndFileSubError,
+    showRcvFileSubError,
     showGroupCreated,
     showGroupDeletedUser,
     showGroupDeleted,
@@ -42,6 +56,7 @@ module Simplex.Chat.View
     showUserProfile,
     showUserProfileUpdated,
     showContactUpdated,
+    showMessageError,
     safeDecodeUtf8,
   )
 where
@@ -50,11 +65,13 @@ import Control.Monad.IO.Unlift
 import Control.Monad.Reader
 import Data.ByteString.Char8 (ByteString)
 import Data.Composition ((.:), (.:.))
+import Data.Int (Int64)
 import Data.Text (Text)
 import qualified Data.Text as T
 import Data.Time.Clock (DiffTime, UTCTime)
 import Data.Time.Format (defaultTimeLocale, formatTime)
 import Data.Time.LocalTime (TimeZone, ZonedTime, getCurrentTimeZone, getZonedTime, localDay, localTimeOfDay, timeOfDayToTime, utcToLocalTime, zonedTimeToLocalTime)
+import Numeric (showFFloat)
 import Simplex.Chat.Controller
 import Simplex.Chat.Markdown
 import Simplex.Chat.Store (StoreError (..))
@@ -124,6 +141,48 @@ showSentGroupMessage = showSentMessage_ . ttyToGroup
 showSentMessage_ :: ChatReader m => StyledString -> ByteString -> m ()
 showSentMessage_ to msg = printToView =<< liftIO (sentMessage to msg)
 
+showSentFileInvitation :: ChatReader m => ContactName -> SndFileTransfer -> m ()
+showSentFileInvitation = printToView .: sentFileInvitation
+
+showSndFileStart :: ChatReader m => Int64 -> m ()
+showSndFileStart = printToView . sndFileStart
+
+showSndFileComplete :: ChatReader m => Int64 -> m ()
+showSndFileComplete = printToView . sndFileComplete
+
+showSndFileCancelled :: ChatReader m => Int64 -> m ()
+showSndFileCancelled = printToView . sndFileCancelled
+
+showSndFileRcvCancelled :: ChatReader m => Int64 -> m ()
+showSndFileRcvCancelled = printToView . sndFileRcvCancelled
+
+showReceivedFileInvitation :: ChatReader m => ContactName -> RcvFileTransfer -> m ()
+showReceivedFileInvitation = printToView .: receivedFileInvitation
+
+showRcvFileAccepted :: ChatReader m => Int64 -> FilePath -> m ()
+showRcvFileAccepted = printToView .: rcvFileAccepted
+
+showRcvFileStart :: ChatReader m => Int64 -> m ()
+showRcvFileStart = printToView . rcvFileStart
+
+showRcvFileComplete :: ChatReader m => Int64 -> m ()
+showRcvFileComplete = printToView . rcvFileComplete
+
+showRcvFileCancelled :: ChatReader m => Int64 -> m ()
+showRcvFileCancelled = printToView . rcvFileCancelled
+
+showRcvFileSndCancelled :: ChatReader m => Int64 -> m ()
+showRcvFileSndCancelled = printToView . rcvFileSndCancelled
+
+showFileTransferStatus :: ChatReader m => (FileTransfer, [Integer]) -> m ()
+showFileTransferStatus = printToView . fileTransferStatus
+
+showSndFileSubError :: ChatReader m => SndFileTransfer -> ChatError -> m ()
+showSndFileSubError = printToView .: sndFileSubError
+
+showRcvFileSubError :: ChatReader m => RcvFileTransfer -> ChatError -> m ()
+showRcvFileSubError = printToView .: rcvFileSubError
+
 showGroupCreated :: ChatReader m => Group -> m ()
 showGroupCreated = printToView . groupCreated
 
@@ -178,6 +237,9 @@ showUserProfileUpdated = printToView .: userProfileUpdated
 showContactUpdated :: ChatReader m => Contact -> Contact -> m ()
 showContactUpdated = printToView .: contactUpdated
 
+showMessageError :: ChatReader m => Text -> Text -> m ()
+showMessageError = printToView .: messageError
+
 invitation :: SMPQueueInfo -> [StyledString]
 invitation qInfo =
   [ "pass this invitation to your contact (via another channel): ",
@@ -202,19 +264,19 @@ contactConnected :: Contact -> [StyledString]
 contactConnected ct = [ttyFullContact ct <> ": contact is connected"]
 
 contactDisconnected :: ContactName -> [StyledString]
-contactDisconnected c = [ttyContact c <> ": contact is disconnected (messages will be queued)"]
+contactDisconnected c = [ttyContact c <> ": disconnected from server (messages will be queued)"]
 
 contactAnotherClient :: ContactName -> [StyledString]
 contactAnotherClient c = [ttyContact c <> ": contact is connected to another client"]
 
 contactSubscribed :: ContactName -> [StyledString]
-contactSubscribed c = [ttyContact c <> ": contact is active"]
+contactSubscribed c = [ttyContact c <> ": connected to server"]
 
 contactSubError :: ContactName -> ChatError -> [StyledString]
-contactSubError c e = [ttyContact c <> ": contact error " <> plain (show e)]
+contactSubError c e = [ttyContact c <> ": contact error " <> sShow e]
 
 groupSubscribed :: GroupName -> [StyledString]
-groupSubscribed g = [ttyGroup g <> ": group is active"]
+groupSubscribed g = [ttyGroup g <> ": connected to server(s)"]
 
 groupEmpty :: GroupName -> [StyledString]
 groupEmpty g = [ttyGroup g <> ": group is empty"]
@@ -223,7 +285,7 @@ groupRemoved :: GroupName -> [StyledString]
 groupRemoved g = [ttyGroup g <> ": you are no longer a member or group deleted"]
 
 memberSubError :: GroupName -> ContactName -> ChatError -> [StyledString]
-memberSubError g c e = [ttyGroup g <> " member " <> ttyContact c <> " error: " <> plain (show e)]
+memberSubError g c e = [ttyGroup g <> " member " <> ttyContact c <> " error: " <> sShow e]
 
 groupCreated :: Group -> [StyledString]
 groupCreated g@Group {localDisplayName} =
@@ -317,7 +379,7 @@ contactsMerged _to@Contact {localDisplayName = c1} _from@Contact {localDisplayNa
 userProfile :: Profile -> [StyledString]
 userProfile Profile {displayName, fullName} =
   [ "user profile: " <> ttyFullName displayName fullName,
-    "use " <> highlight' "/p <display name>[ <full name>]" <> " to change it",
+    "use " <> highlight' "/p <display name> [<full name>]" <> " to change it",
     "(the updated profile will be sent to all your contacts)"
   ]
 
@@ -344,6 +406,9 @@ contactUpdated
     where
       fullNameUpdate = if T.null fullName' || fullName' == n' then " removed full name" else " updated full name: " <> plain fullName'
 
+messageError :: Text -> Text -> [StyledString]
+messageError prefix err = [plain prefix <> ": " <> plain err]
+
 receivedMessage :: StyledString -> UTCTime -> Text -> MsgIntegrity -> IO [StyledString]
 receivedMessage from utcTime msg mOk = do
   t <- formatUTCTime <$> getCurrentTimeZone <*> getZonedTime
@@ -382,6 +447,90 @@ prependFirst s (s' : ss) = (s <> s') : ss
 msgPlain :: Text -> [StyledString]
 msgPlain = map styleMarkdownText . T.lines
 
+sentFileInvitation :: ContactName -> SndFileTransfer -> [StyledString]
+sentFileInvitation cName SndFileTransfer {fileId, fileName} =
+  [ "offered to send the file " <> plain fileName <> " to " <> ttyContact cName,
+    "use " <> highlight ("/fc " <> show fileId) <> " to cancel sending"
+  ]
+
+sndFileStart :: Int64 -> [StyledString]
+sndFileStart fileId = ["started sending the file " <> sShow fileId]
+
+sndFileComplete :: Int64 -> [StyledString]
+sndFileComplete fileId = ["completed sending the file " <> sShow fileId]
+
+sndFileCancelled :: Int64 -> [StyledString]
+sndFileCancelled fileId = ["cancelled sending the file " <> sShow fileId]
+
+sndFileRcvCancelled :: Int64 -> [StyledString]
+sndFileRcvCancelled fileId = ["recipient cancelled receiving the file " <> sShow fileId]
+
+receivedFileInvitation :: ContactName -> RcvFileTransfer -> [StyledString]
+receivedFileInvitation c RcvFileTransfer {fileId, fileInvitation = FileInvitation {fileName, fileSize}} =
+  [ ttyContact c <> " wants to send you the file " <> plain fileName <> " (" <> humanReadableSize fileSize <> " / " <> sShow fileSize <> " bytes)",
+    "use " <> highlight ("/fr " <> show fileId <> " [<dir>/ | <path>]") <> " to receive it"
+  ]
+
+humanReadableSize :: Integer -> StyledString
+humanReadableSize size
+  | size < kB = sShow size <> " bytes"
+  | size < mB = hrSize kB "KiB"
+  | size < gB = hrSize mB "MiB"
+  | otherwise = hrSize gB "GiB"
+  where
+    hrSize sB name = plain $ unwords [showFFloat (Just 1) (fromIntegral size / (fromIntegral sB :: Double)) "", name]
+    kB = 1024
+    mB = kB * 1024
+    gB = mB * 1024
+
+rcvFileAccepted :: Int64 -> FilePath -> [StyledString]
+rcvFileAccepted fileId filePath = ["saving file " <> sShow fileId <> " to " <> plain filePath]
+
+rcvFileStart :: Int64 -> [StyledString]
+rcvFileStart fileId = ["started receiving the file " <> sShow fileId]
+
+rcvFileComplete :: Int64 -> [StyledString]
+rcvFileComplete fileId = ["completed receiving the file " <> sShow fileId]
+
+rcvFileCancelled :: Int64 -> [StyledString]
+rcvFileCancelled fileId = ["cancelled receiving the file " <> sShow fileId]
+
+rcvFileSndCancelled :: Int64 -> [StyledString]
+rcvFileSndCancelled fileId = ["sender cancelled sending the file " <> sShow fileId]
+
+fileTransferStatus :: (FileTransfer, [Integer]) -> [StyledString]
+fileTransferStatus (FTSnd [SndFileTransfer {fileStatus, fileSize, chunkSize}], chunksNum) =
+  ["sent file transfer " <> sndStatus]
+  where
+    sndStatus = case fileStatus of
+      FSNew -> "is not accepted yet"
+      FSAccepted -> "just started"
+      FSConnected -> "progress: " <> fileProgress chunksNum chunkSize fileSize
+      FSComplete -> "is complete"
+      FSCancelled -> "is cancelled"
+fileTransferStatus (FTSnd _fts, _chunks) = [] -- TODO group transfer
+fileTransferStatus (FTRcv RcvFileTransfer {fileId, fileInvitation = FileInvitation {fileSize}, fileStatus, chunkSize}, chunksNum) =
+  ["received file transfer " <> rcvStatus]
+  where
+    rcvStatus = case fileStatus of
+      RFSNew -> "is not accepted yet, use " <> highlight ("/fr " <> show fileId) <> " to receive file"
+      RFSAccepted _ -> "just started"
+      RFSConnected _ -> "progress: " <> fileProgress chunksNum chunkSize fileSize
+      RFSComplete RcvFileInfo {filePath} -> "is complete, path: " <> plain filePath
+      RFSCancelled RcvFileInfo {filePath} -> "is cancelled, received part path: " <> plain filePath
+
+fileProgress :: [Integer] -> Integer -> Integer -> StyledString
+fileProgress chunksNum chunkSize fileSize =
+  sShow (sum chunksNum * chunkSize * 100 `div` fileSize) <> "% of " <> humanReadableSize fileSize
+
+sndFileSubError :: SndFileTransfer -> ChatError -> [StyledString]
+sndFileSubError SndFileTransfer {fileId, fileName} e =
+  ["sent file " <> sShow fileId <> " (" <> plain fileName <> ") error: " <> sShow e]
+
+rcvFileSubError :: RcvFileTransfer -> ChatError -> [StyledString]
+rcvFileSubError RcvFileTransfer {fileId, fileInvitation = FileInvitation {fileName}} e =
+  ["received file " <> sShow fileId <> " (" <> plain fileName <> ") error: " <> sShow e]
+
 chatError :: ChatError -> [StyledString]
 chatError = \case
   ChatError err -> case err of
@@ -394,16 +543,29 @@ chatError = \case
     CEGroupMemberUserRemoved -> ["you are no longer the member of the group"]
     CEGroupMemberNotFound c -> ["contact " <> ttyContact c <> " is not a group member"]
     CEGroupInternal s -> ["chat group bug: " <> plain s]
-  -- e -> ["chat error: " <> plain (show e)]
+    CEFileNotFound f -> ["file not found: " <> plain f]
+    CEFileAlreadyReceiving f -> ["file is already accepted: " <> plain f]
+    CEFileAlreadyExists f -> ["file already exists: " <> plain f]
+    CEFileRead f e -> ["cannot read file " <> plain f, sShow e]
+    CEFileWrite f e -> ["cannot write file " <> plain f, sShow e]
+    CEFileSend fileId e -> ["error sending file " <> sShow fileId <> ": " <> sShow e]
+    CEFileRcvChunk e -> ["error receiving file: " <> plain e]
+    CEFileInternal e -> ["file error: " <> plain e]
+  -- e -> ["chat error: " <> sShow e]
   ChatErrorStore err -> case err of
     SEDuplicateName -> ["this display name is already used by user, contact or group"]
     SEContactNotFound c -> ["no contact " <> ttyContact c]
     SEContactNotReady c -> ["contact " <> ttyContact c <> " is not active yet"]
     SEGroupNotFound g -> ["no group " <> ttyGroup g]
     SEGroupAlreadyJoined -> ["you already joined this group"]
-    e -> ["chat db error: " <> plain (show e)]
-  ChatErrorAgent e -> ["smp agent error: " <> plain (show e)]
-  ChatErrorMessage e -> ["chat message error: " <> plain (show e)]
+    SEFileNotFound fileId -> fileNotFound fileId
+    SESndFileNotFound fileId -> fileNotFound fileId
+    SERcvFileNotFound fileId -> fileNotFound fileId
+    e -> ["chat db error: " <> sShow e]
+  ChatErrorAgent e -> ["smp agent error: " <> sShow e]
+  ChatErrorMessage e -> ["chat message error: " <> sShow e]
+  where
+    fileNotFound fileId = ["file " <> sShow fileId <> " not found"]
 
 printToView :: (MonadUnliftIO m, MonadReader ChatController m) => [StyledString] -> m ()
 printToView s = asks chatTerminal >>= liftIO . (`printToTerminal` s)

src/Simplex/Chat/protocol.md

@@ -65,6 +65,7 @@ refMsgHash = 16*16(OCTET) ; SHA256 of agent message body
 ' x.grp.mem.inv 23456,234 x.text:NNN <invitation> '
 ' x.grp.mem.req 23456,123 x.json:NNN {...} '
 ' x.grp.mem.direct.inv 23456,234 x.text:NNN <invitation>  '
+' x.file name,size x.text:NNN <invitation> '
 ```
 
 ### Group protocol