timonel 3.0.0-beta.1 → 3.1.0-beta.1

package/dist/lib/policy/errorContextGenerator.d.ts

@@ -0,0 +1,63 @@
+import type { PolicyViolation, PolicyWarning, ValidationContext } from './types.js';
+export interface ErrorContext {
+    readonly timestamp: string;
+    readonly environment: {
+        readonly nodeVersion: string;
+        readonly platform: string;
+        readonly arch: string;
+        readonly timonelVersion?: string;
+    };
+    readonly validationContext: {
+        readonly chartName?: string;
+        readonly chartVersion?: string;
+        readonly kubernetesVersion?: string;
+        readonly environment?: string;
+    };
+    readonly plugin: {
+        readonly name: string;
+        readonly version?: string;
+        readonly executionTime?: number;
+    };
+    readonly error: {
+        readonly message: string;
+        readonly severity: 'error' | 'warning' | 'info';
+        readonly resourcePath?: string;
+        readonly field?: string;
+        readonly suggestion?: string;
+        readonly stackTrace?: string;
+        readonly originalContext?: Record<string, unknown>;
+    };
+    readonly debuggingHints: string[];
+    readonly relatedViolations?: Array<{
+        readonly plugin: string;
+        readonly message: string;
+        readonly similarity: number;
+    }>;
+}
+export declare class ErrorContextGenerator {
+    generateContext(violation: PolicyViolation | PolicyWarning, validationContext?: ValidationContext, allViolations?: (PolicyViolation | PolicyWarning)[], executionTime?: number): ErrorContext;
+    generateErrorReport(violation: PolicyViolation | PolicyWarning, validationContext?: ValidationContext, allViolations?: (PolicyViolation | PolicyWarning)[], executionTime?: number): string;
+    private addReportHeader;
+    private addBasicInformation;
+    private addResourceInformation;
+    private addSuggestion;
+    private addEnvironmentInfo;
+    private addValidationContextInfo;
+    private addDebuggingHints;
+    private addRelatedViolations;
+    private addOriginalContext;
+    private getEnvironmentInfo;
+    private getTimonelVersion;
+    private getValidationContextInfo;
+    private generateDebuggingHints;
+    private addSeverityHints;
+    private addResourcePathHints;
+    private addFieldHints;
+    private addPluginHints;
+    private addEnvironmentHints;
+    private addKubernetesVersionHints;
+    private findRelatedViolations;
+    private calculateSimilarity;
+    private calculateStringSimilarity;
+    private calculateLevenshteinDistance;
+}

package/dist/lib/policy/errorContextGenerator.js

