commands/settings/UpdateCommand.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 axios from "axios";
import { spawnSync } from "child_process";
import {
    ActionRowBuilder,
    ButtonBuilder,
    ButtonInteraction,
    ButtonStyle,
    Colors,
    ComponentType,
    StringSelectMenuBuilder,
    StringSelectMenuInteraction,
    StringSelectMenuOptionBuilder
} from "discord.js";
import { existsSync } from "fs";
import { cp, mkdir, rename, rm } from "fs/promises";
import path, { basename, join } from "path";
import semver from "semver";
import Command, { CommandMessage, CommandReturn, ValidationRule } from "../../core/Command";
import { log, logError, logInfo, logWarn } from "../../utils/Logger";
import { downloadFile } from "../../utils/download";
import { sudoPrefix } from "../../utils/utils";

export default class UpdateCommand extends Command {
    public readonly name = "update";
    public readonly validationRules: ValidationRule[] = [];
    public readonly permissions = [];
    public readonly description = "Updates the bot to the latest version.";
    public readonly systemAdminOnly = true;
    protected readonly RELEASE_API_URL = "https://api.github.com/repos/onesoft-sudo/sudobot/releases/latest";
    protected readonly UNSTABLE_DOWNLOAD_URL = "https://github.com/onesoft-sudo/sudobot/archive/refs/heads/main.zip";
    public updateChannel?: "stable" | "unstable";
    public readonly beta = true;

    async execute(message: CommandMessage): Promise<CommandReturn> {
        const unsatisfiedRequirement = this.checkRequirements();

        if (unsatisfiedRequirement) {
            await this.error(
                message,
                `The \`${unsatisfiedRequirement}\` program is not installed in the current system. Please install it if you want to use this command.`
            );
            return;
        }

        await this.deferIfInteraction(message);

        try {
            const response = await axios.get(this.RELEASE_API_URL);
            const tagName = response.data?.tag_name;
            const version = tagName.replace(/^v/, "");
            const stableDownloadURL = `https://github.com/onesoft-sudo/sudobot/archive/refs/tags/${tagName}.zip`;
            const updateAvailable = semver.gt(version, this.client.metadata.data.version);
            this.updateChannel = updateAvailable ? "stable" : "unstable";

            await this.deferredReply(message, {
                embeds: [
                    {
                        author: {
                            name: "System Update",
                            icon_url: this.client.user?.displayAvatarURL() ?? undefined
                        },
                        description:
                            "Are you sure you want to continue? This will download an update, install it, push schema changes to the database, and then restart the bot system. Make sure you have a backup in case if a data loss occurs.",
                        color: 0x007bff
                    }
                ],
                components: this.actionRow({ updateAvailable, version })
            });

            const updateChannelCollector = message.channel!.createMessageComponentCollector({
                componentType: ComponentType.StringSelect,
                filter: (interaction: StringSelectMenuInteraction) => {
                    if (interaction.user.id === message.member!.user.id && interaction.customId === "system_update_channel") {
                        return true;
                    }

                    interaction
                        .reply({
                            ephemeral: true,
                            content: "That's not under your control."
                        })
                        .catch(logError);

                    return false;
                },
                time: 120_000
            });

            const confirmationCollector = message.channel!.createMessageComponentCollector({
                componentType: ComponentType.Button,
                filter: (interaction: ButtonInteraction) => {
                    if (interaction.user.id === message.member!.user.id && interaction.customId.startsWith("system_update__")) {
                        return true;
                    }

                    interaction
                        .reply({
                            ephemeral: true,
                            content: "That's not under your control."
                        })
                        .catch(logError);

                    return false;
                },
                time: 120_000
            });

            confirmationCollector.on("collect", async interaction => {
                if (!interaction.isButton()) {
                    return;
                }

                if (interaction.customId === "system_update__cancel") {
                    confirmationCollector.stop();
                    updateChannelCollector.stop();

                    await interaction.update({
                        embeds: [
                            {
                                author: {
                                    name: "System Update",
                                    icon_url: this.client.user?.displayAvatarURL() ?? undefined
                                },
                                description: "Update cancelled.",
                                color: 0xf14a60
                            }
                        ],
                        components: this.actionRow({ updateAvailable, version, disabled: true })
                    });

                    return;
                }

                if (!this.updateChannel) {
                    await interaction.reply({
                        content: "Please select an update channel first!"
                    });

                    return;
                }

                await interaction.update({
                    embeds: [
                        {
                            author: {
                                name: "System Update",
                                icon_url: this.client.user?.displayAvatarURL() ?? undefined
                            },
                            description: `${this.emoji("loading")} Update in progress...`,
                            color: 0x007bff
                        }
                    ],
                    components: this.actionRow({ updateAvailable, version, disabled: true })
                });

                let success;

                try {
                    success = await this.update({
                        stableDownloadURL,
                        version
                    });
                } catch {
                    success = false;
                }

                await interaction.message.edit({
                    embeds: [
                        {
                            author: {
                                name: "System Update",
                                icon_url: this.client.user?.displayAvatarURL() ?? undefined
                            },
                            description: success
                                ? `${this.emoji("check")} Successfully installed the update. Restarting now.`
                                : `${this.emoji("error")} An error has occurred while performing the update.`,
                            color: Colors.Green
                        }
                    ]
                });

                process.exit(this.client.configManager.systemConfig.restart_exit_code);
            });

            updateChannelCollector.on("collect", async interaction => {
                if (!interaction.isStringSelectMenu()) {
                    return;
                }

                const updateChannel = interaction.component.options[0].value;

                if (!["stable", "unstable"].includes(updateChannel)) {
                    return;
                }

                this.updateChannel = updateChannel as (typeof this)["updateChannel"];
                await interaction.deferUpdate();
            });
        } catch (e) {
            logError(e);
            await this.error(message, "An unknown error has occurred while trying to fetch information about the updates.");
        }
    }

