feat: implement frontend with TDD (Part 8)

- Scaffold Vite + React 19 + TypeScript strict project
- Neumorphic dark design system (Tailwind v3, amber/orange LED accents)
- Zustand stores for auth (persist) and UI state (notifications, sidebar)
- TanStack Query v5 hooks for server CRUD operations
- WebSocket hook with reconnection backoff and query invalidation
- Components: StatusLed, Sidebar, ServerCard, LoginPage, DashboardPage
- Protected routing with auth guard
- Axios client with JWT interceptor and 401 redirect
- 68 tests across 11 test files (89% statement coverage, 90% function coverage)
- TDD workflow: RED validated, GREEN achieved, coverage verified

frontend/src/App.css

@@ -0,0 +1,184 @@
+.counter {
+  font-size: 16px;
+  padding: 5px 10px;
+  border-radius: 5px;
+  color: var(--accent);
+  background: var(--accent-bg);
+  border: 2px solid transparent;
+  transition: border-color 0.3s;
+  margin-bottom: 24px;
+
+  &:hover {
+    border-color: var(--accent-border);
+  }
+  &:focus-visible {
+    outline: 2px solid var(--accent);
+    outline-offset: 2px;
+  }
+}
+
+.hero {
+  position: relative;
+
+  .base,
+  .framework,
+  .vite {
+    inset-inline: 0;
+    margin: 0 auto;
+  }
+
+  .base {
+    width: 170px;
+    position: relative;
+    z-index: 0;
+  }
+
+  .framework,
+  .vite {
+    position: absolute;
+  }
+
+  .framework {
+    z-index: 1;
+    top: 34px;
+    height: 28px;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(44deg) rotateY(39deg)
+      scale(1.4);
+  }
+
+  .vite {
+    z-index: 0;
+    top: 107px;
+    height: 26px;
+    width: auto;
+    transform: perspective(2000px) rotateZ(300deg) rotateX(40deg) rotateY(39deg)
+      scale(0.8);
+  }
+}
+
+#center {
+  display: flex;
+  flex-direction: column;
+  gap: 25px;
+  place-content: center;
+  place-items: center;
+  flex-grow: 1;
+
+  @media (max-width: 1024px) {
+    padding: 32px 20px 24px;
+    gap: 18px;
+  }
+}
+
+#next-steps {
+  display: flex;
+  border-top: 1px solid var(--border);
+  text-align: left;
+
+  & > div {
+    flex: 1 1 0;
+    padding: 32px;
+    @media (max-width: 1024px) {
+      padding: 24px 20px;
+    }
+  }
+
+  .icon {
+    margin-bottom: 16px;
+    width: 22px;
+    height: 22px;
+  }
+
+  @media (max-width: 1024px) {
+    flex-direction: column;
+    text-align: center;
+  }
+}
+
+#docs {
+  border-right: 1px solid var(--border);
+
+  @media (max-width: 1024px) {
+    border-right: none;
+    border-bottom: 1px solid var(--border);
+  }
+}
+
+#next-steps ul {
+  list-style: none;
+  padding: 0;
+  display: flex;
+  gap: 8px;
+  margin: 32px 0 0;
+
+  .logo {
+    height: 18px;
+  }
+
+  a {
+    color: var(--text-h);
+    font-size: 16px;
+    border-radius: 6px;
+    background: var(--social-bg);
+    display: flex;
+    padding: 6px 12px;
+    align-items: center;
+    gap: 8px;
+    text-decoration: none;
+    transition: box-shadow 0.3s;
+
+    &:hover {
+      box-shadow: var(--shadow);
+    }
+    .button-icon {
+      height: 18px;
+      width: 18px;
+    }
+  }
+
+  @media (max-width: 1024px) {
+    margin-top: 20px;
+    flex-wrap: wrap;
+    justify-content: center;
+
+    li {
+      flex: 1 1 calc(50% - 8px);
+    }
+
+    a {
+      width: 100%;
+      justify-content: center;
+      box-sizing: border-box;
+    }
+  }
+}
+
+#spacer {
+  height: 88px;
+  border-top: 1px solid var(--border);
+  @media (max-width: 1024px) {
+    height: 48px;
+  }
+}
+
+.ticks {
+  position: relative;
+  width: 100%;
+
+  &::before,
+  &::after {
+    content: '';
+    position: absolute;
+    top: -4.5px;
+    border: 5px solid transparent;
+  }
+
+  &::before {
+    left: 0;
+    border-left-color: var(--border);
+  }
+  &::after {
+    right: 0;
+    border-right-color: var(--border);
+  }
+}

frontend/src/App.tsx

@@ -0,0 +1,54 @@
+import { BrowserRouter, Routes, Route, Navigate } from "react-router-dom";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { ReactQueryDevtools } from "@tanstack/react-query-devtools";
+
+import { useAuthStore } from "@/store/auth.store";
+import { Sidebar } from "@/components/layout/Sidebar";
+import { LoginPage } from "@/pages/LoginPage";
+import { DashboardPage } from "@/pages/DashboardPage";
+
+const queryClient = new QueryClient({
+  defaultOptions: {
+    queries: {
+      staleTime: 10_000,
+      retry: 2,
+      refetchOnWindowFocus: false,
+    },
+  },
+});
+
+function ProtectedLayout() {
+  const isAuthenticated = useAuthStore((s) => s.isAuthenticated);
+
+  if (!isAuthenticated) {
+    return <Navigate to="/login" replace />;
+  }
+
+  return (
+    <div className="flex h-screen overflow-hidden">
+      <Sidebar />
+      <main className="flex-1 overflow-y-auto bg-surface-base">
+        <Routes>
+          <Route path="/" element={<DashboardPage />} />
+          <Route path="/servers/:serverId" element={<div className="p-6 text-text-primary">Server detail — coming soon</div>} />
+          <Route path="/servers/new" element={<div className="p-6 text-text-primary">Create server — coming soon</div>} />
+          <Route path="/settings" element={<div className="p-6 text-text-primary">Settings — coming soon</div>} />
+        </Routes>
+      </main>
+    </div>
+  );
+}
+
+export default function App() {
+  return (
+    <QueryClientProvider client={queryClient}>
+      <BrowserRouter>
+        <Routes>
+          <Route path="/login" element={<LoginPage />} />
+          <Route path="/*" element={<ProtectedLayout />} />
+        </Routes>
+      </BrowserRouter>
+      <ReactQueryDevtools initialIsOpen={false} />
+    </QueryClientProvider>
+  );
+}

frontend/src/__tests__/DashboardPage.test.tsx

@@ -0,0 +1,124 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { render, screen } from "@testing-library/react";
+import { MemoryRouter, Route, Routes } from "react-router-dom";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+
+import { DashboardPage } from "@/pages/DashboardPage";
+import { useServers } from "@/hooks/useServers";
+import type { Server } from "@/hooks/useServers";
+
+const mockMutation = () => ({
+  mutateAsync: vi.fn(() => Promise.resolve()),
+  mutate: vi.fn(),
+  isPending: false,
+  isSuccess: false,
+  isError: false,
+  reset: vi.fn(),
+});
+
+vi.mock("@/hooks/useServers", () => ({
+  useServers: vi.fn(),
+  useStartServer: vi.fn(() => mockMutation()),
+  useStopServer: vi.fn(() => mockMutation()),
+  useRestartServer: vi.fn(() => mockMutation()),
+  useCreateServer: vi.fn(() => mockMutation()),
+  useDeleteServer: vi.fn(() => mockMutation()),
+}));
+vi.mock("@/hooks/useWebSocket", () => ({
+  useWebSocket: vi.fn(),
+}));
+
+const mockServer: Server = {
+  id: 1,
+  name: "Arma3 Test",
+  game_type: "arma3",
+  status: "running",
+  port: 2302,
+  max_players: 64,
+  current_players: 32,
+  restart_count: 0,
+  auto_restart: true,
+  created_at: "2026-01-01T00:00:00Z",
+};
+
+function renderDashboard() {
+  const queryClient = new QueryClient({
+    defaultOptions: { queries: { retry: false } },
+  });
+
+  return render(
+    <QueryClientProvider client={queryClient}>
+      <MemoryRouter>
+        <Routes>
+          <Route path="*" element={<DashboardPage />} />
+        </Routes>
+      </MemoryRouter>
+    </QueryClientProvider>,
+  );
+}
+
+describe("DashboardPage", () => {
+  beforeEach(() => {
+    vi.mocked(useServers).mockReturnValue({
+      data: undefined,
+      isLoading: true,
+      isError: false,
+      error: null,
+    } as unknown as ReturnType<typeof useServers>);
+  });
+
+  it("should show loading state", () => {
+    renderDashboard();
+    expect(screen.getByText("Loading servers...")).toBeInTheDocument();
+  });
+
+  it("should show error state", () => {
+    vi.mocked(useServers).mockReturnValue({
+      data: undefined,
+      isLoading: false,
+      isError: true,
+      error: new Error("fail"),
+    } as unknown as ReturnType<typeof useServers>);
+
+    renderDashboard();
+    expect(screen.getByText("Failed to load servers")).toBeInTheDocument();
+  });
+
+  it("should show empty state when no servers", () => {
+    vi.mocked(useServers).mockReturnValue({
+      data: [],
+      isLoading: false,
+      isError: false,
+      error: null,
+    } as unknown as ReturnType<typeof useServers>);
+
+    renderDashboard();
+    expect(screen.getByText("No servers configured yet.")).toBeInTheDocument();
+    expect(screen.getByText("Add your first server")).toBeInTheDocument();
+  });
+
+  it("should render server cards", () => {
+    vi.mocked(useServers).mockReturnValue({
+      data: [mockServer],
+      isLoading: false,
+      isError: false,
+      error: null,
+    } as unknown as ReturnType<typeof useServers>);
+
+    renderDashboard();
+    expect(screen.getByText("Arma3 Test")).toBeInTheDocument();
+    expect(screen.getByText("1 server configured")).toBeInTheDocument();
+  });
+
+  it("should show Add Server link", () => {
+    vi.mocked(useServers).mockReturnValue({
+      data: [mockServer],
+      isLoading: false,
+      isError: false,
+      error: null,
+    } as unknown as ReturnType<typeof useServers>);
+
+    renderDashboard();
+    expect(screen.getByText("Add Server")).toBeInTheDocument();
+  });
+});

