Initial commit

.gitignore

@@ -0,0 +1,10 @@
+node_modules
+dist
+coverage
+
+.env
+.env.*
+
+*.log
+
+.vscode/settings.json

.prettierrc

@@ -0,0 +1,6 @@
+{
+  "semi": true,
+  "singleQuote": true,
+  "trailingComma": "es5",
+  "printWidth": 100
+}

Dockerfile

@@ -0,0 +1,14 @@
+FROM node:22-slim
+
+WORKDIR /app
+
+COPY package*.json ./
+RUN npm install
+
+COPY . .
+
+RUN npm run build
+
+EXPOSE 7860
+
+CMD ["npm", "start"]

config.json

@@ -0,0 +1,5 @@
+{
+    "minecraft_host": "NSMP2.play.hosting",
+    "minecraft_port": 25565,
+    "minecraft_version": "1.21.1"
+}

eslint.config.mjs

@@ -0,0 +1,27 @@
+import js from "@eslint/js";
+import globals from "globals";
+import tseslint from "typescript-eslint";
+import prettier from "eslint-config-prettier";
+
+export default tseslint.config(
+  js.configs.recommended,
+
+  ...tseslint.configs.recommended,
+
+  {
+    files: ["**/*.ts"],
+
+    languageOptions: {
+      globals: {
+        ...globals.node
+      }
+    },
+
+    rules: {
+      "@typescript-eslint/no-explicit-any": "warn",
+      "@typescript-eslint/no-unused-vars": "off"
+    }
+  },
+
+  prettier
+);

package.json

@@ -0,0 +1,33 @@
+{
+    "name": "server",
+    "version": "1.0.0",
+    "main": "index.js",
+    "scripts": {
+        "build": "tsc",
+        "check": "prettier . --check",
+        "lint": "eslint .",
+        "start": "node dist/index.js",
+        "dev": "tsc --watch",
+        "format": "prettier . --write"
+    },
+    "keywords": [],
+    "author": "Franek_Le",
+    "license": "MIT",
+    "description": "",
+    "dependencies": {
+        "express": "^5.2.1",
+        "mineflayer": "^4.25.0",
+        "tslib": "^2.8.1"
+    },
+    "devDependencies": {
+        "@eslint/js": "^9.39.4",
+        "@types/express": "^5.0.6",
+        "@types/node": "^25.9.3",
+        "eslint": "^9.39.4",
+        "eslint-config-prettier": "^10.1.8",
+        "globals": "^17.6.0",
+        "prettier": "^3.8.4",
+        "typescript": "^6.0.3",
+        "typescript-eslint": "^8.61.1"
+    }
+}

src/bot/bot.ts

@@ -0,0 +1,58 @@
+import mineflayer, { BotOptions, Bot as MineflayerBot } from "mineflayer";
+import { Config } from "../config/config";
+import { Logger } from "../logger/logger";
+
+export class Bot {
+    private bot: MineflayerBot | undefined = undefined;
+    private readonly botArgs: BotOptions;
+    private readonly config: Config;
+    private readonly logger: Logger;
+
+    constructor(config: Config, logger: Logger) {
+        this.config = config;
+        this.logger = logger;
+
+        this.botArgs = {
+            username: "AFKBot",
+            auth: "offline",
+            version: this.config.get<string>("minecraft_version"),
+            chatLengthLimit: 512,
+            host: this.config.get<string>("minecraft_host"),
+            port: this.config.get<number>("minecraft_port"),
+        }
+    }
+
+    public connect() {
+        this.initBot();
+    }
+
+    private initBot() {
+        this.bot = mineflayer.createBot(this.botArgs);
+
+        this.bot.on("login", () => {
+            this.logger.info(`[Minecraft Bot]: Connected to: ${this.botArgs.host}:${this.botArgs.port}`);
+        })
+
+        this.bot.on("end", () => {
+            this.logger.info("[Minecraft Bot]: Disconnected.")
+
+            this.logger.info("[Minecraft Bot]: Reconnecting...")
+            setTimeout(this.initBot, 5000);
+        })
+
+        this.bot.on("kicked", (reason: string, _loggedIn: boolean) => {
+            this.logger.warn(`[Minecraft Bot]: Kicked for ${reason}`);
+
+            this.logger.info("[Minecraft Bot]: Reconnecting...")
+            setTimeout(this.initBot, 5000);
+        })
+
+        this.bot.on("error", (error: unknown) => {
+            if (typeof error === "object" && error !== null && "code" in error && (error as { code: string }).code === "ECONNREFUSED") {
+                this.logger.error(`[Minecraft Bot]: Failed to connect to: ${this.botArgs.host}:${this.botArgs.port}`);
+            } else {
+                this.logger.error(`[Minecraft Bot]: Unhandled error: ${error}`);
+            }
+        })
+    }
+}

src/config/config.ts

