6.x/scripts/extensions.js

#!/usr/bin/env node

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

require("module-alias/register");
const chalk = require("chalk");
const { spawnSync } = require("child_process");
const { existsSync, lstatSync, readdirSync, readFileSync, writeFileSync, rmSync } = require("fs");
const path = require("path");
const { chdir, cwd } = require("process");

const extensionsPath = path.resolve(__dirname, "../extensions");

function error(...args) {
    console.error(...args);
    process.exit(-1);
}

if (!existsSync(extensionsPath)) {
    error("You're not using any extension! To get started, create an `extensions` folder in the project root.");
}

function getRecuriveJavaScriptFiles(dir) {
    const files = readdirSync(dir);
    const flat = [];

    for (const fileName of files) {
        const file = path.join(dir, fileName);
        const isDirectory = lstatSync(file).isDirectory();

        if (isDirectory) {
            flat.push(...getRecuriveJavaScriptFiles(file));
            continue;
        }

        if (!file.endsWith(".js")) {
            continue;
        }

        flat.push(file);
    }

    return flat;
}

function readMeta(extensionName, extensionDirectory) {
    const metadataFile = path.join(extensionDirectory, "extension.json");

    if (!existsSync(metadataFile)) {
        error(`Extension ${extensionName} does not have a "extension.json" file!`);
    }

    const metadata = JSON.parse(readFileSync(metadataFile, { encoding: "utf-8" }));
    return metadata;
}

async function writeCacheIndex() {
    const extensionsOutputArray = [];
    const meta = [];
    const extensions = readdirSync(extensionsPath);

    for await (const extensionName of extensions) {
        const extensionDirectory = path.resolve(extensionsPath, extensionName);
        const isDirectory = lstatSync(extensionDirectory).isDirectory();

        if (!isDirectory) {
            continue;
        }

        console.log("Found extension: ", extensionName);

        // const metadataFile = path.join(extensionDirectory, "extension.json");

        // if (!existsSync(metadataFile)) {
        //     error(`Extension ${extensionName} does not have a "extension.json" file!`);
        // }

        // const metadata = JSON.parse(readFileSync(metadataFile, { encoding: "utf-8" }));
        // const {
        //     main_directory = "./build",
        //     commands = `./${main_directory}/commands`,
        //     events = `./${main_directory}/events`,
        //     main = `./${main_directory}/index.js`,
        //     language = "typescript"
        // } = metadata;

        const {
            main_directory = "./build",
            commands = `./${main_directory}/commands`,
            events = `./${main_directory}/events`,
            main = `./${main_directory}/index.js`,
            language = "typescript"
        } = readMeta(extensionName, extensionDirectory);

        const extensionPath = path.join(extensionDirectory, main);

        const imported = await require(extensionPath);
        const { default: ExtensionClass } = imported.__esModule ? imported : { default: imported };
        const extension = new ExtensionClass(this.client);
        let commandPaths = await extension.commands();
        let eventPaths = await extension.events();

        if (commandPaths === null) {
            const directory = path.join(__dirname, "../extensions", extensionName, commands);

            if (existsSync(directory)) {
                commandPaths = getRecuriveJavaScriptFiles(directory);
            }
        }

        if (eventPaths === null) {
            const directory = path.join(__dirname, "../extensions", extensionName, events);

            if (existsSync(directory)) {
                eventPaths = getRecuriveJavaScriptFiles(directory);
            }
        }

        extensionsOutputArray.push({
            name: extensionName,
            entry: extensionPath,
            commands: commandPaths ?? [],
            events: eventPaths ?? []
        });

        meta.push({
            language
        });
    }

    console.log("Overview of the extensions: ");
    console.table(
        extensionsOutputArray.map((e, i) => ({
            name: e.name,
            entry: e.entry.replace(path.resolve(__dirname, "../extensions"), "{ROOT}"),
            commands: e.commands.length,
            events: e.events.length,
            language: meta[i].language
        }))
    );

    const indexFile = path.join(__dirname, "../extensions/index.json");

    writeFileSync(
        indexFile,
        JSON.stringify(
            {
                extensions: extensionsOutputArray
            },
            null,
            4
        )
    );

    console.log("Wrote cache index file: ", indexFile);
    console.warn(
        "Note: If you're getting import errors after caching extensions, please try first by removing or rebuilding them."
    );
}

