@objectstack/core 0.9.1 → 1.0.0

package/dist/security/sandbox-runtime.js

@@ -0,0 +1,310 @@
+/**
+ * Plugin Sandbox Runtime
+ *
+ * Provides isolated execution environments for plugins with resource limits
+ * and access controls
+ */
+export class PluginSandboxRuntime {
+    constructor(logger) {
+        // Active sandboxes (pluginId -> context)
+        this.sandboxes = new Map();
+        // Resource monitoring intervals
+        this.monitoringIntervals = new Map();
+        this.logger = logger.child({ component: 'SandboxRuntime' });
+    }
+    /**
+     * Create a sandbox for a plugin
+     */
+    createSandbox(pluginId, config) {
+        if (this.sandboxes.has(pluginId)) {
+            throw new Error(`Sandbox already exists for plugin: ${pluginId}`);
+        }
+        const context = {
+            pluginId,
+            config,
+            startTime: new Date(),
+            resourceUsage: {
+                memory: { current: 0, peak: 0, limit: config.memory?.maxHeap },
+                cpu: { current: 0, average: 0, limit: config.cpu?.maxCpuPercent },
+                connections: { current: 0, limit: config.network?.maxConnections },
+            },
+        };
+        this.sandboxes.set(pluginId, context);
+        // Start resource monitoring
+        this.startResourceMonitoring(pluginId);
+        this.logger.info('Sandbox created', {
+            pluginId,
+            level: config.level,
+            memoryLimit: config.memory?.maxHeap,
+            cpuLimit: config.cpu?.maxCpuPercent
+        });
+        return context;
+    }
+    /**
+     * Destroy a sandbox
+     */
+    destroySandbox(pluginId) {
+        const context = this.sandboxes.get(pluginId);
+        if (!context) {
+            return;
+        }
+        // Stop monitoring
+        this.stopResourceMonitoring(pluginId);
+        this.sandboxes.delete(pluginId);
+        this.logger.info('Sandbox destroyed', { pluginId });
+    }
+    /**
+     * Check if resource access is allowed
+     */
+    checkResourceAccess(pluginId, resourceType, resourcePath) {
+        const context = this.sandboxes.get(pluginId);
+        if (!context) {
+            return { allowed: false, reason: 'Sandbox not found' };
+        }
+        const { config } = context;
+        switch (resourceType) {
+            case 'file':
+                return this.checkFileAccess(config, resourcePath);
+            case 'network':
+                return this.checkNetworkAccess(config, resourcePath);
+            case 'process':
+                return this.checkProcessAccess(config);
+            case 'env':
+                return this.checkEnvAccess(config, resourcePath);
+            default:
+                return { allowed: false, reason: 'Unknown resource type' };
+        }
+    }
+    /**
+     * Check file system access
+     * WARNING: Uses simple prefix matching. For production, use proper path
+     * resolution with path.resolve() and path.normalize() to prevent traversal.
+     */
+    checkFileAccess(config, path) {
+        if (config.level === 'none') {
+            return { allowed: true };
+        }
+        if (!config.filesystem) {
+            return { allowed: false, reason: 'File system access not configured' };
+        }
+        // If no path specified, check general access
+        if (!path) {
+            return { allowed: config.filesystem.mode !== 'none' };
+        }
+        // TODO: Use path.resolve() and path.normalize() for production
+        // Check allowed paths
+        const allowedPaths = config.filesystem.allowedPaths || [];
+        const isAllowed = allowedPaths.some(allowed => {
+            // Simple prefix matching - vulnerable to traversal attacks
+            // TODO: Use proper path resolution
+            return path.startsWith(allowed);
+        });
+        if (allowedPaths.length > 0 && !isAllowed) {
+            return {
+                allowed: false,
+                reason: `Path not in allowed list: ${path}`
+            };
+        }
+        // Check denied paths
+        const deniedPaths = config.filesystem.deniedPaths || [];
+        const isDenied = deniedPaths.some(denied => {
+            return path.startsWith(denied);
+        });
+        if (isDenied) {
+            return {
+                allowed: false,
+                reason: `Path is explicitly denied: ${path}`
+            };
+        }
+        return { allowed: true };
+    }
+    /**
+     * Check network access
+     * WARNING: Uses simple string matching. For production, use proper URL
+     * parsing with new URL() and check hostname property.
+     */
+    checkNetworkAccess(config, url) {
+        if (config.level === 'none') {
+            return { allowed: true };
+        }
+        if (!config.network) {
+            return { allowed: false, reason: 'Network access not configured' };
+        }
+        // Check if network access is enabled
+        if (config.network.mode === 'none') {
+            return { allowed: false, reason: 'Network access disabled' };
+        }
+        // If no URL specified, check general access
+        if (!url) {
+            return { allowed: config.network.mode !== 'none' };
+        }
+        // TODO: Use new URL() and check hostname property for production
+        // Check allowed hosts
+        const allowedHosts = config.network.allowedHosts || [];
+        if (allowedHosts.length > 0) {
+            const isAllowed = allowedHosts.some(host => {
+                // Simple string matching - vulnerable to bypass
+                // TODO: Use proper URL parsing
+                return url.includes(host);
+            });
+            if (!isAllowed) {
+                return {
+                    allowed: false,
+                    reason: `Host not in allowed list: ${url}`
+                };
+            }
+        }
+        // Check denied hosts
+        const deniedHosts = config.network.deniedHosts || [];
+        const isDenied = deniedHosts.some(host => {
+            return url.includes(host);
+        });
+        if (isDenied) {
+            return {
+                allowed: false,
+                reason: `Host is blocked: ${url}`
+            };
+        }
+        return { allowed: true };
+    }
+    /**
+     * Check process spawning access
+     */
+    checkProcessAccess(config) {
+        if (config.level === 'none') {
+            return { allowed: true };
+        }
+        if (!config.process) {
+            return { allowed: false, reason: 'Process access not configured' };
+        }
+        if (!config.process.allowSpawn) {
+            return { allowed: false, reason: 'Process spawning not allowed' };
+        }
+        return { allowed: true };
+    }
+    /**
+     * Check environment variable access
+     */
+    checkEnvAccess(config, varName) {
+        if (config.level === 'none') {
+            return { allowed: true };
+        }
+        if (!config.process) {
+            return { allowed: false, reason: 'Environment access not configured' };
+        }
+        // If no variable specified, check general access
+        if (!varName) {
+            return { allowed: true };
+        }
+        // For now, allow all env access if process is configured
+        // In a real implementation, would check specific allowed vars
+        return { allowed: true };
+    }
+    /**
+     * Check resource limits
+     */
+    checkResourceLimits(pluginId) {
+        const context = this.sandboxes.get(pluginId);
+        if (!context) {
+            return { withinLimits: true, violations: [] };
+        }
+        const violations = [];
+        const { resourceUsage, config } = context;
+        // Check memory limit
+        if (config.memory?.maxHeap &&
+            resourceUsage.memory.current > config.memory.maxHeap) {
+            violations.push(`Memory limit exceeded: ${resourceUsage.memory.current} > ${config.memory.maxHeap}`);
+        }
+        // Check CPU limit (would need runtime config)
+        if (config.runtime?.resourceLimits?.maxCpu &&
+            resourceUsage.cpu.current > config.runtime.resourceLimits.maxCpu) {
+            violations.push(`CPU limit exceeded: ${resourceUsage.cpu.current}% > ${config.runtime.resourceLimits.maxCpu}%`);
+        }
+        // Check connection limit
+        if (config.network?.maxConnections &&
+            resourceUsage.connections.current > config.network.maxConnections) {
+            violations.push(`Connection limit exceeded: ${resourceUsage.connections.current} > ${config.network.maxConnections}`);
+        }
+        return {
+            withinLimits: violations.length === 0,
+            violations,
+        };
+    }
+    /**
+     * Get resource usage for a plugin
+     */
+    getResourceUsage(pluginId) {
+        const context = this.sandboxes.get(pluginId);
+        return context?.resourceUsage;
+    }
+    /**
+     * Start monitoring resource usage
+     */
+    startResourceMonitoring(pluginId) {
+        // Monitor every 5 seconds
+        const interval = setInterval(() => {
+            this.updateResourceUsage(pluginId);
+        }, 5000);
+        this.monitoringIntervals.set(pluginId, interval);
+    }
+    /**
+     * Stop monitoring resource usage
+     */
+    stopResourceMonitoring(pluginId) {
+        const interval = this.monitoringIntervals.get(pluginId);
+        if (interval) {
+            clearInterval(interval);
+            this.monitoringIntervals.delete(pluginId);
+        }
+    }
+    /**
+     * Update resource usage statistics
+     *
+     * NOTE: Currently uses global process.memoryUsage() which tracks the entire
+     * Node.js process, not individual plugins. For production, implement proper
+     * per-plugin tracking using V8 heap snapshots or allocation tracking at
+     * plugin boundaries.
+     */
+    updateResourceUsage(pluginId) {
+        const context = this.sandboxes.get(pluginId);
+        if (!context) {
+            return;
+        }
+        // In a real implementation, this would collect actual metrics
+        // For now, this is a placeholder structure
+        // Update memory usage (global process memory - not per-plugin)
+        // TODO: Implement per-plugin memory tracking
+        const memoryUsage = process.memoryUsage();
+        context.resourceUsage.memory.current = memoryUsage.heapUsed;
+        context.resourceUsage.memory.peak = Math.max(context.resourceUsage.memory.peak, memoryUsage.heapUsed);
+        // Update CPU usage (would use process.cpuUsage() or similar)
+        // This is a placeholder - real implementation would track per-plugin CPU
+        // TODO: Implement per-plugin CPU tracking
+        context.resourceUsage.cpu.current = 0;
+        // Check for violations
+        const { withinLimits, violations } = this.checkResourceLimits(pluginId);
+        if (!withinLimits) {
+            this.logger.warn('Resource limit violations detected', {
+                pluginId,
+                violations
+            });
+        }
+    }
+    /**
+     * Get all active sandboxes
+     */
+    getAllSandboxes() {
+        return new Map(this.sandboxes);
+    }
+    /**
+     * Shutdown sandbox runtime
+     */
+    shutdown() {
+        // Stop all monitoring
+        for (const pluginId of this.monitoringIntervals.keys()) {
+            this.stopResourceMonitoring(pluginId);
+        }
+        this.sandboxes.clear();
+        this.logger.info('Sandbox runtime shutdown complete');
+    }
+}

