7.x/src/index.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 "module-alias/register";
import "reflect-metadata";

import axios from "axios";
import { spawn } from "child_process";
import { GatewayIntentBits, Partials } from "discord.js";
import "dotenv/config";
import { existsSync, readFileSync } from "fs";
import { createInterface } from "node:readline/promises";
import path from "path";
import Client from "./core/Client";
import { logError, logInfo, logSuccess } from "./utils/logger";
import { sudoPrefix } from "./utils/utils";

global.bootDate = Date.now();

if (!Symbol.metadata) {
    (Symbol as unknown as Record<string, symbol>).metadata ??= Symbol("metadata");
}

const intents = [
    GatewayIntentBits.Guilds,
    GatewayIntentBits.MessageContent,
    GatewayIntentBits.GuildMessages,
    GatewayIntentBits.GuildMembers,
    GatewayIntentBits.GuildMessageReactions,
    GatewayIntentBits.GuildModeration,
    GatewayIntentBits.GuildEmojisAndStickers,
    GatewayIntentBits.GuildPresences,
    GatewayIntentBits.GuildInvites
];

const partials = [Partials.Channel];

function spawnNativeProcess() {
    const path = process.env.EXPERIMENTAL_NATIVE_EXECUTABLE_PATH;

    if (path) {
        const child = spawn(path, {
            stdio: "inherit",
            env: process.env
        });

        process.on("exit", () => void (child.killed ? null : child.kill()));
        process.on("uncaughtException", () => void (child.killed ? null : child.kill()));
        process.on("unhandledRejection", () => void (child.killed ? null : child.kill()));
    }
}

async function fetchCredentials() {
    if (!process.env.CREDENTIAL_SERVER) {
        return;
    }

    const restartJsonFile = path.join(sudoPrefix("tmp", true), "restart.json");
    let restartKey = null;

    if (existsSync(restartJsonFile)) {
        logInfo("Found restart.json file: ", restartJsonFile);

        try {
            const { key } = JSON.parse(readFileSync(restartJsonFile, { encoding: "utf-8" }));
            restartKey = key;
        } catch (error) {
            logError(error);
        }
    }

    const index = process.argv.indexOf("--key");
    let key = restartKey ?? (index !== -1 ? process.argv[index + 1] : null);

    if (!key) {
        const readline = createInterface(process.stdin, process.stdout);
        key = await readline.question("Enter key to authenticate with the credentials server: ");
        readline.close();
    } else if (restartKey) {
        logInfo("Accepted key during last restart command");
    } else {
        logInfo("Accepted key from command-line arguments");
    }

    logInfo("Authenticating with the server...");

    try {
        const response = await axios.get(process.env.CREDENTIAL_SERVER, {
            headers: {
                Authorization: `Bearer ${key}`
            }
        });

        if (response.data?.success && response.data?.config && typeof response.data?.config === "object") {
            logSuccess("Successfully authenticated with the credentials server");

            for (const key in response.data.config) {
                process.env[key] = response.data.config[key];
            }
        } else {
            throw new Error("Invalid response received");
        }
    } catch (error) {
        logError(error);
        process.exit(-1);
    }
}

const promise = (async () => {
    await fetchCredentials();
    const client = new Client({
        intents,
        partials
    });

    spawnNativeProcess();

    await client.boot();

    if (process.env.SERVER_ONLY_MODE) {
        await client.server.boot();
        await client.server.start();
    } else {
        await client.login(process.env.TOKEN);
    }
})();

export default promise;
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			import "module-alias/register";
20			import "reflect-metadata";
21
22			import axios from "axios";
23			import { spawn } from "child_process";
24			import { GatewayIntentBits, Partials } from "discord.js";
25			import "dotenv/config";
26			import { existsSync, readFileSync } from "fs";
27			import { createInterface } from "node:readline/promises";
28			import path from "path";
29			import Client from "./core/Client";
30			import { logError, logInfo, logSuccess } from "./utils/logger";
31			import { sudoPrefix } from "./utils/utils";
32
33			global.bootDate = Date.now();
34
35			if (!Symbol.metadata) {
36			(Symbol as unknown as Record<string, symbol>).metadata ??= Symbol("metadata");
37			}
38
39			const intents = [
40			GatewayIntentBits.Guilds,
41			GatewayIntentBits.MessageContent,
42			GatewayIntentBits.GuildMessages,
43			GatewayIntentBits.GuildMembers,
44			GatewayIntentBits.GuildMessageReactions,
45			GatewayIntentBits.GuildModeration,
46			GatewayIntentBits.GuildEmojisAndStickers,
47			GatewayIntentBits.GuildPresences,
48			GatewayIntentBits.GuildInvites
49			];
50
51			const partials = [Partials.Channel];
52
53			function spawnNativeProcess() {
54			const path = process.env.EXPERIMENTAL_NATIVE_EXECUTABLE_PATH;
55
56			if (path) {
57			const child = spawn(path, {
58			stdio: "inherit",
59			env: process.env
60			});
61
62			process.on("exit", () => void (child.killed ? null : child.kill()));
63			process.on("uncaughtException", () => void (child.killed ? null : child.kill()));
64			process.on("unhandledRejection", () => void (child.killed ? null : child.kill()));
65			}
66			}
67
68			async function fetchCredentials() {
69			if (!process.env.CREDENTIAL_SERVER) {
70			return;
71			}
72
73			const restartJsonFile = path.join(sudoPrefix("tmp", true), "restart.json");
74			let restartKey = null;
75
76			if (existsSync(restartJsonFile)) {
77			logInfo("Found restart.json file: ", restartJsonFile);
78
79			try {
80			const { key } = JSON.parse(readFileSync(restartJsonFile, { encoding: "utf-8" }));
81			restartKey = key;
82			} catch (error) {
83			logError(error);
84			}
85			}
86
87			const index = process.argv.indexOf("--key");
88			let key = restartKey ?? (index !== -1 ? process.argv[index + 1] : null);
89
90			if (!key) {
91			const readline = createInterface(process.stdin, process.stdout);
92			key = await readline.question("Enter key to authenticate with the credentials server: ");
93			readline.close();
94			} else if (restartKey) {
95			logInfo("Accepted key during last restart command");
96			} else {
97			logInfo("Accepted key from command-line arguments");
98			}
99
100			logInfo("Authenticating with the server...");
101
102			try {
103			const response = await axios.get(process.env.CREDENTIAL_SERVER, {
104			headers: {
105			Authorization: `Bearer ${key}`
106			}
107			});
108
109			if (response.data?.success && response.data?.config && typeof response.data?.config === "object") {
110			logSuccess("Successfully authenticated with the credentials server");
111
112			for (const key in response.data.config) {
113			process.env[key] = response.data.config[key];
114			}
115			} else {
116			throw new Error("Invalid response received");
117			}
118			} catch (error) {
119			logError(error);
120			process.exit(-1);
121			}
122			}
123
124			const promise = (async () => {
125			await fetchCredentials();
126			const client = new Client({
127			intents,
128			partials
129			});
130
131			spawnNativeProcess();
132
133			await client.boot();
134
135			if (process.env.SERVER_ONLY_MODE) {
136			await client.server.boot();
137			await client.server.start();
138			} else {
139			await client.login(process.env.TOKEN);
140			}
141			})();
142
143			export default promise;