8.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,
    GatewayIntentBits.GuildVoiceStates
];

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 the one-time 2FA code: ");
        readline.close();
    } else if (restartKey) {
        logInfo("Accepted 2FA code during last restart command");
    } else {
        logInfo("Accepted 2FA code from command-line arguments");
    }

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

    const is2FACode = key.length === 6 && !isNaN(Number(key));

    try {
        const response = await axios.get(process.env.CREDENTIAL_SERVER, {
            headers: {
                Authorization: is2FACode ? undefined : `Bearer ${key}`,
                "X-2FA-code": is2FACode ? key : undefined
            }
        });

        if (
            response.data?.success &&
            response.data?.config &&
            typeof response.data?.config === "object"
        ) {
            logSuccess(
                "Successfully authenticated with the credentials server (Method: " +
                    (is2FACode ? "2FA" : "Key") +
                    ")"
            );

            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			GatewayIntentBits.GuildVoiceStates
50			];
51
52			const partials = [Partials.Channel];
53
54			function spawnNativeProcess() {
55			const path = process.env.EXPERIMENTAL_NATIVE_EXECUTABLE_PATH;
56
57			if (path) {
58			const child = spawn(path, {
59			stdio: "inherit",
60			env: process.env
61			});
62
63			process.on("exit", () => void (child.killed ? null : child.kill()));
64			process.on("uncaughtException", () => void (child.killed ? null : child.kill()));
65			process.on("unhandledRejection", () => void (child.killed ? null : child.kill()));
66			}
67			}
68
69			async function fetchCredentials() {
70			if (!process.env.CREDENTIAL_SERVER) {
71			return;
72			}
73
74			const restartJsonFile = path.join(sudoPrefix("tmp", true), "restart.json");
75			let restartKey = null;
76
77			if (existsSync(restartJsonFile)) {
78			logInfo("Found restart.json file: ", restartJsonFile);
79
80			try {
81			const { key } = JSON.parse(readFileSync(restartJsonFile, { encoding: "utf-8" }));
82			restartKey = key;
83			} catch (error) {
84			logError(error);
85			}
86			}
87
88			const index = process.argv.indexOf("--key");
89			let key = restartKey ?? (index !== -1 ? process.argv[index + 1] : null);
90
91			if (!key) {
92			const readline = createInterface(process.stdin, process.stdout);
93			key = await readline.question("Enter the one-time 2FA code: ");
94			readline.close();
95			} else if (restartKey) {
96			logInfo("Accepted 2FA code during last restart command");
97			} else {
98			logInfo("Accepted 2FA code from command-line arguments");
99			}
100
101			logInfo("Authenticating with the server...");
102
103			const is2FACode = key.length === 6 && !isNaN(Number(key));
104
105			try {
106			const response = await axios.get(process.env.CREDENTIAL_SERVER, {
107			headers: {
108			Authorization: is2FACode ? undefined : `Bearer ${key}`,
109			"X-2FA-code": is2FACode ? key : undefined
110			}
111			});
112
113			if (
114			response.data?.success &&
115			response.data?.config &&
116			typeof response.data?.config === "object"
117			) {
118			logSuccess(
119			"Successfully authenticated with the credentials server (Method: " +
120			(is2FACode ? "2FA" : "Key") +
121			")"
122			);
123
124			for (const key in response.data.config) {
125			process.env[key] = response.data.config[key];
126			}
127			} else {
128			throw new Error("Invalid response received");
129			}
130			} catch (error) {
131			logError(error);
132			process.exit(-1);
133			}
134			}
135
136			const promise = (async () => {
137			await fetchCredentials();
138			const client = new Client({
139			intents,
140			partials
141			});
142
143			spawnNativeProcess();
144
145			await client.boot();
146
147			if (process.env.SERVER_ONLY_MODE) {
148			await client.server.boot();
149			await client.server.start();
150			} else {
151			await client.login(process.env.TOKEN);
152			}
153			})();
154
155			export default promise;