const MAX_CHARS = 7;

function actionLog(action, description) {
    console.log(
        chalk.green.bold(`${action}${action.length >= MAX_CHARS ? "" : " ".repeat(MAX_CHARS - action.length)} `),
        description
    );
}

function spawnSyncCatchExit(...args) {
    actionLog("RUN", args[0]);
    const { status } = spawnSync(...args);
    if (status !== 0) process.exit(status);
}

async function buildExtensions() {
    const startTime = Date.now();
    const extensions = readdirSync(extensionsPath);
    const workingDirectory = cwd();

    for await (const extensionName of extensions) {
        const extensionDirectory = path.resolve(extensionsPath, extensionName);
        const isDirectory = lstatSync(extensionDirectory).isDirectory();

        if (!isDirectory) {
            continue;
        }

        chdir(path.join(extensionsPath, extensionName));

        actionLog("DEPS", extensionName);
        spawnSyncCatchExit("npm install -D", {
            encoding: "utf-8",
            shell: true,
            stdio: "inherit"
        });

        actionLog("RELINK", extensionName);
        spawnSyncCatchExit(`npm link --save ${path.relative(cwd(), path.resolve(__dirname, ".."))}`, {
            encoding: "utf-8",
            shell: true,
            stdio: "inherit"
        });

        actionLog("BUILD", extensionName);
        const { build_command } = readMeta(extensionName, extensionDirectory);

        if (!build_command) {
            console.log(chalk.cyan.bold("INFO "), "This extension doesn't require building.");
            continue;
        }

        spawnSyncCatchExit(build_command, {
            encoding: "utf-8",
            shell: true,
            stdio: "inherit"
        });
    }

    actionLog("SUCCESS", `in ${((Date.now() - startTime) / 1000).toFixed(2)}s, built ${extensions.length} extensions`);
    chdir(workingDirectory);
}

