commands/settings/RestartCommand.ts

/**
 * This file is part of SudoBot.
 *
 * Copyright (C) 2021-2023 OSN Developers.
 *
 * SudoBot is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Affero General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * SudoBot is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Affero General Public License for more details.
 *
 * You should have received a copy of the GNU Affero General Public License
 * along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
 */

import {
    ActionRowBuilder,
    ButtonBuilder,
    ButtonStyle,
    CacheType,
    ChatInputCommandInteraction,
    Interaction,
    SlashCommandBuilder,
    Snowflake
} from "discord.js";
import { writeFile } from "fs/promises";
import path from "path";
import Command, { CommandMessage, CommandReturn, ValidationRule } from "../../core/Command";
import { GatewayEventListener } from "../../decorators/GatewayEventListener";
import { HasEventListeners } from "../../types/HasEventListeners";
import { logError } from "../../utils/Logger";
import { sudoPrefix } from "../../utils/utils";

export default class RestartCommand extends Command implements HasEventListeners {
    public readonly name = "restart";
    public readonly validationRules: ValidationRule[] = [];
    public readonly aliases = ["reboot"];
    public readonly systemAdminOnly = true;
    public readonly slashCommandBuilder = new SlashCommandBuilder().addStringOption(option =>
        option.setName("credential_key").setDescription("The key to authenticate with the credentials server, if needed")
    );
    public readonly keys: string[] = [];

    public readonly description = "Restarts the bot.";

    @GatewayEventListener("interactionCreate")
    async onInteractionCreate(interaction: Interaction<CacheType>) {
        if (!interaction.isButton()) {
            return;
        }

        const { customId } = interaction;

        if (!customId.startsWith("restart__yes__") && !customId.startsWith("restart__no__")) {
            return;
        }

        const [, , guildId, channelId, userId, keyId] = customId.split("__");
        const numericKeyId = keyId ? parseInt(keyId) : NaN;
        const isNaN = Number.isNaN(numericKeyId);
        const key = !isNaN ? this.keys.at(parseInt(keyId)) : null;

        if (!isNaN && !key) {
            return;
        }

        if (!guildId || !channelId || !userId) {
            return;
        }

        if (interaction.guildId !== guildId || interaction.channelId !== channelId) {
            return;
        }

        if (interaction.user.id !== userId) {
            await interaction
                .reply({
                    ephemeral: true,
                    content: "That's not under your control!"
                })
                .catch(logError);
            return;
        }

        if (customId.startsWith("restart__yes__")) {
            const buttons = this.buildButtons(guildId, channelId, userId).map(button => button.setDisabled(true));

            await interaction.update({
                embeds: [
                    {
                        color: 0x007bff,
                        title: "System Restart",
                        description: `${this.emoji("loading")} Restarting${key ? " (with one time 2FA code)" : ""}...`
                    }
                ],
                components: [new ActionRowBuilder<ButtonBuilder>().addComponents(...buttons)]
            });

            const json = JSON.stringify(
                {
                    guildId,
                    channelId,
                    messageId: interaction.message.id,
                    time: Date.now(),
                    key
                },
                null,
                4
            );

            await writeFile(path.join(sudoPrefix("tmp", true), "restart.json"), json);
            process.exit(this.client.configManager.systemConfig.restart_exit_code);
        }

        if (customId.startsWith("restart__no__")) {
            const buttons = this.buildButtons(guildId, channelId, userId).map(button => button.setDisabled(true));

            await interaction.update({
                embeds: [
                    {
                        color: 0xf14a60,
                        title: "System Restart",
                        description: "Operation cancelled."
                    }
                ],
                components: [new ActionRowBuilder<ButtonBuilder>().addComponents(...buttons)]
            });
        }
    }