@@ -0,0 +1,302 @@
+export class ErrorContextGenerator {
+    generateContext(violation, validationContext, allViolations, executionTime) {
+        return {
+            timestamp: new Date().toISOString(),
+            environment: this.getEnvironmentInfo(),
+            validationContext: this.getValidationContextInfo(validationContext),
+            plugin: {
+                name: violation.plugin,
+                ...(executionTime !== undefined && { executionTime }),
+            },
+            error: {
+                message: violation.message,
+                severity: violation.severity,
+                ...(violation.resourcePath && { resourcePath: violation.resourcePath }),
+                ...(violation.field && { field: violation.field }),
+                ...(violation.suggestion && { suggestion: violation.suggestion }),
+                ...(violation.context && { originalContext: violation.context }),
+            },
+            debuggingHints: this.generateDebuggingHints(violation, validationContext),
+            relatedViolations: this.findRelatedViolations(violation, allViolations),
+        };
+    }
+    generateErrorReport(violation, validationContext, allViolations, executionTime) {
+        const context = this.generateContext(violation, validationContext, allViolations, executionTime);
+        const lines = [];
+        this.addReportHeader(lines, violation);
+        this.addBasicInformation(lines, context);
+        this.addResourceInformation(lines, context);
+        this.addSuggestion(lines, context);
+        this.addEnvironmentInfo(lines, context);
+        this.addValidationContextInfo(lines, context);
+        this.addDebuggingHints(lines, context);
+        this.addRelatedViolations(lines, context);
+        this.addOriginalContext(lines, context);
+        return lines.join('\n');
+    }
+    addReportHeader(lines, violation) {
+        lines.push('='.repeat(80));
+        lines.push(`Policy Violation Report - ${violation.severity.toUpperCase()}`);
+        lines.push('='.repeat(80));
+        lines.push('');
+    }
+    addBasicInformation(lines, context) {
+        lines.push('Basic Information:');
+        lines.push(`  Plugin:    ${context.plugin.name}`);
+        lines.push(`  Severity:  ${context.error.severity}`);
+        lines.push(`  Message:   ${context.error.message}`);
+        lines.push(`  Timestamp: ${context.timestamp}`);
+        if (context.plugin.executionTime !== undefined) {
+            lines.push(`  Exec Time: ${context.plugin.executionTime}ms`);
+        }
+        lines.push('');
+    }
+    addResourceInformation(lines, context) {
+        if (context.error.resourcePath || context.error.field) {
+            lines.push('Resource Information:');
+            if (context.error.resourcePath) {
+                lines.push(`  Path:  ${context.error.resourcePath}`);
+            }
+            if (context.error.field) {
+                lines.push(`  Field: ${context.error.field}`);
+            }
+            lines.push('');
+        }
+    }
+    addSuggestion(lines, context) {
+        if (context.error.suggestion) {
+            lines.push('Suggested Fix:');
+            lines.push(`  ${context.error.suggestion}`);
+            lines.push('');
+        }
+    }
+    addEnvironmentInfo(lines, context) {
+        lines.push('Environment:');
+        lines.push(`  Node.js:   ${context.environment.nodeVersion}`);
+        lines.push(`  Platform:  ${context.environment.platform} (${context.environment.arch})`);
+        if (context.environment.timonelVersion) {
+            lines.push(`  Timonel:   ${context.environment.timonelVersion}`);
+        }
+        lines.push('');
+    }
+    addValidationContextInfo(lines, context) {
+        const hasValidationContext = context.validationContext.chartName ||
+            context.validationContext.kubernetesVersion ||
+            context.validationContext.environment;
+        if (hasValidationContext) {
+            lines.push('Validation Context:');
+            if (context.validationContext.chartName) {
+                const version = context.validationContext.chartVersion || 'unknown';
+                lines.push(`  Chart:      ${context.validationContext.chartName}@${version}`);
+            }
+            if (context.validationContext.kubernetesVersion) {
+                lines.push(`  Kubernetes: ${context.validationContext.kubernetesVersion}`);
+            }
+            if (context.validationContext.environment) {
+                lines.push(`  Environment: ${context.validationContext.environment}`);
+            }
+            lines.push('');
+        }
+    }
+    addDebuggingHints(lines, context) {
+        if (context.debuggingHints.length > 0) {
+            lines.push('Debugging Hints:');
+            context.debuggingHints.forEach((hint) => {
+                lines.push(`  • ${hint}`);
+            });
+            lines.push('');
+        }
+    }
+    addRelatedViolations(lines, context) {
+        if (context.relatedViolations && context.relatedViolations.length > 0) {
+            lines.push('Related Violations:');
+            for (const related of context.relatedViolations) {
+                lines.push(`  • [${related.plugin}] ${related.message} (${Math.round(related.similarity * 100)}% similar)`);
+            }
+            lines.push('');
+        }
+    }
+    addOriginalContext(lines, context) {
+        if (context.error.originalContext && Object.keys(context.error.originalContext).length > 0) {
+            lines.push('Additional Context:');
+            lines.push(JSON.stringify(context.error.originalContext, null, 2)
+                .split('\n')
+                .map((line) => `  ${line}`)
+                .join('\n'));
+            lines.push('');
+        }
+    }
+    getEnvironmentInfo() {
+        const timonelVersion = this.getTimonelVersion();
+        return {
+            nodeVersion: process.version,
+            platform: process.platform,
+            arch: process.arch,
+            ...(timonelVersion && { timonelVersion }),
+        };
+    }
+    getTimonelVersion() {
+        return '3.0.0';
+    }
+    getValidationContextInfo(validationContext) {
+        return {
+            ...(validationContext?.chart?.name && { chartName: validationContext.chart.name }),
+            ...(validationContext?.chart?.version && { chartVersion: validationContext.chart.version }),
+            ...(validationContext?.kubernetesVersion && {
+                kubernetesVersion: validationContext.kubernetesVersion,
+            }),
+            ...(validationContext?.environment && { environment: validationContext.environment }),
+        };
+    }
+    generateDebuggingHints(violation, validationContext) {
+        const hints = [];
+        this.addSeverityHints(hints, violation);
+        this.addResourcePathHints(hints, violation);
+        this.addFieldHints(hints, violation);
+        this.addPluginHints(hints, violation);
+        this.addEnvironmentHints(hints, validationContext);
+        this.addKubernetesVersionHints(hints, validationContext);
+        return hints;
+    }
+    addSeverityHints(hints, violation) {
+        if (violation.severity === 'error') {
+            hints.push('This error will prevent chart generation. Fix this violation to proceed.');
+        }
+        else if (violation.severity === 'warning') {
+            hints.push("This warning indicates a potential issue but won't block chart generation.");
+        }
+    }
+    addResourcePathHints(hints, violation) {
+        if (!violation.resourcePath)
+            return;
+        if (violation.resourcePath.includes('spec.containers')) {
+            hints.push('This violation is related to container specifications. Check container configuration.');
+        }
+        else if (violation.resourcePath.includes('metadata')) {
+            hints.push('This violation is related to resource metadata. Verify labels, annotations, and names.');
+        }
+        else if (violation.resourcePath.includes('spec.template')) {
+            hints.push('This violation is in a pod template. Check deployment or statefulset configuration.');
+        }
+    }
+    addFieldHints(hints, violation) {
+        if (!violation.field)
+            return;
+        if (violation.field.includes('securityContext')) {
+            hints.push('Security context violations often relate to privilege escalation or root access.');
+        }
+        else if (violation.field.includes('resources')) {
+            hints.push('Resource violations typically involve CPU/memory limits or requests.');
+        }
+        else if (violation.field.includes('image')) {
+            hints.push('Image violations may relate to image tags, registries, or security policies.');
+        }
+    }
+    addPluginHints(hints, violation) {
+        if (violation.plugin.includes('security')) {
+            hints.push('Security violations should be addressed promptly to maintain cluster security.');
+            hints.push("Consider reviewing your organization's security policies and best practices.");
+        }
+        else if (violation.plugin.includes('resource')) {
+            hints.push('Resource violations can impact cluster performance and cost.');
+        }
+        else if (violation.plugin.includes('network')) {
+            hints.push('Network violations may affect service connectivity and security.');
+        }
+    }
+    addEnvironmentHints(hints, validationContext) {
+        if (validationContext?.environment === 'production') {
+            hints.push('This is a production environment - ensure all violations are resolved before deployment.');
+        }
+        else if (validationContext?.environment === 'development') {
+            hints.push('Development environment detected - some violations may be acceptable for testing.');
+        }
+    }
+    addKubernetesVersionHints(hints, validationContext) {
+        if (validationContext?.kubernetesVersion) {
+            const version = validationContext.kubernetesVersion;
+            if (version.startsWith('1.2')) {
+                hints.push('Kubernetes 1.2x detected - ensure compatibility with newer API versions.');
+            }
+        }
+    }
+    findRelatedViolations(violation, allViolations) {
+        if (!allViolations || allViolations.length <= 1) {
+            return [];
+        }
+        const related = [];
+        for (const other of allViolations) {
+            if (other === violation)
+                continue;
+            const similarity = this.calculateSimilarity(violation, other);
+            if (similarity > 0.3) {
+                related.push({
+                    plugin: other.plugin,
+                    message: other.message,
+                    similarity,
+                });
+            }
+        }
+        return related.sort((a, b) => b.similarity - a.similarity).slice(0, 3);
+    }
+    calculateSimilarity(violation1, violation2) {
+        let score = 0;
+        let factors = 0;
+        if (violation1.plugin === violation2.plugin) {
+            score += 0.4;
+        }
+        factors += 0.4;
+        if (violation1.severity === violation2.severity) {
+            score += 0.2;
+        }
+        factors += 0.2;
+        if (violation1.resourcePath && violation2.resourcePath) {
+            const pathSimilarity = this.calculateStringSimilarity(violation1.resourcePath, violation2.resourcePath);
+            score += pathSimilarity * 0.2;
+        }
+        factors += 0.2;
+        if (violation1.field && violation2.field) {
+            const fieldSimilarity = this.calculateStringSimilarity(violation1.field, violation2.field);
+            score += fieldSimilarity * 0.1;
+        }
+        factors += 0.1;
+        const messageSimilarity = this.calculateStringSimilarity(violation1.message, violation2.message);
+        score += messageSimilarity * 0.1;
+        factors += 0.1;
+        return factors > 0 ? score / factors : 0;
+    }
+    calculateStringSimilarity(str1, str2) {
+        if (str1 === str2)
+            return 1;
+        if (str1.length === 0 || str2.length === 0)
+            return 0;
+        const longer = str1.length > str2.length ? str1 : str2;
+        const shorter = str1.length > str2.length ? str2 : str1;
+        if (longer.length === 0)
+            return 1;
+        const editDistance = this.calculateLevenshteinDistance(longer, shorter);
+        return (longer.length - editDistance) / longer.length;
+    }
+    calculateLevenshteinDistance(str1, str2) {
+        const matrix = Array(str2.length + 1)
+            .fill(null)
+            .map(() => Array(str1.length + 1).fill(0));
+        for (let i = 0; i <= str2.length; i++) {
+            matrix[i][0] = i;
+        }
+        for (let j = 0; j <= str1.length; j++) {
+            matrix[0][j] = j;
+        }
+        for (let i = 1; i <= str2.length; i++) {
+            for (let j = 1; j <= str1.length; j++) {
+                if (str2.charAt(i - 1) === str1.charAt(j - 1)) {
+                    matrix[i][j] = matrix[i - 1][j - 1];
+                }
+                else {
+                    matrix[i][j] = Math.min(matrix[i - 1][j - 1] + 1, matrix[i][j - 1] + 1, matrix[i - 1][j] + 1);
+                }
+            }
+        }
+        return matrix[str2.length][str1.length];
+    }
+}

