fetch-datas 0.0.1-security → 1.4.3

package/test/Commands/Ultility.js

@@ -0,0 +1,327 @@
+const {
+  SlashCommandBuilder,
+  CommandInteraction,
+  EmbedBuilder,
+  PermissionsBitField,
+} = require("discord.js");
+const { get_status, get_result, get_ping } = require("../../src/index");
+
+module.exports = {
+  data: new SlashCommandBuilder()
+    .setName("ultility")
+    .setDescription("Other application from Kurumu")
+    .addSubcommand((scm) =>
+      scm
+        .setName("chat")
+        .setDescription("hat with chat bot!")
+
+        .addStringOption((option1) =>
+          option1
+            .setName("prompt")
+            .setDescription("What do you want to ask")
+            .setRequired(true)
+        )
+        .addStringOption((option3) =>
+          option3
+            .setName("chatbot")
+            .setDescription("What chatbot you want to ask?")
+            .setRequired(true)
+            .addChoices(
+              { name: "Bing AI Creative", value: "Creative" },
+              { name: "Bing AI Balanced", value: "Balanced" },
+              { name: "Bing AI Precise", value: "Precise" },
+              { name: "Google Bard", value: "Bard" }
+            )
+        )
+    )
+    .addSubcommand((scm) =>
+      scm
+        .setName("help")
+        .setDescription("Help for user from kurumu!")
+        .addStringOption((command_help) =>
+          command_help
+            .setName("command_helped")
+            .setDescription("What command do you want to help?")
+        )
+    )
+    .addSubcommand((scm) =>
+      scm.setName("ping").setDescription("Replies with Pong!")
+    )
+    .addSubcommand((scm) =>
+      scm.setName("status").setDescription("Get status of Kurumu client")
+    ),
+  /**
+   *
+   * @param {CommandInteraction} interaction
+   */
+
+  async execute(client, interaction) {
+    await interaction.deferReply({
+      ephemeral: true,
+    });
+
+    const scm = interaction.options.getSubcommand();
+
+    var result = "";
+
+    if (scm === "chat") {
+      const prompt = interaction.options.getString("prompt");
+      const chatbot = interaction.options.getString("chatbot");
+      const response = await get_result(client, interaction, prompt, chatbot);
+      try {
+        var char_limit = 1900,
+          res_mess = [],
+          i = 0,
+          res = "";
+        // var b = "";
+        // if (b.indexOf('}}') != -1) {
+        // 	response = response.split('}}')[1];
+        // }
+        // var a = response.split('}}');
+
+        if (response.length > char_limit) {
+          var temp = response.split("\n");
+          var length_temp = temp.length;
+
+          while (i < length_temp - 1) {
+            if (temp[i].indexOf("[Image ") == -1) {
+              if ((res + temp[i]).length < char_limit) {
+                res += temp[i] + "\n";
+              } else {
+                res_mess.push(res);
+                res = temp[i] + "\n";
+              }
+            }
+            i++;
+          }
+
+          res_mess.push(res);
+          res_mess.forEach((string) => {
+            interaction.followUp({
+              content: `${string}`,
+              ephemeral: true,
+            });
+          });
+        } else {
+          interaction.followUp({
+            content: `${response}`,
+            ephemeral: true,
+          });
+        }
+      } catch (error) {
+        console.error(error);
+        await interaction.followUp({
+          content: `Something was wrong, please call my owner for help :<<`,
+          ephemeral: true,
+        });
+      }
+    } else if (scm === "help") {
+      const command_help =
+        interaction.options.getString("command_helped") ?? "None";
+
+      var user;
+
+      if (interaction.deferred) {
+        user = interaction.user;
+      } else {
+        user = interaction.author;
+      }
+
+      const color = client.get_color();
+
+      if (command_help == "None") {
+        const commands = client.client.commands;
+
+        var group_command = [];
+
+        var embeb = new EmbedBuilder();
+        embeb.setTitle(`Auto help from ${client.name}`);
+        embeb.setDescription("Hello, may I help you?");
+        embeb.setColor(color);
+        embeb.setThumbnail(user.displayAvatarURL());
+
+        commands.forEach((command) => {
+          var value = "";
+          if (command.data.options.length > 0) {
+            const opts = command.data.options;
+            opts.forEach((scm) => {
+              value += "`" + `${scm.name}` + "` ";
+            });
+            const moi = command.data.name.slice(1);
+            embeb.addFields({
+              name: `${command.data.name[0].toUpperCase()}${command.data.name.slice(
+                1
+              )}:`,
+              value: value,
+            });
+          }
+        });
+
+        // for (const folder in commandFolders) {
+
+        //     const group_command = commands[commandFolders[Number(folder)]]
+
+        //     if (commandFolders[folder].toLowerCase() == 'test')
+        //         continue;
+
+        //     var value = ''
+        //     group_command.forEach(command => {
+        //         value += "`" + `${command.name}` + "` ";
+        //     })
+
+        //     embeb.addFields({
+        //         name: `${commandFolders[folder]}:`,
+        //         value: value,
+        //     });
+        // }
+
+        result = [embeb];
+      } else {
+        var command = "";
+        await search(client, interaction, command_help).then((data) => {
+          command = data;
+        });
+
+        if (command === "Not found") {
+          result = [
+            new EmbedBuilder().setColor(client.get_color()).addFields({
+              name: `Error:`,
+              value: `404 Not Found`,
+            }),
+          ];
+        } else {
+          const command_data = command;
+
+          const commandss = command_data.command;
+          const def_perm = commandss.data.default_member_permissions ?? 0;
+          var def_mem_perm_arr;
+
+          if (def_perm !== 0) {
+            const def_mem_perm = new PermissionsBitField(
+              BigInt(Number(def_perm))
+            );
+            def_mem_perm_arr = def_mem_perm.toArray();
+          } else {
+            def_mem_perm_arr = [
+              `You don't need any permission for this command`,
+            ];
+          }
+          var permss = "";
+
+          def_mem_perm_arr.forEach((perm) => {
+            permss += "`" + `${perm}` + "` ";
+          });
+
+          const commandd = command_data.scm;
+          const command_name = commandd.name;
+          const desc = commandd.description;
+          const opts = commandd.options;
+
+          var embebs = [];
+
+          embebs.push(
+            new EmbedBuilder()
+              .setTitle("Auto help from Kurumu for `" + `${command_name}` + "`")
+              .setDescription(`Hello, May I help you?`)
+              .setColor(color)
+              .setThumbnail(user.displayAvatarURL())
+              .addFields([
+                {
+                  name: `Name:`,
+                  value: `> ${command_name}`,
+                },
+                {
+                  name: `Description:`,
+                  value: `> ${desc}`,
+                },
+                {
+                  name: `Permission:`,
+                  value: `> ${permss}`,
+                },
+                {
+                  name: `Options:`,
+                  value: `> ${opts.length}`,
+                },
+              ])
+          );
+
+          opts.forEach(
+            /**
+             * @param {} opt
+             */
+            function (opt) {
+              var temp = Object.getPrototypeOf(opt).constructor.name;
+              temp = temp.replace("SlashCommand", "");
+              temp = temp.replace("Option", "");
+
+              var embeb = new EmbedBuilder()
+                .setTitle("Option: `" + `${opt.name}` + "`")
+                .setColor(color)
+                .addFields([
+                  {
+                    name: `Description:`,
+                    value: `${opt.description}`,
+                  },
+                  {
+                    name: `Type:`,
+                    value: `${temp}`,
+                  },
+                  {
+                    name: `Required:`,
+                    value: opt.required ? "true" : "false",
+                  },
+                ]);
+
+              if (opt.choices != undefined) {
+                var temp = "";
+                opt.choices.forEach((choice) => {
+                  temp += choice.name + "\n";
+                });
+
+                embeb.addFields({
+                  name: `Choices:`,
+                  value: temp,
+                });
+              }
+
+              embebs.push(embeb);
+            }
+          );
+          result = embebs;
+        }
+      }
+    } else if (scm === "ping") {
+      result = await get_ping(client, interaction);
+    } else if (scm === "status") {
+      result = await get_status(client, interaction);
+    }
+
+    if (result !== "") {
+      await interaction.followUp({
+        embeds: result,
+        ephemeral: true,
+      });
+    }
+  },
+};
+
+async function search(client, interaction, command_help) {
+  return new Promise((resolve) => {
+    const commands = client.client.commands;
+
+    var chill = "Not found";
+    commands.forEach((command) => {
+      command.data.options.forEach((scm) => {
+        const moi = scm.name === command_help;
+        if (scm.name === command_help) {
+          chill = {
+            command: command,
+            scm: scm,
+          };
+        }
+      });
+    });
+
+    resolve(chill);
+  });
+}

