fix: add timeout to registryValidation to prevent CLI hang (#2027)

.changeset/fix-registry-timeout-1774022951.md

@@ -0,0 +1,5 @@
+---
+"@asyncapi/cli": patch
+---
+
+Fix: add timeout to registry URL validation to prevent CLI hanging on unreachable servers

src/utils/generate/registry.ts

@@ -8,12 +8,26 @@
 
 export async function registryValidation(registryUrl?: string, registryAuth?: string, registryToken?: string) {
   if (!registryUrl) { return; }
+
+  const controller = new AbortController();
+  const timeoutMs = 5000;
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+
   try {
-    const response = await fetch(registryUrl as string);
+    const response = await fetch(registryUrl as string, {
+      method: 'HEAD',
+      signal: controller.signal,
+    });
     if (response.status === 401 && !registryAuth && !registryToken) {
       throw new Error('You Need to pass either registryAuth in username:password encoded in Base64 or need to pass registryToken');
     }
-  } catch {
-    throw new Error(`Can't fetch registryURL: ${registryUrl}`);
+  } catch (error: unknown) {
+    if (error instanceof Error && error.name === 'AbortError') {
+      throw new Error(`Registry URL timed out after ${timeoutMs / 1000} seconds: ${registryUrl}`);
+    }
+    const originalMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(`Can't fetch registryURL: ${registryUrl}. Error: ${originalMessage}`);
+  } finally {
+    clearTimeout(timeout);
   }
 }

test/unit/utils/registry.test.ts

@@ -0,0 +1,82 @@
+import { registryURLParser, registryValidation } from '../../../src/utils/generate/registry';
+
+describe('registryURLParser', () => {
+  it('should return undefined for empty input', () => {
+    expect(registryURLParser()).toBeUndefined();
+    expect(registryURLParser('')).toBeUndefined();
+  });
+
+  it('should accept valid http URLs', () => {
+    expect(() => registryURLParser('http://example.com')).not.toThrow();
+    expect(() => registryURLParser('https://registry.example.com/api')).not.toThrow();
+  });
+
+  it('should reject non-http URLs', () => {
+    expect(() => registryURLParser('ftp://example.com')).toThrow('Invalid --registry-url flag');
+    expect(() => registryURLParser('file:///path/to/file')).toThrow('Invalid --registry-url flag');
+    expect(() => registryURLParser('not-a-url')).toThrow('Invalid --registry-url flag');
+  });
+});
+
+describe('registryValidation', () => {
+  it('should return undefined for empty URL', async () => {
+    await expect(registryValidation()).resolves.toBeUndefined();
+    await expect(registryValidation('')).resolves.toBeUndefined();
+  });
+
+  it('should timeout after 5 seconds on unreachable URL', async () => {
+    // Use a TEST-NET IP that is guaranteed to be unreachable (RFC 5737)
+    // This should trigger the AbortController timeout
+    const result = registryValidation('http://192.0.2.1:9999/registry');
+    await expect(result).rejects.toThrow('timed out');
+  }, 10000); // Allow 10s for the test (5s timeout + buffer)
+
+  it('should throw with URL context on connection error', async () => {
+    // localhost:1 should immediately refuse connection
+    await expect(registryValidation('http://localhost:1/nonexistent'))
+      .rejects.toThrow('Can\'t fetch registryURL');
+  });
+
+  it('should throw when 401 without auth credentials', async () => {
+    // Mock fetch to return 401
+    const originalFetch = global.fetch;
+    global.fetch = jest.fn().mockResolvedValue({
+      status: 401,
+    });
+
+    try {
+      await expect(registryValidation('http://example.com/registry'))
+        .rejects.toThrow('registryAuth');
+    } finally {
+      global.fetch = originalFetch;
+    }
+  });
+
+  it('should not throw when 401 with registryAuth provided', async () => {
+    const originalFetch = global.fetch;
+    global.fetch = jest.fn().mockResolvedValue({
+      status: 401,
+    });
+
+    try {
+      await expect(registryValidation('http://example.com/registry', 'dXNlcjpwYXNz'))
+        .resolves.toBeUndefined();
+    } finally {
+      global.fetch = originalFetch;
+    }
+  });
+
+  it('should not throw when 401 with registryToken provided', async () => {
+    const originalFetch = global.fetch;
+    global.fetch = jest.fn().mockResolvedValue({
+      status: 401,
+    });
+
+    try {
+      await expect(registryValidation('http://example.com/registry', undefined, 'token123'))
+        .resolves.toBeUndefined();
+    } finally {
+      global.fetch = originalFetch;
+    }
+  });
+});