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