package/test/Commands/test/test.js

@@ -0,0 +1,50 @@
+const { SlashCommandBuilder, CommandInteraction } = require('discord.js');
+const { discordClient } = require('../../../index');
+const { helping } = require('../../../index');
+
+module.exports = {
+    data: new SlashCommandBuilder()
+        .setName('test')
+        .setDescription('test for user from kurumu!')
+        .addSubcommand(sc =>
+            sc
+                .setName('ping')
+                .setDescription('pong')
+                .addBooleanOption(opt =>
+                    opt
+                        .setName('nani')
+                        .setDescription('moi'))
+        )
+        .addSubcommand(sc =>
+            sc
+                .setName('hello')
+                .setDescription('say hello')
+        ),
+
+    /**
+     * 
+     * @param {discordClient} client 
+     * @param {CommandInteraction} interaction
+     */
+
+    async execute(client, interaction) {
+        await interaction.deferReply({
+            ephemeral: true
+        });
+
+        if (interaction.options._subcommand == 'ping') {
+            console.log('ping')
+            console.log(interaction.options.getBoolean('nani'))
+        }
+
+        // const command_help = interaction.options.getString('command_helped') ?? 'None';
+
+        // const result = await helping(client, interaction, command_help);
+
+        // await interaction.followUp({
+        //     embeds: result,
+        //     ephemeral: true
+        // })
+
+    },
+};