    actionRow({ version, updateAvailable, disabled = false }: { version: string; updateAvailable: boolean; disabled?: boolean }) {
        return [
            new ActionRowBuilder<StringSelectMenuBuilder>().addComponents(
                new StringSelectMenuBuilder()
                    .addOptions(
                        new StringSelectMenuOptionBuilder({
                            label: "Latest Stable",
                            description: `${version} • ${updateAvailable ? "Update available" : "Up to date"}`,
                            value: "stable",
                            default: updateAvailable
                        }).setEmoji("⚙"),
                        new StringSelectMenuOptionBuilder({
                            label: "Latest Unstable",
                            description: "main • Unstable versions may break things unexpectedly",
                            value: "unstable",
                            default: !updateAvailable
                        }).setEmoji("⚒️")
                    )
                    .setCustomId("system_update_channel")
                    .setMaxValues(1)
                    .setMinValues(1)
                    .setPlaceholder("Select an update channel")
                    .setDisabled(disabled)
            ),
            new ActionRowBuilder<ButtonBuilder>().addComponents(
                new ButtonBuilder()
                    .setCustomId("system_update__cancel")
                    .setLabel("Cancel")
                    .setStyle(ButtonStyle.Danger)
                    .setDisabled(disabled),
                new ButtonBuilder()
                    .setCustomId("system_update__continue")
                    .setLabel("Continue")
                    .setStyle(ButtonStyle.Success)
                    .setDisabled(disabled)
            )
        ];
    }

    downloadUpdate({ stableDownloadURL, version }: { stableDownloadURL: string; version: string }): Promise<{
        filePath?: string;
        storagePath?: string;
        error?: Error;
    }> {
        const url = this.updateChannel === "stable" ? stableDownloadURL : this.UNSTABLE_DOWNLOAD_URL;
        const tmpdir = sudoPrefix("tmp", true);
        const dirname = `update-${this.updateChannel === "stable" ? version : "unstable"}`;

        try {
            return downloadFile({
                url,
                path: tmpdir,
                name: `${dirname}.zip`
            });
        } catch (error) {
            logError(error);
            logError("Failed to download the update package. Aborting");
            return Promise.resolve({ error: error as Error });
        }
    }

    checkRequirements() {
        const paths = process.env.PATH?.split(process.platform === "win32" ? ";" : ":") ?? [];

        for (const path of paths) {
            if (process.platform === "win32" && existsSync(join(path, "powershell.exe"))) {
                return null;
            }

            if (existsSync(join(path, "unzip"))) {
                return null;
            }
        }

        return process.platform === "win32" ? "powershell.exe" : "unzip";
    }

