@fjrodafo/discord-app 1.0.0

package/CONTRIBUTING

@@ -0,0 +1,9 @@
+Feel free to contribute to this repository!
+
+If you spot a problem with the docs, search if an issue already exists at https://github.com/FJrodafo/DiscordAPP/issues. If a related issue doesn't exist, you can open a new issue using a relevant issue form.
+
+If you find an issue to work on, you are welcome to open a pull/merge request with a fix at https://github.com/FJrodafo/DiscordAPP/pulls. To work on the pull request, fork the repository at https://github.com/FJrodafo/DiscordAPP/forks.
+
+Please do not copy questions and answers from other sources, they probably worked hard to add them, and if you add new images, make sure they are free and usable.
+
+Thank you very much for the contribution!

package/LICENSE

@@ -0,0 +1,121 @@
+Creative Commons Legal Code
+
+CC0 1.0 Universal
+
+    CREATIVE COMMONS CORPORATION IS NOT A LAW FIRM AND DOES NOT PROVIDE
+    LEGAL SERVICES. DISTRIBUTION OF THIS DOCUMENT DOES NOT CREATE AN
+    ATTORNEY-CLIENT RELATIONSHIP. CREATIVE COMMONS PROVIDES THIS
+    INFORMATION ON AN "AS-IS" BASIS. CREATIVE COMMONS MAKES NO WARRANTIES
+    REGARDING THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS
+    PROVIDED HEREUNDER, AND DISCLAIMS LIABILITY FOR DAMAGES RESULTING FROM
+    THE USE OF THIS DOCUMENT OR THE INFORMATION OR WORKS PROVIDED
+    HEREUNDER.
+
+Statement of Purpose
+
+The laws of most jurisdictions throughout the world automatically confer
+exclusive Copyright and Related Rights (defined below) upon the creator
+and subsequent owner(s) (each and all, an "owner") of an original work of
+authorship and/or a database (each, a "Work").
+
+Certain owners wish to permanently relinquish those rights to a Work for
+the purpose of contributing to a commons of creative, cultural and
+scientific works ("Commons") that the public can reliably and without fear
+of later claims of infringement build upon, modify, incorporate in other
+works, reuse and redistribute as freely as possible in any form whatsoever
+and for any purposes, including without limitation commercial purposes.
+These owners may contribute to the Commons to promote the ideal of a free
+culture and the further production of creative, cultural and scientific
+works, or to gain reputation or greater distribution for their Work in
+part through the use and efforts of others.
+
+For these and/or other purposes and motivations, and without any
+expectation of additional consideration or compensation, the person
+associating CC0 with a Work (the "Affirmer"), to the extent that he or she
+is an owner of Copyright and Related Rights in the Work, voluntarily
+elects to apply CC0 to the Work and publicly distribute the Work under its
+terms, with knowledge of his or her Copyright and Related Rights in the
+Work and the meaning and intended legal effect of CC0 on those rights.
+
+1. Copyright and Related Rights. A Work made available under CC0 may be
+protected by copyright and related or neighboring rights ("Copyright and
+Related Rights"). Copyright and Related Rights include, but are not
+limited to, the following:
+
+  i. the right to reproduce, adapt, distribute, perform, display,
+     communicate, and translate a Work;
+ ii. moral rights retained by the original author(s) and/or performer(s);
+iii. publicity and privacy rights pertaining to a person's image or
+     likeness depicted in a Work;
+ iv. rights protecting against unfair competition in regards to a Work,
+     subject to the limitations in paragraph 4(a), below;
+  v. rights protecting the extraction, dissemination, use and reuse of data
+     in a Work;
+ vi. database rights (such as those arising under Directive 96/9/EC of the
+     European Parliament and of the Council of 11 March 1996 on the legal
+     protection of databases, and under any national implementation
+     thereof, including any amended or successor version of such
+     directive); and
+vii. other similar, equivalent or corresponding rights throughout the
+     world based on applicable law or treaty, and any national
+     implementations thereof.
+
+2. Waiver. To the greatest extent permitted by, but not in contravention
+of, applicable law, Affirmer hereby overtly, fully, permanently,
+irrevocably and unconditionally waives, abandons, and surrenders all of
+Affirmer's Copyright and Related Rights and associated claims and causes
+of action, whether now known or unknown (including existing as well as
+future claims and causes of action), in the Work (i) in all territories
+worldwide, (ii) for the maximum duration provided by applicable law or
+treaty (including future time extensions), (iii) in any current or future
+medium and for any number of copies, and (iv) for any purpose whatsoever,
+including without limitation commercial, advertising or promotional
+purposes (the "Waiver"). Affirmer makes the Waiver for the benefit of each
+member of the public at large and to the detriment of Affirmer's heirs and
+successors, fully intending that such Waiver shall not be subject to
+revocation, rescission, cancellation, termination, or any other legal or
+equitable action to disrupt the quiet enjoyment of the Work by the public
+as contemplated by Affirmer's express Statement of Purpose.
+
+3. Public License Fallback. Should any part of the Waiver for any reason
+be judged legally invalid or ineffective under applicable law, then the
+Waiver shall be preserved to the maximum extent permitted taking into
+account Affirmer's express Statement of Purpose. In addition, to the
+extent the Waiver is so judged Affirmer hereby grants to each affected
+person a royalty-free, non transferable, non sublicensable, non exclusive,
+irrevocable and unconditional license to exercise Affirmer's Copyright and
+Related Rights in the Work (i) in all territories worldwide, (ii) for the
+maximum duration provided by applicable law or treaty (including future
+time extensions), (iii) in any current or future medium and for any number
+of copies, and (iv) for any purpose whatsoever, including without
+limitation commercial, advertising or promotional purposes (the
+"License"). The License shall be deemed effective as of the date CC0 was
+applied by Affirmer to the Work. Should any part of the License for any
+reason be judged legally invalid or ineffective under applicable law, such
+partial invalidity or ineffectiveness shall not invalidate the remainder
+of the License, and in such case Affirmer hereby affirms that he or she
+will not (i) exercise any of his or her remaining Copyright and Related
+Rights in the Work or (ii) assert any associated claims and causes of
+action with respect to the Work, in either case contrary to Affirmer's
+express Statement of Purpose.
+
+4. Limitations and Disclaimers.
+
+ a. No trademark or patent rights held by Affirmer are waived, abandoned,
+    surrendered, licensed or otherwise affected by this document.
+ b. Affirmer offers the Work as-is and makes no representations or
+    warranties of any kind concerning the Work, express, implied,
+    statutory or otherwise, including without limitation warranties of
+    title, merchantability, fitness for a particular purpose, non
+    infringement, or the absence of latent or other defects, accuracy, or
+    the present or absence of errors, whether or not discoverable, all to
+    the greatest extent permissible under applicable law.
+ c. Affirmer disclaims responsibility for clearing rights of other persons
+    that may apply to the Work or any use thereof, including without
+    limitation any person's Copyright and Related Rights in the Work.
+    Further, Affirmer disclaims responsibility for obtaining any necessary
+    consents, permissions or other rights required for any use of the
+    Work.
+ d. Affirmer understands and acknowledges that Creative Commons is not a
+    party to this document and has no duty or obligation with respect to
+    this CC0 or use of the Work.

package/dashboard/index.js

@@ -0,0 +1,27 @@
+const express = require('express');
+const http = require('node:http');
+const path = require('node:path');
+const { findAvailablePort } = require('@fjrodafo/port-finder');
+
+module.exports = (client) => {
+    const app = express();
+    const server = http.createServer(app);
+    const apiRoutes = require('./routes/api.js')(client);
+    const logsRoutes = require('./routes/logs.js')();
+    const metricsRoute = require('./routes/metrics.js')(client);
+    const desiredPort = process.env.PORT ?? 3000;
+
+    app.use(express.static(path.join(__dirname, 'public')));
+
+    app.use('/api', apiRoutes);
+    app.use('/logs', logsRoutes);
+    app.use('/metrics', metricsRoute);
+
+    findAvailablePort(desiredPort).then(port => {
+        server.listen(port, () => {
+            console.log(`Dashboard --> http://localhost:${port}`);
+        });
+    }).catch(err => {
+        console.error('Error searching for available port:', err);
+    });
+};

package/dashboard/public/index.html

@@ -0,0 +1,18 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <title>DiscordAPP | Dashboard</title>
+    <link rel="stylesheet" href="style.css">
+</head>
+
+<body>
+    <h2>DiscordAPP | Dashboard</h2>
+    <button id="apiBtn">API</button>
+    <button id="logsBtn">Logs</button>
+    <button id="metricsBtn">Metrics</button>
+    <script src="script.js"></script>
+</body>
+
+</html>

package/dashboard/public/script.js

@@ -0,0 +1,11 @@
+document.getElementById('apiBtn').addEventListener('click', () => {
+    window.open('/api', '_blank');
+});
+
+document.getElementById('logsBtn').addEventListener('click', () => {
+    window.open('/logs', '_blank');
+});
+
+document.getElementById('metricsBtn').addEventListener('click', () => {
+    window.open('/metrics', '_blank');
+});

package/dashboard/routes/api.js

@@ -0,0 +1,75 @@
+const express = require('express');
+const router = express.Router();
+const { formatAge, formatTime, formatMemory, formatCPU } = require('./../utils/format.js');
+
+module.exports = (client) => {
+    router.get('/', (_, res) => {
+        try {
+            res.json({
+                app: {
+                    id: client.user.id,
+                    username: client.user.username,
+                    tag: client.user.tag,
+                    discriminator: client.user.discriminator,
+                    avatarURL: {
+                        webp: client.user.displayAvatarURL({ dynamic: true }),
+                        png: client.user.displayAvatarURL({ dynamic: true }).replace('webp', 'png'),
+                    },
+                    createdAt: client.user.createdAt,
+                    createdTimestamp: formatAge(client.user.createdTimestamp),
+                },
+                status: {
+                    online: client.isReady(),
+                    status: client.isReady() ? 'Online' : 'Offline',
+                    presence: client.user.presence?.status ?? 'unknown',
+                    activity: client.user.presence?.activities[0]?.name ?? 'None',
+                    activityType: client.user.presence?.activities[0]?.type ?? 'None',
+                    readyTimestamp: formatTime(Math.floor((Date.now() - client.readyTimestamp) / 1000)),
+                    ping: client.ws.ping,
+                },
+                commands: {
+                    total: client.commands.size,
+                    commandsList: Array.from(client.commands.keys()),
+                    cooldowns: client.cooldowns.size,
+                    events: client.eventNames().length,
+                    eventsList: client.eventNames(),
+                },
+                guilds: {
+                    total: client.guilds.cache.size,
+                    guildUsers: client.guilds.cache.reduce((acc, g) => acc + g.memberCount, 0),
+                    averageMembers: Math.round(client.guilds.cache.reduce((acc, g) => acc + g.memberCount, 0) / client.guilds.cache.size),
+                    largestGuild: client.guilds.cache.sort((a, b) => b.memberCount - a.memberCount).first()?.name ?? 'N/A',
+                    smallestGuild: client.guilds.cache.sort((a, b) => a.memberCount - b.memberCount).first()?.name ?? 'N/A',
+                    guildsDetails: client.guilds.cache.map(g => ({
+                        id: g.id,
+                        name: g.name,
+                        members: g.memberCount,
+                        channels: g.channels.cache.size,
+                        bots: g.members.cache.filter(m => m.user.bot).size,
+                    })),
+                },
+                cache: {
+                    cachedUsers: client.users.cache.size,
+                    cachedChannels: client.channels.cache.size,
+                    cachedRoles: client.guilds.cache.reduce((acc, g) => acc + g.roles.cache.size, 0),
+                    cachedEmojis: client.guilds.cache.reduce((acc, g) => acc + g.emojis.cache.size, 0),
+                },
+                system: {
+                    uptime: formatTime(Math.floor(process.uptime())),
+                    memory: formatMemory(),
+                    cpu: formatCPU(),
+                    pid: process.pid,
+                    version: process.version,
+                    platform: process.platform,
+                    arch: process.arch,
+                },
+            });
+        }
+        catch (err) {
+            console.error('Error generating API response:', err);
+            res.status(500).json({ error: 'Internal Server Error' });
+        }
+    });
+
+    return router;
+};

package/dashboard/routes/logs.js

@@ -0,0 +1,11 @@
+const express = require('express');
+const router = express.Router();
+const logs = require('./../utils/logs.js');
+
+module.exports = () => {
+    router.get('/', (_, res) => {
+        res.json(logs.getAll());
+    });
+
+    return router;
+};

package/dashboard/routes/metrics.js

@@ -0,0 +1,57 @@
+const express = require('express');
+const router = express.Router();
+
+module.exports = (client) => {
+    router.get('/', (_, res) => {
+        const mem = process.memoryUsage();
+        const cpu = process.cpuUsage();
+        const uptime = Math.floor(process.uptime());
+        const guilds = client.guilds?.cache?.size ?? 0;
+        const users = client.users?.cache?.size ?? 0;
+
+        res.set('Content-Type', 'text/plain');
+        res.send(`
+# HELP discord_bot_up Is the bot online
+# TYPE discord_bot_up gauge
+discord_bot_up ${client.isReady() ? 1 : 0}
+
+# HELP discord_bot_ping Websocket ping
+# TYPE discord_bot_ping gauge
+discord_bot_ping ${client.ws?.ping ?? 0}
+
+# HELP process_uptime_seconds Process uptime
+# TYPE process_uptime_seconds gauge
+process_uptime_seconds ${uptime}
+
+# HELP process_cpu_user_microseconds_total CPU user time
+# TYPE process_cpu_user_microseconds_total counter
+process_cpu_user_microseconds_total ${cpu.user}
+
+# HELP process_cpu_system_microseconds_total CPU system time
+# TYPE process_cpu_system_microseconds_total counter
+process_cpu_system_microseconds_total ${cpu.system}
+
+# HELP process_memory_rss_bytes Resident Set Size
+# TYPE process_memory_rss_bytes gauge
+process_memory_rss_bytes ${mem.rss}
+
+# HELP process_memory_heap_used_bytes Heap used
+# TYPE process_memory_heap_used_bytes gauge
+process_memory_heap_used_bytes ${mem.heapUsed}
+
+# HELP process_memory_heap_total_bytes Heap total
+# TYPE process_memory_heap_total_bytes gauge
+process_memory_heap_total_bytes ${mem.heapTotal}
+
+# HELP discord_guilds_total Total guilds
+# TYPE discord_guilds_total gauge
+discord_guilds_total ${guilds}
+
+# HELP discord_users_cached Cached users
+# TYPE discord_users_cached gauge
+discord_users_cached ${users}
+`.trim());
+    });
+
+    return router;
+};

package/dashboard/utils/format.js

@@ -0,0 +1,60 @@
+function formatAge(timestampMs) {
+    const total = Math.floor((Date.now() - timestampMs) / 1000 / 86400);
+
+    const y = Math.floor(total / 365);
+    const m = Math.floor((total % 365) / 30);
+    const d = (total % 365) % 30;
+
+    return `${y}y ${m}m ${d}d`;
+}
+
+function formatTime(seconds) {
+    const h = Math.floor(seconds / 3600);
+    const m = Math.floor((seconds % 3600) / 60);
+    const s = Math.floor(seconds % 60);
+
+    return `${h}h ${m}m ${s}s`;
+}
+
+function formatMemory() {
+    const mem = process.memoryUsage();
+
+    const toMB = v => Math.round(v / 1024 / 1024);
+
+    return {
+        rss: `${toMB(mem.rss)} MB`,
+        heapUsed: `${toMB(mem.heapUsed)} MB`,
+        heapTotal: `${toMB(mem.heapTotal)} MB`,
+        external: `${toMB(mem.external)} MB`,
+        usagePercent: `${Math.round((mem.heapUsed / mem.heapTotal) * 100)}%`,
+    };
+}
+
+let lastCPU = process.cpuUsage();
+let lastTime = Date.now();
+
+function formatCPU() {
+    const now = Date.now();
+    const usage = process.cpuUsage(lastCPU);
+
+    const elapsedMs = now - lastTime;
+    const elapsedMicros = elapsedMs * 1000;
+
+    const percent = ((usage.user + usage.system) / elapsedMicros) * 100;
+
+    lastCPU = process.cpuUsage();
+    lastTime = now;
+
+    return {
+        percent: `${percent.toFixed(2)}%`,
+        user: `${(usage.user / 1000).toFixed(2)} ms`,
+        system: `${(usage.system / 1000).toFixed(2)} ms`,
+    };
+}
+
+module.exports = {
+    formatAge,
+    formatTime,
+    formatMemory,
+    formatCPU,
+};

package/dashboard/utils/logs.js

@@ -0,0 +1,19 @@
+const logs = [];
+
+/**
+ * Adds a log to the array and prints it to the console
+ * @param {string} message
+ */
+function add(message) {
+    const timestamp = new Date().toISOString();
+    const entry = `[${timestamp}] ${message}`;
+    logs.push(entry);
+
+    if (logs.length > 2000) logs.shift();
+
+    console.log(entry);
+}
+
+function getAll() { return logs; }
+
+module.exports = { add, getAll };

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@fjrodafo/discord-app",
+  "version": "1.0.0",
+  "description": "A simple Discord Application made in JavaScript!",
+  "keywords": [
+    "discord",
+    "app",
+    "npmjs",
+    "nodejs",
+    "discordjs",
+    "javascript",
+    "fjrodafo"
+  ],
+  "homepage": "https://github.com/FJrodafo/DiscordAPP#readme",
+  "bugs": {
+    "url": "https://github.com/FJrodafo/DiscordAPP/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/FJrodafo/DiscordAPP.git"
+  },
+  "license": "CC0-1.0",
+  "author": "FJrodafo - Francisco José Rodríguez Afonso",
+  "type": "commonjs",
+  "main": "index.js",
+  "scripts": {
+    "start": "node ./src/deploy-commands.js && node ./src/index.js",
+    "canary": "node ./canary/deploy-commands.js && node ./canary/index.js",
+    "eslint": "eslint './**/*.js'",
+    "eslintfix": "eslint './**/*.js' --fix",
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "tarball": "npm pack --dry-run",
+    "publish:npm": "npm publish --access=public --registry=https://registry.npmjs.org/",
+    "publish:github": "npm publish --registry=https://npm.pkg.github.com/"
+  },
+  "dependencies": {
+    "@fjrodafo/port-finder": "^2.0.5",
+    "canvas": "^3.2.0",
+    "discord.js": "^14.26.2",
+    "express": "^5.2.1",
+    "undici": "^7.16.0"
+  },
+  "devDependencies": {
+    "eslint": "^9.35.0"
+  }
+}