frontend/src/__tests__/LoginPage.test.tsx

@@ -0,0 +1,95 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { render, screen, waitFor } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { MemoryRouter, Route, Routes } from "react-router-dom";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+
+import { LoginPage } from "@/pages/LoginPage";
+
+vi.mock("@/lib/api", () => ({
+  apiClient: {
+    post: vi.fn(),
+  },
+}));
+
+import { apiClient } from "@/lib/api";
+
+function renderLoginPage() {
+  const queryClient = new QueryClient({
+    defaultOptions: { queries: { retry: false } },
+  });
+
+  return {
+    user: userEvent.setup(),
+    ...render(
+      <QueryClientProvider client={queryClient}>
+        <MemoryRouter initialEntries={["/login"]}>
+          <Routes>
+            <Route path="/login" element={<LoginPage />} />
+            <Route path="/" element={<div>Dashboard</div>} />
+          </Routes>
+        </MemoryRouter>
+      </QueryClientProvider>,
+    ),
+  };
+}
+
+describe("LoginPage", () => {
+  beforeEach(() => {
+    vi.mocked(apiClient.post).mockReset();
+  });
+
+  it("should render login form", () => {
+    renderLoginPage();
+    expect(screen.getByLabelText("Username")).toBeInTheDocument();
+    expect(screen.getByLabelText("Password")).toBeInTheDocument();
+    expect(screen.getByRole("button", { name: /sign in/i })).toBeInTheDocument();
+  });
+
+  it("should show validation errors on empty submit", async () => {
+    const { user } = renderLoginPage();
+    await user.click(screen.getByRole("button", { name: /sign in/i }));
+    await waitFor(() => {
+      expect(screen.getByText("Username is required")).toBeInTheDocument();
+    });
+  });
+
+  it("should call API on valid submit", async () => {
+    vi.mocked(apiClient.post).mockResolvedValueOnce({
+      data: {
+        success: true,
+        data: {
+          access_token: "test-token",
+          user: { id: 1, username: "admin", role: "admin" as const },
+        },
+      },
+    });
+
+    const { user } = renderLoginPage();
+    await user.type(screen.getByLabelText("Username"), "admin");
+    await user.type(screen.getByLabelText("Password"), "password");
+    await user.click(screen.getByRole("button", { name: /sign in/i }));
+
+    await waitFor(() => {
+      expect(apiClient.post).toHaveBeenCalledWith("/api/auth/login", {
+        username: "admin",
+        password: "password",
+      });
+    });
+  });
+
+  it("should show error on failed login", async () => {
+    vi.mocked(apiClient.post).mockRejectedValueOnce({
+      response: { data: { detail: "Invalid credentials" } },
+    });
+
+    const { user } = renderLoginPage();
+    await user.type(screen.getByLabelText("Username"), "admin");
+    await user.type(screen.getByLabelText("Password"), "wrong");
+    await user.click(screen.getByRole("button", { name: /sign in/i }));
+
+    await waitFor(() => {
+      expect(screen.getByText("Invalid credentials")).toBeInTheDocument();
+    });
+  });
+});

frontend/src/__tests__/ServerCard.handlers.test.tsx

