Security scan — Stations2

Read-only view of the uploaded .cs file. Ai has detected at risk method calls. A security warning is not an automatic malware verdict — review the code yourself before trusting it.
⚠ 29 flagged lines in Stations2.cs (highlighted below).
Line 225: Directory.CreateDirectory
Line 240: WebClient
Line 385: File.Delete
Line 391: File.Delete
Line 954: Process.Start
Line 954: ProcessStartInfo
Line 980: ProcessStartInfo
Line 989: Process.Start
Line 1400: Process.Start
Line 1494: Process.Start
Line 1528: File.Delete
Line 1545: File.Delete
Line 1557: Process.Start
Line 1622: File.Delete
Line 1647: Directory.CreateDirectory
Line 1648: WebClient
Line 1670: WebClient
Line 1691: Process.Start
Line 1708: Directory.CreateDirectory
Line 1711: WebClient
Line 1712: WebClient
Line 1735: ProcessStartInfo
Line 1783: ProcessStartInfo
Line 1784: ProcessStartInfo
Line 1785: ProcessStartInfo
Line 1825: ProcessStartInfo
Line 1829: ProcessStartInfo
Line 1833: ProcessStartInfo
Line 1846: Process.Start
Stations2.cs · scanned 18 days ago Download
/*▄▄▄▄    ███▄ ▄███▓  ▄████  ▄▄▄██▀▀▀▓█████▄▄▄█████▓
 ▓█████▄ ▓██▒▀█▀ ██▒ ██▒ ▀█▒   ▒██   ▓█   ▀▓  ██▒ ▓▒
 ▒██▒ ▄██▓██    ▓██░▒██░▄▄▄░   ░██   ▒███  ▒ ▓██░ ▒░
 ▒██░█▀  ▒██    ▒██ ░▓█  ██▓▓██▄██▓  ▒▓█  ▄░ ▓██▓ ░ 
 ░▓█  ▀█▓▒██▒   ░██▒░▒▓███▀▒ ▓███▒   ░▒████▒ ▒██▒ ░ 
 ░▒▓███▀▒░ ▒░   ░  ░ ░▒   ▒  ▒▓▒▒░   ░░ ▒░ ░ ▒ ░░   
 ▒░▒   ░ ░  ░      ░  ░   ░  ▒ ░▒░    ░ ░  ░   ░    
  ░    ░ ░      ░   ░ ░   ░  ░ ░ ░      ░    ░      
  ░             ░         ░  ░   ░      ░  ░
Chat Commands

    Set MP3 URL (Stations2.MP3 Privileges Required)
    /mp3
    Sets the MP3 link on boomboxes currently being held or looked at.

    Create Cassettes from YouTube Link (Stations2.YT Privileges Required)
    /yt
    Download youtube video and convert it to cassettes

Console Commands (RCON/Plugins/Admin)

    Change Boombox URL by NetID
    stationsset <NetID> <URL>

    Give Cassettes to Player
    stationstapes <URL> <NameOrIDorIP>

    List All Cassettes
    stationslist

    Remove Cassette
    stationsremove <Index>

Notes
    This plugin functions by distributing your YouTube audio across multiple cassette tapes,   
    with each tape containing up to 30 seconds of audio due to game limitations. 
    Be cautious not to lose any tapes in the set, as missing parts will render the audio incomplete and unusable.

Requires Node/js npm to install deno to solve youtube security since cookies now only covers about 60% of videos
 */
using Newtonsoft.Json;
using System.Collections;
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Net;
using System.Text.RegularExpressions;
using UnityEngine;
using Oxide.Core.Plugins;
using System.Threading.Tasks;
using HarmonyLib;
using Oxide.Core;
using Oxide.Game.Rust.Cui;
namespace Oxide.Plugins
{
    [Info("Stations2", "bmgjet", "2.0.1")]
    class Stations2 : RustPlugin
    {
        //Perms
        private readonly string MP3Perm = "Stations2.MP3";
        private readonly string YTPerm = "Stations2.YT";
        private readonly string NoLimitPerm = "Stations2.NoLimit";

        //Self Reference
        public static Stations2 codebase;

        //Vars
        private string installPath = Path.Combine(Interface.Oxide.DataDirectory, "Stations");
        private Dictionary<ulong, float> cooldowns = new Dictionary<ulong, float>();
        private List<Coroutine> YT_DLP = new List<Coroutine>();
        private Dictionary<BaseEntity, Coroutine> TapeThreads = new Dictionary<BaseEntity, Coroutine>();
        private List<TapeQueue> _queue = new List<TapeQueue>();
        private readonly object _queueLock = new object();
        private Coroutine _queuechecker = null;
        private string VersionString;
        private bool WinOS;
        private bool Linux;
        private string CUICheckSum;

        //ConversionJobs
        public class TapeQueue
        {
            public BasePlayer Player;
            public string Url;
            public int Status = 0;
        }

        //Tapes
        public class CassetteParts
        {
            public ulong ID = 0;
            public string title = "";
            public ulong ownerid = 0;
            public List<ulong> netids = new List<ulong>();
            public List<uint> crc = new List<uint>();
            public List<int> lengths = new List<int>();
        }

        #region Harmony Hooks
        //Casset HooksDeployedRecorder
        [AutoPatch]
        [HarmonyPatch(typeof(DeployedRecorder), "OnCassetteInserted", typeof(Cassette))] internal class DeployedRecorder_OnCassetteInserted {[HarmonyPrefix] static bool Prefix(Cassette c, DeployedRecorder __instance) { try { return codebase.DeployedRecorder(c, __instance); } catch { } return true; } }
        //Casset Hook Deployed Bookox and held boombox
        [AutoPatch]
        [HarmonyPatch(typeof(BoomBox), "OnCassetteInserted", typeof(Cassette))] internal class BoomBox_OnCassetteInserted {[HarmonyPrefix] static bool Prefix(Cassette c, BoomBox __instance) { try { return codebase.BoomBox(c, __instance); } catch { } return true; } }
        //Oxide has no Play hook on deployed recorder so add one
        [AutoPatch]
        [HarmonyPatch(typeof(DeployedRecorder), "ServerTogglePlay", typeof(bool))] internal class DeployedRecorder_ServerTogglePlay {[HarmonyPrefix] static bool Prefix(DeployedRecorder __instance) { try { return codebase.OnRecorderToggle(__instance); } catch { } return true; } }
        #endregion

        #region Configuration
        private Configuration config;
        private class Configuration
        {
            [JsonProperty("Show Debug Info")]
            public bool debug = false;

            [JsonProperty("Cassette Limit Per Player")]
            public int CassetteLimit = 3;

            [JsonProperty("Max Youtube Video Length (Seconds)")]
            public int MaxVideoLength = 600;

            [JsonProperty("Delete Cassettes With Missing Parts On Startup")]
            public bool AutoClean = true;

            [JsonProperty("Use Remote Cookies File")]
            public bool PublicCookies = false;

            [JsonProperty("Remote Cookies File URL")]
            public string PublicCookiesURL = "";

            [JsonProperty("Local Cookies Path")]
            public string CookiesPath = "";

            [JsonProperty("Use Extra Args")]
            public bool UseExtraArgs = false;

            [JsonProperty("Extra YT-DLP Args")]
            public string ExtraArgs = " --cookies-from-browser firefox ";

            [JsonProperty("YouTube Downloader And FFMPEG Stall Timeout (Sec)")]
            public int TimeOut = 30;

            [JsonProperty("Queue Update Message Rate (Sec)")]
            public int MessageTimeout = 10;

            [JsonProperty("Cooldown Between Command Useage (Seconds)")]
            public int Cooldown = 20;

            [JsonProperty("Cooldown Between Cassette Removal (Seconds)")]
            public int TapeCooldown = 5;

            [JsonProperty("Current Installed Version Of YT-DLP (Dont Edit)")]
            public string lastVersionYouTubeDL;

            [JsonProperty("Max Cassette Length (Dont Edit)")]
            public int cassetlength = 30;

            [JsonProperty("Cassette Data (Dont Edit)")]
            public List<CassetteParts> CustomCassettes = new List<CassetteParts>();

            public string ToJson() => JsonConvert.SerializeObject(this);

            public Dictionary<string, object> ToDictionary() => JsonConvert.DeserializeObject<Dictionary<string, object>>(ToJson());
        }

        protected override void LoadDefaultConfig() { config = new Configuration(); }
        protected override void LoadConfig()
        {
            base.LoadConfig();
            try
            {
                config = Config.ReadObject<Configuration>();
                if (config == null) { throw new JsonException(); }

                if (!config.ToDictionary().Keys.SequenceEqual(Config.ToDictionary(x => x.Key, x => x.Value).Keys))
                {
                    PrintWarning("Configuration appears to be outdated; updating and saving");
                    SaveConfig();
                }
            }
            catch
            {
                PrintWarning($"Configuration file {Name}.json is invalid; using defaults");
                LoadDefaultConfig();
            }
        }
        protected override void SaveConfig()
        {
            PrintWarning($"Configuration changes saved to {Name}.json");
            Config.WriteObject(config, true);
        }
        #endregion Configuration

        #region Oxide Hooks
        private void OnNewSave()
        {
            //Wipe custom cassettes on map wipes
            Puts("Reset Custom Cassette Data");
            config.CustomCassettes.Clear();
            SaveConfig();
        }

