✨ feat: topology, and improves handling

apps/backend/src/services/__tests__/session.test.ts

@@ -1,235 +0,0 @@
-import { describe, it, expect, beforeEach, mock } from "bun:test";
-import { SessionService } from "../session";
-
-// Create mock functions
-const mockSessionFindUnique = mock();
-const mockServerFindUnique = mock();
-const mockReverseProxyFindUnique = mock();
-const mockIsUserSuspended = mock();
-
-// Mock the prisma client
-mock.module("@minikura/db", () => ({
-  prisma: {
-    session: {
-      findUnique: mockSessionFindUnique,
-    },
-    server: {
-      findUnique: mockServerFindUnique,
-    },
-    reverseProxyServer: {
-      findUnique: mockReverseProxyFindUnique,
-    },
-  },
-  isUserSuspended: mockIsUserSuspended,
-}));
-
-// Import mocked modules
-await import("@minikura/db");
-
-describe("SessionService", () => {
-  beforeEach(() => {
-    mockSessionFindUnique.mockClear();
-    mockServerFindUnique.mockClear();
-    mockReverseProxyFindUnique.mockClear();
-    mockIsUserSuspended.mockClear();
-  });
-
-  describe("validate", () => {
-    it("should return INVALID for non-existent session", async () => {
-      mockSessionFindUnique.mockResolvedValue(null);
-
-      const result = await SessionService.validate("invalid-token");
-
-      expect(result.status).toBe(SessionService.SESSION_STATUS.INVALID);
-      expect(result.session).toBeNull();
-    });
-
-    it("should return EXPIRED for expired session", async () => {
-      const expiredDate = new Date(Date.now() - 1000);
-      mockSessionFindUnique.mockResolvedValue({
-        id: "session-1",
-        token: "token-1",
-        expiresAt: expiredDate,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        ipAddress: null,
-        userAgent: null,
-        userId: "user-1",
-        user: {
-          id: "user-1",
-          name: "Test User",
-          email: "test@example.com",
-          emailVerified: true,
-          image: null,
-          role: "user",
-          isSuspended: false,
-          suspendedUntil: null,
-        },
-      });
-
-      const result = await SessionService.validate("expired-token");
-
-      expect(result.status).toBe(SessionService.SESSION_STATUS.EXPIRED);
-    });
-
-    it("should return USER_SUSPENDED for suspended user", async () => {
-      const futureDate = new Date(Date.now() + 1000000);
-      mockIsUserSuspended.mockReturnValue(true);
-
-      mockSessionFindUnique.mockResolvedValue({
-        id: "session-1",
-        token: "token-1",
-        expiresAt: futureDate,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        ipAddress: null,
-        userAgent: null,
-        userId: "user-1",
-        user: {
-          id: "user-1",
-          name: "Test User",
-          email: "test@example.com",
-          emailVerified: true,
-          image: null,
-          role: "user",
-          isSuspended: true,
-          suspendedUntil: null,
-        },
-      });
-
-      const result = await SessionService.validate("valid-token");
-
-      expect(result.status).toBe(SessionService.SESSION_STATUS.USER_SUSPENDED);
-    });
-
-    it("should return VALID for valid session with active user", async () => {
-      const futureDate = new Date(Date.now() + 1000000);
-      mockIsUserSuspended.mockReturnValue(false);
-
-      mockSessionFindUnique.mockResolvedValue({
-        id: "session-1",
-        token: "token-1",
-        expiresAt: futureDate,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        ipAddress: null,
-        userAgent: null,
-        userId: "user-1",
-        user: {
-          id: "user-1",
-          name: "Test User",
-          email: "test@example.com",
-          emailVerified: true,
-          image: null,
-          role: "user",
-          isSuspended: false,
-          suspendedUntil: null,
-        },
-      });
-
-      const result = await SessionService.validate("valid-token");
-
-      expect(result.status).toBe(SessionService.SESSION_STATUS.VALID);
-      expect(result.session).toBeDefined();
-    });
-
-    it("should handle temporary suspension correctly", async () => {
-      const futureDate = new Date(Date.now() + 1000000);
-      const pastSuspensionDate = new Date(Date.now() - 1000);
-
-      // User was suspended but suspension has expired
-      mockIsUserSuspended.mockReturnValue(false);
-
-      mockSessionFindUnique.mockResolvedValue({
-        id: "session-1",
-        token: "token-1",
-        expiresAt: futureDate,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-        ipAddress: null,
-        userAgent: null,
-        userId: "user-1",
-        user: {
-          id: "user-1",
-          name: "Test User",
-          email: "test@example.com",
-          emailVerified: true,
-          image: null,
-          role: "user",
-          isSuspended: true,
-          suspendedUntil: pastSuspensionDate,
-        },
-      });
-
-      const result = await SessionService.validate("valid-token");
-
-      expect(result.status).toBe(SessionService.SESSION_STATUS.VALID);
-    });
-  });
-
-  describe("validateApiKey", () => {
-    it("should return INVALID for invalid API key format", async () => {
-      const result = await SessionService.validateApiKey("invalid-key");
-
-      expect(result.status).toBe(SessionService.SESSION_STATUS.INVALID);
-      expect(result.server).toBeNull();
-    });
-
-    it("should return INVALID when reverse proxy server not found", async () => {
-      mockReverseProxyFindUnique.mockResolvedValue(null);
-
-      const result = await SessionService.validateApiKey(
-        "minikura_reverse_proxy_server_api_key_invalid"
-      );
-
-      expect(result.status).toBe(SessionService.SESSION_STATUS.INVALID);
-      expect(result.server).toBeNull();
-    });
-
-    it("should return valid reverse proxy server for valid API key", async () => {
-      const mockServer = {
-        id: "server-1",
-        subdomain: "test",
-        api_key: "minikura_reverse_proxy_server_api_key_valid",
-        type: "VELOCITY",
-        description: null,
-        memory: "1G",
-        external_address: "test.example.com",
-        external_port: 25565,
-        listen_port: 25577,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-      };
-
-      mockReverseProxyFindUnique.mockResolvedValue(mockServer);
-
-      const result = await SessionService.validateApiKey(
-        "minikura_reverse_proxy_server_api_key_valid"
-      );
-
-      expect(result.status).toBe(SessionService.SESSION_STATUS.VALID);
-      expect(result.server?.id).toBe(mockServer.id);
-    });
-
-    it("should return valid server for valid server API key", async () => {
-      const mockServer = {
-        id: "server-1",
-        name: "Test Server",
-        api_key: "minikura_server_api_key_valid",
-        type: "STATEFUL",
-        description: null,
-        memory: "2G",
-        listen_port: 25565,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-      };
-
-      mockServerFindUnique.mockResolvedValue(mockServer);
-
-      const result = await SessionService.validateApiKey("minikura_server_api_key_valid");
-
-      expect(result.status).toBe(SessionService.SESSION_STATUS.VALID);
-      expect(result.server?.id).toBe(mockServer.id);
-    });
-  });
-});