@@ -0,0 +1,173 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { render, screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+
+import { ServerCard } from "@/components/servers/ServerCard";
+import type { Server } from "@/hooks/useServers";
+import {
+  useStartServer,
+  useStopServer,
+  useRestartServer,
+} from "@/hooks/useServers";
+import { useUIStore } from "@/store/ui.store";
+
+vi.mock("@/hooks/useServers", () => ({
+  useStartServer: vi.fn(),
+  useStopServer: vi.fn(),
+  useRestartServer: vi.fn(),
+}));
+
+const baseServer: Server = {
+  id: 1,
+  name: "Test Arma3",
+  game_type: "arma3",
+  status: "running",
+  port: 2302,
+  max_players: 64,
+  current_players: 32,
+  restart_count: 3,
+  auto_restart: true,
+  created_at: "2026-01-01T00:00:00Z",
+};
+
+function renderCard(server: Partial<Server> = {}) {
+  const fullServer: Server = { ...baseServer, ...server };
+  const queryClient = new QueryClient({
+    defaultOptions: { queries: { retry: false } },
+  });
+  return {
+    user: userEvent.setup(),
+    ...render(
+      <QueryClientProvider client={queryClient}>
+        <ServerCard server={fullServer} />
+      </QueryClientProvider>,
+    ),
+  };
+}
+
+function mockMutationResult(
+  overrides: Partial<{ mutateAsync: ReturnType<typeof vi.fn>; isPending: boolean }> = {},
+) {
+  return {
+    mutateAsync: vi.fn(() => Promise.resolve()),
+    isPending: false,
+    isSuccess: false,
+    isError: false,
+    reset: vi.fn(),
+    mutate: vi.fn(),
+    ...overrides,
+  };
+}
+
+describe("ServerCard handlers", () => {
+  beforeEach(() => {
+    useUIStore.setState({ notifications: [] });
+    vi.mocked(useStartServer).mockReturnValue(
+      mockMutationResult() as unknown as ReturnType<typeof useStartServer>,
+    );
+    vi.mocked(useStopServer).mockReturnValue(
+      mockMutationResult() as unknown as ReturnType<typeof useStopServer>,
+    );
+    vi.mocked(useRestartServer).mockReturnValue(
+      mockMutationResult() as unknown as ReturnType<typeof useRestartServer>,
+    );
+  });
+
+  it("should add success notification on start success", async () => {
+    const { user } = renderCard({ status: "stopped" });
+    await user.click(screen.getByLabelText("Start Test Arma3"));
+
+    const state = useUIStore.getState();
+    expect(state.notifications).toHaveLength(1);
+    expect(state.notifications[0].type).toBe("success");
+  });
+
+  it("should add error notification on start failure", async () => {
+    const startMutation = mockMutationResult({
+      mutateAsync: vi.fn(() => Promise.reject(new Error("fail"))),
+    });
+    vi.mocked(useStartServer).mockReturnValue(
+      startMutation as unknown as ReturnType<typeof useStartServer>,
+    );
+
+    const { user } = renderCard({ status: "stopped" });
+    await user.click(screen.getByLabelText("Start Test Arma3"));
+
+    const state = useUIStore.getState();
+    expect(state.notifications.some((n) => n.type === "error")).toBe(true);
+  });
+
+  it("should call stopServer on Stop click", async () => {
+    const stopMutation = mockMutationResult();
+    vi.mocked(useStopServer).mockReturnValue(
+      stopMutation as unknown as ReturnType<typeof useStopServer>,
+    );
+
+    const { user } = renderCard({ status: "running" });
+    await user.click(screen.getByLabelText("Stop Test Arma3"));
+    expect(stopMutation.mutateAsync).toHaveBeenCalledWith({ serverId: 1 });
+  });
+
+  it("should add error notification on stop failure", async () => {
+    const stopMutation = mockMutationResult({
+      mutateAsync: vi.fn(() => Promise.reject(new Error("fail"))),
+    });
+    vi.mocked(useStopServer).mockReturnValue(
+      stopMutation as unknown as ReturnType<typeof useStopServer>,
+    );
+
+    const { user } = renderCard({ status: "running" });
+    await user.click(screen.getByLabelText("Stop Test Arma3"));
+
+    const state = useUIStore.getState();
+    expect(state.notifications.some((n) => n.type === "error")).toBe(true);
+  });
+
+  it("should call restartServer on Restart click", async () => {
+    const restartMutation = mockMutationResult();
+    vi.mocked(useRestartServer).mockReturnValue(
+      restartMutation as unknown as ReturnType<typeof useRestartServer>,
+    );
+
+    const { user } = renderCard({ status: "running" });
+    await user.click(screen.getByLabelText("Restart Test Arma3"));
+    expect(restartMutation.mutateAsync).toHaveBeenCalledWith(1);
+  });
+
+  it("should add error notification on restart failure", async () => {
+    const restartMutation = mockMutationResult({
+      mutateAsync: vi.fn(() => Promise.reject(new Error("fail"))),
+    });
+    vi.mocked(useRestartServer).mockReturnValue(
+      restartMutation as unknown as ReturnType<typeof useRestartServer>,
+    );
+
+    const { user } = renderCard({ status: "running" });
+    await user.click(screen.getByLabelText("Restart Test Arma3"));
+
+    const state = useUIStore.getState();
+    expect(state.notifications.some((n) => n.type === "error")).toBe(true);
+  });
+
+  it("should disable Restart button when server is starting", () => {
+    renderCard({ status: "starting" });
+    const restartBtn = screen.getByLabelText("Restart Test Arma3");
+    expect(restartBtn).toBeDisabled();
+  });
+
+  it("should disable Stop and Restart when server is restarting", () => {
+    renderCard({ status: "restarting" });
+    expect(screen.getByLabelText("Stop Test Arma3")).toBeDisabled();
+    expect(screen.getByLabelText("Restart Test Arma3")).toBeDisabled();
+  });
+
+  it("should disable Start button while start is pending", () => {
+    vi.mocked(useStartServer).mockReturnValue(
+      mockMutationResult({ isPending: true }) as unknown as ReturnType<typeof useStartServer>,
+    );
+
+    renderCard({ status: "stopped" });
+    expect(screen.getByLabelText("Start Test Arma3")).toBeDisabled();
+  });
+});

frontend/src/__tests__/ServerCard.test.tsx

@@ -0,0 +1,116 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { render, screen } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+
+import { ServerCard } from "@/components/servers/ServerCard";
+import type { Server } from "@/hooks/useServers";
+import {
+  useStartServer,
+  useStopServer,
+  useRestartServer,
+} from "@/hooks/useServers";
+
+vi.mock("@/hooks/useServers", () => ({
+  useStartServer: vi.fn(),
+  useStopServer: vi.fn(),
+  useRestartServer: vi.fn(),
+}));
+
+const mockMutation = (resolve?: boolean) => ({
+  mutateAsync: vi.fn(() => (resolve === false ? Promise.reject(new Error("fail")) : Promise.resolve())),
+  isPending: false,
+});
+
+function renderCard(server: Partial<Server> = {}) {
+  const fullServer: Server = {
+    id: 1,
+    name: "Test Arma3",
+    game_type: "arma3",
+    status: "running",
+    port: 2302,
+    max_players: 64,
+    current_players: 32,
+    restart_count: 3,
+    auto_restart: true,
+    created_at: "2026-01-01T00:00:00Z",
+    ...server,
+  };
+
+  const queryClient = new QueryClient({
+    defaultOptions: { queries: { retry: false } },
+  });
+
+  return {
+    user: userEvent.setup(),
+    ...render(
+      <QueryClientProvider client={queryClient}>
+        <ServerCard server={fullServer} />
+      </QueryClientProvider>,
+    ),
+  };
+}
+
+describe("ServerCard", () => {
+  beforeEach(() => {
+    vi.mocked(useStartServer).mockReturnValue(mockMutation() as unknown as ReturnType<typeof useStartServer>);
+    vi.mocked(useStopServer).mockReturnValue(mockMutation() as unknown as ReturnType<typeof useStopServer>);
+    vi.mocked(useRestartServer).mockReturnValue(mockMutation() as unknown as ReturnType<typeof useRestartServer>);
+  });
+
+  it("should render server name and game type", () => {
+    renderCard();
+    expect(screen.getByText("Test Arma3")).toBeInTheDocument();
+    expect(screen.getByText("arma3")).toBeInTheDocument();
+  });
+
+  it("should display player count", () => {
+    renderCard();
+    expect(screen.getByText("32/64")).toBeInTheDocument();
+  });
+
+  it("should display port number", () => {
+    renderCard({ port: 2302 });
+    expect(screen.getByText("2302")).toBeInTheDocument();
+  });
+
+  it("should display restart count", () => {
+    renderCard({ restart_count: 3 });
+    expect(screen.getByText("3")).toBeInTheDocument();
+  });
+
+  it("should show Stop button when server is running", () => {
+    renderCard({ status: "running" });
+    expect(screen.getByLabelText("Stop Test Arma3")).toBeInTheDocument();
+  });
+
+  it("should show Start button when server is stopped", () => {
+    renderCard({ status: "stopped" });
+    expect(screen.getByLabelText("Start Test Arma3")).toBeInTheDocument();
+  });
+
+  it("should not show Start button when server is running", () => {
+    renderCard({ status: "running" });
+    expect(screen.queryByLabelText(/Start Test Arma3/)).not.toBeInTheDocument();
+  });
+
+  it("should show Restart button when server is running", () => {
+    renderCard({ status: "running" });
+    expect(screen.getByLabelText("Restart Test Arma3")).toBeInTheDocument();
+  });
+
+  it("should disable Stop button when server is starting", () => {
+    renderCard({ status: "starting" });
+    const stopBtn = screen.getByLabelText("Stop Test Arma3");
+    expect(stopBtn).toBeDisabled();
+  });
+
+  it("should call startServer on Start click", async () => {
+    const startMutation = mockMutation();
+    vi.mocked(useStartServer).mockReturnValue(startMutation as unknown as ReturnType<typeof useStartServer>);
+
+    const { user } = renderCard({ status: "stopped" });
+    await user.click(screen.getByLabelText("Start Test Arma3"));
+    expect(startMutation.mutateAsync).toHaveBeenCalledWith(1);
+  });
+});

frontend/src/__tests__/Sidebar.test.tsx

@@ -0,0 +1,104 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { render, screen } from "@testing-library/react";
+import { MemoryRouter, Route, Routes } from "react-router-dom";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+
+import { Sidebar } from "@/components/layout/Sidebar";
+import { useServers } from "@/hooks/useServers";
+import type { Server } from "@/hooks/useServers";
+
+vi.mock("@/hooks/useServers");
+
+const mockServer: Server = {
+  id: 1,
+  name: "Test Server",
+  game_type: "arma3",
+  status: "running",
+  port: 2302,
+  max_players: 64,
+  current_players: 32,
+  restart_count: 2,
+  auto_restart: true,
+  created_at: "2026-01-01T00:00:00Z",
+};
+
+function renderSidebar(path = "/") {
+  const queryClient = new QueryClient({
+    defaultOptions: { queries: { retry: false } },
+  });
+
+  return render(
+    <QueryClientProvider client={queryClient}>
+      <MemoryRouter initialEntries={[path]}>
+        <Routes>
+          <Route path="*" element={<Sidebar />} />
+        </Routes>
+      </MemoryRouter>
+    </QueryClientProvider>,
+  );
+}
+
+describe("Sidebar", () => {
+  beforeEach(() => {
+    vi.mocked(useServers).mockReturnValue({
+      data: undefined,
+      isLoading: true,
+      isError: false,
+      error: null,
+    } as unknown as ReturnType<typeof useServers>);
+  });
+
+  it("should render the Languard branding", () => {
+    renderSidebar();
+    expect(screen.getByText("Languard")).toBeInTheDocument();
+    expect(screen.getByText("Server Manager")).toBeInTheDocument();
+  });
+
+  it("should render Dashboard link", () => {
+    renderSidebar();
+    expect(screen.getByText("Dashboard")).toBeInTheDocument();
+  });
+
+  it("should render Settings link", () => {
+    renderSidebar();
+    expect(screen.getByText("Settings")).toBeInTheDocument();
+  });
+
+  it("should show loading state while servers load", () => {
+    vi.mocked(useServers).mockReturnValue({
+      data: undefined,
+      isLoading: true,
+      isError: false,
+      error: null,
+    } as unknown as ReturnType<typeof useServers>);
+
+    renderSidebar();
+    expect(screen.getByText("Loading...")).toBeInTheDocument();
+  });
+
+  it("should render server list when loaded", () => {
+    vi.mocked(useServers).mockReturnValue({
+      data: [mockServer],
+      isLoading: false,
+      isError: false,
+      error: null,
+    } as unknown as ReturnType<typeof useServers>);
+
+    renderSidebar();
+    expect(screen.getByText("Test Server")).toBeInTheDocument();
+    expect(screen.getByText("arma3")).toBeInTheDocument();
+  });
+
+  it("should highlight active server", () => {
+    vi.mocked(useServers).mockReturnValue({
+      data: [mockServer],
+      isLoading: false,
+      isError: false,
+      error: null,
+    } as unknown as ReturnType<typeof useServers>);
+
+    const { container } = renderSidebar("/servers/1");
+    const link = container.querySelector(`a[href="/servers/1"]`);
+    expect(link).toBeTruthy();
+  });
+});

frontend/src/__tests__/StatusLed.test.tsx

@@ -0,0 +1,57 @@
+import { describe, it, expect } from "vitest";
+import { render, screen } from "@testing-library/react";
+import { StatusLed } from "@/components/ui/StatusLed";
+
+describe("StatusLed", () => {
+  it("should render with correct status class for running", () => {
+    const { container } = render(<StatusLed status="running" />);
+    const led = container.querySelector("[aria-hidden='true']");
+    expect(led).toHaveClass("status-led-running");
+  });
+
+  it("should render with correct status class for stopped", () => {
+    const { container } = render(<StatusLed status="stopped" />);
+    const led = container.querySelector("[aria-hidden='true']");
+    expect(led).toHaveClass("status-led-stopped");
+  });
+
+  it("should render with correct status class for crashed", () => {
+    const { container } = render(<StatusLed status="crashed" />);
+    const led = container.querySelector("[aria-hidden='true']");
+    expect(led).toHaveClass("status-led-crashed");
+  });
+
+  it("should render with correct status class for starting", () => {
+    const { container } = render(<StatusLed status="starting" />);
+    const led = container.querySelector("[aria-hidden='true']");
+    expect(led).toHaveClass("status-led-starting");
+  });
+
+  it("should render with correct status class for restarting", () => {
+    const { container } = render(<StatusLed status="restarting" />);
+    const led = container.querySelector("[aria-hidden='true']");
+    expect(led).toHaveClass("status-led-restarting");
+  });
+
+  it("should show label when showLabel is true", () => {
+    render(<StatusLed status="running" showLabel />);
+    expect(screen.getByText("Running")).toBeInTheDocument();
+  });
+
+  it("should not show label when showLabel is false", () => {
+    render(<StatusLed status="running" />);
+    expect(screen.queryByText("Running")).not.toBeInTheDocument();
+  });
+
+  it("should use small size when size is sm", () => {
+    const { container } = render(<StatusLed status="running" size="sm" />);
+    const led = container.querySelector("[aria-hidden='true']");
+    expect(led).toHaveClass("w-1.5", "h-1.5");
+  });
+
+  it("should use medium size when size is md", () => {
+    const { container } = render(<StatusLed status="running" size="md" />);
+    const led = container.querySelector("[aria-hidden='true']");
+    expect(led).toHaveClass("w-2", "h-2");
+  });
+});

frontend/src/__tests__/api.test.ts

@@ -0,0 +1,69 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { apiClient } from "@/lib/api";
+import type { InternalAxiosRequestConfig } from "axios";
+
+describe("apiClient", () => {
+  const originalToken = localStorage.getItem("languard_token");
+
+  beforeEach(() => {
+    localStorage.clear();
+  });
+
+  afterEach(() => {
+    localStorage.clear();
+    if (originalToken) {
+      localStorage.setItem("languard_token", originalToken);
+    }
+  });
+
+  it("should not include Authorization header when no token exists", async () => {
+    const handler = apiClient.interceptors.request.handlers?.[0];
+    if (!handler?.fulfilled) return;
+    const config: InternalAxiosRequestConfig = {
+      headers: {} as InternalAxiosRequestConfig["headers"],
+      baseURL: "http://localhost:8000",
+      url: "/api/test",
+      method: "get",
+    };
+    const result = await handler.fulfilled(config);
+    expect(result.headers?.Authorization).toBeUndefined();
+  });
+
+  it("should include Authorization header when token exists", async () => {
+    localStorage.setItem("languard_token", "test-token-123");
+
+    const handler = apiClient.interceptors.request.handlers?.[0];
+    if (!handler?.fulfilled) return;
+    const config: InternalAxiosRequestConfig = {
+      headers: {} as InternalAxiosRequestConfig["headers"],
+      baseURL: "http://localhost:8000",
+      url: "/api/test",
+      method: "get",
+    };
+    const result = await handler.fulfilled(config);
+    expect(result.headers?.Authorization).toBe("Bearer test-token-123");
+  });
+
+  it("should clear token and redirect on 401 response", async () => {
+    const originalLocation = window.location;
+    Object.defineProperty(window, "location", {
+      value: { href: "" },
+      writable: true,
+    });
+
+    const mockError = {
+      response: { status: 401 },
+      config: {},
+    };
+
+    const handler = apiClient.interceptors.response.handlers?.[0];
+    if (handler?.rejected) {
+      await expect(handler.rejected(mockError as never)).rejects.toBeDefined();
+    }
+
+    expect(localStorage.getItem("languard_token")).toBeNull();
+    expect(window.location.href).toBe("/login");
+
+    Object.defineProperty(window, "location", { value: originalLocation });
+  });
+});

frontend/src/__tests__/auth.store.test.ts

@@ -0,0 +1,47 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { useAuthStore } from "@/store/auth.store";
+
+describe("useAuthStore", () => {
+  beforeEach(() => {
+    localStorage.clear();
+    useAuthStore.setState({
+      token: null,
+      user: null,
+      isAuthenticated: false,
+    });
+  });
+
+  it("should initialize with null token and user", () => {
+    const state = useAuthStore.getState();
+    expect(state.token).toBeNull();
+    expect(state.user).toBeNull();
+    expect(state.isAuthenticated).toBe(false);
+  });
+
+  it("should set auth state correctly", () => {
+    const { setAuth } = useAuthStore.getState();
+    const mockUser = { id: 1, username: "admin", role: "admin" as const };
+
+    setAuth("test-token", mockUser);
+
+    const state = useAuthStore.getState();
+    expect(state.token).toBe("test-token");
+    expect(state.user).toEqual(mockUser);
+    expect(state.isAuthenticated).toBe(true);
+    expect(localStorage.getItem("languard_token")).toBe("test-token");
+  });
+
+  it("should clear auth state correctly", () => {
+    const { setAuth, clearAuth } = useAuthStore.getState();
+    const mockUser = { id: 1, username: "admin", role: "admin" as const };
+
+    setAuth("test-token", mockUser);
+    clearAuth();
+
+    const state = useAuthStore.getState();
+    expect(state.token).toBeNull();
+    expect(state.user).toBeNull();
+    expect(state.isAuthenticated).toBe(false);
+    expect(localStorage.getItem("languard_token")).toBeNull();
+  });
+});

frontend/src/__tests__/setup.ts

@@ -0,0 +1 @@
+import "@testing-library/jest-dom";

frontend/src/__tests__/ui.store.test.ts

@@ -0,0 +1,74 @@
+import { describe, it, expect, beforeEach, vi, afterEach } from "vitest";
+import { useUIStore } from "@/store/ui.store";
+
+describe("useUIStore", () => {
+  beforeEach(() => {
+    useUIStore.setState({
+      sidebarOpen: true,
+      activeServerId: null,
+      notifications: [],
+    });
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  it("should initialize with default values", () => {
+    const state = useUIStore.getState();
+    expect(state.sidebarOpen).toBe(true);
+    expect(state.activeServerId).toBeNull();
+    expect(state.notifications).toEqual([]);
+  });
+
+  it("should toggle sidebar correctly", () => {
+    const { toggleSidebar } = useUIStore.getState();
+
+    toggleSidebar();
+    expect(useUIStore.getState().sidebarOpen).toBe(false);
+
+    toggleSidebar();
+    expect(useUIStore.getState().sidebarOpen).toBe(true);
+  });
+
+  it("should set active server correctly", () => {
+    const { setActiveServer } = useUIStore.getState();
+
+    setActiveServer(1);
+    expect(useUIStore.getState().activeServerId).toBe(1);
+
+    setActiveServer(null);
+    expect(useUIStore.getState().activeServerId).toBeNull();
+  });
+
+  it("should add notification with auto-remove", () => {
+    const { addNotification } = useUIStore.getState();
+
+    addNotification({ type: "success", message: "Test notification" });
+
+    const state = useUIStore.getState();
+    expect(state.notifications).toHaveLength(1);
+    expect(state.notifications[0]).toMatchObject({
+      type: "success",
+      message: "Test notification",
+    });
+
+    // Fast-forward to trigger auto-remove
+    vi.advanceTimersByTime(5000);
+    expect(useUIStore.getState().notifications).toHaveLength(0);
+  });
+
+  it("should remove notification by id", () => {
+    const { addNotification, removeNotification } = useUIStore.getState();
+
+    addNotification({ type: "success", message: "Test 1" });
+    addNotification({ type: "error", message: "Test 2" });
+
+    const notificationId = useUIStore.getState().notifications[0].id;
+    removeNotification(notificationId);
+
+    expect(useUIStore.getState().notifications).toHaveLength(1);
+    expect(useUIStore.getState().notifications[0].message).toBe("Test 2");
+  });
+});

frontend/src/__tests__/useServers.test.tsx

@@ -0,0 +1,216 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { renderHook, waitFor } from "@testing-library/react";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import type { ReactNode } from "react";
+
+import {
+  useServers,
+  useServer,
+  useStartServer,
+  useStopServer,
+  useRestartServer,
+  useCreateServer,
+  useDeleteServer,
+} from "@/hooks/useServers";
+
+vi.mock("@/lib/api", () => ({
+  apiClient: {
+    get: vi.fn(),
+    post: vi.fn(),
+    delete: vi.fn(),
+  },
+}));
+
+import { apiClient } from "@/lib/api";
+
+function createWrapper() {
+  const queryClient = new QueryClient({
+    defaultOptions: { queries: { retry: false } },
+  });
+  return function Wrapper({ children }: { children: ReactNode }) {
+    return (
+      <QueryClientProvider client={queryClient}>
+        {children}
+      </QueryClientProvider>
+    );
+  };
+}
+
+describe("useServers", () => {
+  beforeEach(() => {
+    vi.mocked(apiClient.get).mockReset();
+  });
+
+  it("should fetch servers list", async () => {
+    const mockServers = [
+      {
+        id: 1,
+        name: "Arma3",
+        game_type: "arma3",
+        status: "running",
+        port: 2302,
+        max_players: 64,
+        current_players: 10,
+        restart_count: 0,
+        auto_restart: true,
+        created_at: "2026-01-01T00:00:00Z",
+      },
+    ];
+    vi.mocked(apiClient.get).mockResolvedValueOnce({
+      data: { success: true, data: mockServers },
+    });
+
+    const { result } = renderHook(() => useServers(), {
+      wrapper: createWrapper(),
+    });
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(result.current.data).toEqual(mockServers);
+    expect(apiClient.get).toHaveBeenCalledWith("/api/servers");
+  });
+});
+
+describe("useServer", () => {
+  beforeEach(() => {
+    vi.mocked(apiClient.get).mockReset();
+  });
+
+  it("should fetch single server", async () => {
+    const mockServer = {
+      id: 1,
+      name: "Arma3",
+      game_type: "arma3",
+      status: "running",
+      port: 2302,
+      max_players: 64,
+      current_players: 10,
+      restart_count: 0,
+      auto_restart: true,
+      created_at: "2026-01-01T00:00:00Z",
+    };
+    vi.mocked(apiClient.get).mockResolvedValueOnce({
+      data: { success: true, data: mockServer },
+    });
+
+    const { result } = renderHook(() => useServer(1), {
+      wrapper: createWrapper(),
+    });
+
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(result.current.data).toEqual(mockServer);
+    expect(apiClient.get).toHaveBeenCalledWith("/api/servers/1");
+  });
+
+  it("should not fetch when serverId is 0", () => {
+    renderHook(() => useServer(0), { wrapper: createWrapper() });
+    expect(apiClient.get).not.toHaveBeenCalled();
+  });
+});
+
+describe("useStartServer", () => {
+  beforeEach(() => {
+    vi.mocked(apiClient.post).mockReset();
+  });
+
+  it("should call start endpoint", async () => {
+    vi.mocked(apiClient.post).mockResolvedValueOnce({ data: { success: true } });
+
+    const { result } = renderHook(() => useStartServer(), {
+      wrapper: createWrapper(),
+    });
+
+    result.current.mutate(1);
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(apiClient.post).toHaveBeenCalledWith("/api/servers/1/start");
+  });
+});
+
+describe("useStopServer", () => {
+  beforeEach(() => {
+    vi.mocked(apiClient.post).mockReset();
+  });
+
+  it("should call stop endpoint", async () => {
+    vi.mocked(apiClient.post).mockResolvedValueOnce({ data: { success: true } });
+
+    const { result } = renderHook(() => useStopServer(), {
+      wrapper: createWrapper(),
+    });
+
+    result.current.mutate({ serverId: 1 });
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(apiClient.post).toHaveBeenCalledWith("/api/servers/1/stop", {
+      force: undefined,
+    });
+  });
+
+  it("should pass force flag", async () => {
+    vi.mocked(apiClient.post).mockResolvedValueOnce({ data: { success: true } });
+
+    const { result } = renderHook(() => useStopServer(), {
+      wrapper: createWrapper(),
+    });
+
+    result.current.mutate({ serverId: 1, force: true });
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(apiClient.post).toHaveBeenCalledWith("/api/servers/1/stop", {
+      force: true,
+    });
+  });
+});
+
+describe("useRestartServer", () => {
+  beforeEach(() => {
+    vi.mocked(apiClient.post).mockReset();
+  });
+
+  it("should call restart endpoint", async () => {
+    vi.mocked(apiClient.post).mockResolvedValueOnce({ data: { success: true } });
+
+    const { result } = renderHook(() => useRestartServer(), {
+      wrapper: createWrapper(),
+    });
+
+    result.current.mutate(1);
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(apiClient.post).toHaveBeenCalledWith("/api/servers/1/restart");
+  });
+});
+
+describe("useCreateServer", () => {
+  beforeEach(() => {
+    vi.mocked(apiClient.post).mockReset();
+  });
+
+  it("should call create endpoint", async () => {
+    vi.mocked(apiClient.post).mockResolvedValueOnce({ data: { success: true } });
+
+    const { result } = renderHook(() => useCreateServer(), {
+      wrapper: createWrapper(),
+    });
+
+    result.current.mutate({ name: "New Server" });
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(apiClient.post).toHaveBeenCalledWith("/api/servers", {
+      name: "New Server",
+    });
+  });
+});
+
+describe("useDeleteServer", () => {
+  beforeEach(() => {
+    vi.mocked(apiClient.delete).mockReset();
+  });
+
+  it("should call delete endpoint", async () => {
+    vi.mocked(apiClient.delete).mockResolvedValueOnce({ data: { success: true } });
+
+    const { result } = renderHook(() => useDeleteServer(), {
+      wrapper: createWrapper(),
+    });
+
+    result.current.mutate(1);
+    await waitFor(() => expect(result.current.isSuccess).toBe(true));
+    expect(apiClient.delete).toHaveBeenCalledWith("/api/servers/1");
+  });
+});

frontend/src/__tests__/useWebSocket.test.tsx

@@ -0,0 +1,131 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { renderHook, act } from "@testing-library/react";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import type { ReactNode } from "react";
+
+import { useWebSocket } from "@/hooks/useWebSocket";
+import { useAuthStore } from "@/store/auth.store";
+
+vi.mock("@/store/auth.store", () => ({
+  useAuthStore: vi.fn(),
+}));
+
+const mockInvalidateQueries = vi.fn();
+vi.mock("@tanstack/react-query", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("@tanstack/react-query")>();
+  return {
+    ...actual,
+    useQueryClient: () => ({
+      invalidateQueries: mockInvalidateQueries,
+    }),
+  };
+});
+
+function createWrapper() {
+  const queryClient = new QueryClient();
+  return function Wrapper({ children }: { children: ReactNode }) {
+    return (
+      <QueryClientProvider client={queryClient}>
+        {children}
+      </QueryClientProvider>
+    );
+  };
+}
+
+describe("useWebSocket", () => {
+  let mockWsInstance: {
+    close: ReturnType<typeof vi.fn>;
+    onopen: ((ev: Event) => void) | null;
+    onmessage: ((ev: MessageEvent) => void) | null;
+    onclose: ((ev: CloseEvent) => void) | null;
+    onerror: ((ev: Event) => void) | null;
+  };
+
+  let MockWebSocket: ReturnType<typeof vi.fn>;
+
+  beforeEach(() => {
+    vi.useFakeTimers();
+    localStorage.clear();
+    mockInvalidateQueries.mockClear();
+
+    const handlers = {
+      onopen: null as ((ev: Event) => void) | null,
+      onmessage: null as ((ev: MessageEvent) => void) | null,
+      onclose: null as ((ev: CloseEvent) => void) | null,
+      onerror: null as ((ev: Event) => void) | null,
+    };
+
+    mockWsInstance = {
+      close: vi.fn(),
+      get onopen() { return handlers.onopen; },
+      set onopen(v) { handlers.onopen = v; },
+      get onmessage() { return handlers.onmessage; },
+      set onmessage(v) { handlers.onmessage = v; },
+      get onclose() { return handlers.onclose; },
+      set onclose(v) { handlers.onclose = v; },
+      get onerror() { return handlers.onerror; },
+      set onerror(v) { handlers.onerror = v; },
+    };
+
+    MockWebSocket = vi.fn(function (this: typeof mockWsInstance, _url: string) {
+      return mockWsInstance;
+    });
+
+    vi.stubGlobal("WebSocket", MockWebSocket);
+
+    vi.mocked(useAuthStore).mockReturnValue({
+      token: "test-token",
+    } as unknown as ReturnType<typeof useAuthStore>);
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+    vi.restoreAllMocks();
+  });
+
+  it("should not connect when no token exists", () => {
+    vi.mocked(useAuthStore).mockReturnValue({
+      token: null,
+    } as unknown as ReturnType<typeof useAuthStore>);
+
+    renderHook(() => useWebSocket(), { wrapper: createWrapper() });
+    expect(MockWebSocket).not.toHaveBeenCalled();
+  });
+
+  it("should create WebSocket connection when token exists", () => {
+    renderHook(() => useWebSocket(), { wrapper: createWrapper() });
+    expect(MockWebSocket).toHaveBeenCalled();
+  });
+
+  it("should include token in WebSocket URL", () => {
+    renderHook(() => useWebSocket(), { wrapper: createWrapper() });
+    const calledUrl = MockWebSocket.mock.calls[0][0] as string;
+    expect(calledUrl).toContain("token=test-token");
+  });
+
+  it("should invalidate queries on server_status event", () => {
+    renderHook(() => useWebSocket(), { wrapper: createWrapper() });
+
+    act(() => {
+      if (mockWsInstance.onmessage) {
+        mockWsInstance.onmessage({
+          data: JSON.stringify({
+            type: "server_status",
+            server_id: 1,
+            data: { status: "running" },
+          }),
+        } as unknown as MessageEvent);
+      }
+    });
+
+    expect(mockInvalidateQueries).toHaveBeenCalled();
+  });
+
+  it("should close WebSocket on unmount", () => {
+    const { unmount } = renderHook(() => useWebSocket(), {
+      wrapper: createWrapper(),
+    });
+    unmount();
+    expect(mockWsInstance.close).toHaveBeenCalled();
+  });
+});

frontend/src/assets/react.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="35.93" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 228"><path fill="#00D8FF" d="M210.483 73.824a171.49 171.49 0 0 0-8.24-2.597c.465-1.9.893-3.777 1.273-5.621c6.238-30.281 2.16-54.676-11.769-62.708c-13.355-7.7-35.196.329-57.254 19.526a171.23 171.23 0 0 0-6.375 5.848a155.866 155.866 0 0 0-4.241-3.917C100.759 3.829 77.587-4.822 63.673 3.233C50.33 10.957 46.379 33.89 51.995 62.588a170.974 170.974 0 0 0 1.892 8.48c-3.28.932-6.445 1.924-9.474 2.98C17.309 83.498 0 98.307 0 113.668c0 15.865 18.582 31.778 46.812 41.427a145.52 145.52 0 0 0 6.921 2.165a167.467 167.467 0 0 0-2.01 9.138c-5.354 28.2-1.173 50.591 12.134 58.266c13.744 7.926 36.812-.22 59.273-19.855a145.567 145.567 0 0 0 5.342-4.923a168.064 168.064 0 0 0 6.92 6.314c21.758 18.722 43.246 26.282 56.54 18.586c13.731-7.949 18.194-32.003 12.4-61.268a145.016 145.016 0 0 0-1.535-6.842c1.62-.48 3.21-.974 4.76-1.488c29.348-9.723 48.443-25.443 48.443-41.52c0-15.417-17.868-30.326-45.517-39.844Zm-6.365 70.984c-1.4.463-2.836.91-4.3 1.345c-3.24-10.257-7.612-21.163-12.963-32.432c5.106-11 9.31-21.767 12.459-31.957c2.619.758 5.16 1.557 7.61 2.4c23.69 8.156 38.14 20.213 38.14 29.504c0 9.896-15.606 22.743-40.946 31.14Zm-10.514 20.834c2.562 12.94 2.927 24.64 1.23 33.787c-1.524 8.219-4.59 13.698-8.382 15.893c-8.067 4.67-25.32-1.4-43.927-17.412a156.726 156.726 0 0 1-6.437-5.87c7.214-7.889 14.423-17.06 21.459-27.246c12.376-1.098 24.068-2.894 34.671-5.345a134.17 134.17 0 0 1 1.386 6.193ZM87.276 214.515c-7.882 2.783-14.16 2.863-17.955.675c-8.075-4.657-11.432-22.636-6.853-46.752a156.923 156.923 0 0 1 1.869-8.499c10.486 2.32 22.093 3.988 34.498 4.994c7.084 9.967 14.501 19.128 21.976 27.15a134.668 134.668 0 0 1-4.877 4.492c-9.933 8.682-19.886 14.842-28.658 17.94ZM50.35 144.747c-12.483-4.267-22.792-9.812-29.858-15.863c-6.35-5.437-9.555-10.836-9.555-15.216c0-9.322 13.897-21.212 37.076-29.293c2.813-.98 5.757-1.905 8.812-2.773c3.204 10.42 7.406 21.315 12.477 32.332c-5.137 11.18-9.399 22.249-12.634 32.792a134.718 134.718 0 0 1-6.318-1.979Zm12.378-84.26c-4.811-24.587-1.616-43.134 6.425-47.789c8.564-4.958 27.502 2.111 47.463 19.835a144.318 144.318 0 0 1 3.841 3.545c-7.438 7.987-14.787 17.08-21.808 26.988c-12.04 1.116-23.565 2.908-34.161 5.309a160.342 160.342 0 0 1-1.76-7.887Zm110.427 27.268a347.8 347.8 0 0 0-7.785-12.803c8.168 1.033 15.994 2.404 23.343 4.08c-2.206 7.072-4.956 14.465-8.193 22.045a381.151 381.151 0 0 0-7.365-13.322Zm-45.032-43.861c5.044 5.465 10.096 11.566 15.065 18.186a322.04 322.04 0 0 0-30.257-.006c4.974-6.559 10.069-12.652 15.192-18.18ZM82.802 87.83a323.167 323.167 0 0 0-7.227 13.238c-3.184-7.553-5.909-14.98-8.134-22.152c7.304-1.634 15.093-2.97 23.209-3.984a321.524 321.524 0 0 0-7.848 12.897Zm8.081 65.352c-8.385-.936-16.291-2.203-23.593-3.793c2.26-7.3 5.045-14.885 8.298-22.6a321.187 321.187 0 0 0 7.257 13.246c2.594 4.48 5.28 8.868 8.038 13.147Zm37.542 31.03c-5.184-5.592-10.354-11.779-15.403-18.433c4.902.192 9.899.29 14.978.29c5.218 0 10.376-.117 15.453-.343c-4.985 6.774-10.018 12.97-15.028 18.486Zm52.198-57.817c3.422 7.8 6.306 15.345 8.596 22.52c-7.422 1.694-15.436 3.058-23.88 4.071a382.417 382.417 0 0 0 7.859-13.026a347.403 347.403 0 0 0 7.425-13.565Zm-16.898 8.101a358.557 358.557 0 0 1-12.281 19.815a329.4 329.4 0 0 1-23.444.823c-7.967 0-15.716-.248-23.178-.732a310.202 310.202 0 0 1-12.513-19.846h.001a307.41 307.41 0 0 1-10.923-20.627a310.278 310.278 0 0 1 10.89-20.637l-.001.001a307.318 307.318 0 0 1 12.413-19.761c7.613-.576 15.42-.876 23.31-.876H128c7.926 0 15.743.303 23.354.883a329.357 329.357 0 0 1 12.335 19.695a358.489 358.489 0 0 1 11.036 20.54a329.472 329.472 0 0 1-11 20.722Zm22.56-122.124c8.572 4.944 11.906 24.881 6.52 51.026c-.344 1.668-.73 3.367-1.15 5.09c-10.622-2.452-22.155-4.275-34.23-5.408c-7.034-10.017-14.323-19.124-21.64-27.008a160.789 160.789 0 0 1 5.888-5.4c18.9-16.447 36.564-22.941 44.612-18.3ZM128 90.808c12.625 0 22.86 10.235 22.86 22.86s-10.235 22.86-22.86 22.86s-22.86-10.235-22.86-22.86s10.235-22.86 22.86-22.86Z"></path></svg>

frontend/src/components/layout/Sidebar.tsx

@@ -0,0 +1,74 @@
+import { Link, useParams } from "react-router-dom";
+import { Settings, LayoutDashboard } from "lucide-react";
+import clsx from "clsx";
+
+import { useServers } from "@/hooks/useServers";
+import { StatusLed } from "@/components/ui/StatusLed";
+
+export function Sidebar() {
+  const { data: servers, isLoading } = useServers();
+  const { serverId } = useParams();
+  const activeId = serverId ? parseInt(serverId) : null;
+
+  return (
+    <nav className="w-64 h-screen bg-surface-base border-r border-surface-raised flex flex-col">
+      <div className="px-6 py-5 border-b border-surface-raised">
+        <h1 className="text-text-primary font-bold text-lg tracking-tight">
+          <span className="text-accent">Languard</span>
+          <span className="text-text-secondary font-normal text-sm ml-2">
+            Server Manager
+          </span>
+        </h1>
+      </div>
+
+      <div className="px-3 py-4 border-b border-surface-raised">
+        <Link
+          to="/"
+          className="flex items-center gap-2 px-3 py-2 rounded-lg text-text-secondary
+                     hover:text-text-primary hover:bg-surface-overlay transition-colors"
+        >
+          <LayoutDashboard size={16} />
+          <span className="text-sm">Dashboard</span>
+        </Link>
+      </div>
+
+      <div className="flex-1 overflow-y-auto px-3 py-3">
+        <p className="text-text-muted text-xs uppercase tracking-widest px-3 mb-2">
+          Servers
+        </p>
+
+        {isLoading && (
+          <div className="text-text-muted text-sm px-3">Loading...</div>
+        )}
+
+        {servers?.map((server) => (
+          <Link
+            key={server.id}
+            to={`/servers/${server.id}`}
+            className={clsx(
+              "flex items-center gap-3 px-3 py-2.5 rounded-lg transition-colors mb-1",
+              activeId === server.id
+                ? "bg-surface-overlay text-text-primary shadow-neu-recessed"
+                : "text-text-secondary hover:text-text-primary hover:bg-surface-overlay",
+            )}
+          >
+            <StatusLed status={server.status} size="sm" />
+            <span className="text-sm font-medium truncate flex-1">{server.name}</span>
+            <span className="text-xs text-text-muted uppercase">{server.game_type}</span>
+          </Link>
+        ))}
+      </div>
+
+      <div className="px-3 py-4 border-t border-surface-raised">
+        <Link
+          to="/settings"
+          className="flex items-center gap-2 px-3 py-2 rounded-lg text-text-secondary
+                     hover:text-text-primary hover:bg-surface-overlay transition-colors"
+        >
+          <Settings size={16} />
+          <span className="text-sm">Settings</span>
+        </Link>
+      </div>
+    </nav>
+  );
+}

frontend/src/components/servers/ServerCard.tsx

@@ -0,0 +1,113 @@
+import { Play, Square, RotateCcw } from "lucide-react";
+
+import type { Server } from "@/hooks/useServers";
+import { useStartServer, useStopServer, useRestartServer } from "@/hooks/useServers";
+import { StatusLed } from "@/components/ui/StatusLed";
+import { useUIStore } from "@/store/ui.store";
+
+interface ServerCardProps {
+  server: Server;
+}
+
+export function ServerCard({ server }: ServerCardProps) {
+  const addNotification = useUIStore((s) => s.addNotification);
+  const startServer = useStartServer();
+  const stopServer = useStopServer();
+  const restartServer = useRestartServer();
+
+  const isRunning = server.status === "running";
+  const isBusy = ["starting", "restarting"].includes(server.status);
+
+  const handleStart = async () => {
+    try {
+      await startServer.mutateAsync(server.id);
+      addNotification({ type: "success", message: `${server.name} starting...` });
+    } catch {
+      addNotification({ type: "error", message: `Failed to start ${server.name}` });
+    }
+  };
+
+  const handleStop = async () => {
+    try {
+      await stopServer.mutateAsync({ serverId: server.id });
+      addNotification({ type: "info", message: `${server.name} stopping...` });
+    } catch {
+      addNotification({ type: "error", message: `Failed to stop ${server.name}` });
+    }
+  };
+
+  const handleRestart = async () => {
+    try {
+      await restartServer.mutateAsync(server.id);
+      addNotification({ type: "info", message: `${server.name} restarting...` });
+    } catch {
+      addNotification({ type: "error", message: `Failed to restart ${server.name}` });
+    }
+  };
+
+  return (
+    <div className="neu-card p-5 flex flex-col gap-4">
+      <div className="flex items-center justify-between">
+        <div className="flex items-center gap-2.5">
+          <StatusLed status={server.status} />
+          <h2 className="text-text-primary font-semibold truncate">{server.name}</h2>
+        </div>
+        <span className="text-xs text-text-muted uppercase tracking-wider bg-surface-recessed
+                         px-2 py-1 rounded-md">
+          {server.game_type}
+        </span>
+      </div>
+
+      <div className="grid grid-cols-3 gap-3">
+        <StatItem label="Players" value={`${server.current_players}/${server.max_players}`} />
+        <StatItem label="Port" value={String(server.port)} />
+        <StatItem label="Restarts" value={String(server.restart_count)} />
+      </div>
+
+      <div className="flex gap-2 mt-1">
+        {!isRunning && !isBusy && (
+          <button
+            onClick={(e) => { e.preventDefault(); e.stopPropagation(); handleStart(); }}
+            disabled={startServer.isPending}
+            className="btn-primary flex items-center gap-1.5 text-sm flex-1 justify-center"
+            aria-label={`Start ${server.name}`}
+          >
+            <Play size={14} />
+            Start
+          </button>
+        )}
+
+        {(isRunning || isBusy) && (
+          <>
+            <button
+              onClick={(e) => { e.preventDefault(); e.stopPropagation(); handleStop(); }}
+              disabled={stopServer.isPending || isBusy}
+              className="btn-danger flex items-center gap-1.5 text-sm flex-1 justify-center"
+              aria-label={`Stop ${server.name}`}
+            >
+              <Square size={14} />
+              Stop
+            </button>
+            <button
+              onClick={(e) => { e.preventDefault(); e.stopPropagation(); handleRestart(); }}
+              disabled={restartServer.isPending || isBusy}
+              className="btn-ghost flex items-center gap-1.5 text-sm"
+              aria-label={`Restart ${server.name}`}
+            >
+              <RotateCcw size={14} />
+            </button>
+          </>
+        )}
+      </div>
+    </div>
+  );
+}
+
+function StatItem({ label, value }: { label: string; value: string }) {
+  return (
+    <div className="bg-surface-recessed rounded-lg shadow-neu-recessed px-3 py-2">
+      <p className="text-text-muted text-xs mb-0.5">{label}</p>
+      <p className="text-text-primary font-mono text-sm font-medium">{value}</p>
+    </div>
+  );
+}

frontend/src/components/ui/StatusLed.tsx

@@ -0,0 +1,39 @@
+import clsx from "clsx";
+
+type Status = "running" | "stopped" | "crashed" | "starting" | "restarting";
+
+interface StatusLedProps {
+  status: Status;
+  showLabel?: boolean;
+  size?: "sm" | "md";
+}
+
+const STATUS_LABELS: Record<Status, string> = {
+  running: "Running",
+  stopped: "Stopped",
+  crashed: "Crashed",
+  starting: "Starting",
+  restarting: "Restarting",
+};
+
+export function StatusLed({ status, showLabel = false, size = "md" }: StatusLedProps) {
+  const dotSize = size === "sm" ? "w-1.5 h-1.5" : "w-2 h-2";
+
+  return (
+    <span className="inline-flex items-center gap-1.5">
+      <span
+        className={clsx(
+          "inline-block rounded-full shrink-0",
+          dotSize,
+          `status-led-${status}`,
+        )}
+        aria-hidden="true"
+      />
+      {showLabel && (
+        <span className="text-text-secondary text-sm font-medium capitalize">
+          {STATUS_LABELS[status]}
+        </span>
+      )}
+    </span>
+  );
+}

frontend/src/hooks/useServers.ts

@@ -0,0 +1,95 @@
+import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
+import { apiClient } from "@/lib/api";
+
+export interface Server {
+  id: number;
+  name: string;
+  game_type: string;
+  status: "stopped" | "running" | "starting" | "restarting" | "crashed";
+  port: number;
+  max_players: number;
+  current_players: number;
+  restart_count: number;
+  auto_restart: boolean;
+  created_at: string;
+}
+
+export function useServers() {
+  return useQuery({
+    queryKey: ["servers"],
+    queryFn: async () => {
+      const res = await apiClient.get<{ success: boolean; data: Server[] }>("/api/servers");
+      return res.data.data;
+    },
+    refetchInterval: 30_000,
+  });
+}
+
+export function useServer(serverId: number) {
+  return useQuery({
+    queryKey: ["servers", serverId],
+    queryFn: async () => {
+      const res = await apiClient.get<{ success: boolean; data: Server }>(
+        `/api/servers/${serverId}`,
+      );
+      return res.data.data;
+    },
+    enabled: serverId > 0,
+  });
+}
+
+export function useStartServer() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (serverId: number) =>
+      apiClient.post(`/api/servers/${serverId}/start`),
+    onSuccess: (_, serverId) => {
+      queryClient.invalidateQueries({ queryKey: ["servers", serverId] });
+      queryClient.invalidateQueries({ queryKey: ["servers"] });
+    },
+  });
+}
+
+export function useStopServer() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: ({ serverId, force }: { serverId: number; force?: boolean }) =>
+      apiClient.post(`/api/servers/${serverId}/stop`, { force }),
+    onSuccess: (_, { serverId }) => {
+      queryClient.invalidateQueries({ queryKey: ["servers", serverId] });
+      queryClient.invalidateQueries({ queryKey: ["servers"] });
+    },
+  });
+}
+
+export function useRestartServer() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (serverId: number) =>
+      apiClient.post(`/api/servers/${serverId}/restart`),
+    onSuccess: (_, serverId) => {
+      queryClient.invalidateQueries({ queryKey: ["servers", serverId] });
+    },
+  });
+}
+
+export function useCreateServer() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (data: Partial<Server>) => apiClient.post("/api/servers", data),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["servers"] });
+    },
+  });
+}
+
+export function useDeleteServer() {
+  const queryClient = useQueryClient();
+  return useMutation({
+    mutationFn: (serverId: number) =>
+      apiClient.delete(`/api/servers/${serverId}`),
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["servers"] });
+    },
+  });
+}

