├── client
    ├── parser
    │   ├── old-spigot
    │   │   ├── messages
    │   │   │   └── .gitkeep
    │   │   └── prefix
    │   │   │   ├── threadLoglevel.js
    │   │   │   ├── time.js
    │   │   │   └── index.js
    │   ├── default
    │   │   ├── text.js
    │   │   ├── username.js
    │   │   ├── prefix
    │   │   │   ├── time.js
    │   │   │   ├── threadLoglevel.js
    │   │   │   └── index.js
    │   │   └── messages
    │   │   │   ├── started.js
    │   │   │   ├── leave.js
    │   │   │   ├── entity.js
    │   │   │   ├── join.js
    │   │   │   ├── user.js
    │   │   │   ├── say.js
    │   │   │   ├── self.js
    │   │   │   ├── goal.js
    │   │   │   ├── data.js
    │   │   │   ├── advancement.js
    │   │   │   ├── challenge.js
    │   │   │   ├── players_online.js
    │   │   │   ├── vjoin.js
    │   │   │   ├── players_count.js
    │   │   │   └── death.js
    │   └── index.js
    ├── index.js
    ├── configure.js
    ├── run.js
    ├── dataparser
    │   └── index.js
    └── generator.js
├── .gitignore
├── images
    ├── minecraft.jpg
    └── telegram.png
├── .npmignore
├── bot
    ├── index.js
    ├── gameVersionCheck.js
    ├── utils.js
    ├── configure.js
    ├── auth.js
    └── run.js
├── botwrap
    ├── index.js
    ├── run.js
    └── configure.js
├── wrap
    ├── index.js
    ├── configure.js
    └── run.js
├── cli
    ├── save.js
    ├── load.js
    └── index.js
├── .github
    └── FUNDING.yml
├── package.json
└── README.md


/client/parser/old-spigot/messages/.gitkeep:
--------------------------------------------------------------------------------
1 | 


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | package-lock.json
3 | server
4 | 


--------------------------------------------------------------------------------
/client/parser/default/text.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | 
3 | module.exports = '(?<text>.*)$';
4 | 


--------------------------------------------------------------------------------
/images/minecraft.jpg:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/trgwii/TeMiCross/HEAD/images/minecraft.jpg


--------------------------------------------------------------------------------
/images/telegram.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/trgwii/TeMiCross/HEAD/images/telegram.png


--------------------------------------------------------------------------------
/.npmignore:
--------------------------------------------------------------------------------
1 | node_modules
2 | package-lock.json
3 | .github
4 | server
5 | images
6 | README.md
7 | 


--------------------------------------------------------------------------------
/client/parser/default/username.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | 
3 | module.exports = '[a-zA-Z0-9_]{1,16}';
4 | 


--------------------------------------------------------------------------------
/client/parser/old-spigot/prefix/threadLoglevel.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | 
3 | module.exports = '(?<loglevel>.*?)\\]: ';
4 | 


--------------------------------------------------------------------------------
/client/parser/default/prefix/time.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | 
3 | module.exports = '^\\[(?<time>\\d{2}:\\d{2}:\\d{2})] ';
4 | 


--------------------------------------------------------------------------------
/client/parser/old-spigot/prefix/time.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | 
3 | module.exports = '^\\[(?<time>\\d{2}:\\d{2}:\\d{2}) ';
4 | 


--------------------------------------------------------------------------------
/client/parser/default/prefix/threadLoglevel.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | 
3 | module.exports = '\\[(?<thread>.*?)/(?<loglevel>.*?)\\]: ';
4 | 


--------------------------------------------------------------------------------
/client/parser/default/messages/started.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | 
3 | module.exports = 'Done \\((?<ms>\\d+(\\.\\d+)?)s\\)! For help, type "help"';
4 | 


--------------------------------------------------------------------------------
/client/parser/default/messages/leave.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | 
3 | const username = require('../username');
4 | 
5 | module.exports = '(?<user>' + username + ') left the game$';
6 | 


--------------------------------------------------------------------------------
/client/parser/default/messages/entity.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | 
3 | module.exports =
4 | 	'Keeping entity (?<game>\\w+):(?<mob>\\w+) ' +
5 | 	'that already exists with UUID (?<uuid>.+)$';
6 | 


--------------------------------------------------------------------------------
/client/parser/default/messages/join.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | 
3 | const username = require('../username');
4 | 
5 | module.exports = 'UUID of player (?<user>' + username + ') is (?<uuid>.+)$';
6 | 


--------------------------------------------------------------------------------
/client/parser/default/prefix/index.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | 
3 | const time = require('./time');
4 | const threadLoglevel = require('./threadLoglevel');
5 | 
6 | module.exports = time + threadLoglevel;
7 | 


--------------------------------------------------------------------------------
/client/parser/default/messages/user.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | 
3 | const username = require('../username');
4 | const text = require('../text');
5 | 
6 | module.exports = '<(?<user>' + username + ')> ' + text;
7 | 


--------------------------------------------------------------------------------
/client/parser/old-spigot/prefix/index.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | 
3 | const time = require('./time');
4 | const threadLoglevel = require('./threadLoglevel');
5 | 
6 | module.exports = time + threadLoglevel;
7 | 


--------------------------------------------------------------------------------
/bot/index.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const configure = require('./configure');
 4 | const run = require('./run');
 5 | 
 6 | module.exports = {
 7 | 	configure,
 8 | 	file: 'botconfig',
 9 | 	run
10 | };
11 | 


--------------------------------------------------------------------------------
/client/parser/default/messages/say.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | 
3 | const username = require('../username');
4 | const text = require('../text');
5 | 
6 | module.exports = '\\[(?<user>' + username + ')\\] ' + text;
7 | 


--------------------------------------------------------------------------------
/client/parser/default/messages/self.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | 
3 | const username = require('../username');
4 | const text = require('../text');
5 | 
6 | module.exports = '\\* (?<user>' + username + ') ' + text;
7 | 


--------------------------------------------------------------------------------
/botwrap/index.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const configure = require('./configure');
 4 | const run = require('./run');
 5 | 
 6 | module.exports = {
 7 | 	configure,
 8 | 	file: 'botwrapper',
 9 | 	run
10 | };
11 | 


--------------------------------------------------------------------------------
/client/index.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const configure = require('./configure');
 4 | const run = require('./run');
 5 | 
 6 | module.exports = {
 7 | 	configure,
 8 | 	file: 'clientsettings',
 9 | 	run
10 | };
11 | 


--------------------------------------------------------------------------------
/client/parser/default/messages/goal.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | 
3 | const username = require('../username');
4 | 
5 | module.exports =
6 | 	'(?<user>' +
7 | 		username +
8 | 	') has reached the goal \\[(?<goal>.+)\\]$';
9 | 


--------------------------------------------------------------------------------
/wrap/index.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const configure = require('./configure');
 4 | 
 5 | const run = require('./run');
 6 | 
 7 | module.exports = {
 8 | 	configure,
 9 | 	file: 'wrapper',
10 | 	run
11 | };
12 | 


