blockmine 1.24.0 → 1.27.0

package/backend/src/core/config/ConfigValidator.js

@@ -0,0 +1,72 @@
+const { ConfigurationError } = require('../errors');
+
+const HEX_64_REGEX = /^[0-9a-fA-F]{64}$/;
+const VALID_NODE_ENVS = ['development', 'production', 'test'];
+const VALID_LOG_LEVELS = ['debug', 'info', 'warn', 'error', 'fatal'];
+
+class ConfigValidator {
+    validate(config) {
+        const errors = [];
+
+        if (!config || typeof config !== 'object') {
+            errors.push('config.errors.config_required');
+            return { valid: false, errors };
+        }
+
+        const server = config.server || {};
+        const security = config.security || {};
+
+        if (!server.host || typeof server.host !== 'string') {
+            errors.push('config.errors.server_host_required');
+        }
+
+        const port = server.port;
+        if (port === undefined || port === null) {
+            errors.push('config.errors.server_port_required');
+        } else if (!Number.isInteger(port) || port < 1 || port > 65535) {
+            errors.push('config.errors.server_port_invalid');
+        }
+
+        if (!security.jwtSecret || typeof security.jwtSecret !== 'string') {
+            errors.push('config.errors.jwt_secret_required');
+        } else if (security.jwtSecret.length < 32) {
+            errors.push('config.errors.jwt_secret_too_short');
+        }
+
+        if (!security.encryptionKey || typeof security.encryptionKey !== 'string') {
+            errors.push('config.errors.encryption_key_required');
+        } else if (!HEX_64_REGEX.test(security.encryptionKey)) {
+            errors.push('config.errors.encryption_key_invalid');
+        }
+
+        return { valid: errors.length === 0, errors };
+    }
+
+    validateEnv() {
+        const errors = [];
+        const warnings = [];
+
+        const nodeEnv = process.env.NODE_ENV;
+        if (nodeEnv !== undefined && !VALID_NODE_ENVS.includes(nodeEnv)) {
+            errors.push('config.errors.node_env_invalid');
+        }
+
+        const logLevel = process.env.LOG_LEVEL;
+        if (logLevel !== undefined && !VALID_LOG_LEVELS.includes(logLevel)) {
+            errors.push('config.errors.log_level_invalid');
+        }
+
+        return { valid: errors.length === 0, errors, warnings };
+    }
+
+    validateAndThrow(config) {
+        const result = this.validate(config);
+        if (!result.valid) {
+            throw new ConfigurationError('config.errors.invalid_configuration', {
+                context: { errors: result.errors },
+            });
+        }
+    }
+}
+
+module.exports = ConfigValidator;

package/backend/src/core/config/FeatureFlags.js

@@ -0,0 +1,52 @@
+const DEFAULTS = {
+    useNewDependencyResolver: true,
+    useStructuredLogger: true,
+    useErrorHandler: true,
+    useInputValidation: true,
+    useRateLimiter: false,
+    useCircuitBreaker: false,
+    useMetrics: false,
+    useAuditLog: false,
+};
+
+class FeatureFlags {
+    constructor(overrides = {}) {
+        this._flags = { ...DEFAULTS, ...this._loadFromEnv(), ...overrides };
+    }
+
+    _loadFromEnv() {
+        const flags = {};
+        for (const key of Object.keys(DEFAULTS)) {
+            const envKey = `FEATURE_${key.replace(/([A-Z])/g, '_$1').toUpperCase()}`;
+            if (process.env[envKey] !== undefined) {
+                flags[key] = process.env[envKey] === 'true';
+            }
+        }
+        return flags;
+    }
+
+    isEnabled(flag) {
+        return this._flags[flag] === true;
+    }
+
+    enable(flag) {
+        this._flags[flag] = true;
+    }
+
+    disable(flag) {
+        this._flags[flag] = false;
+    }
+
+    getAll() {
+        return { ...this._flags };
+    }
+}
+
+let instance = null;
+
+function getFeatureFlags() {
+    if (!instance) instance = new FeatureFlags();
+    return instance;
+}
+
+module.exports = { FeatureFlags, getFeatureFlags };