frontend/src/hooks/useWebSocket.ts

@@ -0,0 +1,97 @@
+import { useEffect, useRef, useCallback } from "react";
+import { useQueryClient } from "@tanstack/react-query";
+import { useAuthStore } from "@/store/auth.store";
+
+const WS_BASE = import.meta.env.VITE_WS_URL ?? "ws://localhost:8000";
+const RECONNECT_BASE_MS = 2000;
+const RECONNECT_MAX_MS = 30000;
+
+interface WebSocketEvent {
+  type: string;
+  server_id: number | null;
+  data: unknown;
+}
+
+export function useWebSocket(serverIds?: number[]) {
+  const queryClient = useQueryClient();
+  const { token } = useAuthStore();
+  const wsRef = useRef<WebSocket | null>(null);
+  const reconnectTimeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const backoffRef = useRef(RECONNECT_BASE_MS);
+  const unmountedRef = useRef(false);
+
+  const handleEvent = useCallback(
+    (event: WebSocketEvent) => {
+      const { type, server_id } = event;
+
+      switch (type) {
+        case "server_status":
+          queryClient.invalidateQueries({ queryKey: ["servers", server_id] });
+          queryClient.invalidateQueries({ queryKey: ["servers"] });
+          break;
+        case "metrics":
+          queryClient.invalidateQueries({ queryKey: ["metrics", server_id] });
+          break;
+        case "log":
+          queryClient.invalidateQueries({ queryKey: ["logs", server_id] });
+          break;
+        case "players":
+          queryClient.invalidateQueries({ queryKey: ["players", server_id] });
+          break;
+      }
+    },
+    [queryClient],
+  );
+
+  const connect = useCallback(() => {
+    if (!token || unmountedRef.current) return;
+
+    const params = new URLSearchParams({ token });
+    if (serverIds) {
+      serverIds.forEach((id) => params.append("server_id", String(id)));
+    }
+
+    const url = `${WS_BASE}/ws?${params.toString()}`;
+    const ws = new WebSocket(url);
+    wsRef.current = ws;
+
+    ws.onopen = () => {
+      backoffRef.current = RECONNECT_BASE_MS;
+    };
+
+    ws.onmessage = (e) => {
+      try {
+        const event: WebSocketEvent = JSON.parse(e.data);
+        handleEvent(event);
+      } catch {
+        // Ignore unparseable messages
+      }
+    };
+
+    ws.onclose = (e) => {
+      if (unmountedRef.current) return;
+      if (e.code === 4001) return;
+      reconnectTimeoutRef.current = setTimeout(() => {
+        backoffRef.current = Math.min(backoffRef.current * 2, RECONNECT_MAX_MS);
+        connect();
+      }, backoffRef.current);
+    };
+
+    ws.onerror = () => {
+      ws.close();
+    };
+  }, [token, serverIds, handleEvent]);
+
+  useEffect(() => {
+    unmountedRef.current = false;
+    connect();
+
+    return () => {
+      unmountedRef.current = true;
+      if (reconnectTimeoutRef.current) {
+        clearTimeout(reconnectTimeoutRef.current);
+      }
+      wsRef.current?.close();
+    };
+  }, [connect]);
+}