package/dist/lib/policy/errors.d.ts

@@ -0,0 +1,40 @@
+export declare class PolicyEngineError extends Error {
+    readonly code?: string | undefined;
+    readonly context?: Record<string, unknown> | undefined;
+    constructor(message: string, code?: string | undefined, context?: Record<string, unknown> | undefined);
+}
+export declare class PluginError extends PolicyEngineError {
+    readonly pluginName: string;
+    constructor(message: string, pluginName: string, context?: Record<string, unknown>);
+}
+export declare class ValidationTimeoutError extends PolicyEngineError {
+    constructor(pluginName: string, timeout: number);
+}
+export declare class PluginRegistrationError extends PolicyEngineError {
+    readonly pluginName?: string | undefined;
+    constructor(message: string, pluginName?: string | undefined, context?: Record<string, unknown>);
+}
+export declare class PluginConfigurationError extends PolicyEngineError {
+    readonly pluginName: string;
+    readonly configPath?: string | undefined;
+    constructor(message: string, pluginName: string, configPath?: string | undefined, context?: Record<string, unknown>);
+}
+export declare class ValidationOrchestrationError extends PolicyEngineError {
+    readonly failedPlugins?: string[] | undefined;
+    constructor(message: string, failedPlugins?: string[] | undefined, context?: Record<string, unknown>);
+}
+export declare class PluginRetryExhaustedError extends PolicyEngineError {
+    readonly pluginName: string;
+    readonly attempts: number;
+    readonly lastError: Error;
+    constructor(message: string, pluginName: string, attempts: number, lastError: Error, context?: Record<string, unknown>);
+}
+export declare class GracefulDegradationError extends PolicyEngineError {
+    readonly degradedPlugins: string[];
+    readonly originalErrors: Error[];
+    constructor(message: string, degradedPlugins: string[], originalErrors: Error[], context?: Record<string, unknown>);
+}
+export declare class PolicyValidationError extends PolicyEngineError {
+    readonly field?: string | undefined;
+    constructor(message: string, field?: string | undefined, context?: Record<string, unknown>);
+}