package/backend/src/core/config/__tests__/ConfigValidator.test.js

@@ -0,0 +1,232 @@
+const ConfigValidator = require('../ConfigValidator');
+const { ConfigurationError } = require('../../errors');
+
+const VALID_CONFIG = {
+    server: {
+        host: '127.0.0.1',
+        port: 3001,
+    },
+    security: {
+        jwtSecret: 'a'.repeat(32),
+        encryptionKey: 'a'.repeat(64),
+    },
+};
+
+describe('ConfigValidator', () => {
+    let validator;
+
+    beforeEach(() => {
+        validator = new ConfigValidator();
+    });
+
+    describe('validate()', () => {
+        it('returns valid for a correct config', () => {
+            const result = validator.validate(VALID_CONFIG);
+            expect(result.valid).toBe(true);
+            expect(result.errors).toHaveLength(0);
+        });
+
+        it('returns error when config is null', () => {
+            const result = validator.validate(null);
+            expect(result.valid).toBe(false);
+            expect(result.errors).toContain('config.errors.config_required');
+        });
+
+        it('returns error when server.host is missing', () => {
+            const config = { ...VALID_CONFIG, server: { ...VALID_CONFIG.server, host: undefined } };
+            const result = validator.validate(config);
+            expect(result.valid).toBe(false);
+            expect(result.errors).toContain('config.errors.server_host_required');
+        });
+
+        it('returns error when server.host is not a string', () => {
+            const config = { ...VALID_CONFIG, server: { ...VALID_CONFIG.server, host: 123 } };
+            const result = validator.validate(config);
+            expect(result.valid).toBe(false);
+            expect(result.errors).toContain('config.errors.server_host_required');
+        });
+
+        it('returns error when server.port is missing', () => {
+            const config = { ...VALID_CONFIG, server: { host: '127.0.0.1' } };
+            const result = validator.validate(config);
+            expect(result.valid).toBe(false);
+            expect(result.errors).toContain('config.errors.server_port_required');
+        });
+
+        it('returns error when server.port is 0', () => {
+            const config = { ...VALID_CONFIG, server: { ...VALID_CONFIG.server, port: 0 } };
+            const result = validator.validate(config);
+            expect(result.valid).toBe(false);
+            expect(result.errors).toContain('config.errors.server_port_invalid');
+        });
+
+        it('returns error when server.port is 65536', () => {
+            const config = { ...VALID_CONFIG, server: { ...VALID_CONFIG.server, port: 65536 } };
+            const result = validator.validate(config);
+            expect(result.valid).toBe(false);
+            expect(result.errors).toContain('config.errors.server_port_invalid');
+        });
+
+        it('returns error when server.port is a float', () => {
+            const config = { ...VALID_CONFIG, server: { ...VALID_CONFIG.server, port: 3000.5 } };
+            const result = validator.validate(config);
+            expect(result.valid).toBe(false);
+            expect(result.errors).toContain('config.errors.server_port_invalid');
+        });
+
+        it('accepts port 1 and port 65535 as valid boundaries', () => {
+            const config1 = { ...VALID_CONFIG, server: { ...VALID_CONFIG.server, port: 1 } };
+            const config2 = { ...VALID_CONFIG, server: { ...VALID_CONFIG.server, port: 65535 } };
+            expect(validator.validate(config1).valid).toBe(true);
+            expect(validator.validate(config2).valid).toBe(true);
+        });
+
+        it('returns error when jwtSecret is missing', () => {
+            const config = { ...VALID_CONFIG, security: { ...VALID_CONFIG.security, jwtSecret: undefined } };
+            const result = validator.validate(config);
+            expect(result.valid).toBe(false);
+            expect(result.errors).toContain('config.errors.jwt_secret_required');
+        });
+
+        it('returns error when jwtSecret is shorter than 32 chars', () => {
+            const config = { ...VALID_CONFIG, security: { ...VALID_CONFIG.security, jwtSecret: 'short' } };
+            const result = validator.validate(config);
+            expect(result.valid).toBe(false);
+            expect(result.errors).toContain('config.errors.jwt_secret_too_short');
+        });
+
+        it('accepts jwtSecret of exactly 32 chars', () => {
+            const config = { ...VALID_CONFIG, security: { ...VALID_CONFIG.security, jwtSecret: 'a'.repeat(32) } };
+            expect(validator.validate(config).valid).toBe(true);
+        });
+
+        it('returns error when encryptionKey is missing', () => {
+            const config = { ...VALID_CONFIG, security: { ...VALID_CONFIG.security, encryptionKey: undefined } };
+            const result = validator.validate(config);
+            expect(result.valid).toBe(false);
+            expect(result.errors).toContain('config.errors.encryption_key_required');
+        });
+
+        it('returns error when encryptionKey is not 64 hex chars', () => {
+            const config = { ...VALID_CONFIG, security: { ...VALID_CONFIG.security, encryptionKey: 'abc123' } };
+            const result = validator.validate(config);
+            expect(result.valid).toBe(false);
+            expect(result.errors).toContain('config.errors.encryption_key_invalid');
+        });
+
+        it('returns error when encryptionKey contains non-hex chars', () => {
+            const config = { ...VALID_CONFIG, security: { ...VALID_CONFIG.security, encryptionKey: 'z'.repeat(64) } };
+            const result = validator.validate(config);
+            expect(result.valid).toBe(false);
+            expect(result.errors).toContain('config.errors.encryption_key_invalid');
+        });
+
+        it('accepts valid 64-char lowercase hex encryptionKey', () => {
+            const config = { ...VALID_CONFIG, security: { ...VALID_CONFIG.security, encryptionKey: 'deadbeef'.repeat(8) } };
+            expect(validator.validate(config).valid).toBe(true);
+        });
+
+        it('collects multiple errors at once', () => {
+            const config = { server: {}, security: {} };
+            const result = validator.validate(config);
+            expect(result.valid).toBe(false);
+            expect(result.errors.length).toBeGreaterThan(1);
+        });
+    });
+
+    describe('validateEnv()', () => {
+        const originalEnv = process.env;
+
+        beforeEach(() => {
+            process.env = { ...originalEnv };
+        });
+
+        afterEach(() => {
+            process.env = originalEnv;
+        });
+
+        it('returns valid when no optional env vars are set', () => {
+            delete process.env.NODE_ENV;
+            delete process.env.LOG_LEVEL;
+            delete process.env.DATABASE_URL;
+            delete process.env.GITHUB_TOKEN;
+            const result = validator.validateEnv();
+            expect(result.valid).toBe(true);
+            expect(result.errors).toHaveLength(0);
+            expect(result.warnings).toHaveLength(0);
+        });
+
+        it('accepts valid NODE_ENV values', () => {
+            for (const env of ['development', 'production', 'test']) {
+                process.env.NODE_ENV = env;
+                expect(validator.validateEnv().valid).toBe(true);
+            }
+        });
+
+        it('returns error for invalid NODE_ENV', () => {
+            process.env.NODE_ENV = 'staging';
+            const result = validator.validateEnv();
+            expect(result.valid).toBe(false);
+            expect(result.errors).toContain('config.errors.node_env_invalid');
+        });
+
+        it('accepts valid LOG_LEVEL values', () => {
+            for (const level of ['debug', 'info', 'warn', 'error', 'fatal']) {
+                process.env.LOG_LEVEL = level;
+                expect(validator.validateEnv().valid).toBe(true);
+            }
+        });
+
+        it('returns error for invalid LOG_LEVEL', () => {
+            process.env.LOG_LEVEL = 'verbose';
+            const result = validator.validateEnv();
+            expect(result.valid).toBe(false);
+            expect(result.errors).toContain('config.errors.log_level_invalid');
+        });
+
+        it('accepts DATABASE_URL as optional string', () => {
+            process.env.DATABASE_URL = 'file:./dev.db';
+            const result = validator.validateEnv();
+            expect(result.valid).toBe(true);
+        });
+
+        it('accepts GITHUB_TOKEN as optional string', () => {
+            process.env.GITHUB_TOKEN = 'ghp_sometoken';
+            const result = validator.validateEnv();
+            expect(result.valid).toBe(true);
+        });
+
+        it('returns result with warnings array', () => {
+            const result = validator.validateEnv();
+            expect(Array.isArray(result.warnings)).toBe(true);
+        });
+    });
+
+    describe('validateAndThrow()', () => {
+        it('does not throw for valid config', () => {
+            expect(() => validator.validateAndThrow(VALID_CONFIG)).not.toThrow();
+        });
+
+        it('throws ConfigurationError for invalid config', () => {
+            expect(() => validator.validateAndThrow(null)).toThrow(ConfigurationError);
+        });
+
+        it('throws ConfigurationError with errors in context', () => {
+            try {
+                validator.validateAndThrow({ server: {}, security: {} });
+            } catch (err) {
+                expect(err).toBeInstanceOf(ConfigurationError);
+                expect(err.context.errors).toBeDefined();
+                expect(err.context.errors.length).toBeGreaterThan(0);
+            }
+        });
+
+        it('thrown error has correct messageKey', () => {
+            try {
+                validator.validateAndThrow(null);
+            } catch (err) {
+                expect(err.messageKey).toBe('config.errors.invalid_configuration');
+            }
+        });
+    });
+});