--------------------------------------------------------------------------------
/client/parser/default/messages/data.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | 
3 | const username = require('../username');
4 | 
5 | module.exports = '(?<user>' +
6 | 	username +
7 | 	'|.+?) has the following entity data: (?<data>.+)$';
8 | 


--------------------------------------------------------------------------------
/client/parser/default/messages/advancement.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | 
3 | const username = require('../username');
4 | 
5 | module.exports =
6 | 	'(?<user>' +
7 | 		username +
8 | 	') has made the advancement \\[(?<advancement>.+)\\]$';
9 | 


--------------------------------------------------------------------------------
/client/parser/default/messages/challenge.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | 
3 | const username = require('../username');
4 | 
5 | module.exports =
6 | 	'(?<user>' +
7 | 		username +
8 | 	') has completed the challenge \\[(?<challenge>.+)\\]$';
9 | 


--------------------------------------------------------------------------------
/client/parser/default/messages/players_online.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const username = require('../username');
 4 | 
 5 | module.exports =
 6 | 	'(?<players>(' +
 7 | 		username +
 8 | 	')?(\\s*,\\s*(' +
 9 | 		username +
10 | 	'))*)$';
11 | 


--------------------------------------------------------------------------------
/client/parser/default/messages/vjoin.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const username = require('../username');
 4 | 
 5 | module.exports = '(?<user>' +
 6 | 	username +
 7 | 	') (\\(formerly known as ' +
 8 | 	username +
 9 | 	'\\) )?joined the game$';
10 | 


--------------------------------------------------------------------------------
/cli/save.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const { writeFileSync } = require('fs');
 4 | 
 5 | const save = (name, data) => {
 6 | 	writeFileSync(`${name}.json`, JSON.stringify(data, null, '\t'));
 7 | 	return data;
 8 | };
 9 | 
10 | module.exports = save;
11 | 


--------------------------------------------------------------------------------
/client/parser/default/messages/players_count.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 | 
3 | const players = require('./players_online');
4 | 
5 | module.exports =
6 | 	'There are (?<current>\\d+) (out )?of (a )?max(imum)? (of )?(?<max>\\d+) players online(:|.) ' +
7 | 	players;
8 | 


--------------------------------------------------------------------------------
/botwrap/run.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const runWrapper = require('../wrap/run');
 4 | const runBot = require('../bot/run');
 5 | 
 6 | const run = opts => {
 7 | 	const { stdin, stdout } = runWrapper(opts);
 8 | 	const bot = runBot({ ...opts, stdin, stdout });
 9 | 	return bot;
10 | };
11 | 
12 | module.exports = run;
13 | 


--------------------------------------------------------------------------------
/cli/load.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const r = require;
 4 | 
 5 | const { resolve } = require('path');
 6 | 
 7 | const load = name => {
 8 | 	try {
 9 | 		return r(resolve(`${name}.json`));
10 | 	} catch (err) {
11 | 		if (err.code === 'MODULE_NOT_FOUND') {
12 | 			return null;
13 | 		}
14 | 		throw err;
15 | 	}
16 | };
17 | 
18 | module.exports = load;
19 | 


--------------------------------------------------------------------------------
/botwrap/configure.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const wrapConfig = require('../wrap/configure');
 4 | const botConfig = require('../bot/configure');
 5 | 
 6 | const removeNetwork = x => ![ 'port', 'ip' ].includes(x.name);
 7 | 
 8 | const configure = [
 9 | 	...wrapConfig.filter(removeNetwork),
10 | 	...botConfig.filter(removeNetwork)
11 | ];
12 | 
13 | module.exports = configure;
14 | 


--------------------------------------------------------------------------------
/client/configure.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const { isIP } = require('net');
 4 | 
 5 | const configure = [
 6 | 	{
 7 | 		type: 'input',
 8 | 		name: 'port',
 9 | 		message:
10 | 			'Which port do you want the client to connect to?',
11 | 		default: 12345,
12 | 		validate: x =>
13 | 			Number.isInteger(Number(x)),
14 | 		filter: x => Number(String(x).trim())
15 | 	},
16 | 	{
17 | 		type: 'input',
18 | 		name: 'ip',
19 | 		message:
20 | 			'Which interface / IP do you want the client to connect to?',
21 | 		default: '127.0.0.1',
22 | 		validate: x =>
23 | 			isIP(x) > 0,
24 | 		filter: x => x.trim()
25 | 	}
26 | ];
27 | 
28 | module.exports = configure;
29 | 


--------------------------------------------------------------------------------
/.github/FUNDING.yml:
--------------------------------------------------------------------------------
 1 | # These are supported funding model platforms
 2 | 
 3 | github: trgwii
 4 | patreon: # Replace with a single Patreon username
 5 | open_collective: # Replace with a single Open Collective username
 6 | ko_fi: # Replace with a single Ko-fi username
 7 | tidelift: # Replace with a single Tidelift platform-name/package-name e.g., npm/babel
 8 | community_bridge: # Replace with a single Community Bridge project-name e.g., cloud-foundry
 9 | liberapay: # Replace with a single Liberapay username
10 | issuehunt: # Replace with a single IssueHunt username
11 | otechie: # Replace with a single Otechie username
12 | custom: # Replace with up to 4 custom sponsorship URLs e.g., ['link1', 'link2']
13 | 


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "temicross",
 3 |   "version": "2.3.6",
 4 |   "description": "Telegram - Minecraft chat bridge",
 5 |   "main": "index.js",
 6 |   "bin": {
 7 |     "temicross": "./cli/index.js",
 8 |     "tmc": "./cli/index.js"
 9 |   },
10 |   "scripts": {
11 |     "test": "echo \"Error: no test specified\" && exit 1"
12 |   },
13 |   "keywords": [
14 |     "Telegram",
15 |     "Minecraft",
16 |     "Chat",
17 |     "Bridge"
18 |   ],
19 |   "author": "Thomas Rory Gummerson <thomas@gummerson.no> (https://trgwii.no)",
20 |   "license": "Beerware",
21 |   "dependencies": {
22 |     "axios": "^0.19.2",
23 |     "bracket-split": "^1.1.5",
24 |     "iconv-lite": "^0.5.1",
25 |     "inquirer": "^7.0.4",
26 |     "ramda": "^0.26.1",
27 |     "telegraf": "^3.36.0"
28 |   }
29 | }
30 | 


--------------------------------------------------------------------------------
/bot/gameVersionCheck.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const { EventEmitter } = require('events');
 4 | const axios = require('axios');
 5 | 
 6 | const getVersion = (type = 'release') =>
 7 | 	axios('https://launchermeta.mojang.com/mc/game/version_manifest.json')
 8 | 		.then(x => x.data.latest[type]);
 9 | 
