blockmine 1.25.0 → 1.27.1

package/backend/src/core/infrastructure/__tests__/CircuitBreaker.test.js

@@ -0,0 +1,156 @@
+const CircuitBreaker = require('../CircuitBreaker');
+const { ExternalServiceError } = require('../../errors/index');
+
+const { CLOSED, OPEN, HALF_OPEN } = CircuitBreaker.STATE;
+
+function makeBreaker(opts = {}) {
+    return new CircuitBreaker({ failureThreshold: 3, successThreshold: 2, timeout: 1000, ...opts });
+}
+
+describe('CircuitBreaker', () => {
+    describe('initial state', () => {
+        it('starts in CLOSED state', () => {
+            expect(makeBreaker().getState()).toBe(CLOSED);
+        });
+    });
+
+    describe('CLOSED state', () => {
+        it('calls fn and returns result', async () => {
+            const cb = makeBreaker();
+            const result = await cb.call(async () => 42);
+            expect(result).toBe(42);
+        });
+
+        it('opens after failureThreshold failures', async () => {
+            const cb = makeBreaker({ failureThreshold: 3 });
+            const fail = () => { throw new Error('fail'); };
+            for (let i = 0; i < 3; i++) {
+                await cb.call(fail).catch(() => {});
+            }
+            expect(cb.getState()).toBe(OPEN);
+        });
+
+        it('resets failure count on success', async () => {
+            const cb = makeBreaker({ failureThreshold: 3 });
+            const fail = () => { throw new Error('fail'); };
+            await cb.call(fail).catch(() => {});
+            await cb.call(fail).catch(() => {});
+            await cb.call(async () => 'ok');
+            expect(cb.getStats().failureCount).toBe(0);
+            expect(cb.getState()).toBe(CLOSED);
+        });
+    });
+
+    describe('OPEN state', () => {
+        it('throws ExternalServiceError without calling fn', async () => {
+            const cb = makeBreaker({ failureThreshold: 1 });
+            await cb.call(() => { throw new Error('fail'); }).catch(() => {});
+            expect(cb.getState()).toBe(OPEN);
+
+            const fn = jest.fn();
+            await expect(cb.call(fn)).rejects.toBeInstanceOf(ExternalServiceError);
+            expect(fn).not.toHaveBeenCalled();
+        });
+
+        it('returns fallback value when open', async () => {
+            const cb = makeBreaker({ failureThreshold: 1 });
+            await cb.call(() => { throw new Error('fail'); }).catch(() => {});
+            const result = await cb.call(jest.fn(), 'fallback');
+            expect(result).toBe('fallback');
+        });
+
+        it('returns fallback function result when open', async () => {
+            const cb = makeBreaker({ failureThreshold: 1 });
+            await cb.call(() => { throw new Error('fail'); }).catch(() => {});
+            const result = await cb.call(jest.fn(), () => 'computed');
+            expect(result).toBe('computed');
+        });
+
+        it('transitions to HALF_OPEN after timeout', async () => {
+            jest.useFakeTimers();
+            const cb = makeBreaker({ failureThreshold: 1, timeout: 1000 });
+            await cb.call(() => { throw new Error('fail'); }).catch(() => {});
+            expect(cb.getState()).toBe(OPEN);
+            jest.advanceTimersByTime(1001);
+            await cb.call(async () => 'ok');
+            jest.useRealTimers();
+        });
+    });
+
+    describe('HALF_OPEN state', () => {
+        async function openThenHalfOpen(cb) {
+            await cb.call(() => { throw new Error('fail'); }).catch(() => {});
+            cb.nextAttempt = Date.now() - 1;
+        }
+
+        it('closes after successThreshold successes', async () => {
+            const cb = makeBreaker({ failureThreshold: 1, successThreshold: 2 });
+            await openThenHalfOpen(cb);
+            await cb.call(async () => 'ok');
+            expect(cb.getState()).toBe(HALF_OPEN);
+            await cb.call(async () => 'ok');
+            expect(cb.getState()).toBe(CLOSED);
+        });
+
+        it('reopens on failure in HALF_OPEN', async () => {
+            const cb = makeBreaker({ failureThreshold: 1, successThreshold: 2 });
+            await openThenHalfOpen(cb);
+            await cb.call(() => { throw new Error('fail'); }).catch(() => {});
+            expect(cb.getState()).toBe(OPEN);
+        });
+    });
+
+    describe('fallback', () => {
+        it('returns fallback on failure in CLOSED state', async () => {
+            const cb = makeBreaker({ failureThreshold: 10 });
+            const result = await cb.call(() => { throw new Error('fail'); }, 'default');
+            expect(result).toBe('default');
+        });
+
+        it('calls fallback function on failure', async () => {
+            const cb = makeBreaker({ failureThreshold: 10 });
+            const result = await cb.call(() => { throw new Error('fail'); }, () => 'computed');
+            expect(result).toBe('computed');
+        });
+    });
+
+    describe('events', () => {
+        it('emits stateChange when transitioning to OPEN', async () => {
+            const cb = makeBreaker({ failureThreshold: 1 });
+            const listener = jest.fn();
+            cb.on('stateChange', listener);
+            await cb.call(() => { throw new Error('fail'); }).catch(() => {});
+            expect(listener).toHaveBeenCalledWith({ from: CLOSED, to: OPEN });
+        });
+
+        it('emits stateChange when transitioning to CLOSED', async () => {
+            const cb = makeBreaker({ failureThreshold: 1, successThreshold: 1 });
+            const listener = jest.fn();
+            await cb.call(() => { throw new Error('fail'); }).catch(() => {});
+            cb.nextAttempt = Date.now() - 1;
+            cb.on('stateChange', listener);
+            await cb.call(async () => 'ok');
+            expect(listener).toHaveBeenCalledWith(expect.objectContaining({ to: CLOSED }));
+        });
+    });
+
+    describe('logging', () => {
+        it('logs state transitions when logger provided', async () => {
+            const logger = { warn: jest.fn() };
+            const cb = makeBreaker({ failureThreshold: 1, logger });
+            await cb.call(() => { throw new Error('fail'); }).catch(() => {});
+            expect(logger.warn).toHaveBeenCalled();
+        });
+    });
+
+    describe('getStats', () => {
+        it('returns current stats', async () => {
+            const cb = makeBreaker();
+            const stats = cb.getStats();
+            expect(stats.state).toBe(CLOSED);
+            expect(stats.failureCount).toBe(0);
+            expect(stats.successCount).toBe(0);
+            expect(stats.nextAttempt).toBeNull();
+        });
+    });
+});