    async unpackUpdate({ filePath, storagePath, version }: { version: string; filePath: string; storagePath: string }) {
        const dirname = `update-${this.updateChannel === "stable" ? version : "unstable"}`;
        const unpackedDirectory = join(storagePath!, dirname);

        try {
            const cwd = process.cwd();

            if (existsSync(unpackedDirectory)) {
                await rm(unpackedDirectory, { recursive: true });
            }

            await mkdir(unpackedDirectory);
            process.chdir(unpackedDirectory);

            const { status, error } = spawnSync(
                process.platform === "win32"
                    ? `powershell -command "Expand-Archive -Force '${filePath}' '${unpackedDirectory}'"`
                    : `unzip ../${basename(filePath)}`,
                {
                    shell: true,
                    encoding: "utf-8",
                    stdio: "inherit",
                    cwd: unpackedDirectory
                }
            );

            if (status !== 0 || error) {
                throw error;
            }

            process.chdir(cwd);
            return { unpackedDirectory };
        } catch (error) {
            logError(error);
            logError("Failed to unpack the update package. Aborting.");
            return { error };
        }
    }

    private createDirectoryBackupPair(name: string) {
        return [path.join(__dirname, "../../../", name), path.join(__dirname, `../../../.backup/${name}`)] as const;
    }

    async installUpdate({ unpackedDirectory, version }: { unpackedDirectory: string; version: string }) {
        const dirs = [
            "src",
            "prisma",
            "scripts",
            "package.json",
            "tsconfig.json"
        ];

        if (!process.isBun) {
            dirs.push("build");
        }
        
        const { error, dirpairs } = await this.backupCurrentSystem(dirs);

        if (error) {
            return false;
        }

        const installFiles = ["src", "prisma", "scripts", "package.json", "tsconfig.json"];

        try {
            for (const installFile of installFiles) {
                const src = path.join(
                    unpackedDirectory,
                    `sudobot-${this.updateChannel === "stable" ? version : "main"}`,
                    installFile
                );
                const dest = path.join(__dirname, "../../../", installFile);

                log(`Installing ${src} to ${dest}`);

                await rm(dest, {
                    recursive: true
                });

                await cp(src, dest, {
                    recursive: true
                });
            }
        } catch (error) {
            logError(error);
            logError("Failed to install the update package. Attempting to rollback the changes");
            await this.rollbackUpdate(dirpairs!);
            return false;
        }

        return await this.buildNewInstallation(dirpairs!);
    }

    async backupCurrentSystem(dirsToBackup: string[]) {
        const dirpairs = dirsToBackup.map(dir => this.createDirectoryBackupPair(dir));

        try {
            await this.createBackupDirectoryIfNeeded();

            for (const [src, dest] of dirpairs) {
                log(`Copying ${src} to ${dest}`);

                await cp(src, dest, {
                    recursive: true
                });
            }
        } catch (error) {
            logError(error);
            logError("Failed to backup the current bot system. Attempting to revert changes");
            await this.rollbackUpdate(dirpairs);
            return { error };
        }

        return { dirpairs };
    }

    async createBackupDirectoryIfNeeded() {
        const backupDir = path.join(__dirname, "../../../.backup");

        if (!existsSync(backupDir)) {
            await mkdir(backupDir);
        }

        return backupDir;
    }

    async rollbackUpdate(dirpairs: Array<readonly [string, string]>) {
        try {
            const backupDir = await this.createBackupDirectoryIfNeeded();

            for (const [src, dest] of dirpairs) {
                if (!existsSync(dest)) {
                    log(`No backup found for ${src}`);
                    continue;
                }

                log(`Restoring ${src} from ${dest}`);

                if (existsSync(src)) {
                    log(`Saving current state of ${src}`);
                    await rename(src, path.join(backupDir, `${basename(src)}.current`)).catch(log);
                }

                await rename(dest, src);
            }

            logInfo("Rolled back the update successfully");
        } catch (error) {
            logError(error);
            logError("Error rolling back the update");
            return false;
        }

        return true;
    }

    async cleanup({ unpackedDirectory, downloadedFile }: { unpackedDirectory: string; downloadedFile: string }) {
        await rm(unpackedDirectory, { recursive: true });
        await rm(downloadedFile);
    }

