blockmine 1.24.0 → 1.27.0

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

package/backend/src/core/logging/AuditLogger.js

@@ -0,0 +1,61 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const crypto = require('crypto');
+
+const AUDIT_LOG_DIR = path.join(os.homedir(), '.blockmine', 'logs');
+const AUDIT_LOG_FILE = path.join(AUDIT_LOG_DIR, 'audit.log');
+
+class AuditLogger {
+    constructor({ logFile = AUDIT_LOG_FILE } = {}) {
+        this.logFile = logFile;
+        this._ensureDir();
+    }
+
+    _ensureDir() {
+        const dir = path.dirname(this.logFile);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+    }
+
+    log(event) {
+        const entry = {
+            timestamp: new Date().toISOString(),
+            ...event,
+        };
+
+        const line = JSON.stringify(entry);
+        const hash = crypto.createHash('sha256').update(line).digest('hex');
+        const record = JSON.stringify({ ...entry, _hash: hash }) + '\n';
+
+        try {
+            fs.appendFileSync(this.logFile, record, 'utf8');
+        } catch {}
+    }
+
+    authFailure({ userId, username, ip, reason }) {
+        this.log({ type: 'auth.failure', userId, username, ip, reason });
+    }
+
+    authSuccess({ userId, username, ip }) {
+        this.log({ type: 'auth.success', userId, username, ip });
+    }
+
+    authorizationFailure({ userId, username, resource, action, ip }) {
+        this.log({ type: 'authorization.failure', userId, username, resource, action, ip });
+    }
+
+    sensitiveAction({ userId, username, action, resource, ip }) {
+        this.log({ type: 'sensitive.action', userId, username, action, resource, ip });
+    }
+}
+
+let instance = null;
+
+function getAuditLogger() {
+    if (!instance) instance = new AuditLogger();
+    return instance;
+}
+
+module.exports = { AuditLogger, getAuditLogger };

package/backend/src/core/logging/StructuredLogger.js

@@ -0,0 +1,80 @@
+const ErrorHandler = require('../errors/ErrorHandler');
+
+const LOG_LEVELS = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+    fatal: 4,
+};
+
+class StructuredLogger {
+    constructor({ minLevel = 'info', context = {} } = {}) {
+        this.minLevel = minLevel;
+        this.context = context;
+    }
+
+    _log(level, dataOrMessage, message) {
+        if (LOG_LEVELS[level] < LOG_LEVELS[this.minLevel]) return;
+
+        let data = {};
+        let msg;
+
+        if (message !== undefined) {
+            data = typeof dataOrMessage === 'object' && dataOrMessage !== null ? dataOrMessage : {};
+            msg = message;
+        } else {
+            msg = dataOrMessage;
+        }
+
+        const sanitized = ErrorHandler.sanitize({ ...this.context, ...data });
+
+        const entry = {
+            timestamp: new Date().toISOString(),
+            level,
+            message: msg,
+            ...sanitized,
+        };
+
+        const output = JSON.stringify(entry);
+
+        if (level === 'fatal' || level === 'error') {
+            console.error(output);
+        } else if (level === 'warn') {
+            console.warn(output);
+        } else if (level === 'debug') {
+            console.debug(output);
+        } else {
+            console.info(output);
+        }
+    }
+
+    debug(dataOrMessage, message) {
+        this._log('debug', dataOrMessage, message);
+    }
+
+    info(dataOrMessage, message) {
+        this._log('info', dataOrMessage, message);
+    }
+
+    warn(dataOrMessage, message) {
+        this._log('warn', dataOrMessage, message);
+    }
+
+    error(dataOrMessage, message) {
+        this._log('error', dataOrMessage, message);
+    }
+
+    fatal(dataOrMessage, message) {
+        this._log('fatal', dataOrMessage, message);
+    }
+
+    child(context) {
+        return new StructuredLogger({
+            minLevel: this.minLevel,
+            context: ErrorHandler.sanitize({ ...this.context, ...context }),
+        });
+    }
+}
+
+module.exports = StructuredLogger;