        private void OnServerInitialized()
        {
            //Setup
            codebase = this;
            permission.RegisterPermission(MP3Perm, this);
            permission.RegisterPermission(YTPerm, this);
            permission.RegisterPermission(NoLimitPerm, this);
            VersionString = "Stations2 " + Version + " - " + SystemInfo.operatingSystem + " by bmgjet";
            //Determine OS first - everything below depends on it
            WinOS = SystemInfo.operatingSystem.StartsWith("Windows");
            Linux = SystemInfo.operatingSystem.StartsWith("Linux");
            if (!WinOS && !Linux) //Unknown OS
            {
                Puts("Stations2 Not Compatible with " + SystemInfo.operatingSystem);
            }
            if (!Directory.Exists(installPath))
            {
                Puts("Creating Folder");
                Directory.CreateDirectory(installPath);
                if (Linux)
                {
                    Puts("Setting Folder Permissions");
                    SetPermissions(installPath, "777");
                }
            }
            Task.Run(() =>
            {
                //Create CUI token
                CUICheckSum = RandomString(8);
                if (config.PublicCookies)
                {
                    if (!string.IsNullOrEmpty(config.PublicCookiesURL) && config.PublicCookiesURL.StartsWith("http"))
                    {
                        try { using (WebClient wc = new WebClient()) { wc.DownloadFile(new Uri(config.PublicCookiesURL), Path.Combine(codebase.installPath, "cookies.txt")); } }
                        catch (Exception ex) { Puts("Failed to download remote cookies file: " + ex.Message); }
                    }
                }
                if (WinOS)
                {
                    //Windows Dependencies
                    YouTubeDL.binName = "yt-dlp.exe";
                    YouTubeDL.downloadURL = "https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp.exe";
                    FFmpeg.binName = "ffmpeg.exe";
                    FFmpeg.downloadURL = "https://raw.githubusercontent.com/bmgjet/Stations2/refs/heads/main/ffmpeg.exe";
                    FFmpeg.Files = new Dictionary<string, string>()
                        {
                        {"https://raw.githubusercontent.com/bmgjet/Stations2/refs/heads/main/swscale-6.dll", Path.Combine(installPath, "swscale-6.dll")},
                        {"https://raw.githubusercontent.com/bmgjet/Stations2/refs/heads/main/swresample-4.dll", Path.Combine(installPath, "swresample-4.dll")},
                        {"https://raw.githubusercontent.com/bmgjet/Stations2/refs/heads/main/postproc-56.dll", Path.Combine(installPath, "postproc-56.dll")},
                        {"https://raw.githubusercontent.com/bmgjet/Stations2/refs/heads/main/avutil-57.dll", Path.Combine(installPath, "avutil-57.dll")},
                        {"https://raw.githubusercontent.com/bmgjet/Stations2/refs/heads/main/avformat-59.dll", Path.Combine(installPath, "avformat-59.dll")},
                        {"https://raw.githubusercontent.com/bmgjet/Stations2/refs/heads/main/avfilter-8.dll", Path.Combine(installPath, "avfilter-8.dll")},
                        {"https://raw.githubusercontent.com/bmgjet/Stations2/refs/heads/main/avdevice-59.dll", Path.Combine(installPath, "avdevice-59.dll")},
                        {"https://raw.githubusercontent.com/bmgjet/Stations2/refs/heads/main/avcodec-59.dll", Path.Combine(installPath, "avcodec-59.dll")},
                        };
                }
                else if (Linux)
                {
                    //Linux Dependencies
                    YouTubeDL.binName = "yt-dlp";
                    YouTubeDL.downloadURL = "https://github.com/yt-dlp/yt-dlp/releases/latest/download/yt-dlp";
                    FFmpeg.binName = "ffmpeg";
                    FFmpeg.downloadURL = "https://raw.githubusercontent.com/bmgjet/Stations2/refs/heads/main/ffmpeg";
                    FFmpeg.Files = new Dictionary<string, string>();
                }
                //Check dependencies
                if (!YouTubeDL.isInstalled())
                {
                    Puts("YT-DLP missing. Downloading....");
                    YouTubeDL.checkDownload();
                }
                else { YouTubeDL.checkForUpdates(); }
                if (!FFmpeg.isInstalled())
                {
                    Puts("FFMPEG missing. Downloading....");
                    FFmpeg.downloadAndInstall();
                }
                //YouTube now requires solving a JS signature/n challenge (yt-dlp's "EJS" system) to get
                //real audio formats without it you only get thumbnail/image-only results. Deno is the
                //JS runtime yt-dlp uses for this, and installs the same way cross-platform via npm.
                if (!Deno.isInstalled())
                {
                    Puts("Deno (JS runtime for YouTube challenge solving) missing. Installing via npm....");
                    Deno.downloadAndInstall();
                }
            });
            Puts("Loaded: " + VersionString);
            CleanUpMissingTapes();
        }

        //Oxide Hook For Pressing Play On Deployed And Held BoomBoxes
        private object OnBoomboxToggle(BoomBox boomBox)
        {
            if (!boomBox.HasFlag(BaseEntity.Flags.On))
            {
                ItemContainer slot = (boomBox.baseEntity as DeployableBoomBox)?.inventory;
                if (slot == null) { slot = (boomBox.baseEntity as HeldBoomBox)?.GetItem()?.contents; }
                if (slot != null && slot?.itemList?.Count > 0)
                {
                    Item cassette = slot.itemList[0];
                    if (cassette != null)
                    {
                        foreach (var c in config.CustomCassettes)
                        {
                            foreach (var id in c.netids)
                            {
                                if (id == cassette.instanceData.subEntity.Value)
                                {
                                    BoomBox(BaseNetworkable.serverEntities.Find(cassette.instanceData.subEntity) as Cassette, boomBox);
                                    return true;
                                }
                            }
                        }
                    }
                }
            }
            else
            {
                if (TapeThreads.ContainsKey(boomBox.baseEntity))
                {
                    ServerMgr.Instance.StopCoroutine(TapeThreads[boomBox.baseEntity]);
                    TapeThreads.Remove(boomBox.baseEntity);
                }
            }
            return null;
        }

        //Added hook via Harmony
        private bool OnRecorderToggle(BaseEntity recorder)
        {
            if (!recorder.HasFlag(BaseEntity.Flags.On))
            {
                ItemContainer slot = (recorder as DeployedRecorder)?.inventory;
                if (slot != null && slot?.itemList?.Count > 0)
                {
                    Item cassette = slot.itemList[0];
                    if (cassette != null)
                    {
                        foreach (var c in config.CustomCassettes)
                        {
                            foreach (var id in c.netids)
                            {
                                if (id == cassette.instanceData.subEntity.Value)
                                {
                                    DeployedRecorder(BaseNetworkable.serverEntities.Find(cassette.instanceData.subEntity) as Cassette, recorder as DeployedRecorder);
                                    return false;
                                }
                            }
                        }
                    }
                }
            }
            else
            {
                if (TapeThreads.ContainsKey(recorder))
                {
                    ServerMgr.Instance.StopCoroutine(TapeThreads[recorder]);
                    TapeThreads.Remove(recorder);
                }
            }
            return true;
        }

        private void Unload()
        {
            //Stop Threads
            foreach (Coroutine co in YT_DLP) { if (co != null) { ServerMgr.Instance.StopCoroutine(co); } }
            foreach (KeyValuePair<BaseEntity, Coroutine> tape in TapeThreads) { if (tape.Value != null) { ServerMgr.Instance.StopCoroutine(tape.Value); } }
            //Remove CUI
            foreach (BasePlayer player in BasePlayer.activePlayerList) { CuiHelper.DestroyUi(player, "S2"); }
            //Remove Temp Files
            try
            {
                //Clean up any temp files
                string tempfiles;
                if (config.PublicCookies)
                {
                    tempfiles = Path.Combine(installPath, "cookies.txt");
                    if (File.Exists(tempfiles)) { File.Delete(tempfiles); }
                }
                tempfiles = Path.Combine(installPath, "dl");
                if (Directory.Exists(tempfiles))
                {
                    System.IO.DirectoryInfo di = new DirectoryInfo(tempfiles);
                    foreach (FileInfo file in di.GetFiles()) { file.Delete(); }
                }
            }
            catch { }
            codebase = null;
        }
        #endregion

        #region Chat/Console Commands

        [ConsoleCommand("stationsset")] //API call to directly set youtube/mp3
        private void ConsoleCommandSet(ConsoleSystem.Arg arg)
        {
            if ((arg.IsAdmin || arg.IsRcon) && arg.Args?.Length >= 2) //Check there are 3 or more args
            {
                try
                {
                    if (arg.Args.Length > 1)
                    {
                        ulong netid = 0;
                        if (ulong.TryParse(arg.Args[0].ToString(), out netid))
                        {
                            //Find by passed netid
                            BaseNetworkable bn = BaseNetworkable.serverEntities.Find(new NetworkableId(netid));
                            if (bn != null) { ManuallySetRadio(bn as BaseEntity, arg.Args[1].ToString()); return; }
                        }
                    }
                }
                catch { }
                string err = "Invalid Args!" + Environment.NewLine + "stationsset NetID URL";
                if (arg.Player() != null) { arg.Player().ConsoleMessage(err); }
                else { Puts(err); }
            }
        }

        [ConsoleCommand("stationstapes")]
        private void ConsoleCommandTapes(ConsoleSystem.Arg arg) //API call to directly give player youtube tapes
        {
            if ((arg.IsAdmin || arg.IsRcon) && arg.Args?.Length >= 2) //Check there are 2 or more args
            {
                try
                {
                    //Find player
                    BasePlayer targetplayer = BasePlayer.FindAwakeOrSleeping(arg.Args[1].ToString());
                    if (targetplayer != null)
                    {

                        try { YouTubeTapes(targetplayer, arg.Args[0].ToString()); }
                        catch (Exception ex) { Puts(ex.ToString()); }
                        return;
                    }
                }
                catch { }
                string err = "Invalid Args!" + Environment.NewLine + "stationstapes URL NameOrIDorIP";
                if (arg.Player() != null) { arg.Player().ConsoleMessage(err); }
                else { Puts(err); }
            }
        }

        [ConsoleCommand("stationslist")]
        private void ConsoleCommandList(ConsoleSystem.Arg arg) //API to get list of tapes
        {
            if (arg.IsAdmin)
            {
                var sb = new System.Text.StringBuilder("Cassette List:").AppendLine();
                for (int i = config.CustomCassettes.Count - 1; i >= 0; i--)
                {
                    try { sb.Append("Index: ").Append(config.CustomCassettes[i].ID).Append(" OwnerID: ").Append(config.CustomCassettes[i].ownerid).Append(" Title: ").Append(config.CustomCassettes[i].title).Append(" Tapes: ").Append(config.CustomCassettes[i].netids.Count).AppendLine(); } catch { }
                }
                string msg = sb.ToString();
                if (arg.Player() != null) { arg.Player().ConsoleMessage(msg); }
                else { Puts(msg); }
            }
        }