package/src/commands/admin/ping.js

@@ -0,0 +1,13 @@
+const { SlashCommandBuilder } = require('discord.js');
+
+module.exports = {
+    category: 'admin',
+    cooldown: 60,
+    data: new SlashCommandBuilder()
+        .setName('ping')
+        .setDescription('Replies with Pong!')
+        .setDefaultMemberPermissions(0),
+    async execute(interaction) {
+        await interaction.reply({ content: 'pong', ephemeral: true });
+    },
+};

package/src/commands/admin/prune.js

@@ -0,0 +1,36 @@
+const {
+    SlashCommandBuilder,
+    PermissionFlagsBits,
+} = require('discord.js');
+
+module.exports = {
+    category: 'admin',
+    data: new SlashCommandBuilder()
+        .setName('prune')
+        .setDescription('Prune up to 99 messages!')
+        .setDefaultMemberPermissions(0)
+        .setDMPermission(false)
+        .addIntegerOption(option => option
+            .setName('amount')
+            .setDescription('Number of messages to prune!')
+            .setRequired(false),
+        ),
+    async execute(interaction) {
+        const amount = interaction.options.getInteger('amount');
+
+        if (!interaction.guild.members.me.permissions.has(PermissionFlagsBits.ManageMessages)) {
+            return interaction.reply({ content: 'I do not have permission to prune messages in this channel.', ephemeral: true });
+        }
+
+        if (amount < 1 || amount > 99) {
+            return interaction.reply({ content: 'You need to input a number between `1` and `99`', ephemeral: true });
+        }
+
+        await interaction.channel.bulkDelete(amount, true).catch(error => {
+            console.error(error);
+            interaction.reply({ content: 'There was an error trying to prune messages in this channel.', ephemeral: true });
+        });
+
+        return interaction.reply({ content: `Successfully pruned \`${amount}\` messages!`, ephemeral: true });
+    },
+};