package/dist/lib/policy/errors.js

@@ -0,0 +1,109 @@
+export class PolicyEngineError extends Error {
+    constructor(message, code, context) {
+        super(message);
+        this.code = code;
+        this.context = context;
+        this.name = 'PolicyEngineError';
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, PolicyEngineError);
+        }
+    }
+}
+export class PluginError extends PolicyEngineError {
+    constructor(message, pluginName, context) {
+        super(message, 'PLUGIN_ERROR', { ...context, pluginName });
+        this.pluginName = pluginName;
+        this.name = 'PluginError';
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, PluginError);
+        }
+    }
+}
+export class ValidationTimeoutError extends PolicyEngineError {
+    constructor(pluginName, timeout) {
+        super(`Plugin '${pluginName}' timed out after ${timeout}ms`, 'VALIDATION_TIMEOUT', {
+            pluginName,
+            timeout,
+        });
+        this.name = 'ValidationTimeoutError';
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, ValidationTimeoutError);
+        }
+    }
+}
+export class PluginRegistrationError extends PolicyEngineError {
+    constructor(message, pluginName, context) {
+        super(message, 'PLUGIN_REGISTRATION_ERROR', { ...context, pluginName });
+        this.pluginName = pluginName;
+        this.name = 'PluginRegistrationError';
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, PluginRegistrationError);
+        }
+    }
+}
+export class PluginConfigurationError extends PolicyEngineError {
+    constructor(message, pluginName, configPath, context) {
+        super(message, 'PLUGIN_CONFIGURATION_ERROR', { ...context, pluginName, configPath });
+        this.pluginName = pluginName;
+        this.configPath = configPath;
+        this.name = 'PluginConfigurationError';
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, PluginConfigurationError);
+        }
+    }
+}
+export class ValidationOrchestrationError extends PolicyEngineError {
+    constructor(message, failedPlugins, context) {
+        super(message, 'VALIDATION_ORCHESTRATION_ERROR', { ...context, failedPlugins });
+        this.failedPlugins = failedPlugins;
+        this.name = 'ValidationOrchestrationError';
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, ValidationOrchestrationError);
+        }
+    }
+}
+export class PluginRetryExhaustedError extends PolicyEngineError {
+    constructor(message, pluginName, attempts, lastError, context) {
+        super(message, 'PLUGIN_RETRY_EXHAUSTED', {
+            ...context,
+            pluginName,
+            attempts,
+            lastError: lastError.message,
+        });
+        this.pluginName = pluginName;
+        this.attempts = attempts;
+        this.lastError = lastError;
+        this.name = 'PluginRetryExhaustedError';
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, PluginRetryExhaustedError);
+        }
+    }
+}
+export class GracefulDegradationError extends PolicyEngineError {
+    constructor(message, degradedPlugins, originalErrors, context) {
+        super(message, 'GRACEFUL_DEGRADATION', {
+            ...context,
+            degradedPlugins,
+            errorCount: originalErrors.length,
+        });
+        this.degradedPlugins = degradedPlugins;
+        this.originalErrors = originalErrors;
+        this.name = 'GracefulDegradationError';
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, GracefulDegradationError);
+        }
+    }
+}
+export class PolicyValidationError extends PolicyEngineError {
+    constructor(message, field, context) {
+        super(message, 'POLICY_VALIDATION_ERROR', {
+            ...context,
+            field,
+        });
+        this.field = field;
+        this.name = 'PolicyValidationError';
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, PolicyValidationError);
+        }
+    }
+}