package/backend/src/core/infrastructure/__tests__/ConnectionPool.test.js

@@ -0,0 +1,146 @@
+const ConnectionPool = require('../ConnectionPool');
+const { ExternalServiceError } = require('../../errors/index');
+
+function makeFactory(failCreate = false) {
+    let id = 0;
+    return {
+        create: jest.fn(async () => {
+            if (failCreate) throw new Error('create failed');
+            return { id: ++id };
+        }),
+        destroy: jest.fn(async () => {}),
+    };
+}
+
+describe('ConnectionPool', () => {
+    describe('acquire', () => {
+        it('creates a new connection when pool is empty', async () => {
+            const factory = makeFactory();
+            const pool = new ConnectionPool({ factory, min: 0, max: 5 });
+            const conn = await pool.acquire();
+            expect(conn).toBeDefined();
+            expect(factory.create).toHaveBeenCalledTimes(1);
+        });
+
+        it('returns idle connection without creating a new one', async () => {
+            const factory = makeFactory();
+            const pool = new ConnectionPool({ factory, min: 0, max: 5 });
+            const conn = await pool.acquire();
+            pool.release(conn);
+            const conn2 = await pool.acquire();
+            expect(conn2).toBe(conn);
+            expect(factory.create).toHaveBeenCalledTimes(1);
+        });
+
+        it('queues request when pool is at max capacity', async () => {
+            const factory = makeFactory();
+            const pool = new ConnectionPool({ factory, min: 0, max: 1 });
+            const conn1 = await pool.acquire();
+            const pending = pool.acquire();
+            expect(pool.getStats().pending).toBe(1);
+            pool.release(conn1);
+            const conn2 = await pending;
+            expect(conn2).toBe(conn1);
+        });
+
+        it('throws ExternalServiceError on timeout', async () => {
+            const factory = makeFactory();
+            const pool = new ConnectionPool({ factory, min: 0, max: 1, acquireTimeout: 50 });
+            await pool.acquire();
+            await expect(pool.acquire()).rejects.toBeInstanceOf(ExternalServiceError);
+        });
+
+        it('throws ExternalServiceError when factory.create fails', async () => {
+            const factory = makeFactory(true);
+            const pool = new ConnectionPool({ factory, min: 0, max: 5 });
+            await expect(pool.acquire()).rejects.toBeInstanceOf(ExternalServiceError);
+            expect(pool.getStats().total).toBe(0);
+        });
+    });
+
+    describe('release', () => {
+        it('returns connection to idle pool when no queue', async () => {
+            const factory = makeFactory();
+            const pool = new ConnectionPool({ factory, min: 0, max: 5 });
+            const conn = await pool.acquire();
+            pool.release(conn);
+            expect(pool.getStats().idle).toBe(1);
+        });
+
+        it('passes connection directly to next queued waiter', async () => {
+            const factory = makeFactory();
+            const pool = new ConnectionPool({ factory, min: 0, max: 1 });
+            const conn = await pool.acquire();
+            const waiterPromise = pool.acquire();
+            pool.release(conn);
+            const waiterConn = await waiterPromise;
+            expect(waiterConn).toBe(conn);
+            expect(pool.getStats().idle).toBe(0);
+        });
+    });
+
+    describe('destroy', () => {
+        it('destroys all idle connections', async () => {
+            const factory = makeFactory();
+            const pool = new ConnectionPool({ factory, min: 0, max: 5 });
+            const conn = await pool.acquire();
+            pool.release(conn);
+            await pool.destroy();
+            expect(factory.destroy).toHaveBeenCalledWith(conn);
+            expect(pool.getStats().total).toBe(0);
+            expect(pool.getStats().idle).toBe(0);
+        });
+
+        it('rejects pending queue entries on destroy', async () => {
+            const factory = makeFactory();
+            const pool = new ConnectionPool({ factory, min: 0, max: 1 });
+            await pool.acquire();
+            const pending = pool.acquire();
+            await pool.destroy();
+            await expect(pending).rejects.toBeInstanceOf(ExternalServiceError);
+        });
+    });
+
+    describe('getStats', () => {
+        it('returns correct stats', async () => {
+            const factory = makeFactory();
+            const pool = new ConnectionPool({ factory, min: 0, max: 5 });
+            const conn = await pool.acquire();
+            const stats = pool.getStats();
+            expect(stats.total).toBe(1);
+            expect(stats.idle).toBe(0);
+            expect(stats.pending).toBe(0);
+            expect(stats.utilization).toBe(1);
+            pool.release(conn);
+        });
+
+        it('logs warning when utilization exceeds 0.8', async () => {
+            const factory = makeFactory();
+            const logger = { warn: jest.fn() };
+            const pool = new ConnectionPool({ factory, min: 0, max: 5, logger });
+            const conns = await Promise.all([
+                pool.acquire(), pool.acquire(), pool.acquire(), pool.acquire(), pool.acquire(),
+            ]);
+            pool.getStats();
+            expect(logger.warn).toHaveBeenCalled();
+            conns.forEach(c => pool.release(c));
+        });
+
+        it('does not log warning when utilization is low', async () => {
+            const factory = makeFactory();
+            const logger = { warn: jest.fn() };
+            const pool = new ConnectionPool({ factory, min: 0, max: 10, logger });
+            const conn = await pool.acquire();
+            pool.release(conn);
+            pool.getStats();
+            expect(logger.warn).not.toHaveBeenCalled();
+        });
+
+        it('returns zero utilization when total is 0', () => {
+            const factory = makeFactory();
+            const pool = new ConnectionPool({ factory, min: 0, max: 5 });
+            const stats = pool.getStats();
+            expect(stats.utilization).toBe(0);
+        });
+    });
+});