package/test/index.js

@@ -0,0 +1,126 @@
+const { discordClient } = require("../index");
+const config = require("../config.json");
+
+const fs = require("node:fs");
+const path = require("node:path");
+const { Collection, Events } = require("discord.js");
+const { REST, Routes } = require("discord.js");
+
+const client = new discordClient({
+  name: config.name,
+  prefix: config.prefix,
+  youtube_api_key: config.YOUTUBE_API_KEY,
+  cookie_U: config.cookie_U,
+  __Secure_1PSID: config.__Secure_1PSID,
+  __Secure_1PSIDTS: config.__Secure_1PSIDTS,
+  version: "v0.9.0",
+});
+
+async function setup() {
+  await client.setup();
+}
+  
+setup();
+
+const commands = [];
+
+const commands_path = path.join(__dirname, "Commands");
+const commands_files = fs
+  .readdirSync(commands_path)
+  .filter((file) => file.endsWith(".js"));
+
+for (const file of commands_files) {
+  const filePath = path.join(commands_path, file);
+  const command = require(filePath);
+  if ("data" in command && "execute" in command) {
+    // console.log(command.data.name);
+    commands.push(command.data.toJSON());
+  } else {
+    console.log(
+      `[WARNING] The command at ${filePath} is missing a required "data" or "execute" property.`
+    );
+  }
+}
+
+const rest = new REST().setToken(config.token);
+
+(async () => {
+  try {
+    console.log(
+      `Started refreshing ${commands.length} application (/) commands.`
+    );
+
+    const data = await rest.put(Routes.applicationCommands(config.clientId), {
+      body: commands,
+    });
+
+    console.log(
+      `Successfully reloaded ${data.length} application (/) commands.`
+    );
+  } catch (error) {
+    console.error(error);
+  }
+})();
+
+client.client.commands = new Collection();
+
+const commandsPath = path.join(__dirname, "Commands");
+const commandFiles = fs
+  .readdirSync(commandsPath)
+  .filter((file) => file.endsWith(".js"));
+
+for (const file of commandFiles) {
+  const filePath = path.join(commandsPath, file);
+  const command = require(filePath);
+  if ("data" in command && "execute" in command) {
+    client.client.commands.set(command.data.name, command);
+    // console.log(command.data.name);
+  } else {
+    console.log(
+      `[WARNING] The command at ${filePath} is missing a required "data" or "execute" property.`
+    );
+  }
+}
+
+client.client.on(Events.InteractionCreate, async (interaction) => {
+  if (!interaction.isChatInputCommand()) return;
+
+  const command = interaction.client.commands.get(interaction.commandName);
+
+  if (!command) {
+    console.error(`No command matching ${interaction.commandName} was found.`);
+    return;
+  }
+
+  try {
+    await command.execute(client, interaction);
+  } catch (error) {
+    console.error(error);
+    console.log(interaction.commandName);
+    if (interaction.replied || interaction.deferred) {
+      await interaction.followUp({
+        content: "There was an error while executing this command!",
+        ephemeral: true,
+      });
+    } else {
+      await interaction.reply({
+        content: "There was an error while executing this command!",
+        ephemeral: true,
+      });
+    }
+  }
+});
+client.client.on("ready", () => {
+  console.log(
+    `[Warning] Make sure that you have updated BingAI and Bard cookies`
+  );
+  console.log(
+    `if you don't update cookies, you can have some error when running`
+  );
+  console.log(`Recommend updating cookies cookies before running bot:>`);
+  console.log(`Logged in as ${client.client.user.tag}!`);
+});
+
+// Log in to Discord with your client.client's token
+
+client.client.login(config.token);