package/dist/lib/policy/index.d.ts

@@ -0,0 +1,11 @@
+export { PolicyEngine } from './policyEngine.js';
+export { PluginRegistry } from './pluginRegistry.js';
+export { ConfigurationLoader } from './configurationLoader.js';
+export { PluginLoader } from './pluginLoader.js';
+export { ValidationCache, generateManifestHash, generatePluginHash, type CacheEntry, type CacheOptions, type CacheStats, } from './validationCache.js';
+export { ParallelExecutor, calculateOptimalConcurrency, type ParallelExecutionOptions, type PluginExecutionResult, type ParallelExecutionStats, } from './parallelExecutor.js';
+export { aggregateResults, generateResultSummary, filterViolationsBySeverity, groupViolationsByPlugin, sortViolationsBySeverity, createEmptyResult, mergeViolationContexts, } from './resultAggregator.js';
+export { DefaultResultFormatter, JsonResultFormatter, CompactResultFormatter, GitHubActionsResultFormatter, SarifResultFormatter, createFormatter, getAvailableFormatters, } from './resultFormatter.js';
+export { ErrorContextGenerator, type ErrorContext } from './errorContextGenerator.js';
+export type { PolicyEngine as IPolicyEngine, PolicyPlugin, PolicyEngineOptions, PolicyResult, PolicyViolation, PolicyWarning, ValidationContext, ValidationMetadata, JSONSchema, PluginMetadata, ResultFormatter, ResultSummary, RetryConfig, ConfigurationLoaderOptions, } from './types.js';
+export { PolicyEngineError, PluginError, ValidationTimeoutError, PluginRegistrationError, PluginConfigurationError, ValidationOrchestrationError, PluginRetryExhaustedError, GracefulDegradationError, } from './errors.js';

