blockmine 1.25.0 → 1.27.0

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;

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

@@ -0,0 +1,81 @@
+const { EventEmitter } = require('events');
+const { BaseError } = require('./index');
+
+const SENSITIVE_PATTERNS = [
+    /password/i,
+    /token/i,
+    /secret/i,
+    /\bkey\b/i,
+    /authorization/i,
+    /cookie/i,
+    /apiKey/i,
+    /api_key/i,
+];
+
+class ErrorHandler extends EventEmitter {
+    constructor({ logger }) {
+        super();
+        this.logger = logger;
+    }
+
+    handle(error, context = {}) {
+        const sanitizedContext = ErrorHandler.sanitize(context);
+        const isOperational = ErrorHandler.isOperational(error);
+
+        const logEntry = {
+            botId: sanitizedContext.botId,
+            userId: sanitizedContext.userId,
+            requestId: sanitizedContext.requestId,
+            timestamp: new Date().toISOString(),
+            code: error.code,
+            statusCode: error.statusCode,
+            messageKey: error.messageKey || error.message,
+            isOperational,
+            stack: error.stack,
+            context: sanitizedContext,
+        };
+
+        if (isOperational) {
+            this.logger.warn(logEntry, 'errors.operational');
+        } else {
+            this.logger.error(logEntry, 'errors.unexpected');
+        }
+
+        this.emit('error:handled', { error, context: sanitizedContext, isOperational });
+
+        return {
+            success: false,
+            error: {
+                code: error.code || 'INTERNAL_ERROR',
+                messageKey: error.messageKey || 'errors.internal',
+                statusCode: error.statusCode || 500,
+                isOperational,
+            },
+        };
+    }
+
+    static isOperational(error) {
+        return error instanceof BaseError && error.isOperational === true;
+    }
+
+    static sanitize(data) {
+        if (data === null || data === undefined) return data;
+
+        if (typeof data !== 'object') return data;
+
+        if (Array.isArray(data)) {
+            return data.map(ErrorHandler.sanitize);
+        }
+
+        return Object.fromEntries(
+            Object.entries(data).map(([key, value]) => {
+                const isSensitive = SENSITIVE_PATTERNS.some((pattern) => pattern.test(key));
+                if (isSensitive) return [key, '[REDACTED]'];
+                if (value && typeof value === 'object') return [key, ErrorHandler.sanitize(value)];
+                return [key, value];
+            })
+        );
+    }
+}
+
+module.exports = ErrorHandler;