sinusbot-commands.js

/**
 * @author Jonas Bögle
 * @license MIT
 * 
 * MIT License
 * 
 * Copyright (c) 2019-2020 Jonas Bögle, Michael Friese
 * 
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 * 
 * The above copyright notice and this permission notice shall be included in all
 * copies or substantial portions of the Software.
 * 
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 * 
 * Thanks to the following GitHub sponsors for supporting my work:
 * - Michael Friese
 * - Jay Vasallo
 * 
 * https://github.com/sponsors/irgendwr
 * 
 */
registerPlugin({
    name: 'SinusBot Commands',
    version: '1.1.2',
    description: 'Enables the default commands.',
    author: 'Jonas Bögle (@irgendwr)',
    engine: '>= 1.0.0',
    backends: ['ts3', 'discord'],
    // the next line is not required since beta.7
    //requiredModules: ['discord-dangerous'],
    autorun: true,
    vars: [
        {
            /*
             * Note: Normally you should **not** add something like this,
             * because you can already disable scripts by unchecking them.
             * However in this case it makes sense as `autorun: true`
             * no longer allows users to disable it otherwise.
             */
            name: 'disable',
            title: 'Disable the default SinusBot commands.',
            type: 'checkbox',
            default: false
        },
        {
            name: 'createSuccessReaction',
            title: 'Add a reaction to each command if it was successfull.',
            type: 'checkbox',
            default: false,
            /* conditions: [
                { field: 'disable', value: false }
            ], */ // conditions checking for "false" are currently buggy. @flyth needs to fix this.
        },
        {
            name: 'discord',
            title: 'Show discord settings',
            type: 'checkbox',
            default: true,
            /* conditions: [
                { field: 'disable', value: false }
            ], */ // conditions checking for "false" are currently buggy. @flyth needs to fix this.
        },
        {
            name: 'url',
            title: 'URL to Webinterface (optional, for album covers in discord)',
            type: 'string',
            placeholder: 'i.e. https://sinusbot.example.com',
            conditions: [
                { field: 'discord', value: true },
                /*{ field: 'disable', value: false }*/
            ], // conditions checking for "false" are currently buggy. @flyth needs to fix this.
        },
        {
            name: 'songInStatus',
            title: 'Show playing song in status.',
            type: 'checkbox',
            default: true,
            conditions: [
                { field: 'discord', value: true }
            ],
        },
        {
            name: 'deleteOldMessages',
            title: 'Delete previous responses if !playing command is used again',
            type: 'checkbox',
            default: true,
            conditions: [
                { field: 'discord', value: true },
                /*{ field: 'disable', value: false }*/
            ], // conditions checking for "false" are currently buggy. @flyth needs to fix this.
        }
    ]
}, (_, config, meta) => {
    const event = require('event')
    const engine = require('engine')
    const backend = require('backend')
    const format = require('format')
    const audio = require('audio')
    const media = require('media')

    engine.log(`Loaded ${meta.name} v${meta.version} by ${meta.author}.`)
    engine.log(`SinusBot v${engine.version()} on ${engine.os()}`)

    /********* privileges *********/
    const ENQUEUE           = 1 << 13;
    const SKIP_QUEUE        = 1 << 14;
    const ADMIN_QUEUE       = 1 << 15;
    const PLAYBACK          = 1 << 12;
    const START_STOP        = 1 <<  8;
    const EDIT_BOT_SETTINGS = 1 << 16;
    const LOGIN             = 1 <<  0;
    const UPLOAD_FILES      = 1 <<  2;
    const DELETE_FILES      = 1 <<  3;
    const EDIT_FILES        = 1 <<  4;
    const CREATE_AND_DELETE_PLAYLISTS = 1 << 5;
    const EDIT_PLAYLISTS    = 1 <<  7;
    const EDIT_INSTANCES    = 1 << 17;
    const EDIT_USERS        = 1 <<  9;

    const ERROR_PREFIX = '❌ ';
    const WARNING_PREFIX = '⚠ ';
    const SUCCESS_PREFIX = '✔ ';
    const USAGE_PREFIX = ERROR_PREFIX + 'Usage: ';

    const sinusbotURL = config.url;
    const REACTION_PREV = '⏮';
    const REACTION_PLAYPAUSE = '⏯';
    const REACTION_NEXT = '⏭';
    const REACTION_SUCCESS = '✅';
    const HIDE_REACTIONS_IF_PRIVATE = false;

    const PATTERN_URL = /^https?:\/\/\S+/i;
    const PATTERN_YT_DOMAIN = /^https?:\/\/(?:www\.)?(?:youtube\.com|youtu\.be)\//i;

    // for join/leave
    const ERROR_BOT_NULL = ERROR_PREFIX+'Unable to change channel.\nTry to set a *Default Channel* in the webinterface and click save.'

    /** @type {object[]} */
    let lastEmbeds = [];

    if (config.discord && engine.getBackend() != 'discord') {
        // hide discord-only settings if backend is not discord
        config.discord = false;
        engine.saveConfig(config);
    } else if (!config.discord && engine.getBackend() == 'discord') {
        // show discord-only settings if backend is discord
        config.discord = true;
        engine.saveConfig(config);
    }

    const ytCallbacks = {};
    event.on("ytdl.success", ev => {
        engine.log(`Downloaded YouTube Video: ${ev.url}`);
        const jobId = ev.jobId;
        if (typeof ytCallbacks[jobId] === 'function') {
            ytCallbacks[jobId](ev);
            delete ytCallbacks[jobId];
        }
    });

    event.on("ytdl.error", (ev, message) => {
        engine.log(`Error while downloading YouTube Video: ${ev.url}; ${message}`);
        if (message.startsWith("exit status")) {
            engine.log('Please see "Upload" page in web-interface for more details and read the documentation for troubleshooting advice: https://sinusbot.github.io/docs/youtube-dl/');
        }

        const jobId = ev.jobId;
        if (typeof ytCallbacks[jobId] === 'function') {
            ytCallbacks[jobId](ev, message);
            delete ytCallbacks[jobId];
        }
    });

    /**
     * Registers a callback for success/error events of a given jobId.
     * @param {string} jobId Job ID
     * @param {(ev: {url: string, jobId: string, trackId?: string}, message: string) => void} callback Callback
     */
    function ytCallback(jobId, callback) {
        ytCallbacks[jobId] = callback;
    }

    /**
     * 
     * @param {string} jobId Job ID
     * @param {MessageEvent} ev Event
     * @param {(msg: string) => void} reply
     */
    function handleYT(jobId, ev, reply) {
        ytCallback(jobId, (ytev, err) => {
            if (err) {
                if (err.startsWith("exit status")) {
                    reply(ERROR_PREFIX + `Error: ${err}; Please see "Upload" page in web-interface for more details.`);
                } else {
                    reply(ERROR_PREFIX + `Error: ${err}`);
                }
                return;
            }
            successReaction(ev, reply);
        });
    }

    if (config.disable) {
        engine.log('SinusBot commands are DISABLED.');
    } else { // BEGIN COMMANDS-ENABLED
        event.on('load', () => {
            const command = require('command');
            if (!command) {
                engine.log('command.js library not found! Please download command.js to your scripts folder and restart the SinusBot, otherwise this script will not work.');
                engine.log('command.js can be found here: https://github.com/Multivit4min/Sinusbot-Command/blob/master/command.js');
                return;
            }
            const {createCommand} = command;
            
            createCommand('register')
            .addArgument(args => args.string.setName('username'))
            .help('Register a new user')
            .manual('Registers a new user bound to the Account you are using. This account has no privileges by default but can be edited by the bot administrators.')
            .exec((client, args, reply, ev) => {
                if (!engine.registrationEnabled()) {
                    reply('Registration is disabled.');
                    return;
                }

                // print syntax if no username given
                if (!args.username) {
                    reply(USAGE_PREFIX + 'register <username>');
                    return;
                }

                if (engine.getUserByName(args.username)) {
                    reply(ERROR_PREFIX + 'This username already exists.');
                    return;
                }

                // check if client already has a user
                let user = getUserByUid(client.uid());
                if (user) {
                    reply(ERROR_PREFIX + `You already have a user with the name "${user.name()}".`);
                    return;
                }

                // create user
                let newUser = engine.addUser(args.username);
                if (!newUser) {
                    reply(ERROR_PREFIX + 'Unable to create user, try another username.');
                    return;
                }

                if (!newUser.setUid(client.uid())) {
                    newUser.delete()
                    reply(ERROR_PREFIX + 'Unable to assign uid to user.');
                    return;
                }
                reply(SUCCESS_PREFIX + 'Registered a user with the given name.\nThis account has no privileges by default but can be edited by the bot administrators.');
                successReaction(ev, reply);
            });
            
            createCommand('password')
            .alias('pass')
            .addArgument(args => args.rest.setName('value'))
            .help('Change your password')
            .manual('Changes your password to <value>.')
            .checkPermission(client => getUserByUid(client.uid()))
            .exec((client, args, reply, ev) => {
                // print syntax if no value given
                if (!args.value) {
                    reply(USAGE_PREFIX + 'password <value>\n'+ WARNING_PREFIX + 'Don\'t use this command in a public channel.');
                    return;
                }

                if (ev.mode !== 1) {
                    reply(WARNING_PREFIX + 'Don\'t use this command in a public channel.');
                    return;
                }

                let user = getUserByUid(client.uid());
                if (!user) {
                    reply(ERROR_PREFIX + `You don't have a user-account. Use ${format.bold('!register')} to create one.`);
                    return;
                }

                // set password
                if (!user.setPassword(args.value)) {
                    reply(ERROR_PREFIX + 'Unable to set password.');
                    return;
                }
                reply(SUCCESS_PREFIX + 'Changed your password.');
                successReaction(ev, reply);
            });

            createCommand('whoami')
            .help('Show user identities')
            .manual('Shows user identities matching your ID/groups.')
            .exec((client, args, reply, ev) => {
                let users = getUsersByClient(client);
                if (users && users.length != 0) {
                    const usersStr = users.map(user => user.name()).join(", ");
                    if (users.length == 1) {
                        reply(`You match the following user: ${usersStr}.`);
                    } else {
                        reply(`You match the following ${users.length} users: ${usersStr}.`);
                    }
                } else {
                    reply("You don't match any users.");
                }
                successReaction(ev, reply);
            });

            createCommand('privileges')
            .alias('priv', 'privs')
            .help('Show user privileges')
            .manual('Shows user privileges.')
            .exec((client, args, reply, ev) => {
                let privs = [
                    { n: ENQUEUE, s: 'Enqueue' },
                    { n: SKIP_QUEUE, s: 'Skip Queue' },
                    { n: ADMIN_QUEUE, s: 'Admin Queue' },
                    { n: PLAYBACK, s: 'Playback' },
                    { n: START_STOP, s: 'Start/Stop' },
                    { n: EDIT_BOT_SETTINGS, s: 'Edit Bot Settings' },
                    { n: LOGIN, s: 'Login' },
                    { n: UPLOAD_FILES, s: 'Upload Files' },
                    { n: DELETE_FILES, s: 'Delete Files' },
                    { n: EDIT_FILES, s: 'Edit Files' },
                    { n: CREATE_AND_DELETE_PLAYLISTS, s: 'Create/Delete Playlists' },
                    { n: EDIT_PLAYLISTS, s: 'Edit Playlists' },
                    { n: EDIT_INSTANCES, s: 'Edit Instances' },
                    { n: EDIT_USERS, s: 'Edit Users' },
                ];
                let uprivs = [];
                privs.forEach(p => {
                    if (requirePrivileges(p.n)(client)) {
                        uprivs.push(p.s);
                    }
                })

                if (uprivs.length >= 1) {
                    reply(`You have the following privileges: ${uprivs.join(", ")}.`);
                } else {
                    reply(`You have no privileges.`);
                }
                //reply(getUsersByClient(client).map(u => u.privileges().toString(2)).join(", "));

                successReaction(ev, reply);
            });

            createCommand('playing')
            .help('Show what\'s currently playing')
            .manual('Show what\'s currently playing')
            .exec((client, args, reply, ev) => {
                if (engine.getBackend() !== 'discord' || !ev.message) {
                    if (!audio.isPlaying()) {
                        successReaction(ev, reply);
                        return reply('There is nothing playing at the moment.');
                    }

                    reply(formatTrack(media.getCurrentTrack()));
                    successReaction(ev, reply);
                    return;
                }

                let msg = getPlayingEmbed();
                if (!audio.isPlaying()) {
                    msg.content = 'There is nothing playing at the moment.';
                }

                backend.extended().createMessage(ev.message.channelID(), msg, (err, res) => {
                    if (err) return engine.log(err);
                    if (!res) return engine.log('Error: empty response');

                    const {id, channel_id} = JSON.parse(res);

                    // messages that should be deleted
                    let deleteMsg = [];
                    const msgId = ev.message ? ev.message.ID() : null;
                    const index = lastEmbeds.findIndex(embed => embed.channelId == channel_id);
                    if (index !== -1) {
                        if (config.deleteOldMessages) {
                            // delete previous embed
                            deleteMsg.push(lastEmbeds[index].messageId);
                            // delete previous command from user
                            if (lastEmbeds[index].messageId) {
                                deleteMsg.push(lastEmbeds[index].invokeMessageId);
                            }
                        }
                        // save new embed
                        lastEmbeds[index].messageId = id;
                        lastEmbeds[index].invokeMessageId = msgId;
                    } else {
                        // save new embed
                        lastEmbeds.push({
                            channelId: channel_id,
                            messageId: id,
                            invokeMessageId: msgId
                        });
                    }

                    deleteMessages(channel_id, deleteMsg);

                    if (HIDE_REACTIONS_IF_PRIVATE && ev.mode === 1) return;
                    
                    wait(1000)
                    // create reaction controls
                    .then(() => createReaction(channel_id, id, REACTION_PREV))
                    .then(() => wait(150))
                    .then(() => createReaction(channel_id, id, REACTION_PLAYPAUSE))
                    .then(() => wait(150))
                    .then(() => createReaction(channel_id, id, REACTION_NEXT));
                });
                successReaction(ev, reply);
            });

            createCommand('next')
            .help('Play the next track')
            .manual('Plays the next track (only when a playlist or queue is active).')
            .checkPermission(requirePrivileges(PLAYBACK))
            .exec((client, args, reply, ev) => {
                media.playNext();
                successReaction(ev, reply);
            });

            createCommand('prev')
            .alias('previous')
            .help('Play the previous track')
            .manual('Plays the previous track (only when a playlistis active).')
            .checkPermission(requirePrivileges(PLAYBACK))
            .exec((client, args, reply, ev) => {
                media.playPrevious();
                successReaction(ev, reply);
            });

            createCommand('search')
            .alias('s')
            .addArgument(args => args.rest.setName('searchstring'))
            .help('Search for tracks')
            .manual('Searches for tracks, returns 20 results at most.')
            .checkPermission(requirePrivileges(PLAYBACK, ENQUEUE))
            .exec((client, args, reply, ev) => {
                // print syntax if no searchstring given
                if (!args.searchstring) {
                    reply(USAGE_PREFIX + 'search <searchstring>');
                    return;
                }

                const tracks = media.search(args.searchstring);
                if (tracks.length == 0) {
                    reply('Sorry, nothing found.');
                    successReaction(ev, reply);
                    return;
                }

                const response = tracks.map(formatTrack).join("\n")
                reply(response);
                successReaction(ev, reply);
            });

            createCommand('play')
            .alias('p')
            .addArgument(args => args.rest.setName('idORsearchstring', 'searchstring / uuid'))
            .help('Play a track by its id or name')
            .manual('Plays a track by its id or searches for a track and plays the first match.')
            .checkPermission(requirePrivileges(PLAYBACK))
            .exec((client, args, reply, ev) => {
                let query = args.idORsearchstring;
                // print syntax if no idORsearchstring given
                if (!query) {
                    reply(USAGE_PREFIX + 'play <searchstring / uuid>');
                    return;
                }

                let track = media.getTrackByID(query);
                if (!track) {
                    let tracks = media.search(query);
                    if (tracks.length > 0) {
                        track = tracks[0];
                    } else {
                        query = stripURL(query);
                        if (query.match(PATTERN_URL)) {
                            if (!query.match(PATTERN_YT_DOMAIN)) {
                                if (media.playURL(query)) {
                                    successReaction(ev, reply);
                                    return;
                                }
                            }
                            if (media.ytStream(query)) {
                                successReaction(ev, reply);
                                return;
                            }
                            const jobId = media.yt(query);
                            handleYT(jobId, ev, reply);
                            return;
                        }
                        return reply('Sorry, nothing found.');
                    }
                }

                track.play();
                reply(`Playing ${formatTrack(track)}`);
                successReaction(ev, reply);
            });

            createCommand('playlist')
            .addArgument(args => args.rest.setName('playlistname'))
            .help('Start playing back the playlist <playlistname>')
            .manual('starts playing back the playlist <playlistname>.')
            .checkPermission(requirePrivileges(PLAYBACK))
            .exec((client, args, reply, ev) => {
                // print syntax if no playlistname given
                if (!args.playlistname) {
                    reply(USAGE_PREFIX + 'playlist <playlistname>');
                    return;
                }

                const match = media.getPlaylists().find(playlist => {
                    // case insensitive equals
                    return playlist.name() == args.playlistname || playlist.name().localeCompare(args.playlistname, undefined, { sensitivity: 'accent' }) === 0
                });

                if (!match) {
                    reply('Sorry, no matching playlist found.');
                    successReaction(ev, reply);
                    return;
                }
                
                media.playlistPlayByID(match, 0);

                successReaction(ev, reply);
            });

            createCommand('queue')
            .alias('q')
            .addArgument(args => args.rest.setName('idORsearchstring', 'searchstring / uuid').optional(true))
            .help('Enqueue a track or resume queue')
            .manual('Enqueue a track by its id or search for a track and enqueue the first match. When no track is provided it wil resume the queue.')
            .checkPermission(requirePrivileges(PLAYBACK, ENQUEUE))
            .exec((client, args, reply, ev) => {
                if (!args.idORsearchstring) {
                    if (!audio.isPlaying()) {
                        media.playQueueNext();
                    }
                    return;
                }

                let track = media.getTrackByID(args.idORsearchstring);
                if (!track) {
                    const tracks = media.search(args.idORsearchstring);
                    if (tracks.length > 0) {
                        track = tracks[0];
                    } else {
                        reply('Sorry, nothing found.');
                        return;
                    }
                }

                track.enqueue();
                reply(`Added ${formatTrack(track)} to the queue`);
                successReaction(ev, reply);
            });

            createCommand('queuenext')
            .alias('qnext', 'qn')
            .addArgument(args => args.rest.setName('idORsearchstring', 'searchstring / uuid'))
            .help('Prepends a track to the queue')
            .manual('Prepends a track by its id or searches for a track and prepends the first match to the queue.')
            .checkPermission(requirePrivileges(SKIP_QUEUE))
            .exec((client, args, reply, ev) => {
                // print syntax if no idORsearchstring given
                if (!args.idORsearchstring) {
                    reply(USAGE_PREFIX + 'queuenext <searchstring / uuid>');
                    return;
                }

                let track = media.getTrackByID(args.idORsearchstring);
                if (!track) {
                    const tracks = media.search(args.idORsearchstring);
                    if (tracks.length > 0) {
                        track = tracks[0];
                    } else {
                        reply('Sorry, nothing found.');
                        return;
                    }
                }

                track.enqueue();
                reply(`Added ${formatTrack(track)} to the queue`);
                successReaction(ev, reply);
            });

            createCommand('stop')
            .help('Stop playback')
            .manual('Stops playback.')
            .checkPermission(requirePrivileges(PLAYBACK))
            .exec((client, args, reply, ev) => {
                media.stop();
                successReaction(ev, reply);
            });

            createCommand('!stop')
            .help('Stop playback and remove idle-track')
            .manual('Stops playback and removes idle-track.')
            .checkPermission(requirePrivileges(PLAYBACK|EDIT_BOT_SETTINGS))
            .exec((client, args, reply, ev) => {
                media.stop();
                media.clearIdleTrack();
                successReaction(ev, reply);
            });

            createCommand('volume')
            .alias('vol')
            .addArgument(args => args.string.setName('value'))
            .help('Change the volume')
            .manual('Changes the volume.')
            .checkPermission(requirePrivileges(PLAYBACK))
            .exec((client, args, reply, ev) => {
                let value = args.value;
                let volume = audio.getVolume();

                switch (value) {
                case 'up':
                    volume += 10;
                    break;
                case 'dn':
                case 'down':
                    volume -= 10;
                    break;
                default:
                    value = parseInt(value, 10);
                    if (value >= 0 && value <= 100) {
                        volume = value;
                    } else {
                        reply(USAGE_PREFIX + 'volume <up|down|dn|0-100>');
                        return;
                    }
                }
                
                if (volume < 0) {
                    volume = 0;
                } else if (volume > 100) {
                    volume = 100;
                }

                audio.setVolume(volume);
                successReaction(ev, reply);
            });

            createCommand('stream')
            .addArgument(args => args.string.setName('url'))
            .help('Stream a url')
            .manual('Streams from <url>; this may be http-streams like shoutcast / icecast or just remote soundfiles.')
            .checkPermission(requirePrivileges(PLAYBACK))
            .exec((client, args, reply, ev) => {
                // print syntax if no url given
                if (!args.url) {
                    reply(USAGE_PREFIX + 'stream <url>');
                    return;
                }

                const url = stripURL(args.url);

                if (url.match(PATTERN_YT_DOMAIN)) {
                    if (!media.ytStream(url)) {
                        reply(ERROR_PREFIX + 'Unable to stream this YouTube URL.');
                        return;
                    }
                    successReaction(ev, reply);
                    return;
                }

                if (!media.playURL(url)) {
                    reply(ERROR_PREFIX + 'Unable to stream this URL.');
                    return;
                }
                successReaction(ev, reply);
            });

            createCommand('say')
            .addArgument(args => args.rest.setName('text'))
            .help('Say a text via TTS')
            .manual('Uses text-to-speech (if configured) to say the given text.')
            .checkPermission(requirePrivileges(PLAYBACK))
            .exec((client, args, reply, ev) => {
                // print syntax if no text given
                if (!args.text) {
                    reply(USAGE_PREFIX + 'say <text>');
                    return;
                }

                audio.say(args.text);
                successReaction(ev, reply);
            });

            createCommand('sayex')
            .addArgument(args => args.string.setName('locale'))
            .addArgument(args => args.rest.setName('text'))
            .help('Say a text via TTS with given locale')
            .manual('Uses text-to-speech (if configured) to say the given text with a given locale.')
            .checkPermission(requirePrivileges(PLAYBACK))
            .exec((client, args, reply, ev) => {
                // print syntax if no locale/text given
                if (!args.locale || !args.text) {
                    reply(USAGE_PREFIX + 'sayex <locale> <text>');
                    return;
                }

                audio.say(args.text, args.locale);
                successReaction(ev, reply);
            });

            createCommand('ttsurl')
            .addArgument(args => args.string.setName('url'))
            .help('Set the TTS url.')
            .manual('Sets the TTS url.')
            .checkPermission(requirePrivileges(EDIT_BOT_SETTINGS))
            .exec((client, args, reply, ev) => {
                // print syntax if no url given
                if (!args.url) {
                    reply(USAGE_PREFIX + 'ttsurl <url>');
                    return;
                }

                audio.setTTSURL(stripURL(args.url));
                successReaction(ev, reply);
            });

            createCommand('ttslocale')
            .addArgument(args => args.string.setName('locale'))
            .help('Set the TTS locale.')
            .manual('Sets the TTS locale.')
            .checkPermission(requirePrivileges(EDIT_BOT_SETTINGS))
            .exec((client, args, reply, ev) => {
                // print syntax if no locale given
                if (!args.locale) {
                    reply(USAGE_PREFIX + 'ttslocale <locale>');
                    return;
                }

                audio.setTTSDefaultLocale(args.locale);
                successReaction(ev, reply);
            });

            createCommand('yt')
            .addArgument(args => args.string.setName('url'))
            .help('Play <url> via youtube-dl')
            .manual('Plays <url> via external youtube-dl (if enabled); beware: the file will be downloaded first and played back afterwards, so there might be a slight delay before playback starts.')
            .checkPermission(requirePrivileges(PLAYBACK))
            .exec((client, args, reply, ev) => {
                const url = stripURL(args.url);
                if (!url) return reply(USAGE_PREFIX + 'yt <url>');
                if (!url.match(PATTERN_URL)) return reply(ERROR_PREFIX + 'Invalid URL.');

                const jobId = media.yt(url);
                ytCallback(jobId, (ytev, err) => {
                    if (err) {
                        // try to stream
                        if (!media.ytStream(url)) {
                            if (err.startsWith("exit status")) {
                                return reply(ERROR_PREFIX + `Error: ${err}; Please see "Upload" page in web-interface for more details.`);
                            }
                            return reply(ERROR_PREFIX + `Error: ${err}`);
                        }
                    }
                    successReaction(ev, reply);
                });
            });

            createCommand('ytstream')
            .alias('streamyt')
            .addArgument(args => args.string.setName('url'))
            .help('Stream <url> via youtube-dl')
            .manual('Streams <url> via external youtube-dl (if enabled)')
            .checkPermission(requirePrivileges(PLAYBACK))
            .exec((client, args, reply, ev) => {
                const url = stripURL(args.url);
                if (!url) return reply(USAGE_PREFIX + 'ytstream <url>');
                if (!url.match(PATTERN_URL)) return reply(ERROR_PREFIX + 'Invalid URL.');

                if (!media.ytStream(url)) {
                    return reply(ERROR_PREFIX + 'Unable to stream this URL.');
                }
                successReaction(ev, reply);
            });

            createCommand('ytdl')
            .addArgument(args => args.string.setName('url'))
            .help('Download and play <url> via youtube-dl')
            .manual('Plays <url> via external youtube-dl (if enabled); beware: the file will be downloaded first and played back afterwards, so there might be a slight delay before playback starts; additionally, the file will be stored.')
            .checkPermission(requirePrivileges(PLAYBACK|UPLOAD_FILES))
            .exec((client, args, reply, ev) => {
                const url = stripURL(args.url);
                if (!url) return reply(USAGE_PREFIX + 'ytdl <url>');
                if (!url.match(PATTERN_URL)) return reply(ERROR_PREFIX + 'Invalid URL.');

                const jobId = media.ytdl(url, true);
                handleYT(jobId, ev, reply);
            });

            createCommand('qyt')
            .addArgument(args => args.string.setName('url'))
            .help('Enqueue <url> via youtube-dl')
            .manual('Enqueues <url> via external youtube-dl (if enabled); beware: the file will be downloaded first and played back afterwards, so there might be a slight delay before playback starts.')
            .checkPermission(requirePrivileges(PLAYBACK, ENQUEUE))
            .exec((client, args, reply, ev) => {
                const url = stripURL(args.url);
                if (!url) return reply(USAGE_PREFIX + 'qyt <url>');
                if (!url.match(PATTERN_URL)) return reply(ERROR_PREFIX + 'Invalid URL.');

                const jobId = media.enqueueYt(url);
                handleYT(jobId, ev, reply);
            });

            createCommand('qytdl')
            .addArgument(args => args.string.setName('url'))
            .help('Download and enqueue <url> via youtube-dl')
            .manual('Enqueues <url> via external youtube-dl (if enabled); beware: the file will be downloaded first and played back afterwards, so there might be a slight delay before playback starts; additionally, the file will be stored.')
            .checkPermission(requirePrivileges(PLAYBACK|UPLOAD_FILES, ENQUEUE|UPLOAD_FILES))
            .exec((client, args, reply, ev) => {
                const url = stripURL(args.url);
                if (!url) return reply(USAGE_PREFIX + 'qytdl <url>');
                if (!url.match(PATTERN_URL)) return reply(ERROR_PREFIX + 'Invalid URL.');

                const jobId = media.enqueueYtdl(url);
                handleYT(jobId, ev, reply);
            });

            createCommand('shuffle')
            .help('Toggle shuffle')
            .manual('Toggles shuffle.')
            .checkPermission(requirePrivileges(PLAYBACK))
            .exec((client, args, reply, ev) => {
                audio.setShuffle(!audio.isShuffle());
                reply(SUCCESS_PREFIX + `Shuffle is now ${audio.isShuffle() ? 'en' : 'dis'}abled.`);
                successReaction(ev, reply);
            });

            createCommand('repeat')
            .help('Toggle repeat')
            .manual('Toggles repeat.')
            .checkPermission(requirePrivileges(PLAYBACK))
            .exec((client, args, reply, ev) => {
                audio.setRepeat(!audio.isRepeat());
                reply(SUCCESS_PREFIX + `Repeat is now ${audio.isRepeat() ? 'en' : 'dis'}abled.`);
                successReaction(ev, reply);
            });

            if (engine.getBackend() == 'ts3') {
                createCommand('sub')
                .help('Subscribe to bot')
                .manual('Subscribes to the bot. (subscription transfer-mode only)')
                .checkPermission(() => engine.isSubscriptionMode())
                .exec((client, args, reply, ev) => {
                    if (!engine.isSubscriptionMode()) {
                        reply(ERROR_PREFIX + 'This command only works if Transmit-Mode is set to Subscription.');
                        return;
                    }
                    client.subscribe(true);
                    successReaction(ev, reply);
                });

                createCommand('unsub')
                .help('Unsubscribe from bot')
                .manual('Unsubscribes from the bot. (subscription transfer-mode only)')
                .checkPermission(() => engine.isSubscriptionMode())
                .exec((client, args, reply, ev) => {
                    if (!engine.isSubscriptionMode()) {
                        reply(ERROR_PREFIX + 'This command only works if Transmit-Mode is set to Subscription.');
                        return;
                    }
                    client.subscribe(false);
                    successReaction(ev, reply);
                });

                createCommand('subchan')
                .help('Add subscription for channel')
                .manual('Adds subscription for the channel the user is currently in. (subscription transfer-mode only)')
                .checkPermission(client => requirePrivileges(EDIT_BOT_SETTINGS)(client) && engine.isSubscriptionMode())
                .exec((client, args, reply, ev) => {
                    if (!engine.isSubscriptionMode()) {
                        reply(ERROR_PREFIX + 'This command only works if Transmit-Mode is set to Subscription.');
                        return;
                    }
                    client.getChannels()[0].subscribe(true);
                    successReaction(ev, reply);
                });

                createCommand('unsubchan')
                .help('Remove subscription for channel')
                .manual('Removes subscription for the channel the user is currently in. (subscription transfer-mode only)')
                .checkPermission(client => requirePrivileges(EDIT_BOT_SETTINGS)(client) && engine.isSubscriptionMode())
                .exec((client, args, reply, ev) => {
                    if (!engine.isSubscriptionMode()) {
                        reply(ERROR_PREFIX + 'This command only works if Transmit-Mode is set to Subscription.');
                        return;
                    }
                    client.getChannels()[0].subscribe(false);
                    successReaction(ev, reply);
                });

                createCommand('mode')
                .addArgument(args => args.string.setName('mode'))
                .help('Change Transmit-Mode')
                .manual('Changes Transmit-Mode; 0 = to channel, 1 = subscription mode')
                .checkPermission(requirePrivileges(EDIT_BOT_SETTINGS))
                .exec((client, args, reply, ev) => {
                    let mode = args.mode;
                    if (typeof mode === 'string') {
                        mode = mode.toLowerCase();
                    }

                    switch (mode) {
                    case "0":
                    case "chan":
                    case "channel":
                        engine.setSubscriptionMode(false);
                        reply(SUCCESS_PREFIX + 'Transmit-Mode is now set to Channel (default).');
                        successReaction(ev, reply);
                        break;
                    case "1":
                    case "sub":
                    case "subscription":
                        engine.setSubscriptionMode(true);
                        reply(SUCCESS_PREFIX + 'Transmit-Mode is now set to Subscription.');
                        successReaction(ev, reply);
                        break;
                    default:
                        reply(`Transmit-Mode is currently set to ${engine.isSubscriptionMode() ? 'Subscription' : 'Channel (default)'}.\n` + USAGE_PREFIX + 'mode <0|chan(nel)|1|sub(scription)>');
                    }
                });
            }

            createCommand('registration')
            .addArgument(args => args.string.setName('value'))
            .help('Enable / disable user registration via chat')
            .manual('Enables / disables user registration via chat. Value should be either `enable` or `disable`.')
            .checkPermission(requirePrivileges(EDIT_BOT_SETTINGS))
            .exec((client, args, reply, ev) => {
                switch (args.value) {
                case "enable":
                    engine.enableRegistration();
                    reply(SUCCESS_PREFIX + 'Registration is now enabled.');
                    successReaction(ev, reply);
                    break;
                case "disable":
                    engine.disableRegistration();
                    reply(SUCCESS_PREFIX + 'Registration is now disabled.');
                    successReaction(ev, reply);
                    break;
                default:
                    reply(`Registration is currently ${engine.registrationEnabled() ? 'en' : 'dis'}abled.\n` + USAGE_PREFIX + 'registration <enable|disable>');
                }
            });

            createCommand('prefix')
            .addArgument(args => args.string.setName('prefix'))
            .help('Change command prefix')
            .manual('Changes the prefix for all core commands to <new prefix>, default is "!".')
            .checkPermission(requirePrivileges(EDIT_BOT_SETTINGS))
            .exec((client, args, reply, ev) => {
                // print syntax if no prefix given
                if (!args.prefix) {
                    reply(USAGE_PREFIX + 'prefix <new prefix>');
                    return;
                }

                engine.setCommandPrefix(args.prefix);
                reply(SUCCESS_PREFIX + 'New prefix: ' + args.prefix);
                successReaction(ev, reply);
            });

            createCommand('ping')
            .help('responds with "PONG"')
            .exec((client, args, reply, ev) => {
                reply(`PONG`);
                successReaction(ev, reply);
            });

            createCommand('version')
            .help('Show version')
            .manual('Shows the SinusBot version.')
            .checkPermission(requirePrivileges(EDIT_BOT_SETTINGS))
            .exec((client, args, reply, ev) => {
                reply(`SinusBot v${engine.version()} on ${engine.os()}\nsinusbot-commands.js v${meta.version}\ncommand.js v${command.getVersion()}`);
                successReaction(ev, reply);
            });

            createCommand('reload')
            .help('Reload scripts')
            .manual('Reloads scripts.\nNote: Adding new scripts requires a complete sinusbot restart.')
            .checkPermission(requirePrivileges(EDIT_BOT_SETTINGS))
            .exec((client, args, reply, ev) => {
                reply('reloading...');
                let success = engine.reloadScripts();
                if (success) {
                    reply(SUCCESS_PREFIX + `Scripts reloaded.\n*Please note: adding new scripts requires a complete sinusbot restart.*`);
                    successReaction(ev, reply);
                } else {
                    reply('Unable to reload scripts. Did you allow it in your `config.ini`?');
                }
            });
            
            createCommand('join')
            .help('Move the SinusBot to your channel')
            .manual('Moves the SinusBot into your channel.')
            .checkPermission(requirePrivileges(START_STOP))
            .exec((client, args, reply, ev) => {
                var channel = client.getChannels()[0]
                if (!channel) {
                    return reply(ERROR_PREFIX+'I\'m unable to join your channel :(');
                }

                if (!getBotClient()) {
                    return reply(ERROR_BOT_NULL);
                }
                bot.moveTo(channel);
                engine.setDefaultChannelID(channel.id())
                successReaction(ev, reply);
            });
            
            /* // currently not working due to a bug.
            createCommand('disconnect')
            .help('Disconnect the SinusBot')
            .manual('Disconnects the SinusBot.')
            .checkPermission(requirePrivileges(START_STOP))
            .exec((client, args, reply, ev) => {
                backend.disconnect()
            });
            // */

            if (engine.getBackend() == 'discord') {
                createCommand('leave')
                .help('Disconnect the SinusBot')
                .manual('Disconnects the SinusBot from the current voice channel.')
                .checkPermission(requirePrivileges(START_STOP))
                .exec((client, args, reply, ev) => {
                    if (!getBotClient()) {
                        return reply(ERROR_BOT_NULL);
                    }
                    
                    bot.moveTo('');
                    engine.setDefaultChannelID('');
                    successReaction(ev, reply);
                });
            }
        });
    } // END COMMANDS-ENABLED

    // stores last bot client object for `getBotClient()`
    let bot = backend.getBotClient();

    /**
     * Wrapper for `backend.getBotClient()` because it sometimes returns `null` -_-
     * @returns {Client} Bot client
     */
    function getBotClient() {
        bot = backend.getBotClient() || bot;
        return bot;
    }

    /********** !playing stuff for discord **********/
    if (engine.getBackend() == 'discord') {
        event.on('discord:MESSAGE_REACTION_ADD', ev => {
            let ename = ev.emoji.name;
            // remove 0xefb88f aka. "VARIATION SELECTOR-16" (no idea why discord puts that at the end)
            if (ename.endsWith('\ufe0f')) {
                ename = ename.slice(0, -1);
            }
            const emoji = ev.emoji.id ? `${ename}:${ev.emoji.id}` : ename;

            // ignore reactions that are not controls
            if (![REACTION_PREV, REACTION_PLAYPAUSE, REACTION_NEXT].includes(emoji)) return;

            // ignore reactions from the bot itself
            if (backend.getBotClientID().endsWith(ev.user_id)) return;

            // get user via id
            let client = backend.getClientByID(`${ev.guild_id || backend.getBotClientID().split('/')[0]}/${ev.user_id}`);

            if (!client) {
                engine.log(`playing controls: using workaround for client '${ev.user_id}'`);
                // @ts-ignore: workaround
                client = fakeClient(ev.guild_id || backend.getBotClientID().split('/')[0], ev.user_id, ev.channel_id);
            }

            // ignore if no matching user found or reaction from the bot itself
            if (!client) return engine.log(`playing controls: could not find client '${ev.user_id}'`);

            // ignore if reaction is from the bot itself
            if (client.isSelf()) return;

            let callback = () => {
                // delete the rection
                deleteUserReaction(ev.channel_id, ev.message_id, ev.user_id, emoji);

                // check if user has the 'playback' permission
                if (!requirePrivileges(PLAYBACK)(client)) {
                    engine.log(`${client.nick()} is missing playback permissions for reaction controls`);
                    client.chat(ERROR_PREFIX + 'You need the playback permission to use reaction controls');
                    return;
                }

                const track = media.getCurrentTrack();

                switch (emoji) {
                case REACTION_PREV:
                    // ignore if nothing is playing
                    if (!audio.isPlaying()) return;

                    if (media.getQueue().length !== 0) {
                        // start from beginning if we're playing queue
                        audio.seek(0);
                    } else {
                        // try prev (doesn't work for queue or folder)
                        media.playPrevious();

                        // fallback: start from beginning if there is no previous track
                        if (!audio.isPlaying()) {
                            if (track) track.play();
                        }
                    }
                    break;
                case REACTION_PLAYPAUSE:
                    if (audio.isPlaying()) {
                        media.stop();
                    } else {
                        if (!track) return;
                        const pos = audio.getTrackPosition();

                        if (pos && pos < (track.duration() - 1000 /* milliseconds */)) {
                            // continue playing at last pos
                            audio.setMute(true);
                            track.play();
                            audio.seek(pos);
                            audio.setMute(false);
                        } else {
                            // or start from beginning if it already ended
                            track.play();
                        }
                    }
                    break;
                case REACTION_NEXT:
                    if (audio.isPlaying()) {
                        media.playNext();
                    } else {
                        // is something in queue?
                        if (media.getQueue().length !== 0) {
                            // resume queue
                            media.playQueueNext();
                        }
                    }
                }
            };

            // was reaction added to previous response?
            if (lastEmbeds.some(embed => embed.messageId == ev.message_id)) {
                callback();
                return;
            }

            getMessage(ev.channel_id, ev.message_id).then(msg => {
                // was reaction added to previous response of the bot?
                if (backend.getBotClientID().endsWith(msg.author.id)) {
                    callback();
                }
            })
        });
        
        /**
        * Called when track or it's info changes
        * @param {Track} track
        */
        const onChange = track => {
            if (config.songInStatus) {
                const prefix = '🎵 ';
                const suffix = ' 🎵';
    
                // set track info as status
                backend.extended().setStatus({
                    game: {
                        name: prefix + formatTrack(track) + suffix,
                        type: 2, // => 0 (game), 1 (streaming), 2 (listening)
                    },
                    status: "online",
                    afk: false
                });
            }
    
            // update embeds
            lastEmbeds.forEach(async embed => {
                await editMessage(embed.channelId, embed.messageId, getPlayingEmbed()).then(() => wait(100));
            });
        };
    
        event.on('track', onChange);
        event.on('trackInfo', onChange);
        event.on('trackEnd', () => {
            if (!config.songInStatus) {
                return;
            }
            if (getBotClient()) {
                bot.setDescription('');
            }
        });
    }

    /**
     * Returns embed for current track
     */
    function getPlayingEmbed() {
        let track = media.getCurrentTrack();

        if (!track) {
            return {
                content: "",
                embed: {},
            };
        }

        let album = track.album();
        let duration = track.duration();

        let fields = [];
        fields.push({
            name: "Duration",
            value: duration ? timestamp(duration) : 'stream',
            inline: true
        });
        if (album) {
            fields.push({
                name: "Album",
                value: album,
                inline: true
            });
        }

        return {
            content: formatTrack(track),
            embed: {
                title: formatTrack(track),
                url: sinusbotURL || null,
                color: 0xe13438,
                thumbnail: {
                    url: sinusbotURL && track.thumbnail() ? `${sinusbotURL}/cache/${track.thumbnail()}` : null
                },
                fields: fields,
                footer: {
                    icon_url: "https://sinusbot.github.io/logo.png",
                    text: "SinusBot"
                }
            },
        };
    }

    /**
     * Returns a fake client object from IDs. (Discord only)
     * @param {string} guild Guild ID
     * @param {string} id User ID
     * @param {string} channelid Channel ID
     */
    function fakeClient(guild, id, channelid) {
        const clid = `${guild}/${id}`
        return {
            chat: (/** @type {string} */ str) => {
                backend.extended().createMessage(channelid, {
                    content: str
                });
            },
            isSelf: () => false,
            id: () => clid,
            uid: () => clid,
            uniqueId: () => clid,
            uniqueID: () => clid,
            DBID: () => clid,
            databaseID: () => clid,
            databaseId: () => clid,
            type: () => 1,
            getURL: () => `<@${id}>`,
            name: () => `unknown (ID: ${id})`,
            nick: () => `unknown (ID: ${id})`,
            phoneticName: () => '',
            description: () => '',
            getServerGroups: () => [],
            getChannelGroup: () => null,
            getChannels: () => [],
            getAudioChannel: () => null,
            equals: (/** @type {Client} */ client) => {
              const uid = client.uid().split("/")
              if (uid.length === 2) {
                return uid[2] === id
              } else {
                return client.uid() === clid
              }
            }
        }
    }

    /********** helper functions **********/

    /**
     * Returns the first user with a given UID.
     *
     * @param {string} uid UID of the client
     * @returns {User} first user with given uid
     */
    function getUserByUid(uid) {
        return engine.getUsers().find(user => user.tsUid() === uid)
    }

    /**
     * Returns alls users that match the clients UID and ServerGroups.
     *
     * @param {Client} client
     * @returns {User[]} Users that match the clients UID and ServerGroups.
     */
    function getUsersByClient(client) {
        return engine.getUsers().filter(user =>
            // does the UID match?
            client.uid() == user.uid() ||
            // does a group ID match?
            client.getServerGroups().map(group => group.id()).includes(user.groupId()) ||
            // group ID '-1' matches everyone
            user.groupId() == '-1'
        );
    }

    /**
     * Returns a function that checks if a given user has all of the required privileges.
     * @param {...number} privileges If at least one privilege matches the returned function will return true.
     */
    function requirePrivileges(...privileges) {
        return (/** @type {Client} */ client) => {
            // check if at least one user has the required privileges
            return getUsersByClient(client).some(user => {
                // check if at least one privilege is found
                return privileges.some(priv => {
                    return ((user.privileges()|user.instancePrivileges()) & priv) === priv;
                });
            });
        };
    }

    // /**
    //  * Returns a formatted string from a track.
    //  *
    //  * @param {Track} track
    //  * @returns {string} formatted string
    //  */
    // function formatTrackWithID(track) {
    //     return `${format.code(track.id())} ${formatTrack(track)}`;
    // }

    /**
     * Returns a formatted string from a track.
     *
     * @param {Track} track
     * @returns {string} formatted string
     */
    function formatTrack(track) {
        let title = track.tempTitle() || track.title();
        let artist = track.tempArtist() || track.artist();
        return artist ? `${artist} - ${title}` : title;
    }

    /**
     * Removes TeamSpeaks URL bb-code or Discords < > from a given string.
     *
     * @param {string} str
     * @returns {string} str without [URL] [/URL] and < >
     */
    function stripURL(str) {
        // don't handle non-strings, return as provided
        if (typeof str !== 'string') return str;

        // remove surrounding [URL] [/URL] tags
        let match = str.match(/\[URL\](.+)\[\/URL\]/i);
        if (match && match.length >= 2) {
            return match[1];
        }

        // remove surrounding < >
        match = str.match(/<(.+)>/);
        if (match && match.length >= 2) {
            return match[1];
        }

        // if nothing matches just return str
        return str;
    }

    /**
     * Returns a more human readable timestamp (hours:minutes:secods)
     * @param {number} milliseconds
     */
    function timestamp(milliseconds) {
        const SECOND = 1000; //milliseconds
        const MINUTE = 60 * SECOND;
        const HOUR = 60 * MINUTE;

        let seconds = Math.floor(milliseconds / SECOND);
        let minutes = Math.floor(milliseconds / MINUTE);
        let hours = Math.floor(milliseconds / HOUR);
        
        minutes = minutes % (HOUR/MINUTE);
        seconds = seconds % (MINUTE/SECOND);

        let str = '';

        if (hours !== 0) {
            str += hours + ':';
            if (minutes <= 9) {
                str += '0';
            }
        }
        str += minutes + ':';
        if (seconds <= 9) {
            str += '0';
        }
        str += seconds;

        return str;
    }

    /**
     * @ignore
     * @typedef MessageEvent
     * @type {object}
     * @property {Client} client
     * @property {Channel} channel
     * @property {string} text
     * @property {number} mode
     * @property {DiscordMessage} [message]
     */

    /**
     * Gives the user feedback if a command was successfull.
     *
     * @param {MessageEvent} ev
     * @param {(msg: string) => void} reply
     */
    function successReaction(ev, reply) {
        if (!config.createSuccessReaction) {
            return;
        }
        switch (engine.getBackend()) {
            case "discord":
                if (ev.message) ev.message.createReaction(REACTION_SUCCESS)
                return
            case "ts3":
                return reply(`${REACTION_SUCCESS} done!`)
        }
    }
    
    /**
     * Waits for given milliseconds.
     * @param {number} ms Time to wait for in milliseconds.
     * @return {Promise}
     */
    function wait(ms) {
        return new Promise(resolve => setTimeout(resolve, ms));
    }

    /**
     * Adds a reaction to a message.
     * @param {string} channelID Channel ID
     * @param {string} messageID Message ID
     * @param {string} emoji Emoji
     * @return {Promise<object>}
     * @author Jonas Bögle
     * @license MIT
     */
    function createReaction(channelID, messageID, emoji) {
        return discord('PUT', `/channels/${channelID}/messages/${messageID}/reactions/${emoji}/@me`, null, false);
    }

    /**
     * Removes a reaction from a message.
     * @param {string} channelID Channel ID
     * @param {string} messageID Message ID
     * @param {string} userID User ID
     * @param {string} emoji Emoji
     * @return {Promise<object>}
     * @author Jonas Bögle
     * @license MIT
     */
    function deleteUserReaction(channelID, messageID, userID, emoji) {
        return discord('DELETE', `/channels/${channelID}/messages/${messageID}/reactions/${emoji}/${userID}`, null, false);
    }

    /**
     * Gets a message.
     * @param {string} channelID Channel ID
     * @param {string} messageID Message ID
     * @return {Promise<object>}
     * @author Jonas Bögle
     * @license MIT
     */
    function getMessage(channelID, messageID) {
        return discord('GET', `/channels/${channelID}/messages/${messageID}`, null, true);
    }

    /**
     * Edits a message.
     * @param {string} channelID Channel ID
     * @param {string} messageID Message ID
     * @param {object} message New message
     * @return {Promise<object>}
     * @author Jonas Bögle
     * @license MIT
     */
    function editMessage(channelID, messageID, message) {
        return discord('PATCH', `/channels/${channelID}/messages/${messageID}`, message, true);
    }

    /**
     * Deletes a message.
     * @param {string} channelID Channel ID
     * @param {string} messageID Message ID
     * @return {Promise<object>}
     * @author Jonas Bögle
     * @license MIT
     */
    function deleteMessage(channelID, messageID) {
        return discord('DELETE', `/channels/${channelID}/messages/${messageID}`, null, false);
    }

    /**
     * Deletes multiple messages.
     * @param {string} channelID Channel ID
     * @param {string[]} messageIDs Message IDs
     * @return {Promise<object>}
     * @author Jonas Bögle
     * @license MIT
     */
    function deleteMessages(channelID, messageIDs) {
        switch (messageIDs.length) {
            case 0: return Promise.resolve();
            case 1: return deleteMessage(channelID, messageIDs[0]);
            default: return discord('POST', `/channels/${channelID}/messages/bulk-delete`, {messages: messageIDs}, false);
        }
    }

    /**
     * Executes a discord API call
     * @param {string} method http method
     * @param {string} path path
     * @param {object} [data] json data
     * @param {boolean} [repsonse] `true` if you're expecting a json response, `false` otherwise
     * @return {Promise<object>}
     * @author Jonas Bögle
     * @license MIT
     */
    function discord(method, path, data=null, repsonse=true) {
        return new Promise((resolve, reject) => {
            backend.extended().rawCommand(method, path, data, (err, data) => {
                if (err) return reject(err);
                if (repsonse) {
                    let res;
                    try {
                        res = JSON.parse(data);
                    } catch (err) {
                        engine.log(`${method} ${path} failed`)
                        engine.log(`${data}`)
                        return reject(err);
                    }
                    
                    if (res === undefined) {
                        engine.log(`${method} ${path} failed`)
                        engine.log(`${data}`)
                        return reject('Invalid Response');
                    }

                    return resolve(res);
                }
                resolve();
            });
        });
    }
})