added matrix support, added matrix-sdk dependency

Cargo.toml

@@ -19,3 +19,6 @@ rand = { version = "0.10.0", features = ["thread_rng"] }
 chrono = { version = "0.4.38" }
 serde = "1.0.214"
 serde_json = "1.0.132"
+matrix-sdk = { version = "0.16.0", features = [
+  "rustls-tls",
+], default-features = false }

LICENSE.md

@@ -0,0 +1,260 @@
+Eclipse Public License - v 2.0
+
+    THE ACCOMPANYING PROGRAM IS PROVIDED UNDER THE TERMS OF THIS ECLIPSE
+    PUBLIC LICENSE ("AGREEMENT"). ANY USE, REPRODUCTION OR DISTRIBUTION
+    OF THE PROGRAM CONSTITUTES RECIPIENT'S ACCEPTANCE OF THIS AGREEMENT.
+
+1. DEFINITIONS
+
+"Contribution" means:
+
+a) in the case of the initial Contributor, the initial content
+Distributed under this Agreement, and
+
+b) in the case of each subsequent Contributor:
+i) changes to the Program, and
+ii) additions to the Program;
+where such changes and/or additions to the Program originate from
+and are Distributed by that particular Contributor. A Contribution
+"originates" from a Contributor if it was added to the Program by
+such Contributor itself or anyone acting on such Contributor's behalf.
+Contributions do not include changes or additions to the Program that
+are not Modified Works.
+
+"Contributor" means any person or entity that Distributes the Program.
+
+"Licensed Patents" mean patent claims licensable by a Contributor which
+are necessarily infringed by the use or sale of its Contribution alone
+or when combined with the Program.
+
+"Program" means the Contributions Distributed in accordance with this
+Agreement.
+
+"Recipient" means anyone who receives the Program under this Agreement
+or any Secondary License (as applicable), including Contributors.
+
+"Derivative Works" shall mean any work, whether in Source Code or other
+form, that is based on (or derived from) the Program and for which the
+editorial revisions, annotations, elaborations, or other modifications
+represent, as a whole, an original work of authorship.
+
+"Modified Works" shall mean any work in Source Code or other form that
+results from an addition to, deletion from, or modification of the
+contents of the Program, including, for purposes of clarity any new file
+in Source Code form that contains any contents of the Program. Modified
+Works shall not include works that contain only declarations,
+interfaces, types, classes, structures, or files of the Program solely
+in each case in order to link to, bind by name, or subclass the Program
+or Modified Works thereof.
+
+"Distribute" means the acts of a) distributing or b) making available
+in any manner that enables the transfer of a copy.
+
+"Source Code" means the form of a Program preferred for making
+modifications, including but not limited to software source code,
+documentation source, and configuration files.
+
+"Secondary License" means either the GNU General Public License,
+Version 2.0, or any later versions of that license, including any
+exceptions or additional permissions as identified by the initial
+Contributor.
+
+2. GRANT OF RIGHTS
+
+a) Subject to the terms of this Agreement, each Contributor hereby
+grants Recipient a non-exclusive, worldwide, royalty-free copyright
+license to reproduce, prepare Derivative Works of, publicly display,
+publicly perform, Distribute and sublicense the Contribution of such
+Contributor, if any, and such Derivative Works.
+
+b) Subject to the terms of this Agreement, each Contributor hereby
+grants Recipient a non-exclusive, worldwide, royalty-free patent
+license under Licensed Patents to make, use, sell, offer to sell,
+import and otherwise transfer the Contribution of such Contributor,
+if any, in Source Code or other form. This patent license shall
+apply to the combination of the Contribution and the Program if, at
+the time the Contribution is added by the Contributor, such addition
+of the Contribution causes such combination to be covered by the
+Licensed Patents. The patent license shall not apply to any other
+combinations which include the Contribution. No hardware per se is
+licensed hereunder.
+
+c) Recipient understands that although each Contributor grants the
+licenses to its Contributions set forth herein, no assurances are
+provided by any Contributor that the Program does not infringe the
+patent or other intellectual property rights of any other entity.
+Each Contributor disclaims any liability to Recipient for claims
+brought by any other entity based on infringement of intellectual
+property rights or otherwise. As a condition to exercising the
+rights and licenses granted hereunder, each Recipient hereby
+assumes sole responsibility to secure any other intellectual
+property rights needed, if any. For example, if a third party
+patent license is required to allow Recipient to Distribute the
+Program, it is Recipient's responsibility to acquire that license
+before distributing the Program.
+
+d) Each Contributor represents that to its knowledge it has
+sufficient copyright rights in its Contribution, if any, to grant
+the copyright license set forth in this Agreement.
+
+e) Notwithstanding the terms of any Secondary License, no
+Contributor makes additional grants to any Recipient (other than
+those set forth in this Agreement) as a result of such Recipient's
+receipt of the Program under the terms of a Secondary License
+(if permitted under the terms of Section 3).
+
+3. REQUIREMENTS
+
+3.1 If a Contributor Distributes the Program in any form, then:
+
+a) the Program must also be made available as Source Code, in
+accordance with section 3.2, and the Contributor must accompany
+the Program with a statement that the Source Code for the Program
+is available under this Agreement, and informs Recipients how to
+obtain it in a reasonable manner on or through a medium customarily
+used for software exchange; and
+
+b) the Contributor may Distribute the Program under a license
+different than this Agreement, provided that such license:
+i) effectively disclaims on behalf of all other Contributors all
+warranties and conditions, express and implied, including
+warranties or conditions of title and non-infringement, and
+implied warranties or conditions of merchantability and fitness
+for a particular purpose;
+
+     ii) effectively excludes on behalf of all other Contributors all
+     liability for damages, including direct, indirect, special,
+     incidental and consequential damages, such as lost profits;
+
+     iii) does not attempt to limit or alter the recipients' rights
+     in the Source Code under section 3.2; and
+
+     iv) requires any subsequent distribution of the Program by any
+     party to be under a license that satisfies the requirements
+     of this section 3.
+
+3.2 When the Program is Distributed as Source Code:
+
+a) it must be made available under this Agreement, or if the
+Program (i) is combined with other material in a separate file or
+files made available under a Secondary License, and (ii) the initial
+Contributor attached to the Source Code the notice described in
+Exhibit A of this Agreement, then the Program may be made available
+under the terms of such Secondary Licenses, and
+
+b) a copy of this Agreement must be included with each copy of
+the Program.
+
+3.3 Contributors may not remove or alter any copyright, patent,
+trademark, attribution notices, disclaimers of warranty, or limitations
+of liability ("notices") contained within the Program from any copy of
+the Program which they Distribute, provided that Contributors may add
+their own appropriate notices.
+
+4. COMMERCIAL DISTRIBUTION
+
+Commercial distributors of software may accept certain responsibilities
+with respect to end users, business partners and the like. While this
+license is intended to facilitate the commercial use of the Program,
+the Contributor who includes the Program in a commercial product
+offering should do so in a manner which does not create potential
+liability for other Contributors. Therefore, if a Contributor includes
+the Program in a commercial product offering, such Contributor
+("Commercial Contributor") hereby agrees to defend and indemnify every
+other Contributor ("Indemnified Contributor") against any losses,
+damages and costs (collectively "Losses") arising from claims, lawsuits
+and other legal actions brought by a third party against the Indemnified
+Contributor to the extent caused by the acts or omissions of such
+Commercial Contributor in connection with its distribution of the Program
+in a commercial product offering. The obligations in this section do not
+apply to any claims or Losses relating to any actual or alleged
+intellectual property infringement. In order to qualify, an Indemnified
+Contributor must: a) promptly notify the Commercial Contributor in
+writing of such claim, and b) allow the Commercial Contributor to control,
+and cooperate with the Commercial Contributor in, the defense and any
+related settlement negotiations. The Indemnified Contributor may
+participate in any such claim at its own expense.
+
+For example, a Contributor might include the Program in a commercial
+product offering, Product X. That Contributor is then a Commercial
+Contributor. If that Commercial Contributor then makes performance
+claims, or offers warranties related to Product X, those performance
+claims and warranties are such Commercial Contributor's responsibility
+alone. Under this section, the Commercial Contributor would have to
+defend claims against the other Contributors related to those performance
+claims and warranties, and if a court requires any other Contributor to
+pay any damages as a result, the Commercial Contributor must pay
+those damages.
+
+5. NO WARRANTY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT
+PERMITTED BY APPLICABLE LAW, THE PROGRAM IS PROVIDED ON AN "AS IS"
+BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR
+IMPLIED INCLUDING, WITHOUT LIMITATION, ANY WARRANTIES OR CONDITIONS OF
+TITLE, NON-INFRINGEMENT, MERCHANTABILITY OR FITNESS FOR A PARTICULAR
+PURPOSE. Each Recipient is solely responsible for determining the
+appropriateness of using and distributing the Program and assumes all
+risks associated with its exercise of rights under this Agreement,
+including but not limited to the risks and costs of program errors,
+compliance with applicable laws, damage to or loss of data, programs
+or equipment, and unavailability or interruption of operations.
+
+6. DISCLAIMER OF LIABILITY
+
+EXCEPT AS EXPRESSLY SET FORTH IN THIS AGREEMENT, AND TO THE EXTENT
+PERMITTED BY APPLICABLE LAW, NEITHER RECIPIENT NOR ANY CONTRIBUTORS
+SHALL HAVE ANY LIABILITY FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING WITHOUT LIMITATION LOST
+PROFITS), HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OR DISTRIBUTION OF THE PROGRAM OR THE
+EXERCISE OF ANY RIGHTS GRANTED HEREUNDER, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+7. GENERAL
+
+If any provision of this Agreement is invalid or unenforceable under
+applicable law, it shall not affect the validity or enforceability of
+the remainder of the terms of this Agreement, and without further
+action by the parties hereto, such provision shall be reformed to the
+minimum extent necessary to make such provision valid and enforceable.
+
+If Recipient institutes patent litigation against any entity
+(including a cross-claim or counterclaim in a lawsuit) alleging that the
+Program itself (excluding combinations of the Program with other software
+or hardware) infringes such Recipient's patent(s), then such Recipient's
+rights granted under Section 2(b) shall terminate as of the date such
+litigation is filed.
+
+All Recipient's rights under this Agreement shall terminate if it
+fails to comply with any of the material terms or conditions of this
+Agreement and does not cure such failure in a reasonable period of
+time after becoming aware of such noncompliance. If all Recipient's
+rights under this Agreement terminate, Recipient agrees to cease use
+and distribution of the Program as soon as reasonably practicable.
+However, Recipient's obligations under this Agreement and any licenses
+granted by Recipient relating to the Program shall continue and survive.
+
+Everyone is permitted to copy and distribute copies of this Agreement,
+but in order to avoid inconsistency the Agreement is copyrighted and
+may only be modified in the following manner. The Agreement Steward
+reserves the right to publish new versions (including revisions) of
+this Agreement from time to time. No one other than the Agreement
+Steward has the right to modify this Agreement. The Eclipse Foundation
+is the initial Agreement Steward. The Eclipse Foundation may assign the
+responsibility to serve as the Agreement Steward to a suitable separate
+entity. Each new version of the Agreement will be given a distinguishing
+version number. The Program (including Contributions) may always be
+Distributed subject to the version of the Agreement under which it was
+received. In addition, after a new version of the Agreement is published,
+Contributor may elect to Distribute the Program (including its
+Contributions) under the new version.
+
+Except as expressly stated in Sections 2(a) and 2(b) above, Recipient
+receives no rights or licenses to the intellectual property of any
+Contributor under this Agreement, whether expressly, by implication,
+estoppel or otherwise. All rights in the Program not expressly granted
+under this Agreement are reserved. Nothing in this Agreement is intended
+to be enforceable by any entity that is not a Contributor or Recipient.
+No third-party beneficiary rights are created under this Agreement.