package/backend/src/core/infrastructure/__tests__/RateLimiter.test.js

@@ -0,0 +1,171 @@
+const RateLimiter = require('../RateLimiter');
+
+describe('RateLimiter', () => {
+    describe('constructor defaults', () => {
+        it('uses default options when none provided', () => {
+            const limiter = new RateLimiter();
+            expect(limiter.windowMs).toBe(60000);
+            expect(limiter.max).toBe(100);
+            expect(limiter.keyPrefix).toBe('');
+        });
+
+        it('accepts custom options', () => {
+            const limiter = new RateLimiter({ windowMs: 1000, max: 5, keyPrefix: 'api' });
+            expect(limiter.windowMs).toBe(1000);
+            expect(limiter.max).toBe(5);
+            expect(limiter.keyPrefix).toBe('api');
+        });
+    });
+
+    describe('check', () => {
+        it('allows requests under the limit', () => {
+            const limiter = new RateLimiter({ windowMs: 60000, max: 3 });
+            const result = limiter.check('user1');
+            expect(result.allowed).toBe(true);
+            expect(result.remaining).toBe(2);
+        });
+
+        it('tracks remaining count correctly across multiple requests', () => {
+            const limiter = new RateLimiter({ windowMs: 60000, max: 3 });
+            limiter.check('user1');
+            limiter.check('user1');
+            const result = limiter.check('user1');
+            expect(result.allowed).toBe(true);
+            expect(result.remaining).toBe(0);
+        });
+
+        it('blocks request when limit is exceeded', () => {
+            const limiter = new RateLimiter({ windowMs: 60000, max: 2 });
+            limiter.check('user1');
+            limiter.check('user1');
+            const result = limiter.check('user1');
+            expect(result.allowed).toBe(false);
+            expect(result.remaining).toBe(0);
+        });
+
+        it('returns retryAfter when blocked', () => {
+            const limiter = new RateLimiter({ windowMs: 60000, max: 1 });
+            limiter.check('user1');
+            const result = limiter.check('user1');
+            expect(result.allowed).toBe(false);
+            expect(result.retryAfter).toBeGreaterThan(0);
+            expect(result.retryAfter).toBeLessThanOrEqual(60);
+        });
+
+        it('does not include retryAfter when allowed', () => {
+            const limiter = new RateLimiter({ windowMs: 60000, max: 5 });
+            const result = limiter.check('user1');
+            expect(result.retryAfter).toBeUndefined();
+        });
+
+        it('returns resetAt as a future timestamp', () => {
+            const limiter = new RateLimiter({ windowMs: 60000, max: 5 });
+            const before = Date.now();
+            const result = limiter.check('user1');
+            expect(result.resetAt).toBeGreaterThan(before);
+        });
+
+        it('isolates counts per key', () => {
+            const limiter = new RateLimiter({ windowMs: 60000, max: 2 });
+            limiter.check('user1');
+            limiter.check('user1');
+            const result = limiter.check('user2');
+            expect(result.allowed).toBe(true);
+            expect(result.remaining).toBe(1);
+        });
+
+        it('slides the window and allows requests after old ones expire', () => {
+            jest.useFakeTimers();
+            const limiter = new RateLimiter({ windowMs: 1000, max: 2 });
+            limiter.check('user1');
+            limiter.check('user1');
+            expect(limiter.check('user1').allowed).toBe(false);
+            jest.advanceTimersByTime(1001);
+            expect(limiter.check('user1').allowed).toBe(true);
+            jest.useRealTimers();
+        });
+    });
+
+    describe('reset', () => {
+        it('clears the counter for a key', () => {
+            const limiter = new RateLimiter({ windowMs: 60000, max: 2 });
+            limiter.check('user1');
+            limiter.check('user1');
+            limiter.reset('user1');
+            const result = limiter.check('user1');
+            expect(result.allowed).toBe(true);
+            expect(result.remaining).toBe(1);
+        });
+
+        it('handles reset on non-existent key without error', () => {
+            const limiter = new RateLimiter({ windowMs: 60000, max: 5 });
+            expect(() => limiter.reset('nonexistent')).not.toThrow();
+        });
+    });
+
+    describe('middleware', () => {
+        function makeReqRes(ip = '127.0.0.1', user = null) {
+            const headers = {};
+            const res = {
+                set: jest.fn((k, v) => { headers[k] = v; }),
+                status: jest.fn().mockReturnThis(),
+                json: jest.fn(),
+                _headers: headers,
+            };
+            const req = { ip, user };
+            return { req, res };
+        }
+
+        it('calls next() when request is allowed', () => {
+            const limiter = new RateLimiter({ windowMs: 60000, max: 5 });
+            const { req, res } = makeReqRes();
+            const next = jest.fn();
+            limiter.middleware()(req, res, next);
+            expect(next).toHaveBeenCalled();
+        });
+
+        it('sets rate limit headers on allowed request', () => {
+            const limiter = new RateLimiter({ windowMs: 60000, max: 5 });
+            const { req, res } = makeReqRes();
+            const next = jest.fn();
+            limiter.middleware()(req, res, next);
+            expect(res.set).toHaveBeenCalledWith('X-RateLimit-Limit', '5');
+            expect(res.set).toHaveBeenCalledWith('X-RateLimit-Remaining', '4');
+            expect(res.set).toHaveBeenCalledWith('X-RateLimit-Reset', expect.any(String));
+        });
+
+        it('returns 429 when limit exceeded', () => {
+            const limiter = new RateLimiter({ windowMs: 60000, max: 1 });
+            const { req, res } = makeReqRes();
+            const next = jest.fn();
+            limiter.middleware()(req, res, next);
+            limiter.middleware()(req, res, next);
+            expect(res.status).toHaveBeenCalledWith(429);
+            expect(res.json).toHaveBeenCalledWith(
+                expect.objectContaining({ error: 'errors.rateLimit.exceeded', retryAfter: expect.any(Number) })
+            );
+        });
+
+        it('uses req.user.id as key when user is present', () => {
+            const limiter = new RateLimiter({ windowMs: 60000, max: 1 });
+            const { req: req1, res: res1 } = makeReqRes('1.1.1.1', { id: 42 });
+            const { req: req2, res: res2 } = makeReqRes('2.2.2.2', { id: 42 });
+            const next = jest.fn();
+            limiter.middleware()(req1, res1, next);
+            next.mockClear();
+            limiter.middleware()(req2, res2, next);
+            expect(next).not.toHaveBeenCalled();
+        });
+
+        it('uses req.ip as key when no user', () => {
+            const limiter = new RateLimiter({ windowMs: 60000, max: 1 });
+            const { req: req1, res: res1 } = makeReqRes('1.1.1.1');
+            const { req: req2, res: res2 } = makeReqRes('2.2.2.2');
+            const next = jest.fn();
+            limiter.middleware()(req1, res1, next);
+            next.mockClear();
+            limiter.middleware()(req2, res2, next);
+            expect(next).toHaveBeenCalled();
+        });
+    });
+});

