fix: command permission handling

pumpkin/src/command/client_cmd_suggestions.rs

@@ -20,6 +20,14 @@ pub async fn send_c_commands_packet(player: &Arc<Player>, dispatcher: &RwLock<Co
             continue;
         };
 
+        let Some(permission) = dispatcher.get_permission_lvl(key) else {
+            continue;
+        };
+
+        if !cmd_src.has_permission_lvl(permission) {
+            continue;
+        }
+
         let (is_executable, child_nodes) =
             nodes_to_proto_node_builders(&cmd_src, &tree.nodes, &tree.children);
 

pumpkin/src/command/commands/cmd_fill.rs

@@ -2,13 +2,12 @@ use crate::command::args::arg_block::BlockArgumentConsumer;
 use crate::command::args::arg_position_block::BlockPosArgumentConsumer;
 use crate::command::args::{ConsumedArgs, FindArg};
 use crate::command::tree::CommandTree;
-use crate::command::tree_builder::{argument, literal, require};
+use crate::command::tree_builder::{argument, literal};
 use crate::command::{CommandError, CommandExecutor, CommandSender};
 
 use async_trait::async_trait;
 use pumpkin_core::math::position::WorldPosition;
 use pumpkin_core::math::vector3::Vector3;
-use pumpkin_core::permission::PermissionLvl;
 use pumpkin_core::text::TextComponent;
 
 const NAMES: [&str; 1] = ["fill"];