apps/backend/src/services/__tests__/user.test.ts

@@ -1,272 +0,0 @@
-import { beforeEach, describe, expect, it, mock } from "bun:test";
-import { UserService } from "../user";
-
-// Create mock functions
-const mockFindUnique = mock();
-const mockFindMany = mock();
-const mockUpdate = mock();
-const mockDelete = mock();
-const mockIsUserSuspended = mock();
-
-// Mock the prisma client
-mock.module("@minikura/db", () => ({
-  prisma: {
-    user: {
-      findUnique: mockFindUnique,
-      findMany: mockFindMany,
-      update: mockUpdate,
-      delete: mockDelete,
-    },
-  },
-  isUserSuspended: mockIsUserSuspended,
-}));
-
-// Import mocked modules
-await import("@minikura/db");
-
-describe("UserService", () => {
-  beforeEach(() => {
-    mockFindUnique.mockClear();
-    mockFindMany.mockClear();
-    mockUpdate.mockClear();
-    mockDelete.mockClear();
-    mockIsUserSuspended.mockClear();
-  });
-
-  describe("getUserByEmail", () => {
-    it("should return user when found", async () => {
-      const mockUser = {
-        id: "user-1",
-        name: "Test User",
-        email: "test@example.com",
-        emailVerified: true,
-        image: null,
-        role: "user",
-        banned: false,
-        isSuspended: false,
-        suspendedUntil: null,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-      };
-
-      mockFindUnique.mockResolvedValue(mockUser);
-
-      const result = await UserService.getUserByEmail("test@example.com");
-
-      expect(mockFindUnique).toHaveBeenCalledWith({
-        where: { email: "test@example.com" },
-      });
-      expect(result).toEqual(mockUser);
-    });
-
-    it("should return null when user not found", async () => {
-      mockFindUnique.mockResolvedValue(null);
-
-      const result = await UserService.getUserByEmail("notfound@example.com");
-
-      expect(result).toBeNull();
-    });
-  });
-
-  describe("getUserById", () => {
-    it("should return user when found", async () => {
-      const mockUser = {
-        id: "user-1",
-        name: "Test User",
-        email: "test@example.com",
-        emailVerified: true,
-        image: null,
-        role: "user",
-        banned: false,
-        isSuspended: false,
-        suspendedUntil: null,
-        createdAt: new Date(),
-        updatedAt: new Date(),
-      };
-
-      mockFindUnique.mockResolvedValue(mockUser);
-
-      const result = await UserService.getUserById("user-1");
-
-      expect(result).toEqual(mockUser);
-    });
-  });
-
-  describe("getAllUsersWithSuspension", () => {
-    it("should return all users with suspension info", async () => {
-      const mockUsers = [
-        {
-          id: "user-1",
-          name: "User 1",
-          email: "user1@example.com",
-          emailVerified: true,
-          image: null,
-          role: "user",
-          banned: false,
-          isSuspended: false,
-          suspendedUntil: null,
-          createdAt: new Date(),
-        },
-        {
-          id: "user-2",
-          name: "User 2",
-          email: "user2@example.com",
-          emailVerified: true,
-          image: null,
-          role: "user",
-          banned: false,
-          isSuspended: true,
-          suspendedUntil: new Date(Date.now() + 86400000),
-          createdAt: new Date(),
-        },
-      ];
-
-      mockFindMany.mockResolvedValue(mockUsers);
-
-      const result = await UserService.getAllUsersWithSuspension();
-
-      expect(result).toEqual(mockUsers);
-      expect(result).toHaveLength(2);
-    });
-  });
-
-  describe("updateUser", () => {
-    it("should update user basic information", async () => {
-      const mockUpdatedUser = {
-        id: "user-1",
-        name: "Updated Name",
-        email: "test@example.com",
-        emailVerified: true,
-        image: null,
-        role: "admin",
-        createdAt: new Date(),
-      };
-
-      mockUpdate.mockResolvedValue(mockUpdatedUser);
-
-      const result = await UserService.updateUser("user-1", {
-        name: "Updated Name",
-        role: "admin",
-      });
-
-      expect(result).toEqual(mockUpdatedUser);
-    });
-  });
-
-  describe("suspendUser", () => {
-    it("should suspend user indefinitely when no expiration provided", async () => {
-      const mockSuspendedUser = {
-        id: "user-1",
-        name: "Test User",
-        email: "test@example.com",
-        emailVerified: true,
-        image: null,
-        role: "user",
-        isSuspended: true,
-        suspendedUntil: null,
-        createdAt: new Date(),
-      };
-
-      mockUpdate.mockResolvedValue(mockSuspendedUser);
-
-      const result = await UserService.suspendUser("user-1");
-
-      expect(result.isSuspended).toBe(true);
-      expect(result.suspendedUntil).toBeNull();
-    });
-
-    it("should suspend user until specific date", async () => {
-      const suspendUntil = new Date(Date.now() + 86400000); // 1 day from now
-
-      const mockSuspendedUser = {
-        id: "user-1",
-        name: "Test User",
-        email: "test@example.com",
-        emailVerified: true,
-        image: null,
-        role: "user",
-        isSuspended: true,
-        suspendedUntil: suspendUntil,
-        createdAt: new Date(),
-      };
-
-      mockUpdate.mockResolvedValue(mockSuspendedUser);
-
-      const result = await UserService.suspendUser("user-1", suspendUntil);
-
-      expect(result.isSuspended).toBe(true);
-      expect(result.suspendedUntil).toEqual(suspendUntil);
-    });
-  });
-
-  describe("unsuspendUser", () => {
-    it("should unsuspend a user", async () => {
-      const mockUnsuspendedUser = {
-        id: "user-1",
-        name: "Test User",
-        email: "test@example.com",
-        emailVerified: true,
-        image: null,
-        role: "user",
-        isSuspended: false,
-        suspendedUntil: null,
-        createdAt: new Date(),
-      };
-
-      mockUpdate.mockResolvedValue(mockUnsuspendedUser);
-
-      const result = await UserService.unsuspendUser("user-1");
-
-      expect(result.isSuspended).toBe(false);
-      expect(result.suspendedUntil).toBeNull();
-    });
-  });
-
-  describe("deleteUser", () => {
-    it("should delete a user", async () => {
-      mockDelete.mockResolvedValue({});
-
-      await UserService.deleteUser("user-1");
-
-      expect(mockDelete).toHaveBeenCalledWith({
-        where: { id: "user-1" },
-      });
-    });
-  });
-
-  describe("checkSuspension", () => {
-    it("should return true when user is suspended", async () => {
-      const mockUser = {
-        isSuspended: true,
-        suspendedUntil: null,
-      };
-
-      mockFindUnique.mockResolvedValue(mockUser);
-      mockIsUserSuspended.mockReturnValue(true);
-
-      const result = await UserService.checkSuspension("user-1");
-
-      expect(result).toBe(true);
-    });
-
-    it("should return false when user is not suspended", async () => {
-      const mockUser = {
-        isSuspended: false,
-        suspendedUntil: null,
-      };
-
-      mockFindUnique.mockResolvedValue(mockUser);
-      mockIsUserSuspended.mockReturnValue(false);
-
-      const result = await UserService.checkSuspension("user-1");
-
-      expect(result).toBe(false);
-    });
-
-    it("should throw error when user not found", async () => {
-      mockFindUnique.mockResolvedValue(null);
-
-      await expect(UserService.checkSuspension("user-1")).rejects.toThrow("User not found");
-    });
-  });
-});