package/backend/src/core/ipc/botApiFactory.js

@@ -0,0 +1,72 @@
+const { Vec3 } = require('vec3');
+
+function createBotApi(bot, options = {}) {
+  const { enableLogging = false } = options;
+
+  return {
+    sendMessage(chatType, messageText, recipient) {
+      if (!bot || !bot.messageQueue) {
+        if (enableLogging) {
+          log('[BotApi] Bot not ready for sendMessage');
+        }
+        return;
+      }
+      bot.messageQueue.enqueue(chatType, messageText, recipient);
+    },
+
+    executeCommand(command) {
+      if (!bot || !bot.messageQueue) {
+        if (enableLogging) {
+          log('[BotApi] Bot not ready for executeCommand');
+        }
+        return;
+      }
+      bot.messageQueue.enqueue('command', command);
+    },
+
+    async lookAt(x, y, z) {
+      if (!bot) return;
+      const target = new Vec3(x, y, z);
+      await bot.lookAt(target);
+    },
+
+    async navigate(x, y, z) {
+      if (!bot || !bot.pathfinder) return;
+      const GoalBlock = require('mineflayer-pathfinder').goals.GoalBlock;
+      const goal = new GoalBlock(x, y, z);
+      await bot.pathfinder.goto(goal);
+    },
+
+    attack(entityId) {
+      if (!bot) return;
+      const entity = bot.entities[entityId];
+      if (entity) bot.attack(entity);
+    },
+
+    follow(username) {
+      if (!bot || !bot.pathfinder) return;
+      const player = bot.players[username];
+      if (player && player.entity) {
+        const GoalFollow = require('mineflayer-pathfinder').goals.GoalFollow;
+        const goal = new GoalFollow(player.entity, 3);
+        bot.pathfinder.setGoal(goal, true);
+      }
+    },
+
+    stopFollow() {
+      if (bot && bot.pathfinder) {
+        bot.pathfinder.setGoal(null);
+      }
+    },
+  };
+}
+
+function log(message) {
+  if (process.send) {
+    process.send({ type: 'log', content: message });
+  } else {
+    console.log(message);
+  }
+}
+
+module.exports = { createBotApi };