@@ -157,19 +156,16 @@ impl CommandExecutor for SetblockExecutor {
 
 pub fn init_command_tree() -> CommandTree {
     CommandTree::new(NAMES, DESCRIPTION).with_child(
-        require(|sender| sender.has_permission_lvl(PermissionLvl::Two) && sender.world().is_some())
-            .with_child(
-                argument(ARG_FROM, BlockPosArgumentConsumer).with_child(
-                    argument(ARG_TO, BlockPosArgumentConsumer).with_child(
-                        argument(ARG_BLOCK, BlockArgumentConsumer)
-                            .with_child(literal("destroy").execute(SetblockExecutor(Mode::Destroy)))
-                            .with_child(literal("hollow").execute(SetblockExecutor(Mode::Hollow)))
-                            .with_child(literal("keep").execute(SetblockExecutor(Mode::Keep)))
-                            .with_child(literal("outline").execute(SetblockExecutor(Mode::Outline)))
-                            .with_child(literal("replace").execute(SetblockExecutor(Mode::Replace)))
-                            .execute(SetblockExecutor(Mode::Replace)),
-                    ),
-                ),
+        argument(ARG_FROM, BlockPosArgumentConsumer).with_child(
+            argument(ARG_TO, BlockPosArgumentConsumer).with_child(
+                argument(ARG_BLOCK, BlockArgumentConsumer)
+                    .with_child(literal("destroy").execute(SetblockExecutor(Mode::Destroy)))
+                    .with_child(literal("hollow").execute(SetblockExecutor(Mode::Hollow)))
+                    .with_child(literal("keep").execute(SetblockExecutor(Mode::Keep)))
+                    .with_child(literal("outline").execute(SetblockExecutor(Mode::Outline)))
+                    .with_child(literal("replace").execute(SetblockExecutor(Mode::Replace)))
+                    .execute(SetblockExecutor(Mode::Replace)),
             ),
+        ),
     )
 }

pumpkin/src/command/commands/cmd_gamemode.rs

@@ -4,7 +4,6 @@ use crate::command::args::arg_gamemode::GamemodeArgumentConsumer;
 use crate::command::args::GetCloned;
 
 use crate::TextComponent;
-use pumpkin_core::permission::PermissionLvl;
 
 use crate::command::args::arg_players::PlayersArgumentConsumer;
 
@@ -109,12 +108,10 @@ impl CommandExecutor for GamemodeTargetPlayer {
 #[allow(clippy::redundant_closure_for_method_calls)]
 pub fn init_command_tree() -> CommandTree {
     CommandTree::new(NAMES, DESCRIPTION).with_child(
-        require(|sender| sender.has_permission_lvl(PermissionLvl::Two)).with_child(
-            argument(ARG_GAMEMODE, GamemodeArgumentConsumer)
-                .with_child(require(|sender| sender.is_player()).execute(GamemodeTargetSelf))
-                .with_child(
-                    argument(ARG_TARGET, PlayersArgumentConsumer).execute(GamemodeTargetPlayer),
-                ),
-        ),
+        argument(ARG_GAMEMODE, GamemodeArgumentConsumer)
+            .with_child(require(|sender| sender.is_player()).execute(GamemodeTargetSelf))
+            .with_child(
+                argument(ARG_TARGET, PlayersArgumentConsumer).execute(GamemodeTargetPlayer),
+            ),
     )
 }

pumpkin/src/command/commands/cmd_give.rs

@@ -7,9 +7,8 @@ use crate::command::args::arg_item::ItemArgumentConsumer;
 use crate::command::args::arg_players::PlayersArgumentConsumer;
 use crate::command::args::{ConsumedArgs, FindArg, FindArgDefaultName};
 use crate::command::tree::CommandTree;
-use crate::command::tree_builder::{argument, argument_default_name, require};
+use crate::command::tree_builder::{argument, argument_default_name};
 use crate::command::{CommandError, CommandExecutor, CommandSender};
-use pumpkin_core::permission::PermissionLvl;
 
 const NAMES: [&str; 1] = ["give"];
 
@@ -76,12 +75,10 @@ impl CommandExecutor for GiveExecutor {
 
 pub fn init_command_tree() -> CommandTree {
     CommandTree::new(NAMES, DESCRIPTION).with_child(
-        require(|sender| sender.has_permission_lvl(PermissionLvl::Two)).with_child(
-            argument_default_name(PlayersArgumentConsumer).with_child(
-                argument(ARG_ITEM, ItemArgumentConsumer)
-                    .execute(GiveExecutor)
-                    .with_child(argument_default_name(item_count_consumer()).execute(GiveExecutor)),
-            ),
+        argument_default_name(PlayersArgumentConsumer).with_child(
+            argument(ARG_ITEM, ItemArgumentConsumer)
+                .execute(GiveExecutor)
+                .with_child(argument_default_name(item_count_consumer()).execute(GiveExecutor)),
         ),
     )
 }

pumpkin/src/command/commands/cmd_op.rs

@@ -2,14 +2,13 @@ use crate::{
     command::{
         args::{arg_players::PlayersArgumentConsumer, Arg, ConsumedArgs},
         tree::CommandTree,
-        tree_builder::{argument, require},
+        tree_builder::argument,
         CommandError, CommandExecutor, CommandSender,
     },
     data::{op_data::OPERATOR_CONFIG, SaveJSONConfiguration},
 };
 use async_trait::async_trait;
 use pumpkin_config::{op::Op, BASIC_CONFIG};
-use pumpkin_core::permission::PermissionLvl;
 use pumpkin_core::text::TextComponent;
 use CommandError::InvalidConsumption;
 
@@ -73,8 +72,6 @@ impl CommandExecutor for OpExecutor {
 }
 
 pub fn init_command_tree() -> CommandTree {
-    CommandTree::new(NAMES, DESCRIPTION).with_child(
-        require(|sender| sender.has_permission_lvl(PermissionLvl::Three))
-            .with_child(argument(ARG_TARGET, PlayersArgumentConsumer).execute(OpExecutor)),
-    )
+    CommandTree::new(NAMES, DESCRIPTION)
+        .with_child(argument(ARG_TARGET, PlayersArgumentConsumer).execute(OpExecutor))
 }

pumpkin/src/command/commands/cmd_say.rs

@@ -5,10 +5,9 @@ use pumpkin_protocol::client::play::CSystemChatMessage;
 use crate::command::{
     args::{arg_message::MsgArgConsumer, Arg, ConsumedArgs},
     tree::CommandTree,
-    tree_builder::{argument, require},
+    tree_builder::argument,
     CommandError, CommandExecutor, CommandSender,
 };
-use pumpkin_core::permission::PermissionLvl;
 use CommandError::InvalidConsumption;
 
 const NAMES: [&str; 1] = ["say"];
@@ -42,8 +41,6 @@ impl CommandExecutor for SayExecutor {
 }
 
 pub fn init_command_tree() -> CommandTree {
-    CommandTree::new(NAMES, DESCRIPTION).with_child(
-        require(|sender| sender.has_permission_lvl(PermissionLvl::Two))
-            .with_child(argument(ARG_MESSAGE, MsgArgConsumer).execute(SayExecutor)),
-    )
+    CommandTree::new(NAMES, DESCRIPTION)
+        .with_child(argument(ARG_MESSAGE, MsgArgConsumer).execute(SayExecutor))
 }

pumpkin/src/command/commands/cmd_seed.rs

@@ -1,9 +1,7 @@
-use crate::command::tree_builder::require;
 use crate::command::{
     args::ConsumedArgs, tree::CommandTree, CommandError, CommandExecutor, CommandSender,
 };
 use async_trait::async_trait;
-use pumpkin_core::permission::PermissionLvl;
 use pumpkin_core::text::click::ClickEvent;
 use pumpkin_core::text::hover::HoverEvent;
 use pumpkin_core::text::{color::NamedColor, TextComponent};
@@ -55,9 +53,5 @@ impl CommandExecutor for PumpkinExecutor {
 }
 
 pub fn init_command_tree() -> CommandTree {
-    CommandTree::new(NAMES, DESCRIPTION)
-        .with_child(require(|sender| {
-            sender.has_permission_lvl(PermissionLvl::Two)
-        }))
-        .execute(PumpkinExecutor)
+    CommandTree::new(NAMES, DESCRIPTION).execute(PumpkinExecutor)
 }

pumpkin/src/command/commands/cmd_setblock.rs

@@ -6,9 +6,8 @@ use crate::command::args::arg_block::BlockArgumentConsumer;
 use crate::command::args::arg_position_block::BlockPosArgumentConsumer;
 use crate::command::args::{ConsumedArgs, FindArg};
 use crate::command::tree::CommandTree;
-use crate::command::tree_builder::{argument, literal, require};
+use crate::command::tree_builder::{argument, literal};
 use crate::command::{CommandError, CommandExecutor, CommandSender};
-use pumpkin_core::permission::PermissionLvl;
 
 const NAMES: [&str; 1] = ["setblock"];
 
@@ -81,15 +80,12 @@ impl CommandExecutor for SetblockExecutor {
 
 pub fn init_command_tree() -> CommandTree {
     CommandTree::new(NAMES, DESCRIPTION).with_child(
-        require(|sender| sender.has_permission_lvl(PermissionLvl::Two) && sender.world().is_some())
-            .with_child(
-                argument(ARG_BLOCK_POS, BlockPosArgumentConsumer).with_child(
-                    argument(ARG_BLOCK, BlockArgumentConsumer)
-                        .with_child(literal("replace").execute(SetblockExecutor(Mode::Replace)))
-                        .with_child(literal("destroy").execute(SetblockExecutor(Mode::Destroy)))
-                        .with_child(literal("keep").execute(SetblockExecutor(Mode::Keep)))
-                        .execute(SetblockExecutor(Mode::Replace)),
-                ),
-            ),
+        argument(ARG_BLOCK_POS, BlockPosArgumentConsumer).with_child(
+            argument(ARG_BLOCK, BlockArgumentConsumer)
+                .with_child(literal("replace").execute(SetblockExecutor(Mode::Replace)))
+                .with_child(literal("destroy").execute(SetblockExecutor(Mode::Destroy)))
+                .with_child(literal("keep").execute(SetblockExecutor(Mode::Keep)))
+                .execute(SetblockExecutor(Mode::Replace)),
+        ),
     )
 }

pumpkin/src/command/commands/cmd_stop.rs

@@ -4,9 +4,7 @@ use pumpkin_core::text::TextComponent;
 
 use crate::command::args::ConsumedArgs;
 use crate::command::tree::CommandTree;
-use crate::command::tree_builder::require;
 use crate::command::{CommandError, CommandExecutor, CommandSender};
-use pumpkin_core::permission::PermissionLvl;
 
 const NAMES: [&str; 1] = ["stop"];
 
@@ -38,7 +36,5 @@ impl CommandExecutor for StopExecutor {
 }
 
 pub fn init_command_tree() -> CommandTree {
-    CommandTree::new(NAMES, DESCRIPTION).with_child(
-        require(|sender| sender.has_permission_lvl(PermissionLvl::Four)).execute(StopExecutor),
-    )
+    CommandTree::new(NAMES, DESCRIPTION).execute(StopExecutor)
 }

pumpkin/src/command/commands/cmd_teleport.rs

@@ -9,10 +9,9 @@ use crate::command::args::arg_rotation::RotationArgumentConsumer;
 use crate::command::args::ConsumedArgs;
 use crate::command::args::FindArg;
 use crate::command::tree::CommandTree;
-use crate::command::tree_builder::{argument, literal, require};
+use crate::command::tree_builder::{argument, literal};
 use crate::command::CommandError;
 use crate::command::{CommandExecutor, CommandSender};
-use pumpkin_core::permission::PermissionLvl;
 
 const NAMES: [&str; 2] = ["teleport", "tp"];
 const DESCRIPTION: &str = "Teleports entities, including players."; // todo
@@ -238,41 +237,37 @@ impl CommandExecutor for TpSelfToPosExecutor {
 }
 
 pub fn init_command_tree() -> CommandTree {
-    CommandTree::new(NAMES, DESCRIPTION).with_child(
-        require(|sender| sender.has_permission_lvl(PermissionLvl::Two))
-            .with_child(
-                argument(ARG_LOCATION, Position3DArgumentConsumer).execute(TpSelfToPosExecutor),
-            )
-            .with_child(
-                argument(ARG_DESTINATION, EntityArgumentConsumer).execute(TpSelfToEntityExecutor),
-            )
-            .with_child(
-                argument(ARG_TARGETS, EntitiesArgumentConsumer)
-                    .with_child(
-                        argument(ARG_LOCATION, Position3DArgumentConsumer)
-                            .execute(TpEntitiesToPosExecutor)
-                            .with_child(
-                                argument(ARG_ROTATION, RotationArgumentConsumer)
-                                    .execute(TpEntitiesToPosWithRotationExecutor),
-                            )
-                            .with_child(
-                                literal("facing")
-                                    .with_child(
-                                        literal("entity").with_child(
-                                            argument(ARG_FACING_ENTITY, EntityArgumentConsumer)
-                                                .execute(TpEntitiesToPosFacingEntityExecutor),
-                                        ),
-                                    )
-                                    .with_child(
-                                        argument(ARG_FACING_LOCATION, Position3DArgumentConsumer)
-                                            .execute(TpEntitiesToPosFacingPosExecutor),
+    CommandTree::new(NAMES, DESCRIPTION)
+        .with_child(argument(ARG_LOCATION, Position3DArgumentConsumer).execute(TpSelfToPosExecutor))
+        .with_child(
+            argument(ARG_DESTINATION, EntityArgumentConsumer).execute(TpSelfToEntityExecutor),
+        )
+        .with_child(
+            argument(ARG_TARGETS, EntitiesArgumentConsumer)
+                .with_child(
+                    argument(ARG_LOCATION, Position3DArgumentConsumer)
+                        .execute(TpEntitiesToPosExecutor)
+                        .with_child(
+                            argument(ARG_ROTATION, RotationArgumentConsumer)
+                                .execute(TpEntitiesToPosWithRotationExecutor),
+                        )
+                        .with_child(
+                            literal("facing")
+                                .with_child(
+                                    literal("entity").with_child(
+                                        argument(ARG_FACING_ENTITY, EntityArgumentConsumer)
+                                            .execute(TpEntitiesToPosFacingEntityExecutor),
                                     ),
-                            ),
-                    )
-                    .with_child(
-                        argument(ARG_DESTINATION, EntityArgumentConsumer)
-                            .execute(TpEntitiesToEntityExecutor),
-                    ),
-            ),
-    )
+                                )
+                                .with_child(
+                                    argument(ARG_FACING_LOCATION, Position3DArgumentConsumer)
+                                        .execute(TpEntitiesToPosFacingPosExecutor),
+                                ),
+                        ),
+                )
+                .with_child(
+                    argument(ARG_DESTINATION, EntityArgumentConsumer)
+                        .execute(TpEntitiesToEntityExecutor),
+                ),
+        )
 }

pumpkin/src/command/commands/cmd_time.rs

@@ -6,10 +6,8 @@ use crate::command::args::arg_bounded_num::BoundedNumArgumentConsumer;
 use crate::command::args::FindArgDefaultName;
 use crate::command::tree_builder::{argument_default_name, literal};
 use crate::command::{
-    tree::CommandTree, tree_builder::require, CommandError, CommandExecutor, CommandSender,
-    ConsumedArgs,
+    tree::CommandTree, CommandError, CommandExecutor, CommandSender, ConsumedArgs,
 };
-use pumpkin_core::permission::PermissionLvl;
 
 const NAMES: [&str; 1] = ["time"];
 
@@ -125,19 +123,21 @@ impl CommandExecutor for TimeChangeExecutor {
 }
 
 pub fn init_command_tree() -> CommandTree {
-    CommandTree::new(NAMES, DESCRIPTION).with_child(
-        require(|sender| sender.has_permission_lvl(PermissionLvl::Two))
-            .with_child(literal("add").with_child(
+    CommandTree::new(NAMES, DESCRIPTION)
+        .with_child(
+            literal("add").with_child(
                 argument_default_name(arg_number()).execute(TimeChangeExecutor(Mode::Add)),
-            ))
-            .with_child(
-                literal("query")
-                    .with_child(literal("daytime").execute(TimeQueryExecutor(QueryMode::DayTime)))
-                    .with_child(literal("gametime").execute(TimeQueryExecutor(QueryMode::GameTime)))
-                    .with_child(literal("day").execute(TimeQueryExecutor(QueryMode::Day))),
-            )
-            .with_child(literal("set").with_child(
+            ),
+        )
+        .with_child(
+            literal("query")
+                .with_child(literal("daytime").execute(TimeQueryExecutor(QueryMode::DayTime)))
+                .with_child(literal("gametime").execute(TimeQueryExecutor(QueryMode::GameTime)))
+                .with_child(literal("day").execute(TimeQueryExecutor(QueryMode::Day))),
+        )
+        .with_child(
+            literal("set").with_child(
                 argument_default_name(arg_number()).execute(TimeChangeExecutor(Mode::Set)),
-            )),
-    )
+            ),
+        )
 }