    async execute(message: CommandMessage): Promise<CommandReturn> {
        if (
            process.env.CREDENTIAL_SERVER &&
            (!(message instanceof ChatInputCommandInteraction) || !message.options.getString("credential_key"))
        ) {
            await this.error(message, "Please enter the credential server 2FA code to restart the bot!");
            return;
        }

        const mfaKey = message instanceof ChatInputCommandInteraction ? message.options.getString("credential_key") : "";

        const reply = await this.deferredReply(message, {
            embeds: [
                {
                    color: 0x007bff,
                    title: "System Restart",
                    description: "Are you sure you want to restart the entire system? The bot might go offline for some time."
                }
            ],
            components: [
                new ActionRowBuilder<ButtonBuilder>().addComponents(
                    ...this.buildButtons(message.guildId!, message.channelId!, message.member!.user.id, mfaKey)
                )
            ]
        });

        if (reply) {
            setTimeout(() => {
                reply.edit({
                    embeds: [
                        {
                            color: 0xf14a60,
                            title: "System Restart",
                            description: "Operation cancelled due to inactivity."
                        }
                    ],
                    components: [
                        new ActionRowBuilder<ButtonBuilder>().addComponents(
                            ...this.buildButtons(message.guildId!, message.channelId!, message.member!.user.id, mfaKey, true)
                        )
                    ]
                });
            }, 180_000); // 3 minutes
        }
    }