        [ConsoleCommand("stationsremove")]
        private void ConsoleCommandRemove(ConsoleSystem.Arg arg) //API to remove tape
        {
            if (arg.IsAdmin)
            {
                if (arg.Args?.Length == 1)
                {
                    ServerMgr.Instance.StartCoroutine(RemoveCassettes(arg.Player(), ulong.Parse(arg.Args[0].ToString())));
                    return;
                }
                string err = "Invalid Args!" + Environment.NewLine + "stationsremove Index";
                if (arg.Player() != null) { arg.Player().ConsoleMessage(err); }
                else { Puts(err); }
            }
        }


        [ChatCommand("mp3")]
        private void PlayMP3ChatCmd(BasePlayer player, string command, string[] args)
        {
            if (!OnCoolDown(player)) //Check Not On Cooldown
            {
                if (permission.UserHasPermission(player.UserIDString, MP3Perm)) //Check Has Permission
                {
                    BaseEntity baseEntity = FindBoomBox(player); //Try get entity
                    if (baseEntity != null)
                    {
                        CuiHelper.AddUi(player, RustUI(player, baseEntity.net.ID.Value, "", CUICheckSum)); //Create CUI
                        return;
                    }
                    player.ChatMessage("Couldn't Find BoomBox (Look at or hold one)"); //Error Message
                }
            }
        }

        [ChatCommand("yt")]
        private void PlayYTChatCmd(BasePlayer player, string command, string[] args)
        {
            if (!OnCoolDown(player)) //Check Not On Cooldown
            {
                if (permission.UserHasPermission(player.UserIDString, YTPerm)) //Check Has Permission
                {
                    CuiHelper.AddUi(player, RustUI(player, 0, "_", CUICheckSum)); //Create CUI
                }
            }
        }
        #endregion

        #region CUI

        [ConsoleCommand("SGUI")]
        private void GUICMD(ConsoleSystem.Arg arg)
        {
            //Process CUI Button Presses
            BasePlayer player = arg?.Player();
            //null checks
            if (player == null || arg?.Args?.Length < 3) { return; }
            //Unique Key, Help against console injection
            if (arg.Args[3] != CUICheckSum) { Puts("Invalid CUI Key: " + player.ToString()); CuiHelper.DestroyUi(player, "S2"); return; }
            //Setup Args
            BaseNetworkable info = null;
            string url = (arg.Args.Count() == 5) ? arg.Args[4].ToString() : arg.Args[2].ToString();
            ulong netid = 0;
            if (ulong.TryParse(arg.Args[1].ToString(), out netid)) { info = BaseNetworkable.serverEntities.Find(new NetworkableId(netid)); } //Gets Boombox/Recorder from CUI Command
            //Filter Commands
            switch (arg.Args[0].ToString())
            {
                case "U": //Update
                    CuiHelper.AddUi(player, RustUI(player, (info != null) ? info.net.ID.Value : 0, url, CUICheckSum));
                    break;
                case "S": //Set Stations
                    if (info != null)
                    {
                        if (info is DeployableBoomBox) { ChangeStationDeployed((info as DeployableBoomBox), url, player); }
                        else if (info is HeldBoomBox) { ChangeStationPortable((info as HeldBoomBox), url, player); }
                        CuiHelper.DestroyUi(player, "S2");
                    }
                    break;
                case "D": //Download Cassets
                    YouTubeTapes(player, url);
                    CuiHelper.DestroyUi(player, "S2");
                    break;
                case "L": //List Owned
                    CuiHelper.AddUi(player, CassetteListUI(player, CUICheckSum));
                    break;
                case "R": //Remove Cassetts
                    if (OnCoolDown(player, true)) { return; }
                    if (cooldowns.ContainsKey(player.userID)) { cooldowns[player.userID] = Time.time; }
                    else { cooldowns.Add(player.userID, Time.time); }
                    ServerMgr.Instance.StartCoroutine(RemoveCassettes(player, netid, true, url));
                    break;
            }
        }

        private CuiElementContainer RustUI(BasePlayer player, ulong netid, string url, string checksum)
        {
            //Create CUI
            //Validate URL
            bool youtube = false;
            bool validurl = false;
            if (string.IsNullOrEmpty(url)) { url = "_"; }
            else
            {
                url.Replace(" ", "");
                youtube = url.Contains("watch?v=");
                validurl = isValidURL(url);
            }
            //Check Owned Tapes
            int Owned = NumberOfCassettes(player.userID);
            //Set up defaults settings
            bool tapes = true;
            int ItemID = 476066818;
            if (netid != 0) //Provided NetID Run in MP3 Set Mode
            {
                BaseNetworkable bn = BaseNetworkable.serverEntities.Find(new NetworkableId(netid));
                if (bn != null)
                {
                    tapes = false;
                    var be = bn as BaseEntity;
                    if (be != null)
                    {
                        //Adjust Icon
                        switch (be.prefabID)
                        {
                            case 244503553: //Boombox
                                ItemID = -1113501606;
                                break;
                            case 617635188: //Portable Boombox
                                ItemID = 576509618;
                                break;
                            case 760079751: //Deployed CassetteRecorder
                            case 705457609: //CassetteRecorder
                                ItemID = -1530414568;
                                break;
                        }
                    }
                    if (youtube) { validurl = false; } //Trying to pass youtube link to mp3
                }
            }
            else { if (!youtube) { validurl = false; } }//Missing YouTube Link
            //Create Arg String
            string info = netid + " " + url + " " + checksum;
            //Create CUI
            var container = new CuiElementContainer();
            //Invisible Overlay Whole Screen
            container.Add(new CuiElement
            {
                Name = "S2",
                Parent = "Overlay",
                DestroyUi = "S2",
                Components =
                {
                    new CuiNeedsCursorComponent(),
                    new CuiImageComponent{ Color = "1 1 1 0" },
                    new CuiRectTransformComponent{ AnchorMin = "0 0", AnchorMax = "1 1", OffsetMin = "0 0", OffsetMax = "0 0" }
                }
            });
            //Create Panel
            container.Add(new CuiElement
            {
                Name = "SGUI",
                Parent = "S2",
                DestroyUi = "SGUI",
                Components =
                {
                    new CuiNeedsCursorComponent(),
                    new CuiImageComponent{ Color = ".18 .18 .18 .95" },
                    new CuiRectTransformComponent{ AnchorMin = ".88 .82", AnchorMax = "1 1" }
                }
            });
            //Create Text Label
            container.Add(new CuiElement
            {
                Name = "SLabel",
                Parent = "SGUI",
                Components = {
                    new CuiTextComponent { Text = "URL:", FontSize = 10, Align = TextAnchor.MiddleLeft, Color = "1 1 1 1" },
                    new CuiOutlineComponent { Color = "0 0 0 .5", Distance = "1 -1" },
                    new CuiRectTransformComponent { AnchorMin = ".5 .5", AnchorMax = ".5 .5", OffsetMin = "-65 -38", OffsetMax = "-20 -18" }
                }
            });
            //Create Close Button
            container.Add(new CuiButton
            {
                Button = { Color = "1 1 1 1", Close = "S2" },
                Text = { Text = "X", FontSize = 7, Align = TextAnchor.MiddleCenter, Color = "1 0 0 1" },
                RectTransform = { AnchorMin = ".5 .5", AnchorMax = ".5 .5", OffsetMin = "55 50", OffsetMax = "65 60" }
            }, "SGUI", "CBtn");
            //Limit Check
            string Downloadtxt = "Download YouTube";
            if (!permission.UserHasPermission(player.UserIDString, NoLimitPerm))
            {
                if (tapes && Owned >= config.CassetteLimit)
                {
                    validurl = false;
                    Downloadtxt = "At Limit [" + Owned + "/" + config.CassetteLimit + "]";
                }
            }
            //Download Button
            container.Add(new CuiButton
            {
                Button = { Color = (validurl ? "1 1 1 1" : ".5 .5 .5 1"), Command = !validurl ? "" : (tapes ? ("SGUI D " + info) : ("SGUI S " + info)) },
                Text = { Text = tapes ? Downloadtxt : "Set MP3 Url", FontSize = 14, Align = TextAnchor.MiddleCenter, Color = "0 0 0 1" },
                RectTransform = { AnchorMin = ".5 .5", AnchorMax = ".5 .5", OffsetMin = "-65 -60", OffsetMax = "65 -41" }
            }, "SGUI", "SBtn");

            //List Button
            if (tapes)
            {
                container.Add(new CuiButton
                {
                    Button = { Color = "1 1 1 1", Command = ("SGUI L " + info) },
                    Text = { Text = "List", FontSize = 7, Align = TextAnchor.MiddleCenter, Color = "0 0 0 1" },
                    RectTransform = { AnchorMin = ".5 .5", AnchorMax = ".5 .5", OffsetMin = "-65 50", OffsetMax = "-45 60" }
                }, "SGUI", "MBtn");
            }
            //Create Icon
            container.Add(new CuiElement
            {
                Name = "SIcon",
                Parent = "SGUI",
                Components = {
                    new CuiImageComponent { Color = "1 1 1 1", ItemId = ItemID },
                    new CuiOutlineComponent { Color = "0 0 0 .5", Distance = "1 -1" },
                    new CuiRectTransformComponent { AnchorMin = ".5 .5", AnchorMax = ".5 .5", OffsetMin = "-40 -20", OffsetMax = "40 60" }
                }
            });
            //Create Whitebox
            container.Add(new CuiElement
            {
                Name = "SBox",
                Parent = "SGUI",
                Components = {
                    new CuiImageComponent { Color = "1 1 1 .98", },
                    new CuiRectTransformComponent { AnchorMin = ".5 .5", AnchorMax = ".5 .5", OffsetMin = "-40 -34", OffsetMax = "65 -20" }
                }
            });
            //Create Text Input
            container.Add(new CuiElement
            {
                Name = "SIn",
                Parent = "SBox",
                Components = {
                    new CuiInputFieldComponent { Color = "0 0 0 1", FontSize = 10, Align = TextAnchor.UpperLeft, ReadOnly = false, IsPassword = false, Text = url , Command = "SGUI U " + info },
                    new CuiRectTransformComponent { AnchorMin = ".01 .01", AnchorMax = ".99 .99" }
                }
            });
            return container;
        }