apps/backend/src/services/k8s.ts

@@ -1,13 +1,20 @@
 import * as k8s from "@kubernetes/client-node";
 import type { CustomResourceSummary } from "@minikura/api";
-import { K8sResources } from "./k8s/resources";
+import { API_GROUP } from "@minikura/api";
+import { buildKubeConfig } from "@minikura/shared/kube-auth";
+import type { IK8sService } from "../application/interfaces/k8s.service.interface";
+import { logger } from "../infrastructure/logger";
+import { ClusterOperations } from "./kubernetes/operations/cluster.operations";
+import { CustomResourceOperations } from "./kubernetes/operations/custom-resource.operations";
+import { NetworkOperations } from "./kubernetes/operations/network.operations";
+import { PodOperations } from "./kubernetes/operations/pod.operations";
+import { WorkloadOperations } from "./kubernetes/operations/workload.operations";
+import { K8sResources } from "./kubernetes/resources";
 
-const CUSTOM_RESOURCE_GROUP = "minikura.kirameki.cafe";
 const CUSTOM_RESOURCE_VERSION = "v1alpha1";
 
-export class K8sService {
-  private static instance: K8sService;
-  private kc: k8s.KubeConfig;
+export class K8sService implements IK8sService {
+  private kc!: k8s.KubeConfig;
   private coreApi!: k8s.CoreV1Api;
   private appsApi!: k8s.AppsV1Api;
   private customObjectsApi!: k8s.CustomObjectsApi;
@@ -16,65 +23,30 @@ export class K8sService {
   private initialized: boolean = false;
   private resources!: K8sResources;
 
-  private constructor() {
-    this.kc = new k8s.KubeConfig();
+  private podOps!: PodOperations;
+  private clusterOps!: ClusterOperations;
+  private customResourceOps!: CustomResourceOperations;
+
+  constructor() {
     this.namespace = process.env.KUBERNETES_NAMESPACE || "minikura";
 
     try {
-      this.setupConfig();
+      this.kc = buildKubeConfig();
       this.initializeClients();
+      this.initializeOperations();
       this.resources = new K8sResources(
         this.coreApi,
         this.appsApi,
         this.networkingApi,
-        this.namespace,
+        this.namespace
       );
       this.initialized = true;
-    } catch (_error) {
+    } catch (error) {
+      logger.error({ err: error }, "Failed to initialize Kubernetes client");
       this.initialized = false;
     }
   }
 
-  private setupConfig(): void {
-    const isBun = typeof Bun !== "undefined";
-
-    if (isBun) {
-      const { buildKubeConfig } = require("../lib/kube-auth");
-      this.kc = buildKubeConfig();
-      return;
-    }
-
-    try {
-      this.kc.loadFromDefault();
-      console.log("Loaded Kubernetes config from default location");
-    } catch (err) {
-      console.warn(
-        "Failed to load Kubernetes config from default location:",
-        err,
-      );
-    }
-
-    if (!this.kc.getCurrentContext()) {
-      try {
-        this.kc.loadFromCluster();
-        console.log("Loaded Kubernetes config from cluster");
-      } catch (err) {
-        console.warn("Failed to load Kubernetes config from cluster:", err);
-      }
-    }
-
-    if (!this.kc.getCurrentContext()) {
-      throw new Error(
-        "Failed to setup Kubernetes client - no valid configuration found",
-      );
-    }
-
-    const currentCluster = this.kc.getCurrentCluster();
-    if (currentCluster) {
-      console.log(`Connecting to Kubernetes server: ${currentCluster.server}`);
-    }
-  }
-
   private initializeClients(): void {
     this.coreApi = this.kc.makeApiClient(k8s.CoreV1Api);
     this.appsApi = this.kc.makeApiClient(k8s.AppsV1Api);
@@ -82,11 +54,12 @@ export class K8sService {
     this.networkingApi = this.kc.makeApiClient(k8s.NetworkingV1Api);
   }
 
-  static getInstance(): K8sService {
-    if (!K8sService.instance) {
-      K8sService.instance = new K8sService();
-    }
-    return K8sService.instance;
+  private initializeOperations(): void {
+    this.podOps = new PodOperations(this.coreApi, this.namespace);
+    this.workloadOps = new WorkloadOperations(this.appsApi, this.namespace);
+    this.networkOps = new NetworkOperations(this.coreApi, this.networkingApi, this.namespace);
+    this.clusterOps = new ClusterOperations(this.coreApi, this.customObjectsApi, this.namespace);
+    this.customResourceOps = new CustomResourceOperations(this.customObjectsApi, this.namespace);
   }
 
   isInitialized(): boolean {
@@ -118,147 +91,56 @@ export class K8sService {
   }
 
   async getPods() {
-    if (!this.initialized) {
-      throw new Error("Kubernetes client not initialized");
-    }
-
-    try {
-      return await this.resources.listPods();
-    } catch (error: unknown) {
-      console.error("Error fetching pods:", error);
-      throw new Error(`Failed to fetch pods: ${getErrorMessage(error)}`);
-    }
+    this.ensureInitialized();
+    return this.resources.listPods();
   }
 
   async getDeployments() {
-    if (!this.initialized) {
-      throw new Error("Kubernetes client not initialized");
-    }
-
-    try {
-      return await this.resources.listDeployments();
-    } catch (error: unknown) {
-      console.error("Error fetching deployments:", error);
-      throw new Error(`Failed to fetch deployments: ${getErrorMessage(error)}`);
-    }
+    this.ensureInitialized();
+    return this.resources.listDeployments();
   }
 
   async getStatefulSets() {
-    if (!this.initialized) {
-      throw new Error("Kubernetes client not initialized");
-    }
-
-    try {
-      return await this.resources.listStatefulSets();
-    } catch (error: unknown) {
-      console.error("Error fetching statefulsets:", error);
-      throw new Error(
-        `Failed to fetch statefulsets: ${getErrorMessage(error)}`,
-      );
-    }
+    this.ensureInitialized();
+    return this.resources.listStatefulSets();
   }
 
   async getServices() {
-    if (!this.initialized) {
-      throw new Error("Kubernetes client not initialized");
-    }
-
-    try {
-      return await this.resources.listServices();
-    } catch (error: unknown) {
-      console.error("Error fetching services:", error);
-      throw new Error(`Failed to fetch services: ${getErrorMessage(error)}`);
-    }
+    this.ensureInitialized();
+    return this.resources.listServices();
   }
 
   async getConfigMaps() {
-    if (!this.initialized) {
-      throw new Error("Kubernetes client not initialized");
-    }
-
-    try {
-      return await this.resources.listConfigMaps();
-    } catch (error: unknown) {
-      console.error("Error fetching configmaps:", error);
-      throw new Error(`Failed to fetch configmaps: ${getErrorMessage(error)}`);
-    }
+    this.ensureInitialized();
+    return this.resources.listConfigMaps();
   }
 
   async getIngresses() {
+    this.ensureInitialized();
+    return this.resources.listIngresses();
+  }
+
+  private ensureInitialized(): void {
     if (!this.initialized) {
       throw new Error("Kubernetes client not initialized");
     }
-
-    try {
-      return await this.resources.listIngresses();
-    } catch (error: unknown) {
-      console.error("Error fetching ingresses:", error);
-      throw new Error(`Failed to fetch ingresses: ${getErrorMessage(error)}`);
-    }
   }
 
   async getCustomResources(
     group: string,
     version: string,
-    plural: string,
+    plural: string
   ): Promise<CustomResourceSummary[]> {
-    if (!this.initialized) {
-      throw new Error("Kubernetes client not initialized");
-    }
-
-    try {
-      type CustomResourceItem = {
-        metadata?: {
-          name?: string;
-          namespace?: string;
-          creationTimestamp?: string;
-          labels?: Record<string, string>;
-        };
-        spec?: Record<string, unknown>;
-        status?: { phase?: string; [key: string]: unknown };
-      };
-
-      const response = await this.customObjectsApi.listNamespacedCustomObject({
-        group,
-        version,
-        namespace: this.namespace,
-        plural,
-      });
-      const body = response as unknown as {
-        items?: CustomResourceItem[];
-        body?: { items?: CustomResourceItem[] };
-      };
-      const items = body.items ?? body.body?.items ?? [];
-      return items.map((item) => ({
-        name: item.metadata?.name,
-        namespace: item.metadata?.namespace,
-        age: getAge(item.metadata?.creationTimestamp),
-        labels: item.metadata?.labels,
-        spec: item.spec,
-        status: item.status,
-      }));
-    } catch (error: unknown) {
-      console.error(`Error fetching custom resources ${plural}:`, error);
-      throw new Error(
-        `Failed to fetch custom resources: ${getErrorMessage(error)}`,
-      );
-    }
+    this.ensureInitialized();
+    return this.customResourceOps.listCustomResources(group, version, plural);
   }
 
   async getMinecraftServers() {
-    return this.getCustomResources(
-      CUSTOM_RESOURCE_GROUP,
-      CUSTOM_RESOURCE_VERSION,
-      "minecraftservers",
-    );
+    return this.getCustomResources(API_GROUP, CUSTOM_RESOURCE_VERSION, "minecraftservers");
   }
 
   async getReverseProxyServers() {
-    return this.getCustomResources(
-      CUSTOM_RESOURCE_GROUP,
-      CUSTOM_RESOURCE_VERSION,
-      "reverseproxyservers",
-    );
+    return this.getCustomResources(API_GROUP, CUSTOM_RESOURCE_VERSION, "reverseproxyservers");
   }
 
   async getPodLogs(
@@ -268,150 +150,82 @@ export class K8sService {
       tailLines?: number;
       timestamps?: boolean;
       sinceSeconds?: number;
-    },
+    }
   ) {
-    if (!this.initialized) {
-      throw new Error("Kubernetes client not initialized");
-    }
-
-    try {
-      const response = await this.coreApi.readNamespacedPodLog({
-        name: podName,
-        namespace: this.namespace,
-        container: options?.container,
-        tailLines: options?.tailLines,
-        timestamps: options?.timestamps,
-        sinceSeconds: options?.sinceSeconds,
-      });
-      return response;
-    } catch (error: unknown) {
-      console.error(`Error fetching logs for pod ${podName}:`, error);
-      throw new Error(`Failed to fetch pod logs: ${getErrorMessage(error)}`);
-    }
+    this.ensureInitialized();
+    return this.podOps.getPodLogs(podName, options);
   }
 
   async getPodsByLabel(labelSelector: string) {
-    if (!this.initialized) {
-      throw new Error("Kubernetes client not initialized");
-    }
-
-    try {
-      return await this.resources.listPodsByLabel(labelSelector);
-    } catch (error: unknown) {
-      console.error("Error fetching pods by label:", error);
-      throw new Error(
-        `Failed to fetch pods by label: ${getErrorMessage(error)}`,
-      );
-    }
+    this.ensureInitialized();
+    return this.resources.listPodsByLabel(labelSelector);
   }
 
   async getPodInfo(podName: string) {
-    if (!this.initialized) {
-      throw new Error("Kubernetes client not initialized");
-    }
-
-    try {
-      return await this.resources.getPodInfo(podName);
-    } catch (error: unknown) {
-      console.error(`Error fetching pod ${podName}:`, error);
-      throw new Error(`Failed to fetch pod info: ${getErrorMessage(error)}`);
-    }
+    this.ensureInitialized();
+    return this.resources.getPodInfo(podName);
   }
 
   async getServiceInfo(serviceName: string) {
-    if (!this.initialized) {
-      throw new Error("Kubernetes client not initialized");
-    }
-
-    try {
-      return await this.resources.getServiceInfo(serviceName);
-    } catch (error: unknown) {
-      console.error(`Error fetching service ${serviceName}:`, error);
-      throw new Error(
-        `Failed to fetch service info: ${getErrorMessage(error)}`,
-      );
-    }
+    this.ensureInitialized();
+    return this.resources.getServiceInfo(serviceName);
   }
 
   async getNodes() {
-    if (!this.initialized) {
-      throw new Error("Kubernetes client not initialized");
-    }
-
-    try {
-      return await this.resources.listNodes();
-    } catch (error: unknown) {
-      console.error("Error fetching nodes:", error);
-      throw new Error(`Failed to fetch nodes: ${getErrorMessage(error)}`);
-    }
+    this.ensureInitialized();
+    return this.resources.listNodes();
   }
 
   async getServerConnectionInfo(serviceName: string) {
-    if (!this.initialized) {
-      throw new Error("Kubernetes client not initialized");
-    }
-
-    try {
-      const service = await this.getServiceInfo(serviceName);
-      const nodes = await this.getNodes();
-
-      if (service.type === "ClusterIP") {
-        return {
-          type: "ClusterIP",
-          ip: service.clusterIP,
-          port: service.ports[0]?.port || null,
-          connectionString:
-            service.clusterIP && service.ports[0]?.port
-              ? `${service.clusterIP}:${service.ports[0].port}`
-              : null,
-          note: "Only accessible within the cluster",
-        };
-      }
-
-      if (service.type === "NodePort") {
-        const nodeIP = nodes[0]?.externalIP || nodes[0]?.internalIP;
-        const nodePort = service.ports[0]?.nodePort;
-        return {
-          type: "NodePort",
-          nodeIP,
-          nodePort,
-          port: service.ports[0]?.port || null,
-          connectionString: nodeIP && nodePort ? `${nodeIP}:${nodePort}` : null,
-          note:
-            nodeIP && !nodes[0]?.externalIP
-              ? "Using internal IP (may not be accessible from outside the cluster network)"
-              : "Accessible from any node in the cluster",
-        };
-      }
-
-      if (service.type === "LoadBalancer") {
-        const externalIP =
-          service.loadBalancerIP || service.loadBalancerHostname;
-        return {
-          type: "LoadBalancer",
-          externalIP,
-          port: service.ports[0]?.port || null,
-          connectionString:
-            externalIP && service.ports[0]?.port
-              ? `${externalIP}:${service.ports[0].port}`
-              : null,
-          note: !externalIP ? "LoadBalancer IP pending" : null,
-        };
-      }
+    this.ensureInitialized();
+    const service = await this.getServiceInfo(serviceName);
+    const nodes = await this.getNodes();
 
+    if (service.type === "ClusterIP") {
       return {
-        type: service.type,
-        note: "Unknown service type",
+        type: "ClusterIP",
+        ip: service.clusterIP,
+        port: service.ports[0]?.port || null,
+        connectionString:
+          service.clusterIP && service.ports[0]?.port
+            ? `${service.clusterIP}:${service.ports[0].port}`
+            : null,
+        note: "Only accessible within the cluster",
       };
-    } catch (error: unknown) {
-      console.error(
-        `Error fetching connection info for service ${serviceName}:`,
-        error,
-      );
-      throw new Error(
-        `Failed to fetch connection info: ${getErrorMessage(error)}`,
-      );
     }
+
+    if (service.type === "NodePort") {
+      const nodeIP = nodes[0]?.externalIP || nodes[0]?.internalIP;
+      const nodePort = service.ports[0]?.nodePort;
+      return {
+        type: "NodePort",
+        nodeIP,
+        nodePort,
+        port: service.ports[0]?.port || null,
+        connectionString: nodeIP && nodePort ? `${nodeIP}:${nodePort}` : null,
+        note:
+          nodeIP && !nodes[0]?.externalIP
+            ? "Using internal IP (may not be accessible from outside the cluster network)"
+            : "Accessible from any node in the cluster",
+      };
+    }
+
+    if (service.type === "LoadBalancer") {
+      const externalIP = service.loadBalancerIP || service.loadBalancerHostname;
+      return {
+        type: "LoadBalancer",
+        externalIP,
+        port: service.ports[0]?.port || null,
+        connectionString:
+          externalIP && service.ports[0]?.port ? `${externalIP}:${service.ports[0].port}` : null,
+        note: !externalIP ? "LoadBalancer IP pending" : null,
+      };
+    }
+
+    return {
+      type: service.type,
+      note: "Unknown service type",
+    };
   }
 
   getKubeConfig(): k8s.KubeConfig {
@@ -425,31 +239,35 @@ export class K8sService {
   getNamespace(): string {
     return this.namespace;
   }
-}
 
-function getAge(timestamp: Date | string | undefined): string {
-  if (!timestamp) return "unknown";
-  const now = new Date();
-  const created = new Date(timestamp);
-  const diff = now.getTime() - created.getTime();
-
-  const seconds = Math.floor(diff / 1000);
-  const minutes = Math.floor(seconds / 60);
-  const hours = Math.floor(minutes / 60);
-  const days = Math.floor(hours / 24);
-
-  if (days > 0) return `${days}d`;
-  if (hours > 0) return `${hours}h`;
-  if (minutes > 0) return `${minutes}m`;
-  return `${seconds}s`;
-}
-
-function getErrorMessage(error: unknown): string {
-  if (error instanceof Error) {
-    return error.message;
+  async getPodMetrics(namespace?: string) {
+    this.ensureInitialized();
+    return this.executeOperationSafe(
+      () => this.podOps.getPodMetrics(this.customObjectsApi, namespace),
+      { items: [] },
+      "Error fetching pod metrics"
+    );
   }
-  if (typeof error === "string") {
-    return error;
+
+  async getNodeMetrics() {
+    this.ensureInitialized();
+    return this.executeOperationSafe(
+      () => this.clusterOps.getNodeMetrics(),
+      { items: [] },
+      "Error fetching node metrics"
+    );
+  }
+
+  private async executeOperationSafe<T>(
+    operation: () => Promise<T>,
+    defaultValue: T,
+    errorContext: string
+  ): Promise<T> {
+    try {
+      return await operation();
+    } catch (error: unknown) {
+      logger.error({ err: error, context: errorContext }, "K8s operation failed");
+      return defaultValue;
+    }
   }
-  return "Unknown error";
 }

apps/backend/src/services/kubernetes/operations/base.operations.ts

@@ -0,0 +1,40 @@
+import { getErrorMessage } from "@minikura/shared/errors";
+import { logger } from "../../../infrastructure/logger";
+
+export abstract class BaseK8sOperations {
+  protected namespace: string;
+
+  constructor(namespace: string) {
+    this.namespace = namespace;
+  }
+
+  protected async executeOperation<T>(
+    operation: () => Promise<T>,
+    errorContext: string
+  ): Promise<T> {
+    try {
+      return await operation();
+    } catch (error: unknown) {
+      const errorMessage = getErrorMessage(error);
+      logger.error({ err: error, context: errorContext }, "K8s operation failed");
+      throw new Error(`${errorContext}: ${errorMessage}`);
+    }
+  }
+
+  protected async executeOperationSafe<T>(
+    operation: () => Promise<T>,
+    defaultValue: T,
+    errorContext: string
+  ): Promise<T> {
+    try {
+      return await operation();
+    } catch (error: unknown) {
+      logger.error({ err: error, context: errorContext }, "K8s operation failed (safe mode)");
+      return defaultValue;
+    }
+  }
+
+  getNamespace(): string {
+    return this.namespace;
+  }
+}

apps/backend/src/services/kubernetes/operations/cluster.operations.ts

@@ -0,0 +1,39 @@
+import type * as k8s from "@kubernetes/client-node";
+import { BaseK8sOperations } from "./base.operations";
+
+export class ClusterOperations extends BaseK8sOperations {
+  constructor(
+    private coreApi: k8s.CoreV1Api,
+    private customObjectsApi: k8s.CustomObjectsApi,
+    namespace: string
+  ) {
+    super(namespace);
+  }
+
+  async listNodes() {
+    return this.executeOperation(
+      () => this.coreApi.listNode().then((r) => r.items),
+      "Failed to fetch nodes"
+    );
+  }
+
+  async getNodeMetrics() {
+    return this.executeOperation(
+      () =>
+        this.customObjectsApi.listClusterCustomObject({
+          group: "metrics.k8s.io",
+          version: "v1beta1",
+          plural: "nodes",
+        }),
+      "Failed to fetch node metrics"
+    );
+  }
+
+  async listConfigMaps(namespace?: string) {
+    const ns = namespace || this.namespace;
+    return this.executeOperation(
+      () => this.coreApi.listNamespacedConfigMap({ namespace: ns }).then((r) => r.items),
+      "Failed to fetch configmaps"
+    );
+  }
+}

apps/backend/src/services/kubernetes/operations/custom-resource.operations.ts

@@ -0,0 +1,55 @@
+import type * as k8s from "@kubernetes/client-node";
+import type { CustomResourceSummary } from "@minikura/api";
+import { getAge } from "@minikura/shared/errors";
+import { BaseK8sOperations } from "./base.operations";
+
+interface CustomResourceItem {
+  kind?: string;
+  metadata?: {
+    name?: string;
+    namespace?: string;
+    creationTimestamp?: string;
+    labels?: Record<string, string>;
+  };
+  spec?: Record<string, unknown>;
+  status?: { phase?: string; [key: string]: unknown };
+}
+
+interface CustomResourceList {
+  items?: CustomResourceItem[];
+}
+
+export class CustomResourceOperations extends BaseK8sOperations {
+  constructor(
+    private customObjectsApi: k8s.CustomObjectsApi,
+    namespace: string
+  ) {
+    super(namespace);
+  }
+
+  async listCustomResources(
+    group: string,
+    version: string,
+    plural: string
+  ): Promise<CustomResourceSummary[]> {
+    return this.executeOperation(async () => {
+      const response = await this.customObjectsApi.listNamespacedCustomObject({
+        group,
+        version,
+        namespace: this.namespace,
+        plural,
+      });
+
+      const items = (response as unknown as CustomResourceList).items || [];
+
+      return items.map((item) => ({
+        name: item.metadata?.name ?? "",
+        namespace: item.metadata?.namespace ?? this.namespace,
+        age: getAge(item.metadata?.creationTimestamp),
+        labels: item.metadata?.labels,
+        spec: item.spec ?? {},
+        status: item.status ?? {},
+      }));
+    }, `Failed to fetch custom resources (${plural})`);
+  }
+}

apps/backend/src/services/kubernetes/operations/index.ts

@@ -0,0 +1,6 @@
+export { BaseK8sOperations } from "./base.operations";
+export { ClusterOperations } from "./cluster.operations";
+export { CustomResourceOperations } from "./custom-resource.operations";
+export { NetworkOperations } from "./network.operations";
+export { PodOperations } from "./pod.operations";
+export { WorkloadOperations } from "./workload.operations";

apps/backend/src/services/kubernetes/operations/network.operations.ts

@@ -0,0 +1,89 @@
+import type * as k8s from "@kubernetes/client-node";
+import { BaseK8sOperations } from "./base.operations";
+
+export class NetworkOperations extends BaseK8sOperations {
+  constructor(
+    private coreApi: k8s.CoreV1Api,
+    private networkingApi: k8s.NetworkingV1Api,
+    namespace: string
+  ) {
+    super(namespace);
+  }
+
+  async listServices() {
+    return this.executeOperation(
+      () => this.coreApi.listNamespacedService({ namespace: this.namespace }).then((r) => r.items),
+      "Failed to fetch services"
+    );
+  }
+
+  async listIngresses() {
+    return this.executeOperation(
+      () =>
+        this.networkingApi
+          .listNamespacedIngress({ namespace: this.namespace })
+          .then((r) => r.items),
+      "Failed to fetch ingresses"
+    );
+  }
+
+  async getServiceInfo(serviceName: string) {
+    return this.executeOperation(
+      () => this.coreApi.readNamespacedService({ name: serviceName, namespace: this.namespace }),
+      `Failed to fetch service info for ${serviceName}`
+    );
+  }
+
+  async getServerConnectionInfo(serviceName: string) {
+    return this.executeOperation(async () => {
+      const service = await this.coreApi.readNamespacedService({
+        name: serviceName,
+        namespace: this.namespace,
+      });
+
+      const serviceType = service.spec?.type || "ClusterIP";
+      const ports = service.spec?.ports || [];
+
+      let host: string;
+      let externalHost: string | undefined;
+
+      switch (serviceType) {
+        case "LoadBalancer": {
+          const ingress = service.status?.loadBalancer?.ingress?.[0];
+          host =
+            ingress?.hostname ||
+            ingress?.ip ||
+            `${serviceName}.${this.namespace}.svc.cluster.local`;
+          externalHost = ingress?.hostname || ingress?.ip;
+          break;
+        }
+
+        case "NodePort":
+          host = `${serviceName}.${this.namespace}.svc.cluster.local`;
+          externalHost = "<node-ip>";
+          break;
+
+        default:
+          host = `${serviceName}.${this.namespace}.svc.cluster.local`;
+          externalHost = undefined;
+      }
+
+      const portMappings = ports.map((port) => ({
+        name: port.name,
+        port: port.port,
+        targetPort: port.targetPort,
+        nodePort: port.nodePort,
+        protocol: port.protocol || "TCP",
+      }));
+
+      return {
+        serviceName,
+        namespace: this.namespace,
+        serviceType,
+        internalHost: host,
+        externalHost,
+        ports: portMappings,
+      };
+    }, `Failed to fetch connection info for service ${serviceName}`);
+  }
+}

apps/backend/src/services/kubernetes/operations/pod.operations.ts

@@ -0,0 +1,72 @@
+import type * as k8s from "@kubernetes/client-node";
+import { BaseK8sOperations } from "./base.operations";
+
+export class PodOperations extends BaseK8sOperations {
+  constructor(
+    private coreApi: k8s.CoreV1Api,
+    namespace: string
+  ) {
+    super(namespace);
+  }
+
+  async listPods() {
+    return this.executeOperation(
+      () => this.coreApi.listNamespacedPod({ namespace: this.namespace }).then((r) => r.items),
+      "Failed to fetch pods"
+    );
+  }
+
+  async listPodsByLabel(labelSelector: string) {
+    return this.executeOperation(
+      () =>
+        this.coreApi
+          .listNamespacedPod({ namespace: this.namespace, labelSelector })
+          .then((r) => r.items),
+      "Failed to fetch pods by label"
+    );
+  }
+
+  async getPodInfo(podName: string) {
+    return this.executeOperation(
+      () => this.coreApi.readNamespacedPod({ name: podName, namespace: this.namespace }),
+      `Failed to fetch pod info for ${podName}`
+    );
+  }
+
+  async getPodLogs(
+    podName: string,
+    options?: {
+      container?: string;
+      tailLines?: number;
+      timestamps?: boolean;
+      sinceSeconds?: number;
+    }
+  ): Promise<string> {
+    return this.executeOperation(
+      () =>
+        this.coreApi.readNamespacedPodLog({
+          name: podName,
+          namespace: this.namespace,
+          container: options?.container,
+          tailLines: options?.tailLines,
+          timestamps: options?.timestamps,
+          sinceSeconds: options?.sinceSeconds,
+        }),
+      `Failed to fetch logs for pod ${podName}`
+    );
+  }
+
+  async getPodMetrics(customObjectsApi: k8s.CustomObjectsApi, namespace?: string) {
+    const ns = namespace || this.namespace;
+    return this.executeOperation(
+      () =>
+        customObjectsApi.listNamespacedCustomObject({
+          group: "metrics.k8s.io",
+          version: "v1beta1",
+          namespace: ns,
+          plural: "pods",
+        }),
+      "Failed to fetch pod metrics"
+    );
+  }
+}

apps/backend/src/services/kubernetes/operations/workload.operations.ts

@@ -0,0 +1,27 @@
+import type * as k8s from "@kubernetes/client-node";
+import { BaseK8sOperations } from "./base.operations";
+
+export class WorkloadOperations extends BaseK8sOperations {
+  constructor(
+    private appsApi: k8s.AppsV1Api,
+    namespace: string
+  ) {
+    super(namespace);
+  }
+
+  async listDeployments() {
+    return this.executeOperation(
+      () =>
+        this.appsApi.listNamespacedDeployment({ namespace: this.namespace }).then((r) => r.items),
+      "Failed to fetch deployments"
+    );
+  }
+
+  async listStatefulSets() {
+    return this.executeOperation(
+      () =>
+        this.appsApi.listNamespacedStatefulSet({ namespace: this.namespace }).then((r) => r.items),
+      "Failed to fetch statefulsets"
+    );
+  }
+}

apps/backend/src/services/kubernetes/resources.ts

@@ -11,6 +11,7 @@ import type {
   PodInfo,
   StatefulSetInfo,
 } from "@minikura/api";
+import { getAge } from "@minikura/shared/errors";
 
 export class K8sResources {
   constructor(
@@ -216,7 +217,9 @@ export class K8sResources {
       const internalIP = addresses.find((address) => address.type === "InternalIP")?.address;
       const externalIP = addresses.find((address) => address.type === "ExternalIP")?.address;
       const hostname = addresses.find((address) => address.type === "Hostname")?.address;
-      const readyCondition = node.status?.conditions?.find((condition) => condition.type === "Ready");
+      const readyCondition = node.status?.conditions?.find(
+        (condition) => condition.type === "Ready"
+      );
 
       return {
         name: node.metadata?.name,
@@ -252,20 +255,3 @@ function mapPodInfo(pod: k8s.V1Pod): PodInfo {
     nodeName: pod.spec?.nodeName,
   };
 }
-
-function getAge(timestamp: Date | string | undefined): string {
-  if (!timestamp) return "unknown";
-  const now = new Date();
-  const created = new Date(timestamp);
-  const diff = now.getTime() - created.getTime();
-
-  const seconds = Math.floor(diff / 1000);
-  const minutes = Math.floor(seconds / 60);
-  const hours = Math.floor(minutes / 60);
-  const days = Math.floor(hours / 24);
-
-  if (days > 0) return `${days}d`;
-  if (hours > 0) return `${hours}h`;
-  if (minutes > 0) return `${minutes}m`;
-  return `${seconds}s`;
-}

apps/backend/src/services/websocket.ts

@@ -1,3 +1,5 @@
+import { logger } from "../infrastructure/logger";
+
 export type WebSocketClient = {
   send: (message: string) => void;
 };
@@ -14,14 +16,12 @@ export class WebSocketService implements IWebSocketService {
 
   addClient(client: WebSocketClient): void {
     this.clients.add(client);
-    console.log(`[WebSocket] Client connected (total: ${this.clients.size})`);
+    logger.debug({ totalClients: this.clients.size }, "WebSocket client connected");
   }
 
   removeClient(client: WebSocketClient): void {
     this.clients.delete(client);
-    console.log(
-      `[WebSocket] Client disconnected (total: ${this.clients.size})`,
-    );
+    logger.debug({ totalClients: this.clients.size }, "WebSocket client disconnected");
   }
 
   broadcast(action: string, serverType: string, serverId: string): void {
@@ -33,6 +33,7 @@ export class WebSocketService implements IWebSocketService {
       timestamp: new Date().toISOString(),
     });
 
+    // Send to all connected clients, removing any that fail
     let failedClients = 0;
     this.clients.forEach((client) => {
       try {
@@ -44,7 +45,7 @@ export class WebSocketService implements IWebSocketService {
     });
 
     if (failedClients > 0) {
-      console.log(`[WebSocket] Removed ${failedClients} failed clients`);
+      logger.warn({ failedClients }, "Removed failed WebSocket clients");
     }
   }