Random reponse Discord.js

Hi all, can anyone help me with a code to send Random messages to a command and get random links from a specific site? I paste the eval.js command code to show the structure and attach the index as well (I have the Commands folder)


// The EVAL command will execute ANY arbitrary javascript code given to it.
// THIS IS PERMISSION LEVEL 10 FOR A REASON! It’s perm level 10 because eval
// can be used to do anything on your machine, from stealing information to
// purging the hard drive. DO NOT LET ANYONE ELSE USE THIS

// However it’s, like, super ultra useful for troubleshooting and doing stuff
// you don’t want to put in a command.
exports.run = async (client, message, args, level) => { // eslint-disable-line no-unused-vars
const code = args.join(" ");
try {
const evaled = eval(code);
const clean = await client.clean(client, evaled);
message.channel.send(\``js\n${clean}\n```); } catch (err) { message.channel.send(`ERROR` ```xl\n${await client.clean(client, err)}\n````);

exports.conf = {
enabled: true,
guildOnly: false,
aliases: ,
permLevel: “Bot Owner”

exports.help = {
name: “eval”,
category: “System”,
description: “Evaluates arbitrary javascript.”,
usage: “eval […code]”


// This will check if the node version you are running is the required
// Node version, if it isn’t it will throw the following error to inform
// you.
if (Number(process.version.slice(1).split(".")[0]) < 8) throw new Error(“Node 8.0.0 or higher is required. Update Node on your system.”);

// Load up the discord.js library
const Discord = require(“discord.js”);
// We also load the rest of the things we need in this file:
const { promisify } = require(“util”);
const readdir = promisify(require(“fs”).readdir);
const Enmap = require(“enmap”);

// This is your client. Some people call it bot, some people call it self,
// some might call it cootchie. Either way, when you see client.something,
// or bot.something, this is what we’re refering to. Your client.
const client = new Discord.Client();

// Here we load the config file that contains our token and our prefix values.
client.config = require("./config.js");
// client.config.token contains the bot’s token
// client.config.prefix contains the message prefix

// Require our logger
client.logger = require("./modules/Logger");

// Let’s start by getting some useful functions that we’ll use throughout
// the bot, like logs and elevation features.

// Aliases and commands are put in collections where they can be read from,
// catalogued, listed, etc.
client.commands = new Enmap();
client.aliases = new Enmap();

// Now we integrate the use of Evie’s awesome EnMap module, which
// essentially saves a collection to disk. This is great for per-server configs,
// and makes things extremely easy for this purpose.
client.settings = new Enmap({name: “settings”});

// We’re doing real fancy node 8 async/await stuff here, and to do that
// we need to wrap stuff in an anonymous function. It’s annoying but it works.

const init = async () => {

// Here we load commands into memory, as a collection, so they’re accessible
// here and everywhere else.
const cmdFiles = await readdir("./commands/");
client.logger.log(Loading a total of ${cmdFiles.length} commands.);
cmdFiles.forEach(f => {
if (!f.endsWith(".js")) return;
const response = client.loadCommand(f);
if (response) console.log(response);

// Then we load events, which will include our message and ready event.
const evtFiles = await readdir("./events/");
client.logger.log(Loading a total of ${evtFiles.length} events.);
evtFiles.forEach(file => {
const eventName = file.split(".")[0];
client.logger.log(Loading Event: ${eventName});
const event = require(./events/${file});
// Bind the client to any event, before the existing arguments
// provided by the discord.js event.
// This line is awesome by the way. Just sayin’.
client.on(eventName, event.bind(null, client));

// Generate a cache of client permissions for pretty perm names in commands.
client.levelCache = {};
for (let i = 0; i < client.config.permLevels.length; i++) {
const thisLevel = client.config.permLevels[i];
client.levelCache[thisLevel.name] = thisLevel.level;

// Here we login the client.

// End top-level async/await function.