        private List<CuiElement> CassetteListUI(BasePlayer player, string checksum)
        {
            //Create New CUI
            CuiElementContainer container = new CuiElementContainer();
            List<CassetteParts> Clean = Facepunch.Pool.Get<List<CassetteParts>>(); //Get List of Custom Cassettes from config
            for (int i = config.CustomCassettes.Count - 1; i >= 0; i--)
            {
                if (config.CustomCassettes[i].ownerid == player.userID) { Clean.Add(config.CustomCassettes[i]); }
            }
            //Setup Position based off Size
            int loops = Clean.Count;
            int offset = (loops - (int)(loops)) - 100;
            //Create Panel
            container.Add(new CuiPanel
            {
                CursorEnabled = true,
                Image = { Color = ".18 .18 .18 .95" },
                RectTransform = { AnchorMin = ".75 0", AnchorMax = ".88 1" }
            }, "S2", "MTUI", "MTUI");
            //Create Scroll view
            container.Add(new CuiElement
            {
                Name = "SB",
                Parent = "MTUI",
                Components = {
                    new CuiScrollViewComponent {
                        MovementType = UnityEngine.UI.ScrollRect.MovementType.Elastic,
                        Vertical = true,
                        Inertia = true,
                        Horizontal = false,
                        Elasticity = 0.25f,
                        DecelerationRate = 0.3f,
                        ScrollSensitivity = 24f,
                        //Position based on calculated offsets for size
                        ContentTransform = new CuiRectTransform { AnchorMin = "0 1", AnchorMax = "1 1", OffsetMin = "0 " + ((150+(100 * loops)) * -1), OffsetMax = "0 250" },
                        VerticalScrollbar = new CuiScrollbar() { Size = 18f, AutoHide = true },
                    },
                    new CuiRawImageComponent
                    {
                        Sprite = "assets/content/effects/crossbreed/fx gradient skewed.png",
                        Color = ".05 .05 .05 .5"
                    }
                }
            });
            //Title Bar
            container.Add(new CuiElement
            {
                Name = "Title",
                Parent = "MTUI",
                Components = {
                        new CuiRawImageComponent
                        {
                            Sprite = "assets/content/effects/crossbreed/fx gradient skewed.png",
                            Color = ".25 .25 .25 0.6",},
                        new CuiRectTransformComponent { AnchorMin = "0 1", AnchorMax = "1 1", OffsetMin = "0 -28",OffsetMax = "-18 0"},
                        }
            });
            //Title Text
            container.Add(new CuiElement
            {
                Name = "TT",
                Parent = "MTUI",
                Components = {
                    new CuiTextComponent { Text = "List Of Cassettes", FontSize = 12, Align = TextAnchor.MiddleCenter },
                    new CuiOutlineComponent { Color = "0 0 0 1", Distance = "1 1" },
                    new CuiRectTransformComponent { AnchorMin = "0 1", AnchorMax = "1 1", OffsetMin = "0 -28",OffsetMax = "-18 0" },
                }
            });
            //Create X button
            container.Add(new CuiButton
            {
                Button = { Color = ".5 .2 .2 1", Close = "MTUI" },
                Text = { Text = "X", Font = "droidsansmono.ttf", FontSize = 11, Align = TextAnchor.MiddleCenter },
                RectTransform = { AnchorMin = ".92 .965", AnchorMax = ".98 1" }
            }, "MTUI", "CloseBttn");
            //Create Elements inside Scroll view
            foreach (var data in Clean)
            {
                //Create bar and adjusted position
                offset -= 100;
                string name = offset.ToString();
                container.Add(new CuiElement
                {
                    Name = name,
                    Parent = "SB",
                    Components = {
                        new CuiRawImageComponent{
                        Sprite = "assets/content/effects/crossbreed/fx gradient skewed.png",
                        Color = ".2 .2 .2 .4",},
                        new CuiRectTransformComponent { AnchorMin = ".05 .97", AnchorMax = ".95 .97", OffsetMin = "0 " + (offset - 99).ToString(), OffsetMax = "0 " + name},
                        }
                });
                //Create Icon
                container.Add(new CuiElement
                {
                    Name = "2SIcon" + name,
                    Parent = name,
                    Components = {
                    new CuiImageComponent { Color = "1 1 1 1", ItemId = 476066818 },
                    new CuiOutlineComponent { Color = "0 0 0 .5", Distance = "1 -1" },
                    new CuiRectTransformComponent { AnchorMin = ".1 0", AnchorMax = ".9 1" },
                }
                });
                //Create Button On Icon
                container.Add(new CuiButton
                {
                    Button = { Color = "1 1 1 1", Command = ("SGUI R " + data.ID + " _ " + CUICheckSum) },
                    Text = { Text = "Remove Cassette", FontSize = 10, Align = TextAnchor.MiddleCenter, Color = "0 0 0 1" },
                    RectTransform = { AnchorMin = "0 0", AnchorMax = "1 .15", }
                }, "2SIcon" + name, "_" + name);
                //Create Info Text On Icon
                container.Add(new CuiElement
                {
                    Name = "i_" + name,
                    Parent = "2SIcon" + name,
                    Components = {
                    new CuiTextComponent { Text = data.title, FontSize = 8, Align = TextAnchor.MiddleLeft, Color = "1 1 1 1" },
                    new CuiOutlineComponent { Color = "0 0 0 .5", Distance = "1 -1" },
                    new CuiRectTransformComponent { AnchorMin = "0 .8", AnchorMax = "1 1" }
                }
                });
            }
            Facepunch.Pool.FreeUnmanaged(ref Clean);
            //Store and Show
            return container;
        }
        #endregion

        #region Methods
        //Precompiled, fully anchored URL check. Must start->end match a plausible http(s) URL with no
        //whitespace/quote/backtick characters, so it can't smuggle extra command-line arguments.
        private static readonly Regex ValidUrlRegex = new Regex(
            @"^https?://[^\s""'`|;&<>]+\.[a-zA-Z]{2,}[^\s""'`|;&<>]*$",
            RegexOptions.IgnoreCase | RegexOptions.Compiled);
        private bool isValidURL(string URL) { return !string.IsNullOrWhiteSpace(URL) && ValidUrlRegex.IsMatch(URL); }

        //Extra guard used immediately before a URL is handed to yt-dlp/ffmpeg as a command-line
        //argument. A URL that starts with '-' can be parsed as a flag (e.g. yt-dlp's --exec) instead
        //of a URL, which would let a player run arbitrary commands on the host. Reject that and any
        //other shell/argument-breaking characters even though isValidURL already excludes them.
        private bool IsSafeProcessArgument(string value)
        {
            if (string.IsNullOrWhiteSpace(value) || value.StartsWith("-")) { return false; }
            foreach (char c in value) { if (char.IsWhiteSpace(c) || c == '"' || c == '\'' || c == '`' || c == '|' || c == ';' || c == '&' || c == '<' || c == '>') { return false; } }
            return true;
        }

        //Create random string used to prevent CUI hacking. This token gates a console command that
        //executes server-side actions from a client button press, so it needs to be unguessable -
        //use a cryptographic RNG rather than System.Random.
        public string RandomString(int length)
        {
            const string chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789";
            var bytes = new byte[length];
            using (var rng = System.Security.Cryptography.RandomNumberGenerator.Create()) { rng.GetBytes(bytes); }
            var result = new char[length];
            for (int i = 0; i < length; i++) { result[i] = chars[bytes[i] % chars.Length]; }
            return new string(result);
        }

        //Check if its a youtube url and strip useless info off.
        private void YouTubeTapes(BasePlayer player, string url)
        {
            if (url.Contains("&list=")) { url = url.Split(new string[] { "&list=" }, StringSplitOptions.None)[0]; }

            //Reject anything that isn't a clean http(s) URL before it ever reaches a child process -
            //this is what actually stops argument injection, the CUI button check is only cosmetic.
            if (!isValidURL(url) || !IsSafeProcessArgument(url))
            {
                if (player != null) { player.ChatMessage("<color=red>Invalid URL.</color>"); }
                return;
            }

            TapeQueue tapeQueue = new TapeQueue();
            tapeQueue.Player = player;
            tapeQueue.Url = url;
            lock (_queueLock) { _queue.Add(tapeQueue); }
            if (_queuechecker == null) { _queuechecker = ServerMgr.Instance.StartCoroutine(QueueChecker()); }
            return;
        }

        //Break up length into parts
        private int[] DistributeIntoGroups(float sum, int maxlength)
        {
            int[] groups = new int[(int)Math.Ceiling((sum / maxlength))];
            for (int i = 0; i < groups.Length; i++) { groups[i] = i * maxlength; }
            return groups;
        }

        //Get length of audio ogg
        private float GetOggLength(byte[] t)
        {
            long num1 = -1L;
            for (int i = t.Length - 1 - 8 - 2 - 4; i >= 0; i--) { if (t[i] == 79 && t[i + 1] == 103 && t[i + 2] == 103 && t[i + 3] == 83) { num1 = BitConverter.ToInt64(new byte[] { t[i + 6], t[i + 7], t[i + 8], t[i + 9], t[i + 10], t[i + 11], t[i + 12], t[i + 13] }, 0); break; } }
            int num2 = -1;
            for (int j = 0; j < t.Length - 8 - 2 - 4; j++) { if (t[j] == 118 && t[j + 1] == 111 && t[j + 2] == 114 && t[j + 3] == 98 && t[j + 4] == 105 && t[j + 5] == 115) { num2 = BitConverter.ToInt32(new byte[] { t[j + 11], t[j + 12], t[j + 13], t[j + 14] }, 0); break; } }
            //Header not found or malformed - don't return a bogus/negative length
            if (num1 <= 0 || num2 <= 0) { return 0; }
            return num1 / num2;
        }

        //Get the number of cassettes a player has already created.
        private int NumberOfCassettes(ulong UserID)
        {
            int num = 0;
            //Check cassettes in config
            foreach (var c in config.CustomCassettes)
            {
                if (c.ownerid == UserID) { num++; }
            }
            //Check if player has them queued up
            lock (_queueLock) { foreach (var c in _queue) { if (c?.Player?.userID == UserID) { num++; } } }
            return num;
        }

        //Check if player on cool down
        private bool OnCoolDown(BasePlayer player, bool remove = false)
        {
            if (cooldowns.ContainsKey(player.userID))
            {
                if (cooldowns[player.userID] + ((remove) ? config.TapeCooldown : config.Cooldown) > Time.time)
                {
                    player.ChatMessage("<color=red>Command on cooldown. (" + ((cooldowns[player.userID] + config.Cooldown) - Time.time).ToString() + ")</color>");
                    return true;
                }
            }
            return false;
        }

