285 lines
9.4 KiB
JavaScript
285 lines
9.4 KiB
JavaScript
const { extend: createGotClient } = require('got');
|
|
const { ConnectionError, SayError, TimeoutError, UserBanError, ChatClient } = require('dank-twitch-irc');
|
|
const chalk = require('chalk');
|
|
const WS = require('ws');
|
|
const Config = require('./config.json');
|
|
|
|
const clients = [];
|
|
let listenClient = null;
|
|
const pingInterval = 120e3;
|
|
let lastIndex = 0;
|
|
const uuidRegex = /[0-9A-F]{8}-[0-9A-F]{4}-[4][0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}/i;
|
|
const msgRegex = /[\u034f\u2800\u{E0000}\u180e\ufeff\u2000-\u200d\u206D]/gu;
|
|
|
|
const pnslClient = createGotClient({
|
|
prefixUrl: 'https://bot.tetyys.com/api/v1',
|
|
throwHttpErrors: false,
|
|
headers: {
|
|
Authorization: `Bearer ${Config.PNSLToken}`
|
|
}
|
|
});
|
|
|
|
const urlClient = createGotClient();
|
|
|
|
const fetchList = async (list) => {
|
|
const listID = uuidRegex.exec(list)?.[0];
|
|
if (!listID) {
|
|
throw new Error('Invalid List ID!');
|
|
}
|
|
|
|
const { body: listMetaBody, statusCode } = await pnslClient('BotLists/Properties', { searchParams: { Guid: listID } });
|
|
if (statusCode === 404) {
|
|
throw new Error('List was not found.');
|
|
}
|
|
|
|
if (statusCode === 401) {
|
|
throw new Error('Authorization token is invalid');
|
|
}
|
|
|
|
if (statusCode !== 200) {
|
|
throw new Error('Unexpected error occurred!');
|
|
}
|
|
|
|
const { body: listData } = await pnslClient(`BotLists/${listID}`);
|
|
|
|
const listMeta = JSON.parse(listMetaBody);
|
|
return { listMeta, listData };
|
|
};
|
|
|
|
const fetchUrlList = async (list) => {
|
|
const { body: listMetaBody, statusCode } = await urlClient(list);
|
|
if (statusCode === 404) {
|
|
throw new Error('List was not found.');
|
|
}
|
|
|
|
if (statusCode !== 200) {
|
|
throw new Error('Unexpected error occured!');
|
|
}
|
|
|
|
return listMetaBody;
|
|
};
|
|
|
|
const runList = async (listData, listID, channel, sourceChannel) => {
|
|
const banArr = listData.split('\n');
|
|
|
|
const targetChannel = Config.UseParallelUniverse === true ? channel : `#${channel}`;
|
|
|
|
if (banArr.length > Config.MaxChunkSize) {
|
|
const banChunks = [];
|
|
while (banArr.length > 0) {
|
|
banChunks.push(banArr.splice(0, Config.MaxChunkSize));
|
|
}
|
|
|
|
const chunkCount = banChunks.length;
|
|
|
|
for (const [i, chunk] of banChunks.entries()) {
|
|
const currentChunk = i + 1;
|
|
const promises = [];
|
|
|
|
for (const entry of chunk) {
|
|
let user = '';
|
|
let reason = '';
|
|
if (entry === '') {
|
|
continue;
|
|
}
|
|
[, user, ...reason] = entry.split(' ');
|
|
promises.push(getConnection().ban(targetChannel, user, reason.join(' ')));
|
|
}
|
|
|
|
await Promise.allSettled(promises);
|
|
|
|
say(sourceChannel, `${Config.UseParallelUniverse === true ? '[PU]' : ''} Chunk ${currentChunk}/${chunkCount} of ${listID} executed successfully on channel ${targetChannel}`);
|
|
if (Config.SendChunks) say(channel, `Chunk ${currentChunk}/${chunkCount} executed successfully`);
|
|
|
|
if (currentChunk === chunkCount) {
|
|
break;
|
|
}
|
|
|
|
await sleep(Config.DelayPerChunk);
|
|
}
|
|
} else {
|
|
const promises = [];
|
|
|
|
for (const entry of banArr) {
|
|
let user = '';
|
|
let reason = '';
|
|
if (entry === '') {
|
|
continue;
|
|
}
|
|
[, user, ...reason] = entry.split(' ');
|
|
promises.push(getConnection().ban(targetChannel, user, reason.join(' ')));
|
|
}
|
|
|
|
await Promise.allSettled(promises);
|
|
}
|
|
};
|
|
|
|
const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
|
|
|
|
const createTwitchClient = () => new ChatClient({
|
|
username: Config.Username,
|
|
password: Config.Password,
|
|
rateLimits: 'verifiedBot'
|
|
});
|
|
|
|
const getConnection = () => {
|
|
const readyClients = clients.filter((i) => i.ready);
|
|
return readyClients[++lastIndex % readyClients.length];
|
|
};
|
|
|
|
const say = (channel, message) => {
|
|
if (channel.startsWith('#')) {
|
|
listenClient.say(channel, message);
|
|
} else {
|
|
listenClient.say(`#${channel}`, message);
|
|
}
|
|
};
|
|
|
|
if (!Config.IgnorePNSL) {
|
|
const pnslWebSocket = new WS('wss://bot.tetyys.com/api/wss', [], { headers: { Authorization: `Bearer ${Config.PNSLToken}` } });
|
|
|
|
pnslWebSocket.on('open', () => {
|
|
console.log(`${chalk.green('[P&SL]')} || Connected to P&SL Websocket server`);
|
|
});
|
|
|
|
pnslWebSocket.on('message', async (data) => {
|
|
const { o: type, p: payload } = JSON.parse(data);
|
|
switch (type) {
|
|
case 0: {
|
|
const { listMeta } = await fetchList(payload.LatestBotList);
|
|
console.log(`${chalk.green('[P&SL]')} || Latest Botlist: ${payload.LatestBotList} [${listMeta.name}] (${listMeta.count})`);
|
|
break;
|
|
}
|
|
case 1: {
|
|
console.log(`${chalk.green('[P&SL]')} || New Botlist: ${payload.Guid} [${payload.Name}] (${payload.Count}) (${payload.Tags.join(' ')})`);
|
|
break;
|
|
}
|
|
case 2: {
|
|
console.log(`${chalk.green('[P&SL]')} || New False Positive: ${payload.UserTwitchId} [${payload.BotListGuid}]`);
|
|
break;
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
});
|
|
}
|
|
|
|
(async () => {
|
|
await Promise.all([...Array(Config.MaxConnections)].map(async (_, i) => {
|
|
clients[i] = createTwitchClient();
|
|
clients[i].connect();
|
|
clients[i].on('error', (error) => {
|
|
if (error instanceof SayError) {
|
|
return;
|
|
}
|
|
if (error instanceof UserBanError) {
|
|
return console.warn(`Failed to ban user ${error.username} from ${error.channelName}`);
|
|
}
|
|
if (error instanceof ConnectionError) {
|
|
if (clients[i].ready) {
|
|
return;
|
|
}
|
|
clients[i].connect();
|
|
return console.error(`Error in client ${i} -> ${error.name} || ${error.message}`);
|
|
}
|
|
if (error instanceof TimeoutError) {
|
|
clients[i].connect();
|
|
return console.error(`Timeout in client ${i} -> ${error.name} || ${error.message} | Trying to reconnect`);
|
|
}
|
|
console.error(error);
|
|
});
|
|
return await new Promise((resolve) => clients[i].on('ready', () => resolve()));
|
|
}));
|
|
|
|
listenClient = createTwitchClient();
|
|
listenClient.connect();
|
|
listenClient.on('ready', async () => {
|
|
if (Config.Channels.length !== 0) {
|
|
await listenClient.joinAll(Config.Channels);
|
|
}
|
|
|
|
console.log(`${chalk.green('[TWITCH]')} || Command listener connected`);
|
|
});
|
|
|
|
console.log(`${chalk.green('[TWITCH]')} || ${clients.filter((i) => i.ready).length} Clients connected`);
|
|
|
|
listenClient.on('PRIVMSG', async ({ messageText, senderUserID, channelName }) => {
|
|
if (!Config.Users.includes(senderUserID)) {
|
|
return;
|
|
}
|
|
|
|
const message = messageText.replace(msgRegex, '').trimEnd();
|
|
if (!message.startsWith(Config.Prefix)) {
|
|
return;
|
|
}
|
|
const content = message.split(/\s+/g);
|
|
const command = content[0].slice(Config.Prefix.length);
|
|
const args = content.slice(1);
|
|
|
|
if (command === 'ping') {
|
|
const channel = args[0];
|
|
return say(channel || channelName, `${clients.filter((i) => i.ready).length} Clients from total of ${clients.length} are operational`);
|
|
}
|
|
|
|
if (command === 'quit') {
|
|
process.exit(0);
|
|
}
|
|
|
|
if (command === 'runlist') {
|
|
const listID = args[0];
|
|
let channel = args[1];
|
|
|
|
if (!listID) {
|
|
return say(channelName, 'No list ID provided!');
|
|
}
|
|
if (!channel) {
|
|
channel = Config.DefaultChannel || channelName;
|
|
}
|
|
if (Config.Blacklisted.includes(channel)) {
|
|
return say(channelName, `I am not allowed to execute lists in channel ${channel}!`);
|
|
}
|
|
|
|
try {
|
|
if (channel != channelName) {
|
|
const mods = await listenClient.getMods(`#${channel}`);
|
|
if (!mods.includes(Config.Username)) {
|
|
return say(channelName, `I am not a moderator in channel ${channel}!`);
|
|
}
|
|
}
|
|
|
|
if (!Config.IgnorePNSL) {
|
|
const data = await fetchList(listID);
|
|
await runList(data.listData, listID, channel, channelName);
|
|
} else {
|
|
const data = await fetchUrlList(listID);
|
|
await runList(data, listID, channel, channelName);
|
|
}
|
|
say(channelName, `${Config.UseParallelUniverse === true ? '[PU]' : ''} List ${listID} executed successfully on channel ${channel || channelName}`);
|
|
if (Config.SendMeme) say(channel, 'FeelsGoodMan');
|
|
|
|
} catch (e) {
|
|
console.error(e);
|
|
return say(channelName, `Error Occurred! ${e.message}`);
|
|
}
|
|
}
|
|
});
|
|
|
|
setInterval(() => {
|
|
for (const client of clients) {
|
|
client.ping();
|
|
}
|
|
}, pingInterval);
|
|
})();
|
|
|
|
process
|
|
.on('unhandledRejection', (err) => {
|
|
if (err.name === 'SayError') {
|
|
return;
|
|
}
|
|
console.error(`${chalk.red('[UnhandledRejection]')} || [${err.name}] ${err} - ${err.stack}`);
|
|
})
|
|
.on('uncaughtException', (err) => {
|
|
console.error(`${chalk.red('[UncaughtException]')} || ${err.message}`);
|
|
process.exit(0);
|
|
});
|