package/backend/src/core/logging/__tests__/StructuredLogger.test.js

@@ -0,0 +1,213 @@
+const StructuredLogger = require('../StructuredLogger');
+
+describe('StructuredLogger', () => {
+    let logger;
+
+    beforeEach(() => {
+        logger = new StructuredLogger({ minLevel: 'debug' });
+    });
+
+    describe('log output structure', () => {
+        it('includes timestamp, level, and message in every log entry', () => {
+            const output = [];
+            jest.spyOn(console, 'info').mockImplementation((msg) => output.push(JSON.parse(msg)));
+
+            logger.info('test message');
+
+            expect(output).toHaveLength(1);
+            expect(output[0]).toMatchObject({
+                level: 'info',
+                message: 'test message',
+            });
+            expect(output[0].timestamp).toMatch(/^\d{4}-\d{2}-\d{2}T/);
+        });
+
+        it('accepts (data, message) signature and merges data into entry', () => {
+            const output = [];
+            jest.spyOn(console, 'info').mockImplementation((msg) => output.push(JSON.parse(msg)));
+
+            logger.info({ botId: 'bot-1', userId: 'user-1', requestId: 'req-1' }, 'with context');
+
+            expect(output[0]).toMatchObject({
+                level: 'info',
+                message: 'with context',
+                botId: 'bot-1',
+                userId: 'user-1',
+                requestId: 'req-1',
+            });
+        });
+
+        it('accepts (message) signature without data', () => {
+            const output = [];
+            jest.spyOn(console, 'info').mockImplementation((msg) => output.push(JSON.parse(msg)));
+
+            logger.info('simple message');
+
+            expect(output[0].message).toBe('simple message');
+        });
+    });
+
+    describe('log levels', () => {
+        it('calls console.debug for debug level', () => {
+            const spy = jest.spyOn(console, 'debug').mockImplementation(() => {});
+            logger.debug('debug msg');
+            expect(spy).toHaveBeenCalled();
+        });
+
+        it('calls console.info for info level', () => {
+            const spy = jest.spyOn(console, 'info').mockImplementation(() => {});
+            logger.info('info msg');
+            expect(spy).toHaveBeenCalled();
+        });
+
+        it('calls console.warn for warn level', () => {
+            const spy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+            logger.warn('warn msg');
+            expect(spy).toHaveBeenCalled();
+        });
+
+        it('calls console.error for error level', () => {
+            const spy = jest.spyOn(console, 'error').mockImplementation(() => {});
+            logger.error('error msg');
+            expect(spy).toHaveBeenCalled();
+        });
+
+        it('calls console.error for fatal level', () => {
+            const spy = jest.spyOn(console, 'error').mockImplementation(() => {});
+            logger.fatal('fatal msg');
+            expect(spy).toHaveBeenCalled();
+        });
+    });
+
+    describe('minimum log level filtering', () => {
+        it('suppresses messages below the configured minimum level', () => {
+            const warnLogger = new StructuredLogger({ minLevel: 'warn' });
+            const spy = jest.spyOn(console, 'info').mockImplementation(() => {});
+            const debugSpy = jest.spyOn(console, 'debug').mockImplementation(() => {});
+
+            warnLogger.info('should be suppressed');
+            warnLogger.debug('should be suppressed');
+
+            expect(spy).not.toHaveBeenCalled();
+            expect(debugSpy).not.toHaveBeenCalled();
+        });
+
+        it('outputs messages at or above the minimum level', () => {
+            const warnLogger = new StructuredLogger({ minLevel: 'warn' });
+            const warnSpy = jest.spyOn(console, 'warn').mockImplementation(() => {});
+            const errorSpy = jest.spyOn(console, 'error').mockImplementation(() => {});
+
+            warnLogger.warn('warn passes');
+            warnLogger.error('error passes');
+            warnLogger.fatal('fatal passes');
+
+            expect(warnSpy).toHaveBeenCalledTimes(1);
+            expect(errorSpy).toHaveBeenCalledTimes(2);
+        });
+
+        it('defaults to info level', () => {
+            const defaultLogger = new StructuredLogger();
+            const debugSpy = jest.spyOn(console, 'debug').mockImplementation(() => {});
+            const infoSpy = jest.spyOn(console, 'info').mockImplementation(() => {});
+
+            defaultLogger.debug('suppressed');
+            defaultLogger.info('passes');
+
+            expect(debugSpy).not.toHaveBeenCalled();
+            expect(infoSpy).toHaveBeenCalledTimes(1);
+        });
+    });
+
+    describe('sensitive data redaction', () => {
+        it('redacts password fields', () => {
+            const output = [];
+            jest.spyOn(console, 'info').mockImplementation((msg) => output.push(JSON.parse(msg)));
+
+            logger.info({ password: 'secret123', userId: 'u1' }, 'login attempt');
+
+            expect(output[0].password).toBe('[REDACTED]');
+            expect(output[0].userId).toBe('u1');
+        });
+
+        it('redacts token fields', () => {
+            const output = [];
+            jest.spyOn(console, 'info').mockImplementation((msg) => output.push(JSON.parse(msg)));
+
+            logger.info({ token: 'abc123', botId: 'b1' }, 'token check');
+
+            expect(output[0].token).toBe('[REDACTED]');
+            expect(output[0].botId).toBe('b1');
+        });
+
+        it('redacts apiKey fields', () => {
+            const output = [];
+            jest.spyOn(console, 'info').mockImplementation((msg) => output.push(JSON.parse(msg)));
+
+            logger.info({ apiKey: 'key-xyz' }, 'api call');
+
+            expect(output[0].apiKey).toBe('[REDACTED]');
+        });
+    });
+
+    describe('child logger', () => {
+        it('creates a child logger with pre-bound context', () => {
+            const output = [];
+            jest.spyOn(console, 'info').mockImplementation((msg) => output.push(JSON.parse(msg)));
+
+            const child = logger.child({ botId: 'bot-42', requestId: 'req-99' });
+            child.info('child message');
+
+            expect(output[0]).toMatchObject({
+                botId: 'bot-42',
+                requestId: 'req-99',
+                message: 'child message',
+            });
+        });
+
+        it('child context is merged with per-call data', () => {
+            const output = [];
+            jest.spyOn(console, 'info').mockImplementation((msg) => output.push(JSON.parse(msg)));
+
+            const child = logger.child({ botId: 'bot-1' });
+            child.info({ userId: 'user-5' }, 'merged');
+
+            expect(output[0]).toMatchObject({
+                botId: 'bot-1',
+                userId: 'user-5',
+                message: 'merged',
+            });
+        });
+
+        it('child inherits parent minLevel', () => {
+            const parent = new StructuredLogger({ minLevel: 'error' });
+            const child = parent.child({ botId: 'b1' });
+            const spy = jest.spyOn(console, 'info').mockImplementation(() => {});
+
+            child.info('should be suppressed');
+
+            expect(spy).not.toHaveBeenCalled();
+        });
+
+        it('redacts sensitive fields in child context', () => {
+            const child = logger.child({ token: 'secret-token', botId: 'b1' });
+            const output = [];
+            jest.spyOn(console, 'info').mockImplementation((msg) => output.push(JSON.parse(msg)));
+
+            child.info('check redaction');
+
+            expect(output[0].token).toBe('[REDACTED]');
+            expect(output[0].botId).toBe('b1');
+        });
+    });
+
+    describe('output format', () => {
+        it('outputs valid JSON', () => {
+            const rawOutput = [];
+            jest.spyOn(console, 'info').mockImplementation((msg) => rawOutput.push(msg));
+
+            logger.info({ botId: 'b1' }, 'json check');
+
+            expect(() => JSON.parse(rawOutput[0])).not.toThrow();
+        });
+    });
+});

