diff --git a/Shared/Account/AccountModel.swift b/Shared/Account/AccountModel.swift
index 4dc3aba..1d91b95 100644
--- a/Shared/Account/AccountModel.swift
+++ b/Shared/Account/AccountModel.swift
@@ -1,68 +1,86 @@
 import SwiftUI
 import WriteFreely
 
 enum AccountError: Error {
     case invalidPassword
     case usernameNotFound
     case serverNotFound
     case invalidServerURL
+    case couldNotSaveTokenToKeychain
+    case couldNotFetchTokenFromKeychain
+    case couldNotDeleteTokenFromKeychain
 }
 
 extension AccountError: LocalizedError {
     public var errorDescription: String? {
         switch self {
         case .serverNotFound:
             return NSLocalizedString(
                 "The server could not be found. Please check the information you've entered and try again.",
                 comment: ""
             )
         case .invalidPassword:
             return NSLocalizedString(
                 "Invalid password. Please check that you've entered your password correctly and try logging in again.",
                 comment: ""
             )
         case .usernameNotFound:
             return NSLocalizedString(
                 "Username not found. Did you use your email address by mistake?",
                 comment: ""
             )
         case .invalidServerURL:
             return NSLocalizedString(
                 "Please enter a valid instance domain name. It should look like \"https://example.com\" or \"write.as\".",  // swiftlint:disable:this line_length
                 comment: ""
             )
+        case .couldNotSaveTokenToKeychain:
+            return NSLocalizedString(
+                "There was a problem trying to save your access token to the device, please try logging in again.",
+                comment: ""
+            )
+        case .couldNotFetchTokenFromKeychain:
+            return NSLocalizedString(
+                "There was a problem trying to fetch your access token from the device, please try logging in again.",
+                comment: ""
+            )
+        case .couldNotDeleteTokenFromKeychain:
+            return NSLocalizedString(
+                "There was a problem trying to delete your access token from the device, please try logging out again.",
+                comment: ""
+            )
         }
     }
 }
 
 struct AccountModel {
     @AppStorage("isLoggedIn") var isLoggedIn: Bool = false
     private let defaults = UserDefaults.standard
     let usernameStringKey = "usernameStringKey"
     let serverStringKey = "serverStringKey"
 
     var server: String = ""
     var username: String = ""
 
     private(set) var user: WFUser?
 
     mutating func login(_ user: WFUser) {
         self.user = user
         self.username = user.username ?? ""
         self.isLoggedIn = true
         defaults.set(user.username, forKey: usernameStringKey)
         defaults.set(server, forKey: serverStringKey)
     }
 
     mutating func logout() {
         self.user = nil
         self.isLoggedIn = false
         defaults.removeObject(forKey: usernameStringKey)
         defaults.removeObject(forKey: serverStringKey)
     }
 
     mutating func restoreState() {
         server = defaults.string(forKey: serverStringKey) ?? ""
         username = defaults.string(forKey: usernameStringKey) ?? ""
     }
 }
