blockmine 1.24.0 → 1.27.0

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;

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

@@ -0,0 +1,117 @@
+const MALICIOUS_PATTERNS = [
+    /require\s*\(/,
+    /process\s*\./,
+    /eval\s*\(/,
+    /Function\s*\(/,
+    /__proto__/,
+    /constructor\s*\[/,
+];
+
+class GraphValidator {
+    validate(graph) {
+        const errors = [];
+
+        if (!graph || typeof graph !== 'object') {
+            return { valid: false, errors: ['graph.errors.invalidType'] };
+        }
+
+        if (!Array.isArray(graph.nodes)) {
+            errors.push('graph.errors.missingNodes');
+        }
+
+        if (!Array.isArray(graph.connections)) {
+            errors.push('graph.errors.missingConnections');
+        }
+
+        if (errors.length > 0) {
+            return { valid: false, errors };
+        }
+
+        const nodeIds = new Set();
+        for (const node of graph.nodes) {
+            if (!node.id || typeof node.id !== 'string') {
+                errors.push('graph.errors.nodeInvalidId');
+                continue;
+            }
+            if (nodeIds.has(node.id)) {
+                errors.push('graph.errors.nodeDuplicateId');
+            }
+            nodeIds.add(node.id);
+
+            if (!node.type || typeof node.type !== 'string') {
+                errors.push('graph.errors.nodeInvalidType');
+            }
+
+            if (this._hasMaliciousContent(node)) {
+                errors.push('graph.errors.nodeMaliciousContent');
+            }
+        }
+
+        for (const conn of graph.connections) {
+            if (!conn.sourceNodeId || !conn.targetNodeId) {
+                errors.push('graph.errors.connectionInvalidNodes');
+                continue;
+            }
+            if (!nodeIds.has(conn.sourceNodeId)) {
+                errors.push('graph.errors.connectionSourceNotFound');
+            }
+            if (!nodeIds.has(conn.targetNodeId)) {
+                errors.push('graph.errors.connectionTargetNotFound');
+            }
+        }
+
+        const cycles = this._detectCycles(graph);
+        if (cycles.length > 0) {
+            errors.push('graph.errors.cycleDetected');
+        }
+
+        return { valid: errors.length === 0, errors };
+    }
+
+    _hasMaliciousContent(node) {
+        const str = JSON.stringify(node.data || {});
+        return MALICIOUS_PATTERNS.some(p => p.test(str));
+    }
+
+    _detectCycles(graph) {
+        const execConnections = graph.connections.filter(c => {
+            return true;
+        });
+
+        const adj = new Map();
+        for (const node of graph.nodes) {
+            adj.set(node.id, []);
+        }
+        for (const conn of execConnections) {
+            if (adj.has(conn.sourceNodeId)) {
+                adj.get(conn.sourceNodeId).push(conn.targetNodeId);
+            }
+        }
+
+        const visited = new Set();
+        const visiting = new Set();
+        const cycles = [];
+
+        const visit = (id) => {
+            if (visiting.has(id)) {
+                cycles.push(id);
+                return;
+            }
+            if (visited.has(id)) return;
+            visiting.add(id);
+            for (const next of (adj.get(id) || [])) {
+                visit(next);
+            }
+            visiting.delete(id);
+            visited.add(id);
+        };
+
+        for (const node of graph.nodes) {
+            visit(node.id);
+        }
+
+        return cycles;
+    }
+}
+
+module.exports = GraphValidator;

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

@@ -0,0 +1,34 @@
+class PermissionChecker {
+    check(user, permissionName) {
+        if (!user || !permissionName) return false;
+
+        const groups = user.groups || [];
+        for (const group of groups) {
+            const perms = group.permissions || [];
+            for (const perm of perms) {
+                const name = typeof perm === 'string' ? perm : perm.name;
+                if (this._matches(name, permissionName)) return true;
+            }
+        }
+        return false;
+    }
+
+    checkAny(user, permissionNames) {
+        return permissionNames.some(p => this.check(user, p));
+    }
+
+    checkAll(user, permissionNames) {
+        return permissionNames.every(p => this.check(user, p));
+    }
+
+    _matches(pattern, permission) {
+        if (pattern === permission) return true;
+        if (pattern.endsWith('.*')) {
+            const prefix = pattern.slice(0, -2);
+            return permission === prefix || permission.startsWith(prefix + '.');
+        }
+        return false;
+    }
+}
+
+module.exports = PermissionChecker;

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

@@ -0,0 +1,126 @@
+const DependencyResolver = require('../DependencyResolver');
+
+function makePlugin(name, version, deps = {}, optionalDeps = {}) {
+    return {
+        id: name,
+        name,
+        version,
+        manifest: JSON.stringify({ dependencies: deps, optionalDependencies: optionalDeps }),
+    };
+}
+
+describe('DependencyResolver', () => {
+    let resolver;
+
+    beforeEach(() => {
+        resolver = new DependencyResolver();
+    });
+
+    describe('resolve', () => {
+        it('returns empty sorted list for no plugins', () => {
+            const result = resolver.resolve([], []);
+            expect(result.sortedPlugins).toEqual([]);
+            expect(result.hasCriticalIssues).toBe(false);
+        });
+
+        it('resolves plugins with no dependencies', () => {
+            const plugins = [makePlugin('a', '1.0.0'), makePlugin('b', '2.0.0')];
+            const result = resolver.resolve(plugins, plugins);
+            expect(result.sortedPlugins).toHaveLength(2);
+            expect(result.hasCriticalIssues).toBe(false);
+        });
+
+        it('sorts plugins in dependency order', () => {
+            const a = makePlugin('a', '1.0.0');
+            const b = makePlugin('b', '1.0.0', { a: '^1.0.0' });
+            const result = resolver.resolve([a, b], [a, b]);
+            const names = result.sortedPlugins.map(p => p.name);
+            expect(names.indexOf('a')).toBeLessThan(names.indexOf('b'));
+        });
+
+        it('detects missing dependency', () => {
+            const b = makePlugin('b', '1.0.0', { a: '^1.0.0' });
+            const result = resolver.resolve([b], [b]);
+            expect(result.hasCriticalIssues).toBe(true);
+            expect(result.pluginInfo['b'].issues[0].type).toBe('missing_dependency');
+        });
+
+        it('detects disabled dependency', () => {
+            const a = makePlugin('a', '1.0.0');
+            const b = makePlugin('b', '1.0.0', { a: '^1.0.0' });
+            const result = resolver.resolve([b], [a, b]);
+            expect(result.pluginInfo['b'].issues[0].type).toBe('disabled_dependency');
+        });
+
+        it('detects version mismatch', () => {
+            const a = makePlugin('a', '0.5.0');
+            const b = makePlugin('b', '1.0.0', { a: '^1.0.0' });
+            const result = resolver.resolve([a, b], [a, b]);
+            expect(result.hasCriticalIssues).toBe(true);
+            expect(result.pluginInfo['b'].issues[0].type).toBe('version_mismatch');
+        });
+
+        it('detects circular dependency', () => {
+            const a = makePlugin('a', '1.0.0', { b: '^1.0.0' });
+            const b = makePlugin('b', '1.0.0', { a: '^1.0.0' });
+            const result = resolver.resolve([a, b], [a, b]);
+            expect(result.hasCriticalIssues).toBe(true);
+            const hasCircular = Object.values(result.pluginInfo).some(info =>
+                info.issues.some(i => i.type === 'circular_dependency')
+            );
+            expect(hasCircular).toBe(true);
+        });
+
+        it('does not flag missing optional dependency as critical', () => {
+            const b = makePlugin('b', '1.0.0', {}, { a: '^1.0.0' });
+            const result = resolver.resolve([b], [b]);
+            expect(result.hasCriticalIssues).toBe(false);
+        });
+
+        it('satisfies semver ranges ^, ~, >=', () => {
+            const a1 = makePlugin('a', '1.2.3');
+            const b1 = makePlugin('b', '1.0.0', { a: '^1.0.0' });
+            expect(resolver.resolve([a1, b1], [a1, b1]).hasCriticalIssues).toBe(false);
+
+            const a2 = makePlugin('a', '1.2.3');
+            const b2 = makePlugin('b', '1.0.0', { a: '~1.2.0' });
+            expect(resolver.resolve([a2, b2], [a2, b2]).hasCriticalIssues).toBe(false);
+
+            const a3 = makePlugin('a', '2.0.0');
+            const b3 = makePlugin('b', '1.0.0', { a: '>=1.0.0' });
+            expect(resolver.resolve([a3, b3], [a3, b3]).hasCriticalIssues).toBe(false);
+        });
+    });
+
+    describe('checkCompatibility', () => {
+        it('returns compatible when all deps satisfied', () => {
+            const a = makePlugin('a', '1.0.0');
+            const b = makePlugin('b', '1.0.0', { a: '^1.0.0' });
+            const result = resolver.checkCompatibility(b, [a]);
+            expect(result.compatible).toBe(true);
+            expect(result.issues).toHaveLength(0);
+        });
+
+        it('returns incompatible when dep missing', () => {
+            const b = makePlugin('b', '1.0.0', { a: '^1.0.0' });
+            const result = resolver.checkCompatibility(b, []);
+            expect(result.compatible).toBe(false);
+            expect(result.issues[0].type).toBe('missing_dependency');
+        });
+
+        it('returns incompatible when version mismatch', () => {
+            const a = makePlugin('a', '0.5.0');
+            const b = makePlugin('b', '1.0.0', { a: '^1.0.0' });
+            const result = resolver.checkCompatibility(b, [a]);
+            expect(result.compatible).toBe(false);
+            expect(result.issues[0].type).toBe('version_mismatch');
+        });
+
+        it('includes suggestion in version mismatch issue', () => {
+            const a = makePlugin('a', '0.5.0');
+            const b = makePlugin('b', '1.0.0', { a: '^1.0.0' });
+            const result = resolver.checkCompatibility(b, [a]);
+            expect(result.issues[0].context.suggestion).toBeDefined();
+        });
+    });
+});

package/backend/src/core/domain/valueObjects/BotConfig.js

@@ -0,0 +1,27 @@
+class BotConfig {
+    constructor(data) {
+        if (!data || typeof data !== 'object') {
+            throw new TypeError('domain.botConfig.invalidData');
+        }
+        this._data = Object.freeze({ ...data });
+    }
+
+    get id() { return this._data.id; }
+    get username() { return this._data.username; }
+    get host() { return this._data.host; }
+    get port() { return this._data.port; }
+    get version() { return this._data.version; }
+    get prefix() { return this._data.prefix || '@'; }
+    get owners() { return this._data.owners || ''; }
+    get plugins() { return this._data.plugins || []; }
+
+    with(overrides) {
+        return new BotConfig({ ...this._data, ...overrides });
+    }
+
+    toJSON() {
+        return { ...this._data };
+    }
+}
+
+module.exports = BotConfig;

package/backend/src/core/domain/valueObjects/DependencyGraph.js

@@ -0,0 +1,86 @@
+class DependencyGraph {
+    constructor() {
+        this._nodes = new Map();
+        this._edges = new Map();
+    }
+
+    addNode(name, version) {
+        this._nodes.set(name, version);
+        if (!this._edges.has(name)) {
+            this._edges.set(name, []);
+        }
+    }
+
+    addEdge(from, to, versionRange) {
+        if (!this._edges.has(from)) {
+            this._edges.set(from, []);
+        }
+        this._edges.get(from).push({ to, versionRange });
+    }
+
+    getNodes() {
+        return new Map(this._nodes);
+    }
+
+    getDependencies(name) {
+        return this._edges.get(name) || [];
+    }
+
+    hasNode(name) {
+        return this._nodes.has(name);
+    }
+
+    getVersion(name) {
+        return this._nodes.get(name) || null;
+    }
+
+    detectCycles() {
+        const visited = new Set();
+        const visiting = new Set();
+        const cycles = [];
+
+        const visit = (name, path) => {
+            if (visiting.has(name)) {
+                const cycleStart = path.indexOf(name);
+                cycles.push(path.slice(cycleStart).concat(name));
+                return;
+            }
+            if (visited.has(name)) return;
+
+            visiting.add(name);
+            for (const { to } of this.getDependencies(name)) {
+                visit(to, [...path, name]);
+            }
+            visiting.delete(name);
+            visited.add(name);
+        };
+
+        for (const name of this._nodes.keys()) {
+            visit(name, []);
+        }
+
+        return cycles;
+    }
+
+    topologicalSort() {
+        const visited = new Set();
+        const result = [];
+
+        const visit = (name) => {
+            if (visited.has(name)) return;
+            visited.add(name);
+            for (const { to } of this.getDependencies(name)) {
+                if (this._nodes.has(to)) visit(to);
+            }
+            result.push(name);
+        };
+
+        for (const name of this._nodes.keys()) {
+            visit(name);
+        }
+
+        return result;
+    }
+}
+
+module.exports = DependencyGraph;

package/backend/src/core/domain/valueObjects/PluginManifest.js

@@ -0,0 +1,36 @@
+class PluginManifest {
+    constructor(data) {
+        if (!data || typeof data !== 'object') {
+            throw new TypeError('domain.pluginManifest.invalidData');
+        }
+        this._data = Object.freeze({
+            name: data.name || '',
+            version: data.version || '0.0.0',
+            main: data.main || 'index.js',
+            description: data.description || '',
+            dependencies: Object.freeze(data.dependencies || {}),
+            settings: Object.freeze(data.settings || {}),
+        });
+    }
+
+    get name() { return this._data.name; }
+    get version() { return this._data.version; }
+    get main() { return this._data.main; }
+    get description() { return this._data.description; }
+    get dependencies() { return this._data.dependencies; }
+    get settings() { return this._data.settings; }
+
+    hasDependencies() {
+        return Object.keys(this._data.dependencies).length > 0;
+    }
+
+    getDependencyNames() {
+        return Object.keys(this._data.dependencies);
+    }
+
+    toJSON() {
+        return { ...this._data };
+    }
+}
+
+module.exports = PluginManifest;

package/backend/src/core/errors/BaseError.js

@@ -0,0 +1,29 @@
+class BaseError extends Error {
+    constructor(messageKey, { code, statusCode, context = {}, isOperational = true, cause } = {}) {
+        super(messageKey);
+        this.name = this.constructor.name;
+        this.messageKey = messageKey;
+        this.code = code;
+        this.statusCode = statusCode;
+        this.context = context;
+        this.isOperational = isOperational;
+        if (cause) this.cause = cause;
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+
+    toJSON() {
+        return {
+            name: this.name,
+            code: this.code,
+            messageKey: this.messageKey,
+            statusCode: this.statusCode,
+            context: this.context,
+            isOperational: this.isOperational,
+            stack: this.stack,
+        };
+    }
+}
+
+module.exports = BaseError;