package/backend/src/core/ipc/ipcMessageTypes.js

@@ -0,0 +1,115 @@
+const MessageTypes = {
+  PLUGIN: {
+    UI_START_UPDATES: 'plugin:ui:start-updates',
+    UI_DATA: 'plugin:data',
+  },
+
+  SYSTEM: {
+    GET_PLAYER_LIST: 'system:get_player_list',
+    GET_PLAYER_LIST_RESPONSE: 'get_player_list_response',
+    GET_NEARBY_ENTITIES: 'system:get_nearby_entities',
+    GET_NEARBY_ENTITIES_RESPONSE: 'get_nearby_entities_response',
+  },
+
+  VIEWER: {
+    GET_STATE: 'viewer:get_state',
+    STATE_RESPONSE: 'viewer:state_response',
+    CONTROL: 'viewer:control',
+    CHAT: 'viewer:chat',
+    SPAWN: 'viewer:spawn',
+    HEALTH: 'viewer:health',
+    MOVE: 'viewer:move',
+    BLOCK_UPDATE: 'viewer:blockUpdate',
+  },
+
+  BOT: {
+    READY: 'bot_ready',
+    STATUS: 'status',
+    LOG: 'log',
+    STOP: 'stop',
+    START: 'start',
+    RESTART: 'restart_bot',
+    CHANGE_CREDENTIALS: 'change_credentials',
+    UPDATE_CREDENTIALS: 'update_credentials',
+    EVENT: 'event',
+  },
+
+  GRAPH: {
+    EXECUTE_EVENT_GRAPH: 'execute_event_graph',
+    EXECUTE_HANDLER: 'execute_handler',
+    EXECUTE_COMMAND_REQUEST: 'execute_command_request',
+    EXECUTE_COMMAND_RESPONSE: 'execute_command_response',
+    TRACE_COMPLETED: 'trace:completed',
+  },
+
+  DEBUG: {
+    CHECK_BREAKPOINT: 'debug:check_breakpoint',
+    BREAKPOINT_RESPONSE: 'debug:breakpoint_response',
+    CHECK_STEP_MODE: 'debug:check_step_mode',
+    STEP_RESPONSE: 'debug:step_response',
+  },
+
+  COMMAND: {
+    REGISTER: 'register_command',
+    REGISTER_TEMP: 'register_temp_command',
+    UNREGISTER_TEMP: 'unregister_temp_command',
+    VALIDATE_AND_RUN: 'validate_and_run_command',
+    HANDLE_PERMISSION_ERROR: 'handle_permission_error',
+    HANDLE_WRONG_CHAT: 'handle_wrong_chat',
+    HANDLE_COOLDOWN: 'handle_cooldown',
+    HANDLE_BLACKLIST: 'handle_blacklist',
+  },
+
+  CONFIG: {
+    RELOAD: 'config:reload',
+  },
+
+  CHAT: {
+    SEND_MESSAGE: 'send_message',
+    CHAT: 'chat',
+    ACTION: 'action',
+  },
+
+  SERVER: {
+    COMMAND: 'server_command',
+  },
+
+  PLUGINS: {
+    RELOAD: 'plugins:reload',
+  },
+
+  USER: {
+    ACTION_RESPONSE: 'user_action_response',
+    REQUEST_ACTION: 'request_user_action',
+    INVALIDATE_USER_CACHE: 'invalidate_user_cache',
+    INVALIDATE_ALL_USER_CACHE: 'invalidate_all_user_cache',
+    CREDENTIALS_OPERATION_RESPONSE: 'credentials_operation_response',
+  },
+
+  WEBSOCKET: {
+    SEND_MESSAGE: 'send_websocket_message',
+  },
+};
+
+const EventTypes = {
+  LOG: 'log',
+  EVENT: 'event',
+  BOT_READY: 'bot_ready',
+  STATUS: 'status',
+  CHAT: 'chat',
+  WHISPER: 'whisper',
+  RAW_MESSAGE: 'raw_message',
+  PLAYER_JOINED: 'playerJoined',
+  PLAYER_LEFT: 'playerLeft',
+  ENTITY_SPAWN: 'entitySpawn',
+  ENTITY_MOVED: 'entityMoved',
+  ENTITY_GONE: 'entityGone',
+  BOT_DIED: 'botDied',
+  HEALTH: 'health',
+  KICKED: 'kicked',
+  ERROR: 'error',
+  END: 'end',
+  SPAWN: 'spawn',
+};
+
+module.exports = { MessageTypes, EventTypes };