frontend/src/index.css

@@ -0,0 +1,79 @@
+@import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&family=JetBrains+Mono:wght@400;500&display=swap');
+
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+
+@layer base {
+  html {
+    background-color: #1a1a2e;
+    color: #e2e8f0;
+    font-family: "Inter", system-ui, sans-serif;
+    -webkit-font-smoothing: antialiased;
+  }
+
+  * {
+    box-sizing: border-box;
+  }
+
+  ::-webkit-scrollbar {
+    width: 6px;
+    height: 6px;
+  }
+
+  ::-webkit-scrollbar-track {
+    background: #16162a;
+  }
+
+  ::-webkit-scrollbar-thumb {
+    background: #475569;
+    border-radius: 3px;
+  }
+
+  ::-webkit-scrollbar-thumb:hover {
+    background: #64748b;
+  }
+}
+
+@layer components {
+  .neu-card {
+    @apply bg-surface-raised rounded-neu shadow-neu-raised;
+  }
+
+  .neu-input {
+    @apply bg-surface-recessed rounded-lg shadow-neu-recessed
+           border border-surface-raised text-text-primary
+           placeholder-text-muted px-3 py-2
+           focus:outline-none focus:border-accent focus:shadow-glow-amber
+           transition-all duration-200;
+  }
+
+  .btn-primary {
+    @apply bg-accent text-text-inverse font-semibold px-4 py-2 rounded-lg
+           shadow-neu-raised hover:bg-accent-bright hover:shadow-glow-amber
+           active:shadow-neu-recessed active:translate-y-px
+           transition-all duration-150 cursor-pointer;
+  }
+
+  .btn-ghost {
+    @apply text-text-secondary hover:text-text-primary px-3 py-2 rounded-lg
+           hover:bg-surface-overlay transition-colors duration-150 cursor-pointer;
+  }
+
+  .btn-danger {
+    @apply bg-status-crashed text-white font-semibold px-4 py-2 rounded-lg
+           shadow-neu-raised hover:opacity-90 hover:shadow-glow-red
+           active:shadow-neu-recessed active:translate-y-px
+           transition-all duration-150 cursor-pointer;
+  }
+
+  .status-led {
+    @apply inline-block w-2 h-2 rounded-full;
+  }
+
+  .status-led-running  { @apply bg-status-running  shadow-glow-green animate-glow-pulse; }
+  .status-led-stopped  { @apply bg-status-stopped  shadow-glow-gray; }
+  .status-led-crashed  { @apply bg-status-crashed  shadow-glow-red  animate-pulse-slow; }
+  .status-led-starting { @apply bg-status-starting shadow-glow-amber animate-pulse; }
+  .status-led-restarting { @apply bg-status-restarting shadow-glow-blue animate-pulse; }
+}

