feat(ui): gateway endpoint display and CRD installation UI (#114)

Author: sozercan

backend/src/routes/installation.test.ts

@@ -174,3 +174,117 @@ describe('Installation Provider Routes', () => {
     });
   });
 });
+
+describe('Gateway Installation Routes', () => {
+  const restores: Array<() => void> = [];
+
+  afterEach(() => {
+    restores.forEach((r) => r());
+    restores.length = 0;
+  });
+
+  // ==========================================================================
+  // GET /api/installation/gateway/status
+  // ==========================================================================
+
+  describe('GET /api/installation/gateway/status', () => {
+    test('returns gateway CRD status when CRDs are installed', async () => {
+      restores.push(
+        mockServiceMethod(kubernetesService, 'checkGatewayCRDStatus', async () => ({
+          gatewayApiInstalled: true,
+          inferenceExtInstalled: true,
+          pinnedVersion: 'v1.3.1',
+          gatewayAvailable: true,
+          gatewayEndpoint: '10.0.0.50',
+          message: 'Gateway API and Inference Extension CRDs are installed. Gateway is available.',
+          installCommands: [
+            'kubectl apply -f https://github.com/kubernetes-sigs/gateway-api/releases/latest/download/standard-install.yaml',
+            'kubectl apply -f https://github.com/kubernetes-sigs/gateway-api-inference-extension/releases/download/v1.3.1/manifests.yaml',
+          ],
+        })),
+      );
+
+      const res = await app.request('/api/installation/gateway/status');
+      expect(res.status).toBe(200);
+
+      const data = await res.json();
+      expect(data.gatewayApiInstalled).toBe(true);
+      expect(data.inferenceExtInstalled).toBe(true);
+      expect(data.pinnedVersion).toBe('v1.3.1');
+      expect(data.gatewayAvailable).toBe(true);
+      expect(data.gatewayEndpoint).toBe('10.0.0.50');
+      expect(data.installCommands).toHaveLength(2);
+    });
+
+    test('returns status when CRDs are not installed', async () => {
+      restores.push(
+        mockServiceMethod(kubernetesService, 'checkGatewayCRDStatus', async () => ({
+          gatewayApiInstalled: false,
+          inferenceExtInstalled: false,
+          pinnedVersion: 'v1.3.1',
+          gatewayAvailable: false,
+          message: 'Gateway API and Inference Extension CRDs are not installed.',
+          installCommands: [
+            'kubectl apply -f https://github.com/kubernetes-sigs/gateway-api/releases/latest/download/standard-install.yaml',
+            'kubectl apply -f https://github.com/kubernetes-sigs/gateway-api-inference-extension/releases/download/v1.3.1/manifests.yaml',
+          ],
+        })),
+      );
+
+      const res = await app.request('/api/installation/gateway/status');
+      expect(res.status).toBe(200);
+
+      const data = await res.json();
+      expect(data.gatewayApiInstalled).toBe(false);
+      expect(data.inferenceExtInstalled).toBe(false);
+      expect(data.gatewayAvailable).toBe(false);
+    });
+  });
+
+  // ==========================================================================
+  // POST /api/installation/gateway/install-crds
+  // ==========================================================================
+
+  describe('POST /api/installation/gateway/install-crds', () => {
+    test('returns 200 on successful CRD installation', async () => {
+      restores.push(
+        mockServiceMethod(helmService, 'applyManifestUrl', async () => ({
+          success: true,
+          stdout: 'customresourcedefinition.apiextensions.k8s.io/gateways.gateway.networking.k8s.io created',
+          stderr: '',
+          exitCode: 0,
+        })),
+      );
+
+      const res = await app.request('/api/installation/gateway/install-crds', { method: 'POST' });
+      expect(res.status).toBe(200);
+
+      const data = await res.json();
+      expect(data.success).toBe(true);
+      expect(data.results).toHaveLength(2);
+      expect(data.results[0].step).toBe('gateway-api-crds');
+      expect(data.results[1].step).toBe('inference-extension-crds');
+    });
+
+    test('returns 500 when Gateway API CRD installation fails', async () => {
+      let callCount = 0;
+      restores.push(
+        mockServiceMethod(helmService, 'applyManifestUrl', async () => {
+          callCount++;
+          if (callCount === 1) {
+            return {
+              success: false,
+              stdout: '',
+              stderr: 'connection refused',
+              exitCode: 1,
+            };
+          }
+          return { success: true, stdout: 'ok', stderr: '', exitCode: 0 };
+        }),
+      );
+
+      const res = await app.request('/api/installation/gateway/install-crds', { method: 'POST' });
+      expect(res.status).toBe(500);
+    });
+  });
+});