if (process.argv.includes("--clear-cache") || process.argv.includes("--clean") || process.argv.includes("--delcache")) {
    const indexFile = path.join(__dirname, "../extensions/index.json");

    if (!existsSync(indexFile)) {
        error("No cached index file found!");
    }

    rmSync(indexFile);
    console.log("Removed cached index file: ", indexFile);
} else if (process.argv.includes("--cache") || process.argv.includes("--index")) {
    console.time("Finished in");
    console.log("Creating cache index for all the installed extensions");
    writeCacheIndex()
        .then(() => console.timeEnd("Finished in"))
        .catch(e => {
            console.log(e);
            console.timeEnd("Finished in");
        });
} else if (process.argv.includes("--build")) {
    console.log("Building installed extensions");
    buildExtensions().catch(e => {
        console.log(e);
        process.exit(-1);
    });
} else {
    console.log("Usage:");
    console.log("  node extensions.js <options>\n");
    console.log("Options:");
    console.log("  --build  |  Builds all the installed extensions, if needed.");
    console.log("  --cache  |  Creates cache indexes for installed extensions, to improve the startup time.");
    console.log("  --clean  |  Clears all installed extension cache.");
    process.exit(-1);
}
1	rakinar2	577	#!/usr/bin/env node
2
3			/*
4			* This file is part of SudoBot.
5			*
6			* Copyright (C) 2021-2023 OSN Developers.
7			*
8			* SudoBot is free software; you can redistribute it and/or modify it
9			* under the terms of the GNU Affero General Public License as published by
10			* the Free Software Foundation, either version 3 of the License, or
11			* (at your option) any later version.
12			*
13			* SudoBot is distributed in the hope that it will be useful, but
14			* WITHOUT ANY WARRANTY; without even the implied warranty of
15			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16			* GNU Affero General Public License for more details.
17			*
18			* You should have received a copy of the GNU Affero General Public License
19			* along with SudoBot. If not, see <https://www.gnu.org/licenses/>.
20			*/
21
22			require("module-alias/register");
23			const chalk = require("chalk");
24			const { spawnSync } = require("child_process");
25			const { existsSync, lstatSync, readdirSync, readFileSync, writeFileSync, rmSync } = require("fs");
26			const path = require("path");
27			const { chdir, cwd } = require("process");
28
29			const extensionsPath = path.resolve(__dirname, "../extensions");
30
31			function error(...args) {
32			console.error(...args);
33			process.exit(-1);
34			}
35
36			if (!existsSync(extensionsPath)) {
37			error("You're not using any extension! To get started, create an `extensions` folder in the project root.");
38			}
39
40			function getRecuriveJavaScriptFiles(dir) {
41			const files = readdirSync(dir);
42			const flat = [];
43
44			for (const fileName of files) {
45			const file = path.join(dir, fileName);
46			const isDirectory = lstatSync(file).isDirectory();
47
48			if (isDirectory) {
49			flat.push(...getRecuriveJavaScriptFiles(file));
50			continue;
51			}
52
53			if (!file.endsWith(".js")) {
54			continue;
55			}
56
57			flat.push(file);
58			}
59
60			return flat;
61			}
62
63			function readMeta(extensionName, extensionDirectory) {
64			const metadataFile = path.join(extensionDirectory, "extension.json");
65
66			if (!existsSync(metadataFile)) {
67			error(`Extension ${extensionName} does not have a "extension.json" file!`);
68			}
69
70			const metadata = JSON.parse(readFileSync(metadataFile, { encoding: "utf-8" }));
71			return metadata;
72			}
73
74			async function writeCacheIndex() {
75			const extensionsOutputArray = [];
76			const meta = [];
77			const extensions = readdirSync(extensionsPath);
78
79			for await (const extensionName of extensions) {
80			const extensionDirectory = path.resolve(extensionsPath, extensionName);
81			const isDirectory = lstatSync(extensionDirectory).isDirectory();
82
83			if (!isDirectory) {
84			continue;
85			}
86
87			console.log("Found extension: ", extensionName);
88
89			// const metadataFile = path.join(extensionDirectory, "extension.json");
90
91			// if (!existsSync(metadataFile)) {
92			// error(`Extension ${extensionName} does not have a "extension.json" file!`);
93			// }
94
95			// const metadata = JSON.parse(readFileSync(metadataFile, { encoding: "utf-8" }));
96			// const {
97			// main_directory = "./build",
98			// commands = `./${main_directory}/commands`,
99			// events = `./${main_directory}/events`,
100			// main = `./${main_directory}/index.js`,
101			// language = "typescript"
102			// } = metadata;
103
104			const {
105			main_directory = "./build",
106			commands = `./${main_directory}/commands`,
107			events = `./${main_directory}/events`,
108			main = `./${main_directory}/index.js`,
109			language = "typescript"
110			} = readMeta(extensionName, extensionDirectory);
111
112			const extensionPath = path.join(extensionDirectory, main);
113
114			const imported = await require(extensionPath);
115			const { default: ExtensionClass } = imported.__esModule ? imported : { default: imported };
116			const extension = new ExtensionClass(this.client);
117			let commandPaths = await extension.commands();
118			let eventPaths = await extension.events();
119
120			if (commandPaths === null) {
121			const directory = path.join(__dirname, "../extensions", extensionName, commands);
122
123			if (existsSync(directory)) {
124			commandPaths = getRecuriveJavaScriptFiles(directory);
125			}
126			}
127
128			if (eventPaths === null) {
129			const directory = path.join(__dirname, "../extensions", extensionName, events);
130
131			if (existsSync(directory)) {
132			eventPaths = getRecuriveJavaScriptFiles(directory);
133			}
134			}
135
136			extensionsOutputArray.push({
137			name: extensionName,
138			entry: extensionPath,
139			commands: commandPaths ?? [],
140			events: eventPaths ?? []
141			});
142
143			meta.push({
144			language
145			});
146			}
147
148			console.log("Overview of the extensions: ");
149			console.table(
150			extensionsOutputArray.map((e, i) => ({
151			name: e.name,
152			entry: e.entry.replace(path.resolve(__dirname, "../extensions"), "{ROOT}"),
153			commands: e.commands.length,
154			events: e.events.length,
155			language: meta[i].language
156			}))
157			);
158
159			const indexFile = path.join(__dirname, "../extensions/index.json");
160
161			writeFileSync(
162			indexFile,
163			JSON.stringify(
164			{
165			extensions: extensionsOutputArray
166			},
167			null,
168			4
169			)
170			);
171
172			console.log("Wrote cache index file: ", indexFile);
173			console.warn(
174			"Note: If you're getting import errors after caching extensions, please try first by removing or rebuilding them."
175			);
176			}
177
178			const MAX_CHARS = 7;
179
180			function actionLog(action, description) {
181			console.log(
182			chalk.green.bold(`${action}${action.length >= MAX_CHARS ? "" : " ".repeat(MAX_CHARS - action.length)} `),
183			description
184			);
185			}
186
187			function spawnSyncCatchExit(...args) {
188			actionLog("RUN", args[0]);
189			const { status } = spawnSync(...args);
190			if (status !== 0) process.exit(status);
191			}
192
193			async function buildExtensions() {
194			const startTime = Date.now();
195			const extensions = readdirSync(extensionsPath);
196			const workingDirectory = cwd();
197
198			for await (const extensionName of extensions) {
199			const extensionDirectory = path.resolve(extensionsPath, extensionName);
200			const isDirectory = lstatSync(extensionDirectory).isDirectory();
201
202			if (!isDirectory) {
203			continue;
204			}
205
206			chdir(path.join(extensionsPath, extensionName));
207
208			actionLog("DEPS", extensionName);
209			spawnSyncCatchExit("npm install -D", {
210			encoding: "utf-8",
211			shell: true,
212			stdio: "inherit"
213			});
214
215			actionLog("RELINK", extensionName);
216			spawnSyncCatchExit(`npm link --save ${path.relative(cwd(), path.resolve(__dirname, ".."))}`, {
217			encoding: "utf-8",
218			shell: true,
219			stdio: "inherit"
220			});
221
222			actionLog("BUILD", extensionName);
223			const { build_command } = readMeta(extensionName, extensionDirectory);
224
225			if (!build_command) {
226			console.log(chalk.cyan.bold("INFO "), "This extension doesn't require building.");
227			continue;
228			}
229
230			spawnSyncCatchExit(build_command, {
231			encoding: "utf-8",
232			shell: true,
233			stdio: "inherit"
234			});
235			}
236
237			actionLog("SUCCESS", `in ${((Date.now() - startTime) / 1000).toFixed(2)}s, built ${extensions.length} extensions`);
238			chdir(workingDirectory);
239			}
240
241			if (process.argv.includes("--clear-cache") \|\| process.argv.includes("--clean") \|\| process.argv.includes("--delcache")) {
242			const indexFile = path.join(__dirname, "../extensions/index.json");
243
244			if (!existsSync(indexFile)) {
245			error("No cached index file found!");
246			}
247
248			rmSync(indexFile);
249			console.log("Removed cached index file: ", indexFile);
250			} else if (process.argv.includes("--cache") \|\| process.argv.includes("--index")) {
251			console.time("Finished in");
252			console.log("Creating cache index for all the installed extensions");
253			writeCacheIndex()
254			.then(() => console.timeEnd("Finished in"))
255			.catch(e => {
256			console.log(e);
257			console.timeEnd("Finished in");
258			});
259			} else if (process.argv.includes("--build")) {
260			console.log("Building installed extensions");
261			buildExtensions().catch(e => {
262			console.log(e);
263			process.exit(-1);
264			});
265			} else {
266			console.log("Usage:");
267			console.log(" node extensions.js <options>\n");
268			console.log("Options:");
269			console.log(" --build \| Builds all the installed extensions, if needed.");
270			console.log(" --cache \| Creates cache indexes for installed extensions, to improve the startup time.");
271			console.log(" --clean \| Clears all installed extension cache.");
272			process.exit(-1);
273			}