@forgeportal/plugin-kubernetes 1.3.0

package/src/LogsDrawer.tsx

@@ -0,0 +1,83 @@
+import React, { useEffect, useRef } from 'react';
+import { useApi } from '@forgeportal/plugin-sdk/react';
+
+interface LogsDrawerProps {
+  entityId:  string;
+  podName:   string;
+  namespace: string;
+  cluster?:  string;
+  onClose:   () => void;
+}
+
+export function LogsDrawer({
+  entityId,
+  podName,
+  namespace,
+  cluster,
+  onClose,
+}: LogsDrawerProps): React.ReactElement {
+  const params = new URLSearchParams({ namespace, ...(cluster ? { cluster } : {}) });
+  const url    = `/api/v1/plugins/kubernetes/entities/${entityId}/pods/${encodeURIComponent(podName)}/logs?${params.toString()}`;
+
+  const { data: logsResponse, isPending, isError, error } = useApi<{ data: { logs: string } }>(url, {
+    refetchInterval: 10_000,
+    retry:           1,
+  });
+  const logs = logsResponse?.data.logs;
+
+  const preRef = useRef<HTMLPreElement>(null);
+
+  // Auto-scroll to bottom when new logs arrive
+  useEffect(() => {
+    if (preRef.current) {
+      preRef.current.scrollTop = preRef.current.scrollHeight;
+    }
+  }, [logs]);
+
+  return (
+    <div className="fixed inset-0 z-50 flex items-end justify-center bg-black/50 sm:items-center">
+      <div className="relative w-full max-w-4xl rounded-t-xl bg-gray-900 sm:rounded-xl shadow-2xl">
+        {/* Header */}
+        <div className="flex items-center justify-between border-b border-gray-700 px-4 py-3">
+          <div>
+            <p className="text-sm font-semibold text-white">{podName}</p>
+            <p className="text-xs text-gray-400">namespace: {namespace}{cluster ? ` · cluster: ${cluster}` : ''}</p>
+          </div>
+          <button
+            type="button"
+            onClick={onClose}
+            className="rounded p-1 text-gray-400 hover:bg-gray-700 hover:text-white"
+            aria-label="Close logs"
+          >
+            <svg className="h-5 w-5" viewBox="0 0 20 20" fill="currentColor">
+              <path d="M6.28 5.22a.75.75 0 00-1.06 1.06L8.94 10l-3.72 3.72a.75.75 0 101.06 1.06L10 11.06l3.72 3.72a.75.75 0 101.06-1.06L11.06 10l3.72-3.72a.75.75 0 00-1.06-1.06L10 8.94 6.28 5.22z" />
+            </svg>
+          </button>
+        </div>
+
+        {/* Body */}
+        <div className="h-96 overflow-hidden">
+          {isPending && (
+            <div className="flex h-full items-center justify-center text-gray-400 text-sm">
+              Loading logs…
+            </div>
+          )}
+          {isError && (
+            <div className="flex h-full items-center justify-center text-red-400 text-sm px-4 text-center">
+              {error?.message ?? 'Failed to load logs'}
+            </div>
+          )}
+          {logsResponse !== undefined && (
+            <pre
+              ref={preRef}
+              className="h-full overflow-y-auto p-4 text-xs font-mono whitespace-pre-wrap break-all leading-relaxed"
+              style={{ backgroundColor: '#111827', color: '#86efac' }}
+            >
+              {logs || '(no log output)'}
+            </pre>
+          )}
+        </div>
+      </div>
+    </div>
+  );
+}

package/src/PodStatusBadge.tsx

@@ -0,0 +1,36 @@
+import React from 'react';
+
+interface PodStatusBadgeProps {
+  status: string;
+}
+
+const STATUS_STYLES: Record<string, string> = {
+  Running:           'bg-green-100 text-green-800',
+  Succeeded:         'bg-green-100 text-green-800',
+  Completed:         'bg-green-100 text-green-800',
+  Pending:           'bg-yellow-100 text-yellow-800',
+  Terminating:       'bg-yellow-100 text-yellow-800',
+  Init:              'bg-yellow-100 text-yellow-800',
+  CrashLoopBackOff:  'bg-red-100   text-red-800',
+  Error:             'bg-red-100   text-red-800',
+  OOMKilled:         'bg-red-100   text-red-800',
+  Failed:            'bg-red-100   text-red-800',
+  ImagePullBackOff:  'bg-red-100   text-red-800',
+  Unknown:           'bg-gray-100  text-gray-600',
+};
+
+export function PodStatusBadge({ status }: PodStatusBadgeProps): React.ReactElement {
+  const key = Object.keys(STATUS_STYLES).find((k) =>
+    status.toLowerCase().includes(k.toLowerCase()),
+  ) ?? 'Unknown';
+
+  const cls = STATUS_STYLES[key] ?? STATUS_STYLES['Unknown'];
+
+  return (
+    <span
+      className={`inline-flex items-center rounded-full px-2 py-0.5 text-xs font-medium ${cls}`}
+    >
+      {status}
+    </span>
+  );
+}