10 | const emitUpdates = (type = 'release', init = false) => {
11 | 	const e = new EventEmitter();
12 | 	let version = '';
13 | 	let stop = false;
14 | 	const check = v => {
15 | 		if ((version !== '' || init) && version !== v) {
16 | 			e.emit('update', v);
17 | 		}
18 | 		version = v;
19 | 		if (!stop) {
20 | 			setTimeout(() => getVersion(type).then(check), 10000);
21 | 		}
22 | 	};
23 | 	getVersion(type).then(check);
24 | 	e.stop = () => {
25 | 		stop = true;
26 | 	};
27 | 	return e;
28 | };
29 | 
30 | module.exports = emitUpdates;
31 | 


--------------------------------------------------------------------------------
/bot/utils.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const fs = require('fs');
 4 | 
 5 | const {
 6 | 	__,
 7 | 	compose,
 8 | 	concat,
 9 | 	flip,
10 | 	join,
11 | 	prop,
12 | 	props,
13 | 	replace,
14 | 	tap
15 | } = require('ramda');
16 | 
17 | const load = compose(
18 | 	JSON.parse,
19 | 	flip(fs.readFileSync)('utf8'));
20 | 
21 | const escape = compose(
22 | 	replace(/>/g, '&gt;'),
23 | 	replace(/</g, '&lt;'),
24 | 	replace(/&/g, '&amp;'),
25 | 	String);
26 | 
27 | const code = compose(
28 | 	concat(__, '</code>'),
29 | 	concat('<code>'),
30 | 	escape);
31 | 
32 | const name = prop('first_name');
33 | 
34 | const log = tap(console.log);
35 | 
36 | const logError = tap(compose(
37 | 	console.error,
38 | 	join(': '),
39 | 	props([ 'name', 'message' ])));
40 | 
41 | module.exports = {
42 | 	code,
43 | 	escape,
44 | 	load,
45 | 	log,
46 | 	logError,
47 | 	name
48 | };
49 | 


--------------------------------------------------------------------------------
/wrap/configure.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const { isIP } = require('net');
 4 | 
 5 | const configure = [
 6 | 	{
 7 | 		type: 'input',
 8 | 		name: 'port',
 9 | 		message:
10 | 			'Which port do you want the TCP wrapper to listen on?',
11 | 		default: 12345,
12 | 		validate: x =>
13 | 			Number.isInteger(Number(x)),
14 | 		filter: x => Number(String(x).trim())
15 | 	},
16 | 	{
17 | 		type: 'input',
18 | 		name: 'ip',
19 | 		message:
20 | 			'Which interface / IP do you want the TCP wrapper to listen on?',
21 | 		default: '127.0.0.1',
22 | 		validate: x =>
23 | 			isIP(x) > 0,
24 | 		filter: x => x.trim()
25 | 	},
26 | 	{
27 | 		type: 'input',
28 | 		name: 'cmd',
29 | 		message:
30 | 			'Enter the command you use to run your minecraft server:',
31 | 		default: 'java -Xmx1024M -Xms1024M -jar server.jar nogui'
32 | 	}
33 | ];
34 | 
35 | module.exports = configure;
36 | 


--------------------------------------------------------------------------------
/client/run.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const { EOL } = require('os');
 4 | const { connect } = require('net');
 5 | const { createInterface } = require('readline');
 6 | 
 7 | const Parser = require('./parser');
 8 | 
 9 | const run = ({ port, ip, stdin, stdout, interactive = false, servertype }) => {
10 | 	const [ output, input ] = stdin && stdout
11 | 		? [ stdin, stdout ]
12 | 		: (x => [ x, x ])(connect(Number(port), ip));
13 | 	output.on('close', () => {
14 | 		console.error('Lost connection to server, exiting...');
15 | 		process.stdin.pause();
16 | 	});
17 | 	const parser = Parser(servertype, input);
18 | 	if (interactive) {
19 | 		const rl = createInterface({ input: process.stdin });
20 | 		rl.on('line', line =>
21 | 			output.write(line + EOL));
22 | 		parser.on('line', line =>
23 | 			console.log(line));
24 | 	}
25 | 	parser.send = x => output.write(x + EOL);
26 | 	return parser;
27 | };
28 | 
29 | module.exports = run;
30 | 


--------------------------------------------------------------------------------
/client/dataparser/index.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const bracketSplit = require('bracket-split');
 4 | 
 5 | const unwrap = str => str.slice(1, -1);
 6 | 
 7 | const surroundedBy = (a, b, str) =>
 8 | 	str.startsWith(a) && str.endsWith(b);
 9 | 
10 | const trim = x => x.trim();
11 | 
12 | /* eslint-disable no-nested-ternary, indent, operator-linebreak, max-len */
13 | 
14 | const parse = str =>
15 | 	surroundedBy('[', ']', str) ? bracketSplit(',', unwrap(str))
16 | 		.map(trim).map(parse) :
17 | 	surroundedBy('{', '}', str) ? bracketSplit(',', unwrap(str))
18 | 		.map(trim)
19 | 		.map(kv => {
20 | 			const [ key, value ] = bracketSplit(':', kv);
21 | 			return [ key, parse(value.trim()) ];
22 | 		})
23 | 		.reduce((acc, [ key, value ]) =>
24 | 			({ ...acc, [key]: value }), {}) :
25 | 	surroundedBy('"', '"', str) ? unwrap(str) :
26 | 	str.match(/^-?\d+L$/) ? str.slice(0, -1) :
27 | 	str.match(/^-?\d+(\.\d+)?(d|s|f|b)$/) ? Number(str.slice(0, -1)) :
28 | 	str.match(/^-?\d+$/) ? Number(str) :
29 | 	str;
30 | 
31 | module.exports = parse;
32 | 


--------------------------------------------------------------------------------
/bot/configure.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const clientConfig = require('../client/configure');
 4 | 
 5 | const configure = [
 6 | 	{
 7 | 		type: 'input',
 8 | 		name: 'token',
 9 | 		message:
10 | 			'Enter the bot token you obtained from BotFather on Telegram:',
11 | 		validate: x => x.length > 10 && x.includes(':') ||
12 | 			'That doesn\'t look like a valid token, try again please!',
13 | 		filter: x => x.trim()
14 | 	},
15 | 	{
16 | 		type: 'input',
17 | 		name: 'chatID',
18 | 		message:
19 | 			'Enter the Telegram chat ID you want to ' +
20 | 			'forward messages from Minecraft to:',
21 | 		validate: x =>
22 | 			Number.isInteger(Number(x)),
23 | 		filter: x => x.trim()
24 | 	},
25 | 	{
26 | 		type: 'confirm',
27 | 		name: 'allowList',
28 | 		message: 'Allow /list on Telegram?'
29 | 	},
30 | 	{
31 | 		type: 'confirm',
32 | 		name: 'localAuth',
33 | 		message: '(for cracked servers) Use local auth?',
34 | 		default: false
35 | 	},
36 | 	{
37 | 		type: 'confirm',
38 | 		name: 'postUpdates',
39 | 		message: 'Notify Telegram about game updates?',
40 | 		default: false
41 | 	},
42 | 	...clientConfig
43 | ];
44 | 
45 | module.exports = configure;
46 | 