package/src/commands/admin/reload.js

@@ -0,0 +1,36 @@
+const { SlashCommandBuilder } = require('discord.js');
+
+module.exports = {
+    category: 'admin',
+    data: new SlashCommandBuilder()
+        .setName('reload')
+        .setDescription('Reloads a command!')
+        .setDefaultMemberPermissions(0)
+        .setDMPermission(false)
+        .addStringOption(option => option
+            .setName('command')
+            .setDescription('The command to reload!')
+            .setRequired(true),
+        ),
+    async execute(interaction) {
+        const commandName = interaction.options.getString('command', true).toLowerCase();
+        const command = interaction.client.commands.get(commandName);
+
+        if (!command) {
+            return interaction.reply({ content: `There is no command with name \`/${commandName}\``, ephemeral: true });
+        }
+
+        delete require.cache[require.resolve(`./../${command.category}/${command.data.name}.js`)];
+
+        try {
+            interaction.client.commands.delete(command.data.name);
+            const newCommand = require(`./../${command.category}/${command.data.name}.js`);
+            interaction.client.commands.set(newCommand.data.name, newCommand);
+            await interaction.reply({ content: `Command \`/${newCommand.data.name}\` was reloaded!`, ephemeral: true });
+        }
+        catch (error) {
+            console.error(error);
+            await interaction.reply({ content: `There was an error while reloading a command \`/${command.data.name}\`:\n\`${error.message}\``, ephemeral: true });
+        }
+    },
+};

