blockmine 1.24.0 → 1.27.0

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

@@ -0,0 +1,86 @@
+const BatchingUtility = require('../BatchingUtility');
+
+describe('BatchingUtility', () => {
+    afterEach(() => {
+        jest.useRealTimers();
+    });
+
+    it('executes operations and resolves promises', async () => {
+        const batcher = new BatchingUtility({ windowMs: 50 });
+        const p = batcher.add(() => 42);
+        await batcher.flush();
+        expect(await p).toBe(42);
+    });
+
+    it('batches multiple operations within window', async () => {
+        jest.useFakeTimers();
+        const order = [];
+        const batcher = new BatchingUtility({ windowMs: 100 });
+
+        const p1 = batcher.add(() => { order.push(1); return 1; });
+        const p2 = batcher.add(() => { order.push(2); return 2; });
+        const p3 = batcher.add(() => { order.push(3); return 3; });
+
+        await batcher.flush();
+
+        expect(order).toEqual([1, 2, 3]);
+        expect(await p1).toBe(1);
+        expect(await p2).toBe(2);
+        expect(await p3).toBe(3);
+    });
+
+    it('flushes immediately when maxSize is reached', async () => {
+        const batcher = new BatchingUtility({ windowMs: 10000, maxSize: 2 });
+        const results = [];
+        const p1 = batcher.add(() => results.push(1));
+        const p2 = batcher.add(() => results.push(2));
+        await Promise.all([p1, p2]);
+        expect(results).toEqual([1, 2]);
+    });
+
+    it('preserves operation order', async () => {
+        const batcher = new BatchingUtility({ windowMs: 50 });
+        const order = [];
+        batcher.add(() => order.push('a'));
+        batcher.add(() => order.push('b'));
+        batcher.add(() => order.push('c'));
+        await batcher.flush();
+        expect(order).toEqual(['a', 'b', 'c']);
+    });
+
+    it('rejects promise when operation throws', async () => {
+        const batcher = new BatchingUtility({ windowMs: 50 });
+        const p = batcher.add(() => { throw new Error('fail'); });
+        await batcher.flush();
+        await expect(p).rejects.toThrow('fail');
+    });
+
+    it('handles mixed success and failure in same batch', async () => {
+        const batcher = new BatchingUtility({ windowMs: 50 });
+        const p1 = batcher.add(() => 'ok');
+        const p2 = batcher.add(() => { throw new Error('fail'); });
+        const p3 = batcher.add(() => 'also ok');
+        await batcher.flush();
+        expect(await p1).toBe('ok');
+        await expect(p2).rejects.toThrow('fail');
+        expect(await p3).toBe('also ok');
+    });
+
+    it('getPendingCount returns correct count', () => {
+        jest.useFakeTimers();
+        const batcher = new BatchingUtility({ windowMs: 1000 });
+        batcher.add(() => 1);
+        batcher.add(() => 2);
+        expect(batcher.getPendingCount()).toBe(2);
+    });
+
+    it('destroy rejects all pending operations', async () => {
+        jest.useFakeTimers();
+        const batcher = new BatchingUtility({ windowMs: 1000 });
+        const p1 = batcher.add(() => 1);
+        const p2 = batcher.add(() => 2);
+        batcher.destroy();
+        await expect(p1).rejects.toThrow();
+        await expect(p2).rejects.toThrow();
+    });
+});

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 };