src/services/KeypressHandlerService.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 { spawnSync } from "node:child_process";
import { lstat } from "node:fs/promises";
import path from "node:path";
import { chdir, cwd } from "node:process";
import readline from "node:readline";
import Service from "../core/Service";
import { AnyFunction } from "../types/Utils";
import { LogLevel, logError, logInfo, logWarn, logWithLevel } from "../utils/Logger";
import { developmentMode } from "../utils/utils";

export const name = "keypressHandler";

enum CommandKey {
    ReloadCommands = "R",
    ForceReloadCommands = "Shift+R",
    ReloadConfig = "L",
    WriteConfig = "Shift+L",
    Quit = "Q"
}

export default class KeypressHandlerService extends Service {
    readonly keyHandlers: Record<CommandKey, AnyFunction<[], unknown>> = {
        [CommandKey.ReloadCommands]: this.reloadCommands.bind(this),
        [CommandKey.ForceReloadCommands]: () => this.reloadCommands(true),
        [CommandKey.Quit]: this.quit.bind(this),
        [CommandKey.ReloadConfig]: this.reloadConfig.bind(this),
        [CommandKey.WriteConfig]: this.writeConfig.bind(this)
    };

    lastCommandUpdate = Date.now();

    onKeyPress = (
        _: string,
        key: {
            ctrl: boolean;
            meta: boolean;
            shift: boolean;
            name: string;
        }
    ) => {
        if (key.name.length !== 1) {
            return;
        }

        const modifiers: string[] = [];

        if (key.ctrl) modifiers.push("Ctrl");
        if (key.meta) modifiers.push("Meta");
        if (key.shift) modifiers.push("Shift");

        const commandKey = `${modifiers.join("+")}${modifiers.length > 0 ? "+" : ""}${key.name.toUpperCase()}`;
        const handler = this.keyHandlers[commandKey as CommandKey];

        if (handler) {
            handler();
            return;
        }

        if (key.ctrl && !key.meta && !key.shift && key.name === "c") {
            this.interrupt();
            return;
        }

        logWarn("Unrecognized command key: ", `${commandKey}`);
    };

    quit() {
        logWithLevel(LogLevel.Event, "Quit");
        process.exit(0);
    }

    interrupt() {
        logWithLevel(LogLevel.Event, "SIGINT signal received. Exiting");
        process.exit(1);
    }

    async reloadConfig() {
        await this.client.configManager.load();
        logWithLevel(LogLevel.Event, "Successfully reloaded configuration files");
    }

    async writeConfig() {
        await this.client.configManager.write({ guild: true, system: true });
        logWithLevel(LogLevel.Event, "Successfully saved configuration files to disk");
    }

    async reloadCommands(force = false) {
        const srcDir = process.env.SOURCE_DIRECTORY_PATH ?? path.resolve(__dirname, "../../src");
        const buildDir = process.env.BUILD_DIRECTORY_PATH ?? path.resolve(__dirname, "../../build");
        let built = false,
            failed = false;

        logWithLevel(LogLevel.Event, "Hot reloading commands");

        await this.client.dynamicLoader.loadCommands(undefined, true, async filePath => {
            if (failed) {
                return false;
            }

            if (force) {
                return true;
            }

            delete require.cache[require.resolve(filePath)];

            const sourceFile = filePath.replace(buildDir, srcDir).replace(/\.js$/gi, ".ts");
            const sourceInfo = await lstat(sourceFile);

            if (sourceInfo.mtime.getTime() < this.lastCommandUpdate) {
                return false;
            }

            if (!built && !__filename.endsWith(".ts")) {
                const currentDirectory = cwd();
                chdir(path.resolve(__dirname, "../.."));

                logInfo("Rebuilding project source files");

                const { status } = spawnSync("npm run build", {
                    encoding: "utf-8",
                    shell: true,
                    stdio: "inherit"
                });

                chdir(currentDirectory);

                if (status !== 0) {
                    failed = true;
                    return false;
                }

                built = true;
            }

            return true;
        });

        this.lastCommandUpdate = Date.now();

        if (failed) {
            logError("Build failed. Aborting hot reload");
        } else {
            logWithLevel(LogLevel.Event, "Successfully hot reloaded commands");
        }
    }

    override boot() {
        if (!developmentMode() || !process.stdin.isTTY) {
            return;
        }

        readline.emitKeypressEvents(process.stdin);
        process.stdin.on("keypress", this.onKeyPress);
        process.stdin.setRawMode(true);
    }