package/dist/security/security-scanner.d.ts

@@ -0,0 +1,92 @@
+import type { SecurityVulnerability, SecurityScanResult } from '@objectstack/spec/kernel';
+import type { ObjectLogger } from '../logger.js';
+/**
+ * Scan Target
+ */
+export interface ScanTarget {
+    pluginId: string;
+    version: string;
+    files?: string[];
+    dependencies?: Record<string, string>;
+}
+/**
+ * Security Issue
+ */
+export interface SecurityIssue {
+    id: string;
+    severity: 'critical' | 'high' | 'medium' | 'low' | 'info';
+    category: 'vulnerability' | 'malware' | 'license' | 'code-quality' | 'configuration';
+    title: string;
+    description: string;
+    location?: {
+        file?: string;
+        line?: number;
+        column?: number;
+    };
+    remediation?: string;
+    cve?: string;
+    cvss?: number;
+}
+/**
+ * Plugin Security Scanner
+ *
+ * Scans plugins for security vulnerabilities, malware, and license issues
+ */
+export declare class PluginSecurityScanner {
+    private logger;
+    private vulnerabilityDb;
+    private scanResults;
+    private passThreshold;
+    constructor(logger: ObjectLogger, config?: {
+        passThreshold?: number;
+    });
+    /**
+     * Perform a comprehensive security scan on a plugin
+     */
+    scan(target: ScanTarget): Promise<SecurityScanResult>;
+    /**
+     * Scan code for vulnerabilities
+     */
+    private scanCode;
+    /**
+     * Scan dependencies for known vulnerabilities
+     */
+    private scanDependencies;
+    /**
+     * Scan for malware patterns
+     */
+    private scanMalware;
+    /**
+     * Check license compliance
+     */
+    private scanLicenses;
+    /**
+     * Check configuration security
+     */
+    private scanConfiguration;
+    /**
+     * Calculate security score based on issues
+     */
+    private calculateSecurityScore;
+    /**
+     * Add a vulnerability to the database
+     */
+    addVulnerability(packageName: string, version: string, vulnerability: SecurityVulnerability): void;
+    /**
+     * Get scan result from cache
+     */
+    getScanResult(pluginId: string, version: string): SecurityScanResult | undefined;
+    /**
+     * Clear scan results cache
+     */
+    clearCache(): void;
+    /**
+     * Update vulnerability database from external source
+     */
+    updateVulnerabilityDatabase(): Promise<void>;
+    /**
+     * Shutdown security scanner
+     */
+    shutdown(): void;
+}
+//# sourceMappingURL=security-scanner.d.ts.map