frontend/src/lib/api.ts

@@ -0,0 +1,34 @@
+import axios from "axios";
+
+const API_BASE = import.meta.env.VITE_API_URL ?? "http://localhost:8000";
+
+export const apiClient = axios.create({
+  baseURL: API_BASE,
+  headers: { "Content-Type": "application/json" },
+  timeout: 30_000,
+});
+
+apiClient.interceptors.request.use((config) => {
+  const token = localStorage.getItem("languard_token");
+  if (token) {
+    config.headers.Authorization = `Bearer ${token}`;
+  }
+  return config;
+});
+
+apiClient.interceptors.response.use(
+  (response) => response,
+  (error) => {
+    if (error.response?.status === 401) {
+      localStorage.removeItem("languard_token");
+      window.location.href = "/login";
+    }
+    return Promise.reject(error);
+  },
+);
+
+export type ApiResponse<T> = {
+  success: boolean;
+  data: T;
+  error?: string;
+};

frontend/src/main.tsx

@@ -0,0 +1,10 @@
+import { StrictMode } from 'react'
+import { createRoot } from 'react-dom/client'
+import './index.css'
+import App from './App.tsx'
+
+createRoot(document.getElementById('root')!).render(
+  <StrictMode>
+    <App />
+  </StrictMode>,
+)

