How to make a Rust command alias plugin (Oxide chat shortcuts)

using System;
using System.Collections.Generic;
using Newtonsoft.Json;
using Oxide.Core;
using UnityEngine;

namespace Oxide.Plugins
{
    [Info("Command Aliases", "RustPluginGenerator", "1.0.0")]
    [Description("Maps short chat commands such as /h to longer ones like /home using config-defined aliases.")]
    public class CommandAliases : RustPlugin
    {
        private const string PermAdmin = "commandaliases.admin";

        private PluginConfig config;
        private readonly Dictionary<ulong, float> lastAliasAt = new Dictionary<ulong, float>();

        private class PluginConfig
        {
            [JsonProperty("Alias map (alias -> target command)")]
            public Dictionary<string, string> Aliases { get; set; } = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
            {
                ["h"] = "home",
                ["k"] = "kit",
                ["t"] = "trade"
            };

            [JsonProperty("Seconds between alias uses per player")]
            public float CooldownSeconds { get; set; } = 0.5f;
        }

        protected override void LoadDefaultConfig() => config = new PluginConfig();

        protected override void LoadConfig()
        {
            base.LoadConfig();
            try
            {
                config = Config.ReadObject<PluginConfig>();
                if (config == null) throw new Exception();
            }
            catch
            {
                PrintWarning("Configuration file is invalid, using defaults");
                LoadDefaultConfig();
            }
            SaveConfig();
        }

        protected override void SaveConfig() => Config.WriteObject(config);

        protected override void LoadDefaultMessages()
        {
            lang.RegisterMessages(new Dictionary<string, string>
            {
                ["AliasesReloaded"] = "Reloaded {0} command aliases.",
                ["AliasesList"] = "{0} aliases: {1}",
                ["AliasesNone"] = "No aliases are configured.",
                ["NoPermission"] = "You do not have permission to use that command."
            }, this);
        }

        private string Msg(string key, string userId = null, params object[] args) => string.Format(lang.GetMessage(key, this, userId), args);

        private void Init()
        {
            permission.RegisterPermission(PermAdmin, this);
        }

        private void OnServerInitialized()
        {
            if (config.Aliases == null)
            {
                config.Aliases = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
            }
        }

        private object OnPlayerCommand(BasePlayer player, string cmd, string[] args)
        {
            if (player == null || player.IsNpc || string.IsNullOrEmpty(cmd) || config?.Aliases == null) return null;
            if (config.Aliases.Count == 0) return null;
            if (cmd.StartsWith("chat.", StringComparison.OrdinalIgnoreCase)) return null;
            if (player.IsDead() || player.IsSleeping() || !player.IsConnected) return null;

            string target;
            if (!config.Aliases.TryGetValue(cmd, out target) || string.IsNullOrEmpty(target)) return null;

            string targetCommand = target.Trim().TrimStart('/');
            string firstWord = targetCommand.Split(' ')[0];
            if (string.Equals(firstWord, cmd, StringComparison.OrdinalIgnoreCase)) return null;

            float now = Time.realtimeSinceStartup;
            float last;
            if (lastAliasAt.TryGetValue(player.userID, out last) && now - last < config.CooldownSeconds)
            {
                return null;
            }
            lastAliasAt[player.userID] = now;

            string fullCommand = "/" + targetCommand;
            if (args != null && args.Length > 0)
            {
                fullCommand += " " + string.Join(" ", args);
            }

            player.SendConsoleCommand("chat.say", fullCommand);
            return null;
        }

        private void OnPlayerDisconnected(BasePlayer player)
        {
            if (player != null) lastAliasAt.Remove(player.userID);
        }

        [ConsoleCommand("alias.reload")]
        private void CmdReload(ConsoleSystem.Arg arg)
        {
            if (!CanUseAdmin(arg)) return;
            LoadConfig();
            arg.ReplyWith(Msg("AliasesReloaded", null, config.Aliases?.Count ?? 0));
        }

        [ConsoleCommand("alias.list")]
        private void CmdList(ConsoleSystem.Arg arg)
        {
            if (!CanUseAdmin(arg)) return;
            if (config.Aliases == null || config.Aliases.Count == 0)
            {
                arg.ReplyWith(Msg("AliasesNone"));
                return;
            }
            var parts = new List<string>();
            foreach (var pair in config.Aliases)
            {
                parts.Add("/" + pair.Key + " -> /" + pair.Value);
            }
            arg.ReplyWith(Msg("AliasesList", null, config.Aliases.Count, string.Join(", ", parts)));
        }

        private bool CanUseAdmin(ConsoleSystem.Arg arg)
        {
            if (arg == null) return false;
            var player = arg.Player();
            if (player == null) return true;
            if (permission.UserHasPermission(player.UserIDString, PermAdmin)) return true;
            arg.ReplyWith(Msg("NoPermission", player.UserIDString));
            return false;
        }

        private void Unload()
        {
            lastAliasAt.Clear();
        }
    }
}