    buildButtons(guildId: Snowflake, channelId: Snowflake, userId: Snowflake, key?: string | null, disable?: boolean) {
        let keyId = key ? this.keys.indexOf(key) : null;

        if (keyId === -1 && key) {
            this.keys.push(key);
            keyId = this.keys.length - 1;
        }

        return [
            new ButtonBuilder()
                .setCustomId(`restart__yes__${guildId}__${channelId}__${userId}__${keyId}`)
                .setLabel("Restart")
                .setStyle(ButtonStyle.Success)
                .setDisabled(disable ?? false),
            new ButtonBuilder()
                .setCustomId(`restart__no__${guildId}__${channelId}__${userId}__${keyId}`)
                .setLabel("Cancel")
                .setStyle(ButtonStyle.Danger)
                .setDisabled(disable ?? false)
        ];
    }
}
1	rakinar2	577	/**
2			* This file is part of SudoBot.
3			*
4			* Copyright (C) 2021-2023 OSN Developers.
5			*
6			* SudoBot is free software; you can redistribute it and/or modify it
7			* under the terms of the GNU Affero General Public License as published by
8			* the Free Software Foundation, either version 3 of the License, or
9			* (at your option) any later version.
10			*
11			* SudoBot is distributed in the hope that it will be useful, but
12			* WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU Affero General Public License for more details.
15			*
16			* You should have received a copy of the GNU Affero General Public License
17			* along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
18			*/
19
20			import {
21			ActionRowBuilder,
22			ButtonBuilder,
23			ButtonStyle,
24			CacheType,
25			ChatInputCommandInteraction,
26			Interaction,
27			SlashCommandBuilder,
28			Snowflake
29			} from "discord.js";
30			import { writeFile } from "fs/promises";
31			import path from "path";
32			import Command, { CommandMessage, CommandReturn, ValidationRule } from "../../core/Command";
33			import { GatewayEventListener } from "../../decorators/GatewayEventListener";
34			import { HasEventListeners } from "../../types/HasEventListeners";
35			import { logError } from "../../utils/Logger";
36			import { sudoPrefix } from "../../utils/utils";
37
38			export default class RestartCommand extends Command implements HasEventListeners {
39			public readonly name = "restart";
40			public readonly validationRules: ValidationRule[] = [];
41			public readonly aliases = ["reboot"];
42			public readonly systemAdminOnly = true;
43			public readonly slashCommandBuilder = new SlashCommandBuilder().addStringOption(option =>
44			option.setName("credential_key").setDescription("The key to authenticate with the credentials server, if needed")
45			);
46			public readonly keys: string[] = [];
47
48			public readonly description = "Restarts the bot.";
49
50			@GatewayEventListener("interactionCreate")
51			async onInteractionCreate(interaction: Interaction<CacheType>) {
52			if (!interaction.isButton()) {
53			return;
54			}
55
56			const { customId } = interaction;
57
58			if (!customId.startsWith("restart__yes__") && !customId.startsWith("restart__no__")) {
59			return;
60			}
61
62			const [, , guildId, channelId, userId, keyId] = customId.split("__");
63			const numericKeyId = keyId ? parseInt(keyId) : NaN;
64			const isNaN = Number.isNaN(numericKeyId);
65			const key = !isNaN ? this.keys.at(parseInt(keyId)) : null;
66
67			if (!isNaN && !key) {
68			return;
69			}
70
71			if (!guildId \|\| !channelId \|\| !userId) {
72			return;
73			}
74
75			if (interaction.guildId !== guildId \|\| interaction.channelId !== channelId) {
76			return;
77			}
78
79			if (interaction.user.id !== userId) {
80			await interaction
81			.reply({
82			ephemeral: true,
83			content: "That's not under your control!"
84			})
85			.catch(logError);
86			return;
87			}
88
89			if (customId.startsWith("restart__yes__")) {
90			const buttons = this.buildButtons(guildId, channelId, userId).map(button => button.setDisabled(true));
91
92			await interaction.update({
93			embeds: [
94			{
95			color: 0x007bff,
96			title: "System Restart",
97			description: `${this.emoji("loading")} Restarting${key ? " (with one time 2FA code)" : ""}...`
98			}
99			],
100			components: [new ActionRowBuilder<ButtonBuilder>().addComponents(...buttons)]
101			});
102
103			const json = JSON.stringify(
104			{
105			guildId,
106			channelId,
107			messageId: interaction.message.id,
108			time: Date.now(),
109			key
110			},
111			null,
112			4
113			);
114
115			await writeFile(path.join(sudoPrefix("tmp", true), "restart.json"), json);
116			process.exit(this.client.configManager.systemConfig.restart_exit_code);
117			}
118
119			if (customId.startsWith("restart__no__")) {
120			const buttons = this.buildButtons(guildId, channelId, userId).map(button => button.setDisabled(true));
121
122			await interaction.update({
123			embeds: [
124			{
125			color: 0xf14a60,
126			title: "System Restart",
127			description: "Operation cancelled."
128			}
129			],
130			components: [new ActionRowBuilder<ButtonBuilder>().addComponents(...buttons)]
131			});
132			}
133			}
134
135			async execute(message: CommandMessage): Promise<CommandReturn> {
136			if (
137			process.env.CREDENTIAL_SERVER &&
138			(!(message instanceof ChatInputCommandInteraction) \|\| !message.options.getString("credential_key"))
139			) {
140			await this.error(message, "Please enter the credential server 2FA code to restart the bot!");
141			return;
142			}
143
144			const mfaKey = message instanceof ChatInputCommandInteraction ? message.options.getString("credential_key") : "";
145
146			const reply = await this.deferredReply(message, {
147			embeds: [
148			{
149			color: 0x007bff,
150			title: "System Restart",
151			description: "Are you sure you want to restart the entire system? The bot might go offline for some time."
152			}
153			],
154			components: [
155			new ActionRowBuilder<ButtonBuilder>().addComponents(
156			...this.buildButtons(message.guildId!, message.channelId!, message.member!.user.id, mfaKey)
157			)
158			]
159			});
160
161			if (reply) {
162			setTimeout(() => {
163			reply.edit({
164			embeds: [
165			{
166			color: 0xf14a60,
167			title: "System Restart",
168			description: "Operation cancelled due to inactivity."
169			}
170			],
171			components: [
172			new ActionRowBuilder<ButtonBuilder>().addComponents(
173			...this.buildButtons(message.guildId!, message.channelId!, message.member!.user.id, mfaKey, true)
174			)
175			]
176			});
177			}, 180_000); // 3 minutes
178			}
179			}
180
181			buildButtons(guildId: Snowflake, channelId: Snowflake, userId: Snowflake, key?: string \| null, disable?: boolean) {
182			let keyId = key ? this.keys.indexOf(key) : null;
183
184			if (keyId === -1 && key) {
185			this.keys.push(key);
186			keyId = this.keys.length - 1;
187			}
188
189			return [
190			new ButtonBuilder()
191			.setCustomId(`restart__yes__${guildId}__${channelId}__${userId}__${keyId}`)
192			.setLabel("Restart")
193			.setStyle(ButtonStyle.Success)
194			.setDisabled(disable ?? false),
195			new ButtonBuilder()
196			.setCustomId(`restart__no__${guildId}__${channelId}__${userId}__${keyId}`)
197			.setLabel("Cancel")
198			.setStyle(ButtonStyle.Danger)
199			.setDisabled(disable ?? false)
200			];
201			}
202			}