package/dist/security/security-scanner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"security-scanner.d.ts","sourceRoot":"","sources":["../../src/security/security-scanner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,qBAAqB,EACrB,kBAAkB,EACnB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACvC;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,UAAU,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,GAAG,MAAM,CAAC;IAC1D,QAAQ,EAAE,eAAe,GAAG,SAAS,GAAG,SAAS,GAAG,cAAc,GAAG,eAAe,CAAC;IACrF,KAAK,EAAE,MAAM,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,EAAE;QACT,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,MAAM,CAAC,EAAE,MAAM,CAAC;KACjB,CAAC;IACF,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;GAIG;AACH,qBAAa,qBAAqB;IAChC,OAAO,CAAC,MAAM,CAAe;IAG7B,OAAO,CAAC,eAAe,CAA4C;IAGnE,OAAO,CAAC,WAAW,CAAyC;IAE5D,OAAO,CAAC,aAAa,CAAc;gBAEvB,MAAM,EAAE,YAAY,EAAE,MAAM,CAAC,EAAE;QAAE,aAAa,CAAC,EAAE,MAAM,CAAA;KAAE;IAOrE;;OAEG;IACG,IAAI,CAAC,MAAM,EAAE,UAAU,GAAG,OAAO,CAAC,kBAAkB,CAAC;IA8E3D;;OAEG;YACW,QAAQ;IAmBtB;;OAEG;YACW,gBAAgB;IAyC9B;;OAEG;YACW,WAAW;IAmBzB;;OAEG;YACW,YAAY;IAsB1B;;OAEG;YACW,iBAAiB;IAkB/B;;OAEG;IACH,OAAO,CAAC,sBAAsB;IA6B9B;;OAEG;IACH,gBAAgB,CACd,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,EACf,aAAa,EAAE,qBAAqB,GACnC,IAAI;IAWP;;OAEG;IACH,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS;IAIhF;;OAEG;IACH,UAAU,IAAI,IAAI;IAKlB;;OAEG;IACG,2BAA2B,IAAI,OAAO,CAAC,IAAI,CAAC;IAclD;;OAEG;IACH,QAAQ,IAAI,IAAI;CAMjB"}

