feat: Add command permissions derive (#604)

Co-authored-by: Andrew Gazelka <andrew.gazelka@gmail.com>

Author: Kumpelinus

Cargo.lock

@@ -1,4 +1,3 @@
-[profile]
 [profile.release-debug]
 debug = true
 inherits = 'release'
@@ -136,6 +135,9 @@ path = 'crates/hyperion'
 [workspace.dependencies.hyperion-clap]
 path = 'crates/hyperion-clap'
 
+[workspace.dependencies.hyperion-clap-macros]
+path = 'crates/hyperion-clap-macros'
+
 [workspace.dependencies.hyperion-command]
 path = 'crates/hyperion-command'
 

Cargo.toml

@@ -0,0 +1 @@
+/target

crates/hyperion-clap-macros/.gitignore

@@ -0,0 +1,19 @@
+cargo-features = ["edition2024"]
+
+[dependencies]
+quote.workspace = true
+syn.workspace = true
+
+[lib]
+proc-macro = true
+
+[lints]
+workspace = true
+
+[package]
+authors = ["Andrew Gazelka <andrew.gazelka@gmail.com>"]
+edition = "2024"
+name = "hyperion-clap-macros"
+publish = false
+readme = "README.md"
+version = "0.1.0"

crates/hyperion-clap-macros/Cargo.toml

@@ -0,0 +1,59 @@
+use proc_macro::TokenStream;
+use quote::quote;
+use syn::{DeriveInput, Error, Ident, Lit, parse_macro_input};
+
+#[proc_macro_derive(CommandPermission, attributes(command_permission))]
+pub fn derive_command_permission(input: TokenStream) -> TokenStream {
+    // Parse the input as a DeriveInput (struct or enum)
+    let input = parse_macro_input!(input as DeriveInput);
+    let name = input.ident.clone(); // Clone the Ident to prevent moving
+
+    // Extract the group from the `#[command_permission(group = "Admin")]` attribute
+    let mut group = None;
+    for attr in &input.attrs {
+        if attr.path().is_ident("command_permission") {
+            if let Err(err) = attr.parse_nested_meta(|meta| {
+                if meta.path.is_ident("group") {
+                    if let Ok(Lit::Str(lit)) = meta.value()?.parse::<Lit>() {
+                        group = Some(lit);
+                    }
+                }
+                Ok(())
+            }) {
+                return Error::new_spanned(attr, format!("Failed to parse attribute: {err}"))
+                    .to_compile_error()
+                    .into();
+            }
+        }
+    }
+
+    let group_ident = match group {
+        Some(g) => Ident::new(&g.value(), g.span()),
+        None => {
+            return Error::new_spanned(
+                input,
+                "Missing required `#[command_permission(group = \"<GroupName>\")]` attribute.",
+            )
+            .to_compile_error()
+            .into();
+        }
+    };
+
+    // Generate the trait implementation
+    let expanded = quote! {
+        impl CommandPermission for #name {
+            fn has_required_permission(&self, user_group: ::hyperion_permission::Group) -> bool {
+                const REQUIRED_GROUP: ::hyperion_permission::Group = ::hyperion_permission::Group::#group_ident;
+
+                if REQUIRED_GROUP == ::hyperion_permission::Group::Banned {
+                    // When checking for the group "Banned" we don't want to check for higher groups.
+                    return REQUIRED_GROUP == user_group;
+                } else {
+                    return user_group as u32 >= REQUIRED_GROUP as u32
+                }
+            }
+        }
+    };
+
+    TokenStream::from(expanded)
+}

crates/hyperion-clap-macros/README.md

@@ -12,7 +12,9 @@ publish = false
 clap ={ workspace = true }
 flecs_ecs = { workspace = true }
 hyperion = { workspace = true }
+hyperion-clap-macros = { workspace = true }
 hyperion-command = { workspace = true }
+hyperion-permission = { workspace = true }
 tracing = { workspace = true }
 valence_protocol = { workspace = true }
 

crates/hyperion-clap-macros/src/lib.rs

@@ -6,13 +6,15 @@ use flecs_ecs::{
     prelude::{Component, Module},
 };
 use hyperion::{
-    net::{Compose, agnostic},
+    net::{Compose, DataBundle, NetworkStreamRef, agnostic},
     simulation::{command::get_root_command_entity, handlers::PacketSwitchQuery},
     storage::{CommandCompletionRequest, EventFn},
     system_registry::SystemId,
 };
+pub use hyperion_clap_macros::CommandPermission;
 pub use hyperion_command;
 use hyperion_command::{CommandHandler, CommandRegistry};
+use hyperion_permission::Group;
 use valence_protocol::{
     VarInt,
     packets::{
@@ -21,7 +23,7 @@ use valence_protocol::{
     },
 };
 
-pub trait MinecraftCommand: Parser {
+pub trait MinecraftCommand: Parser + CommandPermission {
     fn execute(self, world: &World, caller: Entity);
 
     fn register(registry: &mut CommandRegistry, world: &World) {
@@ -51,7 +53,29 @@ pub trait MinecraftCommand: Parser {
             let input = input.split_whitespace();
 
             match Self::try_parse_from(input) {
-                Ok(elem) => elem.execute(world, caller),
+                Ok(elem) => {
+                    if world.get::<&Compose>(|compose| {
+                        caller
+                            .entity_view(world)
+                            .get::<(&NetworkStreamRef, &Group)>(|(stream, group)| {
+                                if elem.has_required_permission(*group) {
+                                    true
+                                } else {
+                                    let chat = agnostic::chat(
+                                        "§cYou do not have permission to use this command!",
+                                    );
+
+                                    let mut bundle = DataBundle::new(compose);
+                                    bundle.add_packet(&chat, world).unwrap();
+                                    bundle.send(world, *stream, SystemId(8)).unwrap();
+
+                                    false
+                                }
+                            })
+                    }) {
+                        elem.execute(world, caller);
+                    }
+                }
                 Err(e) => {
                     // add red if not display help
                     let prefix = match e.kind() {
@@ -225,6 +249,10 @@ impl MinecraftArg for ClapArg {
     }
 }
 
+pub trait CommandPermission {
+    fn has_required_permission(&self, user_group: hyperion_permission::Group) -> bool;
+}
+
 #[derive(Clone, Debug, ValueEnum, PartialEq, Eq)]
 pub enum GameMode {
     Survival,