        //Run console/terminal commands
        public Process runCommand(string bin, string opts)
        {
            if (config.debug) { Puts($"{bin} args: {opts}"); }
            Process process = new Process();
            if (!string.IsNullOrEmpty(bin))
            {
                try
                {
                    process.StartInfo = new ProcessStartInfo
                    {
                        WindowStyle = ProcessWindowStyle.Hidden,
                        FileName = bin,
                        Arguments = opts,
                        UseShellExecute = false,
                        RedirectStandardError = true,
                        RedirectStandardInput = true,
                        RedirectStandardOutput = true,
                        CreateNoWindow = true
                    };
                    process.EnableRaisingEvents = false;
                }
                catch (Exception value) { Puts(value.ToString()); }
            }
            return process;
        }

        //Adjust folder permission for Linux OS to allow temp files to write
        public void SetPermissions(string path, string permissions)
        {
            if (!File.Exists(path) && !Directory.Exists(path))
            {
                Puts($"The path '{path}' does not exist.");
                return;
            }
            ProcessStartInfo psi = new ProcessStartInfo
            {
                FileName = "chmod",
                Arguments = $"{permissions} \"{path}\"",
                RedirectStandardOutput = true,
                RedirectStandardError = true,
                UseShellExecute = false,
                CreateNoWindow = true
            };
            using (Process process = Process.Start(psi))
            {
                if (process != null)
                {
                    string output = process.StandardOutput.ReadToEnd();
                    string error = process.StandardError.ReadToEnd();
                    process.WaitForExit();
                    if (process.ExitCode != 0)
                    {
                        Puts($"chmod failed with error: {error}");
                        return;
                    }
                    Puts($"chmod output: {output}");
                }
            }
        }

        //Find boombox thats being held or looked at
        private BaseEntity FindBoomBox(BasePlayer player)
        {
            if (player.IsHoldingEntity<HeldBoomBox>()) { return player?.GetActiveItem()?.GetHeldEntity(); }
            //Check player has building perm to stop changing other bases deployed boomboxes
            if (!player.CanPlaceBuildingPrivilege() && !player.IsAdmin) { player.ChatMessage("<color=red>You don't have building permission.</color>"); return null; }
            //Check what player is looking at
            RaycastHit rhit;
            if (Physics.Raycast(player.eyes.HeadRay(), out rhit))
            {
                var baseEntity = rhit.GetEntity();
                if (baseEntity != null && rhit.distance < 5f && baseEntity is DeployableBoomBox) { return baseEntity; }
            }
            player.ChatMessage("<color=red>Couldn't find boombox deployed or held.</color>");
            return null;
        }

        //Check for missing tapes since one missing tape will break the whole lot
        public void CleanUpMissingTapes()
        {
            if (config.AutoClean)
            {
                for (int i = config.CustomCassettes.Count - 1; i >= 0; i--)
                {
                    bool missing = false;
                    foreach (uint u in config.CustomCassettes[i].netids)
                    {
                        BaseNetworkable bn = BaseNetworkable.serverEntities.Find(new NetworkableId(u));
                        if (bn == null)
                        {
                            missing = true;
                            break;
                        }
                    }
                    if (missing)
                    {
                        //Remove set if one is missing
                        Puts("Missing Cassettes detected " + config.CustomCassettes[i].title);
                        ServerMgr.Instance.StartCoroutine(RemoveCassettes(null, config.CustomCassettes[i].ID));
                    }
                }
            }
        }

        //Check player cool down to prevent command spam
        private void cooldown(BasePlayer player, string url)
        {
            if (player != null)
            {
                if (config.debug) { Puts(player.displayName + " Played: " + url); }
                if (cooldowns.ContainsKey(player.userID)) { cooldowns[player.userID] = Time.time; }
                else { cooldowns.Add(player.userID, Time.time); }
            }
        }

        //Directly set audio player for API calls
        public void ManuallySetRadio(BaseEntity be, string url)
        {
            if (be != null && (be is HeldBoomBox || be is DeployableBoomBox))
            {
                //Set Mp3 Link
                if (be is HeldBoomBox) { ChangeStationPortable(be as HeldBoomBox, url); }
                if (be is DeployableBoomBox) { ChangeStationDeployed(be as DeployableBoomBox, url); }
                if (config.debug) { Puts("Server played " + url); }
            }
        }

        //Adjust mp3 link on held boombox
        private void ChangeStationPortable(HeldBoomBox portableradio, string newlink, BasePlayer player = null)
        {
            portableradio.BoxController.CurrentRadioIp = newlink;
            portableradio.BoxController.ServerTogglePlay(false);
            portableradio.BoxController.BaseEntity.ClientRPC(RpcTarget.NetworkGroup("OnRadioIPChanged"), portableradio.BoxController.CurrentRadioIp);
            portableradio.BoxController.ServerTogglePlay(true);
            cooldown(player, newlink);
            if (config.debug) { Puts("Playing Custom Station"); }
        }

        //Adjust mp3 link on deployed boombox
        private void ChangeStationDeployed(DeployableBoomBox radio, string newlink, BasePlayer player = null)
        {
            radio.BoxController.CurrentRadioIp = newlink;
            radio.BoxController.BaseEntity.ClientRPC(RpcTarget.NetworkGroup("OnRadioIPChanged"), radio.BoxController.CurrentRadioIp);
            radio.BoxController.ServerTogglePlay(true);
            cooldown(player, newlink);
            if (config.debug) { Puts("Playing Custom Station"); }
        }

        //Write info to cassette
        public Cassette SetCassette(string title, byte[] data, BasePlayer player, float length, ref Item item)
        {
            Cassette cassetteEntity;
            if ((cassetteEntity = (BaseNetworkable.serverEntities.Find(item.instanceData.subEntity) as Cassette)) != null)
            {
                //cassetteEntity.ClearContent();
                item.text = title;
                ulong UserID = 0;
                if (player != null) { UserID = player.userID; }
                cassetteEntity.CreatorSteamId = UserID;
                cassetteEntity.MaxCassetteLength = length;
                //Store data in file database
                cassetteEntity.SetAudioId(FileStorage.server.Store(data, FileStorage.Type.ogg, cassetteEntity.net.ID, 0U), UserID);
                cassetteEntity.skinID = item.skin;
            }
            return cassetteEntity;
        }

        //Update entity with changes
        public void UpdateEntity(BaseEntity entity, Cassette newcassette, Item newcassetteitem)
        {
            if (entity != null && newcassette != null)
            {
                if (entity is DeployedRecorder)
                {
                    if (newcassetteitem != null) { newcassetteitem.MoveToContainer((entity as DeployedRecorder).inventory); }
                    DeployedRecorder(newcassette, entity as DeployedRecorder);
                    return;
                }
                if (entity is DeployableBoomBox)
                {
                    if (newcassetteitem != null) { newcassetteitem.MoveToContainer((entity as DeployableBoomBox).inventory); }
                    BoomBox(newcassette, (entity as DeployableBoomBox).BoxController);
                    return;
                }
            }
        }

        //Play tape on Deployed recorder
        public bool DeployedRecorder(Cassette c, DeployedRecorder baseentity)
        {
            if (!baseentity || c.skinID == 3367283489) { return false; } //Dont play grey tapes
            //Stop anr existing play threads
            if (TapeThreads.ContainsKey(baseentity))
            {
                if (TapeThreads[baseentity] != null) { ServerMgr.Instance.StopCoroutine(TapeThreads[baseentity]); }
                TapeThreads.Remove(baseentity);
            }
            //Find first tape in list
            var results = config.CustomCassettes.Where(x => x.netids.Contains(c.net.ID.Value));
            if (results == null || results.Count() == 0) { return true; }
            baseentity.SetFlagLocal(BaseEntity.Flags.On, true, false);
            TapeThreads.Add(baseentity, ServerMgr.Instance.StartCoroutine(CycleTapes(baseentity, results.SingleOrDefault())));
            return false;
        }

        //Play tape in boombox
        public bool BoomBox(Cassette c, BoomBox baseentity)
        {
            if (!baseentity || c.skinID == 3367283489) { return false; } //Dont play grey tapes
            //Stop any existing play threads
            if (TapeThreads.ContainsKey(baseentity.BaseEntity))
            {
                if (TapeThreads[baseentity.BaseEntity] != null) { ServerMgr.Instance.StopCoroutine(TapeThreads[baseentity.BaseEntity]); }
                TapeThreads.Remove(baseentity.BaseEntity);
            }
            //Find first tape in list
            var results = config.CustomCassettes.Where(x => x.netids.Contains(c.net.ID.Value));
            if (results == null || results.Count() == 0) { return true; }
            baseentity.ServerTogglePlay(true);
            TapeThreads.Add(baseentity.BaseEntity, ServerMgr.Instance.StartCoroutine(CycleTapes(baseentity.BaseEntity, results.SingleOrDefault())));
            return false;
        }

        public void UpdateSpeakers(IOEntity ioentity)
        {
            if (ioentity != null)
            {
                //Update all connected Speakers
                IOEntity NextIOEnt = ioentity?.outputs[0]?.connectedTo?.Get();
                int depth = 0;
                List<ConnectedSpeaker> Speakers = Facepunch.Pool.Get<List<ConnectedSpeaker>>();
                Speakers.Clear(); //Make sure isnt dirty from delay
                while (NextIOEnt != null && depth < 90) //Max power out of boombox is 90 so that should be max connected
                {
                    depth++;
                    if (NextIOEnt is ConnectedSpeaker)
                    {
                        //Stop speaker playing to clear audio from it
                        NextIOEnt.ClientRPC(RpcTarget.NetworkGroup("Client_StopPlayingAudio"), ioentity.net.ID);
                        NextIOEnt.SendNetworkUpdateImmediate();
                        Speakers.Add(NextIOEnt as ConnectedSpeaker);
                    }
                    NextIOEnt = NextIOEnt?.outputs[0]?.connectedTo?.Get(); //Get next IO in the path
                }
                ioentity.SendNetworkUpdateImmediate();
                ioentity.Invoke(() =>
                {
                    if (Speakers != null && ioentity != null)
                    {
                        //Start speaker again
                        foreach (ConnectedSpeaker speaker in Speakers)
                        {
                            speaker.ClientRPC(RpcTarget.NetworkGroup("Client_PlayAudioFrom"), ioentity.net.ID);
                            speaker.SendNetworkUpdateImmediate();
                        }
                    }
                    Facepunch.Pool.FreeUnmanaged(ref Speakers);
                }, 0.03125f);
            }
        }
        #endregion