    buildNewInstallation(dirpairs: Array<readonly [string, string]>) {
        if (process.isBun) {
            const { status: installStatus } = spawnSync("bun install -D", {
                stdio: "inherit",
                cwd: path.join(__dirname, "../../.."),
                encoding: "utf-8",
                shell: true
            });
    
            if (installStatus !== 0) {
                logError("Failed to install the new dependencies. Rolling back");
                return this.rollbackUpdate(dirpairs);
            }
        }
        else {
            const { status: rmStatus } = spawnSync("rm -fr build tsconfig.tsbuildinfo", {
                stdio: "inherit",
                cwd: path.join(__dirname, "../../.."),
                encoding: "utf-8",
                shell: true
            });
    
            if (rmStatus !== 0) {
                logError("Failed to remove the old build directory. Rolling back");
                return this.rollbackUpdate(dirpairs);
            }
    
            const { status: installStatus } = spawnSync("npm install -D", {
                stdio: "inherit",
                cwd: path.join(__dirname, "../../.."),
                encoding: "utf-8",
                shell: true
            });
    
            if (installStatus !== 0) {
                logError("Failed to install the new dependencies. Rolling back");
                return this.rollbackUpdate(dirpairs);
            }
    
            const { status: buildStatus } = spawnSync("npm run build", {
                stdio: "inherit",
                cwd: path.join(__dirname, "../../.."),
                encoding: "utf-8",
                shell: true
            });
    
            if (buildStatus !== 0) {
                logError("Failed to build the update. Rolling back");
                return this.rollbackUpdate(dirpairs);
            }
        }

        const { status: dbPushStatus } = spawnSync((process.isBun ? "bunx" : "npx") + " prisma db push", {
            stdio: "inherit",
            cwd: path.join(__dirname, "../../.."),
            encoding: "utf-8",
            shell: true
        });

        if (dbPushStatus !== 0) {
            logError("Failed to push database schema changes. Rolling back");
            return this.rollbackUpdate(dirpairs);
        }

        const { status: slashCommandStatus } = spawnSync((process.isBun ? "bun" : "npm") + " run deploy", {
            stdio: "inherit",
            cwd: path.join(__dirname, "../../.."),
            encoding: "utf-8",
            shell: true
        });

        if (slashCommandStatus !== 0) {
            logWarn("Failed to update application commands. Please manually update them.");
        }

        return true;
    }