    override deactivate() {
        if (!developmentMode() || !process.stdin.isTTY) {
            return;
        }

        process.stdin.off("keypress", this.onKeyPress);
        process.stdin.setRawMode(false);
    }
}
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 { spawnSync } from "node:child_process";
21	import { lstat } from "node:fs/promises";
22	import path from "node:path";
23	import { chdir, cwd } from "node:process";
24	import readline from "node:readline";
25	import Service from "../core/Service";
26	import { AnyFunction } from "../types/Utils";
27	import { LogLevel, logError, logInfo, logWarn, logWithLevel } from "../utils/Logger";
28	import { developmentMode } from "../utils/utils";
29
30	export const name = "keypressHandler";
31
32	enum CommandKey {
33	ReloadCommands = "R",
34	ForceReloadCommands = "Shift+R",
35	ReloadConfig = "L",
36	WriteConfig = "Shift+L",
37	Quit = "Q"
38	}
39
40	export default class KeypressHandlerService extends Service {
41	readonly keyHandlers: Record<CommandKey, AnyFunction<[], unknown>> = {
42	[CommandKey.ReloadCommands]: this.reloadCommands.bind(this),
43	[CommandKey.ForceReloadCommands]: () => this.reloadCommands(true),
44	[CommandKey.Quit]: this.quit.bind(this),
45	[CommandKey.ReloadConfig]: this.reloadConfig.bind(this),
46	[CommandKey.WriteConfig]: this.writeConfig.bind(this)
47	};
48
49	lastCommandUpdate = Date.now();
50
51	onKeyPress = (
52	_: string,
53	key: {
54	ctrl: boolean;
55	meta: boolean;
56	shift: boolean;
57	name: string;
58	}
59	) => {
60	if (key.name.length !== 1) {
61	return;
62	}
63
64	const modifiers: string[] = [];
65
66	if (key.ctrl) modifiers.push("Ctrl");
67	if (key.meta) modifiers.push("Meta");
68	if (key.shift) modifiers.push("Shift");
69
70	const commandKey = `${modifiers.join("+")}${modifiers.length > 0 ? "+" : ""}${key.name.toUpperCase()}`;
71	const handler = this.keyHandlers[commandKey as CommandKey];
72
73	if (handler) {
74	handler();
75	return;
76	}
77
78	if (key.ctrl && !key.meta && !key.shift && key.name === "c") {
79	this.interrupt();
80	return;
81	}
82
83	logWarn("Unrecognized command key: ", `${commandKey}`);
84	};
85
86	quit() {
87	logWithLevel(LogLevel.Event, "Quit");
88	process.exit(0);
89	}
90
91	interrupt() {
92	logWithLevel(LogLevel.Event, "SIGINT signal received. Exiting");
93	process.exit(1);
94	}
95
96	async reloadConfig() {
97	await this.client.configManager.load();
98	logWithLevel(LogLevel.Event, "Successfully reloaded configuration files");
99	}
100
101	async writeConfig() {
102	await this.client.configManager.write({ guild: true, system: true });
103	logWithLevel(LogLevel.Event, "Successfully saved configuration files to disk");
104	}
105
106	async reloadCommands(force = false) {
107	const srcDir = process.env.SOURCE_DIRECTORY_PATH ?? path.resolve(__dirname, "../../src");
108	const buildDir = process.env.BUILD_DIRECTORY_PATH ?? path.resolve(__dirname, "../../build");
109	let built = false,
110	failed = false;
111
112	logWithLevel(LogLevel.Event, "Hot reloading commands");
113
114	await this.client.dynamicLoader.loadCommands(undefined, true, async filePath => {
115	if (failed) {
116	return false;
117	}
118
119	if (force) {
120	return true;
121	}
122
123	delete require.cache[require.resolve(filePath)];
124
125	const sourceFile = filePath.replace(buildDir, srcDir).replace(/\.js$/gi, ".ts");
126	const sourceInfo = await lstat(sourceFile);
127
128	if (sourceInfo.mtime.getTime() < this.lastCommandUpdate) {
129	return false;
130	}
131
132	if (!built && !__filename.endsWith(".ts")) {
133	const currentDirectory = cwd();
134	chdir(path.resolve(__dirname, "../.."));
135
136	logInfo("Rebuilding project source files");
137
138	const { status } = spawnSync("npm run build", {
139	encoding: "utf-8",
140	shell: true,
141	stdio: "inherit"
142	});
143
144	chdir(currentDirectory);
145
146	if (status !== 0) {
147	failed = true;
148	return false;
149	}
150
151	built = true;
152	}
153
154	return true;
155	});
156
157	this.lastCommandUpdate = Date.now();
158
159	if (failed) {
160	logError("Build failed. Aborting hot reload");
161	} else {
162	logWithLevel(LogLevel.Event, "Successfully hot reloaded commands");
163	}
164	}
165
166	override boot() {
167	if (!developmentMode() \|\| !process.stdin.isTTY) {
168	return;
169	}
170
171	readline.emitKeypressEvents(process.stdin);
172	process.stdin.on("keypress", this.onKeyPress);
173	process.stdin.setRawMode(true);
174	}
175
176	override deactivate() {
177	if (!developmentMode() \|\| !process.stdin.isTTY) {
178	return;
179	}
180
181	process.stdin.off("keypress", this.onKeyPress);
182	process.stdin.setRawMode(false);
183	}
184	}