package/backend/src/core/logging/index.js

@@ -0,0 +1,7 @@
+const StructuredLogger = require('./StructuredLogger');
+
+const defaultLogger = new StructuredLogger({
+    minLevel: process.env.LOG_LEVEL || 'info',
+});
+
+module.exports = { StructuredLogger, defaultLogger };

package/backend/src/core/metrics/MetricsCollector.js

@@ -0,0 +1,104 @@
+class MetricsCollector {
+    constructor() {
+        this._counters = new Map();
+        this._histograms = new Map();
+        this._gauges = new Map();
+    }
+
+    incrementCounter(name, labels = {}, value = 1) {
+        const key = this._key(name, labels);
+        this._counters.set(key, { name, labels, value: (this._counters.get(key)?.value || 0) + value });
+    }
+
+    recordDuration(name, durationMs, labels = {}) {
+        const key = this._key(name, labels);
+        const existing = this._histograms.get(key) || { name, labels, count: 0, sum: 0, min: Infinity, max: -Infinity, buckets: [] };
+        existing.count++;
+        existing.sum += durationMs;
+        existing.min = Math.min(existing.min, durationMs);
+        existing.max = Math.max(existing.max, durationMs);
+        existing.buckets.push(durationMs);
+        this._histograms.set(key, existing);
+    }
+
+    setGauge(name, value, labels = {}) {
+        const key = this._key(name, labels);
+        this._gauges.set(key, { name, labels, value });
+    }
+
+    getCounter(name, labels = {}) {
+        return this._counters.get(this._key(name, labels))?.value || 0;
+    }
+
+    getHistogram(name, labels = {}) {
+        const h = this._histograms.get(this._key(name, labels));
+        if (!h) return null;
+        const avg = h.count > 0 ? h.sum / h.count : 0;
+        const p50 = this._percentile(h.buckets, 50);
+        const p95 = this._percentile(h.buckets, 95);
+        const p99 = this._percentile(h.buckets, 99);
+        return { count: h.count, sum: h.sum, min: h.min, max: h.max, avg, p50, p95, p99 };
+    }
+
+    getGauge(name, labels = {}) {
+        return this._gauges.get(this._key(name, labels))?.value ?? null;
+    }
+
+    reset() {
+        this._counters.clear();
+        this._histograms.clear();
+        this._gauges.clear();
+    }
+
+    toPrometheus() {
+        const lines = [];
+
+        for (const { name, labels, value } of this._counters.values()) {
+            lines.push(`# TYPE ${name} counter`);
+            lines.push(`${name}${this._labelsStr(labels)} ${value}`);
+        }
+
+        for (const { name, labels, count, sum, min, max } of this._histograms.values()) {
+            lines.push(`# TYPE ${name} histogram`);
+            lines.push(`${name}_count${this._labelsStr(labels)} ${count}`);
+            lines.push(`${name}_sum${this._labelsStr(labels)} ${sum}`);
+            lines.push(`${name}_min${this._labelsStr(labels)} ${min}`);
+            lines.push(`${name}_max${this._labelsStr(labels)} ${max}`);
+        }
+
+        for (const { name, labels, value } of this._gauges.values()) {
+            lines.push(`# TYPE ${name} gauge`);
+            lines.push(`${name}${this._labelsStr(labels)} ${value}`);
+        }
+
+        return lines.join('\n');
+    }
+
+    _key(name, labels) {
+        const labelStr = Object.entries(labels).sort(([a], [b]) => a.localeCompare(b)).map(([k, v]) => `${k}="${v}"`).join(',');
+        return labelStr ? `${name}{${labelStr}}` : name;
+    }
+
+    _labelsStr(labels) {
+        const entries = Object.entries(labels);
+        if (entries.length === 0) return '';
+        const parts = entries.map(([k, v]) => `${k}="${v}"`).join(',');
+        return `{${parts}}`;
+    }
+
+    _percentile(values, p) {
+        if (values.length === 0) return 0;
+        const sorted = [...values].sort((a, b) => a - b);
+        const idx = Math.ceil((p / 100) * sorted.length) - 1;
+        return sorted[Math.max(0, idx)];
+    }
+}
+
+let instance = null;
+
+function getMetricsCollector() {
+    if (!instance) instance = new MetricsCollector();
+    return instance;
+}
+
+module.exports = { MetricsCollector, getMetricsCollector };