package/src/__tests__/api-client.test.ts

@@ -0,0 +1,324 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { KubernetesApiClient, parseClusters, resolveCluster } from '../api-client.js';
+import type { ClusterConfig, RawDeployment, RawPod } from '../types.js';
+
+// ── Test cluster fixture ──────────────────────────────────────────────────────
+
+const CLUSTER: ClusterConfig = {
+  name:          'test-cluster',
+  url:           'https://k8s.test.internal',
+  token:         'test-token',
+  skipTLSVerify: false,
+};
+
+// ── fetch mock helpers ────────────────────────────────────────────────────────
+
+function mockFetchJson(body: unknown, status = 200): void {
+  vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+    ok:     status >= 200 && status < 300,
+    status,
+    json:   () => Promise.resolve(body),
+    text:   () => Promise.resolve(JSON.stringify(body)),
+    statusText: status === 200 ? 'OK' : 'Error',
+  }));
+}
+
+function mockFetchText(text: string, status = 200): void {
+  vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+    ok:     status >= 200 && status < 300,
+    status,
+    text:   () => Promise.resolve(text),
+    json:   () => Promise.reject(new Error('not JSON')),
+  }));
+}
+
+beforeEach(() => vi.restoreAllMocks());
+afterEach(() => vi.unstubAllGlobals());
+
+// ── parseClusters ─────────────────────────────────────────────────────────────
+
+describe('parseClusters', () => {
+  it('parses a valid clusters JSON string', () => {
+    const json = JSON.stringify([
+      { name: 'production', url: 'https://k8s-prod.internal', skipTLSVerify: false },
+      { name: 'staging',    url: 'https://k8s-stg.internal',  skipTLSVerify: true },
+    ]);
+
+    const clusters = parseClusters(json, (key) => `token-${key.toLowerCase()}`);
+
+    expect(clusters).toHaveLength(2);
+    expect(clusters[0]).toMatchObject({
+      name:          'production',
+      url:           'https://k8s-prod.internal',
+      token:         'token-production',
+      skipTLSVerify: false,
+    });
+    expect(clusters[1]).toMatchObject({
+      name:          'staging',
+      token:         'token-staging',
+      skipTLSVerify: true,
+    });
+  });
+
+  it('strips trailing slash from cluster URL', () => {
+    const json = JSON.stringify([{ name: 'dev', url: 'https://k8s.dev.internal/' }]);
+    const clusters = parseClusters(json, () => undefined);
+    expect(clusters[0]?.url).toBe('https://k8s.dev.internal');
+  });
+
+  it('defaults skipTLSVerify to false when not provided', () => {
+    const json = JSON.stringify([{ name: 'dev', url: 'https://k8s.dev.internal' }]);
+    const clusters = parseClusters(json, () => undefined);
+    expect(clusters[0]?.skipTLSVerify).toBe(false);
+  });
+
+  it('uses empty string token when env var is not set', () => {
+    const json = JSON.stringify([{ name: 'dev', url: 'https://k8s.dev.internal' }]);
+    const clusters = parseClusters(json, () => undefined);
+    expect(clusters[0]?.token).toBe('');
+  });
+
+  it('throws on invalid JSON', () => {
+    expect(() => parseClusters('not-json', () => undefined)).toThrow(/valid JSON/);
+  });
+});
+
+// ── resolveCluster ────────────────────────────────────────────────────────────
+
+describe('resolveCluster', () => {
+  const clusters: ClusterConfig[] = [
+    { name: 'prod',    url: 'https://prod', token: 't1', skipTLSVerify: false },
+    { name: 'staging', url: 'https://stg',  token: 't2', skipTLSVerify: true  },
+  ];
+
+  it('returns first cluster when no name is provided', () => {
+    expect(resolveCluster(clusters)).toBe(clusters[0]);
+  });
+
+  it('resolves cluster by name', () => {
+    expect(resolveCluster(clusters, 'staging')).toBe(clusters[1]);
+  });
+
+  it('throws when named cluster does not exist', () => {
+    expect(() => resolveCluster(clusters, 'ghost')).toThrow(/not found/);
+  });
+
+  it('throws when cluster list is empty', () => {
+    expect(() => resolveCluster([])).toThrow(/no clusters configured/);
+  });
+});
+
+// ── KubernetesApiClient.getWorkloads ──────────────────────────────────────────
+
+describe('KubernetesApiClient.getWorkloads', () => {
+  const client = new KubernetesApiClient(CLUSTER);
+
+  const rawDeployment: RawDeployment = {
+    metadata: { name: 'payment-api', namespace: 'production' },
+    spec: {
+      replicas: 3,
+      template: { spec: { containers: [{ image: 'registry.io/payment-api:v1.2.3' }] } },
+    },
+    status: {
+      replicas:          3,
+      readyReplicas:     3,
+      availableReplicas: 3,
+      conditions:        [{ type: 'Progressing', status: 'True', lastUpdateTime: '2026-02-20T10:00:00Z' }],
+    },
+  };
+
+  const rawPod: RawPod = {
+    metadata: { name: 'payment-api-abc12', namespace: 'production' },
+    spec:     { nodeName: 'node-1', containers: [{ name: 'payment-api' }] },
+    status:   {
+      phase:             'Running',
+      startTime:         '2026-02-20T09:00:00Z',
+      containerStatuses: [{ ready: true, state: {} }],
+    },
+  };
+
+  it('returns normalised workloads on success', async () => {
+    const mockResponse = (url: string) => {
+      if (url.includes('/deployments')) return { items: [rawDeployment] };
+      if (url.includes('/pods'))        return { items: [rawPod] };
+      if (url.includes('/services'))    return { items: [] };
+      return { items: [] };
+    };
+
+    vi.stubGlobal('fetch', vi.fn().mockImplementation((url: string) =>
+      Promise.resolve({
+        ok:     true,
+        status: 200,
+        json:   () => Promise.resolve(mockResponse(url)),
+        text:   () => Promise.resolve(''),
+      }),
+    ));
+
+    const result = await client.getWorkloads('production', 'app=payment-api');
+
+    expect(result.cluster).toBe('test-cluster');
+    expect(result.namespace).toBe('production');
+    expect(result.labelSelector).toBe('app=payment-api');
+
+    expect(result.deployments).toHaveLength(1);
+    expect(result.deployments[0]).toMatchObject({
+      name:    'payment-api',
+      healthy: true,
+      replicas: { desired: 3, ready: 3, available: 3 },
+      image:   'registry.io/payment-api:v1.2.3',
+    });
+
+    expect(result.pods).toHaveLength(1);
+    expect(result.pods[0]).toMatchObject({
+      name:   'payment-api-abc12',
+      status: 'Running',
+      ready:  true,
+    });
+  });
+
+  it('marks deployment unhealthy when readyReplicas < replicas', async () => {
+    const unhealthyDeployment: RawDeployment = {
+      ...rawDeployment,
+      status: { replicas: 3, readyReplicas: 1, availableReplicas: 1 },
+    };
+
+    vi.stubGlobal('fetch', vi.fn().mockImplementation((url: string) =>
+      Promise.resolve({
+        ok:   true,
+        status: 200,
+        json: () => Promise.resolve(url.includes('/deployments')
+          ? { items: [unhealthyDeployment] }
+          : { items: [] }),
+        text: () => Promise.resolve(''),
+      }),
+    ));
+
+    const result = await client.getWorkloads('production', 'app=payment-api');
+    expect(result.deployments[0]?.healthy).toBe(false);
+  });
+
+  it('detects CrashLoopBackOff pod status', async () => {
+    const crashPod: RawPod = {
+      ...rawPod,
+      status: {
+        phase:             'Running',
+        containerStatuses: [{ ready: false, state: { waiting: { reason: 'CrashLoopBackOff' } } }],
+      },
+    };
+
+    vi.stubGlobal('fetch', vi.fn().mockImplementation((url: string) =>
+      Promise.resolve({
+        ok:   true,
+        status: 200,
+        json: () => Promise.resolve(url.includes('/pods')
+          ? { items: [crashPod] }
+          : { items: [] }),
+        text: () => Promise.resolve(''),
+      }),
+    ));
+
+    const result = await client.getWorkloads('production', 'app=crash');
+    expect(result.pods[0]?.status).toBe('CrashLoopBackOff');
+    expect(result.pods[0]?.ready).toBe(false);
+  });
+
+  it('sends the Authorization header with the Bearer token', async () => {
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: true, status: 200,
+      json: () => Promise.resolve({ items: [] }),
+      text: () => Promise.resolve(''),
+    });
+    vi.stubGlobal('fetch', fetchMock);
+
+    await client.getWorkloads('default', 'app=test');
+
+    const firstCall = fetchMock.mock.calls[0] as [string, RequestInit];
+    expect((firstCall[1].headers as Record<string, string>)['Authorization']).toBe('Bearer test-token');
+  });
+
+  it('throws on non-ok response from K8s API', async () => {
+    mockFetchJson({ message: 'Forbidden' }, 403);
+    await expect(client.getWorkloads('default', 'app=test')).rejects.toThrow('403');
+  });
+
+  it('gracefully handles ingress API failure (returns empty ingresses)', async () => {
+    vi.stubGlobal('fetch', vi.fn().mockImplementation((url: string) =>
+      Promise.resolve({
+        ok:   !url.includes('/ingresses'),
+        status: url.includes('/ingresses') ? 404 : 200,
+        json: () => Promise.resolve({ items: [] }),
+        text: () => Promise.resolve('404 Not Found'),
+      }),
+    ));
+
+    const result = await client.getWorkloads('default', 'app=test');
+    expect(result.ingresses).toHaveLength(0);
+  });
+});
+
+// ── KubernetesApiClient.getPodLogs ────────────────────────────────────────────
+
+describe('KubernetesApiClient.getPodLogs', () => {
+  const client = new KubernetesApiClient(CLUSTER);
+
+  it('returns log text on success', async () => {
+    const logText = '2026-02-20T10:00:00Z INFO Server started\n2026-02-20T10:00:01Z INFO Listening on :8080';
+    mockFetchText(logText);
+
+    const logs = await client.getPodLogs('default', 'my-pod-abc12');
+    expect(logs).toBe(logText);
+  });
+
+  it('requests the correct tailLines parameter', async () => {
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: true, status: 200, text: () => Promise.resolve('log line'),
+    });
+    vi.stubGlobal('fetch', fetchMock);
+
+    await client.getPodLogs('default', 'my-pod', 200);
+
+    const url = (fetchMock.mock.calls[0] as [string])[0];
+    expect(url).toContain('tailLines=200');
+  });
+
+  it('throws on non-ok response', async () => {
+    mockFetchText('Not found', 404);
+    await expect(client.getPodLogs('default', 'ghost-pod')).rejects.toThrow('404');
+  });
+});
+
+// ── KubernetesApiClient.restartDeployment ─────────────────────────────────────
+
+describe('KubernetesApiClient.restartDeployment', () => {
+  const client = new KubernetesApiClient(CLUSTER);
+
+  it('sends a PATCH request with strategic merge patch content type', async () => {
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: true, status: 200,
+      json: () => Promise.resolve({}),
+      text: () => Promise.resolve(''),
+    });
+    vi.stubGlobal('fetch', fetchMock);
+
+    await client.restartDeployment('production', 'payment-api');
+
+    const [url, init] = fetchMock.mock.calls[0] as [string, RequestInit];
+    expect(url).toContain('/deployments/payment-api');
+    expect(init.method).toBe('PATCH');
+    expect((init.headers as Record<string, string>)['Content-Type']).toContain('strategic-merge-patch');
+
+    const body = JSON.parse(init.body as string) as Record<string, unknown>;
+    const annotations = (
+      (body as { spec: { template: { metadata: { annotations: Record<string, string> } } } })
+        .spec.template.metadata.annotations
+    );
+    // use direct key access — toHaveProperty interprets '.' as path separator
+    expect(annotations['kubectl.kubernetes.io/restartedAt']).toBeDefined();
+    expect(typeof annotations['kubectl.kubernetes.io/restartedAt']).toBe('string');
+  });
+
+  it('throws on K8s API error', async () => {
+    mockFetchJson({ message: 'Forbidden' }, 403);
+    await expect(client.restartDeployment('production', 'payment-api')).rejects.toThrow('403');
+  });
+});