package/backend/src/core/domain/entities/Bot.js

@@ -0,0 +1,39 @@
+class Bot {
+    constructor({ id, username, password, prefix, note, owners, serverId, proxyId, sortOrder, createdAt, updatedAt } = {}) {
+        this.id = id;
+        this.username = username;
+        this.password = password;
+        this.prefix = prefix || '@';
+        this.note = note || null;
+        this.owners = owners || '';
+        this.serverId = serverId;
+        this.proxyId = proxyId || null;
+        this.sortOrder = sortOrder || null;
+        this.createdAt = createdAt;
+        this.updatedAt = updatedAt;
+    }
+
+    getOwnerList() {
+        if (!this.owners) return [];
+        return this.owners.split(',').map(o => o.trim()).filter(Boolean);
+    }
+
+    isOwner(username) {
+        return this.getOwnerList().includes(username);
+    }
+
+    toJSON() {
+        return {
+            id: this.id,
+            username: this.username,
+            prefix: this.prefix,
+            note: this.note,
+            owners: this.owners,
+            serverId: this.serverId,
+            proxyId: this.proxyId,
+            sortOrder: this.sortOrder,
+        };
+    }
+}
+
+module.exports = Bot;

package/backend/src/core/domain/entities/Command.js

@@ -0,0 +1,41 @@
+class Command {
+    constructor({ id, botId, name, isEnabled, cooldown, aliases, description, owner, permissionId, allowedChatTypes, isVisual, argumentsJson, graphJson, pluginOwnerId } = {}) {
+        this.id = id;
+        this.botId = botId;
+        this.name = name;
+        this.isEnabled = isEnabled !== false;
+        this.cooldown = cooldown || 0;
+        this.aliases = typeof aliases === 'string' ? JSON.parse(aliases || '[]') : (aliases || []);
+        this.description = description || null;
+        this.owner = owner || null;
+        this.permissionId = permissionId || null;
+        this.allowedChatTypes = typeof allowedChatTypes === 'string' ? JSON.parse(allowedChatTypes || '["chat","private"]') : (allowedChatTypes || ['chat', 'private']);
+        this.isVisual = isVisual || false;
+        this.arguments = typeof argumentsJson === 'string' ? JSON.parse(argumentsJson || '[]') : (argumentsJson || []);
+        this.graphJson = graphJson || null;
+        this.pluginOwnerId = pluginOwnerId || null;
+    }
+
+    isAllowedInChat(chatType) {
+        return this.allowedChatTypes.includes(chatType);
+    }
+
+    hasCooldown() {
+        return this.cooldown > 0;
+    }
+
+    toJSON() {
+        return {
+            id: this.id,
+            botId: this.botId,
+            name: this.name,
+            isEnabled: this.isEnabled,
+            cooldown: this.cooldown,
+            aliases: this.aliases,
+            description: this.description,
+            allowedChatTypes: this.allowedChatTypes,
+        };
+    }
+}
+
+module.exports = Command;

