417 lines
16 KiB
JavaScript
417 lines
16 KiB
JavaScript
// This script aims to bridge Minecraft to a guild of your choice by piping
|
|
// the Minecraft output into this script. RCON isrequired for messages to
|
|
// be sent to Minecraft.
|
|
|
|
// Running example - working directory: project root:
|
|
// (cd ~/minecraft_server/ ; exec ~/minecraft_server/start.sh) | RCON_PASSWORD="your rcon password" node scripts/minecraft.js
|
|
|
|
import fetch from "node-fetch";
|
|
import { WebSocket } from "ws";
|
|
import { spawn } from "node:child_process";
|
|
import Rcon from "rcon";
|
|
|
|
|
|
const TOKEN = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJ1c2VybmFtZSI6InN0YWdpbmctbWluZWNyYWZ0LWJyaWRnZSIsImF2YXRhclVSTCI6bnVsbCwiZGlzY29yZElEIjoiMCIsImd1aWxkQWNjZXNzIjpbIjczNjI5MjUwOTEzNDc0OTgwNyJdLCJpc1N1cGVyVG9rZW4iOnRydWUsImlhdCI6MTY0NDQ1MzM4MX0.-XIBl6VLnXVwve9iqhWs51ABZkm1i_v1tS6X01SPk3U"; // A supertoken is required to send messages from Minecraft.
|
|
const TARGET_GUILD_ID = "_";
|
|
const TARGET_CHANNEL_ID = "_";
|
|
const ORIGIN = "http://localhost:4050";
|
|
const GATEWAY_ORIGIN = "ws://localhost:4050/gateway";
|
|
|
|
|
|
const chatMessageRegex = /^\[(?:.*?)\]: \<(?<username>[a-zA-Z0-9]+)\> (?<message>.*)/;
|
|
const joinNotificationRegex = /^\[(?:.*?)\]: (?<username>[a-zA-Z0-9]+) joined the game/;
|
|
const leaveNotificationRegex = /^\[(?:.*?)\]: (?<username>[a-zA-Z0-9]+) left the game/;
|
|
const messageSchema = { t: "number", d: "object" };
|
|
const messageTypes = {
|
|
HELLO: 0,
|
|
YOO: 1,
|
|
READY: 2,
|
|
EVENT: 3
|
|
};
|
|
|
|
const createServerChildProcess = () => {
|
|
const serverJar = process.env.SERVER_JAR;
|
|
if (!serverJar) {
|
|
throw new Error("SERVER_JAR not found in env");
|
|
}
|
|
|
|
const serverPwd = process.env.SERVER_PWD;
|
|
if (!serverPwd) {
|
|
throw new Error("SERVER_PWD not found in env");
|
|
}
|
|
|
|
return spawn("java", [
|
|
"-Xms1G", "-Xmx5G", "-XX:+UseG1GC", "-XX:+ParallelRefProcEnabled", "-XX:MaxGCPauseMillis=200", "-XX:+UnlockExperimentalVMOptions", "-XX:+DisableExplicitGC", "-XX:+AlwaysPreTouch", "-XX:G1NewSizePercent=30",
|
|
"-XX:G1MaxNewSizePercent=40", "-XX:G1HeapRegionSize=8M", "-XX:G1ReservePercent=20", "-XX:G1HeapWastePercent=5", "-XX:G1MixedGCCountTarget=4", "-XX:InitiatingHeapOccupancyPercent=15", "-XX:G1MixedGCLiveThresholdPercent=90",
|
|
"-XX:G1RSetUpdatingPauseTimePercent=5", "-XX:SurvivorRatio=32", "-XX:+PerfDisableSharedMem", "-XX:MaxTenuringThreshold=1", "-Dusing.aikars.flags=https://mcflags.emc.gs",
|
|
"-Daikars.new.flags=true", "-jar", serverJar, "nogui"
|
|
], {
|
|
cwd: serverPwd
|
|
});
|
|
};
|
|
|
|
class GatewayClient {
|
|
constructor(gatewayPath) {
|
|
this.gatewayPath = gatewayPath;
|
|
this.ws = null;
|
|
this.token = null;
|
|
this.user = null;
|
|
this.wasEverReady = false;
|
|
this.isReady = false;
|
|
this.onEvent = (e) => {};
|
|
}
|
|
|
|
connect(token) {
|
|
if (!token)
|
|
token = this.token;
|
|
|
|
if (this.ws) {
|
|
console.log("gateway: connect() but connection already exists, killing existing connection...");
|
|
try {
|
|
this.ws.removeAllListeners();
|
|
this.ws.close();
|
|
this.ws = null;
|
|
} catch (e) {
|
|
console.log("gateway: error while closing existing connection - it might not be established yet");
|
|
}
|
|
}
|
|
|
|
console.log("gateway: connecting");
|
|
|
|
this.ws = new WebSocket(this.gatewayPath);
|
|
|
|
this.ws.on("message", (data, isBinary) => {
|
|
if (isBinary) {
|
|
console.warn("gateway: got binary data from server, ignoring...");
|
|
return;
|
|
}
|
|
|
|
let message = data.toString();
|
|
try {
|
|
message = JSON.parse(data);
|
|
} catch(e) {
|
|
console.warn("gateway: got invalid JSON from server (failed to parse), ignoring...");
|
|
return;
|
|
}
|
|
|
|
if (!this._checkMessageSchema(message)) {
|
|
console.warn("gateway: got invalid JSON from server (does not match schema), ignoring...");
|
|
return;
|
|
}
|
|
|
|
switch (message.t) {
|
|
case messageTypes.HELLO: {
|
|
console.log("gateway: HELLO");
|
|
this.ws.send(JSON.stringify({
|
|
t: messageTypes.YOO,
|
|
d: {
|
|
token
|
|
}
|
|
}));
|
|
break;
|
|
}
|
|
case messageTypes.READY: {
|
|
console.log("gateway: READY");
|
|
this.user = message.d.user;
|
|
this.wasEverReady = true;
|
|
this.isReady = true;
|
|
break;
|
|
}
|
|
case messageTypes.EVENT: {
|
|
this.onEvent(message.d);
|
|
break;
|
|
}
|
|
default: {
|
|
console.warn("gateway: got invalid JSON from server (invalid type), ignoring...");
|
|
return;
|
|
}
|
|
}
|
|
});
|
|
this.ws.on("open", () => {
|
|
console.log("gateway: open");
|
|
});
|
|
this.ws.on("close", () => {
|
|
console.log("gateway: closed, reconnecting in 4000ms");
|
|
this.isReady = false;
|
|
setTimeout(() => {
|
|
console.log("gateway: reconnecting");
|
|
this.connect(token);
|
|
}, 4000);
|
|
});
|
|
this.ws.on("error", (e) => {
|
|
console.error("gateway: error", e);
|
|
console.log("gateway: reconnecting in 4000ms due to previous error");
|
|
this.isReady = false;
|
|
setTimeout(() => {
|
|
console.log("gateway: reconnecting");
|
|
this.connect(token);
|
|
}, 4000);
|
|
});
|
|
}
|
|
|
|
_checkMessageSchema(message) {
|
|
for (const [key, value] of Object.entries(message)) {
|
|
if (!messageSchema[key])
|
|
return false;
|
|
|
|
if (typeof value !== messageSchema[key])
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
class Bridge {
|
|
constructor() {
|
|
this.gatewayConnection = new GatewayClient(GATEWAY_ORIGIN);
|
|
this.process = null;
|
|
this.rconConnection = null;
|
|
this.playerCount = 0;
|
|
this.serverStartedAt = null;
|
|
|
|
this.gatewayConnection.onEvent = (e) => {
|
|
if (
|
|
e.eventType === "MESSAGE_CREATE" &&
|
|
e.message.channel_id === TARGET_CHANNEL_ID &&
|
|
e.message.guild_id === TARGET_GUILD_ID &&
|
|
!e.message.webhook_id
|
|
) {
|
|
if (e.message.content === "!:mc-start") {
|
|
this.userRequestedServerJob();
|
|
return;
|
|
} else if (e.message.content === "!:mc-status") {
|
|
const message = `:scroll: **Server information**
|
|
Player Count: **${this.playerCount}**
|
|
${this.serverStartedAt ? `Started: <t:${Math.floor(this.serverStartedAt/1000)}:R>` : "Started: [server is closed]"}
|
|
|
|
:gear: **Runtime Information**:
|
|
rconConnection exists: \`${!!this.rconConnection}\`
|
|
process exists: \`${!!this.process}\`
|
|
gatewayConnection.user exists: \`${!!this.gatewayConnection.user}\`
|
|
rconConnection.hasAuthed: \`${this.rconConnection.hasAuthed}\`
|
|
gatewayConnection.isReady: \`${this.gatewayConnection.isReady}\`
|
|
gatewayConnection.wasEverReady: \`${this.gatewayConnection.wasEverReady}\`
|
|
`;
|
|
|
|
this.sendBridgeMessageAs(TARGET_GUILD_ID,
|
|
TARGET_CHANNEL_ID,
|
|
message,
|
|
null,
|
|
null
|
|
);
|
|
return;
|
|
}
|
|
|
|
this.sendMinecraftMessageAs(
|
|
e.message.author.username,
|
|
e.message.content,
|
|
e.message.attachments,
|
|
e.message.referenced_message
|
|
);
|
|
}
|
|
};
|
|
}
|
|
|
|
rconConnect() {
|
|
if (this.rconConnection) {
|
|
this.rconConnection.disconnect();
|
|
this.rconConnection = null;
|
|
}
|
|
|
|
this.rconConnection = new Rcon("localhost", "25575", process.env.RCON_PASSWORD);
|
|
this.rconConnection.connect();
|
|
this.rconConnection.on("error", (e) => {
|
|
if (e.code === "ECONNREFUSED" && e.syscall === "connect") {
|
|
console.warn("rcon: ECONNREFUSED, reconnecting in 5s...");
|
|
setTimeout(() => {
|
|
console.log("rcon: reconnecting...");
|
|
this.rconConnect();
|
|
}, 5000);
|
|
} else {
|
|
console.error("rcon: got error", e);
|
|
console.error("rcon: don't know what to do, disconnecting rcon due to previous error");
|
|
this.rconConnection.disconnect();
|
|
this.rconConnection = null;
|
|
}
|
|
});
|
|
this.rconConnection.on("connect", () => {
|
|
this.serverStartedAt = Date.now();
|
|
this.sendBridgeMessageAs(TARGET_GUILD_ID, TARGET_CHANNEL_ID, ":zap: Server started!", null, null);
|
|
});
|
|
}
|
|
|
|
start() {
|
|
this.sendBridgeMessageAs(TARGET_GUILD_ID, TARGET_CHANNEL_ID, ":bridge_at_night: The bridge server has started! Type `!:mc-start` in the chat to start the Minecraft server. Any further updates related to the server's status will be sent in this channel.", null, null);
|
|
this.gatewayConnection.connect(TOKEN);
|
|
}
|
|
|
|
spawnProcess() {
|
|
if (this.process) {
|
|
console.warn("server job: spawnProcess(): another instance already exists");
|
|
this.sendBridgeMessageAs(TARGET_GUILD_ID, TARGET_CHANNEL_ID, ":thinking: It seems like the server is already running! If you think this is a mistake, contact the server manager.", null, null);
|
|
return;
|
|
}
|
|
|
|
console.log("server job: spawning");
|
|
this.sendBridgeMessageAs(TARGET_GUILD_ID, TARGET_CHANNEL_ID, ":clock5: Starting server...", null, null);
|
|
|
|
this.process = createServerChildProcess();
|
|
|
|
process.stdin.pipe(this.process.stdin);
|
|
|
|
this.process.stderr.on("data", async (rawDataBuffer) => {
|
|
const stringData = rawDataBuffer.toString().trim();
|
|
console.error(`[server process stderr]: ${stringData}`);
|
|
});
|
|
|
|
this.process.stdout.on("data", async (rawDataBuffer) => {
|
|
const stringData = rawDataBuffer.toString().trim();
|
|
console.log(`[server process stdout]: ${stringData}`);
|
|
|
|
const joinResult = joinNotificationRegex.exec(stringData);
|
|
if (joinResult) {
|
|
this.onPlayerCountUpdate(1);
|
|
await this.sendBridgeMessageAs(TARGET_GUILD_ID, TARGET_CHANNEL_ID, `:door: **${joinResult.groups.username}** joined the game. Player count is ${this.playerCount}.`, null, null);
|
|
return;
|
|
}
|
|
|
|
const leaveResult = leaveNotificationRegex.exec(stringData);
|
|
if (leaveResult) {
|
|
this.onPlayerCountUpdate(-1);
|
|
await this.sendBridgeMessageAs(TARGET_GUILD_ID, TARGET_CHANNEL_ID, `:door: **${leaveResult.groups.username}** left the game. Player count is ${this.playerCount}.`, null, null);
|
|
return;
|
|
}
|
|
|
|
const messageResult = chatMessageRegex.exec(stringData);
|
|
if (messageResult) {
|
|
await this.sendBridgeMessageAs(TARGET_GUILD_ID, TARGET_CHANNEL_ID, messageResult.groups.message, messageResult.groups.username, null);
|
|
}
|
|
});
|
|
|
|
this.process.on("spawn", () => {
|
|
console.log("server process: spawn");
|
|
this.process.stdout.resume();
|
|
this.process.stderr.resume();
|
|
this.rconConnect();
|
|
});
|
|
|
|
this.process.on("exit", (code) => {
|
|
console.log(`server process: exited with code ${code}`);
|
|
this.sendBridgeMessageAs(TARGET_GUILD_ID, TARGET_CHANNEL_ID, ":zap: Server is now closed.", null, null);
|
|
this.process = null;
|
|
this.serverStartedAt = null;
|
|
});
|
|
|
|
this.process.on("error", (e) => {
|
|
console.error("server process: error", e);
|
|
this.sendBridgeMessageAs(TARGET_GUILD_ID, TARGET_CHANNEL_ID, ":flushed: Server process error.", null, null);
|
|
this.process = null;
|
|
this.serverStartedAt = null;
|
|
});
|
|
}
|
|
|
|
async sendBridgeMessageAs(guildId, channelId, content, username=undefined, avatarURL=undefined) {
|
|
return await fetch(`${ORIGIN}/api/v1/guilds/${guildId}/channels/${channelId}/messages/create`, {
|
|
method: "POST",
|
|
body: JSON.stringify({
|
|
content,
|
|
username,
|
|
avatarURL
|
|
}),
|
|
headers: {
|
|
"content-type": "application/json",
|
|
"authorization": TOKEN
|
|
}
|
|
});
|
|
}
|
|
|
|
sendMinecraftMessageAs(username, content, attachments=[], referencedMessage=null) {
|
|
const tellrawPayload = [
|
|
{ text: "[" },
|
|
{ text: `${username}`, color: "gray" },
|
|
{ text: "]" },
|
|
{ text: " " },
|
|
];
|
|
|
|
if (referencedMessage) {
|
|
let trimmedContent = referencedMessage.content.substring(0, 70);
|
|
if (trimmedContent !== referencedMessage.content) {
|
|
trimmedContent += "...";
|
|
}
|
|
tellrawPayload.push({
|
|
text: `<replying to ${referencedMessage.author.username}: ${trimmedContent}>`,
|
|
color: "gray"
|
|
});
|
|
tellrawPayload.push({
|
|
text: " "
|
|
});
|
|
}
|
|
|
|
attachments.forEach((e) => {
|
|
tellrawPayload.push({
|
|
text: `<open attachment: ${e.filename || "[unknown]"}>`,
|
|
color: "gray",
|
|
clickEvent: {
|
|
action: "open_url",
|
|
value: e.proxy_url
|
|
}
|
|
});
|
|
tellrawPayload.push({
|
|
text: " "
|
|
});
|
|
});
|
|
|
|
tellrawPayload.push({ text: content });
|
|
|
|
if (this.rconConnection)
|
|
this.rconConnection.send(`tellraw @a ${JSON.stringify(tellrawPayload)}`);
|
|
}
|
|
|
|
onPlayerCountUpdate(amount) {
|
|
this.playerCount += amount;
|
|
|
|
if (this.playerCount === 0) {
|
|
this.sendBridgeMessageAs(TARGET_GUILD_ID, TARGET_CHANNEL_ID, ":wave: Everyone has left the server. Closing...", null, null);
|
|
console.log("server job: playerCount has reached 0, will close child server process");
|
|
if (this.process) {
|
|
console.log("server job: closing process...");
|
|
this.process.kill("SIGINT");
|
|
} else {
|
|
console.warn("server job: no process to kill");
|
|
}
|
|
}
|
|
}
|
|
|
|
userRequestedServerJob() {
|
|
console.log("server job: user requested server job, spawning...");
|
|
this.spawnProcess();
|
|
|
|
// wait for 5 minutes - if no one has joined the server in that time, close it
|
|
setTimeout(() => {
|
|
if (this.playerCount === 0) {
|
|
console.log("server job: no players on server after 5 minutes, closing...");
|
|
if (this.process) {
|
|
this.process.kill("SIGINT");
|
|
}
|
|
this.sendBridgeMessageAs(TARGET_GUILD_ID, TARGET_CHANNEL_ID, ":pensive: Server was started, yet no one joined after 5 minutes. Closing again...", null, null);
|
|
}
|
|
}, 300000);
|
|
}
|
|
}
|
|
|
|
function main() {
|
|
const bridge = new Bridge();
|
|
bridge.start();
|
|
|
|
const onServerClosing = () => {
|
|
if (bridge.process)
|
|
bridge.process.kill("SIGINT");
|
|
process.exit();
|
|
};
|
|
|
|
['exit', 'SIGINT', 'SIGUSR1', 'SIGUSR2', 'uncaughtException', 'SIGTERM'].forEach((eventType) => {
|
|
process.on(eventType, onServerClosing);
|
|
});
|
|
}
|
|
|
|
main();
|