blockmine 1.25.0 → 1.27.0

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;

package/backend/src/core/domain/services/DependencyResolver.js

@@ -0,0 +1,168 @@
+const semver = require('semver');
+
+const ISSUE_TYPES = {
+    MISSING: 'missing_dependency',
+    DISABLED: 'disabled_dependency',
+    VERSION_MISMATCH: 'version_mismatch',
+    CIRCULAR: 'circular_dependency',
+};
+
+class DependencyResolver {
+    resolve(enabledPlugins, allPlugins) {
+        const pluginMap = new Map(allPlugins.map(p => [p.name, p]));
+        const enabledSet = new Set(enabledPlugins.map(p => p.name));
+        const pluginInfo = {};
+        let hasCriticalIssues = false;
+
+        for (const plugin of allPlugins) {
+            const manifest = this._parseManifest(plugin.manifest);
+            pluginInfo[plugin.id] = {
+                ...plugin,
+                isEnabled: enabledSet.has(plugin.name),
+                issues: [],
+                dependencies: manifest.dependencies ? Object.entries(manifest.dependencies) : [],
+                optionalDependencies: manifest.optionalDependencies ? Object.entries(manifest.optionalDependencies) : [],
+            };
+        }
+
+        for (const plugin of enabledPlugins) {
+            const info = pluginInfo[plugin.id];
+
+            for (const [depName, depRange] of info.dependencies) {
+                const issue = this._checkDependency(depName, depRange, pluginMap, enabledSet, false);
+                if (issue) {
+                    info.issues.push(issue);
+                    if (issue.type !== ISSUE_TYPES.DISABLED) hasCriticalIssues = true;
+                }
+            }
+
+            for (const [depName, depRange] of info.optionalDependencies) {
+                const issue = this._checkDependency(depName, depRange, pluginMap, enabledSet, true);
+                if (issue) {
+                    info.issues.push({ ...issue, optional: true });
+                }
+            }
+        }
+
+        const { sorted, cycles } = this._topologicalSort(enabledPlugins, pluginMap, enabledSet);
+
+        for (const cycle of cycles) {
+            hasCriticalIssues = true;
+            const cyclePath = cycle.join(' -> ');
+            for (const plugin of enabledPlugins) {
+                if (cycle.includes(plugin.name)) {
+                    pluginInfo[plugin.id].issues.push({
+                        type: ISSUE_TYPES.CIRCULAR,
+                        messageKey: 'dependency.circular',
+                        context: { cyclePath },
+                    });
+                }
+            }
+        }
+
+        return { sortedPlugins: sorted, pluginInfo, hasCriticalIssues };
+    }
+
+    checkCompatibility(plugin, installedPlugins) {
+        const pluginMap = new Map(installedPlugins.map(p => [p.name, p]));
+        const manifest = this._parseManifest(plugin.manifest);
+        const deps = manifest.dependencies || {};
+        const issues = [];
+
+        for (const [depName, depRange] of Object.entries(deps)) {
+            const dep = pluginMap.get(depName);
+            if (!dep) {
+                issues.push({ type: ISSUE_TYPES.MISSING, messageKey: 'dependency.missing', context: { depName, depRange } });
+            } else if (!this._satisfies(dep.version, depRange)) {
+                const suggestion = this._suggestResolution(dep.version, depRange);
+                issues.push({ type: ISSUE_TYPES.VERSION_MISMATCH, messageKey: 'dependency.versionMismatch', context: { depName, depRange, installed: dep.version, suggestion } });
+            }
+        }
+
+        return { compatible: issues.length === 0, issues };
+    }
+
+    _checkDependency(depName, depRange, pluginMap, enabledSet, optional) {
+        const dep = pluginMap.get(depName);
+        if (!dep) {
+            return optional ? null : { type: ISSUE_TYPES.MISSING, messageKey: 'dependency.missing', context: { depName, depRange } };
+        }
+        if (!enabledSet.has(depName)) {
+            return { type: ISSUE_TYPES.DISABLED, messageKey: 'dependency.disabled', context: { depName } };
+        }
+        if (!this._satisfies(dep.version, depRange)) {
+            const suggestion = this._suggestResolution(dep.version, depRange);
+            return { type: ISSUE_TYPES.VERSION_MISMATCH, messageKey: 'dependency.versionMismatch', context: { depName, depRange, installed: dep.version, suggestion } };
+        }
+        return null;
+    }
+
+    _satisfies(version, range) {
+        try {
+            const coerced = semver.coerce(version);
+            if (!coerced) return false;
+            return semver.satisfies(coerced.version, range);
+        } catch {
+            return false;
+        }
+    }
+
+    _suggestResolution(installedVersion, requiredRange) {
+        const coerced = semver.coerce(installedVersion);
+        if (!coerced) return null;
+        const minVersion = semver.minVersion(requiredRange);
+        if (minVersion && semver.gt(minVersion.version, coerced.version)) {
+            return `dependency.suggestion.upgrade`;
+        }
+        return `dependency.suggestion.downgrade`;
+    }
+
+    _topologicalSort(enabledPlugins, pluginMap, enabledSet) {
+        const sorted = [];
+        const visited = new Set();
+        const visiting = new Set();
+        const cycles = [];
+
+        const visit = (name, path) => {
+            if (visited.has(name)) return;
+            if (visiting.has(name)) {
+                const cycleStart = path.indexOf(name);
+                cycles.push(path.slice(cycleStart).concat(name));
+                return;
+            }
+
+            visiting.add(name);
+            const plugin = pluginMap.get(name);
+            if (plugin) {
+                const manifest = this._parseManifest(plugin.manifest);
+                const deps = { ...(manifest.dependencies || {}), ...(manifest.optionalDependencies || {}) };
+                for (const depName of Object.keys(deps)) {
+                    if (enabledSet.has(depName)) {
+                        visit(depName, [...path, name]);
+                    }
+                }
+            }
+            visiting.delete(name);
+            visited.add(name);
+            if (plugin) sorted.push(plugin);
+        };
+
+        for (const plugin of enabledPlugins) {
+            visit(plugin.name, []);
+        }
+
+        return { sorted, cycles };
+    }
+
+    _parseManifest(manifest) {
+        if (!manifest) return {};
+        if (typeof manifest === 'object') return manifest;
+        try {
+            return JSON.parse(manifest);
+        } catch {
+            return {};
+        }
+    }
+}
+
+module.exports = DependencyResolver;