    async update({ stableDownloadURL, version }: { stableDownloadURL: string; version: string }) {
        const updateChannel = this.updateChannel;

        if (!updateChannel) {
            return false;
        }

        if (
            existsSync(path.join(__dirname, "../../..", ".git")) &&
            (existsSync("/usr/bin/git") || existsSync("/usr/local/bin/git") || existsSync("/bin/git"))
        ) {
            const dirs = ["src", "prisma", "scripts"];

            if (!process.isBun) {
                dirs.push("build");
            }
            
            const { error, dirpairs } = await this.backupCurrentSystem(dirs);

            if (error) {
                return false;
            }

            const { status: gitStatus } = spawnSync("git pull", {
                stdio: "inherit",
                cwd: path.join(__dirname, "../../.."),
                encoding: "utf-8",
                shell: true
            });

            if (gitStatus !== 0) {
                this.client.logger.error("Git command returned non-zero status code");
                return false;
            }

            const buildSucceeded = await this.buildNewInstallation(dirpairs!);

            if (!buildSucceeded) {
                await this.rollbackUpdate(dirpairs!).catch(logError);
                return false;
            }

            return true;
        }

        const { error: downloadError, filePath, storagePath } = await this.downloadUpdate({ stableDownloadURL, version });

        if (downloadError) {
            return false;
        }

        const { error: unpackError, unpackedDirectory } = await this.unpackUpdate({
            filePath: filePath!,
            storagePath: storagePath!,
            version
        });

        if (unpackError) {
            return false;
        }

        const successfullyInstalled = await this.installUpdate({ unpackedDirectory: unpackedDirectory!, version });

        if (!successfullyInstalled) {
            return false;
        }

        await this.cleanup({ unpackedDirectory: unpackedDirectory!, downloadedFile: filePath! }).catch(log);
        return true;
    }
}
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 axios from "axios";
21			import { spawnSync } from "child_process";
22			import {
23			ActionRowBuilder,
24			ButtonBuilder,
25			ButtonInteraction,
26			ButtonStyle,
27			Colors,
28			ComponentType,
29			StringSelectMenuBuilder,
30			StringSelectMenuInteraction,
31			StringSelectMenuOptionBuilder
32			} from "discord.js";
33			import { existsSync } from "fs";
34			import { cp, mkdir, rename, rm } from "fs/promises";
35			import path, { basename, join } from "path";
36			import semver from "semver";
37			import Command, { CommandMessage, CommandReturn, ValidationRule } from "../../core/Command";
38			import { log, logError, logInfo, logWarn } from "../../utils/Logger";
39			import { downloadFile } from "../../utils/download";
40			import { sudoPrefix } from "../../utils/utils";
41
42			export default class UpdateCommand extends Command {
43			public readonly name = "update";
44			public readonly validationRules: ValidationRule[] = [];
45			public readonly permissions = [];
46			public readonly description = "Updates the bot to the latest version.";
47			public readonly systemAdminOnly = true;
48			protected readonly RELEASE_API_URL = "https://api.github.com/repos/onesoft-sudo/sudobot/releases/latest";
49			protected readonly UNSTABLE_DOWNLOAD_URL = "https://github.com/onesoft-sudo/sudobot/archive/refs/heads/main.zip";
50			public updateChannel?: "stable" \| "unstable";
51			public readonly beta = true;
52
53			async execute(message: CommandMessage): Promise<CommandReturn> {
54			const unsatisfiedRequirement = this.checkRequirements();
55
56			if (unsatisfiedRequirement) {
57			await this.error(
58			message,
59			`The \`${unsatisfiedRequirement}\` program is not installed in the current system. Please install it if you want to use this command.`
60			);
61			return;
62			}
63
64			await this.deferIfInteraction(message);
65
66			try {
67			const response = await axios.get(this.RELEASE_API_URL);
68			const tagName = response.data?.tag_name;
69			const version = tagName.replace(/^v/, "");
70			const stableDownloadURL = `https://github.com/onesoft-sudo/sudobot/archive/refs/tags/${tagName}.zip`;
71			const updateAvailable = semver.gt(version, this.client.metadata.data.version);
72			this.updateChannel = updateAvailable ? "stable" : "unstable";
73
74			await this.deferredReply(message, {
75			embeds: [
76			{
77			author: {
78			name: "System Update",
79			icon_url: this.client.user?.displayAvatarURL() ?? undefined
80			},
81			description:
82			"Are you sure you want to continue? This will download an update, install it, push schema changes to the database, and then restart the bot system. Make sure you have a backup in case if a data loss occurs.",
83			color: 0x007bff
84			}
85			],
86			components: this.actionRow({ updateAvailable, version })
87			});
88
89			const updateChannelCollector = message.channel!.createMessageComponentCollector({
90			componentType: ComponentType.StringSelect,
91			filter: (interaction: StringSelectMenuInteraction) => {
92			if (interaction.user.id === message.member!.user.id && interaction.customId === "system_update_channel") {
93			return true;
94			}
95
96			interaction
97			.reply({
98			ephemeral: true,
99			content: "That's not under your control."
100			})
101			.catch(logError);
102
103			return false;
104			},
105			time: 120_000
106			});
107
108			const confirmationCollector = message.channel!.createMessageComponentCollector({
109			componentType: ComponentType.Button,
110			filter: (interaction: ButtonInteraction) => {
111			if (interaction.user.id === message.member!.user.id && interaction.customId.startsWith("system_update__")) {
112			return true;
113			}
114
115			interaction
116			.reply({
117			ephemeral: true,
118			content: "That's not under your control."
119			})
120			.catch(logError);
121
122			return false;
123			},
124			time: 120_000
125			});
126
127			confirmationCollector.on("collect", async interaction => {
128			if (!interaction.isButton()) {
129			return;
130			}
131
132			if (interaction.customId === "system_update__cancel") {
133			confirmationCollector.stop();
134			updateChannelCollector.stop();
135
136			await interaction.update({
137			embeds: [
138			{
139			author: {
140			name: "System Update",
141			icon_url: this.client.user?.displayAvatarURL() ?? undefined
142			},
143			description: "Update cancelled.",
144			color: 0xf14a60
145			}
146			],
147			components: this.actionRow({ updateAvailable, version, disabled: true })
148			});
149
150			return;
151			}
152
153			if (!this.updateChannel) {
154			await interaction.reply({
155			content: "Please select an update channel first!"
156			});
157
158			return;
159			}
160
161			await interaction.update({
162			embeds: [
163			{
164			author: {
165			name: "System Update",
166			icon_url: this.client.user?.displayAvatarURL() ?? undefined
167			},
168			description: `${this.emoji("loading")} Update in progress...`,
169			color: 0x007bff
170			}
171			],
172			components: this.actionRow({ updateAvailable, version, disabled: true })
173			});
174
175			let success;
176
177			try {
178			success = await this.update({
179			stableDownloadURL,
180			version
181			});
182			} catch {
183			success = false;
184			}
185
186			await interaction.message.edit({
187			embeds: [
188			{
189			author: {
190			name: "System Update",
191			icon_url: this.client.user?.displayAvatarURL() ?? undefined
192			},
193			description: success
194			? `${this.emoji("check")} Successfully installed the update. Restarting now.`
195			: `${this.emoji("error")} An error has occurred while performing the update.`,
196			color: Colors.Green
197			}
198			]
199			});
200
201			process.exit(this.client.configManager.systemConfig.restart_exit_code);
202			});
203
204			updateChannelCollector.on("collect", async interaction => {
205			if (!interaction.isStringSelectMenu()) {
206			return;
207			}
208
209			const updateChannel = interaction.component.options[0].value;
210
211			if (!["stable", "unstable"].includes(updateChannel)) {
212			return;
213			}
214
215			this.updateChannel = updateChannel as (typeof this)["updateChannel"];
216			await interaction.deferUpdate();
217			});
218			} catch (e) {
219			logError(e);
220			await this.error(message, "An unknown error has occurred while trying to fetch information about the updates.");
221			}
222			}
223
224			actionRow({ version, updateAvailable, disabled = false }: { version: string; updateAvailable: boolean; disabled?: boolean }) {
225			return [
226			new ActionRowBuilder<StringSelectMenuBuilder>().addComponents(
227			new StringSelectMenuBuilder()
228			.addOptions(
229			new StringSelectMenuOptionBuilder({
230			label: "Latest Stable",
231			description: `${version} • ${updateAvailable ? "Update available" : "Up to date"}`,
232			value: "stable",
233			default: updateAvailable
234			}).setEmoji("⚙"),
235			new StringSelectMenuOptionBuilder({
236			label: "Latest Unstable",
237			description: "main • Unstable versions may break things unexpectedly",
238			value: "unstable",
239			default: !updateAvailable
240			}).setEmoji("⚒️")
241			)
242			.setCustomId("system_update_channel")
243			.setMaxValues(1)
244			.setMinValues(1)
245			.setPlaceholder("Select an update channel")
246			.setDisabled(disabled)
247			),
248			new ActionRowBuilder<ButtonBuilder>().addComponents(
249			new ButtonBuilder()
250			.setCustomId("system_update__cancel")
251			.setLabel("Cancel")
252			.setStyle(ButtonStyle.Danger)
253			.setDisabled(disabled),
254			new ButtonBuilder()
255			.setCustomId("system_update__continue")
256			.setLabel("Continue")
257			.setStyle(ButtonStyle.Success)
258			.setDisabled(disabled)
259			)
260			];
261			}
262
263			downloadUpdate({ stableDownloadURL, version }: { stableDownloadURL: string; version: string }): Promise<{
264			filePath?: string;
265			storagePath?: string;
266			error?: Error;
267			}> {
268			const url = this.updateChannel === "stable" ? stableDownloadURL : this.UNSTABLE_DOWNLOAD_URL;
269			const tmpdir = sudoPrefix("tmp", true);
270			const dirname = `update-${this.updateChannel === "stable" ? version : "unstable"}`;
271
272			try {
273			return downloadFile({
274			url,
275			path: tmpdir,
276			name: `${dirname}.zip`
277			});
278			} catch (error) {
279			logError(error);
280			logError("Failed to download the update package. Aborting");
281			return Promise.resolve({ error: error as Error });
282			}
283			}
284
285			checkRequirements() {
286			const paths = process.env.PATH?.split(process.platform === "win32" ? ";" : ":") ?? [];
287
288			for (const path of paths) {
289			if (process.platform === "win32" && existsSync(join(path, "powershell.exe"))) {
290			return null;
291			}
292
293			if (existsSync(join(path, "unzip"))) {
294			return null;
295			}
296			}
297
298			return process.platform === "win32" ? "powershell.exe" : "unzip";
299			}
300
301			async unpackUpdate({ filePath, storagePath, version }: { version: string; filePath: string; storagePath: string }) {
302			const dirname = `update-${this.updateChannel === "stable" ? version : "unstable"}`;
303			const unpackedDirectory = join(storagePath!, dirname);
304
305			try {
306			const cwd = process.cwd();
307
308			if (existsSync(unpackedDirectory)) {
309			await rm(unpackedDirectory, { recursive: true });
310			}
311
312			await mkdir(unpackedDirectory);
313			process.chdir(unpackedDirectory);
314
315			const { status, error } = spawnSync(
316			process.platform === "win32"
317			? `powershell -command "Expand-Archive -Force '${filePath}' '${unpackedDirectory}'"`
318			: `unzip ../${basename(filePath)}`,
319			{
320			shell: true,
321			encoding: "utf-8",
322			stdio: "inherit",
323			cwd: unpackedDirectory
324			}
325			);
326
327			if (status !== 0 \|\| error) {
328			throw error;
329			}
330
331			process.chdir(cwd);
332			return { unpackedDirectory };
333			} catch (error) {
334			logError(error);
335			logError("Failed to unpack the update package. Aborting.");
336			return { error };
337			}
338			}
339
340			private createDirectoryBackupPair(name: string) {
341			return [path.join(__dirname, "../../../", name), path.join(__dirname, `../../../.backup/${name}`)] as const;
342			}
343
344			async installUpdate({ unpackedDirectory, version }: { unpackedDirectory: string; version: string }) {
345			const dirs = [
346			"src",
347			"prisma",
348			"scripts",
349			"package.json",
350			"tsconfig.json"
351			];
352
353			if (!process.isBun) {
354			dirs.push("build");
355			}
356
357			const { error, dirpairs } = await this.backupCurrentSystem(dirs);
358
359			if (error) {
360			return false;
361			}
362
363			const installFiles = ["src", "prisma", "scripts", "package.json", "tsconfig.json"];
364
365			try {
366			for (const installFile of installFiles) {
367			const src = path.join(
368			unpackedDirectory,
369			`sudobot-${this.updateChannel === "stable" ? version : "main"}`,
370			installFile
371			);
372			const dest = path.join(__dirname, "../../../", installFile);
373
374			log(`Installing ${src} to ${dest}`);
375
376			await rm(dest, {
377			recursive: true
378			});
379
380			await cp(src, dest, {
381			recursive: true
382			});
383			}
384			} catch (error) {
385			logError(error);
386			logError("Failed to install the update package. Attempting to rollback the changes");
387			await this.rollbackUpdate(dirpairs!);
388			return false;
389			}
390
391			return await this.buildNewInstallation(dirpairs!);
392			}
393
394			async backupCurrentSystem(dirsToBackup: string[]) {
395			const dirpairs = dirsToBackup.map(dir => this.createDirectoryBackupPair(dir));
396
397			try {
398			await this.createBackupDirectoryIfNeeded();
399
400			for (const [src, dest] of dirpairs) {
401			log(`Copying ${src} to ${dest}`);
402
403			await cp(src, dest, {
404			recursive: true
405			});
406			}
407			} catch (error) {
408			logError(error);
409			logError("Failed to backup the current bot system. Attempting to revert changes");
410			await this.rollbackUpdate(dirpairs);
411			return { error };
412			}
413
414			return { dirpairs };
415			}
416
417			async createBackupDirectoryIfNeeded() {
418			const backupDir = path.join(__dirname, "../../../.backup");
419
420			if (!existsSync(backupDir)) {
421			await mkdir(backupDir);
422			}
423
424			return backupDir;
425			}
426
427			async rollbackUpdate(dirpairs: Array<readonly [string, string]>) {
428			try {
429			const backupDir = await this.createBackupDirectoryIfNeeded();
430
431			for (const [src, dest] of dirpairs) {
432			if (!existsSync(dest)) {
433			log(`No backup found for ${src}`);
434			continue;
435			}
436
437			log(`Restoring ${src} from ${dest}`);
438
439			if (existsSync(src)) {
440			log(`Saving current state of ${src}`);
441			await rename(src, path.join(backupDir, `${basename(src)}.current`)).catch(log);
442			}
443
444			await rename(dest, src);
445			}
446
447			logInfo("Rolled back the update successfully");
448			} catch (error) {
449			logError(error);
450			logError("Error rolling back the update");
451			return false;
452			}
453
454			return true;
455			}
456
457			async cleanup({ unpackedDirectory, downloadedFile }: { unpackedDirectory: string; downloadedFile: string }) {
458			await rm(unpackedDirectory, { recursive: true });
459			await rm(downloadedFile);
460			}
461
462			buildNewInstallation(dirpairs: Array<readonly [string, string]>) {
463			if (process.isBun) {
464			const { status: installStatus } = spawnSync("bun install -D", {
465			stdio: "inherit",
466			cwd: path.join(__dirname, "../../.."),
467			encoding: "utf-8",
468			shell: true
469			});
470
471			if (installStatus !== 0) {
472			logError("Failed to install the new dependencies. Rolling back");
473			return this.rollbackUpdate(dirpairs);
474			}
475			}
476			else {
477			const { status: rmStatus } = spawnSync("rm -fr build tsconfig.tsbuildinfo", {
478			stdio: "inherit",
479			cwd: path.join(__dirname, "../../.."),
480			encoding: "utf-8",
481			shell: true
482			});
483
484			if (rmStatus !== 0) {
485			logError("Failed to remove the old build directory. Rolling back");
486			return this.rollbackUpdate(dirpairs);
487			}
488
489			const { status: installStatus } = spawnSync("npm install -D", {
490			stdio: "inherit",
491			cwd: path.join(__dirname, "../../.."),
492			encoding: "utf-8",
493			shell: true
494			});
495
496			if (installStatus !== 0) {
497			logError("Failed to install the new dependencies. Rolling back");
498			return this.rollbackUpdate(dirpairs);
499			}
500
501			const { status: buildStatus } = spawnSync("npm run build", {
502			stdio: "inherit",
503			cwd: path.join(__dirname, "../../.."),
504			encoding: "utf-8",
505			shell: true
506			});
507
508			if (buildStatus !== 0) {
509			logError("Failed to build the update. Rolling back");
510			return this.rollbackUpdate(dirpairs);
511			}
512			}
513
514			const { status: dbPushStatus } = spawnSync((process.isBun ? "bunx" : "npx") + " prisma db push", {
515			stdio: "inherit",
516			cwd: path.join(__dirname, "../../.."),
517			encoding: "utf-8",
518			shell: true
519			});
520
521			if (dbPushStatus !== 0) {
522			logError("Failed to push database schema changes. Rolling back");
523			return this.rollbackUpdate(dirpairs);
524			}
525
526			const { status: slashCommandStatus } = spawnSync((process.isBun ? "bun" : "npm") + " run deploy", {
527			stdio: "inherit",
528			cwd: path.join(__dirname, "../../.."),
529			encoding: "utf-8",
530			shell: true
531			});
532
533			if (slashCommandStatus !== 0) {
534			logWarn("Failed to update application commands. Please manually update them.");
535			}
536
537			return true;
538			}
539
540			async update({ stableDownloadURL, version }: { stableDownloadURL: string; version: string }) {
541			const updateChannel = this.updateChannel;
542
543			if (!updateChannel) {
544			return false;
545			}
546
547			if (
548			existsSync(path.join(__dirname, "../../..", ".git")) &&
549			(existsSync("/usr/bin/git") \|\| existsSync("/usr/local/bin/git") \|\| existsSync("/bin/git"))
550			) {
551			const dirs = ["src", "prisma", "scripts"];
552
553			if (!process.isBun) {
554			dirs.push("build");
555			}
556
557			const { error, dirpairs } = await this.backupCurrentSystem(dirs);
558
559			if (error) {
560			return false;
561			}
562
563			const { status: gitStatus } = spawnSync("git pull", {
564			stdio: "inherit",
565			cwd: path.join(__dirname, "../../.."),
566			encoding: "utf-8",
567			shell: true
568			});
569
570			if (gitStatus !== 0) {
571			this.client.logger.error("Git command returned non-zero status code");
572			return false;
573			}
574
575			const buildSucceeded = await this.buildNewInstallation(dirpairs!);
576
577			if (!buildSucceeded) {
578			await this.rollbackUpdate(dirpairs!).catch(logError);
579			return false;
580			}
581
582			return true;
583			}
584
585			const { error: downloadError, filePath, storagePath } = await this.downloadUpdate({ stableDownloadURL, version });
586
587			if (downloadError) {
588			return false;
589			}
590
591			const { error: unpackError, unpackedDirectory } = await this.unpackUpdate({
592			filePath: filePath!,
593			storagePath: storagePath!,
594			version
595			});
596
597			if (unpackError) {
598			return false;
599			}
600
601			const successfullyInstalled = await this.installUpdate({ unpackedDirectory: unpackedDirectory!, version });
602
603			if (!successfullyInstalled) {
604			return false;
605			}
606
607			await this.cleanup({ unpackedDirectory: unpackedDirectory!, downloadedFile: filePath! }).catch(log);
608			return true;
609			}
610			}