How to make a Rust entity owner check plugin (raycast admin tool)

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

namespace Oxide.Plugins
{
    [Info("Entity Owner Check", "RustPluginGenerator", "1.0.0")]
    [Description("Adds an admin /owner command that raycasts and reports entity ownership and covering cupboard authorizations.")]
    public class EntityOwnerCheck : RustPlugin
    {
        private const string PermUse = "entityownercheck.use";

        private PluginConfig config;

        private class PluginConfig
        {
            [JsonProperty("Raycast Distance")]
            public float RaycastDistance = 25f;

            [JsonProperty("Show Authorized Players")]
            public bool ShowAuthorizedPlayers = true;

            [JsonProperty("Show Grade")]
            public bool ShowGrade = false;
        }

        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>
            {
                ["NoPermission"] = "You do not have permission to use this command.",
                ["NoHit"] = "No entity found in front of you within {0} metres.",
                ["ServerOwned"] = "Owner: server (OwnerID 0)",
                ["UnknownOwner"] = "Owner: unknown player (SteamID {0})",
                ["Report"] = "Entity: <color=#e6c15c>{0}</color> | Owner: <color=#e6c15c>{1}</color> ({2})",
                ["Grade"] = "Grade: {0}",
                ["NoCupboard"] = "Authorization: not inside any tool cupboard zone.",
                ["Cupboard"] = "Tool cupboard at {0} | Authorized ({1}):",
                ["CupboardEmpty"] = "Tool cupboard found but nobody is authorized.",
                ["AuthLine"] = "  - {0} ({1})"
            }, 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(PermUse, this);
        }

        [ChatCommand("owner")]
        private void CmdOwner(BasePlayer player, string command, string[] args)
        {
            if (player == null) return;
            if (!permission.UserHasPermission(player.UserIDString, PermUse))
            {
                SendReply(player, Msg("NoPermission", player.UserIDString));
                return;
            }

            RaycastHit hit;
            if (!Physics.Raycast(player.eyes.position, player.eyes.HeadForward(), out hit, config.RaycastDistance))
            {
                SendReply(player, Msg("NoHit", player.UserIDString, config.RaycastDistance));
                return;
            }

            var entity = hit.collider != null ? hit.collider.ToBaseEntity() : null;
            if (entity == null)
            {
                SendReply(player, Msg("NoHit", player.UserIDString, config.RaycastDistance));
                return;
            }

            string prefab = entity.ShortPrefabName ?? "unknown";
            string ownerName = "server";
            string ownerId = "0";

            if (entity.OwnerID != 0)
            {
                ownerId = entity.OwnerID.ToString();
                var owner = BasePlayer.FindAwakeOrSleeping(ownerId);
                if (owner != null)
                {
                    ownerName = owner.displayName;
                }
                else
                {
                    ownerName = "unknown";
                }
            }

            SendReply(player, Msg("Report", player.UserIDString, prefab, ownerName, ownerId));

            if (config.ShowGrade)
            {
                var block = entity as BuildingBlock;
                if (block != null)
                {
                    SendReply(player, Msg("Grade", player.UserIDString, block.grade));
                }
            }

            var privilege = entity.GetBuildingPrivilege();
            if (privilege == null)
            {
                SendReply(player, Msg("NoCupboard", player.UserIDString));
                return;
            }

            if (!config.ShowAuthorizedPlayers) return;

            var list = privilege.authorizedPlayers;
            if (list == null || list.Count == 0)
            {
                SendReply(player, Msg("CupboardEmpty", player.UserIDString));
                return;
            }

            var pos = privilege.transform.position;
            SendReply(player, Msg("Cupboard", player.UserIDString, string.Format("{0:F0},{1:F0},{2:F0}", pos.x, pos.y, pos.z), list.Count));
            foreach (var entry in list)
            {
                ulong id = entry;
                var authed = BasePlayer.FindAwakeOrSleeping(id.ToString());
                string name = authed != null && !string.IsNullOrEmpty(authed.displayName) ? authed.displayName : "unknown";
                SendReply(player, Msg("AuthLine", player.UserIDString, name, id));
            }
        }
    }
}