feat: add network detector that uses notices endpoint

Author: kaizencc

packages/@aws-cdk/toolkit-lib/lib/util/network-detector.ts

@@ -0,0 +1,58 @@
+import type { Agent } from 'https';
+import { request } from 'https';
+
+/**
+ * Detects internet connectivity by making a lightweight request to the notices endpoint
+ */
+export class NetworkDetector {
+  private static readonly CACHE_DURATION_MS = 30_000; // 30 seconds
+  private static readonly TIMEOUT_MS = 500;
+  
+  private static cachedResult: boolean | undefined;
+  private static cacheExpiry: number = 0;
+
+  /**
+   * Check if internet connectivity is available
+   */
+  public static async hasConnectivity(agent?: Agent): Promise<boolean> {
+    const now = Date.now();
+    
+    // Return cached result if still valid
+    if (this.cachedResult !== undefined && now < this.cacheExpiry) {
+      return this.cachedResult;
+    }
+
+    try {
+      const connected = await this.ping(agent);
+      this.cachedResult = connected;
+      this.cacheExpiry = now + this.CACHE_DURATION_MS;
+      return connected;
+    } catch {
+      this.cachedResult = false;
+      this.cacheExpiry = now + this.CACHE_DURATION_MS;
+      return false;
+    }
+  }
+
+  private static ping(agent?: Agent): Promise<boolean> {
+    return new Promise((resolve) => {
+      const req = request({
+        hostname: 'cli.cdk.dev-tools.aws.dev',
+        path: '/notices.json',
+        method: 'HEAD',
+        agent,
+        timeout: this.TIMEOUT_MS,
+      }, (res) => {
+        resolve(res.statusCode !== undefined && res.statusCode < 500);
+      });
+
+      req.on('error', () => resolve(false));
+      req.on('timeout', () => {
+        req.destroy();
+        resolve(false);
+      });
+
+      req.end();
+    });
+  }
+}

packages/@aws-cdk/toolkit-lib/test/util/network-detector.test.ts

@@ -0,0 +1,104 @@
+import * as https from 'https';
+import { NetworkDetector } from '../../lib/util/network-detector';
+
+// Mock the https module
+jest.mock('https');
+const mockHttps = https as jest.Mocked<typeof https>;
+
+describe('NetworkDetector', () => {
+  let mockRequest: jest.Mock;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockRequest = jest.fn();
+    mockHttps.request.mockImplementation(mockRequest);
+
+    // Clear static cache between tests
+    (NetworkDetector as any).cachedResult = undefined;
+    (NetworkDetector as any).cacheExpiry = 0;
+  });
+
+  test('returns true when server responds with success status', async () => {
+    const mockReq = {
+      on: jest.fn(),
+      end: jest.fn(),
+      destroy: jest.fn(),
+    };
+
+    mockRequest.mockImplementation((_, callback) => {
+      callback({ statusCode: 200 });
+      return mockReq;
+    });
+
+    const result = await NetworkDetector.hasConnectivity();
+    expect(result).toBe(true);
+  });
+
+  test('returns false when server responds with server error', async () => {
+    const mockReq = {
+      on: jest.fn(),
+      end: jest.fn(),
+      destroy: jest.fn(),
+    };
+
+    mockRequest.mockImplementation((_, callback) => {
+      callback({ statusCode: 500 });
+      return mockReq;
+    });
+
+    const result = await NetworkDetector.hasConnectivity();
+    expect(result).toBe(false);
+  });
+
+  test('returns false on network error', async () => {
+    const mockReq = {
+      on: jest.fn((event, handler) => {
+        if (event === 'error') {
+          setTimeout(() => handler(new Error('Network error')), 0);
+        }
+      }),
+      end: jest.fn(),
+      destroy: jest.fn(),
+    };
+
+    mockRequest.mockReturnValue(mockReq);
+
+    const result = await NetworkDetector.hasConnectivity();
+    expect(result).toBe(false);
+  });
+
+  test('returns false on timeout', async () => {
+    const mockReq = {
+      on: jest.fn((event, handler) => {
+        if (event === 'timeout') {
+          setTimeout(() => handler(), 0);
+        }
+      }),
+      end: jest.fn(),
+      destroy: jest.fn(),
+    };
+
+    mockRequest.mockReturnValue(mockReq);
+
+    const result = await NetworkDetector.hasConnectivity();
+    expect(result).toBe(false);
+  });
+
+  test('caches result for subsequent calls', async () => {
+    const mockReq = {
+      on: jest.fn(),
+      end: jest.fn(),
+      destroy: jest.fn(),
+    };
+
+    mockRequest.mockImplementation((_, callback) => {
+      callback({ statusCode: 200 });
+      return mockReq;
+    });
+
+    await NetworkDetector.hasConnectivity();
+    await NetworkDetector.hasConnectivity();
+
+    expect(mockRequest).toHaveBeenCalledTimes(1);
+  });
+});