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	/**
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	}