        #region Coroutines
        public IEnumerator RemoveCassettes(BasePlayer player, ulong index, bool RefreshCUI = false, string url = null)
        {
            for (int i = config.CustomCassettes.Count - 1; i >= 0; i--)
            {
                //Player null must be from plugin, Other wise limit to players own cassets or all cassettes if admin
                if (player == null || (player != null && player.IsAdmin || config.CustomCassettes[i].ownerid == player?.userID))
                {
                    if (config.CustomCassettes[i].ID == index)
                    {
                        //Free File Store Memory
                        for (int c = config.CustomCassettes[i].netids.Count - 1; c >= 0; c--)
                        {
                            try { FileStorage.server.Remove(config.CustomCassettes[i].crc[c], FileStorage.Type.ogg, new NetworkableId(config.CustomCassettes[i].netids[c])); } catch { }
                        }
                        //Remove from players inventory
                        foreach (BasePlayer p in BasePlayer.allPlayerList)
                        {

                            List<Item> items = Facepunch.Pool.Get<List<Item>>();
                            try
                            {
                                p.inventory.GetAllItems(items);
                                if (items != null && items.Count > 0) for (int j = 0; j < items.Count; j++) { try { if (config.CustomCassettes[i].netids != null) if (config.CustomCassettes[i].netids.Contains(items[j].instanceData.subEntity.Value)) { items[j].Remove(); } } catch { } }
                                //Check backpack
                                if (p.inventory.HasBackpackItem())
                                {
                                    Item anyBackpack = p.inventory.GetAnyBackpack();
                                    if (anyBackpack.contents.itemList != null && anyBackpack.contents.itemList.Count > 0) for (int j = 0; j < anyBackpack.contents.itemList.Count; j++) { try { if (config.CustomCassettes[i].netids != null) if (config.CustomCassettes[i].netids.Contains(anyBackpack.contents.itemList[j].instanceData.subEntity.Value)) { anyBackpack.contents.itemList[j].Remove(); } } catch { } }
                                }
                            }
                            catch { }
                            Facepunch.Pool.FreeUnmanaged(ref items);
                        }
                        //Search all server ents
                        int entloops = 0;
                        foreach (var bn in BaseNetworkable.serverEntities?.entityList?.Get())
                        {
                            if (bn.Value == null) { continue; }
                            entloops++;
                            //Return thread every 10000 ents checked to prevent thread lock
                            if (entloops > 10000)
                            {
                                entloops = 0;
                                yield return CoroutineEx.waitForSeconds(0.0366f);
                            }
                            //Remove dropped cassettes
                            if (bn.Value is DroppedItem)
                            {
                                var item = (bn.Value as DroppedItem)?.item ?? null;
                                if (item == null) { continue; }
                                try { if (config.CustomCassettes[i].netids != null && config.CustomCassettes[i].netids.Contains(item.instanceData.subEntity.Value)) { item.Remove(); } } catch { }
                                continue;
                            }
                            //Check all containers for cassettes to remove
                            if (bn.Value is StorageContainer)
                            {
                                var container = (bn.Value as StorageContainer)?.inventory?.itemList ?? null;
                                if (container == null) { continue; }
                                for (int j = 0; j < container.Count; j++)
                                {
                                    try { if (config.CustomCassettes[i].netids != null) if (config.CustomCassettes[i].netids.Contains(container[j].instanceData.subEntity.Value)) { container[j].Remove(); } } catch { }
                                }
                                continue;
                            }
                            //Check audio players for cassettes to remove
                            if (bn.Value is DeployableBoomBox || bn.Value is DeployedRecorder || bn.Value is HeldBoomBox)
                            {
                                var container = (bn.Value as DeployableBoomBox)?.inventory?.itemList ?? null;
                                if (container == null) { container = (bn.Value as DeployedRecorder)?.inventory?.itemList ?? null; }
                                if (container == null) { container = (bn.Value as HeldBoomBox)?.GetItem()?.contents?.itemList; }
                                if (container == null) { continue; }
                                for (int j = 0; j < container.Count; j++)
                                {
                                    try { if (config.CustomCassettes[i].netids != null) if (config.CustomCassettes[i].netids.Contains(container[j].instanceData.subEntity.Value)) { container[j].Remove(); } } catch { }
                                }
                                continue;
                            }
                            //Remove from ent list
                            if (config.CustomCassettes[i].netids.Contains(bn.Value.net.ID.Value)) { bn.Value.Kill(); }
                        }
                        string title = config?.CustomCassettes[i]?.title;
                        ItemManager.DoRemoves();
                        if (config?.CustomCassettes[i] != null)
                        {
                            config.CustomCassettes.RemoveAt(i);
                            Config.WriteObject(config, true);
                        }
                        try
                        {
                            if (player != null)
                            {
                                player.ConsoleMessage("Removed: " + title);
                                player.ChatMessage("Removed: " + title);
                                if (RefreshCUI)
                                {
                                    CuiHelper.AddUi(player, RustUI(player, 0, url, CUICheckSum));
                                    CuiHelper.AddUi(player, CassetteListUI(player, CUICheckSum));
                                }
                            }
                            else { Puts("Removed: " + title); }
                        }
                        catch { }
                        yield break;
                    }
                }
            }
            yield break;
        }

        //Queue to limit to one user at a time
        public IEnumerator QueueChecker()
        {
            int timeout = 0;
            int messager = 0;
            while (true)
            {
                int count;
                lock (_queueLock) { count = _queue.Count; }
                if (count == 0) { break; } //Nothing left in queue

                if (timeout > config.TimeOut) //Timeout
                {
                    timeout = 0;
                    lock (_queueLock) { if (_queue.Count > 0) { _queue.RemoveAt(0); } }
                }
                else
                {
                    TapeQueue tapeQueue;
                    lock (_queueLock) { tapeQueue = _queue.Count > 0 ? _queue[0] : null; }
                    if (tapeQueue == null) { messager++; timeout++; yield return new WaitForSeconds(1); continue; }
                    switch (tapeQueue.Status)
                    {
                        case 0: //Idle
                            timeout = 0;
                            tapeQueue.Status = 1;
                            ServerMgr.Instance.StartCoroutine(MediaInfo(tapeQueue));
                            break;
                        case 1: //Getting Youtube Info
                            break;
                        case 2: //Got Info, Download and reset timeout
                            timeout = 0;
                            tapeQueue.Status = 3;
                            break;
                        case 3: //Downloading
                            break;
                        case 4: //Downloaded, Encode and reset timeout
                            timeout = 0;
                            tapeQueue.Status = 5;
                            break;
                        case 5: //Encoding
                            break;
                        case 6: //Done Remove From Queue
                            lock (_queueLock) { _queue.Remove(tapeQueue); }
                            break;
                    }
                    if (messager > config.MessageTimeout) //Message Waiting Players
                    {
                        lock (_queueLock)
                        {
                            if (_queue.Count > 1)
                            {
                                for (int i = 1; i < _queue.Count; i++)
                                {
                                    if (_queue[i].Player != null) { _queue[i].Player.ConsoleMessage("You are " + i + " / " + _queue.Count + " in download queue"); }
                                }
                            }
                        }
                        messager = 0;
                    }
                }
                messager++;
                timeout++;
                yield return new WaitForSeconds(1);
            }
            _queuechecker = null;
        }

        //Download Youtube video info
        public IEnumerator MediaInfo(TapeQueue tapeQueue)
        {
            MediaInfoData info = null;
            if (tapeQueue.Player != null)
            {
                tapeQueue.Player.ChatMessage("<color=red>Getting YouTube audio check F1 for more details.</color>");
                tapeQueue.Player.ConsoleMessage(VersionString);
                tapeQueue.Player.ConsoleMessage("Waiting For Youtube Info...");
            }
            //Run in thread to prevent thread locking since can be slow waiting on youtube
            Task task = Task.Run(() =>
            {
                var process = codebase.runCommand(Path.Combine(installPath, YouTubeDL.binName), (config.PublicCookies ? "--cookies " + Path.Combine(installPath, "cookies.txt") + " " : !string.IsNullOrEmpty(config.CookiesPath) ? "--cookies " + config.CookiesPath + " " : "") + "-s --no-warnings --no-cache-dir --remote-components ejs:github --print-json " + tapeQueue.Url);
                process.Start();
                process.PriorityClass = ProcessPriorityClass.Idle;
                string json = process.StandardOutput.ReadToEnd();
                if (json.Contains("ERROR: [youtube]"))
                {
                    if (tapeQueue.Player != null)
                    {
                        tapeQueue.Player.ConsoleMessage(json);
                        tapeQueue.Player.ChatMessage("<color=red>Failed To Download Youtube Info</color>");
                    }
                    lock (_queueLock) { _queue.Remove(tapeQueue); }
                    return;
                }
                info = JsonConvert.DeserializeObject<MediaInfoData>(json);
                if (string.IsNullOrEmpty(info?.title))
                {
                    if (tapeQueue.Player != null)
                    {
                        tapeQueue.Player.ConsoleMessage("Failed To Download Youtube Info");
                        tapeQueue.Player.ChatMessage("<color=red>Failed To Download Youtube Info</color>");
                    }
                    lock (_queueLock) { _queue.Remove(tapeQueue); }
                    return;
                }
                //Check info doesnt list as longer then configs max duration
                double durationParsed;
                if (!double.TryParse(info.duration, System.Globalization.NumberStyles.Float, System.Globalization.CultureInfo.InvariantCulture, out durationParsed))
                {
                    if (tapeQueue.Player != null)
                    {
                        tapeQueue.Player.ConsoleMessage("Could not determine video length (unsupported/live video?)");
                        tapeQueue.Player.ChatMessage("<color=red>Could not determine video length.</color>");
                    }
                    lock (_queueLock) { _queue.Remove(tapeQueue); }
                    return;
                }
                int duration = (int)durationParsed;
                if (duration > config.MaxVideoLength)
                {
                    if (tapeQueue.Player != null)
                    {
                        string err = "File length too long [" + info.duration + "/" + config.MaxVideoLength + "]";
                        tapeQueue.Player.ConsoleMessage(err);
                        tapeQueue.Player.ChatMessage(err);
                    }
                    lock (_queueLock) { _queue.Remove(tapeQueue); }
                    return;
                }
                if (tapeQueue.Player != null)
                {
                    string msg = "Downloading: " + info.title + " [" + duration + "s]";
                    tapeQueue.Player.ChatMessage(msg);
                    tapeQueue.Player.ConsoleMessage(msg);
                    cooldown(tapeQueue.Player, tapeQueue.Url);
                }
                process = runCommand(Path.Combine(installPath, YouTubeDL.binName), YouTubeDL.DefaultArgs(installPath) + (config.UseExtraArgs ? config.ExtraArgs : "") + tapeQueue.Url);
                YT_DLP.Add(ServerMgr.Instance.StartCoroutine(MakeCassette(process, tapeQueue, null, info)));
            });
            yield break;
        }