backend/src/routes/installation.ts

@@ -257,6 +257,57 @@ const installation = new Hono()
         message: `Failed to remove CRDs: ${error instanceof Error ? error.message : 'Unknown error'}`,
       });
     }
+  })
+  .get('/gateway/status', async (c) => {
+    const status = await kubernetesService.checkGatewayCRDStatus();
+    return c.json(status);
+  })
+  .post('/gateway/install-crds', async (c) => {
+    const { GATEWAY_API_CRD_URL, GAIE_CRD_URL, PINNED_GAIE_VERSION } = await import('@kubeairunway/shared');
+
+    const results: Array<{ step: string; success: boolean; output: string; error?: string }> = [];
+
+    // Install Gateway API CRDs
+    logger.info('Installing Gateway API CRDs');
+    const gwResult = await helmService.applyManifestUrl(GATEWAY_API_CRD_URL, (data, stream) => {
+      logger.debug({ stream }, data.trim());
+    });
+    results.push({
+      step: 'gateway-api-crds',
+      success: gwResult.success,
+      output: gwResult.stdout,
+      error: gwResult.stderr || undefined,
+    });
+
+    if (!gwResult.success) {
+      throw new HTTPException(500, {
+        message: `Failed to install Gateway API CRDs: ${gwResult.stderr}`,
+      });
+    }
+
+    // Install GAIE CRDs
+    logger.info(`Installing Inference Extension CRDs (${PINNED_GAIE_VERSION})`);
+    const gaieResult = await helmService.applyManifestUrl(GAIE_CRD_URL, (data, stream) => {
+      logger.debug({ stream }, data.trim());
+    });
+    results.push({
+      step: 'inference-extension-crds',
+      success: gaieResult.success,
+      output: gaieResult.stdout,
+      error: gaieResult.stderr || undefined,
+    });
+
+    if (!gaieResult.success) {
+      throw new HTTPException(500, {
+        message: `Failed to install Inference Extension CRDs: ${gaieResult.stderr}`,
+      });
+    }
+
+    return c.json({
+      success: true,
+      message: 'Gateway API and Inference Extension CRDs installed successfully',
+      results,
+    });
   });
 
 export default installation;

backend/src/services/helm.ts

@@ -655,6 +655,16 @@ class HelmService {
   getGpuOperatorCommands(): string[] {
     return this.getInstallCommands([GPU_OPERATOR_REPO], [GPU_OPERATOR_CHART]);
   }
+
+  /**
+   * Apply a manifest from a URL using kubectl apply -f
+   */
+  async applyManifestUrl(
+    url: string,
+    onStream?: StreamCallback
+  ): Promise<HelmResult> {
+    return this.executeKubectl(['apply', '-f', url], onStream);
+  }
 }
 
 // Export singleton instance

backend/src/services/kubernetes.ts

@@ -1,6 +1,6 @@
 import * as k8s from '@kubernetes/client-node';
 import { configService } from './config';