package/src/commands/context-menu/avatar.js

@@ -0,0 +1,19 @@
+const {
+    ContextMenuCommandBuilder,
+    ApplicationCommandType,
+} = require('discord.js');
+
+module.exports = {
+    category: 'context-menu',
+    data: new ContextMenuCommandBuilder()
+        .setName('Avatar')
+        .setType(ApplicationCommandType.User),
+    async execute(interaction) {
+        const userName = interaction.targetUser.username;
+        const userAvatar = interaction.targetUser
+            .displayAvatarURL({ dynamic: true })
+            .replace('webp', 'png');
+
+        await interaction.reply({ content: `[${userName}](${userAvatar})`, ephemeral: true });
+    },
+};

package/src/commands/context-menu/user.js

@@ -0,0 +1,26 @@
+const {
+    ContextMenuCommandBuilder,
+    ApplicationCommandType,
+    EmbedBuilder,
+} = require('discord.js');
+
+module.exports = {
+    category: 'context-menu',
+    data: new ContextMenuCommandBuilder()
+        .setName('User')
+        .setType(ApplicationCommandType.User)
+        .setDMPermission(false),
+    async execute(interaction) {
+        const user = interaction.targetUser;
+        const member = interaction.targetMember;
+        const embed = new EmbedBuilder()
+            .setThumbnail(`${user.displayAvatarURL()}`)
+            .addFields(
+                { name: 'User:', value: `${user.username}`, inline: true },
+                { name: 'ID:', value: `${user.id}`, inline: true },
+                { name: 'Joined at:', value: `${member.joinedAt}`, inline: false },
+            );
+
+        return interaction.reply({ embeds: [embed], ephemeral: true });
+    },
+};