@@ -0,0 +1,55 @@
+import * as fs from "fs";
+import * as path from "path";
+
+export class Config {
+    private readonly data: Record<string, string | object | number | []>;
+
+    constructor(data: Record<string, any>) {
+        this.data = data;
+    }
+
+    public static load(fileName = "config.json"): Config {
+        const configPath = Config.findConfigFile(fileName);
+
+        if (!configPath) {
+            throw new Error(`Could not find ${fileName}`);
+        }
+
+        const contents = fs.readFileSync(configPath, "utf8");
+        const data = JSON.parse(contents);
+
+        return new Config(data);
+    }
+
+    public get<T>(key: string): T {
+        if (!(key in this.data)) {
+            throw new Error(`Missing configuration key: ${key}`);
+        }
+
+        return this.data[key] as T;
+    }
+
+    public has(key: string): boolean {
+        return key in this.data;
+    }
+
+    private static findConfigFile(fileName: string): string | null {
+        let currentDir = process.cwd();
+
+        while (true) {
+            const candidate = path.join(currentDir, fileName);
+
+            if (fs.existsSync(candidate)) {
+                return candidate;
+            }
+
+            const parentDir = path.dirname(currentDir);
+
+            if (parentDir === currentDir) {
+                return null;
+            }
+
+            currentDir = parentDir;
+        }
+    }
+}

src/index.ts

@@ -0,0 +1,21 @@
+import { Server } from "./server/server";
+import { Logger } from "./logger/logger";
+import { Config } from "./config/config";
+import { Bot } from "./bot/bot";
+
+function main(): void {
+  const config: Config = new Config({});
+  const logger: Logger = new Logger();
+
+  const server: Server = new Server(logger);
+  const bot: Bot = new Bot(config, logger);
+
+  server.get("/",  () => {
+    return "<h1>NSMP Server</h1>";
+  })
+
+  //bot.connect();
+  server.start(7860);
+}
+
+setImmediate(main);

src/logger/logger.ts

@@ -0,0 +1,39 @@
+
+
+enum Color {
+  Reset = "\x1b[0m",
+  Gray = "\x1b[90m",
+  Blue = "\x1b[34m",
+  Yellow = "\x1b[33m",
+  Red = "\x1b[31m",
+}
+
+export class Logger {
+  constructor(private readonly context?: string) {}
+
+  debug(message: string, ...meta: unknown[]): void {
+    this.log("DEBUG", Color.Gray, message, meta);
+  }
+
+  info(message: string, ...meta: unknown[]): void {
+    this.log("INFO ", Color.Blue, message, meta);
+  }
+
+  warn(message: string, ...meta: unknown[]): void {
+    this.log("WARN ", Color.Yellow, message, meta);
+  }
+
+  error(message: string, ...meta: unknown[]): void {
+    this.log("ERROR", Color.Red, message, meta);
+  }
+
+  private log(level: string, color: Color, message: string, meta: unknown[]): void {
+    const timestamp = new Date().toISOString();
+    const context = this.context ? ` [${this.context}]` : "";
+
+    console.log(
+      `${color}[${timestamp}] ${level}${context}: ${message}${Color.Reset}`,
+      ...meta
+    );
+  }
+}

src/server/server.ts

@@ -0,0 +1,58 @@
+import express, {Application, RequestHandler} from "express";
+import { Server as HttpServer } from "http";
+import { Logger } from "../logger/logger";
+
+export class Server {
+    private readonly app: Application;
+    private server?: HttpServer;
+    private readonly logger: Logger;
+
+    constructor(logger: Logger) {
+        this.logger = logger;
+
+        this.app = express();
+
+        this.app.use(express.json());
+        this.app.use(express.urlencoded({ extended: true }));
+    }
+
+    public start(port: number): Promise<void> {
+        return new Promise((resolve, reject) => {
+            if (this.server) {
+                return reject(new Error("Server is already running"));
+            }
+
+            this.server = this.app.listen(port, () => {
+                this.logger.info(`[Server]: Listening on port ${port}`);
+                resolve();
+            });
+
+            this.server.on("error", reject);
+        });
+    }
+
+    public stop(): Promise<void> {
+        return new Promise((resolve, reject) => {
+            if (!this.server) {
+                return resolve();
+            }
+
+            this.server.close((err) => {
+                if (err) {
+                    return reject(err);
+                }
+
+                this.server = undefined;
+                resolve();
+            });
+        });
+    }
+
+    public get(path: string, handler: RequestHandler): void {
+        this.app.get(path, handler);
+    }
+
+    public post(path: string, handler: RequestHandler): void {
+        this.app.post(path, handler);
+    }
+}

tsconfig.json

@@ -0,0 +1,34 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+
+    "rootDir": "./src",
+    "outDir": "./dist",
+
+    "strict": true,
+
+    "noImplicitAny": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+
+    "sourceMap": true,
+    "declaration": true,
+
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true
+  },
+
+  "include": [
+    "src/**/*"
+  ],
+
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}