package/src/actions.ts

@@ -0,0 +1,146 @@
+import type { ActionProvider } from '@forgeportal/plugin-sdk';
+import type { ClusterConfig } from './types.js';
+import { KubernetesApiClient, resolveCluster } from './api-client.js';
+
+/**
+ * kubernetes.restartDeployment@v1
+ *
+ * Triggers a rolling restart of a named Kubernetes Deployment by patching
+ * the pod template annotation `kubectl.kubernetes.io/restartedAt`.
+ *
+ * Input:
+ *   - deploymentName: string (required)
+ *   - namespace:      string (optional, defaults to "default")
+ *   - cluster:        string (optional, defaults to first configured cluster)
+ */
+export function createRestartDeploymentAction(
+  clusters: ClusterConfig[],
+  defaultNamespace: string,
+): ActionProvider {
+  return {
+    id:      'kubernetes.restartDeployment',
+    version: 'v1',
+    schema: {
+      input: {
+        type:       'object',
+        required:   ['deploymentName'],
+        properties: {
+          deploymentName: {
+            type:        'string',
+            title:       'Deployment Name',
+            description: 'Name of the Kubernetes Deployment to restart.',
+          },
+          namespace: {
+            type:        'string',
+            title:       'Namespace',
+            description: 'Kubernetes namespace (default: plugin defaultNamespace or "default").',
+          },
+          cluster: {
+            type:        'string',
+            title:       'Cluster',
+            description: 'Cluster name from plugin config (default: first configured cluster).',
+          },
+        },
+      },
+      output: {
+        type: 'object',
+        properties: {
+          restartedAt: { type: 'string', description: 'ISO timestamp of the restart patch.' },
+        },
+      },
+    },
+
+    async handler(ctx, input) {
+      const deploymentName = input['deploymentName'] as string;
+      const namespace      = (input['namespace'] as string | undefined) ?? defaultNamespace;
+      const clusterName    = input['cluster'] as string | undefined;
+
+      ctx.logger.info(`Restarting deployment "${deploymentName}" in namespace "${namespace}"`);
+
+      const clusterCfg = resolveCluster(clusters, clusterName);
+      const client     = new KubernetesApiClient(clusterCfg);
+
+      await client.restartDeployment(namespace, deploymentName);
+
+      const restartedAt = new Date().toISOString();
+      ctx.logger.info(`Deployment "${deploymentName}" restart patch applied at ${restartedAt}`);
+
+      return {
+        status:  'success',
+        outputs: { restartedAt },
+        links: [
+          {
+            title: `View in cluster ${clusterCfg.name}`,
+            url:   `${clusterCfg.url}/apis/apps/v1/namespaces/${namespace}/deployments/${deploymentName}`,
+          },
+        ],
+      };
+    },
+  };
+}
+
+/**
+ * kubernetes.scaleDeployment@v1
+ *
+ * Scales a Kubernetes Deployment to the desired replica count.
+ *
+ * Input:
+ *   - deploymentName: string  (required)
+ *   - replicas:       number  (required)
+ *   - namespace:      string  (optional)
+ *   - cluster:        string  (optional)
+ */
+export function createScaleDeploymentAction(
+  clusters: ClusterConfig[],
+  defaultNamespace: string,
+): ActionProvider {
+  return {
+    id:      'kubernetes.scaleDeployment',
+    version: 'v1',
+    schema: {
+      input: {
+        type:       'object',
+        required:   ['deploymentName', 'replicas'],
+        properties: {
+          deploymentName: {
+            type:        'string',
+            title:       'Deployment Name',
+            description: 'Name of the Kubernetes Deployment to scale.',
+          },
+          replicas: {
+            type:        'number',
+            title:       'Replicas',
+            description: 'Desired number of replicas (0–100).',
+          },
+          namespace: { type: 'string', title: 'Namespace' },
+          cluster:   { type: 'string', title: 'Cluster' },
+        },
+      },
+      output: {
+        type: 'object',
+        properties: {
+          replicas: { type: 'number', description: 'Replica count applied.' },
+        },
+      },
+    },
+
+    async handler(ctx, input) {
+      const deploymentName = input['deploymentName'] as string;
+      const replicas       = input['replicas'] as number;
+      const namespace      = (input['namespace'] as string | undefined) ?? defaultNamespace;
+      const clusterName    = input['cluster'] as string | undefined;
+
+      ctx.logger.info(
+        `Scaling deployment "${deploymentName}" to ${replicas} replica(s) in namespace "${namespace}"`,
+      );
+
+      const clusterCfg = resolveCluster(clusters, clusterName);
+      const client     = new KubernetesApiClient(clusterCfg);
+
+      await client.scaleDeployment(namespace, deploymentName, replicas);
+      ctx.logger.info(`Deployment "${deploymentName}" scaled to ${replicas}.`);
+
+      return { status: 'success', outputs: { replicas } };
+    },
+  };
+}