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