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, { AnyCommandContext, CommandMessage, CommandReturn, ValidationRule } from "../../core/Command";
import { downloadFile } from "../../utils/download";
import { log, logError, logInfo, logWarn } from "../../utils/logger";
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, context: AnyCommandContext): 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 = false;

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

                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 { error, dirpairs } = await this.backupCurrentSystem(["build", "src", "prisma", "scripts"]);

        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]>) {
        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(`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(`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 { error, dirpairs } = await this.backupCurrentSystem(["build", "src", "prisma", "scripts"]);

            if (error) {
                return false;
            }

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

            if (!gitStatus) {
                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, { AnyCommandContext, CommandMessage, CommandReturn, ValidationRule } from "../../core/Command";
38			import { downloadFile } from "../../utils/download";
39			import { log, logError, logInfo, logWarn } from "../../utils/logger";
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, context: AnyCommandContext): 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 = false;
176
177			try {
178			success = await this.update({
179			stableDownloadURL,
180			version
181			});
182			} catch (e) {}
183
184			await interaction.message.edit({
185			embeds: [
186			{
187			author: {
188			name: "System Update",
189			icon_url: this.client.user?.displayAvatarURL() ?? undefined
190			},
191			description: success
192			? `${this.emoji("check")} Successfully installed the update. Restarting now.`
193			: `${this.emoji("error")} An error has occurred while performing the update.`,
194			color: Colors.Green
195			}
196			]
197			});
198
199			process.exit(this.client.configManager.systemConfig.restart_exit_code);
200			});
201
202			updateChannelCollector.on("collect", async interaction => {
203			if (!interaction.isStringSelectMenu()) {
204			return;
205			}
206
207			const updateChannel = interaction.component.options[0].value;
208
209			if (!["stable", "unstable"].includes(updateChannel)) {
210			return;
211			}
212
213			this.updateChannel = updateChannel as (typeof this)["updateChannel"];
214			await interaction.deferUpdate();
215			});
216			} catch (e) {
217			logError(e);
218			await this.error(message, "An unknown error has occurred while trying to fetch information about the updates.");
219			}
220			}
221
222			actionRow({ version, updateAvailable, disabled = false }: { version: string; updateAvailable: boolean; disabled?: boolean }) {
223			return [
224			new ActionRowBuilder<StringSelectMenuBuilder>().addComponents(
225			new StringSelectMenuBuilder()
226			.addOptions(
227			new StringSelectMenuOptionBuilder({
228			label: "Latest Stable",
229			description: `${version} • ${updateAvailable ? "Update available" : "Up to date"}`,
230			value: "stable",
231			default: updateAvailable
232			}).setEmoji("⚙"),
233			new StringSelectMenuOptionBuilder({
234			label: "Latest Unstable",
235			description: `main • Unstable versions may break things unexpectedly`,
236			value: "unstable",
237			default: !updateAvailable
238			}).setEmoji("⚒️")
239			)
240			.setCustomId("system_update_channel")
241			.setMaxValues(1)
242			.setMinValues(1)
243			.setPlaceholder("Select an update channel")
244			.setDisabled(disabled)
245			),
246			new ActionRowBuilder<ButtonBuilder>().addComponents(
247			new ButtonBuilder()
248			.setCustomId("system_update__cancel")
249			.setLabel("Cancel")
250			.setStyle(ButtonStyle.Danger)
251			.setDisabled(disabled),
252			new ButtonBuilder()
253			.setCustomId("system_update__continue")
254			.setLabel("Continue")
255			.setStyle(ButtonStyle.Success)
256			.setDisabled(disabled)
257			)
258			];
259			}
260
261			downloadUpdate({ stableDownloadURL, version }: { stableDownloadURL: string; version: string }): Promise<{
262			filePath?: string;
263			storagePath?: string;
264			error?: Error;
265			}> {
266			const url = this.updateChannel === "stable" ? stableDownloadURL : this.UNSTABLE_DOWNLOAD_URL;
267			const tmpdir = sudoPrefix("tmp", true);
268			const dirname = `update-${this.updateChannel === "stable" ? version : "unstable"}`;
269
270			try {
271			return downloadFile({
272			url,
273			path: tmpdir,
274			name: `${dirname}.zip`
275			});
276			} catch (error) {
277			logError(error);
278			logError("Failed to download the update package. Aborting");
279			return Promise.resolve({ error: error as Error });
280			}
281			}
282
283			checkRequirements() {
284			const paths = process.env.PATH?.split(process.platform === "win32" ? ";" : ":") ?? [];
285
286			for (const path of paths) {
287			if (process.platform === "win32" && existsSync(join(path, "powershell.exe"))) {
288			return null;
289			}
290
291			if (existsSync(join(path, "unzip"))) {
292			return null;
293			}
294			}
295
296			return process.platform === "win32" ? "powershell.exe" : "unzip";
297			}
298
299			async unpackUpdate({ filePath, storagePath, version }: { version: string; filePath: string; storagePath: string }) {
300			const dirname = `update-${this.updateChannel === "stable" ? version : "unstable"}`;
301			const unpackedDirectory = join(storagePath!, dirname);
302
303			try {
304			const cwd = process.cwd();
305
306			if (existsSync(unpackedDirectory)) {
307			await rm(unpackedDirectory, { recursive: true });
308			}
309
310			await mkdir(unpackedDirectory);
311			process.chdir(unpackedDirectory);
312
313			const { status, error } = spawnSync(
314			process.platform === "win32"
315			? `powershell -command "Expand-Archive -Force '${filePath}' '${unpackedDirectory}'"`
316			: `unzip ../${basename(filePath)}`,
317			{
318			shell: true,
319			encoding: "utf-8",
320			stdio: "inherit",
321			cwd: unpackedDirectory
322			}
323			);
324
325			if (status !== 0 \|\| error) {
326			throw error;
327			}
328
329			process.chdir(cwd);
330			return { unpackedDirectory };
331			} catch (error) {
332			logError(error);
333			logError("Failed to unpack the update package. Aborting.");
334			return { error };
335			}
336			}
337
338			private createDirectoryBackupPair(name: string) {
339			return [path.join(__dirname, "../../../", name), path.join(__dirname, `../../../.backup/${name}`)] as const;
340			}
341
342			async installUpdate({ unpackedDirectory, version }: { unpackedDirectory: string; version: string }) {
343			const { error, dirpairs } = await this.backupCurrentSystem(["build", "src", "prisma", "scripts"]);
344
345			if (error) {
346			return false;
347			}
348
349			const installFiles = ["src", "prisma", "scripts", "package.json", "tsconfig.json"];
350
351			try {
352			for (const installFile of installFiles) {
353			const src = path.join(
354			unpackedDirectory,
355			`sudobot-${this.updateChannel === "stable" ? version : "main"}`,
356			installFile
357			);
358			const dest = path.join(__dirname, "../../../", installFile);
359
360			log(`Installing ${src} to ${dest}`);
361
362			await rm(dest, {
363			recursive: true
364			});
365
366			await cp(src, dest, {
367			recursive: true
368			});
369			}
370			} catch (error) {
371			logError(error);
372			logError("Failed to install the update package. Attempting to rollback the changes");
373			await this.rollbackUpdate(dirpairs!);
374			return false;
375			}
376
377			return await this.buildNewInstallation(dirpairs!);
378			}
379
380			async backupCurrentSystem(dirsToBackup: string[]) {
381			const dirpairs = dirsToBackup.map(dir => this.createDirectoryBackupPair(dir));
382
383			try {
384			await this.createBackupDirectoryIfNeeded();
385
386			for (const [src, dest] of dirpairs) {
387			log(`Copying ${src} to ${dest}`);
388
389			await cp(src, dest, {
390			recursive: true
391			});
392			}
393			} catch (error) {
394			logError(error);
395			logError("Failed to backup the current bot system. Attempting to revert changes");
396			await this.rollbackUpdate(dirpairs);
397			return { error };
398			}
399
400			return { dirpairs };
401			}
402
403			async createBackupDirectoryIfNeeded() {
404			const backupDir = path.join(__dirname, `../../../.backup`);
405
406			if (!existsSync(backupDir)) {
407			await mkdir(backupDir);
408			}
409
410			return backupDir;
411			}
412
413			async rollbackUpdate(dirpairs: Array<readonly [string, string]>) {
414			try {
415			const backupDir = await this.createBackupDirectoryIfNeeded();
416
417			for (const [src, dest] of dirpairs) {
418			if (!existsSync(dest)) {
419			log(`No backup found for ${src}`);
420			continue;
421			}
422
423			log(`Restoring ${src} from ${dest}`);
424
425			if (existsSync(src)) {
426			log(`Saving current state of ${src}`);
427			await rename(src, path.join(backupDir, `${basename(src)}.current`)).catch(log);
428			}
429
430			await rename(dest, src);
431			}
432
433			logInfo("Rolled back the update successfully");
434			} catch (error) {
435			logError(error);
436			logError("Error rolling back the update");
437			return false;
438			}
439
440			return true;
441			}
442
443			async cleanup({ unpackedDirectory, downloadedFile }: { unpackedDirectory: string; downloadedFile: string }) {
444			await rm(unpackedDirectory, { recursive: true });
445			await rm(downloadedFile);
446			}
447
448			buildNewInstallation(dirpairs: Array<readonly [string, string]>) {
449			const { status: buildStatus } = spawnSync(`npm run build`, {
450			stdio: "inherit",
451			cwd: path.join(__dirname, "../../.."),
452			encoding: "utf-8",
453			shell: true
454			});
455
456			if (buildStatus !== 0) {
457			logError("Failed to build the update. Rolling back");
458			return this.rollbackUpdate(dirpairs);
459			}
460
461			const { status: dbPushStatus } = spawnSync(`npx prisma db push`, {
462			stdio: "inherit",
463			cwd: path.join(__dirname, "../../.."),
464			encoding: "utf-8",
465			shell: true
466			});
467
468			if (dbPushStatus !== 0) {
469			logError("Failed to push database schema changes. Rolling back");
470			return this.rollbackUpdate(dirpairs);
471			}
472
473			const { status: slashCommandStatus } = spawnSync(`npm run deploy`, {
474			stdio: "inherit",
475			cwd: path.join(__dirname, "../../.."),
476			encoding: "utf-8",
477			shell: true
478			});
479
480			if (slashCommandStatus !== 0) {
481			logWarn("Failed to update application commands. Please manually update them.");
482			}
483
484			return true;
485			}
486
487			async update({ stableDownloadURL, version }: { stableDownloadURL: string; version: string }) {
488			const updateChannel = this.updateChannel;
489
490			if (!updateChannel) {
491			return false;
492			}
493
494			if (
495			existsSync(path.join(__dirname, "../../..", ".git")) &&
496			(existsSync("/usr/bin/git") \|\| existsSync("/usr/local/bin/git") \|\| existsSync("/bin/git"))
497			) {
498			const { error, dirpairs } = await this.backupCurrentSystem(["build", "src", "prisma", "scripts"]);
499
500			if (error) {
501			return false;
502			}
503
504			const { status: gitStatus } = spawnSync(`git pull`, {
505			stdio: "inherit",
506			cwd: path.join(__dirname, "../../.."),
507			encoding: "utf-8",
508			shell: true
509			});
510
511			if (!gitStatus) {
512			return false;
513			}
514
515			const buildSucceeded = await this.buildNewInstallation(dirpairs!);
516
517			if (!buildSucceeded) {
518			await this.rollbackUpdate(dirpairs!).catch(logError);
519			return false;
520			}
521
522			return true;
523			}
524
525			const { error: downloadError, filePath, storagePath } = await this.downloadUpdate({ stableDownloadURL, version });
526
527			if (downloadError) {
528			return false;
529			}
530
531			const { error: unpackError, unpackedDirectory } = await this.unpackUpdate({
532			filePath: filePath!,
533			storagePath: storagePath!,
534			version
535			});
536
537			if (unpackError) {
538			return false;
539			}
540
541			const successfullyInstalled = await this.installUpdate({ unpackedDirectory: unpackedDirectory!, version });
542
543			if (!successfullyInstalled) {
544			return false;
545			}
546
547			await this.cleanup({ unpackedDirectory: unpackedDirectory!, downloadedFile: filePath! }).catch(log);
548			return true;
549			}
550			}