schat2-clive/src/schat.js

'use strict';

const config = require('config');
const { setTimeout: delay } = require('timers/promises');
const bhttp = require('bhttp');
const WebSocket = require('ws');
const logger = require('simple-node-logger').createSimpleLogger();
const { argv } = require('yargs');

const {
	onMessage,
	getGames,
} = require('./play');

const instance = process.env.NODE_APP_INSTANCE || 'main';

logger.setLevel(argv.level || 'info');

async function auth() {
	const username = config.uniqueUsername ? `${config.user.username}-${new Date().getTime().toString().slice(-5)}` : config.user.username;

	const res = await bhttp.post(`${config.api}/session`, {
		...config.user,
		username,
	}, {
		encodeJSON: true,
	});

	if (res.statusCode !== 200) {
		throw new Error(`Failed to authenticate: ${res.body.toString()}`);
	}

	logger.info(`Authenticated as '${username}' with ${config.api}`);

	return {
		user: res.body,
		// auth may return an explicit auth cookie domain, but we connect through the VPN domain that would break the cookie, so don't use a bhttp session and strip the domain
		sessionCookie: res.headers['set-cookie'][0].replace(/Domain=.*;/, ''),
	};
}

async function getWsId(sessionCookie) {
	const res = await bhttp.get(`${config.api}/socket`, {
		headers: {
			cookie: sessionCookie,
		},
	});

	if (res.statusCode !== 200) {
		throw new Error(`Failed to retrieve WebSocket ID: ${res.body.toString()}`);
	}

	return res.body;
}

function onConnect(data, bot) {
	bot.socket.transmit('joinRooms', { rooms: config.channels });
}

async function onRooms({ rooms }, bot) {
	logger.info(`Joined ${rooms.map((room) => room.name).join(', ')}`);

	const usersRes = await bhttp.get(`${config.api}/room/${rooms.map((room) => room.id).join(',')}/users`);
	const users = usersRes.body;

	const userIdsByRoom = Object.values(users).reduce((acc, user) => {
		user.sharedRooms.forEach((roomId) => {
			if (!acc[roomId]) {
				acc[roomId] = [];
			}

			acc[roomId].push(user.id);
		});

		return acc;
	}, {});

	/* eslint-disable no-param-reassign */
	bot.rooms = rooms.reduce((acc, room) => ({
		...acc,
		[room.id]: {
			...room,
			userIds: userIdsByRoom[room.id],
		},
	}), {});

	bot.users = { ...bot.users, ...users };
	/* eslint-enable no-param-reassign */

	rooms.forEach((room) => {
		bot.socket.transmit('message', {
			roomId: room.id,
			body: `Hi, I am ${config.user.username}, your game host!`,
			style: config.style,
		});
	});
}

/* eslint-disable no-param-reassign */
function onJoin(data, bot) {
	if (bot.rooms[data.roomId] && !bot.rooms[data.roomId].userIds?.includes(data.user.id)) {
		bot.users[data.user.id] = data.user;
		bot.rooms[data.roomId].userIds.push(data.user.id);
	}
}

function onLeave(data, bot) {
	if (bot.rooms[data.roomId]) {
		bot.rooms[data.roomId].userIds = bot.rooms[data.roomId].userIds.filter((userId) => userId !== data.userId);
	}
}

const messageHandlers = {
	connect: onConnect,
	rooms: onRooms,
	message: onMessage,
	join: onJoin,
	leave: onLeave,
};

function handleError(error, socket, domain, data) {
	logger.error(`${domain} '${JSON.stringify(data)}' triggered error: ${error.message} ${error.stack}`);

	if (data?.roomId) {
		socket.transmit('message', {
			body: ':zap::robot::zap: Many fragments! Some large, some small.',
			type: 'message',
			roomId: data.roomId,
		});
	}
}

const pongRegex = /^pong:\d+$/;

async function connect(bot, games) {
	const socket = {
		ws: { readyState: 0 },
		io: {},
	};

	socket.connect = async () => {
		try {
			const { user, sessionCookie } = await auth();
			const wsCreds = await getWsId(sessionCookie);

			bot.user = user;

			logger.info(`Attempting to connect to ${config.socket}`);

			socket.ws = new WebSocket(`${config.socket}?${new URLSearchParams({ v: wsCreds.wsId, t: wsCreds.timestamp }).toString()}`, [], {
				headers: {
					cookie: sessionCookie,
				},
			});

			socket.ws.on('message', async (msgData) => {
				const msg = msgData.toString();

				if (typeof msg === 'string' && pongRegex.test(msg)) {
					logger.debug(`Received pong ${msg.split(':')[1]}`);
					return;
				}

				const [domain, data] = JSON.parse(msg);

				logger.debug(`Received ${domain}: ${JSON.stringify(data)}`);

				if (messageHandlers[domain]) {
					try {
						await messageHandlers[domain](data, bot, games);
					} catch (error) {
						handleError(error, socket, domain, data);
					}
				}
			});

			socket.ws.on('close', async (info) => {
				logger.error(`WebSocket closed, reconnecting in ${config.reconnectDelay} seconds: ${info}`);

				await delay(config.reconnectDelay * 1000);
				socket.connect();
			});

			socket.ws.on('error', async (error) => {
				logger.error(`WebSocket error: ${error.message}`);
			});

			logger.info(`Connected to ${config.socket}`);
		} catch (error) {
			logger.error(`Failed to connect, retrying in ${config.reconnectDelay} seconds: ${error.message}`);

			await delay(config.reconnectDelay * 1000);
			socket.connect();
		}
	};

	socket.transmit = (domain, data) => {
		socket.ws.send(JSON.stringify([domain, data]));
	};

	function ping() {
		setTimeout(() => {
			if (socket.ws && socket.ws?.readyState === socket.ws?.OPEN) {
				const now = Date.now();

				socket.ws.send(`ping:${now}`);
				logger.debug(`Sent ping ${now}`);
			}

			ping();
		}, 10000);
	}

	ping();

	socket.connect();

	return socket;
}

async function init() {
	const bot = {
		rooms: [],
		users: [],
	};

	const games = await getGames(bot, instance);

	bot.socket = await connect(bot, games);
}

module.exports = init;