Many fixes and tweaks

* Fix tags (again?)

* Make tag names more consistent

* Remove prefix commands (not implemented well and not worth fixing)

* Allow '-'s in tags

* Fix /joke

* Fix /members

* Fix intel_hd issue match

* Fix log analysis reply

* Clearer log analysis messages

It's weird to say the process failed when no issues were found.

* Clippy

* Final doc cleanup

* Fix link expanding

* Fix duplicate event filtering

The other code simply does not work. ChannelId does have a method to grab members but I'm not sure whether it would work either.

* Remove message resolution

It's surprisingly hard to create an bug-free implementation.

* Fix pluralkit detection

* simplify tag codegen

* commands: improve error handling in members

unwrap() bad!!!11!!

* events: use debug logs for pk checks

* Revert "Remove message resolution"

This reverts commit 0d9f224a81917212adafdeb2213f3cc11b44cf88.

* Bring back prefix commands with "."

(it's easier to type)

* Add help

* Fix messsage resolution

* utils: factor out message resolution

* Improve tag message

* Disable VC support for message resolution for now

* Improve prefix command usage

Update on edit, display additional tip with wrong usage.

* Check invoke_on_edit to display tip

* Add defer in commands which make http requests

* Apply tag sorting to slash commands too

* handlers::error: `+=` -> `writeln!`

* handlers::event: ignore own new messages

* help: remove unneeded format!

* optimize for size in release builds

* nix: cleanup deployment expressions

* nix: use treefmt

* nix: update flake.lock

Flake lock file updates:

• Updated input 'fenix':
    'github:nix-community/fenix/eb683549b7d76b12d1a009f888b91b70ed34485f' (2024-01-27)
  → 'github:nix-community/fenix/c53bb4a32f2fce7acf4e8e160a54779c4460ffdb' (2024-03-17)
• Updated input 'fenix/rust-analyzer-src':
    'github:rust-lang/rust-analyzer/596e5c77cf5b2b660b3ac2ce732fa0596c246d9b' (2024-01-26)
  → 'github:rust-lang/rust-analyzer/5ecace48f693afaa6adf8cb23086b651db3aec96' (2024-03-16)
• Updated input 'nixpkgs':
    'github:nixos/nixpkgs/4fddc9be4eaf195d631333908f2a454b03628ee5' (2024-01-25)
  → 'github:nixos/nixpkgs/34ad8c9f29a18b4dd97a9ad40ceb16954f24afe7' (2024-03-17)
• Updated input 'pre-commit-hooks':
    'github:cachix/pre-commit-hooks.nix/f56597d53fd174f796b5a7d3ee0b494f9e2285cc' (2024-01-20)
  → 'github:cachix/pre-commit-hooks.nix/5df5a70ad7575f6601d91f0efec95dd9bc619431' (2024-02-15)
• Updated input 'procfile-nix':
    'github:getchoo/procfile-nix/31a33e4264e5c6214844993c5b508fb3500ef5cd' (2024-01-27)
  → 'github:getchoo/procfile-nix/7a0ab379a4ab71c9deccaca9fb463e9aaea363d8' (2024-03-14)

---------

Co-authored-by: seth <getchoo@tuta.io>

src/api/dadjoke.rs

@@ -7,7 +7,10 @@ use reqwest::StatusCode;
 const DADJOKE: &str = "https://icanhazdadjoke.com";
 
 pub async fn get_joke() -> Result<String> {
-	let req = REQWEST_CLIENT.get(DADJOKE).build()?;
+	let req = REQWEST_CLIENT
+		.get(DADJOKE)
+		.header("Accept", "text/plain")
+		.build()?;
 
 	debug!("Making request to {}", req.url());
 	let resp = REQWEST_CLIENT.execute(req).await?;

src/commands/general/help.rs

@@ -0,0 +1,23 @@
+use eyre::Result;
+use poise::{builtins, samples::HelpConfiguration};
+
+use crate::Context;
+
+/// View the help menu
+#[poise::command(slash_command, prefix_command, track_edits = true)]
+pub async fn help(
+	ctx: Context<'_>,
+	#[description = "provide information about a specific command"] command: Option<String>,
+) -> Result<()> {
+	builtins::help(
+		ctx,
+		command.as_deref(),
+		HelpConfiguration {
+			extra_text_at_bottom: "Use /help for more information about a specific command!",
+			..HelpConfiguration::default()
+		},
+	)
+	.await?;
+
+	Ok(())
+}

src/commands/general/joke.rs

@@ -5,11 +5,14 @@ use eyre::Result;
 use log::trace;
 
 /// It's a joke
-#[poise::command(slash_command, prefix_command)]
+#[poise::command(slash_command, prefix_command, track_edits = true)]
 pub async fn joke(ctx: Context<'_>) -> Result<()> {
 	trace!("Running joke command");
+
+	ctx.defer().await?;
+
 	let joke = dadjoke::get_joke().await?;
 
-	ctx.reply(joke).await?;
+	ctx.say(joke).await?;
 	Ok(())
 }

src/commands/general/members.rs

@@ -1,26 +1,34 @@
 use crate::{consts, Context};
 
-use eyre::{OptionExt, Result};
+use eyre::{eyre, Context as _, OptionExt, Result};
 use log::trace;
 use poise::serenity_prelude::CreateEmbed;
 use poise::CreateReply;
 
 /// Returns the number of members in the server
-#[poise::command(slash_command, prefix_command)]
+#[poise::command(slash_command, prefix_command, guild_only = true, track_edits = true)]
 pub async fn members(ctx: Context<'_>) -> Result<()> {
 	trace!("Running members command");
-	let guild = ctx.guild().ok_or_eyre("Couldn't fetch guild!")?.to_owned();
 
-	let count = guild.member_count;
-	let online = if let Some(count) = guild.approximate_presence_count {
-		count.to_string()
-	} else {
-		"Undefined".to_string()
-	};
+	ctx.defer().await?;
+
+	let guild_id = ctx.guild_id().ok_or_eyre("Couldn't get guild ID!")?;
+	let guild = ctx
+		.http()
+		.get_guild_with_counts(guild_id)
+		.await
+		.wrap_err_with(|| format!("Couldn't fetch guild {guild_id} with counts!"))?;
+
+	let member_count = guild
+		.approximate_member_count
+		.ok_or_else(|| eyre!("Couldn't get member count for guild {guild_id}!"))?;
+	let online_count = guild
+		.approximate_presence_count
+		.ok_or_else(|| eyre!("Couldn't get online count for guild {guild_id}!"))?;
 
 	let embed = CreateEmbed::new()
-		.title(format!("{count} total members!"))
-		.description(format!("{online} online members"))
+		.title(format!("{member_count} total members!",))
+		.description(format!("{online_count} online members",))
 		.color(consts::COLORS["blue"]);
 	let reply = CreateReply::default().embed(embed);
 

src/commands/general/mod.rs

@@ -1,3 +1,4 @@
+mod help;
 mod joke;
 mod members;
 mod ping;
@@ -6,6 +7,7 @@ mod say;
 mod stars;
 mod tag;
 
+pub use help::help;
 pub use joke::joke;
 pub use members::members;
 pub use ping::ping;

src/commands/general/ping.rs

@@ -4,9 +4,9 @@ use eyre::Result;
 use log::trace;
 
 /// Replies with pong!
-#[poise::command(slash_command, prefix_command, ephemeral)]
+#[poise::command(slash_command, prefix_command, track_edits = true, ephemeral)]
 pub async fn ping(ctx: Context<'_>) -> Result<()> {
 	trace!("Running ping command!");
-	ctx.reply("Pong!").await?;
+	ctx.say("Pong!").await?;
 	Ok(())
 }

src/commands/general/rory.rs

@@ -7,12 +7,15 @@ use poise::serenity_prelude::{CreateEmbed, CreateEmbedFooter};
 use poise::CreateReply;
 
 /// Gets a Rory photo!
-#[poise::command(slash_command, prefix_command)]
+#[poise::command(slash_command, prefix_command, track_edits = true)]
 pub async fn rory(
 	ctx: Context<'_>,
 	#[description = "specify a Rory ID"] id: Option<u64>,
 ) -> Result<()> {
 	trace!("Running rory command");
+
+	ctx.defer().await?;
+
 	let rory = rory::get(id).await?;
 
 	let embed = {

src/commands/general/say.rs

@@ -9,18 +9,30 @@ use poise::serenity_prelude::{CreateEmbed, CreateEmbedAuthor, CreateMessage};
 	prefix_command,
 	ephemeral,
 	default_member_permissions = "MODERATE_MEMBERS",
-	required_permissions = "MODERATE_MEMBERS"
+	required_permissions = "MODERATE_MEMBERS",
+	guild_only = true
 )]
-pub async fn say(ctx: Context<'_>, #[description = "Just content?"] content: String) -> Result<()> {
+pub async fn say(
+	ctx: Context<'_>,
+	#[description = "the message content"] content: String,
+) -> Result<()> {
 	let guild = ctx.guild().ok_or_eyre("Couldn't get guild!")?.to_owned();
 	let channel = ctx
 		.guild_channel()
 		.await
 		.ok_or_eyre("Couldn't get channel!")?;
 
+	if let Context::Prefix(prefix) = ctx {
+		// ignore error, we might not have perm
+		let _ = prefix.msg.delete(ctx).await;
+	}
+
 	ctx.defer_ephemeral().await?;
 	channel.say(ctx, &content).await?;
-	ctx.say("I said what you said!").await?;
+
+	if let Context::Application(_) = ctx {
+		ctx.say("I said what you said!").await?;
+	}
 
 	if let Some(channel_id) = ctx.data().config.discord.channels().say_log_channel_id() {
 		let log_channel = guild
@@ -29,8 +41,11 @@ pub async fn say(ctx: Context<'_>, #[description = "Just content?"] content: Str
 			.find(|c| c.0 == &channel_id)
 			.ok_or_eyre("Couldn't get log channel from guild!")?;
 
-		let author = CreateEmbedAuthor::new(ctx.author().tag())
-			.icon_url(ctx.author().avatar_url().unwrap_or("Undefined".to_string()));
+		let author = CreateEmbedAuthor::new(ctx.author().tag()).icon_url(
+			ctx.author()
+				.avatar_url()
+				.unwrap_or_else(|| ctx.author().default_avatar_url()),
+		);
 
 		let embed = CreateEmbed::default()
 			.title("Say command used!")

src/commands/general/stars.rs

@@ -6,10 +6,12 @@ use poise::serenity_prelude::CreateEmbed;
 use poise::CreateReply;
 
 /// Returns GitHub stargazer count
-#[poise::command(slash_command, prefix_command)]
+#[poise::command(slash_command, prefix_command, track_edits = true)]
 pub async fn stars(ctx: Context<'_>) -> Result<()> {
 	trace!("Running stars command");
 
+	ctx.defer().await?;
+
 	let prismlauncher = ctx
 		.data()
 		.octocrab

src/commands/general/tag.rs

@@ -13,19 +13,24 @@ include!(concat!(env!("OUT_DIR"), "/generated.rs"));
 static TAGS: Lazy<Vec<Tag>> = Lazy::new(|| serde_json::from_str(env!("TAGS")).unwrap());
 
 /// Send a tag
-#[poise::command(slash_command, prefix_command)]
+#[poise::command(
+	slash_command,
+	prefix_command,
+	track_edits = true,
+	help_text_fn = help
+)]
 pub async fn tag(
 	ctx: Context<'_>,
-	#[description = "the copypasta you want to send"] name: Choice,
-	user: Option<User>,
+	#[description = "the tag to send"] name: Choice,
+	#[description = "a user to mention"] user: Option<User>,
 ) -> Result<()> {
 	trace!("Running tag command");
 
-	let tag_file = name.as_str();
+	let tag_id = name.as_str();
 	let tag = TAGS
 		.iter()
-		.find(|t| t.file_name == tag_file)
-		.ok_or_else(|| eyre!("Tried to get non-existent tag: {tag_file}"))?;
+		.find(|t| t.id == tag_id)
+		.ok_or_else(|| eyre!("Tried to get non-existent tag: {tag_id}"))?;
 
 	let frontmatter = &tag.frontmatter;
 
@@ -49,6 +54,9 @@ pub async fn tag(
 			}
 		}
 
+		e = e.title(&frontmatter.title);
+		e = e.description(&tag.content);
+
 		e
 	};
 
@@ -66,3 +74,13 @@ pub async fn tag(
 
 	Ok(())
 }
+
+fn help() -> String {
+	let tag_list = TAGS
+		.iter()
+		.map(|tag| format!("`{}`", tag.id))
+		.collect::<Vec<String>>()
+		.join(", ");
+
+	format!("Available tags: {tag_list}")
+}

src/commands/mod.rs

@@ -14,5 +14,6 @@ pub fn get() -> Vec<Command<Data, Report>> {
 		general::say(),
 		general::stars(),
 		general::tag(),
+		general::help(),
 	]
 }

src/handlers/error.rs

@@ -1,11 +1,21 @@
 use crate::consts;
 use crate::Data;
+use std::fmt::Write;
 
 use eyre::Report;
 use log::error;
 use poise::serenity_prelude::{CreateEmbed, Timestamp};
 use poise::{CreateReply, FrameworkError};
 
+// getchoo: i like writeln! and don't like
+macro_rules! writelne {
+	($dst:expr, $($arg:tt)*) => {
+		if let Err(why) = writeln!($dst, $($arg)*) {
+			error!("We somehow cannot write to what should be on the heap. What are you using this macro with? Anyways, here's the error:\n{why:#?}");
+		}
+	}
+}
+
 pub async fn handle(error: FrameworkError<'_, Data, Report>) {
 	match error {
 		FrameworkError::Setup {
@@ -44,6 +54,42 @@ pub async fn handle(error: FrameworkError<'_, Data, Report>) {
 			);
 		}
 
+		FrameworkError::ArgumentParse {
+			error, input, ctx, ..
+		} => {
+			let mut response = String::new();
+
+			if let Some(input) = input {
+				writelne!(
+					&mut response,
+					"**Cannot parse `{input}` as argument: {error}**\n"
+				);
+			} else {
+				writelne!(&mut response, "**{error}**\n");
+			}
+
+			if let Some(help_text) = ctx.command().help_text.as_ref() {
+				writelne!(&mut response, "{help_text}\n");
+			}
+
+			if ctx.command().invoke_on_edit {
+				writelne!(
+					&mut response,
+					"**Tip:** Edit your message to update the response."
+				);
+			}
+
+			writelne!(
+				&mut response,
+				"For more information, refer to /help {}.",
+				ctx.command().name
+			);
+
+			if let Err(why) = ctx.say(response).await {
+				error!("Unhandled error displaying ArgumentParse error\n{why:#?}");
+			}
+		}
+
 		error => {
 			if let Err(e) = poise::builtins::on_error(error).await {
 				error!("Unhandled error occurred:\n{e:#?}");

src/handlers/event/analyze_logs/issues.rs

@@ -95,7 +95,7 @@ fn intel_hd(log: &str) -> Issue {
         See https://prismlauncher.org/wiki/getting-started/installing-java/#a-note-about-intel-hd-20003000-on-windows-10 for more info".to_string()
     );
 
-	let found = log.contains("java.lang.NoSuchMethodError: sun.security.util.ManifestEntryVerifier.<init>(Ljava/util/jar/Manifest;)V");
+	let found = log.contains("org.lwjgl.LWJGLException: Pixel format not accelerated");
 	found.then_some(issue)
 }
 
@@ -204,7 +204,7 @@ async fn outdated_launcher(log: &str, data: &Data) -> Result<Issue> {
 
 	if version_from_log < latest_version {
 		let issue = (
-          "Outdated Prism Launcher".to_string(), 
+          "Outdated Prism Launcher".to_string(),
           format!("Your installed version is {version_from_log}, while the newest version is {latest_version}.\nPlease update, for more info see https://prismlauncher.org/download/")
         );
 

src/handlers/event/analyze_logs/mod.rs

@@ -19,7 +19,7 @@ pub async fn handle(ctx: &Context, message: &Message, data: &Data) -> Result<()>
 
 	if log.is_err() {
 		let embed = CreateEmbed::new()
-			.title("Analyze failed!")
+			.title("Analysis failed!")
 			.description("Couldn't download log");
 		let allowed_mentions = CreateAllowedMentions::new().replied_user(true);
 		let our_message = CreateMessage::new()
@@ -43,11 +43,9 @@ pub async fn handle(ctx: &Context, message: &Message, data: &Data) -> Result<()>
 		let mut e = CreateEmbed::new().title("Log analysis");
 
 		if issues.is_empty() {
-			e = e.color(COLORS["green"]).field(
-				"Analyze failed!",
-				"No issues found automatically",
-				false,
-			);
+			e = e
+				.color(COLORS["green"])
+				.description("No issues found automatically");
 		} else {
 			e = e.color(COLORS["red"]);
 
@@ -61,6 +59,7 @@ pub async fn handle(ctx: &Context, message: &Message, data: &Data) -> Result<()>
 
 	let allowed_mentions = CreateAllowedMentions::new().replied_user(true);
 	let message = CreateMessage::new()
+		.reference_message(message)
 		.allowed_mentions(allowed_mentions)
 		.embed(embed);
 

src/handlers/event/expand_link.rs

@@ -4,13 +4,12 @@ use poise::serenity_prelude::{Context, CreateAllowedMentions, CreateMessage, Mes
 use crate::utils;
 
 pub async fn handle(ctx: &Context, message: &Message) -> Result<()> {
-	let embeds = utils::resolve_message(ctx, message).await?;
+	let embeds = utils::resolve_message::from_message(ctx, message).await?;
 
-	// TODO getchoo: actually reply to user
-	// ...not sure why Message doesn't give me a builder in reply() or equivalents
 	if !embeds.is_empty() {
 		let allowed_mentions = CreateAllowedMentions::new().replied_user(false);
 		let reply = CreateMessage::new()
+			.reference_message(message)
 			.embeds(embeds)
 			.allowed_mentions(allowed_mentions);
 

src/handlers/event/mod.rs

@@ -15,7 +15,7 @@ mod support_onboard;
 pub async fn handle(
 	ctx: &Context,
 	event: &FullEvent,
-	framework: FrameworkContext<'_, Data, Report>,
+	_framework: FrameworkContext<'_, Data, Report>,
 	data: &Data,
 ) -> Result<()> {
 	match event {
@@ -31,8 +31,10 @@ pub async fn handle(
 
 		FullEvent::Message { new_message } => {
 			// ignore new messages from bots
-			// NOTE: the webhook_id check allows us to still respond to PK users
-			if new_message.author.bot && new_message.webhook_id.is_none() {
+			// note: the webhook_id check allows us to still respond to PK users
+			if (new_message.author.bot && new_message.webhook_id.is_none())
+				|| new_message.is_own(ctx)
+			{
 				trace!("Ignoring message {} from bot", new_message.id);
 				return Ok(());
 			}
@@ -57,7 +59,7 @@ pub async fn handle(
 		}
 
 		FullEvent::ThreadCreate { thread } => {
-			support_onboard::handle(ctx, thread, framework).await?;
+			support_onboard::handle(ctx, thread).await?;
 		}
 
 		_ => {}

src/handlers/event/pluralkit.rs

@@ -2,18 +2,18 @@ use crate::{api, Data};
 use std::time::Duration;
 
 use eyre::Result;
-use log::trace;
+use log::{debug, trace};
 use poise::serenity_prelude::{Context, Message};
 use tokio::time::sleep;
 
-const PK_DELAY_SEC: Duration = Duration::from_secs(1000);
+const PK_DELAY: Duration = Duration::from_secs(1);
 
 pub async fn is_message_proxied(message: &Message) -> Result<bool> {
 	trace!(
 		"Waiting on PluralKit API for {} seconds",
-		PK_DELAY_SEC.as_secs()
+		PK_DELAY.as_secs()
 	);
-	sleep(PK_DELAY_SEC).await;
+	sleep(PK_DELAY).await;
 
 	let proxied = api::pluralkit::get_sender(message.id).await.is_ok();
 
@@ -21,21 +21,23 @@ pub async fn is_message_proxied(message: &Message) -> Result<bool> {
 }
 
 pub async fn handle(_: &Context, msg: &Message, data: &Data) -> Result<()> {
-	if msg.webhook_id.is_some() {
-		trace!(
-			"Message {} has a webhook ID. Checking if it was sent through PluralKit",
-			msg.id
-		);
+	if msg.webhook_id.is_none() {
+		return Ok(());
+	}
 
-		trace!(
-			"Waiting on PluralKit API for {} seconds",
-			PK_DELAY_SEC.as_secs()
-		);
-		sleep(PK_DELAY_SEC).await;
+	debug!(
+		"Message {} has a webhook ID. Checking if it was sent through PluralKit",
+		msg.id
+	);
 
-		if let Ok(sender) = api::pluralkit::get_sender(msg.id).await {
-			data.storage.store_user_plurality(sender).await?;
-		}
+	trace!(
+		"Waiting on PluralKit API for {} seconds",
+		PK_DELAY.as_secs()
+	);
+	sleep(PK_DELAY).await;
+
+	if let Ok(sender) = api::pluralkit::get_sender(msg.id).await {
+		data.storage.store_user_plurality(sender).await?;
 	}
 
 	Ok(())

src/handlers/event/support_onboard.rs

@@ -1,36 +1,17 @@
-use crate::Data;
-
-use eyre::{eyre, Context as _, OptionExt, Report, Result};
+use eyre::{eyre, OptionExt, Result};
 use log::{debug, trace};
 use poise::serenity_prelude::{
 	ChannelType, Context, CreateAllowedMentions, CreateMessage, GuildChannel,
 };
-use poise::FrameworkContext;
 
-pub async fn handle(
-	ctx: &Context,
-	thread: &GuildChannel,
-	framework: FrameworkContext<'_, Data, Report>,
-) -> Result<()> {
+pub async fn handle(ctx: &Context, thread: &GuildChannel) -> Result<()> {
 	if thread.kind != ChannelType::PublicThread {
 		trace!("Not doing support onboard in non-public thread channel");
 		return Ok(());
 	}
 
-	// TODO @getchoo: it seems like we can get multiple ThreadCreate events
-	// should probably figure out a better way to not repeat ourselves here
-	if thread
-		.members(ctx)
-		.wrap_err_with(|| {
-			format!(
-				"Couldn't fetch members from thread {}! Not sending a support onboard message.",
-				thread.id
-			)
-		})?
-		.iter()
-		.any(|member| member.user.id == framework.bot_id)
-	{
-		debug!("Not sending support onboard message...I think i've been here before :p");
+	if thread.last_message_id.is_some() {
+		debug!("Ignoring duplicate thread creation event");
 		return Ok(());
 	}
 

src/main.rs

@@ -2,8 +2,7 @@
 #![allow(clippy::missing_errors_doc)]
 #![forbid(unsafe_code)]
 
-use std::sync::Arc;
-use std::time::Duration;
+use std::{sync::Arc, time::Duration};
 
 use eyre::{eyre, Context as _, Report, Result};
 use log::{info, trace, warn};
@@ -111,7 +110,7 @@ async fn main() -> Result<()> {
 		},
 
 		prefix_options: PrefixFrameworkOptions {
-			prefix: Some("r".into()),
+			prefix: Some(".".into()),
 			edit_tracker: Some(Arc::from(EditTracker::for_timespan(Duration::from_secs(
 				3600,
 			)))),

src/tags.rs

@@ -15,6 +15,6 @@ pub struct TagFrontmatter {
 #[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct Tag {
 	pub content: String,
-	pub file_name: String,
+	pub id: String,
 	pub frontmatter: TagFrontmatter,
 }

src/utils/mod.rs

@@ -1,3 +1 @@
-mod resolve_message;
-
-pub use resolve_message::resolve as resolve_message;
+pub mod resolve_message;

src/utils/resolve_message.rs

@@ -4,17 +4,14 @@ use eyre::{eyre, Context as _, Result};
 use log::{debug, trace};
 use once_cell::sync::Lazy;
 use poise::serenity_prelude::{
-	ChannelId, ChannelType, Colour, Context, CreateEmbed, CreateEmbedAuthor, CreateEmbedFooter,
-	Message, MessageId,
+	Cache, CacheHttp, ChannelId, ChannelType, Colour, Context, CreateEmbed, CreateEmbedAuthor,
+	CreateEmbedFooter, GuildChannel, Member, Message, MessageId, Permissions,
 };
 use regex::Regex;
 
-static MESSAGE_PATTERN: Lazy<Regex> = Lazy::new(|| {
-	Regex::new(r"/(https?:\/\/)?(?:canary\.|ptb\.)?discord(?:app)?\.com\/channels\/(?<serverId>\d+)\/(?<channelId>\d+)\/(?<messageId>\d+)/g;").unwrap()
-});
-
-fn find_first_image(msg: &Message) -> Option<String> {
-	msg.attachments
+fn find_first_image(message: &Message) -> Option<String> {
+	message
+		.attachments
 		.iter()
 		.find(|a| {
 			a.content_type
@@ -25,86 +22,130 @@ fn find_first_image(msg: &Message) -> Option<String> {
 		.map(|res| res.url.clone())
 }
 
-pub async fn resolve(ctx: &Context, msg: &Message) -> Result<Vec<CreateEmbed>> {
+async fn member_can_view_channel(
+	ctx: impl CacheHttp + AsRef<Cache>,
+	member: &Member,
+	channel: &GuildChannel,
+) -> Result<bool> {
+	static REQUIRED_PERMISSIONS: Lazy<Permissions> =
+		Lazy::new(|| Permissions::VIEW_CHANNEL | Permissions::READ_MESSAGE_HISTORY);
+
+	let guild = ctx.http().get_guild(channel.guild_id).await?;
+
+	let channel_to_check = match &channel.kind {
+		ChannelType::PublicThread => {
+			let parent_id = channel
+				.parent_id
+				.ok_or_else(|| eyre!("Couldn't get parent of thread {}", channel.id))?;
+			parent_id
+				.to_channel(ctx)
+				.await?
+				.guild()
+				.ok_or_else(|| eyre!("Couldn't get GuildChannel from ChannelID {parent_id}!"))?
+		}
+
+		ChannelType::Text | ChannelType::News => channel.to_owned(),
+
+		_ => return Ok(false),
+	};
+
+	let can_view = guild
+		.user_permissions_in(&channel_to_check, member)
+		.contains(*REQUIRED_PERMISSIONS);
+	Ok(can_view)
+}
+
+pub async fn to_embed(
+	ctx: impl CacheHttp + AsRef<Cache>,
+	message: &Message,
+) -> Result<CreateEmbed> {
+	let author = CreateEmbedAuthor::new(message.author.tag()).icon_url(
+		message
+			.author
+			.avatar_url()
+			.unwrap_or_else(|| message.author.default_avatar_url()),
+	);
+
+	let footer = CreateEmbedFooter::new(format!(
+		"#{}",
+		message.channel(ctx).await?.guild().unwrap_or_default().name
+	));
+
+	let mut embed = CreateEmbed::new()
+		.author(author)
+		.color(Colour::BLITZ_BLUE)
+		.timestamp(message.timestamp)
+		.footer(footer)
+		.description(format!(
+			"{}\n\n[Jump to original message]({})",
+			message.content,
+			message.link()
+		));
+
+	if !message.attachments.is_empty() {
+		embed = embed.fields(message.attachments.iter().map(|a| {
+			(
+				"Attachments".to_string(),
+				format!("[{}]({})", a.filename, a.url),
+				false,
+			)
+		}));
+
+		if let Some(image) = find_first_image(message) {
+			embed = embed.image(image);
+		}
+	}
+
+	Ok(embed)
+}
+
+pub async fn from_message(ctx: &Context, msg: &Message) -> Result<Vec<CreateEmbed>> {
+	static MESSAGE_PATTERN: Lazy<Regex> = Lazy::new(|| {
+		Regex::new(r"(?:https?:\/\/)?(?:canary\.|ptb\.)?discord(?:app)?\.com\/channels\/(?<server_id>\d+)\/(?<channel_id>\d+)\/(?<message_id>\d+)").unwrap()
+	});
+
+	let Some(guild_id) = msg.guild_id else {
+		debug!("Not resolving message in DM");
+		return Ok(Vec::new());
+	};
+	let author = guild_id.member(ctx, msg.author.id).await?;
+
 	let matches = MESSAGE_PATTERN
 		.captures_iter(&msg.content)
 		.map(|capture| capture.extract());
 
 	let mut embeds: Vec<CreateEmbed> = vec![];
 
-	for (url, [_server_id, channel_id, message_id]) in matches {
-		trace!("Attempting to resolve message {message_id} from URL {url}");
-
-		let channel = ChannelId::from_str(channel_id)
-			.wrap_err_with(|| format!("Couldn't parse channel ID {channel_id}!"))?
-			.to_channel_cached(ctx.as_ref())
-			.ok_or_else(|| eyre!("Couldn't find Guild Channel from {channel_id}!"))?
-			.to_owned();
-
-		let author_can_view = if channel.kind == ChannelType::PublicThread
-			|| channel.kind == ChannelType::PrivateThread
-		{
-			let thread_members = channel
-				.id
-				.get_thread_members(ctx)
-				.await
-				.wrap_err("Couldn't get members from thread!")?;
-
-			thread_members
-				.iter()
-				.any(|member| member.user_id == msg.author.id)
-		} else {
-			channel
-				.members(ctx)
-				.wrap_err_with(|| format!("Couldn't get members for channel {channel_id}!"))?
-				.iter()
-				.any(|member| member.user.id == msg.author.id)
-		};
-
-		if !author_can_view {
-			debug!("Not resolving message for author who can't see it");
+	for (url, [target_guild_id, target_channel_id, target_message_id]) in matches {
+		if target_guild_id != guild_id.to_string() {
+			debug!("Not resolving message from other server");
+			continue;
 		}
+		trace!("Attempting to resolve message {target_message_id} from URL {url}");
 
-		let original_message = channel
-			.message(
-				ctx,
-				MessageId::from_str(message_id)
-					.wrap_err_with(|| format!("Couldn't parse message ID {message_id}!"))?,
-			)
-			.await
-			.wrap_err_with(|| {
-				format!("Couldn't get message from ID {message_id} in channel {channel_id}!")
+		let target_channel = ChannelId::from_str(target_channel_id)?
+			.to_channel(ctx)
+			.await?
+			.guild()
+			.ok_or_else(|| {
+				eyre!("Couldn't find GuildChannel from ChannelId {target_channel_id}!")
 			})?;
 
-		let author = CreateEmbedAuthor::new(original_message.author.tag())
-			.icon_url(original_message.author.default_avatar_url());
-		let footer = CreateEmbedFooter::new(format!("#{}", channel.name));
-
-		let mut embed = CreateEmbed::new()
-			.author(author)
-			.color(Colour::BLITZ_BLUE)
-			.timestamp(original_message.timestamp)
-			.footer(footer)
-			.description(format!(
-				"{}\n\n[Jump to original message]({})",
-				original_message.content,
-				original_message.link()
-			));
-
-		if !original_message.attachments.is_empty() {
-			embed = embed.fields(original_message.attachments.iter().map(|a| {
-				(
-					"Attachments".to_string(),
-					format!("[{}]({})", a.filename, a.url),
-					false,
-				)
-			}));
-
-			if let Some(image) = find_first_image(msg) {
-				embed = embed.image(image);
-			}
+		if !member_can_view_channel(ctx, &author, &target_channel).await? {
+			debug!("Not resolving message for author who can't see it");
+			continue;
 		}
 
+		let target_message_id = MessageId::from_str(target_message_id)?;
+		let target_message = target_channel
+			.message(ctx, target_message_id)
+			.await
+			.wrap_err_with(|| {
+				eyre!("Couldn't find channel message from ID {target_message_id}!")
+			})?;
+
+		let embed = to_embed(ctx, &target_message).await?;
+
 		embeds.push(embed);
 	}