-import type { DeploymentStatus, PodStatus, ClusterStatus, PodPhase, DeploymentConfig, RuntimeStatus, ModelDeployment, GatewayInfo, GatewayModelInfo } from '@kubeairunway/shared';
+import type { DeploymentStatus, PodStatus, ClusterStatus, PodPhase, DeploymentConfig, RuntimeStatus, ModelDeployment, GatewayInfo, GatewayModelInfo, GatewayCRDStatus } from '@kubeairunway/shared';
 import { toModelDeploymentManifest, toDeploymentStatus } from '@kubeairunway/shared';
 import { withRetry } from '../lib/retry';
 import logger from '../lib/logger';
@@ -1480,6 +1480,108 @@ class KubernetesService {
 
     return models;
   }
+
+  /**
+   * Check Gateway API and GAIE CRD installation status.
+   * Also includes live gateway availability info.
+   */
+  async checkGatewayCRDStatus(): Promise<GatewayCRDStatus> {
+    const { PINNED_GAIE_VERSION, GAIE_CRD_URL, GATEWAY_API_CRD_URL } = await import('@kubeairunway/shared');
+
+    const [gatewayApiInstalled, inferenceExtInstalled] = await Promise.all([
+      this.checkCRDExists('gateways.gateway.networking.k8s.io'),
+      this.checkCRDExists('inferencepools.inference.networking.k8s.io'),
+    ]);
+
+    // Get live gateway status
+    let gatewayAvailable = false;
+    let gatewayEndpoint: string | undefined;
+    if (gatewayApiInstalled && inferenceExtInstalled) {
+      try {
+        const gwStatus = await this.getGatewayStatus();
+        gatewayAvailable = gwStatus.available;
+        gatewayEndpoint = gwStatus.endpoint;
+      } catch {
+        // Gateway status check failed, not critical
+      }
+    }
+
+    const allInstalled = gatewayApiInstalled && inferenceExtInstalled;
+    let message: string;
+    if (allInstalled && gatewayAvailable) {
+      message = 'Gateway API and Inference Extension CRDs are installed. Gateway is available.';
+    } else if (allInstalled) {
+      message = 'Gateway API and Inference Extension CRDs are installed. No active gateway detected.';
+    } else if (!gatewayApiInstalled && !inferenceExtInstalled) {
+      message = 'Gateway API and Inference Extension CRDs are not installed.';
+    } else if (!gatewayApiInstalled) {
+      message = 'Gateway API CRDs are not installed.';
+    } else {
+      message = 'Inference Extension CRDs are not installed.';
+    }
+
+    return {
+      gatewayApiInstalled,
+      inferenceExtInstalled,
+      pinnedVersion: PINNED_GAIE_VERSION,
+      gatewayAvailable,
+      gatewayEndpoint,
+      message,
+      installCommands: [
+        `kubectl apply -f ${GATEWAY_API_CRD_URL}`,
+        `kubectl apply -f ${GAIE_CRD_URL}`,
+      ],
+    };
+  }
+
+  /**
+   * Proxy a GET request to a Kubernetes service through the API server.
+   * This allows fetching service endpoints (e.g. /metrics) even when running off-cluster.
+   * Uses raw fetch instead of the generated client to support text/plain responses.
+   */
+  async proxyServiceGet(serviceName: string, namespace: string, port: number, path: string): Promise<string> {
+    const cluster = this.kc.getCurrentCluster();
+    if (!cluster) {
+      throw new Error('No active Kubernetes cluster configured');
+    }
+
+    // Build proxy URL: /api/v1/namespaces/{ns}/services/{name}:{port}/proxy/{path}
+    const proxyUrl = `${cluster.server}/api/v1/namespaces/${encodeURIComponent(namespace)}/services/${encodeURIComponent(serviceName)}:${port}/proxy/${path}`;
+
+    // Extract auth headers from KubeConfig
+    const reqOpts: { headers: Record<string, string>; strictSSL?: boolean } = { headers: {} };
+    await this.kc.applyToRequest(reqOpts as any);
+
+    // Extract TLS options (CA cert, client cert/key) from KubeConfig
+    const httpsOpts: { ca?: Buffer; cert?: Buffer; key?: Buffer; rejectUnauthorized?: boolean } = {};
+    this.kc.applyToHTTPSOptions(httpsOpts as any);
+
+    const tlsOpts: Record<string, any> = {};
+    if (httpsOpts.ca) tlsOpts.ca = httpsOpts.ca;
+    if (httpsOpts.cert) tlsOpts.cert = httpsOpts.cert;
+    if (httpsOpts.key) tlsOpts.key = httpsOpts.key;
+    if (cluster.skipTLSVerify || httpsOpts.rejectUnauthorized === false) {
+      tlsOpts.rejectUnauthorized = false;
+    }
+
+    const fetchOpts: RequestInit & { tls?: Record<string, any> } = {
+      method: 'GET',
+      headers: {
+        ...reqOpts.headers,
+        'Accept': 'text/plain',
+      },
+    };
+
+    if (Object.keys(tlsOpts).length > 0) {
+      fetchOpts.tls = tlsOpts;
+    }
+
+    const response = await fetch(proxyUrl, fetchOpts);
+    if (!response.ok) {
+      throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+    }
+    return await response.text();
+  }
 }
 
 export const kubernetesService = new KubernetesService();

