@nexical/cli 0.11.23 → 0.12.0

package/test/unit/deploy/providers/railway.test.ts

@@ -1,7 +1,8 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { describe, it, expect, vi, beforeEach, afterEach, type Mock } from 'vitest';
 import { RailwayProvider } from '../../../../src/deploy/providers/railway.js';
 import { execAsync } from '../../../../src/deploy/utils.js';
 import { logger } from '@nexical/cli-core';
+import { DeploymentContext, AppConfig } from '../../../../src/deploy/types.js';
 
 vi.mock('../../../../src/deploy/utils.js');
 vi.mock('@nexical/cli-core', () => ({
@@ -10,22 +11,30 @@ vi.mock('@nexical/cli-core', () => ({
     error: vi.fn(),
     warn: vi.fn(),
     debug: vi.fn(),
+    success: vi.fn(),
   },
 }));
 
 describe('RailwayProvider', () => {
   let provider: RailwayProvider;
-  let mockContext: { cwd: string; options: Record<string, unknown>; config: any };
+  let mockContext: DeploymentContext;
+  let mockApp: AppConfig;
 
   beforeEach(() => {
     vi.resetAllMocks();
     provider = new RailwayProvider();
     mockContext = {
       cwd: '/mock',
-      options: {}, // Env undefined by default
-      config: { deploy: { backend: { projectName: 'my-proj' } } },
+      options: {},
+      config: { deploy: { repository: { provider: 'github' }, apps: {} } },
+    } as unknown as DeploymentContext;
+    mockApp = {
+      name: 'backend',
+      provider: 'railway',
+      projectName: 'my-proj',
+      target: 'apps/backend',
     };
-    (execAsync as unknown as { mockResolvedValue: any }).mockResolvedValue({
+    (execAsync as Mock).mockResolvedValue({
       stdout: '',
       stderr: '',
     });
@@ -35,296 +44,76 @@ describe('RailwayProvider', () => {
     vi.clearAllMocks();
     delete process.env.RAILWAY_API_TOKEN;
     delete process.env.RAILWAY_TOKEN;
-    delete process.env.CUSTOM_RW_TOKEN;
   });
 
   describe('provision', () => {
-    it('should default to production environment if options.env is missing', async () => {
-      // mockContext.options.env is undefined
-      (execAsync as unknown as { mockResolvedValueOnce: any }).mockResolvedValueOnce({
-        stdout: 'Linked',
-      }); // status
-      (execAsync as unknown as { mockResolvedValueOnce: any }).mockResolvedValueOnce({
-        stdout: 'postgres',
-      }); // postgres check
-
-      await provider.provision(mockContext);
-
-      // Should stick to baseProjectName 'my-proj'
-      expect(execAsync).not.toHaveBeenCalledWith(
-        expect.stringContaining('my-proj-production'),
-        expect.anything(),
-      );
-    });
-
-    it('should error if project name missing', async () => {
-      mockContext.config.deploy.backend.projectName = undefined;
-      await expect(provider.provision(mockContext)).rejects.toThrow(
-        'Railway project name not found',
-      );
-    });
-
     it('should handle dry run', async () => {
       mockContext.options.dryRun = true;
-      await provider.provision(mockContext);
+      await provider.provision(mockContext, mockApp);
       expect(logger.info).toHaveBeenCalledWith(expect.stringContaining('[Dry Run]'));
       expect(execAsync).not.toHaveBeenCalled();
     });
 
-    it('should handle deleted project', async () => {
-      // Use real Error to trigger 'instanceof Error' branch
-      (execAsync as unknown as { mockRejectedValueOnce: any }).mockRejectedValueOnce(
-        Object.assign(new Error('Error'), { stderr: 'Project is deleted' }),
-      );
-      (execAsync as unknown as { mockResolvedValueOnce: any }).mockResolvedValueOnce({
-        stdout: 'Linked',
-      }); // init
-      (execAsync as unknown as { mockResolvedValueOnce: any }).mockResolvedValueOnce({
-        stdout: 'postgres',
-      }); // postgres check
-
-      await provider.provision(mockContext);
+    it('should provision successfully', async () => {
+      process.env.RAILWAY_TOKEN = 'tok';
+      (execAsync as Mock).mockResolvedValueOnce({ stdout: 'ok' }); // status
 
-      expect(execAsync).toHaveBeenCalledWith('railway unlink', expect.anything());
-    });
+      await provider.provision(mockContext, mockApp);
 
-    it('should handle unlink failure (deleted project)', async () => {
-      (execAsync as unknown as { mockRejectedValueOnce: any }).mockRejectedValueOnce(
-        Object.assign(new Error('Error'), { stderr: 'Project is deleted' }),
-      );
-      (execAsync as unknown as { mockRejectedValueOnce: any }).mockRejectedValueOnce(
-        new Error('Unlink failed'),
-      ); // unlink fail
-      (execAsync as unknown as { mockResolvedValueOnce: any }).mockResolvedValueOnce({
-        stdout: 'Linked',
-      }); // init
-      (execAsync as unknown as { mockResolvedValueOnce: any }).mockResolvedValueOnce({
-        stdout: 'postgres',
-      }); // postgres check
-
-      await provider.provision(mockContext);
-      // Should proceed to init despite unlink fail
       expect(execAsync).toHaveBeenCalledWith(
-        expect.stringContaining('railway init'),
+        expect.stringContaining('railway status'),
         expect.anything(),
       );
     });
 
-    it('should check status and init if not linked', async () => {
-      (execAsync as unknown as { mockRejectedValueOnce: any }).mockRejectedValueOnce(
-        Object.assign(new Error('Error'), { stderr: 'Project not found' }),
-      );
-      (execAsync as unknown as { mockResolvedValueOnce: any }).mockResolvedValueOnce({
-        stdout: 'Linked',
-      });
-      (execAsync as unknown as { mockResolvedValueOnce: any }).mockResolvedValueOnce({
-        stdout: 'postgres',
-      });
+    it('should warn if auto-add service fails', async () => {
+      process.env.RAILWAY_TOKEN = 'tok';
+      mockApp.railway = {
+        services: [{ type: 'database', name: 'postgres' }],
+      };
 
-      await provider.provision(mockContext);
+      (execAsync as Mock).mockResolvedValueOnce({ stdout: 'ok' }); // status
+      (execAsync as Mock).mockResolvedValueOnce({ stdout: 'empty' }); // list
+      (execAsync as Mock).mockRejectedValueOnce(new Error('Add failed')); // add
 
-      expect(execAsync).toHaveBeenCalledWith(
-        expect.stringContaining('railway init --name my-proj'),
-        expect.anything(),
-      );
-    });
-
-    it('should throw on auth failure', async () => {
-      (execAsync as unknown as { mockRejectedValueOnce: any }).mockRejectedValueOnce(
-        Object.assign(new Error('Error'), { stderr: 'Unauthorized' }),
-      );
-
-      await expect(provider.provision(mockContext)).rejects.toThrow(
-        'Railway authentication failed',
-      );
-    });
-
-    it('should warn on generic status failure with Error object', async () => {
-      (execAsync as unknown as { mockRejectedValueOnce: any }).mockRejectedValueOnce(
-        new Error('Timeout'),
-      ); // generic
-      (execAsync as unknown as { mockResolvedValueOnce: any }).mockResolvedValueOnce({
-        stdout: 'postgres',
-      }); // postgres check pass
-
-      await provider.provision(mockContext);
+      await provider.provision(mockContext, mockApp);
 
       expect(logger.warn).toHaveBeenCalledWith(
-        expect.stringContaining('Railway status check failed'),
-      );
-    });
-
-    it('should warn on generic status failure with string error', async () => {
-      (execAsync as unknown as { mockRejectedValueOnce: any }).mockRejectedValueOnce(
-        'Timeout String',
-      );
-      (execAsync as unknown as { mockResolvedValueOnce: any }).mockResolvedValueOnce({
-        stdout: 'postgres',
-      });
-
-      await provider.provision(mockContext);
-
-      expect(logger.warn).toHaveBeenCalledWith(
-        expect.stringContaining('Railway status check failed: Timeout String'),
-      );
-    });
-
-    it('should add postgres if missing', async () => {
-      (execAsync as unknown as { mockResolvedValueOnce: any }).mockResolvedValueOnce({
-        stdout: 'ok',
-      }); // status ok
-      (execAsync as unknown as { mockResolvedValueOnce: any }).mockResolvedValueOnce({
-        stdout: 'empty',
-      }); // postgres missing
-      (execAsync as unknown as { mockResolvedValueOnce: any }).mockResolvedValueOnce({
-        stdout: 'db added',
-      }); // add db
-
-      await provider.provision(mockContext);
-
-      expect(execAsync).toHaveBeenCalledWith(
-        expect.stringContaining('railway add --database postgres'),
-        expect.anything(),
-      );
-    });
-
-    it('should handle second status check failure (swallow error)', async () => {
-      (execAsync as unknown as { mockResolvedValueOnce: any }).mockResolvedValueOnce({
-        stdout: 'ok',
-      }); // status ok
-      (execAsync as unknown as { mockRejectedValueOnce: any }).mockRejectedValueOnce(
-        new Error('Status2 fail'),
-      ); // status2 fail -> catch -> { stdout: '' }
-      // If stdout is empty, it proceeds to add postgres?
-      // Line 78: if (!status.includes('postgres')) -> '' doesn't include it -> true.
-      (execAsync as unknown as { mockResolvedValueOnce: any }).mockResolvedValueOnce({
-        stdout: 'db added',
-      }); // add db
-
-      await provider.provision(mockContext);
-
-      expect(execAsync).toHaveBeenCalledWith(
-        expect.stringContaining('railway add --database postgres'),
-        expect.anything(),
-      );
-    });
-
-    it('should handle postgres status check failure (explicit throw in add logic check)', async () => {
-      // This tests the logic flow, but "Status2 fail" catch block return value triggers "add"
-      // My previous test above covers the catch block.
-    });
-
-    it('should warn if auto-add postgres fails', async () => {
-      (execAsync as unknown as { mockResolvedValueOnce: any }).mockResolvedValueOnce({
-        stdout: 'ok',
-      }); // status ok
-      (execAsync as unknown as { mockResolvedValueOnce: any }).mockResolvedValueOnce({
-        stdout: 'empty',
-      }); // postgres missing
-      (execAsync as unknown as { mockRejectedValueOnce: any }).mockRejectedValueOnce(
-        new Error('Add failed'),
-      ); // add db fail
-
-      await provider.provision(mockContext);
-
-      expect(logger.warn).toHaveBeenCalledWith('Failed to auto-add PostgreSQL.');
-    });
-
-    it('should log generic setup failures', async () => {
-      const err = new Error('Generic failure') as any;
-      err.stderr = 'some stderr';
-      err.stdout = 'some stdout';
-
-      (execAsync as unknown as { mockRejectedValueOnce: any }).mockRejectedValueOnce(
-        Object.assign(new Error('Error'), { stderr: 'Project not found' }),
-      );
-      (execAsync as any).mockRejectedValueOnce(err);
-
-      await provider.provision(mockContext);
-
-      expect(logger.error).toHaveBeenCalledWith(
-        expect.stringContaining('Railway setup failed with error: Generic failure'),
-      );
-    });
-
-    it('should handle setup failure with empty output', async () => {
-      const errEmpty = new Error('Empty fail') as any;
-      (execAsync as unknown as { mockRejectedValueOnce: any }).mockRejectedValueOnce(
-        Object.assign(new Error('Error'), { stderr: 'Project not found' }),
-      );
-      (execAsync as any).mockRejectedValueOnce(errEmpty);
-
-      await provider.provision(mockContext);
-
-      expect(logger.error).toHaveBeenCalledWith(
-        expect.stringContaining('Railway setup failed with error: Empty fail'),
-      );
-    });
-
-    it('should handle non-Error exceptions in outer catch', async () => {
-      (execAsync as unknown as { mockRejectedValueOnce: any }).mockRejectedValueOnce(
-        Object.assign(new Error('Error'), { stderr: 'Project not found' }),
-      );
-      (execAsync as any).mockRejectedValueOnce('String setup error');
-
-      await provider.provision(mockContext);
-
-      expect(logger.error).toHaveBeenCalledWith(
-        expect.stringContaining('Railway setup failed with error: String setup error'),
-      );
-    });
-
-    it('should handle non-production environment', async () => {
-      mockContext.options.env = 'staging';
-      (execAsync as unknown as { mockRejectedValueOnce: any }).mockRejectedValueOnce(
-        Object.assign(new Error('Error'), { stderr: 'Project not found' }),
-      );
-
-      await provider.provision(mockContext);
-
-      expect(execAsync).toHaveBeenCalledWith(
-        expect.stringContaining('railway init --name my-proj-staging'),
-        expect.anything(),
+        expect.stringContaining('Failed to auto-add postgres database'),
       );
     });
   });
 
   describe('getSecrets', () => {
-    it('should resolve token from env', async () => {
-      process.env.RAILWAY_API_TOKEN = 'tok';
-      const secrets = await provider.getSecrets(mockContext);
-      expect(secrets['RAILWAY_API_TOKEN']).toBe('tok');
-      delete process.env.RAILWAY_API_TOKEN;
-    });
-
-    it('should resolve token from configured env var', async () => {
-      mockContext.config.deploy.backend.options = { tokenEnvVar: 'CUSTOM_RW_TOKEN' };
-      process.env.CUSTOM_RW_TOKEN = 'custom-rw-tok';
-
-      const secrets = await provider.getSecrets(mockContext);
-      expect(secrets['RAILWAY_API_TOKEN']).toBe('custom-rw-tok');
+    it('should resolve secrets', async () => {
+      process.env.RAILWAY_TOKEN = 'tok';
+      mockApp.secrets = { KEY: 'SOME_ENV' };
+      process.env.SOME_ENV = 'VALUE';
 
-      delete process.env.CUSTOM_RW_TOKEN;
-    });
+      const secrets = await provider.getSecrets(mockContext, mockApp);
+      expect(secrets['RAILWAY_API_TOKEN']).toBe('tok');
+      expect(secrets['KEY']).toBe('VALUE');
 
-    it('should error if token missing', async () => {
-      delete process.env.RAILWAY_API_TOKEN;
-      delete process.env.RAILWAY_TOKEN;
-      await expect(provider.getSecrets(mockContext)).rejects.toThrow('Railway Token not found');
+      delete process.env.SOME_ENV;
     });
   });
 
   describe('getVariables', () => {
-    it('should return project name', async () => {
-      expect(await provider.getVariables(mockContext)).toEqual({
-        RAILWAY_PROJECT_NAME: 'my-proj',
-      });
+    it('should return project and environment variables', async () => {
+      const vars = await provider.getVariables(mockContext, mockApp);
+      expect(vars['RAILWAY_PROJECT_NAME']).toBe('my-proj');
+      expect(vars['RAILWAY_ENVIRONMENT']).toBe('production');
     });
   });
 
-  describe('getCIConfig', () => {
-    it('should return config', () => {
-      expect(provider.getCIConfig()).toHaveProperty('deploySteps');
+  describe('deploy', () => {
+    it('should run railway up', async () => {
+      process.env.RAILWAY_TOKEN = 'tok';
+      await provider.deploy(mockContext, mockApp);
+      expect(execAsync).toHaveBeenCalledWith(
+        expect.stringContaining('railway up'),
+        expect.anything(),
+      );
     });
   });
 });

package/test/unit/deploy/registry.test.ts

@@ -35,9 +35,9 @@ describe('ProviderRegistry', () => {
     vi.restoreAllMocks();
   });
 
-  describe('getDeploymentProvider', () => {
+  describe('getHostingProvider', () => {
     it('should return undefined for non-existent provider', () => {
-      expect(registry.getDeploymentProvider('missing')).toBeUndefined();
+      expect(registry.getHostingProvider('missing')).toBeUndefined();
     });
   });
 
@@ -49,9 +49,9 @@ describe('ProviderRegistry', () => {
         getCIConfig() {}
       };
       (
-        registry as unknown as { registerProviderFromModule: (mod: any, name: string) => void }
+        registry as unknown as { registerProviderFromModule: (mod: unknown, name: string) => void }
       ).registerProviderFromModule({ default: MockProvider }, 'test');
-      expect(registry.getDeploymentProvider('valid-deploy')).toBeDefined();
+      expect(registry.getHostingProvider('valid-deploy')).toBeDefined();
     });
 
     it('should register a valid repository provider', () => {
@@ -61,7 +61,7 @@ describe('ProviderRegistry', () => {
         generateWorkflow() {}
       };
       (
-        registry as unknown as { registerProviderFromModule: (mod: any, name: string) => void }
+        registry as unknown as { registerProviderFromModule: (mod: unknown, name: string) => void }
       ).registerProviderFromModule({ default: MockProvider }, 'test');
       expect(registry.getRepositoryProvider('valid-repo')).toBeDefined();
     });
@@ -73,19 +73,19 @@ describe('ProviderRegistry', () => {
         getCIConfig() {}
       };
       (
-        registry as unknown as { registerProviderFromModule: (mod: any, name: string) => void }
+        registry as unknown as { registerProviderFromModule: (mod: unknown, name: string) => void }
       ).registerProviderFromModule({ Named: MockProvider }, 'test');
-      expect(registry.getDeploymentProvider('named-export')).toBeDefined();
+      expect(registry.getHostingProvider('named-export')).toBeDefined();
     });
 
     it('should handle missing exported provider', async () => {
       const mockModule = {};
       await (
         registry as unknown as {
-          registerProviderFromModule: (mod: any, name: string) => Promise<void>;
+          registerProviderFromModule: (mod: unknown, name: string) => Promise<void>;
         }
       ).registerProviderFromModule(mockModule, 'test');
-      expect(registry.getDeploymentProvider('test')).toBeUndefined();
+      expect(registry.getHostingProvider('test')).toBeUndefined();
     });
 
     it('should handle instantiation failure', async () => {
@@ -95,20 +95,20 @@ describe('ProviderRegistry', () => {
       const mockModule = { Provider: MockProvider };
       await (
         registry as unknown as {
-          registerProviderFromModule: (mod: any, name: string) => Promise<void>;
+          registerProviderFromModule: (mod: unknown, name: string) => Promise<void>;
         }
       ).registerProviderFromModule(mockModule, 'fail');
-      expect(registry.getDeploymentProvider('fail')).toBeUndefined();
+      expect(registry.getHostingProvider('fail')).toBeUndefined();
     });
 
     it('should handle non-class provider', async () => {
       const mockModule = { Provider: { name: 'static' } };
       await (
         registry as unknown as {
-          registerProviderFromModule: (mod: any, name: string) => Promise<void>;
+          registerProviderFromModule: (mod: unknown, name: string) => Promise<void>;
         }
       ).registerProviderFromModule(mockModule, 'static');
-      expect(registry.getDeploymentProvider('static')).toBeUndefined();
+      expect(registry.getHostingProvider('static')).toBeUndefined();
     });
   });
 
@@ -136,7 +136,7 @@ describe('ProviderRegistry', () => {
 
       // Assert
       expect(fs.readdir).toHaveBeenCalled();
-      expect(registry.getDeploymentProvider('core-mock')).toBeDefined();
+      expect(registry.getHostingProvider('core-mock')).toBeDefined();
     });
 
     it('should warn if no providers directory found', async () => {
@@ -196,7 +196,7 @@ describe('ProviderRegistry', () => {
       await registry.loadLocalProviders(mockRoot);
 
       expect(mockJitiRequest).toHaveBeenCalledWith(path.join(deployDir, 'custom.ts'));
-      expect(registry.getDeploymentProvider('local-custom')).toBeDefined();
+      expect(registry.getHostingProvider('local-custom')).toBeDefined();
     });
 
     it('should ignore non-js/ts files', async () => {
@@ -246,11 +246,14 @@ describe('ProviderRegistry', () => {
 
     it('should handle non-Error during registration in loadCoreProviders', async () => {
       vi.spyOn(fs, 'access').mockResolvedValue(undefined);
-      vi.spyOn(fs, 'readdir').mockResolvedValue(['fail-registration.js'] as any);
+      vi.spyOn(fs, 'readdir').mockResolvedValue(['fail-registration.js'] as unknown as never);
 
       // Mock registerProviderFromModule to throw a string
       const regSpy = vi
-        .spyOn(registry as any, 'registerProviderFromModule')
+        .spyOn(
+          registry as unknown as { registerProviderFromModule: (m: unknown, s: string) => void },
+          'registerProviderFromModule',
+        )
         .mockImplementation(() => {
           throw 'Registration string fail';
         });

package/tsup.config.ts

@@ -12,6 +12,9 @@ export default <Options>{
   splitting: true,
   outDir: 'dist',
   shims: true, // Enable shims (including __require shim for legacy deps)
+  loader: {
+    '.yaml': 'copy',
+  },
   banner: {
     js: 'import { createRequire } from "module"; const require = createRequire(import.meta.url);',
   },

package/dist/chunk-2FKDEDDE.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/deploy/config-manager.ts"],"sourcesContent":["import fs from 'node:fs/promises';\nimport path from 'node:path';\nimport YAML from 'yaml';\nimport { NexicalConfig } from './types';\n\nexport class ConfigManager {\n  private configPath: string;\n\n  constructor(cwd: string) {\n    this.configPath = path.join(cwd, 'nexical.yaml');\n  }\n\n  async load(): Promise<NexicalConfig> {\n    try {\n      const content = await fs.readFile(this.configPath, 'utf-8');\n      return YAML.parse(content) as NexicalConfig;\n    } catch (error: unknown) {\n      if (\n        error &&\n        typeof error === 'object' &&\n        'code' in error &&\n        (error as { code: unknown }).code === 'ENOENT'\n      ) {\n        return {};\n      }\n      throw error;\n    }\n  }\n\n  async save(config: NexicalConfig): Promise<void> {\n    const content = YAML.stringify(config);\n    await fs.writeFile(this.configPath, content, 'utf-8');\n  }\n\n  exists(): Promise<boolean> {\n    return fs\n      .access(this.configPath)\n      .then(() => true)\n      .catch(() => false);\n  }\n}\n"],"mappings":";;;;;;AAAA;AAAA,OAAO,QAAQ;AACf,OAAO,UAAU;AACjB,OAAO,UAAU;AAGV,IAAM,gBAAN,MAAoB;AAAA,EACjB;AAAA,EAER,YAAY,KAAa;AACvB,SAAK,aAAa,KAAK,KAAK,KAAK,cAAc;AAAA,EACjD;AAAA,EAEA,MAAM,OAA+B;AACnC,QAAI;AACF,YAAM,UAAU,MAAM,GAAG,SAAS,KAAK,YAAY,OAAO;AAC1D,aAAO,KAAK,MAAM,OAAO;AAAA,IAC3B,SAAS,OAAgB;AACvB,UACE,SACA,OAAO,UAAU,YACjB,UAAU,SACT,MAA4B,SAAS,UACtC;AACA,eAAO,CAAC;AAAA,MACV;AACA,YAAM;AAAA,IACR;AAAA,EACF;AAAA,EAEA,MAAM,KAAK,QAAsC;AAC/C,UAAM,UAAU,KAAK,UAAU,MAAM;AACrC,UAAM,GAAG,UAAU,KAAK,YAAY,SAAS,OAAO;AAAA,EACtD;AAAA,EAEA,SAA2B;AACzB,WAAO,GACJ,OAAO,KAAK,UAAU,EACtB,KAAK,MAAM,IAAI,EACf,MAAM,MAAM,KAAK;AAAA,EACtB;AACF;","names":[]}

package/dist/chunk-EKCOW7FM.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/deploy/registry.ts"],"sourcesContent":["import path from 'node:path';\nimport fs from 'node:fs/promises';\nimport { logger } from '@nexical/cli-core';\nimport { DeploymentProvider, RepositoryProvider } from './types';\n\nexport class ProviderRegistry {\n  private deploymentProviders: Map<string, DeploymentProvider> = new Map();\n  private repositoryProviders: Map<string, RepositoryProvider> = new Map();\n\n  registerDeploymentProvider(provider: DeploymentProvider) {\n    this.deploymentProviders.set(provider.name, provider);\n  }\n\n  registerRepositoryProvider(provider: RepositoryProvider) {\n    this.repositoryProviders.set(provider.name, provider);\n  }\n\n  getDeploymentProvider(name: string): DeploymentProvider | undefined {\n    return this.deploymentProviders.get(name);\n  }\n\n  getRepositoryProvider(name: string): RepositoryProvider | undefined {\n    return this.repositoryProviders.get(name);\n  }\n\n  private registerProviderFromModule(module: unknown, source: string) {\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    const moduleAny = module as any;\n    let provider = moduleAny.default;\n\n    // Handle named exports if default is missing (fallback)\n    if (!provider && Object.keys(moduleAny).length > 0) {\n      // Try to find a class export that looks like a provider\n      for (const key of Object.keys(moduleAny)) {\n        if (typeof moduleAny[key] === 'function') {\n          provider = moduleAny[key];\n          break;\n        }\n      }\n    }\n\n    // If it's a class, instantiate it\n    if (typeof provider === 'function') {\n      try {\n        provider = new provider();\n      } catch {\n        // Not a constructor or failed\n      }\n    }\n\n    if (provider) {\n      if (typeof provider.provision === 'function' && typeof provider.getCIConfig === 'function') {\n        logger.info(`[Registry] Loaded ${source} deployment provider: ${provider.name}`);\n        this.registerDeploymentProvider(provider as DeploymentProvider);\n      } else if (\n        typeof provider.configureSecrets === 'function' &&\n        typeof provider.generateWorkflow === 'function'\n      ) {\n        logger.info(`[Registry] Loaded ${source} repository provider: ${provider.name}`);\n        this.registerRepositoryProvider(provider as RepositoryProvider);\n      }\n    }\n  }\n\n  async loadCoreProviders() {\n    const dirname = path.dirname(new URL(import.meta.url).pathname);\n\n    // Try multiple paths to find the providers directory\n    // 1. 'providers' - Standard source structure / flattened dist\n    // 2. 'src/deploy/providers' - tsup output (chunk in root, files in src/...)\n    const candidates = [\n      path.join(dirname, 'providers'),\n      path.join(dirname, 'src/deploy/providers'),\n    ];\n\n    let providersDir = '';\n    for (const candidate of candidates) {\n      try {\n        await fs.access(candidate);\n        providersDir = candidate;\n        break;\n      } catch {\n        // Ignore missing dir\n      }\n    }\n\n    if (!providersDir) {\n      logger.warn(\n        `[Registry] Could not locate core providers directory. Checked: ${candidates.join(', ')}`,\n      );\n      return;\n    }\n\n    try {\n      const files = await fs.readdir(providersDir);\n      for (const file of files) {\n        if (file.endsWith('.js') || (file.endsWith('.ts') && !file.endsWith('.d.ts'))) {\n          try {\n            const providerPath = path.join(providersDir, file);\n            const module = await import(providerPath);\n            this.registerProviderFromModule(module, 'core');\n          } catch (e: unknown) {\n            const message = e instanceof Error ? e.message : String(e);\n            logger.warn(`Failed to load core provider from ${file}: ${message}`);\n          }\n        }\n      }\n    } catch (e: unknown) {\n      const message = e instanceof Error ? e.message : String(e);\n      logger.warn(`Failed to scan core providers at ${providersDir}: ${message}`);\n    }\n  }\n\n  async loadLocalProviders(cwd: string) {\n    const deployDir = path.join(cwd, 'deploy');\n    try {\n      const files = await fs.readdir(deployDir);\n      for (const file of files) {\n        if (file.endsWith('.ts') || file.endsWith('.js')) {\n          try {\n            const providerPath = path.join(deployDir, file);\n            // Use jiti to load TS/JS files dynamically\n            const jiti = (await import('jiti')).createJiti(import.meta.url);\n            const module = (await jiti.import(providerPath)) as unknown;\n            this.registerProviderFromModule(module, 'local');\n          } catch (e: unknown) {\n            const message = e instanceof Error ? e.message : String(e);\n            logger.warn(`Failed to load local provider from ${file}: ${message}`);\n          }\n        }\n      }\n    } catch {\n      // Ignore if deploy dir doesn't exist\n    }\n  }\n}\n"],"mappings":"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","names":[]}