8.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");
require("dotenv/config");

const chalk = require("chalk");
const { spawnSync } = require("child_process");
const { existsSync, lstatSync, readdirSync, readFileSync, writeFileSync, rmSync } = require("fs");
const { readFile } = require("fs/promises");
const path = require("path");
const { chdir, cwd } = require("process");
const { z } = require("zod");
const semver = require("semver");

const extensionsPath = process.env.EXTENSIONS_DIRECTORY ?? 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) {
    if (!existsSync(dir)) {
        return [];
    }

    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;
}

const extensionMetadataSchema = z.object({
    main: z.string().optional(),
    commands: z.string().optional(),
    services: z.string().optional(),
    events: z.string().optional(),
    language: z.enum(["typescript", "javascript"]).optional(),
    main_directory: z.string().optional(),
    build_command: z.string().optional(),
    name: z.string().optional(),
    description: z.string().optional(),
    resources: z.string().optional(),
    id: z.string(),
    icon: z.string().optional(),
    readmeFileName: z.string().default("README.md")
});

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" }));

    try {
        return extensionMetadataSchema.parse(metadata);
    } catch (e) {
        error(`Extension ${extensionName} has an invalid "extension.json" file!`, e);
    }
}

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 || extensionName === ".extbuilds") {
            continue;
        }

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

        const {
            main_directory = "./build",
            commands = `./${main_directory}/commands`,
            events = `./${main_directory}/events`,
            services = `./${main_directory}/services`,
            main = `./${main_directory}/index.js`,
            language = "typescript",
            id
        } = 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();
        let servicePaths = await extension.services();

        if (commandPaths === null) {
            const directory = path.join(
                ...(process.env.EXTENSIONS_DIRECTORY ? [process.env.EXTENSIONS_DIRECTORY] : [__dirname, "../extensions"]),
                extensionName,
                commands
            );

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

        if (eventPaths === null) {
            const directory = path.join(
                ...(process.env.EXTENSIONS_DIRECTORY ? [process.env.EXTENSIONS_DIRECTORY] : [__dirname, "../extensions"]),
                extensionName,
                events
            );

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

        if (servicePaths === null) {
            const directory = path.join(
                ...(process.env.EXTENSIONS_DIRECTORY ? [process.env.EXTENSIONS_DIRECTORY] : [__dirname, "../extensions"]),
                extensionName,
                services
            );

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

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

        meta.push({
            language
        });
    }

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

    const indexFile = path.join(extensionsPath, "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();
    let count = 0;

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

        if (!isDirectory || extensionName === ".extbuilds") {
            continue;
        }

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

        if (!process.argv.includes("--tsc")) {
            actionLog("DEPS", extensionName);
            spawnSyncCatchExit("npm install -D", {
                encoding: "utf-8",
                shell: true,
                stdio: "inherit"
            });

            actionLog("RELINK", extensionName);
            spawnSyncCatchExit(`npm install --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"
        });

        count++;
    }

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

async function writeExtensionIndex() {
    const extensionsPath = path.resolve(__dirname, "../extensions");
    const extensionsOutputRecord = {};
    const extensions = readdirSync(extensionsPath);

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

        if (!isDirectory || extensionName === ".extbuilds") {
            continue;
        }

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

        const packageJsonPath = path.join(extensionDirectory, "package.json");
        const packageJson = JSON.parse(await readFile(packageJsonPath, { encoding: "utf-8" }));

        const {
            main_directory = "./build",
            commands = `./${main_directory}/commands`,
            events = `./${main_directory}/events`,
            build_command = null,
            name = packageJson.name ?? extensionName,
            description = packageJson.description,
            language = "javascript",
            main = `./${main_directory}/index.js`,
            services = `./${main_directory}/services`,
            id,
            icon,
            readmeFileName
        } = readMeta(extensionName, extensionDirectory) ?? {};

        const commandPaths = getRecuriveJavaScriptFiles(path.join(extensionDirectory, commands));
        const eventPaths = getRecuriveJavaScriptFiles(path.join(extensionDirectory, events));
        const servicePaths = getRecuriveJavaScriptFiles(path.join(extensionDirectory, services));

        const tarballs = readdirSync(path.resolve(extensionsPath, ".extbuilds", extensionName));

        tarballs.sort((a, b) => {
            const vA = path
                .basename(a)
                .replace(`${extensionName}-`, "")
                .replace(/\.tar\.gz$/gi, "");
            const vB = path
                .basename(b)
                .replace(`${extensionName}-`, "")
                .replace(/\.tar\.gz$/gi, "");
            const splitA = vA.split("-");
            const splitB = vB.split("-");
            const dashVA = splitA[1];
            const dashVB = splitB[1];
            const revA = isNaN(dashVA) ? 0 : parseInt(dashVA);
            const revB = isNaN(dashVB) ? 0 : parseInt(dashVB);
            const result = semver.rcompare(vA, vB);

            if (splitA[0] === splitB[0] && vA.includes("-") && !isNaN(dashVA) && (!vB.includes("-") || isNaN(dashVB))) {
                return -1;
            }

            if (splitA[0] === splitB[0] && vB.includes("-") && !isNaN(dashVB) && (!vA.includes("-") || isNaN(dashVA))) {
                return 1;
            }

            return result === 0 ? revB - revA : result;
        });

        const tarballList = tarballs.map(file => {
            const basename = path.basename(file);
            const filePath = path.join(extensionsPath, ".extbuilds", extensionName, basename);
            const { stdout } = spawnSync(`sha512sum`, [filePath], {
                encoding: "utf-8"
            });
            const { size, birthtime } = lstatSync(filePath);
            const checksum = stdout.split(" ")[0];

            return {
                url:
                    "https://raw.githubusercontent.com/onesoft-sudo/sudobot/main/extensions" +
                    path.join("/.extbuilds/", extensionName, basename),
                basename,
                version: basename.replace(`${extensionName}-`, "").replace(/\.tar\.gz$/gi, ""),
                checksum,
                size,
                createdAt: birthtime
            };
        });

        extensionsOutputRecord[id] = {
            name,
            id,
            shortName: packageJson.name ?? extensionName,
            description,
            version: packageJson.version,
            commands: commandPaths.length,
            events: eventPaths.length,
            buildCommand: build_command,
            language,
            services: servicePaths.length,
            main,
            iconURL: icon
                ? "https://raw.githubusercontent.com/onesoft-sudo/sudobot/main/extensions" + path.join("/", extensionName, icon)
                : null,
            author:
                typeof packageJson.author === "string"
                    ? {
                          name: packageJson.author
                      }
                    : packageJson.author,
            license: packageJson.license,
            licenseURL: `https://spdx.org/licenses/${packageJson.license}.html`,
            homepage: packageJson.homepage,
            repository: typeof packageJson.repository === "string" ? packageJson.repository : packageJson.repository?.url,
            issues: typeof packageJson.bugs === "string" ? packageJson.bugs : packageJson.bugs?.url,
            lastUpdated: new Date(),
            readmeFileName: readmeFileName,
            readmeFileURL: `https://raw.githubusercontent.com/onesoft-sudo/sudobot/main/extensions/${extensionName}/${readmeFileName}`,
            tarballs: tarballList
        };
    }

    console.log("Overview of the extensions: ");
    console.table(
        Object.values(extensionsOutputRecord).map(e => ({
            name: e.name,
            commands: e.commands.length,
            events: e.events.length
        }))
    );

    const indexFile = path.join(extensionsPath, ".extbuilds/index.json");

    writeFileSync(indexFile, JSON.stringify(extensionsOutputRecord, null, 4));

    console.log("Wrote index file: ", indexFile);
}

if (process.argv.includes("--clear-cache") || process.argv.includes("--clean") || process.argv.includes("--delcache")) {
    const indexFile = path.join(extensionsPath, "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 if (process.argv.includes("--mkindex")) {
    console.log("Creating index for all the available extensions in the extensions/ directory");

    writeExtensionIndex().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 [--tsc]    |  Builds all the installed extensions, if needed.");
    console.log("                     |  The `--tsc` flag will only run the typescript compiler.");
    console.log("  --cache            |  Creates cache indexes for installed extensions, to improve the startup time.");
    console.log("  --clean            |  Clears all installed extension cache.");
    console.log(
        "  --mkindex          |  Creates indexes for all the available extensions, in the extensions/ top level directory."
    );
    process.exit(-1);
}
1	#!/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	require("dotenv/config");
24
25	const chalk = require("chalk");
26	const { spawnSync } = require("child_process");
27	const { existsSync, lstatSync, readdirSync, readFileSync, writeFileSync, rmSync } = require("fs");
28	const { readFile } = require("fs/promises");
29	const path = require("path");
30	const { chdir, cwd } = require("process");
31	const { z } = require("zod");
32	const semver = require("semver");
33
34	const extensionsPath = process.env.EXTENSIONS_DIRECTORY ?? path.resolve(__dirname, "../extensions");
35
36	function error(...args) {
37	console.error(...args);
38	process.exit(-1);
39	}
40
41	if (!existsSync(extensionsPath)) {
42	error("You're not using any extension! To get started, create an `extensions` folder in the project root.");
43	}
44
45	function getRecuriveJavaScriptFiles(dir) {
46	if (!existsSync(dir)) {
47	return [];
48	}
49
50	const files = readdirSync(dir);
51	const flat = [];
52
53	for (const fileName of files) {
54	const file = path.join(dir, fileName);
55	const isDirectory = lstatSync(file).isDirectory();
56
57	if (isDirectory) {
58	flat.push(...getRecuriveJavaScriptFiles(file));
59	continue;
60	}
61
62	if (!file.endsWith(".js")) {
63	continue;
64	}
65
66	flat.push(file);
67	}
68
69	return flat;
70	}
71
72	const extensionMetadataSchema = z.object({
73	main: z.string().optional(),
74	commands: z.string().optional(),
75	services: z.string().optional(),
76	events: z.string().optional(),
77	language: z.enum(["typescript", "javascript"]).optional(),
78	main_directory: z.string().optional(),
79	build_command: z.string().optional(),
80	name: z.string().optional(),
81	description: z.string().optional(),
82	resources: z.string().optional(),
83	id: z.string(),
84	icon: z.string().optional(),
85	readmeFileName: z.string().default("README.md")
86	});
87
88	function readMeta(extensionName, extensionDirectory) {
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
97	try {
98	return extensionMetadataSchema.parse(metadata);
99	} catch (e) {
100	error(`Extension ${extensionName} has an invalid "extension.json" file!`, e);
101	}
102	}
103
104	async function writeCacheIndex() {
105	const extensionsOutputArray = [];
106	const meta = [];
107	const extensions = readdirSync(extensionsPath);
108
109	for await (const extensionName of extensions) {
110	const extensionDirectory = path.resolve(extensionsPath, extensionName);
111	const isDirectory = lstatSync(extensionDirectory).isDirectory();
112
113	if (!isDirectory \|\| extensionName === ".extbuilds") {
114	continue;
115	}
116
117	console.log("Found extension: ", extensionName);
118
119	const {
120	main_directory = "./build",
121	commands = `./${main_directory}/commands`,
122	events = `./${main_directory}/events`,
123	services = `./${main_directory}/services`,
124	main = `./${main_directory}/index.js`,
125	language = "typescript",
126	id
127	} = readMeta(extensionName, extensionDirectory);
128
129	const extensionPath = path.join(extensionDirectory, main);
130
131	const imported = await require(extensionPath);
132	const { default: ExtensionClass } = imported.__esModule ? imported : { default: imported };
133	const extension = new ExtensionClass(this.client);
134	let commandPaths = await extension.commands();
135	let eventPaths = await extension.events();
136	let servicePaths = await extension.services();
137
138	if (commandPaths === null) {
139	const directory = path.join(
140	...(process.env.EXTENSIONS_DIRECTORY ? [process.env.EXTENSIONS_DIRECTORY] : [__dirname, "../extensions"]),
141	extensionName,
142	commands
143	);
144
145	if (existsSync(directory)) {
146	commandPaths = getRecuriveJavaScriptFiles(directory);
147	}
148	}
149
150	if (eventPaths === null) {
151	const directory = path.join(
152	...(process.env.EXTENSIONS_DIRECTORY ? [process.env.EXTENSIONS_DIRECTORY] : [__dirname, "../extensions"]),
153	extensionName,
154	events
155	);
156
157	if (existsSync(directory)) {
158	eventPaths = getRecuriveJavaScriptFiles(directory);
159	}
160	}
161
162	if (servicePaths === null) {
163	const directory = path.join(
164	...(process.env.EXTENSIONS_DIRECTORY ? [process.env.EXTENSIONS_DIRECTORY] : [__dirname, "../extensions"]),
165	extensionName,
166	services
167	);
168
169	if (existsSync(directory)) {
170	servicePaths = getRecuriveJavaScriptFiles(directory);
171	}
172	}
173
174	extensionsOutputArray.push({
175	name: extensionName,
176	entry: extensionPath,
177	commands: commandPaths ?? [],
178	events: eventPaths ?? [],
179	services: servicePaths ?? [],
180	id
181	});
182
183	meta.push({
184	language
185	});
186	}
187
188	console.log("Overview of the extensions: ");
189	console.table(
190	extensionsOutputArray.map((e, i) => ({
191	name: e.name,
192	entry: e.entry.replace(extensionsPath, "{ROOT}"),
193	commands: e.commands.length,
194	events: e.events.length,
195	services: e.services.length,
196	language: meta[i].language
197	}))
198	);
199
200	const indexFile = path.join(extensionsPath, "index.json");
201
202	writeFileSync(
203	indexFile,
204	JSON.stringify(
205	{
206	extensions: extensionsOutputArray
207	},
208	null,
209	4
210	)
211	);
212
213	console.log("Wrote cache index file: ", indexFile);
214	console.warn(
215	"Note: If you're getting import errors after caching extensions, please try first by removing or rebuilding them."
216	);
217	}
218
219	const MAX_CHARS = 7;
220
221	function actionLog(action, description) {
222	console.log(
223	chalk.green.bold(`${action}${action.length >= MAX_CHARS ? "" : " ".repeat(MAX_CHARS - action.length)} `),
224	description
225	);
226	}
227
228	function spawnSyncCatchExit(...args) {
229	actionLog("RUN", args[0]);
230	const { status } = spawnSync(...args);
231	if (status !== 0) process.exit(status);
232	}
233
234	async function buildExtensions() {
235	const startTime = Date.now();
236	const extensions = readdirSync(extensionsPath);
237	const workingDirectory = cwd();
238	let count = 0;
239
240	for await (const extensionName of extensions) {
241	const extensionDirectory = path.resolve(extensionsPath, extensionName);
242	const isDirectory = lstatSync(extensionDirectory).isDirectory();
243
244	if (!isDirectory \|\| extensionName === ".extbuilds") {
245	continue;
246	}
247
248	chdir(path.join(extensionsPath, extensionName));
249
250	if (!process.argv.includes("--tsc")) {
251	actionLog("DEPS", extensionName);
252	spawnSyncCatchExit("npm install -D", {
253	encoding: "utf-8",
254	shell: true,
255	stdio: "inherit"
256	});
257
258	actionLog("RELINK", extensionName);
259	spawnSyncCatchExit(`npm install --save ${path.relative(cwd(), path.resolve(__dirname, ".."))}`, {
260	encoding: "utf-8",
261	shell: true,
262	stdio: "inherit"
263	});
264	}
265
266	actionLog("BUILD", extensionName);
267	const { build_command } = readMeta(extensionName, extensionDirectory);
268
269	if (!build_command) {
270	console.log(chalk.cyan.bold("INFO "), "This extension doesn't require building.");
271	continue;
272	}
273
274	spawnSyncCatchExit(build_command, {
275	encoding: "utf-8",
276	shell: true,
277	stdio: "inherit"
278	});
279
280	count++;
281	}
282
283	actionLog("SUCCESS", `in ${((Date.now() - startTime) / 1000).toFixed(2)}s, built ${count} extensions`);
284	chdir(workingDirectory);
285	}
286
287	async function writeExtensionIndex() {
288	const extensionsPath = path.resolve(__dirname, "../extensions");
289	const extensionsOutputRecord = {};
290	const extensions = readdirSync(extensionsPath);
291
292	for await (const extensionName of extensions) {
293	const extensionDirectory = path.resolve(extensionsPath, extensionName);
294	const isDirectory = lstatSync(extensionDirectory).isDirectory();
295
296	if (!isDirectory \|\| extensionName === ".extbuilds") {
297	continue;
298	}
299
300	console.log("Found extension: ", extensionName);
301
302	const packageJsonPath = path.join(extensionDirectory, "package.json");
303	const packageJson = JSON.parse(await readFile(packageJsonPath, { encoding: "utf-8" }));
304
305	const {
306	main_directory = "./build",
307	commands = `./${main_directory}/commands`,
308	events = `./${main_directory}/events`,
309	build_command = null,
310	name = packageJson.name ?? extensionName,
311	description = packageJson.description,
312	language = "javascript",
313	main = `./${main_directory}/index.js`,
314	services = `./${main_directory}/services`,
315	id,
316	icon,
317	readmeFileName
318	} = readMeta(extensionName, extensionDirectory) ?? {};
319
320	const commandPaths = getRecuriveJavaScriptFiles(path.join(extensionDirectory, commands));
321	const eventPaths = getRecuriveJavaScriptFiles(path.join(extensionDirectory, events));
322	const servicePaths = getRecuriveJavaScriptFiles(path.join(extensionDirectory, services));
323
324	const tarballs = readdirSync(path.resolve(extensionsPath, ".extbuilds", extensionName));
325
326	tarballs.sort((a, b) => {
327	const vA = path
328	.basename(a)
329	.replace(`${extensionName}-`, "")
330	.replace(/\.tar\.gz$/gi, "");
331	const vB = path
332	.basename(b)
333	.replace(`${extensionName}-`, "")
334	.replace(/\.tar\.gz$/gi, "");
335	const splitA = vA.split("-");
336	const splitB = vB.split("-");
337	const dashVA = splitA[1];
338	const dashVB = splitB[1];
339	const revA = isNaN(dashVA) ? 0 : parseInt(dashVA);
340	const revB = isNaN(dashVB) ? 0 : parseInt(dashVB);
341	const result = semver.rcompare(vA, vB);
342
343	if (splitA[0] === splitB[0] && vA.includes("-") && !isNaN(dashVA) && (!vB.includes("-") \|\| isNaN(dashVB))) {
344	return -1;
345	}
346
347	if (splitA[0] === splitB[0] && vB.includes("-") && !isNaN(dashVB) && (!vA.includes("-") \|\| isNaN(dashVA))) {
348	return 1;
349	}
350
351	return result === 0 ? revB - revA : result;
352	});
353
354	const tarballList = tarballs.map(file => {
355	const basename = path.basename(file);
356	const filePath = path.join(extensionsPath, ".extbuilds", extensionName, basename);
357	const { stdout } = spawnSync(`sha512sum`, [filePath], {
358	encoding: "utf-8"
359	});
360	const { size, birthtime } = lstatSync(filePath);
361	const checksum = stdout.split(" ")[0];
362
363	return {
364	url:
365	"https://raw.githubusercontent.com/onesoft-sudo/sudobot/main/extensions" +
366	path.join("/.extbuilds/", extensionName, basename),
367	basename,
368	version: basename.replace(`${extensionName}-`, "").replace(/\.tar\.gz$/gi, ""),
369	checksum,
370	size,
371	createdAt: birthtime
372	};
373	});
374
375	extensionsOutputRecord[id] = {
376	name,
377	id,
378	shortName: packageJson.name ?? extensionName,
379	description,
380	version: packageJson.version,
381	commands: commandPaths.length,
382	events: eventPaths.length,
383	buildCommand: build_command,
384	language,
385	services: servicePaths.length,
386	main,
387	iconURL: icon
388	? "https://raw.githubusercontent.com/onesoft-sudo/sudobot/main/extensions" + path.join("/", extensionName, icon)
389	: null,
390	author:
391	typeof packageJson.author === "string"
392	? {
393	name: packageJson.author
394	}
395	: packageJson.author,
396	license: packageJson.license,
397	licenseURL: `https://spdx.org/licenses/${packageJson.license}.html`,
398	homepage: packageJson.homepage,
399	repository: typeof packageJson.repository === "string" ? packageJson.repository : packageJson.repository?.url,
400	issues: typeof packageJson.bugs === "string" ? packageJson.bugs : packageJson.bugs?.url,
401	lastUpdated: new Date(),
402	readmeFileName: readmeFileName,
403	readmeFileURL: `https://raw.githubusercontent.com/onesoft-sudo/sudobot/main/extensions/${extensionName}/${readmeFileName}`,
404	tarballs: tarballList
405	};
406	}
407
408	console.log("Overview of the extensions: ");
409	console.table(
410	Object.values(extensionsOutputRecord).map(e => ({
411	name: e.name,
412	commands: e.commands.length,
413	events: e.events.length
414	}))
415	);
416
417	const indexFile = path.join(extensionsPath, ".extbuilds/index.json");
418
419	writeFileSync(indexFile, JSON.stringify(extensionsOutputRecord, null, 4));
420
421	console.log("Wrote index file: ", indexFile);
422	}
423
424	if (process.argv.includes("--clear-cache") \|\| process.argv.includes("--clean") \|\| process.argv.includes("--delcache")) {
425	const indexFile = path.join(extensionsPath, "index.json");
426
427	if (!existsSync(indexFile)) {
428	error("No cached index file found!");
429	}
430
431	rmSync(indexFile);
432	console.log("Removed cached index file: ", indexFile);
433	} else if (process.argv.includes("--cache") \|\| process.argv.includes("--index")) {
434	console.time("Finished in");
435	console.log("Creating cache index for all the installed extensions");
436	writeCacheIndex()
437	.then(() => console.timeEnd("Finished in"))
438	.catch(e => {
439	console.log(e);
440	console.timeEnd("Finished in");
441	});
442	} else if (process.argv.includes("--build")) {
443	console.log("Building installed extensions");
444	buildExtensions().catch(e => {
445	console.log(e);
446	process.exit(-1);
447	});
448	} else if (process.argv.includes("--mkindex")) {
449	console.log("Creating index for all the available extensions in the extensions/ directory");
450
451	writeExtensionIndex().catch(e => {
452	console.log(e);
453	process.exit(-1);
454	});
455	} else {
456	console.log("Usage:");
457	console.log(" node extensions.js <options>\n");
458	console.log("Options:");
459	console.log(" --build [--tsc] \| Builds all the installed extensions, if needed.");
460	console.log(" \| The `--tsc` flag will only run the typescript compiler.");
461	console.log(" --cache \| Creates cache indexes for installed extensions, to improve the startup time.");
462	console.log(" --clean \| Clears all installed extension cache.");
463	console.log(
464	" --mkindex \| Creates indexes for all the available extensions, in the extensions/ top level directory."
465	);
466	process.exit(-1);
467	}