package/dist/security/security-scanner.js

@@ -0,0 +1,273 @@
+/**
+ * Plugin Security Scanner
+ *
+ * Scans plugins for security vulnerabilities, malware, and license issues
+ */
+export class PluginSecurityScanner {
+    constructor(logger, config) {
+        // Known vulnerabilities database (CVE cache)
+        this.vulnerabilityDb = new Map();
+        // Scan results cache
+        this.scanResults = new Map();
+        this.passThreshold = 70;
+        this.logger = logger.child({ component: 'SecurityScanner' });
+        if (config?.passThreshold !== undefined) {
+            this.passThreshold = config.passThreshold;
+        }
+    }
+    /**
+     * Perform a comprehensive security scan on a plugin
+     */
+    async scan(target) {
+        this.logger.info('Starting security scan', {
+            pluginId: target.pluginId,
+            version: target.version
+        });
+        const issues = [];
+        try {
+            // 1. Scan for code vulnerabilities
+            const codeIssues = await this.scanCode(target);
+            issues.push(...codeIssues);
+            // 2. Scan dependencies for known vulnerabilities
+            const depIssues = await this.scanDependencies(target);
+            issues.push(...depIssues);
+            // 3. Scan for malware patterns
+            const malwareIssues = await this.scanMalware(target);
+            issues.push(...malwareIssues);
+            // 4. Check license compliance
+            const licenseIssues = await this.scanLicenses(target);
+            issues.push(...licenseIssues);
+            // 5. Check configuration security
+            const configIssues = await this.scanConfiguration(target);
+            issues.push(...configIssues);
+            // Calculate security score (0-100, higher is better)
+            const score = this.calculateSecurityScore(issues);
+            const result = {
+                timestamp: new Date().toISOString(),
+                scanner: { name: 'ObjectStack Security Scanner', version: '1.0.0' },
+                status: score >= this.passThreshold ? 'passed' : 'failed',
+                vulnerabilities: issues.map(issue => ({
+                    id: issue.id,
+                    severity: issue.severity,
+                    category: issue.category,
+                    title: issue.title,
+                    description: issue.description,
+                    location: issue.location ? `${issue.location.file}:${issue.location.line}` : undefined,
+                    remediation: issue.remediation,
+                    affectedVersions: [],
+                    exploitAvailable: false,
+                    patchAvailable: false,
+                })),
+                summary: {
+                    totalVulnerabilities: issues.length,
+                    criticalCount: issues.filter(i => i.severity === 'critical').length,
+                    highCount: issues.filter(i => i.severity === 'high').length,
+                    mediumCount: issues.filter(i => i.severity === 'medium').length,
+                    lowCount: issues.filter(i => i.severity === 'low').length,
+                    infoCount: issues.filter(i => i.severity === 'info').length,
+                },
+            };
+            this.scanResults.set(`${target.pluginId}:${target.version}`, result);
+            this.logger.info('Security scan complete', {
+                pluginId: target.pluginId,
+                score,
+                status: result.status,
+                summary: result.summary
+            });
+            return result;
+        }
+        catch (error) {
+            this.logger.error('Security scan failed', {
+                pluginId: target.pluginId,
+                error
+            });
+            throw error;
+        }
+    }
+    /**
+     * Scan code for vulnerabilities
+     */
+    async scanCode(target) {
+        const issues = [];
+        // In a real implementation, this would:
+        // - Parse code with AST (e.g., using @typescript-eslint/parser)
+        // - Check for dangerous patterns (eval, Function constructor, etc.)
+        // - Check for XSS vulnerabilities
+        // - Check for SQL injection patterns
+        // - Check for insecure crypto usage
+        // - Check for path traversal vulnerabilities
+        this.logger.debug('Code scan complete', {
+            pluginId: target.pluginId,
+            issuesFound: issues.length
+        });
+        return issues;
+    }
+    /**
+     * Scan dependencies for known vulnerabilities
+     */
+    async scanDependencies(target) {
+        const issues = [];
+        if (!target.dependencies) {
+            return issues;
+        }
+        // In a real implementation, this would:
+        // - Query npm audit API
+        // - Check GitHub Advisory Database
+        // - Check Snyk vulnerability database
+        // - Check OSV (Open Source Vulnerabilities)
+        for (const [depName, version] of Object.entries(target.dependencies)) {
+            const vulnKey = `${depName}@${version}`;
+            const vulnerability = this.vulnerabilityDb.get(vulnKey);
+            if (vulnerability) {
+                issues.push({
+                    id: `vuln-${vulnerability.cve || depName}`,
+                    severity: vulnerability.severity,
+                    category: 'vulnerability',
+                    title: `Vulnerable dependency: ${depName}`,
+                    description: `${depName}@${version} has known security vulnerabilities`,
+                    remediation: vulnerability.fixedIn
+                        ? `Upgrade to ${vulnerability.fixedIn.join(' or ')}`
+                        : 'No fix available',
+                    cve: vulnerability.cve,
+                });
+            }
+        }
+        this.logger.debug('Dependency scan complete', {
+            pluginId: target.pluginId,
+            dependencies: Object.keys(target.dependencies).length,
+            vulnerabilities: issues.length
+        });
+        return issues;
+    }
+    /**
+     * Scan for malware patterns
+     */
+    async scanMalware(target) {
+        const issues = [];
+        // In a real implementation, this would:
+        // - Check for obfuscated code
+        // - Check for suspicious network activity patterns
+        // - Check for crypto mining patterns
+        // - Check for data exfiltration patterns
+        // - Use ML-based malware detection
+        // - Check file hashes against known malware databases
+        this.logger.debug('Malware scan complete', {
+            pluginId: target.pluginId,
+            issuesFound: issues.length
+        });
+        return issues;
+    }
+    /**
+     * Check license compliance
+     */
+    async scanLicenses(target) {
+        const issues = [];
+        if (!target.dependencies) {
+            return issues;
+        }
+        // In a real implementation, this would:
+        // - Check license compatibility
+        // - Detect GPL contamination
+        // - Flag proprietary dependencies
+        // - Check for missing licenses
+        // - Verify SPDX identifiers
+        this.logger.debug('License scan complete', {
+            pluginId: target.pluginId,
+            issuesFound: issues.length
+        });
+        return issues;
+    }
+    /**
+     * Check configuration security
+     */
+    async scanConfiguration(target) {
+        const issues = [];
+        // In a real implementation, this would:
+        // - Check for hardcoded secrets
+        // - Check for weak permissions
+        // - Check for insecure defaults
+        // - Check for missing security headers
+        // - Check CSP policies
+        this.logger.debug('Configuration scan complete', {
+            pluginId: target.pluginId,
+            issuesFound: issues.length
+        });
+        return issues;
+    }
+    /**
+     * Calculate security score based on issues
+     */
+    calculateSecurityScore(issues) {
+        // Start with perfect score
+        let score = 100;
+        // Deduct points based on severity
+        for (const issue of issues) {
+            switch (issue.severity) {
+                case 'critical':
+                    score -= 20;
+                    break;
+                case 'high':
+                    score -= 10;
+                    break;
+                case 'medium':
+                    score -= 5;
+                    break;
+                case 'low':
+                    score -= 2;
+                    break;
+                case 'info':
+                    score -= 0;
+                    break;
+            }
+        }
+        // Ensure score doesn't go below 0
+        return Math.max(0, score);
+    }
+    /**
+     * Add a vulnerability to the database
+     */
+    addVulnerability(packageName, version, vulnerability) {
+        const key = `${packageName}@${version}`;
+        this.vulnerabilityDb.set(key, vulnerability);
+        this.logger.debug('Vulnerability added to database', {
+            package: packageName,
+            version,
+            cve: vulnerability.cve
+        });
+    }
+    /**
+     * Get scan result from cache
+     */
+    getScanResult(pluginId, version) {
+        return this.scanResults.get(`${pluginId}:${version}`);
+    }
+    /**
+     * Clear scan results cache
+     */
+    clearCache() {
+        this.scanResults.clear();
+        this.logger.debug('Scan results cache cleared');
+    }
+    /**
+     * Update vulnerability database from external source
+     */
+    async updateVulnerabilityDatabase() {
+        this.logger.info('Updating vulnerability database');
+        // In a real implementation, this would:
+        // - Fetch from GitHub Advisory Database
+        // - Fetch from npm audit
+        // - Fetch from NVD (National Vulnerability Database)
+        // - Parse and cache vulnerability data
+        this.logger.info('Vulnerability database updated', {
+            entries: this.vulnerabilityDb.size
+        });
+    }
+    /**
+     * Shutdown security scanner
+     */
+    shutdown() {
+        this.vulnerabilityDb.clear();
+        this.scanResults.clear();
+        this.logger.info('Security scanner shutdown complete');
+    }
+}