frontend/src/pages/DashboardPage.tsx

@@ -0,0 +1,63 @@
+import { Plus } from "lucide-react";
+import { Link } from "react-router-dom";
+
+import { useServers } from "@/hooks/useServers";
+import { useWebSocket } from "@/hooks/useWebSocket";
+import { ServerCard } from "@/components/servers/ServerCard";
+
+export function DashboardPage() {
+  const { data: servers, isLoading, isError } = useServers();
+
+  useWebSocket();
+
+  if (isLoading) {
+    return (
+      <div className="flex items-center justify-center h-64">
+        <div className="text-text-secondary">Loading servers...</div>
+      </div>
+    );
+  }
+
+  if (isError) {
+    return (
+      <div className="flex items-center justify-center h-64">
+        <div className="text-status-crashed">Failed to load servers</div>
+      </div>
+    );
+  }
+
+  return (
+    <div className="p-6">
+      <div className="flex items-center justify-between mb-6">
+        <div>
+          <h1 className="text-text-primary font-bold text-xl">Dashboard</h1>
+          <p className="text-text-secondary text-sm mt-0.5">
+            {servers?.length ?? 0} server{servers?.length !== 1 ? "s" : ""} configured
+          </p>
+        </div>
+        <Link to="/servers/new" className="btn-primary flex items-center gap-1.5 text-sm">
+          <Plus size={14} />
+          Add Server
+        </Link>
+      </div>
+
+      {servers?.length === 0 ? (
+        <div className="neu-card p-12 text-center">
+          <p className="text-text-secondary">No servers configured yet.</p>
+          <Link to="/servers/new" className="btn-primary mt-4 inline-flex items-center gap-2">
+            <Plus size={14} />
+            Add your first server
+          </Link>
+        </div>
+      ) : (
+        <div className="grid grid-cols-1 md:grid-cols-2 xl:grid-cols-3 gap-4">
+          {servers?.map((server) => (
+            <Link key={server.id} to={`/servers/${server.id}`}>
+              <ServerCard server={server} />
+            </Link>
+          ))}
+        </div>
+      )}
+    </div>
+  );
+}