        //Switch tape to next one in the list on completion of a tape
        public IEnumerator CycleTapes(BaseEntity cassetplayer, CassetteParts parts)
        {
            int track = 0;
            while (cassetplayer.HasFlag(BaseEntity.Flags.On))
            {
                if (track == parts.netids.Count) { track = 0; }
                var cid = new NetworkableId(parts.netids[track]);
                cassetplayer.ClientRPC(RpcTarget.NetworkGroup("Client_OnCassetteInserted"), cid);
                cassetplayer.SendNetworkUpdate(BasePlayer.NetworkQueue.Update);
                cassetplayer.Invoke(() => { UpdateSpeakers(cassetplayer as IOEntity); }, 0.03125f);
                yield return CoroutineEx.waitForSeconds(parts.lengths[track++]);
            }
        }

        //Create multiple tapes from a single audio file
        public IEnumerator EncodeChapter(Item Cassette, float playlength, string source, TapeQueue tapeQueue, BaseEntity entity, MediaInfoData mediaInfo)
        {
            bool parent = true;
            CassetteParts newcassette = new CassetteParts();
            newcassette.title = mediaInfo.title;
            if (tapeQueue != null) { tapeQueue.Player.ConsoleMessage("Encoding " + mediaInfo.title); }
            //Split into parts upto 30 sec each
            int[] Chapters = DistributeIntoGroups(playlength, config.cassetlength);
            Item newcassetteitem = null;
            Cassette newServercassette = null;
            for (int i = 0; i < Chapters.Length; i++)
            {
                tapeQueue.Status = 4;
                if (tapeQueue != null) { tapeQueue.Player.ConsoleMessage("[encoding] " + (i + 1) + " / " + Chapters.Length); }
                //Run FFMPEG to split into parts
                string filename = source.Replace(".ogg", "." + i.ToString() + ".ogg");
                Process process = FFmpeg.run("-nostdin -hide_banner -ss " + Chapters[i].ToString() + " -t " + config.cassetlength + @" -i """ + source + @""" """ + filename + @"""");
                process.Start();
                process.PriorityClass = ProcessPriorityClass.Idle;
                Task.Run(() =>
                {
                    try { while (!process.StandardOutput.EndOfStream) { process.StandardOutput.ReadLine(); } }
                    catch { }
                });
                while (!process.StandardError.EndOfStream)
                {
                    //Small wait for disk IO
                    yield return CoroutineEx.waitForSeconds(0.003f);
                    string console = process.StandardError.ReadLine();
                    if (config.debug) { Puts(console); }
                    //FFMPEG Conversion Done
                    if (console.Contains("video:"))
                    {
                        //Wait for IO to write to disk
                        yield return CoroutineEx.waitForSeconds(0.25f);
                        if (File.Exists(filename))
                        {
                            //Found split part of audio on disk, Write it to cassette
                            byte[] oggfile = File.ReadAllBytes(filename);
                            float sectionlength = 0;
                            Task task = Task.Run(() => { sectionlength = GetOggLength(oggfile); });
                            //Wait for getting ogg length with out locking thread
                            while (!task.IsCompleted) { yield return CoroutineEx.waitForSeconds(0.01f); }
                            if (parent) { newcassetteitem = Cassette; }
                            else { newcassetteitem = ItemManager.Create(ItemManager.FindItemDefinition("cassette"), 1, 3367283489); } //Skin as grey tape
                            newServercassette = SetCassette(mediaInfo.title, oggfile, tapeQueue.Player, sectionlength, ref newcassetteitem);
                            if (!parent) { if (tapeQueue != null) { tapeQueue.Player.GiveItem(newcassetteitem, BaseEntity.GiveItemReason.Crafted); } }
                            else { parent = false; }
                            newcassette.crc.Add(newServercassette.AudioId);
                            newcassette.netids.Add(newcassetteitem.instanceData.subEntity.Value);
                            newcassette.lengths.Add((int)sectionlength);
                            File.Delete(filename); //Remove temp part file
                            continue;
                        }
                    }
                }
            }
            //Setup custom cassette and give to player
            newcassette.ID = newServercassette.net.ID.Value;
            if (tapeQueue != null)
            {
                newcassette.ownerid = tapeQueue.Player.userID;
                tapeQueue.Player.GiveItem(Cassette, BaseEntity.GiveItemReason.Crafted);
            }
            config.CustomCassettes.Add(newcassette);
            Config.WriteObject(config, true);
            UpdateEntity(entity, newServercassette, newcassetteitem);
            if (tapeQueue != null) { tapeQueue.Status = 6; }
            File.Delete(source); //Remove Source file
            yield break;
        }

        public IEnumerator MakeCassette(Process process, TapeQueue tapeQueue, BaseEntity entity = null, MediaInfoData mediaInfo = null)
        {
            tapeQueue.Status = 2;
            Task task = Task.Run(() =>
            {
                //Create default item to use as main tape
                Item DefaultCassette = ItemManager.Create(ItemManager.FindItemDefinition("cassette"), 1, 0);
                //Start Youtube Downloader 
                process.Start();
                //Set as lowest priority so doesnt effect rust server
                process.PriorityClass = ProcessPriorityClass.Idle;
                //Drain stderr on its own thread - if nobody reads it, the OS pipe buffer fills up once
                //yt-dlp writes enough warnings/notices there, and yt-dlp then blocks trying to write to
                //it, silently stalling the whole process (including stdout). This is what causes
                //downloads to appear to hang with no further output.
                Task.Run(() =>
                {
                    try
                    {
                        while (!process.StandardError.EndOfStream)
                        {
                            string errLine = process.StandardError.ReadLine();
                            if (config.debug && !string.IsNullOrEmpty(errLine)) { Puts("[yt-dlp stderr] " + errLine); }
                        }
                    }
                    catch { }
                });
                //Loop until has all downloaded data
                while (!process.StandardOutput.EndOfStream)
                {
                    //Read console output
                    string console = process.StandardOutput.ReadLine();
                    if (config.debug) { Puts(console); }
                    //Gotten info on download, update console
                    if (console.Contains("[download]"))
                    {
                        if (tapeQueue != null && !console.Contains("Destination")) { tapeQueue.Player.ConsoleMessage(console); }
                        continue;
                    }
                    //Temp file full download and converted, Start converting to tapes
                    if (console.Contains("Deleting original file"))
                    {
                        string filename = console.Replace("Deleting original file ", "").Replace(".webm (pass -k to keep)", ".ogg").Replace(".m4a (pass -k to keep)", ".ogg").Replace(@"\", @"\\");
                        if (config.debug) { Puts("File Name: " + filename); }
                        if (File.Exists(filename))
                        {
                            if (config.debug) { Puts("Found File: " + filename); }
                            byte[] oggfile = null;
                            float playlength = 0;
                            //Read data out of temp folder
                            oggfile = File.ReadAllBytes(filename); playlength = GetOggLength(oggfile);
                            if (config.debug) { Puts("Play Length: " + playlength); }
                            if (playlength > config.cassetlength)
                            {
                                //Split up into parts
                                YT_DLP.Add(ServerMgr.Instance.StartCoroutine(EncodeChapter(DefaultCassette, playlength, Path.Combine(Environment.CurrentDirectory, filename), tapeQueue, entity, mediaInfo)));
                                break;
                            }
                            tapeQueue.Status = 4;
                            //Smaller then 30sec so single tape
                            CassetteParts newcassette = new CassetteParts();
                            newcassette.title = mediaInfo.title;
                            Cassette newServercassette = SetCassette(filename, oggfile, tapeQueue?.Player, playlength, ref DefaultCassette);
                            if (tapeQueue != null) { tapeQueue.Player.GiveItem(DefaultCassette, BaseEntity.GiveItemReason.Crafted); }
                            if (config.debug) { Puts("Cassette Created: " + newcassette.ToString() + " Deleting download."); }
                            newcassette.crc.Add(newServercassette.AudioId);
                            newcassette.netids.Add(newServercassette.net.ID.Value);
                            newcassette.lengths.Add((int)playlength);
                            newcassette.ID = newServercassette.net.ID.Value;
                            config.CustomCassettes.Add(newcassette);
                            Config.WriteObject(config, true);
                            UpdateEntity(entity, newServercassette, DefaultCassette);
                            if (tapeQueue != null) { tapeQueue.Status = 6; }
                            File.Delete(filename);
                            break;
                        }
                    }
                }
            });
            yield break;
        }
        #endregion

        #region Classes
        internal class YouTubeDL
        {
            public static string binName;
            public static string downloadURL;

            //Args to extra youtube audio
            public static string DefaultArgs(string path) { return (codebase.config.PublicCookies ? "--cookies " + Path.Combine(codebase.installPath, "cookies.txt") + " " : !string.IsNullOrEmpty(codebase.config.CookiesPath) ? "--cookies " + codebase.config.CookiesPath + " " : "") + @"-x --audio-format vorbis --audio-quality 10 --postprocessor-args ""-ac 1"" --restrict-filenames --remote-components ejs:github -o " + Path.Combine(path, "dl", @"%(title)s.%(id)s.%(ext)s") + @" --ffmpeg-location """ + path + @""" "; }
            public static bool isInstalled() { return File.Exists(Path.Combine(codebase.installPath, binName)); } //Check if installed by if files exsist
            public static void checkDownload() { if (!isInstalled()) { downloadAndInstall(); } } //Check if need to download
            public static void downloadAndInstall()
            {
                //Create folder if missing
                if (!File.Exists(Path.Combine(codebase.installPath, binName)))
                {
                    if (!Directory.Exists(codebase.installPath)) { Directory.CreateDirectory(codebase.installPath); }
                    try { using (WebClient wc = new WebClient()) { wc.DownloadFile(new Uri(downloadURL), Path.Combine(codebase.installPath, binName)); } }
                    catch (Exception ex) { codebase.Puts("Failed to download yt-dlp: " + ex.Message); return; }
                }
                //Set up permission on Linux
                if (codebase.Linux)
                {
                    codebase.Puts("Setting YouTubeDL Permissions");
                    codebase.SetPermissions(Path.Combine(codebase.installPath, binName), "777");
                }
            }

            //Check if latest version
            //Re-downloads the latest yt-dlp release and reports if the version changed. yt-dlp ships
            //frequent fixes for YouTube site changes, so the binary needs to actually be refreshed -
            //previously this only compared the already-installed binary's version to itself and never
            //fetched anything new, so it silently went stale after first install.
            public static void checkForUpdates()
            {
                if (!isInstalled()) { return; }
                string lastVersionYouTubeDL = codebase.config.lastVersionYouTubeDL;
                try
                {
                    using (WebClient wc = new WebClient()) { wc.DownloadFile(new Uri(downloadURL), Path.Combine(codebase.installPath, binName)); }
                }
                catch (Exception ex)
                {
                    codebase.Puts("Failed to check for yt-dlp updates: " + ex.Message);
                    return;
                }
                if (codebase.Linux) { codebase.SetPermissions(Path.Combine(codebase.installPath, binName), "777"); }
                string version = getVersion();
                if (string.IsNullOrEmpty(lastVersionYouTubeDL) || lastVersionYouTubeDL != version)
                {
                    codebase.config.lastVersionYouTubeDL = version;
                    codebase.SaveConfig();
                    if (!string.IsNullOrEmpty(lastVersionYouTubeDL)) { codebase.Puts(string.Format("Dependency yt-dlp has been upgraded from {0} to {1}!", lastVersionYouTubeDL, version)); }
                }
            }

            //Get Version Number Of Youtube Downloader
            public static string getVersion()
            {
                Process process = codebase.runCommand(Path.Combine(codebase.installPath, binName), "--version");
                process.Start();
                return process.StandardOutput.ReadToEnd().Trim();
            }
        }

        internal class FFmpeg
        {
            public static bool isInstalled() { return File.Exists(Path.Combine(codebase.installPath, binName)); }
            public static string binName;
            public static string downloadURL;
            public static Dictionary<string, string> Files; //Extra dependencies

            //Download files
            public static void downloadAndInstall()
            {
                if (!File.Exists(Path.Combine(codebase.installPath, binName)))
                {
                    if (!Directory.Exists(codebase.installPath)) { Directory.CreateDirectory(codebase.installPath); }
                    try
                    {
                        using (WebClient wc = new WebClient()) { wc.DownloadFile(new Uri(downloadURL), Path.Combine(codebase.installPath, binName)); }
                        foreach (KeyValuePair<string, string> f in Files) { using (WebClient wc = new WebClient()) { wc.DownloadFile(new Uri(f.Key), f.Value); } }
                    }
                    catch (Exception ex) { codebase.Puts("Failed to download ffmpeg: " + ex.Message); return; }
                }
                if (codebase.Linux)
                {
                    //Set linux permissions to execute
                    codebase.Puts("Setting FFmpeg Permissions");
                    codebase.SetPermissions(Path.Combine(codebase.installPath, binName), "777");
                }
            }
            public static Process run(string opts) { return codebase.runCommand(Path.Combine(codebase.installPath, binName), opts); }
        }

        //JS runtime yt-dlp needs to solve YouTube's signature/n challenge (its "EJS" system). Without
        //it, yt-dlp silently falls back to formats that don't need the challenge solved - usually just
        //thumbnails - and audio downloads fail with "Requested format is not available".
        internal static class Deno
        {
            public static bool isInstalled()
            {
                try
                {
                    ProcessStartInfo psi = new ProcessStartInfo
                    {
                        FileName = codebase.WinOS ? "cmd.exe" : "deno",
                        Arguments = codebase.WinOS ? "/c deno --version" : "--version",
                        UseShellExecute = false,
                        RedirectStandardOutput = true,
                        RedirectStandardError = true,
                        CreateNoWindow = true
                    };

                    using (Process p = new Process { StartInfo = psi })
                    {
                        p.Start();

                        string output = p.StandardOutput.ReadToEnd();
                        string error = p.StandardError.ReadToEnd();

                        p.WaitForExit(10000);

                        if (codebase.config.debug)
                        {
                            codebase.Puts("[Deno] ExitCode: " + p.ExitCode);
                            codebase.Puts("[Deno] Output: " + output.Trim());

                            if (!string.IsNullOrEmpty(error))
                                codebase.Puts("[Deno] Error: " + error.Trim());
                        }

                        return p.ExitCode == 0;
                    }
                }
                catch (Exception ex)
                {
                    if (codebase.config.debug)
                        codebase.Puts("[Deno] Detection failed: " + ex);

                    return false;
                }
            }

            //npm's global bin folder is where it just placed the deno binary/shim, and where PATH needs
            //to include it. A brand-new terminal picks this up automatically from the system/user PATH,
            //but our already-running server process loaded its PATH into memory before npm ever ran, so
            //it won't see the new folder until we patch it in ourselves.
            private static string GetNpmGlobalBinDir()
            {
                try
                {
                    ProcessStartInfo psi = codebase.WinOS
                        ? new ProcessStartInfo { FileName = "cmd.exe", Arguments = "/c npm config get prefix" }
                        : new ProcessStartInfo { FileName = "npm", Arguments = "config get prefix" };
                    psi.UseShellExecute = false;
                    psi.RedirectStandardOutput = true;
                    psi.RedirectStandardError = true;
                    psi.CreateNoWindow = true;
                    using (Process p = new Process { StartInfo = psi })
                    {
                        p.Start();
                        string prefix = p.StandardOutput.ReadToEnd().Trim();
                        p.StandardError.ReadToEnd(); //Drain to avoid the same pipe-buffer deadlock as elsewhere
                        p.WaitForExit(10000);
                        if (string.IsNullOrEmpty(prefix)) { return null; }
                        //On Windows npm places shims directly in the prefix folder; on Unix in <prefix>/bin
                        return codebase.WinOS ? prefix : Path.Combine(prefix, "bin");
                    }
                }
                catch { return null; }
            }

            //Prepend a directory to THIS process's PATH (in-memory only, not persisted) so anything we
            //spawn from here on - including yt-dlp, which itself spawns deno as a child - can find it,
            //without requiring the whole server to be restarted.
            private static void AddToProcessPath(string dir)
            {
                if (string.IsNullOrEmpty(dir) || !Directory.Exists(dir)) { return; }
                string currentPath = Environment.GetEnvironmentVariable("PATH") ?? "";
                string sep = codebase.WinOS ? ";" : ":";
                if (!currentPath.Split(new[] { sep }, StringSplitOptions.RemoveEmptyEntries).Any(p => string.Equals(p.TrimEnd('\\', '/'), dir.TrimEnd('\\', '/'), StringComparison.OrdinalIgnoreCase)))
                {
                    Environment.SetEnvironmentVariable("PATH", dir + sep + currentPath);
                }
            }

            //`npm install -g deno` is identical on Windows and Linux, so no OS branching is needed here
            //beyond how the shell/host process is invoked. Requires Node.js/npm already present on the
            //host; if it isn't, this fails and logs instead of crashing plugin startup.
            public static void downloadAndInstall()
            {
                try
                {
                    ProcessStartInfo psi;
                    if (codebase.WinOS)
                    {
                        //npm ships as npm.cmd on Windows, which needs a shell host to execute directly
                        psi = new ProcessStartInfo { FileName = "cmd.exe", Arguments = "/c npm install -g deno" };
                    }
                    else
                    {
                        psi = new ProcessStartInfo { FileName = "npm", Arguments = "install -g deno" };
                    }
                    psi.UseShellExecute = false;
                    psi.RedirectStandardOutput = true;
                    psi.RedirectStandardError = true;
                    psi.CreateNoWindow = true;
                    psi.WindowStyle = ProcessWindowStyle.Hidden;
                    using (Process process = new Process { StartInfo = psi, EnableRaisingEvents = false })
                    {
                        //Read both streams via events instead of synchronous ReadLine loops, so this
                        //can't deadlock the same way the yt-dlp/ffmpeg process reads could.
                        process.OutputDataReceived += (s, e) => { if (codebase.config.debug && !string.IsNullOrEmpty(e.Data)) { codebase.Puts("[npm] " + e.Data); } };
                        process.ErrorDataReceived += (s, e) => { if (codebase.config.debug && !string.IsNullOrEmpty(e.Data)) { codebase.Puts("[npm] " + e.Data); } };
                        process.Start();
                        process.BeginOutputReadLine();
                        process.BeginErrorReadLine();
                        process.WaitForExit(120000); //npm install can be slow on first run
                    }
                    //Patch npm's global bin folder into our own PATH so deno (and anything spawning it,
                    //like yt-dlp) can be found immediately, without a server restart.
                    AddToProcessPath(GetNpmGlobalBinDir());
                    if (isInstalled()) { codebase.Puts("Deno installed successfully."); }
                    else { codebase.Puts("Deno install via npm did not succeed - is Node.js/npm installed on this host? Install it manually if not: https://deno.com/"); }
                }
                catch (Exception ex) { codebase.Puts("Failed to install Deno via npm: " + ex.Message + " - install it manually if Node.js/npm isn't available: https://deno.com/"); }
            }
        }

        //Info from youtube downloader thats returned in the json file
        internal class MediaInfoData
        {
            public string duration
            {
                get { return duration__BackingField; }
                set { duration__BackingField = value; }
            }

            public string title
            {
                get { return title__BackingField; }
                set { title__BackingField = value; }
            }

            [JsonProperty("_filename")]
            public string filename
            {
                get { return filename__BackingField; }
                set { filename__BackingField = value; }
            }

            private string duration__BackingField;
            private string title__BackingField;
            private string filename__BackingField;
        }
        #endregion
    }
}