backend/src/services/metrics.test.ts

@@ -52,24 +52,26 @@ describe('MetricsService - Error Message Handling', () => {
   // Test error message mapping logic
   function mapErrorMessage(errorMessage: string): string {
     if (errorMessage.includes('ENOTFOUND') || errorMessage.includes('getaddrinfo')) {
-      return 'Cannot resolve service DNS. KubeAIRunway must be running in-cluster to fetch metrics.';
+      return 'Cannot resolve service DNS. The deployment service may not exist yet.';
     } else if (errorMessage.includes('ECONNREFUSED')) {
       return 'Connection refused. The deployment may not be ready yet.';
     } else if (errorMessage.includes('abort')) {
       return 'Request timed out. The deployment may be under heavy load or not responding.';
-    } else if (errorMessage.includes('HTTP 404')) {
+    } else if (errorMessage.includes('HTTP 404') || errorMessage.includes('404')) {
       return 'Metrics endpoint not found. The deployment may not expose metrics.';
-    } else if (errorMessage.includes('HTTP 503')) {
+    } else if (errorMessage.includes('HTTP 503') || errorMessage.includes('503')) {
       return 'Service unavailable. The deployment is starting up.';
     } else if (errorMessage.includes('fetch failed') || errorMessage.includes('TypeError')) {
-      return 'Cannot connect to metrics endpoint. KubeAIRunway must be running in-cluster.';
+      return 'Cannot connect to metrics endpoint. Verify the deployment is running.';
+    } else if (errorMessage.includes('connect ECONNREFUSED') || errorMessage.includes('no cluster')) {
+      return 'Cannot connect to the Kubernetes cluster. Check your kubeconfig.';
     }
     return errorMessage;
   }
 
   test('maps DNS resolution errors', () => {
     expect(mapErrorMessage('getaddrinfo ENOTFOUND service.namespace.svc')).toContain('Cannot resolve service DNS');
-    expect(mapErrorMessage('Error: ENOTFOUND')).toContain('in-cluster');
+    expect(mapErrorMessage('Error: ENOTFOUND')).toContain('not exist yet');
   });
 
   test('maps connection refused errors', () => {
@@ -93,8 +95,8 @@ describe('MetricsService - Error Message Handling', () => {
   });
 
   test('maps fetch errors', () => {
-    expect(mapErrorMessage('fetch failed')).toContain('in-cluster');
-    expect(mapErrorMessage('TypeError: Failed to fetch')).toContain('in-cluster');
+    expect(mapErrorMessage('fetch failed')).toContain('Verify the deployment');
+    expect(mapErrorMessage('TypeError: Failed to fetch')).toContain('Verify the deployment');
   });
 
   test('returns original message for unknown errors', () => {