typekro 0.1.0 → 0.2.2

package/dist/core/deployment/engine.js

@@ -5,14 +5,16 @@
  * without requiring the Kro controller, using in-process dependency resolution.
  */
 import * as k8s from '@kubernetes/client-node';
+import { ensureReadinessEvaluator } from '../../utils/helpers.js';
 import { DependencyResolver } from '../dependencies/index.js';
 import { CircularDependencyError } from '../errors.js';
 import { getComponentLogger } from '../logging/index.js';
-import { ReferenceResolver, DeploymentMode } from '../references/index.js';
+import { DeploymentMode, ReferenceResolver } from '../references/index.js';
 import { ResourceDeploymentError } from '../types/deployment.js';
+import { createDebugLoggerFromDeploymentOptions } from './debug-logger.js';
 import { ResourceReadinessChecker } from './readiness.js';
 import { StatusHydrator } from './status-hydrator.js';
-import { ensureReadinessEvaluator } from '../../utils/helpers.js';
+import { createEventMonitor } from './event-monitor.js';
 export class DirectDeploymentEngine {
     kubeClient;
     deploymentMode;
@@ -21,6 +23,9 @@ export class DirectDeploymentEngine {
     k8sApi;
     readinessChecker;
     statusHydrator;
+    debugLogger;
+    eventMonitor;
+    eventFilter;
     deploymentState = new Map();
     readyResources = new Set(); // Track resources that are already ready
     logger = getComponentLogger('deployment-engine');
@@ -28,17 +33,19 @@ export class DirectDeploymentEngine {
         this.kubeClient = kubeClient;
         this.deploymentMode = deploymentMode;
         this.dependencyResolver = new DependencyResolver();
-        this.referenceResolver = referenceResolver || new ReferenceResolver(kubeClient, this.deploymentMode, k8sApi);
+        this.referenceResolver =
+            referenceResolver || new ReferenceResolver(kubeClient, this.deploymentMode, k8sApi);
         this.k8sApi = k8sApi || kubeClient.makeApiClient(k8s.KubernetesObjectApi);
         this.readinessChecker = new ResourceReadinessChecker(this.k8sApi);
         this.statusHydrator = new StatusHydrator(this.k8sApi);
+        // this.eventFilter = createEventFilter();
         // Set up callback to track ready resources
         this.readinessChecker.setOnResourceReady((resource) => {
             const resourceKey = `${resource.kind}/${resource.name}/${resource.namespace}`;
             this.readyResources.add(resourceKey);
             this.logger.debug('Resource marked as ready via generic readiness checker', {
                 resourceKey,
-                totalReady: this.readyResources.size
+                totalReady: this.readyResources.size,
             });
         });
     }
@@ -55,7 +62,8 @@ export class DirectDeploymentEngine {
     async isDeployedResourceReady(deployedResource) {
         try {
             // Check if the deployed resource has a factory-provided readiness evaluator
-            const readinessEvaluator = deployedResource.manifest.readinessEvaluator;
+            const readinessEvaluator = deployedResource.manifest
+                .readinessEvaluator;
             if (readinessEvaluator) {
                 // Use the factory-provided readiness evaluator
                 // Create a resource reference for the API call
@@ -71,19 +79,25 @@ export class DirectDeploymentEngine {
                 const liveResource = await this.k8sApi.read(resourceRef);
                 // Use the factory-provided readiness evaluator
                 const result = readinessEvaluator(liveResource.body);
+                let readinessResult;
                 if (typeof result === 'boolean') {
-                    return result;
+                    readinessResult = { ready: result };
                 }
                 else if (result && typeof result === 'object' && 'ready' in result) {
-                    return result.ready;
+                    readinessResult = result;
                 }
                 else {
                     this.logger.warn('Readiness evaluator returned unexpected result', {
                         resourceId: deployedResource.id,
-                        result
+                        result,
                     });
-                    return false;
+                    readinessResult = { ready: false, reason: 'Invalid evaluator result' };
                 }
+                // Debug logging for readiness evaluation
+                if (this.debugLogger) {
+                    this.debugLogger.logReadinessEvaluation(deployedResource, readinessEvaluator, readinessResult);
+                }
+                return readinessResult.ready;
             }
             else {
                 // Fallback to generic readiness checker
@@ -105,7 +119,7 @@ export class DirectDeploymentEngine {
                 resourceId: deployedResource.id,
                 kind: deployedResource.kind,
                 name: deployedResource.name,
-                namespace: deployedResource.namespace
+                namespace: deployedResource.namespace,
             });
             return false;
         }
@@ -124,7 +138,10 @@ export class DirectDeploymentEngine {
         const startTime = Date.now();
         const deployedResources = [];
         const errors = [];
-        const deploymentLogger = this.logger.child({ deploymentId, resourceCount: graph.resources.length });
+        const deploymentLogger = this.logger.child({
+            deploymentId,
+            resourceCount: graph.resources.length,
+        });
         deploymentLogger.info('Starting deployment', { options });
         try {
             this.emitEvent(options, {
@@ -133,7 +150,9 @@ export class DirectDeploymentEngine {
                 timestamp: new Date(),
             });
             // 1. Validate no cycles in dependency graph
-            deploymentLogger.debug('Validating dependency graph', { dependencyGraph: graph.dependencyGraph });
+            deploymentLogger.debug('Validating dependency graph', {
+                dependencyGraph: graph.dependencyGraph,
+            });
             this.dependencyResolver.validateNoCycles(graph.dependencyGraph);
             // 2. Analyze deployment order and identify parallel stages
             deploymentLogger.debug('Analyzing deployment order for parallel execution');
@@ -141,16 +160,40 @@ export class DirectDeploymentEngine {
             deploymentLogger.debug('Deployment plan determined', {
                 levels: deploymentPlan.levels.length,
                 totalResources: deploymentPlan.totalResources,
-                maxParallelism: deploymentPlan.maxParallelism
+                maxParallelism: deploymentPlan.maxParallelism,
             });
-            // 3. Create resolution context
+            // 3. Initialize and start event monitoring if enabled
+            if (options.eventMonitoring?.enabled) {
+                try {
+                    this.eventMonitor = createEventMonitor(this.kubeClient, {
+                        namespace: options.namespace || 'default',
+                        eventTypes: options.eventMonitoring.eventTypes || ['Warning', 'Error'],
+                        includeChildResources: options.eventMonitoring.includeChildResources ?? true,
+                        startTime: new Date(startTime),
+                        ...(options.progressCallback && { progressCallback: options.progressCallback }),
+                    });
+                    // Start monitoring immediately to capture all deployment events
+                    await this.eventMonitor.startMonitoring([]);
+                    deploymentLogger.debug('Event monitoring started for deployment');
+                }
+                catch (error) {
+                    deploymentLogger.warn('Failed to initialize event monitoring, continuing without it', error);
+                }
+            }
+            // 3.1. Initialize debug logging if enabled
+            if (options.debugLogging?.enabled) {
+                this.debugLogger = createDebugLoggerFromDeploymentOptions(options);
+                this.readinessChecker.setDebugLogger(this.debugLogger);
+                deploymentLogger.debug('Debug logging initialized');
+            }
+            // 4. Create resolution context
             const context = {
                 deployedResources,
                 kubeClient: this.kubeClient,
                 ...(options.namespace && { namespace: options.namespace }),
                 timeout: options.timeout || 30000,
             };
-            // 4. Deploy resources in parallel stages
+            // 5. Deploy resources in parallel stages
             for (let levelIndex = 0; levelIndex < deploymentPlan.levels.length; levelIndex++) {
                 const currentLevel = deploymentPlan.levels[levelIndex];
                 if (!currentLevel) {
@@ -158,7 +201,7 @@ export class DirectDeploymentEngine {
                 }
                 const levelLogger = deploymentLogger.child({
                     level: levelIndex + 1,
-                    resourceCount: currentLevel.length
+                    resourceCount: currentLevel.length,
                 });
                 levelLogger.debug(`Deploying level ${levelIndex + 1} with ${currentLevel.length} resources in parallel`);
                 // Track performance metrics for this level
@@ -179,13 +222,13 @@ export class DirectDeploymentEngine {
                                 phase: 'validation',
                                 error,
                                 timestamp: new Date(),
-                            }
+                            },
                         };
                     }
                     resourceLogger.debug('Found resource in graph', {
                         resourceId: resource.id,
                         kind: resource.manifest?.kind,
-                        name: resource.manifest?.metadata?.name
+                        name: resource.manifest?.metadata?.name,
                     });
                     try {
                         resourceLogger.debug('Calling deploySingleResource');
@@ -193,12 +236,31 @@ export class DirectDeploymentEngine {
                         await this.waitForCRDIfCustomResource(resource.manifest, options, resourceLogger);
                         // FIX: Unconditionally ensure the readiness evaluator is attached just before deployment.
                         const resourceWithEvaluator = ensureReadinessEvaluator(resource.manifest);
+                        // Add resource to event monitoring before deployment to capture creation events
+                        if (this.eventMonitor) {
+                            const preDeployedResource = {
+                                id: resourceId,
+                                kind: resourceWithEvaluator.kind,
+                                name: resourceWithEvaluator.metadata?.name || 'unknown',
+                                namespace: resourceWithEvaluator.metadata?.namespace || options.namespace || 'default',
+                                manifest: resourceWithEvaluator,
+                                status: 'deployed',
+                                deployedAt: new Date(),
+                            };
+                            try {
+                                await this.eventMonitor.addResources([preDeployedResource]);
+                                resourceLogger.debug('Added resource to event monitoring before deployment');
+                            }
+                            catch (error) {
+                                resourceLogger.warn('Failed to add resource to event monitoring, continuing deployment', error);
+                            }
+                        }
                         const deployedResource = await this.deploySingleResource(resourceWithEvaluator, context, options);
                         resourceLogger.debug('Resource deployed successfully');
                         return {
                             success: true,
                             resourceId,
-                            deployedResource
+                            deployedResource,
                         };
                     }
                     catch (error) {
@@ -222,7 +284,7 @@ export class DirectDeploymentEngine {
                                 phase: 'deployment',
                                 error: error,
                                 timestamp: new Date(),
-                            }
+                            },
                         };
                     }
                 });
@@ -252,6 +314,7 @@ export class DirectDeploymentEngine {
                         levelLogger.error('Unexpected promise rejection in parallel deployment', result.reason);
                     }
                 }
+                // Resources are now added to event monitoring before deployment (see individual resource deployment above)
                 // Handle rollback if there are failures and rollback is enabled
                 if (levelHasFailures && options.rollbackOnFailure) {
                     levelLogger.warn('Level deployment failed, initiating rollback');
@@ -273,27 +336,21 @@ export class DirectDeploymentEngine {
                 }
                 // Calculate level performance metrics
                 const levelDuration = Date.now() - levelStartTime;
-                const successfulCount = levelResults.filter(r => r.status === 'fulfilled' && r.value.success).length;
-                const failedCount = levelResults.filter(r => r.status === 'rejected' || (r.status === 'fulfilled' && !r.value.success)).length;
-                const isTestEnvironment = process.env.NODE_ENV === 'test' || process.env.VITEST === 'true';
-                // Use debug level in test environments to reduce noise, info level in production
-                const logLevel = isTestEnvironment ? 'debug' : 'info';
-                levelLogger[logLevel](`Level ${levelIndex + 1} deployment completed`, {
+                const successfulCount = levelResults.filter((r) => r.status === 'fulfilled' && r.value.success).length;
+                const failedCount = levelResults.filter((r) => r.status === 'rejected' || (r.status === 'fulfilled' && !r.value.success)).length;
+                levelLogger.info(`Level ${levelIndex + 1} deployment completed`, {
                     successful: successfulCount,
                     failed: failedCount,
                     duration: levelDuration,
                     parallelism: currentLevel.length,
-                    averageTimePerResource: Math.round(levelDuration / currentLevel.length)
+                    averageTimePerResource: Math.round(levelDuration / currentLevel.length),
                 });
             }
             const duration = Date.now() - startTime;
             const successfulResources = deployedResources.filter((r) => r.status !== 'failed');
             const status = errors.length === 0 ? 'success' : successfulResources.length > 0 ? 'partial' : 'failed';
             // Log comprehensive performance metrics
-            const isTestEnvironment = process.env.NODE_ENV === 'test' || process.env.VITEST === 'true';
-            // Use debug level in test environments to reduce noise, info level in production
-            const logLevel = isTestEnvironment ? 'debug' : 'info';
-            deploymentLogger[logLevel]('Parallel deployment performance metrics', {
+            deploymentLogger.info('Parallel deployment performance metrics', {
                 totalDuration: duration,
                 totalResources: deploymentPlan.totalResources,
                 parallelLevels: deploymentPlan.levels.length,
@@ -301,14 +358,27 @@ export class DirectDeploymentEngine {
                 averageTimePerResource: Math.round(duration / deploymentPlan.totalResources),
                 successfulResources: successfulResources.length,
                 failedResources: errors.length,
-                parallelismEfficiency: Math.round((deploymentPlan.totalResources / deploymentPlan.levels.length) / deploymentPlan.maxParallelism * 100),
-                status
+                parallelismEfficiency: Math.round((deploymentPlan.totalResources /
+                    deploymentPlan.levels.length /
+                    deploymentPlan.maxParallelism) *
+                    100),
+                status,
             });
             this.emitEvent(options, {
                 type: status === 'success' ? 'completed' : 'failed',
                 message: `Deployment ${status} in ${duration}ms (${deploymentPlan.levels.length} parallel levels, max ${deploymentPlan.maxParallelism} concurrent)`,
                 timestamp: new Date(),
             });
+            // Stop event monitoring
+            if (this.eventMonitor) {
+                try {
+                    await this.eventMonitor.stopMonitoring();
+                    deploymentLogger.debug('Event monitoring stopped');
+                }
+                catch (error) {
+                    deploymentLogger.warn('Failed to stop event monitoring cleanly', error);
+                }
+            }
             // Store deployment state for rollback
             this.deploymentState.set(deploymentId, {
                 deploymentId,
@@ -340,6 +410,15 @@ export class DirectDeploymentEngine {
                 timestamp: new Date(),
                 error: error,
             });
+            // Stop event monitoring on error
+            if (this.eventMonitor) {
+                try {
+                    await this.eventMonitor.stopMonitoring();
+                }
+                catch (_cleanupError) {
+                    // Ignore cleanup errors in error path
+                }
+            }
             // Store deployment state even for failed deployments (for rollback)
             this.deploymentState.set(deploymentId, {
                 deploymentId,
@@ -401,7 +480,7 @@ export class DirectDeploymentEngine {
      * Extract dependencies from a closure by analyzing its configuration
      * This is a simplified implementation - in practice, we would need more sophisticated analysis
      */
-    extractClosureDependencies(closure, spec) {
+    extractClosureDependencies(_closure, _spec) {
         // For now, return empty dependencies since closures typically don't depend on Enhanced<> resources
         // In the future, this could analyze closure arguments for resource references
         return [];
@@ -414,7 +493,7 @@ export class DirectDeploymentEngine {
         const deploymentPlan = this.dependencyResolver.analyzeDeploymentOrder(dependencyGraph);
         for (let levelIndex = 0; levelIndex < deploymentPlan.levels.length; levelIndex++) {
             const level = deploymentPlan.levels[levelIndex];
-            if (level && level.includes(resourceId)) {
+            if (level?.includes(resourceId)) {
                 return levelIndex;
             }
         }
@@ -427,7 +506,7 @@ export class DirectDeploymentEngine {
         // Create enhanced levels with both resources and closures
         const enhancedLevels = [];
         // Check if we have any closures at level -1 (pre-resource level)
-        const preResourceClosures = closureDependencies.filter(c => c.level === -1);
+        const preResourceClosures = closureDependencies.filter((c) => c.level === -1);
         // If we have pre-resource closures, add them as level 0 and shift everything else
         if (preResourceClosures.length > 0) {
             enhancedLevels.push({
@@ -462,7 +541,7 @@ export class DirectDeploymentEngine {
             levels: enhancedLevels,
             totalResources: deploymentPlan.totalResources,
             totalClosures: closureDependencies.length,
-            maxParallelism: Math.max(deploymentPlan.maxParallelism, Math.max(...enhancedLevels.map(level => level.closures.length))),
+            maxParallelism: Math.max(deploymentPlan.maxParallelism, Math.max(...enhancedLevels.map((level) => level.closures.length))),
         };
     }
     /**
@@ -476,11 +555,11 @@ export class DirectDeploymentEngine {
         const deploymentLogger = this.logger.child({
             deploymentId,
             resourceCount: graph.resources.length,
-            closureCount: Object.keys(closures).length
+            closureCount: Object.keys(closures).length,
         });
         deploymentLogger.info('Starting deployment with closures', {
             options,
-            closures: Object.keys(closures)
+            closures: Object.keys(closures),
         });
         try {
             this.emitEvent(options, {
@@ -489,7 +568,9 @@ export class DirectDeploymentEngine {
                 timestamp: new Date(),
             });
             // 1. Validate no cycles in dependency graph
-            deploymentLogger.debug('Validating dependency graph', { dependencyGraph: graph.dependencyGraph });
+            deploymentLogger.debug('Validating dependency graph', {
+                dependencyGraph: graph.dependencyGraph,
+            });
             this.dependencyResolver.validateNoCycles(graph.dependencyGraph);
             // 2. Analyze deployment order and identify parallel stages
             deploymentLogger.debug('Analyzing deployment order for parallel execution');
@@ -497,7 +578,7 @@ export class DirectDeploymentEngine {
             deploymentLogger.debug('Deployment plan determined', {
                 levels: deploymentPlan.levels.length,
                 totalResources: deploymentPlan.totalResources,
-                maxParallelism: deploymentPlan.maxParallelism
+                maxParallelism: deploymentPlan.maxParallelism,
             });
             // 3. Analyze closure dependencies and integrate into deployment plan
             const closureDependencies = this.analyzeClosureDependencies(closures, spec, graph.dependencyGraph);
@@ -506,7 +587,7 @@ export class DirectDeploymentEngine {
                 levels: enhancedPlan.levels.length,
                 totalResources: enhancedPlan.totalResources,
                 totalClosures: enhancedPlan.totalClosures,
-                maxParallelism: enhancedPlan.maxParallelism
+                maxParallelism: enhancedPlan.maxParallelism,
             });
             // 4. Create resolution context
             const context = {
@@ -524,7 +605,7 @@ export class DirectDeploymentEngine {
                 const levelLogger = deploymentLogger.child({
                     level: levelIndex + 1,
                     resourceCount: currentLevel.resources.length,
-                    closureCount: currentLevel.closures.length
+                    closureCount: currentLevel.closures.length,
                 });
                 levelLogger.debug(`Deploying level ${levelIndex + 1} with ${currentLevel.resources.length} resources and ${currentLevel.closures.length} closures in parallel`);
                 const levelStartTime = Date.now();
@@ -562,13 +643,13 @@ export class DirectDeploymentEngine {
                                 phase: 'validation',
                                 error,
                                 timestamp: new Date(),
-                            }
+                            },
                         };
                     }
                     resourceLogger.debug('Found resource in graph', {
                         resourceId: resource.id,
                         kind: resource.manifest?.kind,
-                        name: resource.manifest?.metadata?.name
+                        name: resource.manifest?.metadata?.name,
                     });
                     try {
                         resourceLogger.debug('Calling deploySingleResource');
@@ -578,7 +659,7 @@ export class DirectDeploymentEngine {
                         return {
                             success: true,
                             resourceId,
-                            deployedResource
+                            deployedResource,
                         };
                     }
                     catch (error) {
@@ -602,7 +683,7 @@ export class DirectDeploymentEngine {
                                 phase: 'deployment',
                                 error: error,
                                 timestamp: new Date(),
-                            }
+                            },
                         };
                     }
                 });
@@ -612,12 +693,14 @@ export class DirectDeploymentEngine {
                     closureLogger.debug('Executing closure at level', { level: levelIndex + 1 });
                     try {
                         const result = await closureInfo.closure(deploymentContext);
-                        closureLogger.debug('Closure executed successfully', { resultCount: result?.length || 0 });
+                        closureLogger.debug('Closure executed successfully', {
+                            resultCount: result?.length || 0,
+                        });
                         return {
                             success: true,
                             type: 'closure',
                             name: closureInfo.name,
-                            result
+                            result,
                         };
                     }
                     catch (error) {
@@ -631,7 +714,7 @@ export class DirectDeploymentEngine {
                                 phase: 'deployment',
                                 error: error,
                                 timestamp: new Date(),
-                            }
+                            },
                         };
                     }
                 });
@@ -706,23 +789,19 @@ export class DirectDeploymentEngine {
                 // Calculate level performance metrics
                 const levelDuration = Date.now() - levelStartTime;
                 const totalOperations = currentLevel.resources.length + currentLevel.closures.length;
-                const isTestEnvironment = process.env.NODE_ENV === 'test' || process.env.VITEST === 'true';
-                const logLevel = isTestEnvironment ? 'debug' : 'info';
-                levelLogger[logLevel](`Level ${levelIndex + 1} deployment completed`, {
+                levelLogger.info(`Level ${levelIndex + 1} deployment completed`, {
                     resources: { successful: successfulResources, failed: failedResources },
                     closures: { successful: successfulClosures, failed: failedClosures },
                     duration: levelDuration,
                     parallelism: totalOperations,
-                    averageTimePerOperation: totalOperations > 0 ? Math.round(levelDuration / totalOperations) : 0
+                    averageTimePerOperation: totalOperations > 0 ? Math.round(levelDuration / totalOperations) : 0,
                 });
             }
             const duration = Date.now() - startTime;
             const successfulResources = deployedResources.filter((r) => r.status !== 'failed');
             const status = errors.length === 0 ? 'success' : successfulResources.length > 0 ? 'partial' : 'failed';
             // Log comprehensive performance metrics
-            const isTestEnvironment = process.env.NODE_ENV === 'test' || process.env.VITEST === 'true';
-            const logLevel = isTestEnvironment ? 'debug' : 'info';
-            deploymentLogger[logLevel]('Parallel deployment with closures performance metrics', {
+            deploymentLogger.info('Parallel deployment with closures performance metrics', {
                 totalDuration: duration,
                 totalResources: enhancedPlan.totalResources,
                 totalClosures: enhancedPlan.totalClosures,
@@ -731,7 +810,7 @@ export class DirectDeploymentEngine {
                 averageTimePerResource: enhancedPlan.totalResources > 0 ? Math.round(duration / enhancedPlan.totalResources) : 0,
                 successfulResources: successfulResources.length,
                 failedResources: errors.length,
-                status
+                status,
             });
             this.emitEvent(options, {
                 type: status === 'success' ? 'completed' : 'failed',
@@ -804,7 +883,7 @@ export class DirectDeploymentEngine {
         const resourceLogger = this.logger.child({
             resourceId,
             kind: resource.kind,
-            name: resource.metadata?.name
+            name: resource.metadata?.name,
         });
         resourceLogger.debug('Starting single resource deployment');
         this.emitEvent(options, {
@@ -817,7 +896,7 @@ export class DirectDeploymentEngine {
         let resolvedResource;
         try {
             resourceLogger.debug('Resolving resource references', {
-                originalMetadata: resource.metadata
+                originalMetadata: resource.metadata,
             });
             const resolveTimeout = options.timeout || 30000;
             resolvedResource = (await Promise.race([
@@ -826,7 +905,7 @@ export class DirectDeploymentEngine {
             ]));
             resourceLogger.debug('References resolved successfully', {
                 resolvedMetadata: resolvedResource.metadata,
-                hasReadinessEvaluator: !!resolvedResource.readinessEvaluator
+                hasReadinessEvaluator: !!resolvedResource.readinessEvaluator,
             });
         }
         catch (error) {
@@ -834,11 +913,13 @@ export class DirectDeploymentEngine {
             resolvedResource = resource;
         }
         // 2. Apply namespace if specified, but only if resource doesn't already have one
-        if (options.namespace && resolvedResource.metadata && typeof resolvedResource.metadata.namespace !== 'string') {
+        if (options.namespace &&
+            resolvedResource.metadata &&
+            typeof resolvedResource.metadata.namespace !== 'string') {
             resourceLogger.debug('Applying namespace from deployment options', {
                 targetNamespace: options.namespace,
                 currentNamespace: resolvedResource.metadata.namespace,
-                currentNamespaceType: typeof resolvedResource.metadata.namespace
+                currentNamespaceType: typeof resolvedResource.metadata.namespace,
             });
             // Create a completely new metadata object to avoid proxy issues
             const newMetadata = {
@@ -857,7 +938,7 @@ export class DirectDeploymentEngine {
                     value: readinessEvaluator,
                     enumerable: false,
                     configurable: true,
-                    writable: false
+                    writable: false,
                 });
             }
             resolvedResource = newResolvedResource;
@@ -923,7 +1004,7 @@ export class DirectDeploymentEngine {
                         appliedName: appliedResource.metadata?.name,
                         appliedNamespace: appliedResource.metadata?.namespace,
                         operation: existing ? 'patched' : 'created',
-                        attempt
+                        attempt,
                     });
                     // Success - break out of retry loop
                     break;
@@ -940,10 +1021,10 @@ export class DirectDeploymentEngine {
                     resourceLogger.debug('Retrying resource deployment', {
                         attempt: attempt + 1,
                         maxRetries: retryPolicy.maxRetries,
-                        delay
+                        delay,
                     });
                     // Wait before retrying
-                    await new Promise(resolve => setTimeout(resolve, delay));
+                    await new Promise((resolve) => setTimeout(resolve, delay));
                 }
             }
         }
@@ -1018,7 +1099,8 @@ export class DirectDeploymentEngine {
                         this.emitEvent(options, {
                             type: 'resource-ready',
                             resourceId: deployedResource.id,
-                            message: result.message || `${deployedResource.kind}/${deployedResource.name} ready (custom evaluator)`,
+                            message: result.message ||
+                                `${deployedResource.kind}/${deployedResource.name} ready (custom evaluator)`,
                             timestamp: new Date(),
                         });
                         return;
@@ -1034,7 +1116,7 @@ export class DirectDeploymentEngine {
                     });
                 }
                 // Wait before next check
-                await new Promise(resolve => setTimeout(resolve, 2000));
+                await new Promise((resolve) => setTimeout(resolve, 2000));
             }
             catch (error) {
                 // Emit error status event
@@ -1045,7 +1127,7 @@ export class DirectDeploymentEngine {
                     timestamp: new Date(),
                 });
                 // If we can't read the resource, it's not ready yet
-                await new Promise(resolve => setTimeout(resolve, 2000));
+                await new Promise((resolve) => setTimeout(resolve, 2000));
             }
         }
         // Timeout reached
@@ -1089,7 +1171,7 @@ export class DirectDeploymentEngine {
                     error: error,
                     resourceId: resource.id,
                     kind: resource.kind,
-                    name: resource.name
+                    name: resource.name,
                 });
                 errors.push({
                     resourceId: resource.id,
@@ -1134,7 +1216,7 @@ export class DirectDeploymentEngine {
         const deleteLogger = this.logger.child({
             resourceId: resource.id,
             kind: resource.kind,
-            name: resource.name
+            name: resource.name,
         });
         try {
             await this.k8sApi.delete({
@@ -1194,8 +1276,7 @@ export class DirectDeploymentEngine {
         }
         try {
             const { rolledBackResources, errors } = await this.rollbackDeployedResources(deploymentRecord.resources, deploymentRecord.options);
-            const status = errors.length === 0 ? 'success' :
-                rolledBackResources.length > 0 ? 'partial' : 'failed';
+            const status = errors.length === 0 ? 'success' : rolledBackResources.length > 0 ? 'partial' : 'failed';
             return {
                 deploymentId,
                 rolledBackResources,
@@ -1211,12 +1292,14 @@ export class DirectDeploymentEngine {
                 rolledBackResources: [],
                 duration: Date.now() - startTime,
                 status: 'failed',
-                errors: [{
+                errors: [
+                    {
                         resourceId: deploymentId,
                         phase: 'rollback',
                         error: error,
                         timestamp: new Date(),
-                    }],
+                    },
+                ],
             };
         }
     }
@@ -1235,8 +1318,11 @@ export class DirectDeploymentEngine {
         }
         const result = {
             deploymentId,
-            status: deploymentRecord.status === 'completed' ? 'completed' :
-                deploymentRecord.status === 'failed' ? 'failed' : 'running',
+            status: deploymentRecord.status === 'completed'
+                ? 'completed'
+                : deploymentRecord.status === 'failed'
+                    ? 'failed'
+                    : 'running',
             startTime: deploymentRecord.startTime,
             resources: deploymentRecord.resources,
         };
@@ -1268,27 +1354,20 @@ export class DirectDeploymentEngine {
         if (!crdName) {
             logger.warn('Could not determine CRD name for custom resource', {
                 kind: resource.kind,
-                apiVersion: resource.apiVersion
+                apiVersion: resource.apiVersion,
             });
             return;
         }
         logger.debug('Custom resource detected, waiting for CRD establishment', {
             resourceKind: resource.kind,
-            crdName
+            crdName,
         });
         await this.waitForCRDEstablishment({ metadata: { name: crdName } }, options, logger);
         logger.debug('CRD established, proceeding with custom resource deployment', {
             resourceKind: resource.kind,
-            crdName
+            crdName,
         });
     }
-    /**
-     * Check if a resource is a CustomResourceDefinition
-     */
-    isCRD(resource) {
-        return resource.kind === 'CustomResourceDefinition' &&
-            resource.apiVersion?.includes('apiextensions.k8s.io');
-    }
     /**
      * Check if a resource is a custom resource (not a built-in Kubernetes resource)
      */
@@ -1319,7 +1398,7 @@ export class DirectDeploymentEngine {
             'events.k8s.io/v1',
             'flowcontrol.apiserver.k8s.io/v1beta3',
             'node.k8s.io/v1',
-            'scheduling.k8s.io/v1'
+            'scheduling.k8s.io/v1',
         ];
         return !builtInApiGroups.includes(resource.apiVersion);
     }
@@ -1346,8 +1425,7 @@ export class DirectDeploymentEngine {
             // Look for a CRD that matches our group and kind
             const matchingCrd = crds.body?.items?.find((crd) => {
                 const crdSpec = crd.spec;
-                return crdSpec?.group === group &&
-                    crdSpec?.names?.kind === resource.kind;
+                return crdSpec?.group === group && crdSpec?.names?.kind === resource.kind;
             });
             if (matchingCrd) {
                 return matchingCrd.metadata?.name;
@@ -1362,6 +1440,17 @@ export class DirectDeploymentEngine {
         const plural = kind.endsWith('s') ? kind : `${kind}s`;
         return `${plural}.${group}`;
     }
+    /**
+     * Public method to wait for CRD readiness by name
+     */
+    async waitForCRDReady(crdName, timeout = 300000) {
+        const logger = this.logger.child({ crdName, timeout });
+        const options = {
+            mode: this.deploymentMode,
+            timeout,
+        };
+        await this.waitForCRDEstablishment({ metadata: { name: crdName } }, options, logger);
+    }
     /**
      * Wait for a CRD to be established in the cluster
      */
@@ -1377,7 +1466,7 @@ export class DirectDeploymentEngine {
                 const crdStatus = await this.k8sApi.read({
                     apiVersion: 'apiextensions.k8s.io/v1',
                     kind: 'CustomResourceDefinition',
-                    metadata: { name: crdName } // CRDs are cluster-scoped, no namespace needed
+                    metadata: { name: crdName }, // CRDs are cluster-scoped, no namespace needed
                 });
                 const conditions = crdStatus.body?.status?.conditions || [];
                 const establishedCondition = conditions.find((c) => c.type === 'Established');
@@ -1387,7 +1476,7 @@ export class DirectDeploymentEngine {
                 }
                 logger.debug('CRD exists but not yet established, waiting...', {
                     crdName,
-                    establishedStatus: establishedCondition?.status || 'unknown'
+                    establishedStatus: establishedCondition?.status || 'unknown',
                 });
             }
             catch (error) {
@@ -1395,11 +1484,11 @@ export class DirectDeploymentEngine {
                 // This is expected in scenarios where closures install CRDs
                 logger.debug('CRD not found yet, waiting for it to be created...', {
                     crdName,
-                    error: error.message
+                    error: error.message,
                 });
             }
             // Wait before next poll
-            await new Promise(resolve => setTimeout(resolve, pollInterval));
+            await new Promise((resolve) => setTimeout(resolve, pollInterval));
         }
         // Timeout reached
         throw new Error(`Timeout waiting for CRD ${crdName} to be established after ${timeout}ms`);