feat: Add dynamic provider loader with improved error handling

- Create provider-loader.ts with function-based dynamic import functionality
- Update CloudRunner.setupSelectedBuildPlatform to use dynamic loader for unknown providers
- Add comprehensive error handling for missing packages and interface validation
- Include test coverage for successful loading and error scenarios
- Maintain backward compatibility with existing built-in providers
- Add ProviderLoader class wrapper for backward compatibility
- Support both built-in providers (via switch) and external providers (via dynamic import)

src/model/cloud-runner/cloud-runner.ts

@@ -13,6 +13,7 @@ import CloudRunnerEnvironmentVariable from './options/cloud-runner-environment-v
 import TestCloudRunner from './providers/test';
 import LocalCloudRunner from './providers/local';
 import LocalDockerCloudRunner from './providers/docker';
+import loadProvider from './providers/provider-loader';
 import GitHub from '../github';
 import SharedWorkspaceLocking from './services/core/shared-workspace-locking';
 import { FollowLogStreamService } from './services/core/follow-log-stream-service';
@@ -39,7 +40,7 @@ class CloudRunner {
     if (CloudRunner.buildParameters.githubCheckId === ``) {
       CloudRunner.buildParameters.githubCheckId = await GitHub.createGitHubCheck(CloudRunner.buildParameters.buildGuid);
     }
-    CloudRunner.setupSelectedBuildPlatform();
+    await CloudRunner.setupSelectedBuildPlatform();
     CloudRunner.defaultSecrets = TaskParameterSerializer.readDefaultSecrets();
     CloudRunner.cloudRunnerEnvironmentVariables =
       TaskParameterSerializer.createCloudRunnerEnvironmentVariables(buildParameters);
@@ -63,7 +64,7 @@ class CloudRunner {
     FollowLogStreamService.Reset();
   }
 
-  private static setupSelectedBuildPlatform() {
+  private static async setupSelectedBuildPlatform() {
     CloudRunnerLogger.log(`Cloud Runner platform selected ${CloudRunner.buildParameters.providerStrategy}`);
     // Detect LocalStack endpoints and reroute AWS provider to local-docker for CI tests that only need S3
     const endpointsToCheck = [
@@ -88,6 +89,7 @@ class CloudRunner {
       CloudRunnerLogger.log('LocalStack endpoints detected; routing provider to local-docker for this run');
       provider = 'local-docker';
     }
+
     switch (provider) {
       case 'k8s':
         CloudRunner.Provider = new Kubernetes(CloudRunner.buildParameters);
@@ -105,9 +107,18 @@ class CloudRunner {
         CloudRunner.Provider = new LocalCloudRunner();
         break;
       case 'local':
-      default:
         CloudRunner.Provider = new LocalCloudRunner();
         break;
+      default:
+        // Try to load provider using the dynamic loader for unknown providers
+        try {
+          CloudRunner.Provider = await loadProvider(provider, CloudRunner.buildParameters);
+        } catch (error: any) {
+          CloudRunnerLogger.log(`Failed to load provider '${provider}' using dynamic loader: ${error.message}`);
+          CloudRunnerLogger.log('Falling back to local provider...');
+          CloudRunner.Provider = new LocalCloudRunner();
+        }
+        break;
     }
   }
 

src/model/cloud-runner/providers/fixtures/invalid-provider.ts

@@ -0,0 +1 @@
+export default class InvalidProvider {}

src/model/cloud-runner/providers/provider-loader.test.ts

@@ -0,0 +1,19 @@
+import loadProvider from './provider-loader';
+import { ProviderInterface } from './provider-interface';
+
+describe('provider-loader', () => {
+  it('loads a provider dynamically', async () => {
+    const provider: ProviderInterface = await loadProvider('./test', {} as any);
+    expect(typeof provider.runTaskInWorkflow).toBe('function');
+  });
+
+  it('throws when provider package is missing', async () => {
+    await expect(loadProvider('non-existent-package', {} as any)).rejects.toThrow('non-existent-package');
+  });
+
+  it('throws when provider does not implement ProviderInterface', async () => {
+    await expect(loadProvider('./fixtures/invalid-provider', {} as any)).rejects.toThrow(
+      'does not implement ProviderInterface',
+    );
+  });
+});

src/model/cloud-runner/providers/provider-loader.ts

@@ -0,0 +1,87 @@
+import { ProviderInterface } from './provider-interface';
+import BuildParameters from '../../build-parameters';
+import CloudRunnerLogger from '../services/core/cloud-runner-logger';
+
+/**
+ * Dynamically load a provider package by name.
+ * @param providerName Name of the provider package to load
+ * @param buildParameters Build parameters passed to the provider constructor
+ * @throws Error when the provider cannot be loaded or does not implement ProviderInterface
+ */
+export default async function loadProvider(
+  providerName: string,
+  buildParameters: BuildParameters,
+): Promise<ProviderInterface> {
+  CloudRunnerLogger.log(`Loading provider: ${providerName}`);
+  
+  let importedModule: any;
+  try {
+    // Map provider names to their module paths for built-in providers
+    const providerModuleMap: Record<string, string> = {
+      'aws': './aws',
+      'k8s': './k8s',
+      'test': './test',
+      'local-docker': './docker',
+      'local-system': './local',
+      'local': './local'
+    };
+
+    const modulePath = providerModuleMap[providerName] || providerName;
+    importedModule = await import(modulePath);
+  } catch (error) {
+    throw new Error(`Failed to load provider package '${providerName}': ${(error as Error).message}`);
+  }
+
+  const Provider = importedModule.default || importedModule;
+  let instance: any;
+  try {
+    instance = new Provider(buildParameters);
+  } catch (error) {
+    throw new Error(`Failed to instantiate provider '${providerName}': ${(error as Error).message}`);
+  }
+
+  const requiredMethods = [
+    'cleanupWorkflow',
+    'setupWorkflow',
+    'runTaskInWorkflow',
+    'garbageCollect',
+    'listResources',
+    'listWorkflow',
+    'watchWorkflow',
+  ];
+
+  for (const method of requiredMethods) {
+    if (typeof instance[method] !== 'function') {
+      throw new Error(
+        `Provider package '${providerName}' does not implement ProviderInterface. Missing method '${method}'.`,
+      );
+    }
+  }
+
+  CloudRunnerLogger.log(`Successfully loaded provider: ${providerName}`);
+  return instance as ProviderInterface;
+}
+
+/**
+ * ProviderLoader class for backward compatibility and additional utilities
+ */
+export class ProviderLoader {
+  /**
+   * Dynamically loads a provider by name (wrapper around loadProvider function)
+   * @param providerName - The name of the provider to load
+   * @param buildParameters - Build parameters to pass to the provider constructor
+   * @returns Promise<ProviderInterface> - The loaded provider instance
+   * @throws Error if provider package is missing or doesn't implement ProviderInterface
+   */
+  static async loadProvider(providerName: string, buildParameters: BuildParameters): Promise<ProviderInterface> {
+    return loadProvider(providerName, buildParameters);
+  }
+
+  /**
+   * Gets a list of available provider names
+   * @returns string[] - Array of available provider names
+   */
+  static getAvailableProviders(): string[] {
+    return ['aws', 'k8s', 'test', 'local-docker', 'local-system', 'local'];
+  }
+}

src/model/index.ts

@@ -10,6 +10,7 @@ import Project from './project';
 import Unity from './unity';
 import Versioning from './versioning';
 import CloudRunner from './cloud-runner/cloud-runner';
+import loadProvider, { ProviderLoader } from './cloud-runner/providers/provider-loader';
 
 export {
   Action,
@@ -24,4 +25,6 @@ export {
   Unity,
   Versioning,
   CloudRunner as CloudRunner,
+  loadProvider,
+  ProviderLoader,
 };