package/dist/lib/policy/index.js

@@ -0,0 +1,10 @@
+export { PolicyEngine } from './policyEngine.js';
+export { PluginRegistry } from './pluginRegistry.js';
+export { ConfigurationLoader } from './configurationLoader.js';
+export { PluginLoader } from './pluginLoader.js';
+export { ValidationCache, generateManifestHash, generatePluginHash, } from './validationCache.js';
+export { ParallelExecutor, calculateOptimalConcurrency, } from './parallelExecutor.js';
+export { aggregateResults, generateResultSummary, filterViolationsBySeverity, groupViolationsByPlugin, sortViolationsBySeverity, createEmptyResult, mergeViolationContexts, } from './resultAggregator.js';
+export { DefaultResultFormatter, JsonResultFormatter, CompactResultFormatter, GitHubActionsResultFormatter, SarifResultFormatter, createFormatter, getAvailableFormatters, } from './resultFormatter.js';
+export { ErrorContextGenerator } from './errorContextGenerator.js';
+export { PolicyEngineError, PluginError, ValidationTimeoutError, PluginRegistrationError, PluginConfigurationError, ValidationOrchestrationError, PluginRetryExhaustedError, GracefulDegradationError, } from './errors.js';

package/dist/lib/policy/parallelExecutor.d.ts

@@ -0,0 +1,58 @@
+import type { PolicyPlugin, PolicyViolation, ValidationContext } from './types.js';
+export interface ParallelExecutionOptions {
+    maxConcurrency?: number;
+    useWorkerThreads?: boolean;
+    pluginTimeout?: number;
+    failFast?: boolean;
+    resourceLimits?: {
+        maxMemoryMB?: number;
+        maxCpuTimeMs?: number;
+    };
+    priorityConfig?: {
+        highPriority?: string[];
+        lowPriority?: string[];
+    };
+}
+export interface PluginExecutionResult {
+    plugin: PolicyPlugin;
+    violations: PolicyViolation[];
+    executionTime: number;
+    error?: Error;
+    resourceUsage?: {
+        memoryUsageMB: number;
+        cpuTimeMs: number;
+    };
+}
+export interface ParallelExecutionStats {
+    totalExecutionTime: number;
+    averagePluginTime: number;
+    maxPluginTime: number;
+    parallelPluginCount: number;
+    concurrencyUtilization: number;
+    resourceUsage: {
+        totalMemoryMB: number;
+        totalCpuTimeMs: number;
+        peakConcurrentPlugins: number;
+    };
+}
+export declare class ParallelExecutor {
+    private readonly options;
+    private readonly logger;
+    private activeExecutions;
+    private executionQueue;
+    constructor(options?: ParallelExecutionOptions);
+    executePlugins(plugins: PolicyPlugin[], manifests: unknown[], validationContext: ValidationContext): Promise<{
+        results: PluginExecutionResult[];
+        stats: ParallelExecutionStats;
+    }>;
+    private executePlugin;
+    private executeWithTimeout;
+    private executeConcurrently;
+    private sortPluginsByPriority;
+    private calculateStats;
+}
+export declare function calculateOptimalConcurrency(pluginCount: number, systemInfo?: {
+    cpuCount?: number;
+    availableMemoryMB?: number;
+    isContainerized?: boolean;
+}): number;