--------------------------------------------------------------------------------
/cli/index.js:
--------------------------------------------------------------------------------
 1 | #!/usr/bin/env node
 2 | 'use strict';
 3 | 
 4 | const inquirer = require('inquirer');
 5 | 
 6 | const load = require('./load');
 7 | const save = require('./save');
 8 | 
 9 | const plugins = {
10 | 	/* eslint-disable global-require */
11 | 	bot: () => require('../bot'),
12 | 	botwrap: () => require('../botwrap'),
13 | 	client: () => require('../client'),
14 | 	wrap: () => require('../wrap')
15 | 	/* eslint-enable global-require */
16 | };
17 | 
18 | const args = process.argv.slice(2);
19 | const command = args.shift();
20 | const reconfigure = args[0] && args[0].startsWith('conf');
21 | 
22 | if (plugins[command]) {
23 | 	const plugin = plugins[command]();
24 | 	return Promise.resolve(load(plugin.file))
25 | 		.then(settings =>
26 | 			// eslint-disable-next-line operator-linebreak
27 | 			settings && !reconfigure ? settings :
28 | 				inquirer.prompt(
29 | 					settings
30 | 						? plugin.configure.map(question =>
31 | 							settings[question.name]
32 | 								? {
33 | 									...question,
34 | 									default: settings[question.name]
35 | 								}
36 | 								: question)
37 | 						: plugin.configure))
38 | 		.then(settings =>
39 | 			save(plugin.file, settings))
40 | 		.then(settings =>
41 | 			plugin.run({ ...settings, interactive: true }));
42 | }
43 | 
44 | const helpText = `Possible arguments:
45 | ${Object.keys(plugins).map(x => `\t${x}`).join('\n')}
46 | `;
47 | 
48 | if (!command || command.length === 0) {
49 | 	return console.log(helpText);
50 | }
51 | // eslint-disable-next-line no-console
52 | process.exitCode = 1;
53 | return console.error('Unknown command: ' + command);
54 | 


--------------------------------------------------------------------------------
/client/parser/index.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const { join } = require('path');
 4 | const { readdirSync } = require('fs');
 5 | const { createInterface } = require('readline');
 6 | const parse = require('../dataparser');
 7 | 
 8 | const {
 9 | 	head,
10 | 	map,
11 | 	mapObjIndexed
12 | } = require('ramda');
13 | 
14 | const loadMessages = type =>
15 | 	readdirSync(join(__dirname, `/${type}/messages`))
16 | 		.reduce((result, file) => ({
17 | 			...result,
18 | 			// eslint-disable-next-line global-require
19 | 			[file]: require(join(__dirname, `/${type}/messages`, file))
20 | 		}), {});
21 | 
22 | const getMessages = type => ({
23 | 	// eslint-disable-next-line global-require
24 | 	prefix: require(`./${type}/prefix`),
25 | 	messages: type === 'default'
26 | 		? loadMessages(type)
27 | 		: {
28 | 			...loadMessages('default'),
29 | 			...loadMessages(type)
30 | 		}
31 | });
32 | 
33 | const fixType = t =>
34 | 	[ 'default', 'old-spigot' ].includes(t)
35 | 		? t
36 | 		: 'default';
37 | 
38 | const Parser = (type, stream) => {
39 | 	const { prefix, messages } = getMessages(fixType(type));
40 | 	const rl = createInterface({ input: stream });
41 | 
42 | 	const handlers = mapObjIndexed((regexp, file) => ({
43 | 		regexp: new RegExp(prefix + regexp),
44 | 		type: head(file.split('.'))
45 | 	}), messages);
46 | 
47 | 	rl.on('line', line =>
48 | 		map(handler => {
49 | 			const result = handler.regexp.exec(line);
50 | 			if (handler.type === 'data') {
51 | 				return result && rl.emit(handler.type, {
52 | 					...result.groups,
53 | 					data: parse(result.groups.data),
54 | 					type: handler.type
55 | 				});
56 | 			}
57 | 			return result && rl.emit(handler.type, {
58 | 				...result.groups,
59 | 				type: handler.type
60 | 			});
61 | 		}, handlers));
62 | 
63 | 	return rl;
64 | };
65 | 
66 | Parser.fixType = fixType;
67 | 
68 | module.exports = Parser;
69 | 


--------------------------------------------------------------------------------
/client/generator.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const {
 4 | 	__,
 5 | 	append,
 6 | 	assoc,
 7 | 	compose,
 8 | 	concat,
 9 | 	flip,
10 | 	ifElse,
11 | 	intersperse,
12 | 	is,
13 | 	map,
14 | 	nthArg,
15 | 	of,
16 | 	replace,
17 | 	split,
18 | 	startsWith,
19 | 	trim,
20 | 	when
21 | } = require('ramda');
22 | 
23 | const textJSON = when(
24 | 	is(String),
25 | 	compose(
26 | 		intersperse('\n'),
27 | 		map(ifElse(
28 | 			compose(startsWith('>'), trim),
29 | 			assoc('text', __, { color: 'green' }),
30 | 			assoc('text', __, { color: 'white' })
31 | 		)),
32 | 		split('\n'),
33 | 		replace(/\n/g, '\n ')));
34 | 
35 | // eslint-disable-next-line no-unused-vars
36 | const replyTextJSON = compose(
37 | 	of,
38 | 	concat(__, '\n'),
39 | 	concat('\n > '),
40 | 	replace(/\n/g, '\n > '));
41 | 
42 | const userJSON = ifElse(
43 | 	nthArg(1),
44 | 	compose(
45 | 		flip(append)([
46 | 			{ text: 'TG', color: 'blue' },
47 | 			{ text: ': ', color: 'white' }
48 | 		]),
49 | 		assoc('text', __, { color: 'white' })),
50 | 	of);
51 | 
52 | const hoverUserJSON = (hoverText, telegram, name, text) => [
53 | 	' (',
54 | 	{
55 | 		text: hoverText,
56 | 		color: 'yellow',
57 | 		hoverEvent: {
58 | 			action: 'show_text',
59 | 			value: [
60 | 				{ text: '<', color: 'white' },
61 | 				...userJSON(name, telegram),
62 | 				{ text: '> ', color: 'white' },
63 | 				...textJSON(text)
64 | 			]
65 | 		}
66 | 	},
67 | 	')'
68 | ];
69 | 
70 | const fromJSON = (name, telegram, reply) => [
71 | 	'<',
72 | 	...userJSON(name, telegram),
73 | 	...reply || [],
74 | 	'> '
75 | ];
76 | 
77 | 
78 | const messageJSON = (telegram, from, text,
79 | 	hoverType,
80 | 	hoverUserTelegram, hoverUser, hoverText) => [
81 | 	...fromJSON(from, telegram,
82 | 		hoverUser &&
83 | 			hoverUserJSON(hoverType, hoverUserTelegram, hoverUser, hoverText)),
84 | 	// ...replyText ? replyTextJSON(replyText) : [],
85 | 	...textJSON(text)
86 | ];
87 | 
88 | module.exports = {
89 | 	textJSON,
90 | 	messageJSON
91 | };
92 | 


