anon-identity/dist/mcp/functions/function-executor.d.ts

Decentralized identity framework with DIDs, Verifiable Credentials, and privacy-preserving selective disclosure

/**
 * Function Executor for MCP
 *
 * Secure function execution framework with validation, sandboxing, and monitoring
 */
import { EventEmitter } from 'events';
import { FunctionCall, FunctionSecurity } from '../types';
import { FunctionRegistry, FunctionExecutionContext, FunctionExecutionResult } from './function-registry';
import { AuthManager } from '../security/auth-manager';
import { AuditLogger } from '../security/audit-logger';
/**
 * Execution environment
 */
export interface ExecutionEnvironment {
    sandboxed: boolean;
    timeoutMs: number;
    memoryLimitMB: number;
    networkAccess: boolean;
    fileSystemAccess: boolean;
    allowedModules: string[];
    environmentVariables: Record<string, string>;
}
/**
 * Execution options
 */
export interface ExecutionOptions {
    environment?: Partial<ExecutionEnvironment>;
    priority: 'low' | 'normal' | 'high' | 'critical';
    retryOnFailure: boolean;
    maxRetries: number;
    validateResult: boolean;
    auditExecution: boolean;
}
/**
 * Result validation schema
 */
export interface ResultValidationSchema {
    type: string;
    properties?: Record<string, any>;
    required?: string[];
    maxLength?: number;
    maxItems?: number;
    pattern?: string;
}
/**
 * Execution metrics
 */
export interface ExecutionMetrics {
    functionName: string;
    executionTime: number;
    memoryUsed: number;
    cpuTime: number;
    networkCalls: number;
    errors: string[];
    warnings: string[];
    securityViolations: string[];
}
/**
 * Sandbox violation
 */
export interface SandboxViolation {
    type: 'network' | 'filesystem' | 'memory' | 'cpu' | 'module' | 'timeout';
    message: string;
    timestamp: Date;
    severity: 'low' | 'medium' | 'high' | 'critical';
}
/**
 * Function Executor
 */
export declare class FunctionExecutor extends EventEmitter {
    private functionRegistry;
    private authManager;
    private auditLogger;
    private defaultEnvironment;
    private executionQueue;
    private activeExecutions;
    private resultValidators;
    private securityPolicies;
    private isProcessing;
    private processInterval?;
    constructor(functionRegistry: FunctionRegistry, authManager: AuthManager, auditLogger: AuditLogger, defaultEnvironment?: ExecutionEnvironment);
    /**
     * Execute function with full security and validation
     */
    executeFunction(functionCall: FunctionCall, context: FunctionExecutionContext, options?: ExecutionOptions): Promise<FunctionExecutionResult>;
    /**
     * Register result validator for function
     */
    registerResultValidator(functionName: string, schema: ResultValidationSchema): void;
    /**
     * Set security policy for function
     */
    setSecurityPolicy(functionName: string, policy: FunctionSecurity): void;
    /**
     * Get execution statistics
     */
    getExecutionStatistics(): {
        queueSize: number;
        activeExecutions: number;
        totalExecuted: number;
        averageExecutionTime: number;
        errorRate: number;
        securityViolations: number;
    };
    /**
     * Perform security checks before execution
     */
    private performSecurityChecks;
    /**
     * Execute function immediately
     */
    private executeImmediate;
    /**
     * Queue execution for later processing
     */
    private queueExecution;
    /**
     * Execute function with comprehensive monitoring
     */
    private executeWithMonitoring;
    /**
     * Execute function in sandbox
     */
    private executeSandboxed;
    /**
     * Validate execution result
     */
    private validateExecutionResult;
    /**
     * Validate result against schema
     */
    private validateResultAgainstSchema;
    /**
     * Create execution environment
     */
    private createExecutionEnvironment;
    /**
     * Get priority value for sorting
     */
    private getPriorityValue;
    /**
     * Start queue processor
     */
    private startQueueProcessor;
    /**
     * Process execution queue
     */
    private processQueue;
    /**
     * Clear execution queue
     */
    clearQueue(): void;
    /**
     * Shutdown executor
     */
    shutdown(): void;
}
export default FunctionExecutor;
//# sourceMappingURL=function-executor.d.ts.map