README.md

@@ -2,13 +2,49 @@
 
 ![actions](https://scm.wyattjmiller.com/wymiller/CaitSith/actions/workflows/build.yml/badge.svg?branch=master)
 
-Copyright 2025, all rights reserved
+Designed and developed by Wyatt J. Miller
+
+Copyright 2025-2026, all rights reserved
+
+Licensed by the Eclipse Public License 2.0 (EPL-2.0). See [LICENSE.md](./LICENSE.md) for the full text.
+
+## Description
+
+This bot gives a user the ability to "deathroll" or roll random dice (e.g. D20). This bot can either run on Discord or Matrix.
+
+## Building
+
+Requirements:
+
+- Rust (built on 1.93, 2024 edition)
+- pkg-config (most Linux distributions have this already by default)
+
+Run the following command to get a binary:
+
+```bash
+cargo build --release
+```
+
+If you are running `nix` or NixOS, you should probably run the provided `flake.nix`. The build's result will be the bot itself.
+
+Running the binary by itself won't do anything. In fact, the bot will just quit if you don't have the needed information. You will need to have the following:
+
+- A Discord token - `DISCORD_TOKEN`
+- A guild ID - `GUILD_ID`
+
+_OR_
+
+- A Matrix homeserver (or admin access to one) - `MATRIX_HOMESERVER`
+- A Matrix username - `MATRIX_USERNAME`
+- A Matrix password - `MATRIX_PASSWORD`
+
+Those will be environment variables. Configure them based on how you're deploying the bot—whether that's in your .bashrc, docker-compose.yml, systemd service file, etc. They need to be defined _somewhere_ in your environment.
 
 ## Hacking
 
 Requirements:
 
-- Rust (built on 1.86, 2021 edition)
+- Rust (built on 1.93, 2024 edition)
 - git
 - pkg-config
 - openssl-devel

docker-compose.yml

@@ -10,6 +10,11 @@ services:
       ## Fill these in when you deploy
       # GUILD_ID:
       # DISCORD_TOKEN:
+      #
+      # OR FILL THESE IN INSTEAD
+      # MATRIX_HOMESERVER:
+      # MATRIX_USERNAME:
+      # MATRIX_PASSWORD:
     expose:
       - 80
 

src/commands/about.rs

@@ -1,12 +1,12 @@
 use serenity::builder::CreateCommand;
 use serenity::model::application::ResolvedOption;
 
-pub async fn run(options: &[ResolvedOption<'_>]) -> String {
-    r#"
-    A Discord bot that rolls limitless dice, randomly!
-    Copyright 2025, all rights reserved
-    "#
-    .to_string()
+pub fn run_core() -> String {
+    "A bot that rolls limitless dice, randomly!\nCopyright 2025, all rights reserved".to_string()
+}
+
+pub async fn run(_options: &[ResolvedOption<'_>]) -> String {
+    run_core()
 }
 
 pub fn register() -> CreateCommand {

src/commands/random.rs

@@ -3,24 +3,27 @@ use crate::util::{junk, random::RandomGen, validate};
 use serenity::builder::{CreateCommand, CreateCommandOption};
 use serenity::model::application::{CommandOptionType, ResolvedOption, ResolvedValue};
 
-pub async fn run(options: &[ResolvedOption<'_>]) -> String {
-    // check if options array is empty first
-    if options.is_empty() {
+pub fn run_core(input: Option<&str>) -> String {
     let mut rng = RandomGen::new();
-        return rng.range_random_from_one(999).to_string();
+    match input {
+        None => rng.range_random_from_one(999).to_string(),
+        Some(s) => match validate::parse_str_into_num::<i32>(s.trim()) {
+            Some(n) => rng.range_random_from_one(n).to_string(),
+            None => junk::get_random_insult(),
+        },
     }
+}
 
-    // options exist, process first option
+pub async fn run(options: &[ResolvedOption<'_>]) -> String {
+    if options.is_empty() {
+        return run_core(None);
+    }
     if let Some(ResolvedOption {
         value: ResolvedValue::String(input),
         ..
     }) = options.first()
     {
-        let mut rng = RandomGen::new();
-        return match validate::parse_str_into_num::<i32>(input.trim()) {
-            Some(n) => rng.range_random_from_one(n).to_string(),
-            None => return junk::get_random_insult(),
-        };
+        run_core(Some(input))
     } else {
         junk::get_random_insult()
     }

src/commands/roll.rs

@@ -6,25 +6,33 @@ use crate::{
 use serenity::builder::{CreateCommand, CreateCommandOption};
 use serenity::model::application::{CommandOptionType, ResolvedOption, ResolvedValue};
 
+pub fn run_core(input: Option<&str>) -> String {
+    let Some(input) = input else {
+        return junk::get_random_insult();
+    };
+    let split = match input.split('d').nth(1) {
+        Some(s) => s,
+        None => return junk::get_random_insult(),
+    };
+    let die_num = match validate::parse_str_into_num::<i32>(split.trim()) {
+        Some(d) => d,
+        None => return junk::get_random_insult(),
+    };
+    match dietype::DieType::from_sides(die_num) {
+        Some(_) => {}
+        None => return junk::get_random_insult(),
+    };
+    let mut rng = random::RandomGen::new();
+    rng.range_random_from_one(die_num).to_string()
+}
+
 pub async fn run(options: &[ResolvedOption<'_>]) -> String {
     if let Some(ResolvedOption {
         value: ResolvedValue::String(input),
         ..
     }) = options.first()
     {
-        let split = input.split("d").nth(1).unwrap();
-        let die_num = match validate::parse_str_into_num::<i32>(split.trim()) {
-            Some(d) => d,
-            None => return junk::get_random_insult(),
-        };
-
-        let _die_type = match dietype::DieType::from_sides(die_num) {
-            Some(d) => d.to_sides(),
-            None => return junk::get_random_insult(),
-        };
-        let mut rng = random::RandomGen::new();
-        let result = rng.range_random_from_one(die_num).to_string();
-        return format!("{result}");
+        run_core(Some(input))
     } else {
         junk::get_random_insult()
     }

src/discord.rs

@@ -0,0 +1,76 @@
+use std::env;
+
+use serenity::async_trait;
+use serenity::builder::{CreateInteractionResponse, CreateInteractionResponseMessage};
+use serenity::model::application::Interaction;
+use serenity::model::gateway::Ready;
+use serenity::model::id::GuildId;
+use serenity::prelude::*;
+
+use crate::commands;
+
+struct Handler;
+
+#[async_trait]
+impl EventHandler for Handler {
+    async fn interaction_create(&self, ctx: Context, interaction: Interaction) {
+        if let Interaction::Command(command) = interaction {
+            let content = match command.data.name.as_str() {
+                "roll" => Some(commands::roll::run(&command.data.options()).await),
+                "random" => Some(commands::random::run(&command.data.options()).await),
+                "about" => Some(commands::about::run(&command.data.options()).await),
+                _ => Some("not implemented".to_string()),
+            };
+
+            if let Some(content) = content {
+                let data = CreateInteractionResponseMessage::new().content(content);
+                let builder = CreateInteractionResponse::Message(data);
+                if let Err(why) = command.create_response(&ctx.http, builder).await {
+                    println!("Cannot respond to slash command: {why}");
+                }
+            }
+        }
+    }
+
+    async fn ready(&self, ctx: Context, ready: Ready) {
+        println!("{} is connected!", ready.user.name);
+
+        let guild_id = GuildId::new(
+            env::var("GUILD_ID")
+                .expect("Expected GUILD_ID in environment")
+                .parse()
+                .expect("GUILD_ID must be an integer"),
+        );
+
+        let cmds = guild_id
+            .set_commands(
+                &ctx.http,
+                vec![
+                    commands::roll::register(),
+                    commands::random::register(),
+                    commands::about::register(),
+                ],
+            )
+            .await;
+
+        match cmds {
+            Ok(c) => println!("Registered {} commands!", c.len()),
+            Err(e) => println!("Error registering commands! Reason: {e}"),
+        }
+
+        println!("{} is ready to rock and roll!", ready.user.name);
+    }
+}
+
+pub async fn run() {
+    let token = env::var("DISCORD_TOKEN").expect("Expected DISCORD_TOKEN in environment");
+    let intents = GatewayIntents::MESSAGE_CONTENT | GatewayIntents::GUILD_MESSAGES;
+    let mut client = Client::builder(token, intents)
+        .event_handler(Handler)
+        .await
+        .expect("Error creating Discord client");
+
+    if let Err(why) = client.start().await {
+        println!("Discord client error: {why:?}");
+    }
+}

src/main.rs

@@ -1,86 +1,38 @@
 mod commands;
 mod config;
+mod discord;
+mod matrix;
 mod types;
 mod util;
 
 use std::env;
 
-use serenity::async_trait;
-use serenity::builder::{CreateInteractionResponse, CreateInteractionResponseMessage};
-use serenity::model::application::Interaction;
-use serenity::model::gateway::Ready;
-use serenity::model::id::GuildId;
-use serenity::prelude::*;
-
-struct Handler;
-
-#[async_trait]
-impl EventHandler for Handler {
-    async fn interaction_create(&self, ctx: Context, interaction: Interaction) {
-        if let Interaction::Command(command) = interaction {
-            let content = match command.data.name.as_str() {
-                "roll" => Some(commands::roll::run(&command.data.options()).await),
-                "random" => Some(commands::random::run(&command.data.options()).await),
-                "about" => Some(commands::about::run(&command.data.options()).await),
-                _ => Some("not implemented :(".to_string()),
-            };
-
-            if let Some(content) = content {
-                let data = CreateInteractionResponseMessage::new().content(content);
-                let builder = CreateInteractionResponse::Message(data);
-                if let Err(why) = command.create_response(&ctx.http, builder).await {
-                    println!("Cannot respond to slash command: {why}");
-                }
-            }
-        }
-    }
-
-    async fn ready(&self, ctx: Context, ready: Ready) {
-        println!("{} is connected!", ready.user.name);
-
-        let guild_id = GuildId::new(
-            env::var("GUILD_ID")
-                .expect("Expected GUILD_ID in environment")
-                .parse()
-                .expect("GUILD_ID must be an integer"),
-        );
-
-        let commands = guild_id
-            .set_commands(
-                &ctx.http,
-                vec![
-                    commands::roll::register(),
-                    commands::random::register(),
-                    commands::about::register(),
-                ],
-            )
-            .await;
-
-        match commands {
-            Ok(c) => println!("Registered {} commands!", c.len()),
-            Err(e) => println!("Error registering commands! Reason: {e}"),
-        }
-
-        println!("{} is ready to rock and roll!", ready.user.name);
-    }
-}
-
 #[tokio::main]
 async fn main() {
-    // setting up configuration
     let _ = config::config();
 
-    // setting up the discord bot
-    let token = env::var("DISCORD_TOKEN").expect("Expected a token in the environment");
+    let has_discord = env::var("DISCORD_TOKEN").is_ok();
+    let has_matrix = env::var("MATRIX_HOMESERVER").is_ok()
+        && env::var("MATRIX_USERNAME").is_ok()
+        && env::var("MATRIX_PASSWORD").is_ok();
 
-    // setting up the discord client
-    let intents = GatewayIntents::MESSAGE_CONTENT | GatewayIntents::GUILD_MESSAGES;
-    let mut client = Client::builder(token, intents)
-        .event_handler(Handler)
-        .await
-        .expect("Error creating client");
-
-    if let Err(why) = client.start().await {
-        println!("Client error: {why:?}");
+    match (has_discord, has_matrix) {
+        (true, true) => {
+            println!("Both Discord and Matrix credentials found; defaulting to Discord.");
+            discord::run().await;
+        }
+        (true, false) => {
+            discord::run().await;
+        }
+        (false, true) => {
+            matrix::run().await;
+        }
+        (false, false) => {
+            eprintln!(
+                "No credentials found. Set DISCORD_TOKEN or \
+                 MATRIX_HOMESERVER + MATRIX_USERNAME + MATRIX_PASSWORD."
+            );
+            std::process::exit(1);
+        }
     }
 }

src/matrix.rs

@@ -0,0 +1,114 @@
+use std::env;
+
+use matrix_sdk::{
+    Client, Room, RoomState,
+    config::SyncSettings,
+    ruma::events::room::{
+        member::{MembershipState, StrippedRoomMemberEvent},
+        message::{
+            AddMentions, ForwardThread, MessageType, OriginalSyncRoomMessageEvent,
+            RoomMessageEventContent,
+        },
+    },
+};
+
+use crate::commands;
+
+async fn on_room_message(event: OriginalSyncRoomMessageEvent, room: Room) {
+    if room.state() != RoomState::Joined {
+        return;
+    }
+
+    let MessageType::Text(text_content) = event.content.msgtype.to_owned() else {
+        return;
+    };
+
+    let body = text_content.body.trim();
+    if !body.starts_with('!') {
+        return;
+    }
+
+    let mut parts = body.splitn(3, ' ');
+    let command = parts.next().unwrap_or("");
+    let arg = parts.next();
+
+    let response = match command {
+        "!roll" => commands::roll::run_core(arg),
+        "!random" => commands::random::run_core(arg),
+        "!about" => commands::about::run_core(),
+        _ => return,
+    };
+
+    let reply = RoomMessageEventContent::text_plain(response).make_reply_to(
+        &event.into_full_event(room.room_id().to_owned()),
+        ForwardThread::No,
+        AddMentions::Yes,
+    );
+
+    match room.send(reply).await {
+        Ok(_) => (),
+        Err(e) => {
+            println!("Failed to send message: {e}");
+        }
+    }
+}
+
+async fn on_stripped_member(event: StrippedRoomMemberEvent, client: Client, room: Room) {
+    let user_id = match client.user_id() {
+        Some(u) => u,
+        None => {
+            println!("Irregular Matrix ID");
+            return;
+        }
+    };
+
+    if event.state_key != user_id {
+        return;
+    }
+
+    if event.content.membership != MembershipState::Invite {
+        return;
+    }
+
+    if let Err(e) = room.join().await {
+        println!("Failed to join room: {e}");
+    }
+}
+
+pub async fn run() {
+    let homeserver =
+        env::var("MATRIX_HOMESERVER").expect("Expected MATRIX_HOMESERVER in environment");
+    let username = env::var("MATRIX_USERNAME").expect("Expected MATRIX_USERNAME in environment");
+    let password = env::var("MATRIX_PASSWORD").expect("Expected MATRIX_PASSWORD in environment");
+
+    let client = Client::builder()
+        .homeserver_url(&homeserver)
+        .build()
+        .await
+        .expect("Failed to build Matrix client");
+
+    client
+        .matrix_auth()
+        .login_username(&username, &password)
+        .initial_device_display_name("caitsith")
+        .send()
+        .await
+        .expect("Failed to log in to Matrix");
+
+    println!("Logged in to Matrix as {username}");
+
+    // Advance past existing messages before registering handlers so the bot
+    // doesn't reply to messages that ever existed in a given room.
+    let sync_response = client
+        .sync_once(SyncSettings::default())
+        .await
+        .expect("Matrix initial sync error");
+
+    client.add_event_handler(on_room_message);
+    client.add_event_handler(on_stripped_member);
+
+    client
+        .sync(SyncSettings::default().token(sync_response.next_batch))
+        .await
+        .expect("Matrix sync error");
+}