--------------------------------------------------------------------------------
/client/parser/default/messages/death.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const username = require('../username');
 4 | 
 5 | module.exports =
 6 | 	'(?<user>' +
 7 | 		username +
 8 | 	') (?<text>' +
 9 | 		'was (' +
10 | 			'shot by .+|' +
11 | 			'shot off (some vines|a ladder) by .+|' +
12 | 			'pricked to death|' +
13 | 			'stabbed to death|' +
14 | 			'squished too much|' +
15 | 			'blown up by .+|' +
16 | 			'killed by .+|' +
17 | 			'doomed to fall by .+|' +
18 | 			'blown from a high place by .+|' +
19 | 			'squashed by .+|' +
20 | 			'burnt to a crisp whilst fighting .+|' +
21 | 			'roasted in dragon breath( by .+)?|' +
22 | 			'struck by lightning( whilst fighting .+)?|' +
23 | 			'slain by .+|' +
24 | 			'fireballed by .+|' +
25 | 			'killed trying to hurt .+|' +
26 | 			'impaled by .+|' +
27 | 			'speared by .+|' +
28 | 			'poked to death by a sweet berry bush( whilst trying to escape .+)?|' +
29 | 			'pummeled by .+' +
30 | 		')|' +
31 | 		'hugged a cactus|' +
32 | 		'walked into a cactus whilst trying to escape .+|' +
33 | 		'drowned( whilst trying to escape .+)?|' +
34 | 		'suffocated in a wall( whilst fighting .+)?|' +
35 | 		'experienced kinetic energy( whilst trying to escape .+)?|' +
36 | 		'removed an elytra while flying( whilst trying to escape .+)?|' +
37 | 		'blew up|' +
38 | 		'hit the ground too hard( whilst trying to escape .+)?|' +
39 | 		'went up in flames|' +
40 | 		'burned to death|' +
41 | 		'walked into fire whilst fighting .+|' +
42 | 		'went off with a bang( whilst fighting .+)?|' +
43 | 		'tried to swim in lava(( while trying)? to escape .+)?|' +
44 | 		'discovered floor was lava|' +
45 | 		'walked into danger zone due to .+|' +
46 | 		'got finished off by .+|' +
47 | 		'starved to death|' +
48 | 		'didn\'t want to live in the same world as .+|' +
49 | 		'withered away( whilst fighting .+)?|' +
50 | 		'died( because of .+)?|' +
51 | 		'fell (' +
52 | 			'from a high place( and fell out of the world)?|' +
53 | 			'off a ladder|' +
54 | 			'off to death( whilst fighting .+)?|' +
55 | 			'off some vines|' +
56 | 			'out of the water|' +
57 | 			'into a patch of fire|' +
58 | 			'into a patch of cacti|' +
59 | 			'too far and was finished by .+|' +
60 | 			'out of the world' +
61 | 		')' +
62 | 	')$';
63 | 


--------------------------------------------------------------------------------
/wrap/run.js:
--------------------------------------------------------------------------------
 1 | 'use strict';
 2 | 
 3 | const { EOL, platform } = require('os');
 4 | const { spawn } = require('child_process');
 5 | const { createServer } = require('net');
 6 | const { createInterface } = require('readline');
 7 | const { decodeStream } = require('iconv-lite');
 8 | 
 9 | const bracketSplit = require('bracket-split');
10 | 
11 | const splitCommand = x =>
12 | 	bracketSplit(' ', x, [], [ '"' ]);
13 | 
14 | const logError = err =>
15 | 	// eslint-disable-next-line no-console
16 | 	console.error(err.name + ': ' + err.message);
17 | 
18 | const rl = stream =>
19 | 	createInterface({ input: stream });
20 | 
21 | const decode = x =>
22 | 	platform() === 'win32'
23 | 		? x.pipe(decodeStream('win1252'))
24 | 		: x;
25 | 
26 | const run = ({ port, ip, cmd }) => {
27 | 
28 | 	const [ command, ...args ] = splitCommand(cmd).map(arg =>
29 | 		arg.startsWith('"') && arg.endsWith('"')
30 | 			? arg.slice(1, -1)
31 | 			: arg);
32 | 
33 | 	const minecraftServer = spawn(command, args, {
34 | 		detached: true
35 | 	});
36 | 
37 | 	const { stdin } = minecraftServer;
38 | 	const stdout = decode(minecraftServer.stdout);
39 | 	const stderr = decode(minecraftServer.stderr);
40 | 
41 | 	stdout.pipe(process.stdout);
42 | 	stderr.pipe(process.stderr);
43 | 
44 | 	process.on('SIGINT', () =>
45 | 		stdin.write('stop' + EOL));
46 | 	process.on('SIGTERM', () =>
47 | 		stdin.write('stop' + EOL));
48 | 
49 | 	const minecraftOutput = rl(stdout);
50 | 	const cliInput = rl(process.stdin);
51 | 
52 | 	cliInput.on('line', line => stdin.write(line + EOL));
53 | 
54 | 	if (port && ip) {
55 | 		const server = createServer(client => {
56 | 			client.unref();
57 | 			client.on('error', logError);
58 | 			const clientOutput = rl(client);
59 | 			const clientWriter = line => client.write(line + EOL);
60 | 			clientOutput.on('line', line => stdin.write(line + EOL));
61 | 			minecraftOutput.on('line', clientWriter);
62 | 			client.on('close', () =>
63 | 				minecraftOutput.removeListener('line', clientWriter));
64 | 		});
65 | 
66 | 
67 | 		minecraftServer.once('exit', () => {
68 | 			server.close();
69 | 			cliInput.close();
70 | 		});
71 | 
72 | 		server.listen(port, ip);
73 | 	}
74 | 	return {
75 | 		stderr,
76 | 		stdin,
77 | 		stdout
78 | 	};
79 | };
80 | 
81 | module.exports = run;
82 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # TeMiCross
 2 | 
 3 | This is a Minecraft-to-Telegram chat bridge
 4 | 
 5 | ![Minecraft example](images/minecraft.jpg)
 6 | ![Telegram example](images/telegram.png)
 7 | 
 8 | ## Setup
 9 | 