diff --git a/Shared/Extensions/WriteFreelyModel+APIHandlers.swift b/Shared/Extensions/WriteFreelyModel+APIHandlers.swift
index 9000ace..b4d24a6 100644
--- a/Shared/Extensions/WriteFreelyModel+APIHandlers.swift
+++ b/Shared/Extensions/WriteFreelyModel+APIHandlers.swift
@@ -1,294 +1,301 @@
 import Foundation
 import WriteFreely
 
 extension WriteFreelyModel {
     func loginHandler(result: Result<WFUser, Error>) {
         DispatchQueue.main.async {
             self.isLoggingIn = false
         }
         do {
             let user = try result.get()
             fetchUserCollections()
             fetchUserPosts()
-            saveTokenToKeychain(user.token, username: user.username, server: account.server)
-            DispatchQueue.main.async {
-                self.account.login(user)
+            do {
+                try saveTokenToKeychain(user.token, username: user.username, server: account.server)
+                DispatchQueue.main.async {
+                    self.account.login(user)
+                }
+            } catch {
+                DispatchQueue.main.async {
+                    self.loginErrorMessage = "There was a problem storing your access token to the Keychain."
+                    self.isPresentingLoginErrorAlert = true
+                }
             }
         } catch WFError.notFound {
             DispatchQueue.main.async {
                 self.loginErrorMessage = AccountError.usernameNotFound.localizedDescription
                 self.isPresentingLoginErrorAlert = true
             }
         } catch WFError.unauthorized {
             DispatchQueue.main.async {
                 self.loginErrorMessage = AccountError.invalidPassword.localizedDescription
                 self.isPresentingLoginErrorAlert = true
             }
         } catch {
             if (error as NSError).domain == NSURLErrorDomain,
                (error as NSError).code == -1003 {
                 DispatchQueue.main.async {
                     self.loginErrorMessage = AccountError.serverNotFound.localizedDescription
                     self.isPresentingLoginErrorAlert = true
                 }
             } else {
                 DispatchQueue.main.async {
                     self.loginErrorMessage = error.localizedDescription
                     self.isPresentingLoginErrorAlert = true
                 }
             }
         }
     }
 
     func logoutHandler(result: Result<Bool, Error>) {
         do {
             _ = try result.get()
             do {
                 try purgeTokenFromKeychain(username: account.user?.username, server: account.server)
                 client = nil
                 DispatchQueue.main.async {
                     self.account.logout()
                     LocalStorageManager().purgeUserCollections()
                     self.posts.purgePublishedPosts()
                 }
             } catch {
                 print("Something went wrong purging the token from the Keychain.")
             }
         } catch WFError.notFound {
             // The user token is invalid or doesn't exist, so it's been invalidated by the server. Proceed with
             // purging the token from the Keychain, destroying the client object, and setting the AccountModel to its
             // logged-out state.
             do {
                 try purgeTokenFromKeychain(username: account.user?.username, server: account.server)
                 client = nil
                 DispatchQueue.main.async {
                     self.account.logout()
                     LocalStorageManager().purgeUserCollections()
                     self.posts.purgePublishedPosts()
                 }
             } catch {
                 print("Something went wrong purging the token from the Keychain.")
             }
         } catch {
             // We get a 'cannot parse response' (similar to what we were seeing in the Swift package) NSURLError here,
             // so we're using a hacky workaround — if we get the NSURLError, but the AccountModel still thinks we're
             // logged in, try calling the logout function again and see what we get.
             // Conditional cast from 'Error' to 'NSError' always succeeds but is the only way to check error properties.
             if (error as NSError).domain == NSURLErrorDomain,
                (error as NSError).code == NSURLErrorCannotParseResponse {
                 if account.isLoggedIn {
                     self.logout()
                 }
             }
         }
     }
 
     func fetchUserCollectionsHandler(result: Result<[WFCollection], Error>) {
         // We're done with the network request.
         DispatchQueue.main.async {
             self.isProcessingRequest = false
         }
         do {
             let fetchedCollections = try result.get()
             for fetchedCollection in fetchedCollections {
                 DispatchQueue.main.async {
                     let localCollection = WFACollection(context: LocalStorageManager.persistentContainer.viewContext)
                     localCollection.alias = fetchedCollection.alias
                     localCollection.blogDescription = fetchedCollection.description
                     localCollection.email = fetchedCollection.email
                     localCollection.isPublic = fetchedCollection.isPublic ?? false
                     localCollection.styleSheet = fetchedCollection.styleSheet
                     localCollection.title = fetchedCollection.title
                     localCollection.url = fetchedCollection.url
                 }
             }
             DispatchQueue.main.async {
                 LocalStorageManager().saveContext()
             }
         } catch WFError.unauthorized {
             DispatchQueue.main.async {
                 self.loginErrorMessage = "Something went wrong, please try logging in again."
                 self.isPresentingLoginErrorAlert = true
             }
             self.logout()
         } catch {
             print(error)
         }
     }
 
     func fetchUserPostsHandler(result: Result<[WFPost], Error>) {
         // We're done with the network request.
         DispatchQueue.main.async {
             self.isProcessingRequest = false
         }
         let request = WFAPost.createFetchRequest()
         do {
             let locallyCachedPosts = try LocalStorageManager.persistentContainer.viewContext.fetch(request)
             do {
                 var postsToDelete = locallyCachedPosts.filter { $0.status != PostStatus.local.rawValue }
                 let fetchedPosts = try result.get()
                 for fetchedPost in fetchedPosts {
                     if let managedPost = locallyCachedPosts.first(where: { $0.postId == fetchedPost.postId }) {
                         DispatchQueue.main.async {
                             managedPost.wasDeletedFromServer = false
                             if let fetchedPostUpdatedDate = fetchedPost.updatedDate,
                                let localPostUpdatedDate = managedPost.updatedDate {
                                 managedPost.hasNewerRemoteCopy = fetchedPostUpdatedDate > localPostUpdatedDate
                             } else { print("Error: could not determine which copy of post is newer") }
                             postsToDelete.removeAll(where: { $0.postId == fetchedPost.postId })
                         }
                     } else {
                         DispatchQueue.main.async {
                             let managedPost = WFAPost(context: LocalStorageManager.persistentContainer.viewContext)
                             managedPost.postId = fetchedPost.postId
                             managedPost.slug = fetchedPost.slug
                             managedPost.appearance = fetchedPost.appearance
                             managedPost.language = fetchedPost.language
                             managedPost.rtl = fetchedPost.rtl ?? false
                             managedPost.createdDate = fetchedPost.createdDate
                             managedPost.updatedDate = fetchedPost.updatedDate
                             managedPost.title = fetchedPost.title ?? ""
                             managedPost.body = fetchedPost.body
                             managedPost.collectionAlias = fetchedPost.collectionAlias
                             managedPost.status = PostStatus.published.rawValue
                             managedPost.wasDeletedFromServer = false
                         }
                     }
                 }
                 DispatchQueue.main.async {
                     for post in postsToDelete { post.wasDeletedFromServer = true }
                     LocalStorageManager().saveContext()
                 }
             } catch {
                 print(error)
             }
         } catch WFError.unauthorized {
             DispatchQueue.main.async {
                 self.loginErrorMessage = "Something went wrong, please try logging in again."
                 self.isPresentingLoginErrorAlert = true
             }
             self.logout()
         } catch {
             print("Error: Failed to fetch cached posts")
         }
     }
 
     func publishHandler(result: Result<WFPost, Error>) {
         // We're done with the network request.
         DispatchQueue.main.async {
             self.isProcessingRequest = false
         }
         // ⚠️ NOTE:
         // The API does not return a collection alias, so we take care not to overwrite the
         // cached post's collection alias with the 'nil' value from the fetched post.
         // See: https://github.com/writeas/writefreely-swift/issues/20
         do {
             let fetchedPost = try result.get()
             // If this is an updated post, check it against postToUpdate.
             if let updatingPost = self.postToUpdate {
                 updatingPost.appearance = fetchedPost.appearance
                 updatingPost.body = fetchedPost.body
                 updatingPost.createdDate = fetchedPost.createdDate
                 updatingPost.language = fetchedPost.language
                 updatingPost.postId = fetchedPost.postId
                 updatingPost.rtl = fetchedPost.rtl ?? false
                 updatingPost.slug = fetchedPost.slug
                 updatingPost.status = PostStatus.published.rawValue
                 updatingPost.title = fetchedPost.title ?? ""
                 updatingPost.updatedDate = fetchedPost.updatedDate
                 DispatchQueue.main.async {
                     LocalStorageManager().saveContext()
                 }
             } else {
                 // Otherwise if it's a newly-published post, find it in the local store.
                 let request = WFAPost.createFetchRequest()
                 let matchBodyPredicate = NSPredicate(format: "body == %@", fetchedPost.body)
                 if let fetchedPostTitle = fetchedPost.title {
                     let matchTitlePredicate = NSPredicate(format: "title == %@", fetchedPostTitle)
                     request.predicate = NSCompoundPredicate(
                         andPredicateWithSubpredicates: [
                             matchTitlePredicate,
                             matchBodyPredicate
                         ]
                     )
                 } else {
                     request.predicate = matchBodyPredicate
                 }
                 do {
                     let cachedPostsResults = try LocalStorageManager.persistentContainer.viewContext.fetch(request)
                     guard let cachedPost = cachedPostsResults.first else { return }
                     cachedPost.appearance = fetchedPost.appearance
                     cachedPost.body = fetchedPost.body
                     cachedPost.createdDate = fetchedPost.createdDate
                     cachedPost.language = fetchedPost.language
                     cachedPost.postId = fetchedPost.postId
                     cachedPost.rtl = fetchedPost.rtl ?? false
                     cachedPost.slug = fetchedPost.slug
                     cachedPost.status = PostStatus.published.rawValue
                     cachedPost.title = fetchedPost.title ?? ""
                     cachedPost.updatedDate = fetchedPost.updatedDate
                     DispatchQueue.main.async {
                         LocalStorageManager().saveContext()
                     }
                 } catch {
                     print("Error: Failed to fetch cached posts")
                 }
             }
         } catch {
             print(error)
         }
     }
 
     func updateFromServerHandler(result: Result<WFPost, Error>) {
         // We're done with the network request.
         DispatchQueue.main.async {
             self.isProcessingRequest = false
         }
         // ⚠️ NOTE:
         // The API does not return a collection alias, so we take care not to overwrite the
         // cached post's collection alias with the 'nil' value from the fetched post.
         // See: https://github.com/writeas/writefreely-swift/issues/20
         do {
             let fetchedPost = try result.get()
             guard let cachedPost = self.selectedPost else { return }
             cachedPost.appearance = fetchedPost.appearance
             cachedPost.body = fetchedPost.body
             cachedPost.createdDate = fetchedPost.createdDate
             cachedPost.language = fetchedPost.language
             cachedPost.postId = fetchedPost.postId
             cachedPost.rtl = fetchedPost.rtl ?? false
             cachedPost.slug = fetchedPost.slug
             cachedPost.status = PostStatus.published.rawValue
             cachedPost.title = fetchedPost.title ?? ""
             cachedPost.updatedDate = fetchedPost.updatedDate
             cachedPost.hasNewerRemoteCopy = false
             DispatchQueue.main.async {
                 LocalStorageManager().saveContext()
             }
         } catch {
             print(error)
         }
     }
 
     func movePostHandler(result: Result<Bool, Error>) {
         // We're done with the network request.
         DispatchQueue.main.async {
             self.isProcessingRequest = false
         }
         do {
             let succeeded = try result.get()
             if succeeded {
                 if let post = selectedPost {
                     updateFromServer(post: post)
                 } else {
                     return
                 }
             }
         } catch {
             DispatchQueue.main.async {
                 LocalStorageManager.persistentContainer.viewContext.rollback()
             }
             print(error)
         }
     }
 }
diff --git a/Shared/Models/WriteFreelyModel.swift b/Shared/Models/WriteFreelyModel.swift
index d392e02..e6c9a23 100644
--- a/Shared/Models/WriteFreelyModel.swift
+++ b/Shared/Models/WriteFreelyModel.swift
@@ -1,76 +1,83 @@
 import Foundation
 import WriteFreely
 import Security
 import Network
 
 // MARK: - WriteFreelyModel
 
 final class WriteFreelyModel: ObservableObject {
     @Published var account = AccountModel()
     @Published var preferences = PreferencesModel()
     @Published var posts = PostListModel()
     @Published var editor = PostEditorModel()
     @Published var isLoggingIn: Bool = false
     @Published var isProcessingRequest: Bool = false
     @Published var hasNetworkConnection: Bool = true
     @Published var selectedPost: WFAPost?
     @Published var selectedCollection: WFACollection?
     @Published var showAllPosts: Bool = true
     @Published var isPresentingDeleteAlert: Bool = false
     @Published var isPresentingLoginErrorAlert: Bool = false
     @Published var isPresentingNetworkErrorAlert: Bool = false
     @Published var postToDelete: WFAPost?
     #if os(iOS)
     @Published var isPresentingSettingsView: Bool = false
     #endif
 
     static var shared = WriteFreelyModel()
 
     var loginErrorMessage: String?
 
     // swiftlint:disable line_length
     let helpURL = URL(string: "https://discuss.write.as/c/help/5")!
     let howToURL = URL(string: "https://discuss.write.as/t/using-the-writefreely-ios-app/1946")!
     let reviewURL = URL(string: "https://apps.apple.com/app/id1531530896?action=write-review")!
     let licensesURL = URL(string: "https://github.com/writeas/writefreely-swiftui-multiplatform/tree/main/Shared/Resources/Licenses")!
     // swiftlint:enable line_length
 
     internal var client: WFClient?
     private let defaults = UserDefaults.standard
     private let monitor = NWPathMonitor()
     private let queue = DispatchQueue(label: "NetworkMonitor")
     internal var postToUpdate: WFAPost?
 
     init() {
         DispatchQueue.main.async {
             self.preferences.appearance = self.defaults.integer(forKey: self.preferences.colorSchemeIntegerKey)
             self.preferences.font = self.defaults.integer(forKey: self.preferences.defaultFontIntegerKey)
             self.account.restoreState()
             if self.account.isLoggedIn {
                 guard let serverURL = URL(string: self.account.server) else {
                     print("Server URL not found")
                     return
                 }
-                guard let token = self.fetchTokenFromKeychain(
-                        username: self.account.username,
-                        server: self.account.server
-                ) else {
-                    print("Could not fetch token from Keychain")
-                    return
+                do {
+                    guard let token = try self.fetchTokenFromKeychain(
+                            username: self.account.username,
+                            server: self.account.server
+                    ) else {
+                        self.loginErrorMessage = AccountError.couldNotFetchTokenFromKeychain.localizedDescription
+                        self.isPresentingLoginErrorAlert = true
+                        return
+                    }
+
+                    self.account.login(WFUser(token: token, username: self.account.username))
+                    self.client = WFClient(for: serverURL)
+                    self.client?.user = self.account.user
+                    self.fetchUserCollections()
+                    self.fetchUserPosts()
+                } catch {
+                    self.loginErrorMessage = AccountError.couldNotFetchTokenFromKeychain.localizedDescription
+                    self.isPresentingLoginErrorAlert = true
                 }
-                self.account.login(WFUser(token: token, username: self.account.username))
-                self.client = WFClient(for: serverURL)
-                self.client?.user = self.account.user
-                self.fetchUserCollections()
-                self.fetchUserPosts()
             }
         }
 
         monitor.pathUpdateHandler = { path in
             DispatchQueue.main.async {
                 self.hasNetworkConnection = path.status == .satisfied
             }
         }
         monitor.start(queue: queue)
     }
 }