Release v0.0.7 (#68)

Cargo.lock

@@ -860,6 +860,12 @@ dependencies = [
  "cfg-if",
 ]
 
+[[package]]
+name = "endian-type"
+version = "0.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c34f04666d835ff5d62e058c3995147c06f42fe86ff053337632bca83e42702d"
+
 [[package]]
 name = "errno"
 version = "0.2.8"
@@ -1302,7 +1308,7 @@ dependencies = [
 
 [[package]]
 name = "iamb"
-version = "0.0.4"
+version = "0.0.7"
 dependencies = [
  "bitflags",
  "chrono",
@@ -1876,9 +1882,9 @@ dependencies = [
 
 [[package]]
 name = "modalkit"
-version = "0.0.11"
+version = "0.0.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd7bd7d02d65842dab4cea53016cf29c16cde197131dd6d9eea95662deb77778"
+checksum = "5c48c7d7e6d764a09435b43a7e4d342ba2d2e026626ca773b16a5ba34b90b933"
 dependencies = [
  "anymap2",
  "arboard",
@@ -1888,10 +1894,12 @@ dependencies = [
  "intervaltree",
  "libc",
  "nom",
+ "radix_trie",
  "regex",
  "ropey",
  "thiserror",
  "tui",
+ "unicode-segmentation",
 ]
 
 [[package]]
@@ -1900,6 +1908,15 @@ version = "1.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e4a24736216ec316047a1fc4252e27dabb04218aa4a3f37c6e7ddbf1f9782b54"
 
+[[package]]
+name = "nibble_vec"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "77a5d83df9f36fe23f0c3648c6bbb8b0298bb5f1939c8f2704431371f4b84d43"
+dependencies = [
+ "smallvec",
+]
+
 [[package]]
 name = "nix"
 version = "0.24.3"
@@ -2344,6 +2361,16 @@ dependencies = [
  "proc-macro2",
 ]
 
+[[package]]
+name = "radix_trie"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c069c179fcdc6a2fe24d8d18305cf085fdbd4f922c041943e203685d6a1c58fd"
+dependencies = [
+ "endian-type",
+ "nibble_vec",
+]
+
 [[package]]
 name = "rand"
 version = "0.7.3"

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "iamb"
-version = "0.0.5"
+version = "0.0.7"
 edition = "2018"
 authors = ["Ulyssa <git@ulyssa.dev>"]
 repository = "https://github.com/ulyssa/iamb"
@@ -39,7 +39,7 @@ unicode-width = "0.1.10"
 url = {version = "^2.2.2", features = ["serde"]}
 
 [dependencies.modalkit]
-version = "0.0.11"
+version = "0.0.14"
 
 [dependencies.matrix-sdk]
 version = "0.6"
@@ -52,3 +52,7 @@ features = ["macros", "net", "rt-multi-thread", "sync", "time"]
 
 [dev-dependencies]
 lazy_static = "1.4.0"
+
+[profile.release]
+lto = true
+incremental = false

README.md

@@ -2,6 +2,7 @@
 
 [![Build Status](https://github.com/ulyssa/iamb/workflows/CI/badge.svg)](https://github.com/ulyssa/iamb/actions?query=workflow%3ACI+)
 [![License: Apache 2.0](https://img.shields.io/crates/l/iamb.svg?logo=apache)](https://crates.io/crates/iamb)
+[![#iamb:0x.badd.cafe](https://img.shields.io/badge/matrix-%23iamb:0x.badd.cafe-blue)](https://matrix.to/#/#iamb:0x.badd.cafe)
 [![Latest Version](https://img.shields.io/crates/v/iamb.svg?logo=rust)](https://crates.io/crates/iamb)
 
 ## About
@@ -11,6 +12,8 @@
 This project is a work-in-progress, and there's still a lot to be implemented,
 but much of the basic client functionality is already present.
 
+![Example Usage](https://iamb.chat/static/images/iamb-demo.gif)
+
 ## Documentation
 
 You can find documentation for installing, configuring, and using iamb on its
@@ -24,6 +27,22 @@ Install Rust and Cargo, and then run:
 cargo install --locked iamb
 ```
 
+### NetBSD
+
+On NetBSD a package is available from the official repositories. To install it simply run:
+
+```
+pkgin install iamb
+```
+
+### Arch Linux
+
+On Arch Linux a package is available in the Arch User Repositories (AUR). To install it simply run with your favorite AUR helper:
+
+```
+paru iamb-git
+```
+
 ## Configuration
 
 You can create a basic configuration in `$CONFIG_DIR/iamb/config.json` that looks like:
@@ -75,7 +94,7 @@ two other TUI clients and Element Web:
 | VOIP                                    | ❌          | ❌       | ❌               | ✔️                   |
 | Reactions                               | ✔️           | ✔️        | ❌               | ✔️                   |
 | Message editing                         | ✔️           | ✔️        | ❌               | ✔️                   |
-| Room upgrades                           | ❌          | ✔️        | ❌               | ✔️                   |
+| Room upgrades                           | ❌ ([#41])  | ✔️        | ❌               | ✔️                   |
 | Localisations                           | ❌          | 1        | ❌               | 44                  |
 | SSO Support                             | ❌          | ✔️        | ✔️                | ✔️                   |
                                                                                        
@@ -88,18 +107,7 @@ iamb is released under the [Apache License, Version 2.0].
 [iamb.chat]: https://iamb.chat
 [gomuks]: https://github.com/tulir/gomuks
 [weechat-matrix]: https://github.com/poljar/weechat-matrix
-[#2]: https://github.com/ulyssa/iamb/issues/2
-[#3]: https://github.com/ulyssa/iamb/issues/3
-[#4]: https://github.com/ulyssa/iamb/issues/4
-[#5]: https://github.com/ulyssa/iamb/issues/5
-[#6]: https://github.com/ulyssa/iamb/issues/6
-[#7]: https://github.com/ulyssa/iamb/issues/7
 [#8]: https://github.com/ulyssa/iamb/issues/8
-[#9]: https://github.com/ulyssa/iamb/issues/9
-[#10]: https://github.com/ulyssa/iamb/issues/10
-[#11]: https://github.com/ulyssa/iamb/issues/11
-[#12]: https://github.com/ulyssa/iamb/issues/12
-[#13]: https://github.com/ulyssa/iamb/issues/13
 [#14]: https://github.com/ulyssa/iamb/issues/14
-[#15]: https://github.com/ulyssa/iamb/issues/15
 [#16]: https://github.com/ulyssa/iamb/issues/16
+[#41]: https://github.com/ulyssa/iamb/issues/41

src/base.rs

@@ -1,10 +1,12 @@
+use std::borrow::Cow;
 use std::collections::{HashMap, HashSet};
 use std::hash::Hash;
+use std::str::FromStr;
 use std::sync::Arc;
 use std::time::{Duration, Instant};
 
+use emojis::Emoji;
 use tokio::sync::Mutex as AsyncMutex;
-use tracing::warn;
 
 use matrix_sdk::{
     encryption::verification::SasVerification,
@@ -12,6 +14,7 @@ use matrix_sdk::{
     ruma::{
         events::{
             reaction::ReactionEvent,
+            room::encrypted::RoomEncryptedEvent,
             room::message::{
                 OriginalRoomMessageEvent,
                 Relation,
@@ -20,9 +23,9 @@ use matrix_sdk::{
                 RoomMessageEventContent,
             },
             tag::{TagName, Tags},
-            AnyMessageLikeEvent,
             MessageLikeEvent,
         },
+        presence::PresenceState,
         EventId,
         OwnedEventId,
         OwnedRoomId,
@@ -42,11 +45,15 @@ use modalkit::{
             ApplicationStore,
             ApplicationWindowId,
         },
+        base::{CommandType, WordStyle},
+        completion::{complete_path, CompletionMap},
         context::EditContext,
+        cursor::Cursor,
+        rope::EditRope,
         store::Store,
     },
     env::vim::{
-        command::{CommandContext, VimCommand, VimCommandMachine},
+        command::{CommandContext, CommandDescription, VimCommand, VimCommandMachine},
         keybindings::VimMachine,
         VimContext,
     },
@@ -66,6 +73,20 @@ use crate::{
     ApplicationSettings,
 };
 
+pub const MATRIX_ID_WORD: WordStyle = WordStyle::CharSet(is_mxid_char);
+
+/// Find the boundaries for a Matrix username, room alias, or room ID.
+///
+/// Technically "[" and "]" should be here since IPv6 addresses are allowed
+/// in the server name, but in practice that should be uncommon, and people
+/// can just use `gf` and friends in Visual mode instead.
+fn is_mxid_char(c: char) -> bool {
+    return c >= 'a' && c <= 'z' ||
+        c >= 'A' && c <= 'Z' ||
+        c >= '0' && c <= '9' ||
+        ":-./@_#!".contains(c);
+}
+
 const ROOM_FETCH_DEBOUNCE: Duration = Duration::from_secs(2);
 
 #[derive(Clone, Debug, Eq, PartialEq)]
@@ -109,6 +130,30 @@ pub enum MessageAction {
     Unreact(Option<String>),
 }
 
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum CreateRoomType {
+    /// A direct message room.
+    Direct(OwnedUserId),
+
+    /// A standard chat room.
+    Room,
+
+    /// A Matrix space.
+    Space,
+}
+
+bitflags::bitflags! {
+    pub struct CreateRoomFlags: u32 {
+        const NONE = 0b00000000;
+
+        /// Make the room public.
+        const PUBLIC = 0b00000001;
+
+        /// Encrypt this room.
+        const ENCRYPTED = 0b00000010;
+    }
+}
+
 bitflags::bitflags! {
     pub struct DownloadFlags: u32 {
         const NONE = 0b00000000;
@@ -144,8 +189,14 @@ pub enum SendAction {
     Upload(String),
 }
 
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub enum HomeserverAction {
+    CreateRoom(Option<String>, CreateRoomType, CreateRoomFlags),
+}
+
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum IambAction {
+    Homeserver(HomeserverAction),
     Message(MessageAction),
     Room(RoomAction),
     Send(SendAction),
@@ -154,6 +205,12 @@ pub enum IambAction {
     ToggleScrollbackFocus,
 }
 
+impl From<HomeserverAction> for IambAction {
+    fn from(act: HomeserverAction) -> Self {
+        IambAction::Homeserver(act)
+    }
+}
+
 impl From<MessageAction> for IambAction {
     fn from(act: MessageAction) -> Self {
         IambAction::Message(act)
@@ -175,6 +232,7 @@ impl From<SendAction> for IambAction {
 impl ApplicationAction for IambAction {
     fn is_edit_sequence<C: EditContext>(&self, _: &C) -> SequenceStatus {
         match self {
+            IambAction::Homeserver(..) => SequenceStatus::Break,
             IambAction::Message(..) => SequenceStatus::Break,
             IambAction::Room(..) => SequenceStatus::Break,
             IambAction::Send(..) => SequenceStatus::Break,
@@ -186,6 +244,7 @@ impl ApplicationAction for IambAction {
 
     fn is_last_action<C: EditContext>(&self, _: &C) -> SequenceStatus {
         match self {
+            IambAction::Homeserver(..) => SequenceStatus::Atom,
             IambAction::Message(..) => SequenceStatus::Atom,
             IambAction::Room(..) => SequenceStatus::Atom,
             IambAction::Send(..) => SequenceStatus::Atom,
@@ -197,6 +256,7 @@ impl ApplicationAction for IambAction {
 
     fn is_last_selection<C: EditContext>(&self, _: &C) -> SequenceStatus {
         match self {
+            IambAction::Homeserver(..) => SequenceStatus::Ignore,
             IambAction::Message(..) => SequenceStatus::Ignore,
             IambAction::Room(..) => SequenceStatus::Ignore,
             IambAction::Send(..) => SequenceStatus::Ignore,
@@ -208,6 +268,7 @@ impl ApplicationAction for IambAction {
 
     fn is_switchable<C: EditContext>(&self, _: &C) -> bool {
         match self {
+            IambAction::Homeserver(..) => false,
             IambAction::Message(..) => false,
             IambAction::Room(..) => false,
             IambAction::Send(..) => false,
@@ -350,6 +411,9 @@ pub struct RoomInfo {
     /// A map of message identifiers to a map of reaction events.
     pub reactions: HashMap<OwnedEventId, MessageReactions>,
 
+    /// Whether the scrollback for this room is currently being fetched.
+    pub fetching: bool,
+
     /// Where to continue fetching from when we continue loading scrollback history.
     pub fetch_id: RoomFetchStatus,
 
@@ -427,10 +491,23 @@ impl RoomInfo {
             MessageEvent::Local(_, content) => {
                 *content = new_content;
             },
-            MessageEvent::Redacted(_) => {
+            MessageEvent::Redacted(_) |
+            MessageEvent::EncryptedOriginal(_) |
+            MessageEvent::EncryptedRedacted(_) => {
                 return;
             },
         }
+
+        msg.html = msg.event.html();
+    }
+
+    /// Inserts events that couldn't be decrypted into the scrollback.
+    pub fn insert_encrypted(&mut self, msg: RoomEncryptedEvent) {
+        let event_id = msg.event_id().to_owned();
+        let key = (msg.origin_server_ts().into(), event_id.clone());
+
+        self.keys.insert(event_id, EventLocation::Message(key.clone()));
+        self.messages.insert(key, msg.into());
     }
 
     pub fn insert_message(&mut self, msg: RoomMessageEvent) {
@@ -456,7 +533,7 @@ impl RoomInfo {
         }
     }
 
-    fn recently_fetched(&self) -> bool {
+    pub fn recently_fetched(&self) -> bool {
         self.fetch_last.map_or(false, |i| i.elapsed() < ROOM_FETCH_DEBOUNCE)
     }
 
@@ -528,13 +605,28 @@ impl RoomInfo {
     }
 }
 
+fn emoji_map() -> CompletionMap<String, &'static Emoji> {
+    let mut emojis = CompletionMap::default();
+
+    for emoji in emojis::iter() {
+        for shortcode in emoji.shortcodes() {
+            emojis.insert(shortcode.to_string(), emoji);
+        }
+    }
+
+    return emojis;
+}
+
 pub struct ChatStore {
+    pub cmds: ProgramCommands,
     pub worker: Requester,
-    pub rooms: HashMap<OwnedRoomId, RoomInfo>,
-    pub names: HashMap<String, OwnedRoomId>,
+    pub rooms: CompletionMap<OwnedRoomId, RoomInfo>,
+    pub names: CompletionMap<String, OwnedRoomId>,
+    pub presences: CompletionMap<OwnedUserId, PresenceState>,
     pub verifications: HashMap<String, SasVerification>,
     pub settings: ApplicationSettings,
     pub need_load: HashSet<OwnedRoomId>,
+    pub emojis: CompletionMap<String, &'static Emoji>,
 }
 
 impl ChatStore {
@@ -543,10 +635,13 @@ impl ChatStore {
             worker,
             settings,
 
+            cmds: crate::commands::setup_commands(),
             names: Default::default(),
             rooms: Default::default(),
+            presences: Default::default(),
             verifications: Default::default(),
             need_load: Default::default(),
+            emojis: emoji_map(),
         }
     }
 
@@ -586,64 +681,12 @@ impl ChatStore {
         self.need_load.insert(room_id);
     }
 
-    pub fn load_older(&mut self, limit: u32) {
-        let ChatStore { need_load, rooms, worker, .. } = self;
-
-        for room_id in std::mem::take(need_load).into_iter() {
-            let info = rooms.entry(room_id.clone()).or_default();
-
-            if info.recently_fetched() {
-                need_load.insert(room_id);
-                continue;
-            } else {
-                info.fetch_last = Instant::now().into();
-            }
-
-            let fetch_id = match &info.fetch_id {
-                RoomFetchStatus::Done => continue,
-                RoomFetchStatus::HaveMore(fetch_id) => Some(fetch_id.clone()),
-                RoomFetchStatus::NotStarted => None,
-            };
-
-            let res = worker.load_older(room_id.clone(), fetch_id, limit);
-
-            match res {
-                Ok((fetch_id, msgs)) => {
-                    for msg in msgs.into_iter() {
-                        match msg {
-                            AnyMessageLikeEvent::RoomMessage(msg) => {
-                                info.insert(msg);
-                            },
-                            AnyMessageLikeEvent::Reaction(ev) => {
-                                info.insert_reaction(ev);
-                            },
-                            _ => continue,
-                        }
-                    }
-
-                    info.fetch_id =
-                        fetch_id.map_or(RoomFetchStatus::Done, RoomFetchStatus::HaveMore);
-                },
-                Err(e) => {
-                    warn!(
-                        room_id = room_id.as_str(),
-                        err = e.to_string(),
-                        "Failed to load older messages"
-                    );
-
-                    // Wait and try again.
-                    need_load.insert(room_id);
-                },
-            }
-        }
-    }
-
     pub fn get_room_info(&mut self, room_id: OwnedRoomId) -> &mut RoomInfo {
-        self.rooms.entry(room_id).or_default()
+        self.rooms.get_or_default(room_id)
     }
 
     pub fn set_room_name(&mut self, room_id: &RoomId, name: &str) {
-        self.rooms.entry(room_id.to_owned()).or_default().name = name.to_string().into();
+        self.rooms.get_or_default(room_id.to_owned()).name = name.to_string().into();
     }
 
     pub fn insert_sas(&mut self, sas: SasVerification) {
@@ -686,7 +729,7 @@ impl RoomFocus {
 
 #[derive(Clone, Debug, Eq, Hash, PartialEq)]
 pub enum IambBufferId {
-    Command,
+    Command(CommandType),
     Room(OwnedRoomId, RoomFocus),
     DirectList,
     MemberList(OwnedRoomId),
@@ -699,7 +742,7 @@ pub enum IambBufferId {
 impl IambBufferId {
     pub fn to_window(&self) -> Option<IambId> {
         match self {
-            IambBufferId::Command => None,
+            IambBufferId::Command(_) => None,
             IambBufferId::Room(room, _) => Some(IambId::Room(room.clone())),
             IambBufferId::DirectList => Some(IambId::DirectList),
             IambBufferId::MemberList(room) => Some(IambId::MemberList(room.clone())),
@@ -719,6 +762,133 @@ impl ApplicationInfo for IambInfo {
     type Action = IambAction;
     type WindowId = IambId;
     type ContentId = IambBufferId;
+
+    fn complete(
+        text: &EditRope,
+        cursor: &mut Cursor,
+        content: &IambBufferId,
+        store: &mut ProgramStore,
+    ) -> Vec<String> {
+        match content {
+            IambBufferId::Command(CommandType::Command) => complete_cmdbar(text, cursor, store),
+            IambBufferId::Command(CommandType::Search) => vec![],
+
+            IambBufferId::Room(_, RoomFocus::MessageBar) => {
+                complete_matrix_names(text, cursor, store)
+            },
+            IambBufferId::Room(_, RoomFocus::Scrollback) => vec![],
+
+            IambBufferId::DirectList => vec![],
+            IambBufferId::MemberList(_) => vec![],
+            IambBufferId::RoomList => vec![],
+            IambBufferId::SpaceList => vec![],
+            IambBufferId::VerifyList => vec![],
+            IambBufferId::Welcome => vec![],
+        }
+    }
+
+    fn content_of_command(ct: CommandType) -> IambBufferId {
+        IambBufferId::Command(ct)
+    }
+}
+
+fn complete_users(text: &EditRope, cursor: &mut Cursor, store: &ProgramStore) -> Vec<String> {
+    let id = text
+        .get_prefix_word_mut(cursor, &MATRIX_ID_WORD)
+        .unwrap_or_else(EditRope::empty);
+    let id = Cow::from(&id);
+
+    store
+        .application
+        .presences
+        .complete(id.as_ref())
+        .into_iter()
+        .map(|i| i.to_string())
+        .collect()
+}
+
+fn complete_matrix_names(
+    text: &EditRope,
+    cursor: &mut Cursor,
+    store: &ProgramStore,
+) -> Vec<String> {
+    let id = text
+        .get_prefix_word_mut(cursor, &MATRIX_ID_WORD)
+        .unwrap_or_else(EditRope::empty);
+    let id = Cow::from(&id);
+
+    let list = store.application.names.complete(id.as_ref());
+    if !list.is_empty() {
+        return list;
+    }
+
+    let list = store.application.presences.complete(id.as_ref());
+    if !list.is_empty() {
+        return list.into_iter().map(|i| i.to_string()).collect();
+    }
+
+    store
+        .application
+        .rooms
+        .complete(id.as_ref())
+        .into_iter()
+        .map(|i| i.to_string())
+        .collect()
+}
+
+fn complete_emoji(text: &EditRope, cursor: &mut Cursor, store: &ProgramStore) -> Vec<String> {
+    let sc = text.get_prefix_word_mut(cursor, &WordStyle::Little);
+    let sc = sc.unwrap_or_else(EditRope::empty);
+    let sc = Cow::from(&sc);
+
+    store.application.emojis.complete(sc.as_ref())
+}
+
+fn complete_cmdarg(
+    desc: CommandDescription,
+    text: &EditRope,
+    cursor: &mut Cursor,
+    store: &ProgramStore,
+) -> Vec<String> {
+    let cmd = match store.application.cmds.get(desc.command.as_str()) {
+        Ok(cmd) => cmd,
+        Err(_) => return vec![],
+    };
+
+    match cmd.name.as_str() {
+        "cancel" | "dms" | "edit" | "redact" | "reply" => vec![],
+        "members" | "rooms" | "spaces" | "welcome" => vec![],
+        "download" | "open" | "upload" => complete_path(text, cursor),
+        "react" | "unreact" => complete_emoji(text, cursor, store),
+
+        "invite" => complete_users(text, cursor, store),
+        "join" => complete_matrix_names(text, cursor, store),
+        "room" => vec![],
+        "verify" => vec![],
+        _ => panic!("unknown command {}", cmd.name.as_str()),
+    }
+}
+
+fn complete_cmdbar(text: &EditRope, cursor: &mut Cursor, store: &ProgramStore) -> Vec<String> {
+    let eo = text.cursor_to_offset(cursor);
+    let slice = text.slice(0.into(), eo, false);
+    let cow = Cow::from(&slice);
+
+    match CommandDescription::from_str(cow.as_ref()) {
+        Ok(desc) => {
+            if desc.arg.untrimmed.is_empty() {
+                // Complete command name and set cursor position.
+                let _ = text.get_prefix_word_mut(cursor, &WordStyle::Little);
+                store.application.cmds.complete_name(desc.command.as_str())
+            } else {
+                // Complete command argument.
+                complete_cmdarg(desc, text, cursor, store)
+            }
+        },
+
+        // Can't parse command text, so return zero completions.
+        Err(_) => vec![],
+    }
 }
 
 #[cfg(test)]
@@ -804,4 +974,44 @@ pub mod tests {
             ])
         );
     }
+
+    #[tokio::test]
+    async fn test_complete_cmdbar() {
+        let store = mock_store().await;
+
+        let text = EditRope::from("invite    ");
+        let mut cursor = Cursor::new(0, 7);
+        let id = text
+            .get_prefix_word_mut(&mut cursor, &MATRIX_ID_WORD)
+            .unwrap_or_else(EditRope::empty);
+        assert_eq!(id.to_string(), "");
+        assert_eq!(cursor, Cursor::new(0, 7));
+
+        let text = EditRope::from("invite    ");
+        let mut cursor = Cursor::new(0, 7);
+        let res = complete_cmdbar(&text, &mut cursor, &store);
+        assert_eq!(res, vec![
+            "@user1:example.com",
+            "@user2:example.com",
+            "@user3:example.com",
+            "@user4:example.com",
+            "@user5:example.com"
+        ]);
+
+        let text = EditRope::from("invite ignored");
+        let mut cursor = Cursor::new(0, 7);
+        let res = complete_cmdbar(&text, &mut cursor, &store);
+        assert_eq!(res, vec![
+            "@user1:example.com",
+            "@user2:example.com",
+            "@user3:example.com",
+            "@user4:example.com",
+            "@user5:example.com"
+        ]);
+
+        let text = EditRope::from("invite @user1ignored");
+        let mut cursor = Cursor::new(0, 13);
+        let res = complete_cmdbar(&text, &mut cursor, &store);
+        assert_eq!(res, vec!["@user1:example.com"]);
+    }
 }

src/commands.rs

@@ -4,13 +4,16 @@ use matrix_sdk::ruma::{events::tag::TagName, OwnedUserId};
 
 use modalkit::{
     editing::base::OpenTarget,
-    env::vim::command::{CommandContext, CommandDescription},
+    env::vim::command::{CommandContext, CommandDescription, OptionType},
     input::commands::{CommandError, CommandResult, CommandStep},
     input::InputContext,
 };
 
 use crate::base::{
+    CreateRoomFlags,
+    CreateRoomType,
     DownloadFlags,
+    HomeserverAction,
     IambAction,
     IambId,
     MessageAction,
@@ -297,6 +300,53 @@ fn iamb_join(desc: CommandDescription, ctx: &mut ProgContext) -> ProgResult {
     return Ok(step);
 }
 
+fn iamb_create(desc: CommandDescription, ctx: &mut ProgContext) -> ProgResult {
+    let args = desc.arg.options()?;
+    let mut flags = CreateRoomFlags::NONE;
+    let mut alias = None;
+    let mut ct = CreateRoomType::Room;
+
+    for arg in args {
+        match arg {
+            OptionType::Flag(name, Some(arg)) => {
+                match name.as_str() {
+                    "alias" => {
+                        if alias.is_some() {
+                            let msg = "Multiple ++alias arguments are not allowed";
+                            let err = CommandError::Error(msg.into());
+
+                            return Err(err);
+                        } else {
+                            alias = Some(arg);
+                        }
+                    },
+                    _ => return Err(CommandError::InvalidArgument),
+                }
+            },
+            OptionType::Flag(name, None) => {
+                match name.as_str() {
+                    "public" => flags |= CreateRoomFlags::PUBLIC,
+                    "space" => ct = CreateRoomType::Space,
+                    "enc" | "encrypted" => flags |= CreateRoomFlags::ENCRYPTED,
+                    _ => return Err(CommandError::InvalidArgument),
+                }
+            },
+            OptionType::Positional(_) => {
+                let msg = ":create doesn't take any positional arguments";
+                let err = CommandError::Error(msg.into());
+
+                return Err(err);
+            },
+        }
+    }
+
+    let hact = HomeserverAction::CreateRoom(alias, ct, flags);
+    let iact = IambAction::from(hact);
+    let step = CommandStep::Continue(iact.into(), ctx.context.take());
+
+    return Ok(step);
+}
+
 fn iamb_room(desc: CommandDescription, ctx: &mut ProgContext) -> ProgResult {
     let mut args = desc.arg.strings()?;
 
@@ -395,24 +445,81 @@ fn iamb_open(desc: CommandDescription, ctx: &mut ProgContext) -> ProgResult {
 }
 
 fn add_iamb_commands(cmds: &mut ProgramCommands) {
-    cmds.add_command(ProgramCommand { names: vec!["cancel".into()], f: iamb_cancel });
-    cmds.add_command(ProgramCommand { names: vec!["dms".into()], f: iamb_dms });
-    cmds.add_command(ProgramCommand { names: vec!["download".into()], f: iamb_download });
-    cmds.add_command(ProgramCommand { names: vec!["open".into()], f: iamb_open });
-    cmds.add_command(ProgramCommand { names: vec!["edit".into()], f: iamb_edit });
-    cmds.add_command(ProgramCommand { names: vec!["invite".into()], f: iamb_invite });
-    cmds.add_command(ProgramCommand { names: vec!["join".into()], f: iamb_join });
-    cmds.add_command(ProgramCommand { names: vec!["members".into()], f: iamb_members });
-    cmds.add_command(ProgramCommand { names: vec!["react".into()], f: iamb_react });
-    cmds.add_command(ProgramCommand { names: vec!["redact".into()], f: iamb_redact });
-    cmds.add_command(ProgramCommand { names: vec!["reply".into()], f: iamb_reply });
-    cmds.add_command(ProgramCommand { names: vec!["rooms".into()], f: iamb_rooms });
-    cmds.add_command(ProgramCommand { names: vec!["room".into()], f: iamb_room });
-    cmds.add_command(ProgramCommand { names: vec!["spaces".into()], f: iamb_spaces });
-    cmds.add_command(ProgramCommand { names: vec!["unreact".into()], f: iamb_unreact });
-    cmds.add_command(ProgramCommand { names: vec!["upload".into()], f: iamb_upload });
-    cmds.add_command(ProgramCommand { names: vec!["verify".into()], f: iamb_verify });
-    cmds.add_command(ProgramCommand { names: vec!["welcome".into()], f: iamb_welcome });
+    cmds.add_command(ProgramCommand {
+        name: "cancel".into(),
+        aliases: vec![],
+        f: iamb_cancel,
+    });
+    cmds.add_command(ProgramCommand {
+        name: "create".into(),
+        aliases: vec![],
+        f: iamb_create,
+    });
+    cmds.add_command(ProgramCommand { name: "dms".into(), aliases: vec![], f: iamb_dms });
+    cmds.add_command(ProgramCommand {
+        name: "download".into(),
+        aliases: vec![],
+        f: iamb_download,
+    });
+    cmds.add_command(ProgramCommand { name: "open".into(), aliases: vec![], f: iamb_open });
+    cmds.add_command(ProgramCommand { name: "edit".into(), aliases: vec![], f: iamb_edit });
+    cmds.add_command(ProgramCommand {
+        name: "invite".into(),
+        aliases: vec![],
+        f: iamb_invite,
+    });
+    cmds.add_command(ProgramCommand { name: "join".into(), aliases: vec![], f: iamb_join });
+    cmds.add_command(ProgramCommand {
+        name: "members".into(),
+        aliases: vec![],
+        f: iamb_members,
+    });
+    cmds.add_command(ProgramCommand {
+        name: "react".into(),
+        aliases: vec![],
+        f: iamb_react,
+    });
+    cmds.add_command(ProgramCommand {
+        name: "redact".into(),
+        aliases: vec![],
+        f: iamb_redact,
+    });
+    cmds.add_command(ProgramCommand {
+        name: "reply".into(),
+        aliases: vec![],
+        f: iamb_reply,
+    });
+    cmds.add_command(ProgramCommand {
+        name: "rooms".into(),
+        aliases: vec![],
+        f: iamb_rooms,
+    });
+    cmds.add_command(ProgramCommand { name: "room".into(), aliases: vec![], f: iamb_room });
+    cmds.add_command(ProgramCommand {
+        name: "spaces".into(),
+        aliases: vec![],
+        f: iamb_spaces,
+    });
+    cmds.add_command(ProgramCommand {
+        name: "unreact".into(),
+        aliases: vec![],
+        f: iamb_unreact,
+    });
+    cmds.add_command(ProgramCommand {
+        name: "upload".into(),
+        aliases: vec![],
+        f: iamb_upload,
+    });
+    cmds.add_command(ProgramCommand {
+        name: "verify".into(),
+        aliases: vec![],
+        f: iamb_verify,
+    });
+    cmds.add_command(ProgramCommand {
+        name: "welcome".into(),
+        aliases: vec![],
+        f: iamb_welcome,
+    });
 }
 
 pub fn setup_commands() -> ProgramCommands {

src/config.rs

@@ -11,6 +11,7 @@ use std::process;
 use clap::Parser;
 use matrix_sdk::ruma::{OwnedUserId, UserId};
 use serde::{de::Error as SerdeError, de::Visitor, Deserialize, Deserializer};
+use tracing::Level;
 use url::Url;
 
 use modalkit::tui::{
@@ -25,6 +26,8 @@ macro_rules! usage {
     }
 }
 
+const DEFAULT_REQ_TIMEOUT: u64 = 120;
+
 const COLORS: [Color; 13] = [
     Color::Blue,
     Color::Cyan,
@@ -106,6 +109,47 @@ pub enum ConfigError {
     Invalid(#[from] serde_json::Error),
 }
 
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct LogLevel(pub Level);
+pub struct LogLevelVisitor;
+
+impl From<LogLevel> for Level {
+    fn from(level: LogLevel) -> Level {
+        level.0
+    }
+}
+
+impl<'de> Visitor<'de> for LogLevelVisitor {
+    type Value = LogLevel;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter.write_str("a valid log level (e.g. \"warn\" or \"debug\")")
+    }
+
+    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+    where
+        E: SerdeError,
+    {
+        match value {
+            "info" => Ok(LogLevel(Level::INFO)),
+            "debug" => Ok(LogLevel(Level::DEBUG)),
+            "warn" => Ok(LogLevel(Level::WARN)),
+            "error" => Ok(LogLevel(Level::ERROR)),
+            "trace" => Ok(LogLevel(Level::TRACE)),
+            _ => Err(E::custom("Could not parse log level")),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for LogLevel {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_str(LogLevelVisitor)
+    }
+}
+
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub struct UserColor(pub Color);
 pub struct UserColorVisitor;
@@ -178,10 +222,12 @@ fn merge_users(a: Option<UserOverrides>, b: Option<UserOverrides>) -> Option<Use
 
 #[derive(Clone)]
 pub struct TunableValues {
+    pub log_level: Level,
     pub reaction_display: bool,
     pub reaction_shortcode_display: bool,
     pub read_receipt_send: bool,
     pub read_receipt_display: bool,
+    pub request_timeout: u64,
     pub typing_notice_send: bool,
     pub typing_notice_display: bool,
     pub users: UserOverrides,
@@ -190,10 +236,12 @@ pub struct TunableValues {
 
 #[derive(Clone, Default, Deserialize)]
 pub struct Tunables {
+    pub log_level: Option<LogLevel>,
     pub reaction_display: Option<bool>,
     pub reaction_shortcode_display: Option<bool>,
     pub read_receipt_send: Option<bool>,
     pub read_receipt_display: Option<bool>,
+    pub request_timeout: Option<u64>,
     pub typing_notice_send: Option<bool>,
     pub typing_notice_display: Option<bool>,
     pub users: Option<UserOverrides>,
@@ -203,12 +251,14 @@ pub struct Tunables {
 impl Tunables {
     fn merge(self, other: Self) -> Self {
         Tunables {
+            log_level: self.log_level.or(other.log_level),
             reaction_display: self.reaction_display.or(other.reaction_display),
             reaction_shortcode_display: self
                 .reaction_shortcode_display
                 .or(other.reaction_shortcode_display),
             read_receipt_send: self.read_receipt_send.or(other.read_receipt_send),
             read_receipt_display: self.read_receipt_display.or(other.read_receipt_display),
+            request_timeout: self.request_timeout.or(other.request_timeout),
             typing_notice_send: self.typing_notice_send.or(other.typing_notice_send),
             typing_notice_display: self.typing_notice_display.or(other.typing_notice_display),
             users: merge_users(self.users, other.users),
@@ -218,10 +268,12 @@ impl Tunables {
 
     fn values(self) -> TunableValues {
         TunableValues {
+            log_level: self.log_level.map(Level::from).unwrap_or(Level::INFO),
             reaction_display: self.reaction_display.unwrap_or(true),
             reaction_shortcode_display: self.reaction_shortcode_display.unwrap_or(false),
             read_receipt_send: self.read_receipt_send.unwrap_or(true),
             read_receipt_display: self.read_receipt_display.unwrap_or(true),
+            request_timeout: self.request_timeout.unwrap_or(DEFAULT_REQ_TIMEOUT),
             typing_notice_send: self.typing_notice_send.unwrap_or(true),
             typing_notice_display: self.typing_notice_display.unwrap_or(true),
             users: self.users.unwrap_or_default(),

src/keybindings.rs

@@ -1,34 +1,21 @@
 use modalkit::{
     editing::action::WindowAction,
-    editing::base::WordStyle,
     env::vim::keybindings::{InputStep, VimBindings},
     env::vim::VimMode,
     input::bindings::{EdgeEvent, EdgeRepeat, InputBindings},
     input::key::TerminalKey,
 };
 
-use crate::base::{IambAction, IambInfo, Keybindings};
+use crate::base::{IambAction, IambInfo, Keybindings, MATRIX_ID_WORD};
 
 type IambStep = InputStep<IambInfo>;
 
-/// Find the boundaries for a Matrix username, room alias, or room ID.
-///
-/// Technically "[" and "]" should be here since IPv6 addresses are allowed
-/// in the server name, but in practice that should be uncommon, and people
-/// can just use `gf` and friends in Visual mode instead.
-fn is_mxid_char(c: char) -> bool {
-    return c >= 'a' && c <= 'z' ||
-        c >= 'A' && c <= 'Z' ||
-        c >= '0' && c <= '9' ||
-        ":-./@_#!".contains(c);
-}
-
 pub fn setup_keybindings() -> Keybindings {
     let mut ism = Keybindings::empty();
 
     let vim = VimBindings::default()
         .submit_on_enter()
-        .cursor_open(WordStyle::CharSet(is_mxid_char));
+        .cursor_open(MATRIX_ID_WORD.clone());
 
     vim.setup(&mut ism);
 

src/main.rs

@@ -15,7 +15,6 @@ use std::time::Duration;
 
 use clap::Parser;
 use tokio::sync::Mutex as AsyncMutex;
-use tracing::{self, Level};
 use tracing_subscriber::FmtSubscriber;
 
 use matrix_sdk::ruma::OwnedUserId;
@@ -53,20 +52,19 @@ use crate::{
     base::{
         AsyncProgramStore,
         ChatStore,
+        HomeserverAction,
         IambAction,
-        IambBufferId,
         IambError,
         IambId,
         IambInfo,
         IambResult,
         ProgramAction,
-        ProgramCommands,
         ProgramContext,
         ProgramStore,
     },
     config::{ApplicationSettings, Iamb},
     windows::IambWindow,
-    worker::{ClientWorker, LoginStyle, Requester},
+    worker::{create_room, ClientWorker, LoginStyle, Requester},
 };
 
 use modalkit::{
@@ -102,21 +100,12 @@ use modalkit::{
     },
 };
 
-const MIN_MSG_LOAD: u32 = 50;
-
-fn msg_load_req(area: Rect) -> u32 {
-    let n = area.height as u32;
-
-    n.max(MIN_MSG_LOAD)
-}
-
 struct Application {
     store: AsyncProgramStore,
     worker: Requester,
     terminal: Terminal<CrosstermBackend<Stdout>>,
     bindings: KeyManager<TerminalKey, ProgramAction, RepeatType, ProgramContext>,
     actstack: VecDeque<(ProgramAction, ProgramContext)>,
-    cmds: ProgramCommands,
     screen: ScreenState<IambWindow, IambInfo>,
 }
 
@@ -138,7 +127,6 @@ impl Application {
 
         let bindings = crate::keybindings::setup_keybindings();
         let bindings = KeyManager::new(bindings);
-        let cmds = crate::commands::setup_commands();
 
         let mut locked = store.lock().await;
 
@@ -149,7 +137,7 @@ impl Application {
             .or_else(|| IambWindow::open(IambId::Welcome, locked.deref_mut()).ok())
             .unwrap();
 
-        let cmd = CommandBarState::new(IambBufferId::Command, locked.deref_mut());
+        let cmd = CommandBarState::new(locked.deref_mut());
         let screen = ScreenState::new(win, cmd);
 
         let worker = locked.application.worker.clone();
@@ -163,7 +151,6 @@ impl Application {
             terminal,
             bindings,
             actstack,
-            cmds,
             screen,
         })
     }
@@ -194,8 +181,6 @@ impl Application {
                 }
                 f.set_cursor(cx, cy);
             }
-
-            store.application.load_older(msg_load_req(area));
         })?;
 
         Ok(())
@@ -321,7 +306,7 @@ impl Application {
                 None
             },
             Action::Command(act) => {
-                let acts = self.cmds.command(&act, &ctx)?;
+                let acts = store.application.cmds.command(&act, &ctx)?;
                 self.action_prepend(acts);
 
                 None
@@ -360,6 +345,12 @@ impl Application {
                 None
             },
 
+            IambAction::Homeserver(act) => {
+                let acts = self.homeserver_command(act, ctx, store).await?;
+                self.action_prepend(acts);
+
+                None
+            },
             IambAction::Message(act) => {
                 self.screen.current_window_mut()?.message_command(act, ctx, store).await?
             },
@@ -392,6 +383,25 @@ impl Application {
         Ok(info)
     }
 
+    async fn homeserver_command(
+        &mut self,
+        action: HomeserverAction,
+        ctx: ProgramContext,
+        store: &mut ProgramStore,
+    ) -> IambResult<Vec<(Action<IambInfo>, ProgramContext)>> {
+        match action {
+            HomeserverAction::CreateRoom(alias, vis, flags) => {
+                let client = &store.application.worker.client;
+                let room_id = create_room(client, alias.as_deref(), vis, flags).await?;
+                let room = IambId::Room(room_id);
+                let target = OpenTarget::Application(room);
+                let action = WindowAction::Switch(target);
+
+                Ok(vec![(action.into(), ctx)])
+            },
+        }
+    }
+
     pub async fn run(&mut self) -> Result<(), std::io::Error> {
         self.terminal.clear()?;
 
@@ -523,7 +533,7 @@ fn main() -> IambResult<()> {
 
     let subscriber = FmtSubscriber::builder()
         .with_writer(appender)
-        .with_max_level(Level::TRACE)
+        .with_max_level(settings.tunables.log_level)
         .finish();
     tracing::subscriber::set_global_default(subscriber).expect("setting default subscriber failed");
 

src/message/html.rs

@@ -6,7 +6,7 @@
 //! The Matrix specification recommends limiting rendered tags and attributes to a safe subset of
 //! HTML. You can read more in section 11.2.1.1, "m.room.message msgtypes":
 //!
-//!   https://spec.matrix.org/unstable/client-server-api/#mroommessage-msgtypes
+//!   <https://spec.matrix.org/unstable/client-server-api/#mroommessage-msgtypes>
 //!
 //! This isn't as important for iamb, since it isn't a browser environment, but we do still map
 //! input onto an enum of the safe list of tags to keep it easy to understand and process.
@@ -271,10 +271,12 @@ impl StyleTreeNode {
             },
             StyleTreeNode::Header(child, level) => {
                 let style = style.add_modifier(StyleModifier::BOLD);
-                let mut hashes = "#".repeat(*level);
-                hashes.push(' ');
 
-                printer.push_str(hashes, style);
+                for _ in 0..*level {
+                    printer.push_str("#", style);
+                }
+
+                printer.push_str(" ", style);
                 child.print(printer, style);
             },
             StyleTreeNode::Image(None) => {},
@@ -320,7 +322,9 @@ impl StyleTreeNode {
                 printer.commit();
             },
             StyleTreeNode::Ruler => {
-                printer.push_str(line::HORIZONTAL.repeat(width), style);
+                for _ in 0..width {
+                    printer.push_str(line::HORIZONTAL, style);
+                }
             },
             StyleTreeNode::Table(table) => {
                 let text = table.to_text(width, style);
@@ -615,7 +619,7 @@ pub fn parse_matrix_html(s: &str) -> StyleTree {
     let dom = parse_fragment(
         RcDom::default(),
         ParseOpts::default(),
-        QualName::new(None, ns!(), local_name!("div")),
+        QualName::new(None, ns!(html), local_name!("body")),
         vec![],
     )
     .one(StrTendril::from(s));
@@ -636,8 +640,11 @@ pub mod tests {
         let tree = parse_matrix_html(s);
         let text = tree.to_text(20, Style::default(), false);
         assert_eq!(text.lines, vec![Spans(vec![
-            Span::styled("# ", bold),
-            Span::styled("Header 1", bold),
+            Span::styled("#", bold),
+            Span::styled(" ", bold),
+            Span::styled("Header", bold),
+            Span::styled(" ", bold),
+            Span::styled("1", bold),
             space_span(10, Style::default())
         ])]);
 
@@ -645,8 +652,12 @@ pub mod tests {
         let tree = parse_matrix_html(s);
         let text = tree.to_text(20, Style::default(), false);
         assert_eq!(text.lines, vec![Spans(vec![
-            Span::styled("## ", bold),
-            Span::styled("Header 2", bold),
+            Span::styled("#", bold),
+            Span::styled("#", bold),
+            Span::styled(" ", bold),
+            Span::styled("Header", bold),
+            Span::styled(" ", bold),
+            Span::styled("2", bold),
             space_span(9, Style::default())
         ])]);
 
@@ -654,8 +665,13 @@ pub mod tests {
         let tree = parse_matrix_html(s);
         let text = tree.to_text(20, Style::default(), false);
         assert_eq!(text.lines, vec![Spans(vec![
-            Span::styled("### ", bold),
-            Span::styled("Header 3", bold),
+            Span::styled("#", bold),
+            Span::styled("#", bold),
+            Span::styled("#", bold),
+            Span::styled(" ", bold),
+            Span::styled("Header", bold),
+            Span::styled(" ", bold),
+            Span::styled("3", bold),
             space_span(8, Style::default())
         ])]);
 
@@ -663,8 +679,14 @@ pub mod tests {
         let tree = parse_matrix_html(s);
         let text = tree.to_text(20, Style::default(), false);
         assert_eq!(text.lines, vec![Spans(vec![
-            Span::styled("#### ", bold),
-            Span::styled("Header 4", bold),
+            Span::styled("#", bold),
+            Span::styled("#", bold),
+            Span::styled("#", bold),
+            Span::styled("#", bold),
+            Span::styled(" ", bold),
+            Span::styled("Header", bold),
+            Span::styled(" ", bold),
+            Span::styled("4", bold),
             space_span(7, Style::default())
         ])]);
 
@@ -672,8 +694,15 @@ pub mod tests {
         let tree = parse_matrix_html(s);
         let text = tree.to_text(20, Style::default(), false);
         assert_eq!(text.lines, vec![Spans(vec![
-            Span::styled("##### ", bold),
-            Span::styled("Header 5", bold),
+            Span::styled("#", bold),
+            Span::styled("#", bold),
+            Span::styled("#", bold),
+            Span::styled("#", bold),
+            Span::styled("#", bold),
+            Span::styled(" ", bold),
+            Span::styled("Header", bold),
+            Span::styled(" ", bold),
+            Span::styled("5", bold),
             space_span(6, Style::default())
         ])]);
 
@@ -681,8 +710,16 @@ pub mod tests {
         let tree = parse_matrix_html(s);
         let text = tree.to_text(20, Style::default(), false);
         assert_eq!(text.lines, vec![Spans(vec![
-            Span::styled("###### ", bold),
-            Span::styled("Header 6", bold),
+            Span::styled("#", bold),
+            Span::styled("#", bold),
+            Span::styled("#", bold),
+            Span::styled("#", bold),
+            Span::styled("#", bold),
+            Span::styled("#", bold),
+            Span::styled(" ", bold),
+            Span::styled("Header", bold),
+            Span::styled(" ", bold),
+            Span::styled("6", bold),
             space_span(5, Style::default())
         ])]);
     }
@@ -700,7 +737,8 @@ pub mod tests {
         let tree = parse_matrix_html(s);
         let text = tree.to_text(20, Style::default(), false);
         assert_eq!(text.lines, vec![Spans(vec![
-            Span::styled("Bold!", bold),
+            Span::styled("Bold", bold),
+            Span::styled("!", bold),
             space_span(15, def)
         ])]);
 
@@ -708,7 +746,8 @@ pub mod tests {
         let tree = parse_matrix_html(s);
         let text = tree.to_text(20, Style::default(), false);
         assert_eq!(text.lines, vec![Spans(vec![
-            Span::styled("Bold!", bold),
+            Span::styled("Bold", bold),
+            Span::styled("!", bold),
             space_span(15, def)
         ])]);
 
@@ -716,7 +755,8 @@ pub mod tests {
         let tree = parse_matrix_html(s);
         let text = tree.to_text(20, Style::default(), false);
         assert_eq!(text.lines, vec![Spans(vec![
-            Span::styled("Italic!", italic),
+            Span::styled("Italic", italic),
+            Span::styled("!", italic),
             space_span(13, def)
         ])]);
 
@@ -724,7 +764,8 @@ pub mod tests {
         let tree = parse_matrix_html(s);
         let text = tree.to_text(20, Style::default(), false);
         assert_eq!(text.lines, vec![Spans(vec![
-            Span::styled("Italic!", italic),
+            Span::styled("Italic", italic),
+            Span::styled("!", italic),
             space_span(13, def)
         ])]);
 
@@ -732,7 +773,8 @@ pub mod tests {
         let tree = parse_matrix_html(s);
         let text = tree.to_text(20, Style::default(), false);
         assert_eq!(text.lines, vec![Spans(vec![
-            Span::styled("Strikethrough!", strike),
+            Span::styled("Strikethrough", strike),
+            Span::styled("!", strike),
             space_span(6, def)
         ])]);
 
@@ -740,7 +782,8 @@ pub mod tests {
         let tree = parse_matrix_html(s);
         let text = tree.to_text(20, Style::default(), false);
         assert_eq!(text.lines, vec![Spans(vec![
-            Span::styled("Strikethrough!", strike),
+            Span::styled("Strikethrough", strike),
+            Span::styled("!", strike),
             space_span(6, def)
         ])]);
 
@@ -748,19 +791,28 @@ pub mod tests {
         let tree = parse_matrix_html(s);
         let text = tree.to_text(20, Style::default(), false);
         assert_eq!(text.lines, vec![Spans(vec![
-            Span::styled("Underline!", underl),
+            Span::styled("Underline", underl),
+            Span::styled("!", underl),
             space_span(10, def)
         ])]);
 
         let s = "<font color=\"#ff0000\">Red!</u>";
         let tree = parse_matrix_html(s);
         let text = tree.to_text(20, Style::default(), false);
-        assert_eq!(text.lines, vec![Spans(vec![Span::styled("Red!", red), space_span(16, def)])]);
+        assert_eq!(text.lines, vec![Spans(vec![
+            Span::styled("Red", red),
+            Span::styled("!", red),
+            space_span(16, def)
+        ])]);
 
         let s = "<font color=\"red\">Red!</u>";
         let tree = parse_matrix_html(s);
         let text = tree.to_text(20, Style::default(), false);
-        assert_eq!(text.lines, vec![Spans(vec![Span::styled("Red!", red), space_span(16, def)])]);
+        assert_eq!(text.lines, vec![Spans(vec![
+            Span::styled("Red", red),
+            Span::styled("!", red),
+            space_span(16, def)
+        ])]);
     }
 
     #[test]
@@ -769,13 +821,25 @@ pub mod tests {
         let tree = parse_matrix_html(s);
         let text = tree.to_text(10, Style::default(), false);
         assert_eq!(text.lines.len(), 7);
-        assert_eq!(text.lines[0], Spans(vec![Span::raw("Hello worl")]));
-        assert_eq!(text.lines[1], Spans(vec![Span::raw("d!"), Span::raw("        ")]));
+        assert_eq!(
+            text.lines[0],
+            Spans(vec![Span::raw("Hello"), Span::raw(" "), Span::raw("    ")])
+        );
+        assert_eq!(
+            text.lines[1],
+            Spans(vec![Span::raw("world"), Span::raw("!"), Span::raw("    ")])
+        );
         assert_eq!(text.lines[2], Spans(vec![Span::raw("          ")]));
         assert_eq!(text.lines[3], Spans(vec![Span::raw("Content"), Span::raw("   ")]));
         assert_eq!(text.lines[4], Spans(vec![Span::raw("          ")]));
-        assert_eq!(text.lines[5], Spans(vec![Span::raw("Goodbye wo")]));
-        assert_eq!(text.lines[6], Spans(vec![Span::raw("rld!"), Span::raw("      ")]));
+        assert_eq!(
+            text.lines[5],
+            Spans(vec![Span::raw("Goodbye"), Span::raw(" "), Span::raw("  ")])
+        );
+        assert_eq!(
+            text.lines[6],
+            Spans(vec![Span::raw("world"), Span::raw("!"), Span::raw("    ")])
+        );
     }
 
     #[test]
@@ -784,8 +848,14 @@ pub mod tests {
         let tree = parse_matrix_html(s);
         let text = tree.to_text(10, Style::default(), false);
         assert_eq!(text.lines.len(), 2);
-        assert_eq!(text.lines[0], Spans(vec![Span::raw("    "), Span::raw("Hello ")]));
-        assert_eq!(text.lines[1], Spans(vec![Span::raw("    "), Span::raw("world!")]));
+        assert_eq!(
+            text.lines[0],
+            Spans(vec![Span::raw("    "), Span::raw("Hello"), Span::raw(" ")])
+        );
+        assert_eq!(
+            text.lines[1],
+            Spans(vec![Span::raw("    "), Span::raw("world"), Span::raw("!")])
+        );
     }
 
     #[test]
@@ -794,12 +864,60 @@ pub mod tests {
         let tree = parse_matrix_html(s);
         let text = tree.to_text(8, Style::default(), false);
         assert_eq!(text.lines.len(), 6);
-        assert_eq!(text.lines[0], Spans(vec![Span::raw("- "), Span::raw("List I")]));
-        assert_eq!(text.lines[1], Spans(vec![Span::raw("  "), Span::raw("tem 1"), Span::raw(" ")]));
-        assert_eq!(text.lines[2], Spans(vec![Span::raw("- "), Span::raw("List I")]));
-        assert_eq!(text.lines[3], Spans(vec![Span::raw("  "), Span::raw("tem 2"), Span::raw(" ")]));
-        assert_eq!(text.lines[4], Spans(vec![Span::raw("- "), Span::raw("List I")]));
-        assert_eq!(text.lines[5], Spans(vec![Span::raw("  "), Span::raw("tem 3"), Span::raw(" ")]));
+        assert_eq!(
+            text.lines[0],
+            Spans(vec![
+                Span::raw("- "),
+                Span::raw("List"),
+                Span::raw(" "),
+                Span::raw(" ")
+            ])
+        );
+        assert_eq!(
+            text.lines[1],
+            Spans(vec![
+                Span::raw("  "),
+                Span::raw("Item"),
+                Span::raw(" "),
+                Span::raw("1")
+            ])
+        );
+        assert_eq!(
+            text.lines[2],
+            Spans(vec![
+                Span::raw("- "),
+                Span::raw("List"),
+                Span::raw(" "),
+                Span::raw(" ")
+            ])
+        );
+        assert_eq!(
+            text.lines[3],
+            Spans(vec![
+                Span::raw("  "),
+                Span::raw("Item"),
+                Span::raw(" "),
+                Span::raw("2")
+            ])
+        );
+        assert_eq!(
+            text.lines[4],
+            Spans(vec![
+                Span::raw("- "),
+                Span::raw("List"),
+                Span::raw(" "),
+                Span::raw(" ")
+            ])
+        );
+        assert_eq!(
+            text.lines[5],
+            Spans(vec![
+                Span::raw("  "),
+                Span::raw("Item"),
+                Span::raw(" "),
+                Span::raw("3")
+            ])
+        );
     }
 
     #[test]
@@ -808,20 +926,59 @@ pub mod tests {
         let tree = parse_matrix_html(s);
         let text = tree.to_text(9, Style::default(), false);
         assert_eq!(text.lines.len(), 6);
-        assert_eq!(text.lines[0], Spans(vec![Span::raw("1. "), Span::raw("List I")]));
+        assert_eq!(
+            text.lines[0],
+            Spans(vec![
+                Span::raw("1. "),
+                Span::raw("List"),
+                Span::raw(" "),
+                Span::raw(" ")
+            ])
+        );
         assert_eq!(
             text.lines[1],
-            Spans(vec![Span::raw("   "), Span::raw("tem 1"), Span::raw(" ")])
+            Spans(vec![
+                Span::raw("   "),
+                Span::raw("Item"),
+                Span::raw(" "),
+                Span::raw("1")
+            ])
+        );
+        assert_eq!(
+            text.lines[2],
+            Spans(vec![
+                Span::raw("2. "),
+                Span::raw("List"),
+                Span::raw(" "),
+                Span::raw(" ")
+            ])
         );
-        assert_eq!(text.lines[2], Spans(vec![Span::raw("2. "), Span::raw("List I")]));
         assert_eq!(
             text.lines[3],
-            Spans(vec![Span::raw("   "), Span::raw("tem 2"), Span::raw(" ")])
+            Spans(vec![
+                Span::raw("   "),
+                Span::raw("Item"),
+                Span::raw(" "),
+                Span::raw("2")
+            ])
+        );
+        assert_eq!(
+            text.lines[4],
+            Spans(vec![
+                Span::raw("3. "),
+                Span::raw("List"),
+                Span::raw(" "),
+                Span::raw(" ")
+            ])
         );
-        assert_eq!(text.lines[4], Spans(vec![Span::raw("3. "), Span::raw("List I")]));
         assert_eq!(
             text.lines[5],
-            Spans(vec![Span::raw("   "), Span::raw("tem 3"), Span::raw(" ")])
+            Spans(vec![
+                Span::raw("   "),
+                Span::raw("Item"),
+                Span::raw(" "),
+                Span::raw("3")
+            ])
         );
     }
 
@@ -854,9 +1011,13 @@ pub mod tests {
         ]);
         assert_eq!(text.lines[2].0, vec![
             Span::raw("│"),
-            Span::styled("mn 1", bold),
+            Span::styled("mn", bold),
+            Span::styled(" ", bold),
+            Span::styled("1", bold),
             Span::raw("│"),
-            Span::styled("mn 2", bold),
+            Span::styled("mn", bold),
+            Span::styled(" ", bold),
+            Span::styled("2", bold),
             Span::raw("│"),
             Span::styled("umn", bold),
             Span::raw("│")
@@ -867,7 +1028,8 @@ pub mod tests {
             Span::raw("│"),
             Span::raw("    "),
             Span::raw("│"),
-            Span::styled(" 3", bold),
+            Span::styled(" ", bold),
+            Span::styled("3", bold),
             Span::styled(" ", bold),
             Span::raw("│")
         ]);
@@ -928,15 +1090,72 @@ pub mod tests {
         let tree = parse_matrix_html(s);
         let text = tree.to_text(10, Style::default(), false);
         assert_eq!(text.lines.len(), 4);
-        assert_eq!(text.lines[0], Spans(vec![Span::raw("This was r")]));
-        assert_eq!(text.lines[1], Spans(vec![Span::raw("eplied to"), Span::raw(" ")]));
-        assert_eq!(text.lines[2], Spans(vec![Span::raw("This is th")]));
-        assert_eq!(text.lines[3], Spans(vec![Span::raw("e reply"), Span::raw("   ")]));
+        assert_eq!(
+            text.lines[0],
+            Spans(vec![
+                Span::raw("This"),
+                Span::raw(" "),
+                Span::raw("was"),
+                Span::raw(" "),
+                Span::raw(" ")
+            ])
+        );
+        assert_eq!(
+            text.lines[1],
+            Spans(vec![Span::raw("replied"), Span::raw(" "), Span::raw("to")])
+        );
+        assert_eq!(
+            text.lines[2],
+            Spans(vec![
+                Span::raw("This"),
+                Span::raw(" "),
+                Span::raw("is"),
+                Span::raw(" "),
+                Span::raw("  ")
+            ])
+        );
+        assert_eq!(
+            text.lines[3],
+            Spans(vec![
+                Span::raw("the"),
+                Span::raw(" "),
+                Span::raw("reply"),
+                Span::raw(" ")
+            ])
+        );
 
         let tree = parse_matrix_html(s);
         let text = tree.to_text(10, Style::default(), true);
         assert_eq!(text.lines.len(), 2);
-        assert_eq!(text.lines[0], Spans(vec![Span::raw("This is th")]));
-        assert_eq!(text.lines[1], Spans(vec![Span::raw("e reply"), Span::raw("   ")]));
+        assert_eq!(
+            text.lines[0],
+            Spans(vec![
+                Span::raw("This"),
+                Span::raw(" "),
+                Span::raw("is"),
+                Span::raw(" "),
+                Span::raw("  ")
+            ])
+        );
+        assert_eq!(
+            text.lines[1],
+            Spans(vec![
+                Span::raw("the"),
+                Span::raw(" "),
+                Span::raw("reply"),
+                Span::raw(" ")
+            ])
+        );
+    }
+
+    #[test]
+    fn test_self_closing() {
+        let s = "Hello<br>World<br>Goodbye";
+        let tree = parse_matrix_html(s);
+        let text = tree.to_text(7, Style::default(), true);
+        assert_eq!(text.lines.len(), 3);
+        assert_eq!(text.lines[0], Spans(vec![Span::raw("Hello"), Span::raw("  "),]));
+        assert_eq!(text.lines[1], Spans(vec![Span::raw("World"), Span::raw("  "),]));
+        assert_eq!(text.lines[2], Spans(vec![Span::raw("Goodbye")]),);
     }
 }

src/message/mod.rs

@@ -12,6 +12,11 @@ use unicode_width::UnicodeWidthStr;
 use matrix_sdk::ruma::{
     events::{
         room::{
+            encrypted::{
+                OriginalRoomEncryptedEvent,
+                RedactedRoomEncryptedEvent,
+                RoomEncryptedEvent,
+            },
             message::{
                 FormattedBody,
                 MessageFormat,
@@ -26,6 +31,7 @@ use matrix_sdk::ruma::{
         },
         AnyMessageLikeEvent,
         Redact,
+        RedactedUnsigned,
     },
     EventId,
     MilliSecondsSinceUnixEpoch,
@@ -318,6 +324,8 @@ impl PartialOrd for MessageCursor {
 
 #[derive(Clone)]
 pub enum MessageEvent {
+    EncryptedOriginal(Box<OriginalRoomEncryptedEvent>),
+    EncryptedRedacted(Box<RedactedRoomEncryptedEvent>),
     Original(Box<OriginalRoomMessageEvent>),
     Redacted(Box<RedactedRoomMessageEvent>),
     Local(OwnedEventId, Box<RoomMessageEventContent>),
@@ -326,35 +334,45 @@ pub enum MessageEvent {
 impl MessageEvent {
     pub fn event_id(&self) -> &EventId {
         match self {
+            MessageEvent::EncryptedOriginal(ev) => ev.event_id.as_ref(),
+            MessageEvent::EncryptedRedacted(ev) => ev.event_id.as_ref(),
             MessageEvent::Original(ev) => ev.event_id.as_ref(),
             MessageEvent::Redacted(ev) => ev.event_id.as_ref(),
             MessageEvent::Local(event_id, _) => event_id.as_ref(),
         }
     }
 
+    pub fn content(&self) -> Option<&RoomMessageEventContent> {
+        match self {
+            MessageEvent::EncryptedOriginal(_) => None,
+            MessageEvent::Original(ev) => Some(&ev.content),
+            MessageEvent::EncryptedRedacted(_) => None,
+            MessageEvent::Redacted(_) => None,
+            MessageEvent::Local(_, content) => Some(content),
+        }
+    }
+
+    pub fn is_emote(&self) -> bool {
+        matches!(
+            self.content(),
+            Some(RoomMessageEventContent { msgtype: MessageType::Emote(_), .. })
+        )
+    }
+
     pub fn body(&self) -> Cow<'_, str> {
         match self {
+            MessageEvent::EncryptedOriginal(_) => "[Unable to decrypt message]".into(),
             MessageEvent::Original(ev) => body_cow_content(&ev.content),
-            MessageEvent::Redacted(ev) => {
-                let reason = ev
-                    .unsigned
-                    .redacted_because
-                    .as_ref()
-                    .and_then(|e| e.as_original())
-                    .and_then(|r| r.content.reason.as_ref());
-
-                if let Some(r) = reason {
-                    Cow::Owned(format!("[Redacted: {r:?}]"))
-                } else {
-                    Cow::Borrowed("[Redacted]")
-                }
-            },
+            MessageEvent::EncryptedRedacted(ev) => body_cow_reason(&ev.unsigned),
+            MessageEvent::Redacted(ev) => body_cow_reason(&ev.unsigned),
             MessageEvent::Local(_, content) => body_cow_content(content),
         }
     }
 
     pub fn html(&self) -> Option<StyleTree> {
         let content = match self {
+            MessageEvent::EncryptedOriginal(_) => return None,
+            MessageEvent::EncryptedRedacted(_) => return None,
             MessageEvent::Original(ev) => &ev.content,
             MessageEvent::Redacted(_) => return None,
             MessageEvent::Local(_, content) => content,
@@ -371,8 +389,10 @@ impl MessageEvent {
         }
     }
 
-    pub fn redact(&mut self, redaction: SyncRoomRedactionEvent, version: &RoomVersionId) {
+    fn redact(&mut self, redaction: SyncRoomRedactionEvent, version: &RoomVersionId) {
         match self {
+            MessageEvent::EncryptedOriginal(_) => return,
+            MessageEvent::EncryptedRedacted(_) => return,
             MessageEvent::Redacted(_) => return,
             MessageEvent::Local(_, _) => return,
             MessageEvent::Original(ev) => {
@@ -411,6 +431,20 @@ fn body_cow_content(content: &RoomMessageEventContent) -> Cow<'_, str> {
     Cow::Borrowed(s)
 }
 
+fn body_cow_reason(unsigned: &RedactedUnsigned) -> Cow<'_, str> {
+    let reason = unsigned
+        .redacted_because
+        .as_ref()
+        .and_then(|e| e.as_original())
+        .and_then(|r| r.content.reason.as_ref());
+
+    if let Some(r) = reason {
+        Cow::Owned(format!("[Redacted: {r:?}]"))
+    } else {
+        Cow::Borrowed("[Redacted]")
+    }
+}
+
 enum MessageColumns {
     /// Four columns: sender, message, timestamp, read receipts.
     Four,
@@ -548,6 +582,8 @@ impl Message {
 
     pub fn reply_to(&self) -> Option<OwnedEventId> {
         let content = match &self.event {
+            MessageEvent::EncryptedOriginal(_) => return None,
+            MessageEvent::EncryptedRedacted(_) => return None,
             MessageEvent::Local(_, content) => content,
             MessageEvent::Original(ev) => &ev.content,
             MessageEvent::Redacted(_) => return None,
@@ -710,7 +746,11 @@ impl Message {
                     key
                 };
 
-                emojis.push_str(format!("[{name} {count}]"), style);
+                emojis.push_str("[", style);
+                emojis.push_str(name, style);
+                emojis.push_str(" ", style);
+                emojis.push_span_nobreak(Span::styled(count.to_string(), style));
+                emojis.push_str("]", style);
 
                 reactions += 1;
             }
@@ -748,7 +788,10 @@ impl Message {
         settings: &ApplicationSettings,
     ) -> Option<Span> {
         if let Some(prev) = prev {
-            if self.sender == prev.sender && self.timestamp.same_day(&prev.timestamp) {
+            if self.sender == prev.sender &&
+                self.timestamp.same_day(&prev.timestamp) &&
+                !self.event.is_emote()
+            {
                 return None;
             }
         }
@@ -765,6 +808,24 @@ impl Message {
 
         Span::styled(sender, style).into()
     }
+
+    pub fn redact(&mut self, redaction: SyncRoomRedactionEvent, version: &RoomVersionId) {
+        self.event.redact(redaction, version);
+        self.html = None;
+    }
+}
+
+impl From<RoomEncryptedEvent> for Message {
+    fn from(event: RoomEncryptedEvent) -> Self {
+        let timestamp = event.origin_server_ts().into();
+        let user_id = event.sender().to_owned();
+        let content = match event {
+            RoomEncryptedEvent::Original(ev) => MessageEvent::EncryptedOriginal(ev.into()),
+            RoomEncryptedEvent::Redacted(ev) => MessageEvent::EncryptedRedacted(ev.into()),
+        };
+
+        Message::new(content, user_id, timestamp)
+    }
 }
 
 impl From<OriginalRoomMessageEvent> for Message {

src/message/printer.rs

@@ -3,6 +3,7 @@ use std::borrow::Cow;
 use modalkit::tui::layout::Alignment;
 use modalkit::tui::style::Style;
 use modalkit::tui::text::{Span, Spans, Text};
+use unicode_segmentation::UnicodeSegmentation;
 use unicode_width::UnicodeWidthStr;
 
 use crate::util::{space_span, take_width};
@@ -107,7 +108,7 @@ impl<'a> TextPrinter<'a> {
         self.push();
     }
 
-    pub fn push_str<T>(&mut self, s: T, style: Style)
+    fn push_str_wrapped<T>(&mut self, s: T, style: Style)
     where
         T: Into<Cow<'a, str>>,
     {
@@ -140,6 +141,55 @@ impl<'a> TextPrinter<'a> {
         }
     }
 
+    pub fn push_span_nobreak(&mut self, span: Span<'a>) {
+        let sw = UnicodeWidthStr::width(span.content.as_ref());
+
+        if self.curr_width + sw > self.width {
+            // Span doesn't fit on this line, so start a new one.
+            self.commit();
+        }
+
+        self.curr_spans.push(span);
+        self.curr_width += sw;
+    }
+
+    pub fn push_str(&mut self, s: &'a str, style: Style) {
+        let style = self.base_style.patch(style);
+
+        for word in UnicodeSegmentation::split_word_bounds(s) {
+            if self.width == 0 && word.chars().all(char::is_whitespace) {
+                // Drop leading whitespace.
+                continue;
+            }
+
+            let sw = UnicodeWidthStr::width(word);
+
+            if sw > self.width {
+                self.push_str_wrapped(word, style);
+                continue;
+            }
+
+            if self.curr_width + sw > self.width {
+                // Word doesn't fit on this line, so start a new one.
+                self.commit();
+
+                if word.chars().all(char::is_whitespace) {
+                    // Drop leading whitespace.
+                    continue;
+                }
+            }
+
+            let span = Span::styled(word, style);
+            self.curr_spans.push(span);
+            self.curr_width += sw;
+        }
+
+        if self.curr_width == self.width {
+            // If the last bit fills the full line, start a new one.
+            self.push();
+        }
+    }
+
     pub fn push_line(&mut self, spans: Spans<'a>) {
         self.commit();
         self.text.lines.push(spans);

src/tests.rs

@@ -17,6 +17,7 @@ use matrix_sdk::ruma::{
 use lazy_static::lazy_static;
 use modalkit::tui::style::{Color, Style};
 use tokio::sync::mpsc::unbounded_channel;
+use tracing::Level;
 use url::Url;
 
 use crate::{
@@ -153,6 +154,7 @@ pub fn mock_room() -> RoomInfo {
         read_till: None,
         reactions: HashMap::new(),
 
+        fetching: false,
         fetch_id: RoomFetchStatus::NotStarted,
         fetch_last: None,
         users_typing: None,
@@ -170,10 +172,12 @@ pub fn mock_dirs() -> DirectoryValues {
 pub fn mock_tunables() -> TunableValues {
     TunableValues {
         default_room: None,
+        log_level: Level::INFO,
         reaction_display: true,
         reaction_shortcode_display: false,
         read_receipt_send: true,
         read_receipt_display: true,
+        request_timeout: 120,
         typing_notice_send: true,
         typing_notice_display: true,
         users: vec![(TEST_USER5.clone(), UserDisplayTunables {
@@ -208,6 +212,14 @@ pub async fn mock_store() -> ProgramStore {
     let worker = Requester { tx, client };
 
     let mut store = ChatStore::new(worker, mock_settings());
+
+    // Add presence information.
+    store.presences.get_or_default(TEST_USER1.clone());
+    store.presences.get_or_default(TEST_USER2.clone());
+    store.presences.get_or_default(TEST_USER3.clone());
+    store.presences.get_or_default(TEST_USER4.clone());
+    store.presences.get_or_default(TEST_USER5.clone());
+
     let room_id = TEST_ROOM1_ID.clone();
     let info = mock_room();
 

src/windows/mod.rs

@@ -1,5 +1,5 @@
 use std::cmp::{Ord, Ordering, PartialOrd};
-use std::collections::hash_map::Entry;
+use std::time::{Duration, Instant};
 
 use matrix_sdk::{
     encryption::verification::{format_emojis, SasVerification},
@@ -45,7 +45,9 @@ use modalkit::{
             ScrollStyle,
             ViewportContext,
             WordStyle,
+            WriteFlags,
         },
+        completion::CompletionList,
     },
     widgets::{
         list::{List, ListCursor, ListItem, ListState},
@@ -76,6 +78,8 @@ use self::{room::RoomState, welcome::WelcomeState};
 pub mod room;
 pub mod welcome;
 
+const MEMBER_FETCH_DEBOUNCE: Duration = Duration::from_secs(5);
+
 #[inline]
 fn bold_style() -> Style {
     Style::default().add_modifier(StyleModifier::BOLD)
@@ -210,7 +214,7 @@ macro_rules! delegate {
         match $s {
             IambWindow::Room($id) => $e,
             IambWindow::DirectList($id) => $e,
-            IambWindow::MemberList($id, _) => $e,
+            IambWindow::MemberList($id, _, _) => $e,
             IambWindow::RoomList($id) => $e,
             IambWindow::SpaceList($id) => $e,
             IambWindow::VerifyList($id) => $e,
@@ -221,7 +225,7 @@ macro_rules! delegate {
 
 pub enum IambWindow {
     DirectList(DirectListState),
-    MemberList(MemberListState, OwnedRoomId),
+    MemberList(MemberListState, OwnedRoomId, Option<Instant>),
     Room(RoomState),
     VerifyList(VerifyListState),
     RoomList(RoomListState),
@@ -391,10 +395,18 @@ impl WindowOps<IambInfo> for IambWindow {
                     .focus(focused)
                     .render(area, buf, state);
             },
-            IambWindow::MemberList(state, room_id) => {
-                if let Ok(mems) = store.application.worker.members(room_id.clone()) {
-                    let items = mems.into_iter().map(MemberItem::new);
-                    state.set(items.collect());
+            IambWindow::MemberList(state, room_id, last_fetch) => {
+                let need_fetch = match last_fetch {
+                    Some(i) => i.elapsed() >= MEMBER_FETCH_DEBOUNCE,
+                    None => true,
+                };
+
+                if need_fetch {
+                    if let Ok(mems) = store.application.worker.members(room_id.clone()) {
+                        let items = mems.into_iter().map(MemberItem::new);
+                        state.set(items.collect());
+                        *last_fetch = Some(Instant::now());
+                    }
                 }
 
                 List::new(store)
@@ -455,8 +467,8 @@ impl WindowOps<IambInfo> for IambWindow {
         match self {
             IambWindow::Room(w) => w.dup(store).into(),
             IambWindow::DirectList(w) => w.dup(store).into(),
-            IambWindow::MemberList(w, room_id) => {
-                IambWindow::MemberList(w.dup(store), room_id.clone())
+            IambWindow::MemberList(w, room_id, last_fetch) => {
+                IambWindow::MemberList(w.dup(store), room_id.clone(), *last_fetch)
             },
             IambWindow::RoomList(w) => w.dup(store).into(),
             IambWindow::SpaceList(w) => w.dup(store).into(),
@@ -469,6 +481,19 @@ impl WindowOps<IambInfo> for IambWindow {
         delegate!(self, w => w.close(flags, store))
     }
 
+    fn write(
+        &mut self,
+        path: Option<&str>,
+        flags: WriteFlags,
+        store: &mut ProgramStore,
+    ) -> IambResult<EditInfo> {
+        delegate!(self, w => w.write(path, flags, store))
+    }
+
+    fn get_completions(&self) -> Option<CompletionList> {
+        delegate!(self, w => w.get_completions())
+    }
+
     fn get_cursor_word(&self, style: &WordStyle) -> Option<String> {
         delegate!(self, w => w.get_cursor_word(style))
     }
@@ -483,7 +508,7 @@ impl Window<IambInfo> for IambWindow {
         match self {
             IambWindow::Room(room) => IambId::Room(room.id().to_owned()),
             IambWindow::DirectList(_) => IambId::DirectList,
-            IambWindow::MemberList(_, room_id) => IambId::MemberList(room_id.clone()),
+            IambWindow::MemberList(_, room_id, _) => IambId::MemberList(room_id.clone()),
             IambWindow::RoomList(_) => IambId::RoomList,
             IambWindow::SpaceList(_) => IambId::SpaceList,
             IambWindow::VerifyList(_) => IambId::VerifyList,
@@ -504,7 +529,7 @@ impl Window<IambInfo> for IambWindow {
 
                 Spans::from(title)
             },
-            IambWindow::MemberList(_, room_id) => {
+            IambWindow::MemberList(_, room_id, _) => {
                 let title = store.application.get_room_title(room_id.as_ref());
 
                 Spans(vec![bold_span("Room Members: "), title.into()])
@@ -521,7 +546,7 @@ impl Window<IambInfo> for IambWindow {
             IambWindow::Welcome(_) => bold_spans("Welcome to iamb"),
 
             IambWindow::Room(w) => w.get_title(store),
-            IambWindow::MemberList(_, room_id) => {
+            IambWindow::MemberList(_, room_id, _) => {
                 let title = store.application.get_room_title(room_id.as_ref());
 
                 Spans(vec![bold_span("Room Members: "), title.into()])
@@ -545,7 +570,7 @@ impl Window<IambInfo> for IambWindow {
             IambId::MemberList(room_id) => {
                 let id = IambBufferId::MemberList(room_id.clone());
                 let list = MemberListState::new(id, vec![]);
-                let win = IambWindow::MemberList(list, room_id);
+                let win = IambWindow::MemberList(list, room_id, None);
 
                 return Ok(win);
             },
@@ -575,21 +600,18 @@ impl Window<IambInfo> for IambWindow {
     fn find(name: String, store: &mut ProgramStore) -> IambResult<Self> {
         let ChatStore { names, worker, .. } = &mut store.application;
 
-        match names.entry(name) {
-            Entry::Vacant(v) => {
-                let room_id = worker.join_room(v.key().to_string())?;
-                v.insert(room_id.clone());
+        if let Some(room) = names.get_mut(&name) {
+            let id = IambId::Room(room.clone());
 
-                let (room, name, tags) = store.application.worker.get_room(room_id)?;
-                let room = RoomState::new(room, name, tags, store);
+            IambWindow::open(id, store)
+        } else {
+            let room_id = worker.join_room(name.clone())?;
+            names.insert(name, room_id.clone());
 
-                Ok(room.into())
-            },
-            Entry::Occupied(o) => {
-                let id = IambId::Room(o.get().clone());
+            let (room, name, tags) = store.application.worker.get_room(room_id)?;
+            let room = RoomState::new(room, name, tags, store);
 
-                IambWindow::open(id, store)
-            },
+            Ok(room.into())
         }
     }
 
@@ -620,11 +642,16 @@ impl RoomItem {
         store: &mut ProgramStore,
     ) -> Self {
         let name = name.to_string();
+        let room_id = room.room_id();
 
-        let info = store.application.get_room_info(room.room_id().to_owned());
+        let info = store.application.get_room_info(room_id.to_owned());
         info.name = name.clone().into();
         info.tags = tags.clone();
 
+        if let Some(alias) = room.canonical_alias() {
+            store.application.names.insert(alias.to_string(), room_id.to_owned());
+        }
+
         RoomItem { room, tags, name }
     }
 }
@@ -772,8 +799,13 @@ pub struct SpaceItem {
 impl SpaceItem {
     fn new(room: MatrixRoom, name: DisplayName, store: &mut ProgramStore) -> Self {
         let name = name.to_string();
+        let room_id = room.room_id();
 
-        store.application.set_room_name(room.room_id(), name.as_str());
+        store.application.set_room_name(room_id, name.as_str());
+
+        if let Some(alias) = room.canonical_alias() {
+            store.application.names.insert(alias.to_string(), room_id.to_owned());
+        }
 
         SpaceItem { room, name }
     }

src/windows/room/chat.rs

@@ -52,7 +52,8 @@ use modalkit::editing::{
         Scrollable,
         UIError,
     },
-    base::{CloseFlags, Count, MoveDir1D, PositionList, ScrollStyle, WordStyle},
+    base::{CloseFlags, Count, MoveDir1D, PositionList, ScrollStyle, WordStyle, WriteFlags},
+    completion::CompletionList,
     context::Resolve,
     history::{self, HistoryList},
     rope::EditRope,
@@ -154,7 +155,7 @@ impl ChatState {
         let client = &store.application.worker.client;
 
         let settings = &store.application.settings;
-        let info = store.application.rooms.entry(self.room_id.clone()).or_default();
+        let info = store.application.rooms.get_or_default(self.room_id.clone());
 
         let msg = self
             .scrollback
@@ -293,6 +294,8 @@ impl ChatState {
             MessageAction::React(emoji) => {
                 let room = self.get_joined(&store.application.worker)?;
                 let event_id = match &msg.event {
+                    MessageEvent::EncryptedOriginal(ev) => ev.event_id.clone(),
+                    MessageEvent::EncryptedRedacted(ev) => ev.event_id.clone(),
                     MessageEvent::Original(ev) => ev.event_id.clone(),
                     MessageEvent::Local(event_id, _) => event_id.clone(),
                     MessageEvent::Redacted(_) => {
@@ -312,6 +315,8 @@ impl ChatState {
             MessageAction::Redact(reason) => {
                 let room = self.get_joined(&store.application.worker)?;
                 let event_id = match &msg.event {
+                    MessageEvent::EncryptedOriginal(ev) => ev.event_id.clone(),
+                    MessageEvent::EncryptedRedacted(ev) => ev.event_id.clone(),
                     MessageEvent::Original(ev) => ev.event_id.clone(),
                     MessageEvent::Local(event_id, _) => event_id.clone(),
                     MessageEvent::Redacted(_) => {
@@ -337,6 +342,8 @@ impl ChatState {
             MessageAction::Unreact(emoji) => {
                 let room = self.get_joined(&store.application.worker)?;
                 let event_id: &EventId = match &msg.event {
+                    MessageEvent::EncryptedOriginal(ev) => ev.event_id.as_ref(),
+                    MessageEvent::EncryptedRedacted(ev) => ev.event_id.as_ref(),
                     MessageEvent::Original(ev) => ev.event_id.as_ref(),
                     MessageEvent::Local(event_id, _) => event_id.as_ref(),
                     MessageEvent::Redacted(_) => {
@@ -389,18 +396,18 @@ impl ChatState {
             .client
             .get_joined_room(self.id())
             .ok_or(IambError::NotJoined)?;
-        let info = store.application.rooms.entry(self.id().to_owned()).or_default();
+        let info = store.application.rooms.get_or_default(self.id().to_owned());
         let mut show_echo = true;
 
         let (event_id, msg) = match act {
             SendAction::Submit => {
-                let msg = self.tbox.get_text();
+                let msg = self.tbox.get();
 
-                if msg.is_empty() {
+                if msg.is_blank() {
                     return Ok(None);
                 }
 
-                let msg = TextMessageEventContent::markdown(msg);
+                let msg = TextMessageEventContent::markdown(msg.to_string());
                 let msg = MessageType::Text(msg);
 
                 let mut msg = RoomMessageEventContent::new(msg);
@@ -550,6 +557,21 @@ impl WindowOps<IambInfo> for ChatState {
         true
     }
 
+    fn write(
+        &mut self,
+        _: Option<&str>,
+        _: WriteFlags,
+        _: &mut ProgramStore,
+    ) -> IambResult<EditInfo> {
+        // XXX: what's the right writing behaviour for a room?
+        // Should write send a message?
+        Ok(None)
+    }
+
+    fn get_completions(&self) -> Option<CompletionList> {
+        delegate!(self, w => w.get_completions())
+    }
+
     fn get_cursor_word(&self, style: &WordStyle) -> Option<String> {
         delegate!(self, w => w.get_cursor_word(style))
     }

src/windows/room/mod.rs

@@ -40,7 +40,9 @@ use modalkit::{
         PositionList,
         ScrollStyle,
         WordStyle,
+        WriteFlags,
     },
+    editing::completion::CompletionList,
     input::InputContext,
     widgets::{TermOffset, TerminalCursor, WindowOps},
 };
@@ -183,8 +185,16 @@ impl RoomState {
         match act {
             RoomAction::InviteAccept => {
                 if let Some(room) = store.application.worker.client.get_invited_room(self.id()) {
+                    let details = room.invite_details().await.map_err(IambError::from)?;
+                    let details = details.invitee.event().original_content();
+                    let is_direct = details.and_then(|ev| ev.is_direct).unwrap_or_default();
+
                     room.accept_invitation().await.map_err(IambError::from)?;
 
+                    if is_direct {
+                        room.set_is_direct(true).await.map_err(IambError::from)?;
+                    }
+
                     Ok(vec![])
                 } else {
                     Err(IambError::NotInvited.into())
@@ -383,10 +393,30 @@ impl WindowOps<IambInfo> for RoomState {
         }
     }
 
-    fn close(&mut self, _: CloseFlags, _: &mut ProgramStore) -> bool {
-        // XXX: what's the right closing behaviour for a room?
-        // Should write send a message?
-        true
+    fn close(&mut self, flags: CloseFlags, store: &mut ProgramStore) -> bool {
+        match self {
+            RoomState::Chat(chat) => chat.close(flags, store),
+            RoomState::Space(space) => space.close(flags, store),
+        }
+    }
+
+    fn write(
+        &mut self,
+        path: Option<&str>,
+        flags: WriteFlags,
+        store: &mut ProgramStore,
+    ) -> IambResult<EditInfo> {
+        match self {
+            RoomState::Chat(chat) => chat.write(path, flags, store),
+            RoomState::Space(space) => space.write(path, flags, store),
+        }
+    }
+
+    fn get_completions(&self) -> Option<CompletionList> {
+        match self {
+            RoomState::Chat(chat) => chat.get_completions(),
+            RoomState::Space(space) => space.get_completions(),
+        }
     }
 
     fn get_cursor_word(&self, style: &WordStyle) -> Option<String> {

src/windows/room/scrollback.rs

@@ -32,6 +32,9 @@ use modalkit::editing::{
     base::{
         Axis,
         CloseFlags,
+        CompletionDisplay,
+        CompletionSelection,
+        CompletionType,
         Count,
         EditRange,
         EditTarget,
@@ -51,7 +54,9 @@ use modalkit::editing::{
         TargetShape,
         ViewportContext,
         WordStyle,
+        WriteFlags,
     },
+    completion::CompletionList,
     context::{EditContext, Resolve},
     cursor::{CursorGroup, CursorState},
     history::HistoryList,
@@ -60,7 +65,7 @@ use modalkit::editing::{
 };
 
 use crate::{
-    base::{IambBufferId, IambInfo, ProgramContext, ProgramStore, RoomFocus, RoomInfo},
+    base::{IambBufferId, IambInfo, IambResult, ProgramContext, ProgramStore, RoomFocus, RoomInfo},
     config::ApplicationSettings,
     message::{Message, MessageCursor, MessageKey, Messages},
 };
@@ -515,6 +520,23 @@ impl WindowOps<IambInfo> for ScrollbackState {
         true
     }
 
+    fn write(
+        &mut self,
+        _: Option<&str>,
+        flags: WriteFlags,
+        _: &mut ProgramStore,
+    ) -> IambResult<EditInfo> {
+        if flags.contains(WriteFlags::FORCE) {
+            Ok(None)
+        } else {
+            Err(EditError::ReadOnly.into())
+        }
+    }
+
+    fn get_completions(&self) -> Option<CompletionList> {
+        None
+    }
+
     fn get_cursor_word(&self, _: &WordStyle) -> Option<String> {
         None
     }
@@ -532,7 +554,7 @@ impl EditorActions<ProgramContext, ProgramStore, IambInfo> for ScrollbackState {
         ctx: &ProgramContext,
         store: &mut ProgramStore,
     ) -> EditResult<EditInfo, IambInfo> {
-        let info = store.application.rooms.entry(self.room_id.clone()).or_default();
+        let info = store.application.rooms.get_or_default(self.room_id.clone());
         let key = if let Some(k) = self.cursor.to_key(info) {
             k.clone()
         } else {
@@ -762,6 +784,17 @@ impl EditorActions<ProgramContext, ProgramStore, IambInfo> for ScrollbackState {
         }
     }
 
+    fn complete(
+        &mut self,
+        _: &CompletionType,
+        _: &CompletionSelection,
+        _: &CompletionDisplay,
+        _: &ProgramContext,
+        _: &mut ProgramStore,
+    ) -> EditResult<EditInfo, IambInfo> {
+        Err(EditError::ReadOnly)
+    }
+
     fn insert_text(
         &mut self,
         _: &InsertTextAction,
@@ -867,9 +900,9 @@ impl Editable<ProgramContext, ProgramStore, IambInfo> for ScrollbackState {
             EditorAction::Mark(name) => self.mark(ctx.resolve(name), ctx, store),
             EditorAction::Selection(act) => self.selection_command(act, ctx, store),
 
-            EditorAction::Complete(_, _) => {
-                let msg = "";
-                let err = EditError::Unimplemented(msg.into());
+            EditorAction::Complete(_, _, _) => {
+                let msg = "Nothing to complete in message scrollback";
+                let err = EditError::Failure(msg.into());
 
                 Err(err)
             },
@@ -991,7 +1024,7 @@ impl ScrollActions<ProgramContext, ProgramStore, IambInfo> for ScrollbackState {
         ctx: &ProgramContext,
         store: &mut ProgramStore,
     ) -> EditResult<EditInfo, IambInfo> {
-        let info = store.application.rooms.entry(self.room_id.clone()).or_default();
+        let info = store.application.rooms.get_or_default(self.room_id.clone());
         let settings = &store.application.settings;
         let mut corner = self.viewctx.corner.clone();
 
@@ -1105,7 +1138,7 @@ impl ScrollActions<ProgramContext, ProgramStore, IambInfo> for ScrollbackState {
                 Err(err)
             },
             Axis::Vertical => {
-                let info = store.application.rooms.entry(self.room_id.clone()).or_default();
+                let info = store.application.rooms.get_or_default(self.room_id.clone());
                 let settings = &store.application.settings;
 
                 if let Some(key) = self.cursor.to_key(info).cloned() {
@@ -1193,7 +1226,7 @@ impl<'a> StatefulWidget for Scrollback<'a> {
     type State = ScrollbackState;
 
     fn render(self, area: Rect, buf: &mut Buffer, state: &mut Self::State) {
-        let info = self.store.application.rooms.entry(state.room_id.clone()).or_default();
+        let info = self.store.application.rooms.get_or_default(state.room_id.clone());
         let settings = &self.store.application.settings;
         let area = info.render_typing(area, buf, &self.store.application.settings);
 

src/windows/welcome.rs

@@ -8,9 +8,11 @@ use modalkit::{
     widgets::{TermOffset, TerminalCursor},
 };
 
-use modalkit::editing::base::{CloseFlags, WordStyle};
+use modalkit::editing::action::EditInfo;
+use modalkit::editing::base::{CloseFlags, WordStyle, WriteFlags};
+use modalkit::editing::completion::CompletionList;
 
-use crate::base::{IambBufferId, IambInfo, ProgramStore};
+use crate::base::{IambBufferId, IambInfo, IambResult, ProgramStore};
 
 const WELCOME_TEXT: &str = include_str!("welcome.md");
 
@@ -63,6 +65,19 @@ impl WindowOps<IambInfo> for WelcomeState {
         self.tbox.close(flags, store)
     }
 
+    fn write(
+        &mut self,
+        path: Option<&str>,
+        flags: WriteFlags,
+        store: &mut ProgramStore,
+    ) -> IambResult<EditInfo> {
+        self.tbox.write(path, flags, store)
+    }
+
+    fn get_completions(&self) -> Option<CompletionList> {
+        self.tbox.get_completions()
+    }
+
     fn get_cursor_word(&self, style: &WordStyle) -> Option<String> {
         self.tbox.get_cursor_word(style)
     }

src/worker.rs

@@ -1,3 +1,4 @@
+use std::collections::HashMap;
 use std::convert::TryFrom;
 use std::fmt::{Debug, Formatter};
 use std::fs::File;
@@ -5,25 +6,27 @@ use std::io::BufWriter;
 use std::str::FromStr;
 use std::sync::mpsc::{sync_channel, Receiver, SyncSender};
 use std::sync::Arc;
-use std::time::Duration;
+use std::time::{Duration, Instant};
 
 use gethostname::gethostname;
 use tokio::sync::mpsc::{unbounded_channel, UnboundedReceiver, UnboundedSender};
 use tokio::task::JoinHandle;
-use tracing::error;
+use tracing::{error, warn};
 
 use matrix_sdk::{
-    config::{RequestConfig, StoreConfig, SyncSettings},
+    config::{RequestConfig, SyncSettings},
     encryption::verification::{SasVerification, Verification},
     event_handler::Ctx,
     reqwest,
     room::{Invited, Messages, MessagesOptions, Room as MatrixRoom, RoomMember},
     ruma::{
         api::client::{
-            room::create_room::v3::{Request as CreateRoomRequest, RoomPreset},
+            filter::{FilterDefinition, LazyLoadOptions, RoomEventFilter, RoomFilter},
+            room::create_room::v3::{CreationContent, Request as CreateRoomRequest, RoomPreset},
             room::Visibility,
             space::get_hierarchy::v1::Request as SpaceHierarchyRequest,
         },
+        assign,
         events::{
             key::verification::{
                 done::{OriginalSyncKeyVerificationDoneEvent, ToDeviceKeyVerificationDoneEvent},
@@ -32,21 +35,31 @@ use matrix_sdk::{
                 start::{OriginalSyncKeyVerificationStartEvent, ToDeviceKeyVerificationStartEvent},
                 VerificationMethod,
             },
+            presence::PresenceEvent,
             reaction::ReactionEventContent,
             room::{
+                encryption::RoomEncryptionEventContent,
                 message::{MessageType, RoomMessageEventContent},
                 name::RoomNameEventContent,
                 redaction::{OriginalSyncRoomRedactionEvent, SyncRoomRedactionEvent},
             },
             tag::Tags,
             typing::SyncTypingEvent,
+            AnyInitialStateEvent,
+            AnyMessageLikeEvent,
             AnyTimelineEvent,
+            EmptyStateKey,
+            InitialStateEvent,
             SyncMessageLikeEvent,
             SyncStateEvent,
         },
+        room::RoomType,
+        serde::Raw,
+        EventEncryptionAlgorithm,
         OwnedRoomId,
         OwnedRoomOrAliasId,
         OwnedUserId,
+        RoomId,
         RoomVersionId,
     },
     Client,
@@ -57,19 +70,211 @@ use matrix_sdk::{
 use modalkit::editing::action::{EditInfo, InfoMessage, UIError};
 
 use crate::{
-    base::{AsyncProgramStore, EventLocation, IambError, IambResult, Receipts, VerifyAction},
+    base::{
+        AsyncProgramStore,
+        ChatStore,
+        CreateRoomFlags,
+        CreateRoomType,
+        EventLocation,
+        IambError,
+        IambResult,
+        Receipts,
+        RoomFetchStatus,
+        VerifyAction,
+    },
     message::MessageFetchResult,
     ApplicationSettings,
 };
 
 const IAMB_DEVICE_NAME: &str = "iamb";
 const IAMB_USER_AGENT: &str = "iamb";
-const REQ_TIMEOUT: Duration = Duration::from_secs(60);
+const MIN_MSG_LOAD: u32 = 50;
 
 fn initial_devname() -> String {
     format!("{} on {}", IAMB_DEVICE_NAME, gethostname().to_string_lossy())
 }
 
+pub async fn create_room(
+    client: &Client,
+    room_alias_name: Option<&str>,
+    rt: CreateRoomType,
+    flags: CreateRoomFlags,
+) -> IambResult<OwnedRoomId> {
+    let mut creation_content = None;
+    let mut initial_state = vec![];
+    let mut is_direct = false;
+    let mut preset = None;
+    let mut invite = vec![];
+
+    let visibility = if flags.contains(CreateRoomFlags::PUBLIC) {
+        Visibility::Public
+    } else {
+        Visibility::Private
+    };
+
+    match rt {
+        CreateRoomType::Direct(user) => {
+            invite.push(user);
+            is_direct = true;
+            preset = Some(RoomPreset::TrustedPrivateChat);
+        },
+        CreateRoomType::Space => {
+            let mut cc = CreationContent::new();
+            cc.room_type = Some(RoomType::Space);
+
+            let raw_cc = Raw::new(&cc).map_err(IambError::from)?;
+            creation_content = Some(raw_cc);
+        },
+        CreateRoomType::Room => {},
+    }
+
+    // Set up encryption.
+    if flags.contains(CreateRoomFlags::ENCRYPTED) {
+        // XXX: Once matrix-sdk uses ruma 0.8, then this can skip the cast.
+        let algo = EventEncryptionAlgorithm::MegolmV1AesSha2;
+        let content = RoomEncryptionEventContent::new(algo);
+        let encr = InitialStateEvent { content, state_key: EmptyStateKey };
+        let encr_raw = Raw::new(&encr).map_err(IambError::from)?;
+        let encr_raw = encr_raw.cast::<AnyInitialStateEvent>();
+        initial_state.push(encr_raw);
+    }
+
+    let request = assign!(CreateRoomRequest::new(), {
+        room_alias_name,
+        creation_content,
+        initial_state: initial_state.as_slice(),
+        invite: invite.as_slice(),
+        is_direct,
+        visibility,
+        preset,
+    });
+
+    let resp = client.create_room(request).await.map_err(IambError::from)?;
+
+    if is_direct {
+        if let Some(room) = client.get_room(&resp.room_id) {
+            room.set_is_direct(true).await.map_err(IambError::from)?;
+        } else {
+            error!(
+                room_id = resp.room_id.as_str(),
+                "Couldn't set is_direct for new direct message room"
+            );
+        }
+    }
+
+    return Ok(resp.room_id);
+}
+
+async fn load_plan(store: &AsyncProgramStore) -> HashMap<OwnedRoomId, Option<String>> {
+    let mut locked = store.lock().await;
+    let ChatStore { need_load, rooms, .. } = &mut locked.application;
+    let mut plan = HashMap::new();
+
+    for room_id in std::mem::take(need_load).into_iter() {
+        let info = rooms.get_or_default(room_id.clone());
+
+        if info.recently_fetched() || info.fetching {
+            need_load.insert(room_id);
+            continue;
+        } else {
+            info.fetch_last = Instant::now().into();
+            info.fetching = true;
+        }
+
+        let fetch_id = match &info.fetch_id {
+            RoomFetchStatus::Done => continue,
+            RoomFetchStatus::HaveMore(fetch_id) => Some(fetch_id.clone()),
+            RoomFetchStatus::NotStarted => None,
+        };
+
+        plan.insert(room_id, fetch_id);
+    }
+
+    return plan;
+}
+
+async fn load_older_one(
+    client: Client,
+    room_id: &RoomId,
+    fetch_id: Option<String>,
+    limit: u32,
+) -> MessageFetchResult {
+    if let Some(room) = client.get_room(room_id) {
+        let mut opts = match &fetch_id {
+            Some(id) => MessagesOptions::backward().from(id.as_str()),
+            None => MessagesOptions::backward(),
+        };
+        opts.limit = limit.into();
+
+        let Messages { end, chunk, .. } = room.messages(opts).await.map_err(IambError::from)?;
+
+        let msgs = chunk.into_iter().filter_map(|ev| {
+            match ev.event.deserialize() {
+                Ok(AnyTimelineEvent::MessageLike(msg)) => Some(msg),
+                Ok(AnyTimelineEvent::State(_)) => None,
+                Err(_) => None,
+            }
+        });
+
+        Ok((end, msgs.collect()))
+    } else {
+        Err(IambError::UnknownRoom(room_id.to_owned()).into())
+    }
+}
+
+async fn load_insert(room_id: OwnedRoomId, res: MessageFetchResult, store: AsyncProgramStore) {
+    let mut locked = store.lock().await;
+    let ChatStore { need_load, presences, rooms, .. } = &mut locked.application;
+    let info = rooms.get_or_default(room_id.clone());
+    info.fetching = false;
+
+    match res {
+        Ok((fetch_id, msgs)) => {
+            for msg in msgs.into_iter() {
+                let sender = msg.sender().to_owned();
+                let _ = presences.get_or_default(sender);
+
+                match msg {
+                    AnyMessageLikeEvent::RoomEncrypted(msg) => {
+                        info.insert_encrypted(msg);
+                    },
+                    AnyMessageLikeEvent::RoomMessage(msg) => {
+                        info.insert(msg);
+                    },
+                    AnyMessageLikeEvent::Reaction(ev) => {
+                        info.insert_reaction(ev);
+                    },
+                    _ => continue,
+                }
+            }
+
+            info.fetch_id = fetch_id.map_or(RoomFetchStatus::Done, RoomFetchStatus::HaveMore);
+        },
+        Err(e) => {
+            warn!(room_id = room_id.as_str(), err = e.to_string(), "Failed to load older messages");
+
+            // Wait and try again.
+            need_load.insert(room_id);
+        },
+    }
+}
+
+async fn load_older(client: &Client, store: &AsyncProgramStore) {
+    let limit = MIN_MSG_LOAD;
+    let plan = load_plan(store).await;
+
+    // Fetch each room separately, so they don't block each other.
+    for (room_id, fetch_id) in plan.into_iter() {
+        let client = client.clone();
+        let store = store.clone();
+
+        tokio::spawn(async move {
+            let res = load_older_one(client, room_id.as_ref(), fetch_id, limit).await;
+            load_insert(room_id, res, store).await;
+        });
+    }
+}
+
 #[derive(Debug)]
 pub enum LoginStyle {
     SessionRestore(Session),
@@ -128,7 +333,6 @@ pub enum WorkerTask {
     ActiveRooms(ClientReply<Vec<FetchedRoom>>),
     DirectMessages(ClientReply<Vec<FetchedRoom>>),
     Init(AsyncProgramStore, ClientReply<()>),
-    LoadOlder(OwnedRoomId, Option<String>, u32, ClientReply<MessageFetchResult>),
     Login(LoginStyle, ClientReply<IambResult<EditInfo>>),
     GetInviter(Invited, ClientReply<IambResult<Option<RoomMember>>>),
     GetRoom(OwnedRoomId, ClientReply<IambResult<FetchedRoom>>),
@@ -158,14 +362,6 @@ impl Debug for WorkerTask {
                     .field(&format_args!("_"))
                     .finish()
             },
-            WorkerTask::LoadOlder(room_id, from, n, _) => {
-                f.debug_tuple("WorkerTask::LoadOlder")
-                    .field(room_id)
-                    .field(from)
-                    .field(n)
-                    .field(&format_args!("_"))
-                    .finish()
-            },
             WorkerTask::Login(style, _) => {
                 f.debug_tuple("WorkerTask::Login")
                     .field(style)
@@ -237,21 +433,6 @@ impl Requester {
         return response.recv();
     }
 
-    pub fn load_older(
-        &self,
-        room_id: OwnedRoomId,
-        fetch_id: Option<String>,
-        limit: u32,
-    ) -> MessageFetchResult {
-        let (reply, response) = oneshot();
-
-        self.tx
-            .send(WorkerTask::LoadOlder(room_id, fetch_id, limit, reply))
-            .unwrap();
-
-        return response.recv();
-    }
-
     pub fn login(&self, style: LoginStyle) -> IambResult<EditInfo> {
         let (reply, response) = oneshot();
 
@@ -349,8 +530,9 @@ pub struct ClientWorker {
     initialized: bool,
     settings: ApplicationSettings,
     client: Client,
-    sync_handle: Option<JoinHandle<()>>,
+    load_handle: Option<JoinHandle<()>>,
     rcpt_handle: Option<JoinHandle<()>>,
+    sync_handle: Option<JoinHandle<()>>,
 }
 
 impl ClientWorker {
@@ -358,28 +540,27 @@ impl ClientWorker {
         let (tx, rx) = unbounded_channel();
         let account = &settings.profile;
 
-        // Set up a custom client that only uses HTTP/1.
-        //
-        // During my testing, I kept stumbling across something weird with sync and HTTP/2 that
-        // will need to be revisited in the future.
+        let req_timeout = Duration::from_secs(settings.tunables.request_timeout);
+
+        // Set up the HTTP client.
         let http = reqwest::Client::builder()
             .user_agent(IAMB_USER_AGENT)
-            .timeout(Duration::from_secs(30))
+            .timeout(req_timeout)
             .pool_idle_timeout(Duration::from_secs(60))
             .pool_max_idle_per_host(10)
             .tcp_keepalive(Duration::from_secs(10))
-            .http1_only()
             .build()
             .unwrap();
 
+        let req_config = RequestConfig::new().timeout(req_timeout).retry_timeout(req_timeout);
+
         // Set up the Matrix client for the selected profile.
         let client = Client::builder()
             .http_client(Arc::new(http))
             .homeserver_url(account.url.clone())
-            .store_config(StoreConfig::default())
             .sled_store(settings.matrix_dir.as_path(), None)
             .expect("Failed to setup up sled store for Matrix SDK")
-            .request_config(RequestConfig::new().timeout(REQ_TIMEOUT).retry_timeout(REQ_TIMEOUT))
+            .request_config(req_config)
             .build()
             .await
             .expect("Failed to instantiate Matrix client");
@@ -388,8 +569,9 @@ impl ClientWorker {
             initialized: false,
             settings,
             client: client.clone(),
-            sync_handle: None,
+            load_handle: None,
             rcpt_handle: None,
+            sync_handle: None,
         };
 
         tokio::spawn(async move {
@@ -447,10 +629,6 @@ impl ClientWorker {
                 assert!(self.initialized);
                 reply.send(self.active_rooms().await);
             },
-            WorkerTask::LoadOlder(room_id, fetch_id, limit, reply) => {
-                assert!(self.initialized);
-                reply.send(self.load_older(room_id, fetch_id, limit).await);
-            },
             WorkerTask::Login(style, reply) => {
                 assert!(self.initialized);
                 reply.send(self.login_and_sync(style).await);
@@ -503,6 +681,15 @@ impl ClientWorker {
             },
         );
 
+        let _ =
+            self.client
+                .add_event_handler(|ev: PresenceEvent, store: Ctx<AsyncProgramStore>| {
+                    async move {
+                        let mut locked = store.lock().await;
+                        locked.application.presences.insert(ev.sender, ev.content.presence);
+                    }
+                });
+
         let _ = self.client.add_event_handler(
             |ev: SyncStateEvent<RoomNameEventContent>,
              room: MatrixRoom,
@@ -513,8 +700,7 @@ impl ClientWorker {
                             let room_id = room.room_id().to_owned();
                             let room_name = Some(room_name.to_string());
                             let mut locked = store.lock().await;
-                            let mut info =
-                                locked.application.rooms.entry(room_id.to_owned()).or_default();
+                            let mut info = locked.application.rooms.get_or_default(room_id.clone());
                             info.name = room_name;
                         }
                     }
@@ -529,8 +715,6 @@ impl ClientWorker {
              store: Ctx<AsyncProgramStore>| {
                 async move {
                     let room_id = room.room_id();
-                    let room_name = room.display_name().await.ok();
-                    let room_name = room_name.as_ref().map(ToString::to_string);
 
                     if let Some(msg) = ev.as_original() {
                         if let MessageType::VerificationRequest(_) = msg.content.msgtype {
@@ -545,8 +729,11 @@ impl ClientWorker {
                     }
 
                     let mut locked = store.lock().await;
-                    let mut info = locked.application.get_room_info(room_id.to_owned());
-                    info.name = room_name;
+
+                    let sender = ev.sender().to_owned();
+                    let _ = locked.application.presences.get_or_default(sender);
+
+                    let info = locked.application.get_room_info(room_id.to_owned());
                     info.insert(ev.into_full_event(room_id.to_owned()));
                 }
             },
@@ -560,6 +747,10 @@ impl ClientWorker {
                     let room_id = room.room_id();
 
                     let mut locked = store.lock().await;
+
+                    let sender = ev.sender().to_owned();
+                    let _ = locked.application.presences.get_or_default(sender);
+
                     let info = locked.application.get_room_info(room_id.to_owned());
                     info.insert_reaction(ev.into_full_event(room_id.to_owned()));
                 }
@@ -583,7 +774,7 @@ impl ClientWorker {
                         Some(EventLocation::Message(key)) => {
                             if let Some(msg) = info.messages.get_mut(key) {
                                 let ev = SyncRoomRedactionEvent::Original(ev);
-                                msg.event.redact(ev, room_version);
+                                msg.redact(ev, room_version);
                             }
                         },
                         Some(EventLocation::Reaction(event_id)) => {
@@ -710,17 +901,34 @@ impl ClientWorker {
             },
         );
 
-        let client = self.client.clone();
+        self.rcpt_handle = tokio::spawn({
+            let store = store.clone();
+            let client = self.client.clone();
 
-        self.rcpt_handle = tokio::spawn(async move {
-            // Update the displayed read receipts ever 5 seconds.
-            let mut interval = tokio::time::interval(Duration::from_secs(5));
+            async move {
+                // Update the displayed read receipts every 5 seconds.
+                let mut interval = tokio::time::interval(Duration::from_secs(5));
 
-            loop {
-                interval.tick().await;
+                loop {
+                    interval.tick().await;
 
-                let receipts = update_receipts(&client).await;
-                store.lock().await.application.set_receipts(receipts).await;
+                    let receipts = update_receipts(&client).await;
+                    store.lock().await.application.set_receipts(receipts).await;
+                }
+            }
+        })
+        .into();
+
+        self.load_handle = tokio::spawn({
+            let client = self.client.clone();
+
+            async move {
+                // Load older messages every 2 seconds.
+                let mut interval = tokio::time::interval(Duration::from_secs(2));
+                loop {
+                    interval.tick().await;
+                    load_older(&client, &store).await;
+                }
             }
         })
         .into();
@@ -759,10 +967,19 @@ impl ClientWorker {
 
         self.sync_handle = Some(handle);
 
-        self.client
-            .sync_once(SyncSettings::default())
-            .await
-            .map_err(IambError::from)?;
+        // Perform an initial, lazily-loaded sync.
+        let mut room = RoomEventFilter::default();
+        room.lazy_load_options = LazyLoadOptions::Enabled { include_redundant_members: false };
+
+        let mut room_ev = RoomFilter::default();
+        room_ev.state = room;
+
+        let mut filter = FilterDefinition::default();
+        filter.room = room_ev;
+
+        let settings = SyncSettings::new().filter(filter.into());
+
+        self.client.sync_once(settings).await.map_err(IambError::from)?;
 
         Ok(Some(InfoMessage::from("Successfully logged in!")))
     }
@@ -774,15 +991,11 @@ impl ClientWorker {
             }
         }
 
-        let mut request = CreateRoomRequest::new();
-        let invite = [user.clone()];
-        request.is_direct = true;
-        request.invite = &invite;
-        request.visibility = Visibility::Private;
-        request.preset = Some(RoomPreset::PrivateChat);
+        let rt = CreateRoomType::Direct(user.clone());
+        let flags = CreateRoomFlags::ENCRYPTED;
 
-        match self.client.create_room(request).await {
-            Ok(resp) => self.get_room(resp.room_id).await,
+        match create_room(&self.client, None, rt, flags).await {
+            Ok(room_id) => self.get_room(room_id).await,
             Err(e) => {
                 error!(
                     user_id = user.as_str(),
@@ -894,35 +1107,6 @@ impl ClientWorker {
         return rooms;
     }
 
-    async fn load_older(
-        &mut self,
-        room_id: OwnedRoomId,
-        fetch_id: Option<String>,
-        limit: u32,
-    ) -> MessageFetchResult {
-        if let Some(room) = self.client.get_room(room_id.as_ref()) {
-            let mut opts = match &fetch_id {
-                Some(id) => MessagesOptions::backward().from(id.as_str()),
-                None => MessagesOptions::backward(),
-            };
-            opts.limit = limit.into();
-
-            let Messages { end, chunk, .. } = room.messages(opts).await.map_err(IambError::from)?;
-
-            let msgs = chunk.into_iter().filter_map(|ev| {
-                match ev.event.deserialize() {
-                    Ok(AnyTimelineEvent::MessageLike(msg)) => Some(msg),
-                    Ok(AnyTimelineEvent::State(_)) => None,
-                    Err(_) => None,
-                }
-            });
-
-            Ok((end, msgs.collect()))
-        } else {
-            Err(IambError::UnknownRoom(room_id).into())
-        }
-    }
-
     async fn members(&mut self, room_id: OwnedRoomId) -> IambResult<Vec<RoomMember>> {
         if let Some(room) = self.client.get_room(room_id.as_ref()) {
             Ok(room.active_members().await.map_err(IambError::from)?)