10 | ### Prerequisites
11 | 
12 | 1. Install [Node.js](https://nodejs.org/)
13 | 1. Install temicross: `npm i -g temicross`
14 | 
15 | ### Easy mode (bot + minecraft server)
16 | 
17 | 1. [Download the Minecraft server jar](https://minecraft.net/download/server) and put it in a folder if you haven't.
18 | 1. Open a terminal.
19 | 1. `cd` to your Minecraft server folder.
20 | 1. Run `tmc botwrap` to set up your server and bot.
21 | 	* You will be asked to fill in some values.
22 | 	* Get a bot token from [@BotFather](https://t.me/BotFather).
23 | 1. The server and bot will start.
24 | 1. Test it in-game and from your Telegram-chat to make sure it works!
25 | 1. Report any bugs you find on the Issues page here!
26 | 
27 | ### Unattended mode
28 | 
29 | This mode enables updating the bot without restarting the Minecraft server.
30 | 
31 | #### Setup server
32 | 
33 | 1. Follow steps 1-3 from [above](#easy-mode-bot--minecraft-server).
34 | 1. Run `tmc wrap` to start the server.
35 | 	* You will be asked to fill in some values.
36 | 1. The server will start.
37 | 
38 | #### Setup bot
39 | 
40 | 1. Open a new terminal and `cd` to any folder (Your bot config will be stored here, if you don't know which folder to pick, the same folder as [above](#easy-mode-bot--minecraft-server) is a good choice).
41 | 1. Run `tmc bot` (make sure the Minecraft server is started using `tmc wrap` first, see [above](#setup-server)).
42 | 	* You will be asked to fill in some more values.
43 | 	* Use the token you got from [@BotFather](https://t.me/BotFather).
44 | 	* Make sure to use the same port and IP as you did before (the defaults are the same).
45 | 1. The bot will start.
46 | 
47 | #### Setup client
48 | 
49 | The client allows remote control of a server that has been properly set up with port and IP.
50 | 
51 | **MAKE SURE YOU KNOW THE SECURITY IMPLICATIONS OF ALLOWING REMOTE UNAUTHENTICATED ACCESS TO YOUR SERVER CONSOLE**
52 | 
53 | 1. Open a new terminal and `cd` to any folder (your client config will be stored here)
54 | 1. Run `tmc client` (make sure the Minecraft server is started using `tmc wrap` first, see [above](#setup-server)).
55 | 	* You will be asked to fill in even more values.
56 | 1. The client will start, and you can type commands into it to run commands on the server console.
57 | 
58 | ## Tips
59 | 
60 | ### Reconfigure
61 | 
62 | You can reconfigure the bot at any time by running: `tmc <command> config`
63 | 
64 | Example: `tmc botwrap config` will load values from `botwrapper.json` and ask you the configuration questions again. You may or may not need to do this after updating.
65 | 


--------------------------------------------------------------------------------
/bot/auth.js:
--------------------------------------------------------------------------------
  1 | 'use strict';
  2 | 
  3 | const {
  4 | 	compose,
  5 | 	invertObj,
  6 | 	last,
  7 | 	slice,
  8 | 	split
  9 | } = require('ramda');
 10 | 
 11 | const load = require('../cli/load');
 12 | const save = require('../cli/save');
 13 | 
 14 | const Pin = compose(
 15 | 	slice(0, 4),
 16 | 	last,
 17 | 	split('.'),
 18 | 	String,
 19 | 	Math.random);
 20 | 
 21 | const gamemodes = [
 22 | 	'survival',
 23 | 	'creative',
 24 | 	'adventure',
 25 | 	'survival'
 26 | ];
 27 | 
 28 | const limitPlayer = (client, user, player, timeout = 300000) => {
 29 | 
 30 | 	const gamemodeListener = ({ user: u, data }) => {
 31 | 		if (u === user && !Number.isNaN(data)) {
 32 | 			player.gamemode = gamemodes[data];
 33 | 			client.removeListener('data', gamemodeListener);
 34 | 		}
 35 | 	};
 36 | 	const dimensionListener = ({ user: u, data }) => {
 37 | 		if (u === user && typeof data === 'string') {
 38 | 			player.dimension = data;
 39 | 			client.removeListener('data', dimensionListener);
 40 | 		}
 41 | 	};
 42 | 	const positionListener = ({ user: u, data }) => {
 43 | 		if (u === user && Array.isArray(data)) {
 44 | 			player.position = data;
 45 | 			client.removeListener('data', positionListener);
 46 | 		}
 47 | 	};
 48 | 
 49 | 	player.kickTimeout = setTimeout(() =>
 50 | 		client.send(`kick ${user}`), timeout);
 51 | 	player.positionInterval = setInterval(() =>
 52 | 		player.position &&
 53 | 		client.send(`execute in ${player.dimension} run tp ${user} ${player.position.join(' ')}`), 400);
 54 | 
 55 | 	client.on('data', gamemodeListener);
 56 | 	client.on('data', positionListener);
 57 | 	client.on('data', dimensionListener);
 58 | 	client.send(`data get entity ${user} playerGameType`);
 59 | 	client.send(`data get entity ${user} Pos`);
 60 | 	client.send(`data get entity ${user} Dimension`);
 61 | 	client.send(`effect give ${user} minecraft:blindness 1000000`);
 62 | 	client.send(`effect give ${user} minecraft:slowness 1000000 255`);
 63 | 	client.send(`gamemode spectator ${user}`);
 64 | };
 65 | 
 66 | const unlimitPlayer = (client, user, player, left = false) => {
 67 | 	clearTimeout(player.kickTimeout);
 68 | 	clearInterval(player.positionInterval);
 69 | 	if (!left) {
 70 | 		client.send(`gamemode ${player.gamemode} ${user}`);
 71 | 		client.send(`effect clear ${user} minecraft:blindness`);
 72 | 		client.send(`effect clear ${user} minecraft:slowness`);
 73 | 	}
 74 | };
 75 | 
 76 | const LocalAuth = (bot, client) => {
 77 | 
 78 | 	const players = {};
 79 | 	const linked = load('auth') || {};
 80 | 	const pins = {};
 81 | 
 82 | 	client.on('join', ({ user }) => {
 83 | 		const player = players[user];
 84 | 		if (player) {
 85 | 			unlimitPlayer(client, user, player);
 86 | 			delete players[user];
 87 | 		}
 88 | 		limitPlayer(client, user, players[user] = {});
 89 | 		if (linked[user]) {
 90 | 			bot.telegram.sendMessage(
 91 | 				linked[user],
 92 | 				'Type /auth to authenticate yourself');
 93 | 		}
 94 | 	});
 95 | 
 96 | 	client.on('leave', ({ user }) => {
 97 | 		const player = players[user];
 98 | 		if (player) {
 99 | 			unlimitPlayer(client, user, player, true);
100 | 		}
101 | 	});
102 | 
103 | 	client.on('user', ({ user, text }) => {
104 | 		if (text.startsWith('!')) {
105 | 			const [ command, ...args ] = split(/\s+/, text.slice(1));
106 | 			if (command === 'link') {
107 | 				const [ pin ] = args;
108 | 				if (pins[pin]) {
109 | 					if (linked[user]) {
110 | 						client.send(`tellraw ${user} "This Minecraft account is already in use by another Telegram user!"`);
111 | 						setTimeout(() => client.send(`kick ${user}`), 2000);
112 | 						if (players[user]) {
113 | 							unlimitPlayer(client, user, players[user], true);
114 | 						}
115 | 						return;
116 | 					}
117 | 					linked[user] = pins[pin];
118 | 					save('auth', linked);
119 | 					const player = players[user];
120 | 					if (player) {
121 | 						unlimitPlayer(client, user, player);
122 | 						client.send(`tellraw ${user} "Successfully linked with Telegram account!"`);
123 | 					}
124 | 				}
125 | 			}
126 | 		}
127 | 	});
128 | 
129 | 	bot.command('auth', ctx => {
130 | 		const user = invertObj(linked)[ctx.from.id];
131 | 		if (user) {
132 | 			const player = players[user];
133 | 			if (player) {
134 | 				unlimitPlayer(client, user, player);
135 | 				return ctx.reply('You\'ve successfully authenticated yourself');
136 | 			}
137 | 			return ctx.reply('Log into the server first!');
138 | 		}
139 | 		return ctx.reply('Use /link first!');
140 | 	});
141 | 
142 | 	bot.command('deauth', ctx => {
143 | 		const user = invertObj(linked)[ctx.from.id];
144 | 		if (user) {
145 | 			const player = players[user];
146 | 			if (player) {
147 | 				unlimitPlayer(client, user, player);
148 | 				delete players[user];
149 | 			}
150 | 			limitPlayer(client, user, players[user] = {}, 30000);
151 | 			return ctx.reply('Deauthed yourself!');
152 | 		}
153 | 		return ctx.reply('Could not find you, did you /link ?');
154 | 	});
155 | 
156 | 	bot.command('link', ctx => {
157 | 		if (ctx.message.chat.type !== 'private') {
158 | 			return ctx.reply('Please use PM');
159 | 		}
160 | 		const pin = Pin();
161 | 		pins[pin] = ctx.from.id;
162 | 		return ctx.reply(
163 | 			`Type \`!link ${pin}\` in Minecraft after logging in!`,
164 | 			{ parse_mode: 'Markdown' });
165 | 	});
166 | };
167 | 
168 | module.exports = LocalAuth;
169 | 


--------------------------------------------------------------------------------
/bot/run.js:
--------------------------------------------------------------------------------
  1 | 'use strict';
  2 | 
  3 | const R = require('ramda');
  4 | const Telegraf = require('telegraf');
  5 | 
  6 | const Client = require('../client/run');
  7 | const Parser = require('../client/parser');
  8 | 
  9 | const {
 10 | 	messageJSON,
 11 | 	textJSON
 12 | } = require('../client/generator');
 13 | 
 14 | const {
 15 | 	code,
 16 | 	escape,
 17 | 	logError
 18 | } = require('./utils');
 19 | 
 20 | const emitUpdates = require('./gameVersionCheck');
 21 | 
 22 | const tgOpts = { parse_mode: 'HTML' };
 23 | 
 24 | const splitSpace = R.split(' ');
 25 | const joinSpace = R.join(' ');
 26 | 
 27 | const id = R.prop('id');
 28 | const chat = R.prop('chat');
 29 | const from = R.prop('from');
 30 | const text = R.prop('text');
 31 | const message = R.prop('message');
 32 | const lastName = R.prop('last_name');
 33 | const firstName = R.prop('first_name');
 34 | const reply = R.prop('reply_to_message');
 35 | 
 36 | const chatID = R.o(id, chat);
 37 | const fromID = R.o(id, from);
 38 | const fromLastName = R.o(lastName, from);
 39 | const fromFirstName = R.o(firstName, from);
 40 | 
 41 | 
 42 | const fromName = R.ifElse(
 43 | 	fromLastName,
 44 | 	R.o(
 45 | 		joinSpace,
 46 | 		R.converge(
 47 | 			R.pair,
 48 | 			[ fromFirstName, fromLastName ])),
 49 | 	fromFirstName);
 50 | 
 51 | const minecraftUsername = R.o(
 52 | 	R.head,
 53 | 	splitSpace);
 54 | 
 55 | const removeMinecraftUsername = R.compose(
 56 | 	joinSpace,
 57 | 	R.tail,
 58 | 	splitSpace);
 59 | 
 60 | const nextArg = R.nthArg(1);
 61 | 
 62 | const captionMedia = (name, fn) => R.ifElse(
 63 | 	R.compose(R.prop('caption'), fn),
 64 | 	R.compose(
 65 | 		R.insert(3, R.__, [
 66 | 			{ text: '[', color: 'white' },
 67 | 			{ text: name, color: 'gray' },
 68 | 			{ text: '] ', color: 'white' }
 69 | 		]),
 70 | 		textJSON,
 71 | 		R.compose(R.prop('caption'), fn)),
 72 | 	R.always([
 73 | 		{ text: '[', color: 'white' },
 74 | 		{ text: name, color: 'gray' },
 75 | 		{ text: ']', color: 'white' }
 76 | 	]));
 77 | 
 78 | 
 79 | const run = opts => {
 80 | 
 81 | 	const { token, chatID: tgID, allowList, localAuth } = opts;
 82 | 
 83 | 	const botID = R.head(R.split(':', token));
 84 | 
 85 | 	const client = Client({ ...opts, interactive: false });
 86 | 
 87 | 	const bot = new Telegraf(token);
 88 | 	bot.options.id = botID;
 89 | 
 90 | 	client.on('close', () => bot.stop());
 91 | 	bot.telegram.getMe().then(info => Object.assign(bot.options, info));
 92 | 
 93 | 	const send = msg =>
 94 | 		bot.telegram.sendMessage(tgID, msg, tgOpts).catch(err => console.error('[TG.sendMessage]: ]' + err.message));
 95 | 
 96 | 	if (opts.postUpdates) {
 97 | 		const updates = emitUpdates();
 98 | 		updates.on('update', version =>
 99 | 			send('<b>New version released:</b> ' + code(version)));
100 | 		client.on('close', () => updates.stop());
101 | 	}
102 | 
103 | 	let maxPlayers = 0;
104 | 	const players = [];
105 | 
106 | 	if (localAuth) {
107 | 		// eslint-disable-next-line global-require
108 | 		require('./auth')(bot, client);
109 | 	}
110 | 
111 | 	const addPlayer = name => {
112 | 		players.splice(0, Infinity, ...players.filter(x => x !== name), name);
113 | 		return name;
114 | 	};
115 | 	const removePlayer = name => {
116 | 		players.splice(0, Infinity, ...players.filter(x => x !== name));
117 | 		return name;
118 | 	};
119 | 
120 | 	if (allowList) {
121 | 		new Promise((resolve, reject) => {
122 | 			setTimeout(() => reject(new Error('/list took too long!')), 300000);
123 | 			return client.once('players_count', count =>
124 | 				resolve([
125 | 					count.current,
126 | 					count.max,
127 | 					count.players
128 | 						.split(/\s*,\s*/)
129 | 						.filter(l => l.length > 0)
130 | 				]));
131 | 		}).then(([ , max, ps ]) => {
132 | 			maxPlayers = max;
133 | 			players.splice(0, Infinity, ...ps);
134 | 		});
135 | 	}
136 | 
137 | 	client.send('list');
138 | 
139 | 	client.on('user', msg =>
140 | 		send(code(msg.user) + ' ' + escape(msg.text)));
141 | 
142 | 	client.on('self', msg =>
143 | 		send(code('* ' + msg.user + ' ' + msg.text)));
144 | 
145 | 	client.on('say', msg =>
146 | 		send(code(msg.user + ': ' + msg.text)));
147 | 
148 | 	client.on('join', msg =>
149 | 		send(code(addPlayer(msg.user) + ' joined the server')));
150 | 
151 | 	client.on('leave', msg =>
152 | 		send(code(removePlayer(msg.user) + ' left the server')));
153 | 
154 | 	client.on('death', msg =>
155 | 		send(code(msg.user + ' ' + msg.text)));
156 | 
157 | 	client.on('advancement', msg =>
158 | 		send(
159 | 			code(msg.user) +
160 | 		' has made the advancement ' +
161 | 		code('[' + msg.advancement + ']')));
162 | 
163 | 	client.on('goal', msg =>
164 | 		send(
165 | 			code(msg.user) +
166 | 		' has reached the goal ' +
167 | 		code('[' + msg.goal + ']')));
168 | 
169 | 	client.on('challenge', msg =>
170 | 		send(
171 | 			code(msg.user) +
172 | 		' has completed the challenge ' +
173 | 		code('[' + msg.challenge + ']')));
174 | 
175 | 	client.on('close', () =>
176 | 		bot.stop());
177 | 
178 | 	bot.command('chatid', ctx =>
179 | 		ctx.reply(ctx.chat.id));
180 | 
181 | 	if (allowList) {
182 | 		bot.command('list', ctx =>
183 | 			ctx.reply(
184 | 				'Players online ' +
185 | 				'(' + code(players.length) + '/' + code(maxPlayers) + '):\n' +
186 | 				code(players.join('\n')), tgOpts));
187 | 	}
188 | 
189 | 
190 | 	const telegram = R.compose(
191 | 		R.not,
192 | 		R.equals(botID),
193 | 		String,
194 | 		fromID);
195 | 
196 | 	const fromUser = R.ifElse(
197 | 		telegram,
198 | 		R.o(fromName, message),
199 | 		R.compose(minecraftUsername, text, message));
200 | 
201 | 	const handler = R.ifElse(
202 | 		R.compose(
203 | 			x => players.length > 0 && x,
204 | 			R.equals(tgID),
205 | 			String,
206 | 			chatID,
207 | 			message),
208 | 		R.compose(
209 | 			R.bind(client.send, client),
210 | 			R.concat('tellraw @a '),
211 | 			JSON.stringify,
212 | 			R.converge(messageJSON, [
213 | 				// telegram
214 | 				R.o(telegram, message),
215 | 				// from
216 | 				fromUser,
217 | 				// text
218 | 				R.cond([
219 | 					[ R.compose(text, message),
220 | 						R.compose(text, message) ],
221 | 					[ R.compose(R.prop('audio'), message),
222 | 						captionMedia('AUDIO', message) ],
223 | 					[ R.compose(R.prop('document'), message),
224 | 						captionMedia('DOCUMENT', message) ],
225 | 					[ R.compose(R.prop('photo'), message),
226 | 						captionMedia('IMAGE', message) ],
227 | 					[ R.compose(R.prop('sticker'), message),
228 | 						captionMedia('STICKER', message) ],
229 | 					[ R.compose(R.prop('video'), message),
230 | 						captionMedia('VIDEO', message) ],
231 | 					[ R.compose(R.prop('voice'), message),
232 | 						captionMedia('VOICE', message) ],
233 | 					[ R.compose(R.prop('contact'), message),
234 | 						captionMedia('CONTACT', message) ],
235 | 					[ R.compose(R.prop('location'), message),
236 | 						captionMedia('LOCATION', message) ],
237 | 					[ R.compose(R.prop('game'), message),
238 | 						captionMedia('GAME', message) ],
239 | 					[ R.compose(R.prop('video_note'), message),
240 | 						captionMedia('VIDEO NOTE', message) ]
241 | 				]),
242 | 				// hoverType
243 | 				R.ifElse(
244 | 					R.o(reply, message),
245 | 					R.always('Reply'),
246 | 					R.always(undefined)),
247 | 				// hoverUserTelegram
248 | 				R.compose(telegram, reply, message),
249 | 				// hoverUser
250 | 				R.ifElse(
251 | 					R.o(reply, message),
252 | 					R.ifElse(
253 | 						R.compose(
254 | 							R.equals(botID),
255 | 							String,
256 | 							fromID,
257 | 							reply,
258 | 							message),
259 | 						R.compose(minecraftUsername, text, reply, message),
260 | 						R.compose(fromName, reply, message)),
261 | 					R.always(undefined)),
262 | 				// hoverText
263 | 				R.ifElse(
264 | 					R.compose(telegram, reply, message),
265 | 					R.cond([
266 | 						[ R.compose(text, reply, message),
267 | 							R.compose(text, reply, message) ],
268 | 						[ R.compose(R.prop('audio'), reply, message),
269 | 							captionMedia('AUDIO', R.compose(reply, message)) ],
270 | 						[ R.compose(R.prop('document'), reply, message),
271 | 							captionMedia('DOCUMENT', R.compose(reply, message)) ],
272 | 						[ R.compose(R.prop('photo'), reply, message),
273 | 							captionMedia('IMAGE', R.compose(reply, message)) ],
274 | 						[ R.compose(R.prop('sticker'), reply, message),
275 | 							captionMedia('STICKER', R.compose(reply, message)) ],
276 | 						[ R.compose(R.prop('video'), reply, message),
277 | 							captionMedia('VIDEO', R.compose(reply, message)) ],
278 | 						[ R.compose(R.prop('voice'), reply, message),
279 | 							captionMedia('VOICE', R.compose(reply, message)) ],
280 | 						[ R.compose(R.prop('contact'), reply, message),
281 | 							captionMedia('CONTACT', R.compose(reply, message)) ],
282 | 						[ R.compose(R.prop('location'), reply, message),
283 | 							captionMedia('LOCATION', R.compose(reply, message)) ],
284 | 						[ R.compose(R.prop('game'), reply, message),
285 | 							captionMedia('GAME', R.compose(reply, message)) ],
286 | 						[ R.compose(R.prop('video_note'), reply, message),
287 | 							captionMedia('VIDEO NOTE', R.compose(reply, message)) ]
288 | 					]),
289 | 					R.compose(removeMinecraftUsername, text, reply, message))
290 | 			])),
291 | 		R.o(
292 | 			R.call,
293 | 			nextArg));
294 | 
295 | 	bot.on([
296 | 		'text',
297 | 		'audio',
298 | 		'document',
299 | 		'photo',
300 | 		'sticker',
301 | 		'video',
302 | 		'voice',
303 | 		'contact',
304 | 		'location',
305 | 		'game',
306 | 		'video_note'
307 | 	], handler);
308 | 
309 | 	bot.catch(logError);
310 | 
311 | 	bot.launch(opts.telegraf);
312 | 
313 | 	return bot;
314 | };
315 | 
316 | module.exports = run;
317 | 


--------------------------------------------------------------------------------