frontend/src/pages/LoginPage.tsx

@@ -0,0 +1,106 @@
+import { useState } from "react";
+import { useNavigate } from "react-router-dom";
+import { useForm } from "react-hook-form";
+import { zodResolver } from "@hookform/resolvers/zod";
+import { z } from "zod";
+
+import { apiClient } from "@/lib/api";
+import { useAuthStore } from "@/store/auth.store";
+
+const loginSchema = z.object({
+  username: z.string().min(1, "Username is required"),
+  password: z.string().min(1, "Password is required"),
+});
+
+type LoginForm = z.infer<typeof loginSchema>;
+
+export function LoginPage() {
+  const navigate = useNavigate();
+  const setAuth = useAuthStore((s) => s.setAuth);
+  const [error, setError] = useState<string | null>(null);
+
+  const {
+    register,
+    handleSubmit,
+    formState: { errors, isSubmitting },
+  } = useForm<LoginForm>({ resolver: zodResolver(loginSchema) });
+
+  const onSubmit = async (data: LoginForm) => {
+    setError(null);
+    try {
+      const res = await apiClient.post<{
+        success: boolean;
+        data: { access_token: string; user: { id: number; username: string; role: "admin" | "viewer" } };
+      }>("/api/auth/login", data);
+
+      setAuth(res.data.data.access_token, res.data.data.user);
+      navigate("/");
+    } catch (err: unknown) {
+      const message =
+        (err as { response?: { data?: { detail?: string } } })?.response?.data?.detail ??
+        "Login failed";
+      setError(typeof message === "string" ? message : "Login failed");
+    }
+  };
+
+  return (
+    <div className="min-h-screen bg-surface-base flex items-center justify-center p-4">
+      <div className="neu-card p-8 w-full max-w-sm">
+        <div className="text-center mb-8">
+          <h1 className="text-2xl font-bold text-text-primary">
+            <span className="text-accent">Languard</span>
+          </h1>
+          <p className="text-text-secondary text-sm mt-1">Server Manager</p>
+        </div>
+
+        <form onSubmit={handleSubmit(onSubmit)} className="space-y-4">
+          <div>
+            <label className="block text-text-secondary text-sm mb-1.5" htmlFor="username">
+              Username
+            </label>
+            <input
+              id="username"
+              type="text"
+              autoComplete="username"
+              className="neu-input w-full"
+              {...register("username")}
+            />
+            {errors.username && (
+              <p className="text-status-crashed text-xs mt-1">{errors.username.message}</p>
+            )}
+          </div>
+
+          <div>
+            <label className="block text-text-secondary text-sm mb-1.5" htmlFor="password">
+              Password
+            </label>
+            <input
+              id="password"
+              type="password"
+              autoComplete="current-password"
+              className="neu-input w-full"
+              {...register("password")}
+            />
+            {errors.password && (
+              <p className="text-status-crashed text-xs mt-1">{errors.password.message}</p>
+            )}
+          </div>
+
+          {error && (
+            <div className="bg-surface-recessed border border-status-crashed rounded-lg px-3 py-2">
+              <p className="text-status-crashed text-sm">{error}</p>
+            </div>
+          )}
+
+          <button
+            type="submit"
+            disabled={isSubmitting}
+            className="btn-primary w-full mt-2"
+          >
+            {isSubmitting ? "Signing in..." : "Sign In"}
+          </button>
+        </form>
+      </div>
+    </div>
+  );
+}

frontend/src/store/auth.store.ts

@@ -0,0 +1,45 @@
+import { create } from "zustand";
+import { persist } from "zustand/middleware";
+
+interface User {
+  id: number;
+  username: string;
+  role: "admin" | "viewer";
+}
+
+interface AuthState {
+  token: string | null;
+  user: User | null;
+  isAuthenticated: boolean;
+  setAuth: (token: string, user: User) => void;
+  clearAuth: () => void;
+}
+
+export const useAuthStore = create<AuthState>()(
+  persist(
+    (set) => ({
+      token: null,
+      user: null,
+      isAuthenticated: false,
+
+      setAuth: (token, user) => {
+        localStorage.setItem("languard_token", token);
+        set({ token, user, isAuthenticated: true });
+      },
+
+      clearAuth: () => {
+        localStorage.removeItem("languard_token");
+        set({ token: null, user: null, isAuthenticated: false });
+      },
+    }),
+    {
+      name: "languard-auth",
+      partialize: (state) => ({ token: state.token, user: state.user }),
+      onRehydrateStorage: () => (state) => {
+        if (state?.token) {
+          state.isAuthenticated = true;
+        }
+      },
+    },
+  ),
+);

frontend/src/store/ui.store.ts

@@ -0,0 +1,40 @@
+import { create } from "zustand";
+
+interface Notification {
+  id: string;
+  type: "success" | "error" | "info" | "warning";
+  message: string;
+}
+
+interface UIState {
+  sidebarOpen: boolean;
+  activeServerId: number | null;
+  notifications: Notification[];
+  toggleSidebar: () => void;
+  setActiveServer: (id: number | null) => void;
+  addNotification: (notification: Omit<Notification, "id">) => void;
+  removeNotification: (id: string) => void;
+}
+
+export const useUIStore = create<UIState>((set, get) => ({
+  sidebarOpen: true,
+  activeServerId: null,
+  notifications: [],
+
+  toggleSidebar: () => set((s) => ({ sidebarOpen: !s.sidebarOpen })),
+
+  setActiveServer: (id) => set({ activeServerId: id }),
+
+  addNotification: (notification) => {
+    const id = Math.random().toString(36).slice(2);
+    set((s) => ({
+      notifications: [...s.notifications, { ...notification, id }],
+    }));
+    setTimeout(() => get().removeNotification(id), 5000);
+  },
+
+  removeNotification: (id) =>
+    set((s) => ({
+      notifications: s.notifications.filter((n) => n.id !== id),
+    })),
+}));

frontend/src/vite-env.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="vite/client" />
+
+interface ImportMetaEnv {
+  readonly VITE_API_URL: string;
+  readonly VITE_WS_URL: string;
+}
+
+interface ImportMeta {
+  readonly env: ImportMetaEnv;
+}