package/backend/src/core/domain/entities/EventGraph.js

@@ -0,0 +1,39 @@
+class EventGraph {
+    constructor({ id, botId, name, isEnabled, graphJson, variables, pluginOwnerId, createdAt, updatedAt } = {}) {
+        this.id = id;
+        this.botId = botId;
+        this.name = name;
+        this.isEnabled = isEnabled !== false;
+        this.graphJson = graphJson || null;
+        this.variables = typeof variables === 'string' ? JSON.parse(variables || '[]') : (variables || []);
+        this.pluginOwnerId = pluginOwnerId || null;
+        this.createdAt = createdAt;
+        this.updatedAt = updatedAt;
+    }
+
+    getParsedGraph() {
+        if (!this.graphJson || this.graphJson === 'null') return null;
+        if (typeof this.graphJson === 'object') return this.graphJson;
+        try {
+            return JSON.parse(this.graphJson);
+        } catch {
+            return null;
+        }
+    }
+
+    isOwnedByPlugin() {
+        return this.pluginOwnerId !== null;
+    }
+
+    toJSON() {
+        return {
+            id: this.id,
+            botId: this.botId,
+            name: this.name,
+            isEnabled: this.isEnabled,
+            pluginOwnerId: this.pluginOwnerId,
+        };
+    }
+}
+
+module.exports = EventGraph;

