src/services/LogServer.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 bcrypt from "bcrypt";
import chalk from "chalk";
import { Server, Socket } from "socket.io";
import Client from "../core/Client";
import Service from "../core/Service";
import { LogLevel, logInfo, logStringWithLevel, logWarn } from "../utils/logger";

export const name = "logServer";

export default class LogServer extends Service {
    public readonly MAX_CONNECTIONS = 5;
    protected connections = 0;
    private _io?: Server;
    public readonly sockets: Array<Socket> = [];
    public readonly attributes: Array<{ colorize?: boolean }> = [];

    constructor(client: Client) {
        super(client);

        if (!client.configManager.systemConfig.log_server?.auto_start) {
            return;
        }

        this.initialize();
    }

    get io() {
        return this._io;
    }

    initialize() {
        this._io = new Server();
        this.setupListeners();
    }

    start() {
        this.initialize();
        this.listen();
    }

    close() {
        this.io?.close();
        this._io = undefined;
    }

    isAuthorized(socket: Socket) {
        const { authorization } = socket.request.headers;
        const [type, password] = authorization?.split(/\s+/) ?? ["", ""];

        if (type !== "Bearer") {
            socket.send("[error] Only bearer tokens are supported!");
            socket.disconnect(true);
            return false;
        }

        if (!bcrypt.compareSync(password, process.env.LOG_SERVER_PASSWORD ?? Math.random().toString())) {
            socket.send("[error] Authentication failed");
            socket.disconnect(true);
            return false;
        }

        return true;
    }

    setupListeners() {
        this.io?.on("connection", socket => {
            if (this.connections >= this.MAX_CONNECTIONS) {
                socket.disconnect();
                return;
            }

            this.connections++;
            logInfo("New client connected to the log server", socket.id);

            socket.on("disconnect", reason => {
                this.connections--;
                logInfo("Client Disonnected from log server: ", socket.id, reason);
                const index = this.sockets.findIndex(s => s.id === socket.id);

                if (index !== -1) {
                    this.sockets.splice(index, 1);
                    this.attributes.splice(index, 1);
                }
            });

            if (!this.isAuthorized(socket)) {
                logWarn("Unauthorized client attempted to connect to the log server", socket.id);
                return;
            }

            const colorize = socket.request.headers["x-colorize"] === "Yes";

            socket.write(`${colorize ? chalk.cyan("[info]") : "[info]"} Connection Accepted`);

            this.sockets.push(socket);
            this.attributes.push({
                colorize
            });
        });
    }

    send(message: string) {
        for (const socket of this.sockets) {
            socket.send(message);
        }
    }

    log(level: LogLevel, message: string) {
        this.sockets.forEach((socket, index) => {
            const { colorize } = this.attributes[index] ?? {};

            if (colorize) {
                socket.send(logStringWithLevel(level, message));
            } else {
                socket.send(`[system:${LogLevel[level].toLowerCase()}] ${message}`);
            }
        });
    }

    listen() {
        let port = process.env.LOG_SERVER_PORT ? parseInt(process.env.LOG_SERVER_PORT) : 3500;
        port = isNaN(port) ? 3500 : port;

        this.io?.listen(port);
        logInfo("The log server is running at port", port);
    }
}
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
20	import bcrypt from "bcrypt";
21	import chalk from "chalk";
22	import { Server, Socket } from "socket.io";
23	import Client from "../core/Client";
24	import Service from "../core/Service";
25	import { LogLevel, logInfo, logStringWithLevel, logWarn } from "../utils/logger";
26
27	export const name = "logServer";
28
29	export default class LogServer extends Service {
30	public readonly MAX_CONNECTIONS = 5;
31	protected connections = 0;
32	private _io?: Server;
33	public readonly sockets: Array<Socket> = [];
34	public readonly attributes: Array<{ colorize?: boolean }> = [];
35
36	constructor(client: Client) {
37	super(client);
38
39	if (!client.configManager.systemConfig.log_server?.auto_start) {
40	return;
41	}
42
43	this.initialize();
44	}
45
46	get io() {
47	return this._io;
48	}
49
50	initialize() {
51	this._io = new Server();
52	this.setupListeners();
53	}
54
55	start() {
56	this.initialize();
57	this.listen();
58	}
59
60	close() {
61	this.io?.close();
62	this._io = undefined;
63	}
64
65	isAuthorized(socket: Socket) {
66	const { authorization } = socket.request.headers;
67	const [type, password] = authorization?.split(/\s+/) ?? ["", ""];
68
69	if (type !== "Bearer") {
70	socket.send("[error] Only bearer tokens are supported!");
71	socket.disconnect(true);
72	return false;
73	}
74
75	if (!bcrypt.compareSync(password, process.env.LOG_SERVER_PASSWORD ?? Math.random().toString())) {
76	socket.send("[error] Authentication failed");
77	socket.disconnect(true);
78	return false;
79	}
80
81	return true;
82	}
83
84	setupListeners() {
85	this.io?.on("connection", socket => {
86	if (this.connections >= this.MAX_CONNECTIONS) {
87	socket.disconnect();
88	return;
89	}
90
91	this.connections++;
92	logInfo("New client connected to the log server", socket.id);
93
94	socket.on("disconnect", reason => {
95	this.connections--;
96	logInfo("Client Disonnected from log server: ", socket.id, reason);
97	const index = this.sockets.findIndex(s => s.id === socket.id);
98
99	if (index !== -1) {
100	this.sockets.splice(index, 1);
101	this.attributes.splice(index, 1);
102	}
103	});
104
105	if (!this.isAuthorized(socket)) {
106	logWarn("Unauthorized client attempted to connect to the log server", socket.id);
107	return;
108	}
109
110	const colorize = socket.request.headers["x-colorize"] === "Yes";
111
112	socket.write(`${colorize ? chalk.cyan("[info]") : "[info]"} Connection Accepted`);
113
114	this.sockets.push(socket);
115	this.attributes.push({
116	colorize
117	});
118	});
119	}
120
121	send(message: string) {
122	for (const socket of this.sockets) {
123	socket.send(message);
124	}
125	}
126
127	log(level: LogLevel, message: string) {
128	this.sockets.forEach((socket, index) => {
129	const { colorize } = this.attributes[index] ?? {};
130
131	if (colorize) {
132	socket.send(logStringWithLevel(level, message));
133	} else {
134	socket.send(`[system:${LogLevel[level].toLowerCase()}] ${message}`);
135	}
136	});
137	}
138
139	listen() {
140	let port = process.env.LOG_SERVER_PORT ? parseInt(process.env.LOG_SERVER_PORT) : 3500;
141	port = isNaN(port) ? 3500 : port;
142
143	this.io?.listen(port);
144	logInfo("The log server is running at port", port);
145	}
146	}