package/backend/src/core/domain/entities/Plugin.js

@@ -0,0 +1,45 @@
+class Plugin {
+    constructor({ id, botId, name, version, description, sourceType, sourceUri, sourceRefType, sourceRef, path, isEnabled, manifest, settings, createdAt } = {}) {
+        this.id = id;
+        this.botId = botId;
+        this.name = name;
+        this.version = version;
+        this.description = description || '';
+        this.sourceType = sourceType;
+        this.sourceUri = sourceUri || null;
+        this.sourceRefType = sourceRefType || null;
+        this.sourceRef = sourceRef || null;
+        this.path = path;
+        this.isEnabled = isEnabled !== false;
+        this.manifest = typeof manifest === 'string' ? JSON.parse(manifest || '{}') : (manifest || {});
+        this.settings = typeof settings === 'string' ? JSON.parse(settings || '{}') : (settings || {});
+        this.createdAt = createdAt;
+    }
+
+    getDependencies() {
+        return this.manifest.dependencies || {};
+    }
+
+    isLocal() {
+        return this.sourceType === 'LOCAL' || this.sourceType === 'LOCAL_IDE';
+    }
+
+    isGithub() {
+        return this.sourceType === 'GITHUB';
+    }
+
+    toJSON() {
+        return {
+            id: this.id,
+            botId: this.botId,
+            name: this.name,
+            version: this.version,
+            description: this.description,
+            sourceType: this.sourceType,
+            sourceUri: this.sourceUri,
+            isEnabled: this.isEnabled,
+        };
+    }
+}
+
+module.exports = Plugin;

package/backend/src/core/domain/entities/User.js

@@ -0,0 +1,40 @@
+class User {
+    constructor({ id, username, isBlacklisted, botId, groups } = {}) {
+        this.id = id;
+        this.username = username;
+        this.isBlacklisted = isBlacklisted || false;
+        this.botId = botId;
+        this.groups = groups || [];
+    }
+
+    hasPermission(permissionName) {
+        for (const group of this.groups) {
+            const perms = group.permissions || [];
+            for (const perm of perms) {
+                const name = perm.name || perm;
+                if (name === permissionName) return true;
+                if (name.endsWith('.*')) {
+                    const prefix = name.slice(0, -2);
+                    if (permissionName.startsWith(prefix)) return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    getGroupNames() {
+        return this.groups.map(g => g.name || g);
+    }
+
+    toJSON() {
+        return {
+            id: this.id,
+            username: this.username,
+            isBlacklisted: this.isBlacklisted,
+            botId: this.botId,
+            groups: this.getGroupNames(),
+        };
+    }
+}
+
+module.exports = User;