initial import server-manager

feat: improve manager recovery and expose server pid in dashboard
fix: prevent stopped servers from returning to running state
2026-07-22 00:12:44 +02:00 · 2026-07-21 20:45:40 +02:00 · 2026-07-21 19:38:11 +02:00 · 2026-07-21 19:29:06 +02:00 · 2026-07-21 14:49:09 +02:00 · 2026-07-20 21:54:36 +02:00
82 changed files with 4674 additions and 561 deletions
@@ -1,7 +1,12 @@
 node_modules/
 dist/
 build/
-.env
+
 *.log

-.vscode/
+.env
+
+*-state.json
+
+.vscode/
+.idea/
@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="de">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>Server Manager</title>
+  </head>
+  <body>
+    <div id="root"></div>
+    <script type="module" src="/src/main.tsx"></script>
+  </body>
+</html>
@@ -0,0 +1,23 @@
+{
+  "name": "server-manager-dashboard",
+  "private": true,
+  "version": "1.0.0",
+  "type": "module",
+  "scripts": {
+    "dev": "vite",
+    "build": "tsc -b && vite build",
+    "preview": "vite preview"
+  },
+  "dependencies": {
+    "@vitejs/plugin-react": "^4.3.4",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
+    "react-router-dom": "^6.28.1",
+    "vite": "^5.4.11"
+  },
+  "devDependencies": {
+    "@types/react": "^18.3.12",
+    "@types/react-dom": "^18.3.1",
+    "typescript": "^5.7.3"
+  }
+}
@@ -0,0 +1,38 @@
+export interface DashboardData {
+  managerStatus: string;
+  rabbitMqStatus: string;
+  wrapperCount: number;
+  onlineWrapperCount: number;
+  serverCount: number;
+  runningServerCount: number;
+  totalPlayers: number;
+  totalCapacity: number;
+  utilizationPercent: number;
+  desiredServers: number;
+  activeServers: number;
+}
+
+export interface Wrapper {
+  id: string; hostname: string; online: boolean; cpu: number; ram: number;
+  ramFree: number; lastHeartbeat: number; serverCount: number;
+}
+
+export interface Server {
+  id: string; name: string; status: string; wrapperId: string; port: number;
+  pid?: number; queryPort: number; players: number; maxPlayers: number; created: number;
+  startedAt?: number; emptySince?: number; alive?: boolean; started?: number;
+}
+
+async function request<T>(path: string): Promise<T> {
+  const response = await fetch(`/api${path}`);
+  if (!response.ok) throw new Error(`API request failed (${response.status})`);
+  return response.json() as Promise<T>;
+}
+
+export const api = {
+  dashboard: () => request<DashboardData>("/dashboard"),
+  wrappers: () => request<Wrapper[]>("/wrappers"),
+  wrapper: (id: string) => request<Wrapper & { servers: Server[] }>(`/wrappers/${encodeURIComponent(id)}`),
+  servers: () => request<Server[]>("/servers"),
+  server: (id: string) => request<Server>(`/servers/${encodeURIComponent(id)}`)
+};
@@ -0,0 +1,10 @@
+import { NavLink, Outlet } from "react-router-dom";
+
+export function Layout() {
+  return <main className="shell">
+    <header><NavLink to="/" className="brand">Server Manager</NavLink><nav>
+      <NavLink to="/">Dashboard</NavLink><NavLink to="/wrappers">Wrapper</NavLink><NavLink to="/servers">Server</NavLink>
+    </nav></header>
+    <Outlet />
+  </main>;
+}
@@ -0,0 +1,3 @@
+export function PageState({ error }: { error?: Error }) {
+  return <p className={error ? "error" : "loading"}>{error ? error.message : "Daten werden geladen …"}</p>;
+}
@@ -0,0 +1,6 @@
+export function StatusBadge({ status }: { status: string | boolean }) {
+  const label = typeof status === "boolean" ? (status ? "ONLINE" : "OFFLINE") : status;
+  const tone = ["RUNNING", "ONLINE", "CONNECTED"].includes(label) ? "good"
+    : ["STARTING", "STOPPING"].includes(label) ? "pending" : "bad";
+  return <span className={`status status--${tone}`}>{label}</span>;
+}
@@ -0,0 +1,17 @@
+import { StrictMode } from "react";
+import { createRoot } from "react-dom/client";
+import { createBrowserRouter, RouterProvider } from "react-router-dom";
+import { Layout } from "./components/Layout";
+import { Dashboard } from "./pages/Dashboard";
+import { ServerDetail } from "./pages/ServerDetail";
+import { Servers } from "./pages/Servers";
+import { WrapperDetail } from "./pages/WrapperDetail";
+import { Wrappers } from "./pages/Wrappers";
+import "./styles.css";
+
+const router = createBrowserRouter([{ path: "/", element: <Layout />, children: [
+  { index: true, element: <Dashboard /> }, { path: "wrappers", element: <Wrappers /> },
+  { path: "wrappers/:id", element: <WrapperDetail /> }, { path: "servers", element: <Servers /> },
+  { path: "servers/:id", element: <ServerDetail /> }
+] }]);
+createRoot(document.getElementById("root")!).render(<StrictMode><RouterProvider router={router} /></StrictMode>);
@@ -0,0 +1,13 @@
+import { useEffect, useState } from "react";
+import { api, DashboardData } from "../api/client";
+import { PageState } from "../components/PageState";
+import { StatusBadge } from "../components/StatusBadge";
+
+export function Dashboard() {
+  const [data, setData] = useState<DashboardData>(); const [error, setError] = useState<Error>();
+  useEffect(() => { api.dashboard().then(setData).catch(setError); }, []);
+  if (!data) return <PageState error={error} />;
+  return <><section className="title"><div><h1>Dashboard</h1><p>Aktueller Zustand des Managers</p></div><button onClick={() => location.reload()}>Aktualisieren</button></section>
+    <section className="cards"><article><small>Manager</small><StatusBadge status={data.managerStatus} /></article><article><small>RabbitMQ</small><StatusBadge status={data.rabbitMqStatus} /></article><article><small>Wrapper online</small><strong>{data.onlineWrapperCount} / {data.wrapperCount}</strong></article><article><small>Server laufend</small><strong>{data.runningServerCount} / {data.serverCount}</strong></article><article><small>Spieler / Kapazität</small><strong>{data.totalPlayers} / {data.totalCapacity}</strong></article><article><small>Auslastung</small><strong>{data.utilizationPercent}%</strong></article><article><small>Soll-Server</small><strong>{data.desiredServers}</strong></article><article><small>Aktive Server</small><strong>{data.activeServers}</strong></article></section>
+  </>;
+}
@@ -0,0 +1,31 @@
+import { useEffect, useState } from "react";
+import { Link, useParams } from "react-router-dom";
+import { api, Server } from "../api/client";
+import { PageState } from "../components/PageState";
+import { StatusBadge } from "../components/StatusBadge";
+
+const date = (value?: number) => value ? new Date(value).toLocaleString("de-DE") : "–";
+
+export function ServerDetail() {
+  const { id = "" } = useParams();
+  const [item, setItem] = useState<Server>();
+  const [error, setError] = useState<Error>();
+
+  useEffect(() => { api.server(id).then(setItem).catch(setError); }, [id]);
+
+  if (!item) return <PageState error={error} />;
+
+  return <>
+    <section className="title"><div><p><Link to="/servers">← Server</Link></p><h1>{item.name}</h1><StatusBadge status={item.status} /></div></section>
+    <section className="details">
+      <div><small>ID</small><span>{item.id}</span></div>
+      <div><small>Wrapper</small><span>{item.wrapperId}</span></div>
+      <div><small>PID</small><span>{item.pid ?? "–"}</span></div>
+      <div><small>Spieler / Kapazität</small><span>{item.players} / {item.maxPlayers}</span></div>
+      <div><small>Port / Query Port</small><span>{item.port} / {item.queryPort}</span></div>
+      <div><small>Erstellt</small><span>{date(item.created)}</span></div>
+      <div><small>Gestartet</small><span>{date(item.startedAt)}</span></div>
+      <div><small>Leer seit</small><span>{date(item.emptySince)}</span></div>
+    </section>
+  </>;
+}
@@ -0,0 +1,9 @@
+import { useEffect, useState } from "react";
+import { Link } from "react-router-dom";
+import { api, Server } from "../api/client";
+import { PageState } from "../components/PageState";
+import { StatusBadge } from "../components/StatusBadge";
+
+export function Servers() { const [items, setItems] = useState<Server[]>(); const [error, setError] = useState<Error>(); useEffect(() => { api.servers().then(setItems).catch(setError); }, []); if (!items) return <PageState error={error} />;
+ return <><section className="title"><div><h1>Server</h1><p>{items.length} registriert</p></div></section><section className="table-wrap"><table><thead><tr><th>ID</th><th>Name</th><th>Status</th><th>Spieler</th><th>Kapazität</th><th>Port</th><th>Query Port</th><th>Wrapper</th></tr></thead><tbody>{items.map(item => <tr key={item.id}><td><Link to={`/servers/${item.id}`}>{item.id}</Link></td><td>{item.name}</td><td><StatusBadge status={item.status} /></td><td>{item.players}</td><td>{item.maxPlayers}</td><td>{item.port}</td><td>{item.queryPort}</td><td>{item.wrapperId}</td></tr>)}</tbody></table></section></>;
+}
@@ -0,0 +1,11 @@
+import { useEffect, useState } from "react";
+import { Link, useParams } from "react-router-dom";
+import { api, Server, Wrapper } from "../api/client";
+import { PageState } from "../components/PageState";
+import { StatusBadge } from "../components/StatusBadge";
+
+export function WrapperDetail() {
+  const { id = "" } = useParams(); const [item, setItem] = useState<(Wrapper & { servers: Server[] })>(); const [error, setError] = useState<Error>();
+  useEffect(() => { api.wrapper(id).then(setItem).catch(setError); }, [id]); if (!item) return <PageState error={error} />;
+  return <><section className="title"><div><p><Link to="/wrappers">← Wrapper</Link></p><h1>{item.hostname}</h1><StatusBadge status={item.online} /></div></section><section className="details"><div><small>ID</small><span>{item.id}</span></div><div><small>CPU</small><span>{item.cpu}%</span></div><div><small>RAM frei / gesamt</small><span>{item.ramFree} / {item.ram}</span></div><div><small>Letzter Heartbeat</small><span>{item.lastHeartbeat ? new Date(item.lastHeartbeat).toLocaleString("de-DE") : "–"}</span></div></section><h2>Zugeordnete Server</h2><section className="table-wrap"><table><thead><tr><th>Name</th><th>Port</th><th>Spieler</th><th>Status</th></tr></thead><tbody>{item.servers.map(server => <tr key={server.id}><td><Link to={`/servers/${server.id}`}>{server.name}</Link></td><td>{server.port}</td><td>{server.players} / {server.maxPlayers}</td><td><StatusBadge status={server.alive ? "RUNNING" : "OFFLINE"} /></td></tr>)}</tbody></table></section></>;
+}
@@ -0,0 +1,9 @@
+import { useEffect, useState } from "react";
+import { Link } from "react-router-dom";
+import { api, Wrapper } from "../api/client";
+import { PageState } from "../components/PageState";
+import { StatusBadge } from "../components/StatusBadge";
+
+export function Wrappers() { const [items, setItems] = useState<Wrapper[]>(); const [error, setError] = useState<Error>(); useEffect(() => { api.wrappers().then(setItems).catch(setError); }, []); if (!items) return <PageState error={error} />;
+  return <><section className="title"><div><h1>Wrapper</h1><p>{items.length} registriert</p></div></section><section className="table-wrap"><table><thead><tr><th>ID</th><th>Hostname</th><th>Status</th><th>CPU</th><th>RAM frei / gesamt</th><th>Heartbeat</th><th>Server</th></tr></thead><tbody>{items.map(item => <tr key={item.id}><td><Link to={`/wrappers/${item.id}`}>{item.id}</Link></td><td>{item.hostname}</td><td><StatusBadge status={item.online} /></td><td>{item.cpu}%</td><td>{item.ramFree} / {item.ram}</td><td>{item.lastHeartbeat ? new Date(item.lastHeartbeat).toLocaleString("de-DE") : "–"}</td><td>{item.serverCount}</td></tr>)}</tbody></table></section></>;
+}
@@ -0,0 +1,8 @@
+:root { color: #e7edf6; background: #0e1521; font-family: Inter, ui-sans-serif, system-ui, sans-serif; }
+* { box-sizing: border-box; } body { margin: 0; } a { color: #a9ccff; text-decoration: none; } a:hover { text-decoration: underline; }
+.shell { max-width: 1240px; padding: 0 28px 48px; margin: auto; } header { min-height: 70px; display:flex; align-items:center; justify-content:space-between; border-bottom: 1px solid #263446; margin-bottom: 44px; } .brand { color:#fff; font-weight:700; font-size:18px; } nav { display:flex; gap:24px; } nav a { color:#91a2b8; padding:24px 0; } nav a.active { color:#fff; border-bottom:2px solid #58a6ff; }
+.title { display:flex; justify-content:space-between; align-items:center; margin-bottom:28px; } h1 { margin:0; font-size:28px; } h2 { margin:38px 0 14px; font-size:18px; } p { color:#91a2b8; margin:7px 0 0; } button { border:1px solid #3c6d9d; color:#dbeafe; background:#17395b; border-radius:6px; padding:9px 13px; cursor:pointer; }
+.cards { display:grid; grid-template-columns:repeat(4, minmax(0, 1fr)); gap:14px; } .cards article, .details > div { background:#151f2e; border:1px solid #263446; border-radius:8px; padding:18px; min-height:94px; display:flex; flex-direction:column; justify-content:space-between; gap:10px; } small { color:#91a2b8; font-size:12px; } strong { font-size:23px; }
+.status { display:inline-flex; width:max-content; align-items:center; gap:6px; border-radius:999px; padding:4px 9px; font-size:11px; font-weight:700; letter-spacing:.03em; } .status--good { color:#8ee6bb; background:#123c2c; } .status--pending { color:#ffd98a; background:#493718; } .status--bad { color:#ffabb0; background:#48232b; }
+.table-wrap { overflow-x:auto; border:1px solid #263446; border-radius:8px; background:#151f2e; } table { width:100%; border-collapse:collapse; min-width:750px; } th,td { padding:14px 16px; text-align:left; border-bottom:1px solid #263446; font-size:14px; } th { color:#91a2b8; font-size:11px; text-transform:uppercase; letter-spacing:.05em; } tbody tr:last-child td { border-bottom:0; } .details { display:grid; grid-template-columns:repeat(3, 1fr); gap:14px; } .details span { word-break:break-word; } .loading,.error { padding:20px; background:#151f2e; border-radius:8px; } .error { color:#ffabb0; }
+@media (max-width: 760px) { .shell { padding:0 16px 32px; } header { margin-bottom:28px; } .cards,.details { grid-template-columns:repeat(2, 1fr); } nav { gap:12px; } } @media (max-width: 440px) { .cards,.details { grid-template-columns:1fr; } }
@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "allowJs": false,
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "strict": true,
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx"
+  },
+  "include": ["src"],
+  "references": [{ "path": "./tsconfig.node.json" }]
+}
@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "skipLibCheck": true,
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "allowSyntheticDefaultImports": true
+  },
+  "include": ["vite.config.ts"]
+}
@@ -0,0 +1 @@
+{"root":["./src/main.tsx","./src/api/client.ts","./src/components/layout.tsx","./src/components/pagestate.tsx","./src/components/statusbadge.tsx","./src/pages/dashboard.tsx","./src/pages/serverdetail.tsx","./src/pages/servers.tsx","./src/pages/wrapperdetail.tsx","./src/pages/wrappers.tsx"],"version":"5.9.3"}
@@ -0,0 +1,2 @@
+declare const _default: import("vite").UserConfig;
+export default _default;
@@ -0,0 +1,10 @@
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+export default defineConfig({
+    plugins: [react()],
+    server: {
+        proxy: {
+            "/api": "http://localhost:3000"
+        }
+    }
+});
@@ -0,0 +1,11 @@
+import { defineConfig } from "vite";
+import react from "@vitejs/plugin-react";
+
+export default defineConfig({
+  plugins: [react()],
+  server: {
+    proxy: {
+      "/api": "http://localhost:3000"
+    }
+  }
+});
@@ -4,7 +4,8 @@
  "description": "",
  "main": "index.js",
  "scripts": {
-    "start": "ts-node src/index.ts"
+    "start": "ts-node src/index.ts",
+    "build": "tsc -p tsconfig.json"
  },
  "keywords": [],
  "author": "",
@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandService = void 0;
+const logger_1 = require("./logger");
+const logger = (0, logger_1.getLogger)("CommandService");
+class CommandService {
+    constructor(channel) {
+        this.channel = channel;
+    }
+    async send(queue, command) {
+        await this.channel.sendToQueue(queue, Buffer.from(JSON.stringify(command)));
+        logger.debug("Command sent", command);
+    }
+}
+exports.CommandService = CommandService;
@@ -1,5 +1,7 @@
 import * as amqp from "amqplib";
+import { getLogger } from "./logger";

+const logger = getLogger("CommandService");

 export class CommandService {

@@ -27,8 +29,8 @@ export class CommandService {
        );


-        console.log(
-            "Command gesendet:",
+        logger.debug(
+            "Command sent",
            command
        );

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QUERY_PORT_START = exports.GAME_PORT_START = exports.DEFAULT_DESIRED_SERVERS = exports.LIFECYCLE_CRASH_RETENTION = exports.LIFECYCLE_CRASH_TIMEOUT = exports.LIFECYCLE_SCALE_COOLDOWN = exports.LIFECYCLE_STARTUP_GRACE_PERIOD = exports.LIFECYCLE_SCALE_DOWN_THRESHOLD = exports.LIFECYCLE_MIN_UPTIME = exports.LIFECYCLE_EMPTY_TIMEOUT = exports.LIFECYCLE_CHECK_INTERVAL = exports.RABBITMQ_URL = void 0;
+exports.RABBITMQ_URL = "amqp://manager:gigi1337@192.168.1.74";
+// Lifecycle
+exports.LIFECYCLE_CHECK_INTERVAL = 10000; // Alle 10 Sekunden prüfen
+// Scale Down
+exports.LIFECYCLE_EMPTY_TIMEOUT = 300000; // 5 Minuten leer
+exports.LIFECYCLE_MIN_UPTIME = 600000; // 10 Minuten Mindestlaufzeit
+exports.LIFECYCLE_SCALE_DOWN_THRESHOLD = 0.30; // Unter 30% Gesamtauslastung darf abgebaut werden
+// Scale Up
+exports.LIFECYCLE_STARTUP_GRACE_PERIOD = 60000; // 1 Minute Schutz nach Start
+exports.LIFECYCLE_SCALE_COOLDOWN = 120000; // 2 Minuten zwischen Scale-Up Aktionen
+// Crash Detection
+exports.LIFECYCLE_CRASH_TIMEOUT = 120000; // 2 Minuten ohne Status -> Crash
+exports.LIFECYCLE_CRASH_RETENTION = 300000; // 5 Minuten sichtbar nach Crash
+// Default
+exports.DEFAULT_DESIRED_SERVERS = 1;
+// Ports
+exports.GAME_PORT_START = 7777;
+exports.QUERY_PORT_START = 27015;
@@ -0,0 +1,24 @@
+export const RABBITMQ_URL = "amqp://manager:gigi1337@192.168.1.74";
+
+// Lifecycle
+export const LIFECYCLE_CHECK_INTERVAL = 10000;          // Alle 10 Sekunden prüfen
+
+// Scale Down
+export const LIFECYCLE_EMPTY_TIMEOUT = 300000;          // 5 Minuten leer
+export const LIFECYCLE_MIN_UPTIME = 600000;             // 10 Minuten Mindestlaufzeit
+export const LIFECYCLE_SCALE_DOWN_THRESHOLD = 0.30;     // Unter 30% Gesamtauslastung darf abgebaut werden
+
+// Scale Up
+export const LIFECYCLE_STARTUP_GRACE_PERIOD = 60000;   // 1 Minute Schutz nach Start
+export const LIFECYCLE_SCALE_COOLDOWN = 120000;        // 2 Minuten zwischen Scale-Up Aktionen
+
+// Crash Detection
+export const LIFECYCLE_CRASH_TIMEOUT = 120000;          // 2 Minuten ohne Status -> Crash
+export const LIFECYCLE_CRASH_RETENTION = 300000;        // 5 Minuten sichtbar nach Crash
+
+// Default
+export const DEFAULT_DESIRED_SERVERS = 1;
+
+// Ports
+export const GAME_PORT_START = 7777;
+export const QUERY_PORT_START = 27015;
@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const rabbit_1 = require("./rabbit");
+const wrapperManager_1 = require("./wrapperManager");
+const wrapperRegistry_1 = require("./wrapperRegistry");
+const serverRegistry_1 = require("./serverRegistry");
+const serverManager_1 = require("./serverManager");
+const portManager_1 = require("./portManager");
+const serverStatusManager_1 = require("./serverStatusManager");
+const serverLifecycle_1 = require("./serverLifecycle");
+const logger_1 = require("./logger");
+const server_1 = require("./web/server");
+const logger = (0, logger_1.getLogger)("Index");
+const wrapperRegistry = new wrapperRegistry_1.WrapperRegistry();
+const serverRegistry = new serverRegistry_1.ServerRegistry();
+const portManager = new portManager_1.PortManager();
+async function main() {
+    const rabbit = new rabbit_1.Rabbit();
+    await rabbit.connect();
+    logger.info("RabbitMQ-Verbindung hergestellt");
+    await portManager.init();
+    logger.info("Persistenz initialisiert");
+    await wrapperRegistry.init();
+    logger.debug("WrapperRegistry initialisiert");
+    await serverRegistry.init();
+    logger.debug("ServerRegistry initialisiert");
+    const wrapperManager = new wrapperManager_1.WrapperManager(rabbit, wrapperRegistry, serverRegistry);
+    await wrapperManager.start();
+    logger.info("WrapperManager erfolgreich gestartet");
+    const serverManager = new serverManager_1.ServerManager(rabbit, wrapperRegistry, serverRegistry, portManager);
+    const lifecycle = new serverLifecycle_1.ServerLifecycle(serverRegistry, serverManager);
+    lifecycle.start();
+    logger.debug("ServerLifecycle gestartet");
+    const statusManager = new serverStatusManager_1.ServerStatusManager(rabbit, serverRegistry);
+    await statusManager.start();
+    const webServer = (0, server_1.createWebServer)({
+        wrapperRegistry,
+        serverRegistry,
+        lifecycle,
+        rabbitMqStatus: "connected",
+        managerStatus: "running"
+    }, 3000);
+    logger.info("Manager gestartet");
+    void webServer;
+}
+main();
@@ -1,4 +1,4 @@
-import { Rabbit } from "./rabbit";
+import { Rabbit } from "./rabbit";
 import { WrapperManager } from "./wrapperManager";
 import { WrapperRegistry } from "./wrapperRegistry";
 import { ServerRegistry } from "./serverRegistry";
@@ -6,6 +6,10 @@ import { ServerManager } from "./serverManager";
 import { PortManager } from "./portManager";
 import { ServerStatusManager } from "./serverStatusManager";
 import { ServerLifecycle } from "./serverLifecycle";
+import { getLogger } from "./logger";
+import { createWebServer } from "./web/server";
+
+const logger = getLogger("Index");


 const wrapperRegistry =
@@ -34,8 +38,16 @@ async function main(){


    await rabbit.connect();
+    logger.info("RabbitMQ-Verbindung hergestellt");

+    await portManager.init();
+    logger.info("Persistenz initialisiert");

+    await wrapperRegistry.init();
+    logger.debug("WrapperRegistry initialisiert");
+
+    await serverRegistry.init();
+    logger.debug("ServerRegistry initialisiert");

    const wrapperManager =
        new WrapperManager(
@@ -51,6 +63,7 @@ async function main(){


    await wrapperManager.start();
+    logger.info("WrapperManager erfolgreich gestartet");


    const serverManager =
@@ -77,6 +90,7 @@ async function main(){


    lifecycle.start();
+    logger.debug("ServerLifecycle gestartet");

    const statusManager =
        new ServerStatusManager(
@@ -90,16 +104,21 @@ async function main(){

    await statusManager.start();

+    const webServer = createWebServer({
+        wrapperRegistry,
+        serverRegistry,
+        lifecycle,
+        rabbitMqStatus: "connected",
+        managerStatus: "running"
+    }, 3000);

+    logger.info("Manager gestartet");

-
-    console.log(
-        "Manager gestartet"
-    );
+    void webServer;


 }



-main();
+main();
@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLogger = getLogger;
+const LEVELS = {
+    DEBUG: 0,
+    INFO: 1,
+    WARN: 2,
+    ERROR: 3,
+};
+const DEFAULT_LOG_LEVEL = "INFO";
+const configuredLevel = (process.env.LOG_LEVEL ?? "").toUpperCase();
+const currentLogLevel = configuredLevel in LEVELS ? configuredLevel : DEFAULT_LOG_LEVEL;
+const currentLogLevelValue = LEVELS[currentLogLevel];
+function shouldLog(level) {
+    return LEVELS[level] >= currentLogLevelValue;
+}
+function formatMessage(level, component, message) {
+    return `${new Date().toISOString()} ${level} [${component}] ${message}`;
+}
+class Logger {
+    constructor(component) {
+        this.component = component;
+    }
+    debug(message, ...args) {
+        if (!shouldLog("DEBUG"))
+            return;
+        console.log(formatMessage("DEBUG", this.component, message), ...args);
+    }
+    info(message, ...args) {
+        if (!shouldLog("INFO"))
+            return;
+        console.log(formatMessage("INFO", this.component, message), ...args);
+    }
+    warn(message, ...args) {
+        if (!shouldLog("WARN"))
+            return;
+        console.warn(formatMessage("WARN", this.component, message), ...args);
+    }
+    error(message, ...args) {
+        if (!shouldLog("ERROR"))
+            return;
+        console.error(formatMessage("ERROR", this.component, message), ...args);
+    }
+}
+function getLogger(component) {
+    return new Logger(component);
+}
@@ -0,0 +1,62 @@
+declare const process: {
+  env: Record<string, string | undefined>;
+};
+
+type LogLevel = "DEBUG" | "INFO" | "WARN" | "ERROR";
+
+const LEVELS: Record<LogLevel, number> = {
+  DEBUG: 0,
+  INFO: 1,
+  WARN: 2,
+  ERROR: 3,
+};
+
+const DEFAULT_LOG_LEVEL: LogLevel = "INFO";
+
+const configuredLevel =
+  (process.env.LOG_LEVEL ?? "").toUpperCase() as LogLevel;
+
+const currentLogLevel: LogLevel =
+  configuredLevel in LEVELS ? configuredLevel : DEFAULT_LOG_LEVEL;
+
+const currentLogLevelValue = LEVELS[currentLogLevel];
+
+function shouldLog(level: LogLevel): boolean {
+  return LEVELS[level] >= currentLogLevelValue;
+}
+
+function formatMessage(
+  level: LogLevel,
+  component: string,
+  message: unknown
+): string {
+  return `${new Date().toISOString()} ${level} [${component}] ${message}`;
+}
+
+class Logger {
+  constructor(private component: string) {}
+
+  debug(message: unknown, ...args: unknown[]): void {
+    if (!shouldLog("DEBUG")) return;
+    console.log(formatMessage("DEBUG", this.component, message), ...args);
+  }
+
+  info(message: unknown, ...args: unknown[]): void {
+    if (!shouldLog("INFO")) return;
+    console.log(formatMessage("INFO", this.component, message), ...args);
+  }
+
+  warn(message: unknown, ...args: unknown[]): void {
+    if (!shouldLog("WARN")) return;
+    console.warn(formatMessage("WARN", this.component, message), ...args);
+  }
+
+  error(message: unknown, ...args: unknown[]): void {
+    if (!shouldLog("ERROR")) return;
+    console.error(formatMessage("ERROR", this.component, message), ...args);
+  }
+}
+
+export function getLogger(component: string): Logger {
+  return new Logger(component);
+}
@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateServerName = generateServerName;
+const locations = [
+    "Crimson",
+    "Azure",
+    "Emerald",
+    "Amber",
+    "Sapphire",
+    "Ruby",
+    "Obsidian",
+    "Pearl",
+    "Onyx",
+    "Ivory",
+    "Copper",
+    "Platinum",
+    "Titanium",
+    "Neon",
+    "Shadow",
+    "Frost",
+    "Solar",
+    "Void",
+    "Storm",
+    "Ocean"
+];
+function generateServerName(existingNames) {
+    for (const location of locations) {
+        const name = "[EU] druecktieR | " + location;
+        if (!existingNames.includes(name)) {
+            return name;
+        }
+    }
+    /*
+        Falls alle Namen vergeben sind
+    */
+    return ("[EU] druecktieR | " +
+        Math.random()
+            .toString(36)
+            .substring(2, 6));
+}
@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsonFileStore = void 0;
+const fs_1 = require("fs");
+const logger_1 = require("../logger");
+const logger = (0, logger_1.getLogger)("JsonFileStore");
+class JsonFileStore {
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    async load() {
+        try {
+            const fileContents = await fs_1.promises.readFile(this.filePath, "utf-8");
+            return JSON.parse(fileContents);
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return null;
+            }
+            logger.error(`Fehler beim Laden der Persistenzdatei ${this.filePath}:`, error);
+            throw error;
+        }
+    }
+    async save(data) {
+        try {
+            const fileContents = JSON.stringify(data, null, 4);
+            await fs_1.promises.writeFile(this.filePath, fileContents, "utf-8");
+        }
+        catch (error) {
+            logger.error(`Fehler beim Speichern der Persistenzdatei ${this.filePath}:`, error);
+            throw error;
+        }
+    }
+}
+exports.JsonFileStore = JsonFileStore;
@@ -0,0 +1,42 @@
+import { promises as fs } from "fs";
+import { PersistenceStore } from "./persistenceStore";
+import { getLogger } from "../logger";
+
+const logger = getLogger("JsonFileStore");
+
+export class JsonFileStore<T> implements PersistenceStore<T> {
+    constructor(
+        private readonly filePath: string
+    ) {}
+
+    async load(): Promise<T | null> {
+        try {
+            const fileContents = await fs.readFile(this.filePath, "utf-8");
+            return JSON.parse(fileContents) as T;
+        }
+        catch (error) {
+            if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+                return null;
+            }
+            logger.error(
+                `Fehler beim Laden der Persistenzdatei ${this.filePath}:`,
+                error
+            );
+            throw error;
+        }
+    }
+
+    async save(data: T): Promise<void> {
+        try {
+            const fileContents = JSON.stringify(data, null, 4);
+            await fs.writeFile(this.filePath, fileContents, "utf-8");
+        }
+        catch (error) {
+            logger.error(
+                `Fehler beim Speichern der Persistenzdatei ${this.filePath}:`,
+                error
+            );
+            throw error;
+        }
+    }
+}
@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
@@ -0,0 +1,4 @@
+export interface PersistenceStore<T> {
+    load(): Promise<T | null>;
+    save(data: T): Promise<void>;
+}
@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PortManager = void 0;
+const config_1 = require("./config");
+const jsonFileStore_1 = require("./persistence/jsonFileStore");
+const logger_1 = require("./logger");
+const logger = (0, logger_1.getLogger)("PortManager");
+class PortManager {
+    constructor() {
+        this.usedPorts = new Set();
+        this.usedQueryPorts = new Set();
+        this.gamePortStart = config_1.GAME_PORT_START;
+        this.queryPortStart = config_1.QUERY_PORT_START;
+        this.persistence = new jsonFileStore_1.JsonFileStore("portManager-state.json");
+    }
+    async init() {
+        const state = await this.persistence.load();
+        if (!state)
+            return;
+        this.usedPorts =
+            new Set(state.usedPorts);
+        this.usedQueryPorts =
+            new Set(state.usedQueryPorts);
+    }
+    allocate() {
+        let port = this.gamePortStart;
+        while (this.usedPorts.has(port)) {
+            port++;
+        }
+        let queryPort = this.queryPortStart;
+        while (this.usedQueryPorts.has(queryPort)) {
+            queryPort++;
+        }
+        this.usedPorts.add(port);
+        this.usedQueryPorts.add(queryPort);
+        logger.debug(`Port erfolgreich reserviert: ${port}`);
+        logger.debug(`Query-Port erfolgreich reserviert: ${queryPort}`);
+        this.saveState();
+        return {
+            port,
+            queryPort
+        };
+    }
+    release(port, queryPort) {
+        const removedPort = this.usedPorts.delete(port);
+        const removedQueryPort = this.usedQueryPorts.delete(queryPort);
+        if (!removedPort || !removedQueryPort) {
+            logger.warn(`Unerwarteter Port-Zustand während der Freigabe: port=${port}, queryPort=${queryPort}`);
+        }
+        else {
+            logger.debug(`Port wieder freigegeben: ${port}`);
+            logger.debug(`Query-Port wieder freigegeben: ${queryPort}`);
+        }
+        this.saveState();
+    }
+    saveState() {
+        const state = {
+            usedPorts: Array.from(this.usedPorts),
+            usedQueryPorts: Array.from(this.usedQueryPorts)
+        };
+        this.persistence
+            .save(state)
+            .catch(error => {
+            logger.error("Fehler beim Speichern des PortManager-Zustands:", error);
+        });
+    }
+}
+exports.PortManager = PortManager;
@@ -1,118 +1,124 @@
+import { GAME_PORT_START, QUERY_PORT_START } from "./config";
+import { JsonFileStore } from "./persistence/jsonFileStore";
+import { getLogger } from "./logger";
+
+const logger = getLogger("PortManager");
+
+interface PortManagerState {
+    usedPorts: number[];
+    usedQueryPorts: number[];
+}
+
 export class PortManager {

-
-
    private usedPorts =
        new Set<number>();

-
-
    private usedQueryPorts =
        new Set<number>();

-
-
-
-
    private gamePortStart =
-        7777;
-
+        GAME_PORT_START;

    private queryPortStart =
-        27015;
+        QUERY_PORT_START;

+    private readonly persistence =
+        new JsonFileStore<PortManagerState>(
+            "portManager-state.json"
+        );

+    async init(){
+        const state = await this.persistence.load();

+        if(!state)
+            return;

+        this.usedPorts =
+            new Set(state.usedPorts);
+
+        this.usedQueryPorts =
+            new Set(state.usedQueryPorts);
+    }

    allocate(){

-
-
        let port =
            this.gamePortStart;

-
-
        while(
            this.usedPorts.has(port)
        ){
-
            port++;
-
        }

-
-
-
        let queryPort =
            this.queryPortStart;

-
-
        while(
            this.usedQueryPorts.has(queryPort)
        ){
-
            queryPort++;
-
        }

-
-
-
-
        this.usedPorts.add(
            port
        );

-
        this.usedQueryPorts.add(
            queryPort
        );

+        logger.debug(`Port erfolgreich reserviert: ${port}`);
+        logger.debug(`Query-Port erfolgreich reserviert: ${queryPort}`);

-
+        this.saveState();

        return {
-
-
            port,
-
-
            queryPort
-
-
        };
-
-
    }

-
-
-
-
-
-
    release(
        port:number,
        queryPort:number
    ){

-
-        this.usedPorts.delete(
+        const removedPort = this.usedPorts.delete(
            port
        );

-
-        this.usedQueryPorts.delete(
+        const removedQueryPort = this.usedQueryPorts.delete(
            queryPort
        );

+        if (!removedPort || !removedQueryPort) {
+            logger.warn(
+                `Unerwarteter Port-Zustand während der Freigabe: port=${port}, queryPort=${queryPort}`
+            );
+        } else {
+            logger.debug(`Port wieder freigegeben: ${port}`);
+            logger.debug(`Query-Port wieder freigegeben: ${queryPort}`);
+        }
+
+        this.saveState();

    }

+    private saveState(){
+        const state: PortManagerState = {
+            usedPorts: Array.from(this.usedPorts),
+            usedQueryPorts: Array.from(this.usedQueryPorts)
+        };

-
-
+        this.persistence
+            .save(state)
+            .catch(error => {
+                logger.error(
+                    "Fehler beim Speichern des PortManager-Zustands:",
+                    error
+                );
+            });
+    }
 }
@@ -0,0 +1,50 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Rabbit = void 0;
+const amqp = __importStar(require("amqplib"));
+const config_1 = require("./config");
+const logger_1 = require("./logger");
+const logger = (0, logger_1.getLogger)("Rabbit");
+class Rabbit {
+    async connect() {
+        this.connection =
+            await amqp.connect(config_1.RABBITMQ_URL);
+        this.channel =
+            await this.connection.createChannel();
+        logger.info("Connected to RabbitMQ");
+    }
+}
+exports.Rabbit = Rabbit;
@@ -1,5 +1,8 @@
 import * as amqp from "amqplib";
+import { RABBITMQ_URL } from "./config";
+import { getLogger } from "./logger";

+const logger = getLogger("Rabbit");

 export class Rabbit {

@@ -12,7 +15,7 @@ export class Rabbit {

        this.connection =
            await amqp.connect(
-                "amqp://manager:gigi1337@192.168.1.74"
+                RABBITMQ_URL
            );


@@ -20,8 +23,8 @@ export class Rabbit {
            await this.connection.createChannel();


-        console.log(
-            "RabbitMQ verbunden"
+        logger.info(
+            "Connected to RabbitMQ"
        );
    }

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerLifecycle = void 0;
+const logger_1 = require("./logger");
+const config_1 = require("./config");
+const logger = (0, logger_1.getLogger)("ServerLifecycle");
+class ServerLifecycle {
+    constructor(serverRegistry, serverManager, desiredServers = config_1.DEFAULT_DESIRED_SERVERS) {
+        this.serverRegistry = serverRegistry;
+        this.serverManager = serverManager;
+        this.desiredServers = desiredServers;
+        this.creatingServers = 0;
+        this.emptyTimeout = config_1.LIFECYCLE_EMPTY_TIMEOUT;
+        this.lastScaleUp = 0;
+        this.scaleCooldown = config_1.LIFECYCLE_SCALE_COOLDOWN;
+    }
+    start() {
+        logger.info("Server Lifecycle gestartet");
+        setInterval(() => {
+            this.checkServers();
+        }, config_1.LIFECYCLE_CHECK_INTERVAL);
+    }
+    setDesiredServers(count) {
+        logger.debug("Neue Soll Server Anzahl:", count);
+        this.desiredServers =
+            count;
+    }
+    /**
+     * Exposes the configured target for monitoring consumers.
+     * It deliberately does not influence lifecycle behaviour.
+     */
+    getDesiredServers() {
+        return this.desiredServers;
+    }
+    checkServers() {
+        const servers = this.serverRegistry.getAll();
+        /*
+            STATUS AKTUALISIEREN
+        */
+        for (const server of servers) {
+            switch (server.status) {
+                case "STARTING":
+                    if (server.pid) {
+                        server.status =
+                            "RUNNING";
+                        server.startedAt =
+                            Date.now();
+                        server.emptySince =
+                            undefined;
+                        this.serverRegistry.update(server);
+                        logger.info("Server RUNNING:", server.name, "PID:", server.pid);
+                    }
+                    break;
+                case "RECOVERING":
+                    if (Date.now() -
+                        server.lastSeen
+                        >
+                            config_1.LIFECYCLE_CRASH_TIMEOUT) {
+                        server.status =
+                            "CRASHED";
+                        server.crashedAt =
+                            Date.now();
+                        this.serverRegistry.update(server);
+                        logger.error("Server-Recovery fehlgeschlagen:", server.name);
+                    }
+                    break;
+                case "RUNNING":
+                    /*
+                        Crash Detection
+                    */
+                    if (Date.now() -
+                        server.lastSeen
+                        >
+                            config_1.LIFECYCLE_CRASH_TIMEOUT) {
+                        server.status =
+                            "CRASHED";
+                        server.crashedAt =
+                            Date.now();
+                        this.serverRegistry.update(server);
+                        logger.error("Server abgestürzt:", server.name);
+                        break;
+                    }
+                    /*
+                        Leere Server tracken
+                    */
+                    if (server.players === 0) {
+                        if (!server.emptySince) {
+                            if (server.startedAt &&
+                                Date.now() -
+                                    server.startedAt <
+                                    config_1.LIFECYCLE_STARTUP_GRACE_PERIOD) {
+                                break;
+                            }
+                            server.emptySince =
+                                Date.now();
+                            this.serverRegistry.update(server);
+                            logger.debug("Server leer:", server.name);
+                        }
+                    }
+                    else {
+                        if (server.emptySince) {
+                            logger.debug("Server wieder aktiv:", server.name);
+                        }
+                        server.emptySince =
+                            undefined;
+                        this.serverRegistry.update(server);
+                    }
+                    break;
+                case "CRASHED":
+                    if (!server.crashedAt) {
+                        server.crashedAt =
+                            Date.now();
+                        this.serverRegistry.update(server);
+                        logger.error("Server abgestürzt erkannt:", server.name);
+                        break;
+                    }
+                    if (Date.now() -
+                        server.crashedAt
+                        >
+                            config_1.LIFECYCLE_CRASH_RETENTION) {
+                        logger.info("Entferne abgestürzten Server nach Grace-Zeit:", server.name);
+                        this.serverRegistry.remove(server.id);
+                    }
+                    break;
+            }
+        }
+        /*
+            AKTIVE SERVER
+        */
+        const activeServers = this.serverRegistry
+            .getAll()
+            .filter(server => server.status === "RUNNING" ||
+            server.status === "STARTING" ||
+            server.status === "RECOVERING");
+        /*
+            SLOT AUSLASTUNG
+        */
+        const runningServers = activeServers.filter(server => server.status === "RUNNING");
+        const totalPlayers = runningServers.reduce((sum, server) => sum + server.players, 0);
+        const totalSlots = runningServers.reduce((sum, server) => sum + server.maxPlayers, 0);
+        const usage = totalSlots > 0
+            ?
+                totalPlayers / totalSlots
+            :
+                0;
+        logger.debug("Kapazität:", `${totalPlayers}/${totalSlots}`, `${(usage * 100).toFixed(1)}%`);
+        /*
+            MINDEST SERVER ANZAHL
+        */
+        const totalActive = activeServers.length +
+            this.creatingServers;
+        if (totalActive <
+            this.desiredServers) {
+            const missing = this.desiredServers -
+                totalActive;
+            this.startServers(missing);
+        }
+        /*
+            SCALE UP BEI 90%
+        */
+        const shouldScale = runningServers.length > 0 &&
+            this.creatingServers === 0 &&
+            usage >= 0.90 &&
+            Date.now() -
+                this.lastScaleUp
+                >
+                    this.scaleCooldown;
+        if (shouldScale) {
+            logger.info("Auslastung hoch - starte zusätzlichen Server");
+            this.lastScaleUp =
+                Date.now();
+            this.startServers(1);
+        }
+        /*
+            LEERE SERVER ENTFERNEN
+        */
+        const removableServers = activeServers
+            .filter(server => server.status === "RUNNING" &&
+            server.players === 0 &&
+            server.emptySince &&
+            server.startedAt &&
+            Date.now() -
+                server.startedAt
+                >=
+                    config_1.LIFECYCLE_MIN_UPTIME &&
+            Date.now() -
+                server.emptySince
+                >
+                    this.emptyTimeout &&
+            usage <
+                config_1.LIFECYCLE_SCALE_DOWN_THRESHOLD)
+            .sort((a, b) => (a.emptySince ?? 0) -
+            (b.emptySince ?? 0));
+        for (const server of removableServers) {
+            const activeCount = this.serverRegistry
+                .getAll()
+                .filter(s => s.status === "RUNNING" ||
+                s.status === "STARTING" ||
+                s.status === "RECOVERING")
+                .length;
+            if (activeCount <=
+                this.desiredServers) {
+                break;
+            }
+            logger.info("Stoppe leeren Server:", server.name);
+            this.serverManager.stopServer(server.id);
+        }
+    }
+    startServers(count) {
+        logger.info("Starte Server:", count);
+        for (let i = 0; i < count; i++) {
+            this.creatingServers++;
+            this.serverManager
+                .createServer()
+                .then(() => {
+                this.creatingServers--;
+            })
+                .catch(err => {
+                this.creatingServers--;
+                logger.error("Server Erstellung fehlgeschlagen:", err);
+            });
+        }
+    }
+}
+exports.ServerLifecycle = ServerLifecycle;
@@ -1,20 +1,34 @@
+import { getLogger } from "./logger";
 import { ServerRegistry } from "./serverRegistry";
 import { ServerManager } from "./serverManager";
+import {
+  LIFECYCLE_CHECK_INTERVAL,
+  LIFECYCLE_EMPTY_TIMEOUT,
+  LIFECYCLE_STARTUP_GRACE_PERIOD,
+  LIFECYCLE_MIN_UPTIME,
+  LIFECYCLE_SCALE_DOWN_THRESHOLD,
+  LIFECYCLE_SCALE_COOLDOWN,
+  LIFECYCLE_CRASH_TIMEOUT,
+  LIFECYCLE_CRASH_RETENTION,
+  DEFAULT_DESIRED_SERVERS
+} from "./config";


+const logger = getLogger("ServerLifecycle");
+
 export class ServerLifecycle {


    private creatingServers = 0;


-    private emptyTimeout = 300000; // 5 Minuten
+    private emptyTimeout = LIFECYCLE_EMPTY_TIMEOUT;


    private lastScaleUp = 0;


-    private scaleCooldown = 60000; // 1 Minute
+    private scaleCooldown = LIFECYCLE_SCALE_COOLDOWN;



@@ -25,7 +39,7 @@ export class ServerLifecycle {

        private serverManager: ServerManager,

-        private desiredServers:number = 1
+        private desiredServers:number = DEFAULT_DESIRED_SERVERS

    ){}

@@ -36,7 +50,7 @@ export class ServerLifecycle {
    start(){


-        console.log(
+        logger.info(
            "Server Lifecycle gestartet"
        );

@@ -47,7 +61,7 @@ export class ServerLifecycle {
            this.checkServers();


-        },10000);
+        },LIFECYCLE_CHECK_INTERVAL);


    }
@@ -59,7 +73,7 @@ export class ServerLifecycle {
    setDesiredServers(count:number){


-        console.log(
+        logger.debug(
            "Neue Soll Server Anzahl:",
            count
        );
@@ -72,6 +86,17 @@ export class ServerLifecycle {
    }


+    /**
+     * Exposes the configured target for monitoring consumers.
+     * It deliberately does not influence lifecycle behaviour.
+     */
+    getDesiredServers(): number {
+
+        return this.desiredServers;
+
+    }
+
+



@@ -110,13 +135,19 @@ export class ServerLifecycle {
                        server.status =
                            "RUNNING";

+                        server.startedAt =
+                            Date.now();
+
+                        server.emptySince =
+                            undefined;
+

                        this.serverRegistry.update(
                            server
                        );


-                        console.log(
+                        logger.info(
                            "Server RUNNING:",
                            server.name,
                            "PID:",
@@ -134,6 +165,43 @@ export class ServerLifecycle {



+                case "RECOVERING":
+
+
+                    if(
+                        Date.now() -
+                        server.lastSeen
+                        >
+                        LIFECYCLE_CRASH_TIMEOUT
+                    ){
+
+
+                        server.status =
+                            "CRASHED";
+
+                        server.crashedAt =
+                            Date.now();
+
+
+                        this.serverRegistry.update(
+                            server
+                        );
+
+
+                        logger.error(
+                            "Server-Recovery fehlgeschlagen:",
+                            server.name
+                        );
+
+
+                    }
+
+
+                    break;
+
+
+
+
                case "RUNNING":


@@ -147,20 +215,23 @@ export class ServerLifecycle {
                        Date.now() -
                        server.lastSeen
                        >
-                        30000
+                        LIFECYCLE_CRASH_TIMEOUT
                    ){


                        server.status =
                            "CRASHED";

+                        server.crashedAt =
+                            Date.now();
+

                        this.serverRegistry.update(
                            server
                        );


-                        console.log(
+                        logger.error(
                            "Server abgestürzt:",
                            server.name
                        );
@@ -186,17 +257,23 @@ export class ServerLifecycle {

                        if(!server.emptySince){

+                            if(
+                                server.startedAt &&
+                                Date.now() -
+                                server.startedAt <
+                                LIFECYCLE_STARTUP_GRACE_PERIOD
+                            ){
+                                break;
+                            }

                            server.emptySince =
                                Date.now();

-
                            this.serverRegistry.update(
                                server
                            );

-
-                            console.log(
+                            logger.debug(
                                "Server leer:",
                                server.name
                            );
@@ -213,7 +290,7 @@ export class ServerLifecycle {
                        if(server.emptySince){


-                            console.log(
+                            logger.debug(
                                "Server wieder aktiv:",
                                server.name
                            );
@@ -247,11 +324,42 @@ export class ServerLifecycle {
                case "CRASHED":


+                    if(!server.crashedAt){

-                    console.log(
-                        "Server abgestürzt erkannt:",
-                        server.name
-                    );
+                        server.crashedAt =
+                            Date.now();
+
+                        this.serverRegistry.update(
+                            server
+                        );
+
+                        logger.error(
+                            "Server abgestürzt erkannt:",
+                            server.name
+                        );
+
+                        break;
+
+                    }
+
+
+                    if(
+                        Date.now() -
+                        server.crashedAt
+                        >
+                        LIFECYCLE_CRASH_RETENTION
+                    ){
+
+                        logger.info(
+                            "Entferne abgestürzten Server nach Grace-Zeit:",
+                            server.name
+                        );
+
+                        this.serverRegistry.remove(
+                            server.id
+                        );
+
+                    }


                    break;
@@ -282,7 +390,8 @@ export class ServerLifecycle {

                server =>
                    server.status === "RUNNING" ||
-                    server.status === "STARTING"
+                    server.status === "STARTING" ||
+                    server.status === "RECOVERING"

            );

@@ -359,7 +468,7 @@ export class ServerLifecycle {



-        console.log(
+        logger.debug(

            "Kapazität:",

@@ -452,7 +561,7 @@ export class ServerLifecycle {



-            console.log(
+            logger.info(

                "Auslastung hoch - starte zusätzlichen Server"

@@ -501,11 +610,20 @@ export class ServerLifecycle {

                server.emptySince &&

+                server.startedAt &&
+
+                Date.now() -
+                server.startedAt
+                >=
+                LIFECYCLE_MIN_UPTIME &&

                Date.now() -
                server.emptySince
                >
-                this.emptyTimeout
+                this.emptyTimeout &&
+
+                usage <
+                LIFECYCLE_SCALE_DOWN_THRESHOLD


            )
@@ -537,7 +655,8 @@ export class ServerLifecycle {

                    s =>
                        s.status === "RUNNING" ||
-                        s.status === "STARTING"
+                        s.status === "STARTING" ||
+                        s.status === "RECOVERING"

                )
                .length;
@@ -559,12 +678,9 @@ export class ServerLifecycle {



-            console.log(
-
+            logger.info(
                "Stoppe leeren Server:",
-
                server.name
-
            );


@@ -597,7 +713,7 @@ export class ServerLifecycle {



-        console.log(
+        logger.info(

            "Starte Server:",

@@ -647,7 +763,7 @@ export class ServerLifecycle {



-                console.error(
+                logger.error(

                    "Server Erstellung fehlgeschlagen:",

@@ -667,4 +783,4 @@ export class ServerLifecycle {



-}
+}
@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerLifecycleManager = void 0;
+class ServerLifecycleManager {
+    constructor(serverRegistry, rabbit) {
+        this.serverRegistry = serverRegistry;
+        this.rabbit = rabbit;
+    }
+    start() {
+        console.log("Server Lifecycle Manager gestartet");
+        setInterval(() => {
+            this.checkServers();
+        }, 5000);
+    }
+    checkServers() {
+        const servers = this.serverRegistry.getAll();
+        for (const server of servers) {
+            switch (server.status) {
+                case "STARTING":
+                    this.checkStarting(server);
+                    break;
+                case "RUNNING":
+                    this.checkRunning(server);
+                    break;
+                case "CRASHED":
+                    this.checkOffline(server);
+                    break;
+            }
+        }
+    }
+    checkStarting(server) {
+        // kommt später
+    }
+    checkRunning(server) {
+        // kommt später
+    }
+    checkOffline(server) {
+        // kommt später
+    }
+}
+exports.ServerLifecycleManager = ServerLifecycleManager;
@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerManager = void 0;
+const logger_1 = require("./logger");
+const crypto_1 = require("crypto");
+const nameGenerator_1 = require("./nameGenerator");
+const logger = (0, logger_1.getLogger)("ServerManager");
+class ServerManager {
+    constructor(rabbit, wrapperRegistry, serverRegistry, portManager) {
+        this.rabbit = rabbit;
+        this.wrapperRegistry = wrapperRegistry;
+        this.serverRegistry = serverRegistry;
+        this.portManager = portManager;
+    }
+    async createServer() {
+        /*
+            freien Wrapper suchen
+        */
+        const wrapper = this.findBestWrapper();
+        if (!wrapper) {
+            logger.warn("Kein Wrapper verfügbar");
+            return;
+        }
+        const serverId = "srv-" +
+            (0, crypto_1.randomUUID)()
+                .slice(0, 8);
+        const serverName = (0, nameGenerator_1.generateServerName)(this.serverRegistry
+            .getAll()
+            .map(server => server.name));
+        /*
+            Ports reservieren
+        */
+        const ports = this.portManager.allocate();
+        const server = {
+            id: serverId,
+            name: serverName,
+            wrapperId: wrapper.id,
+            status: "STARTING",
+            port: ports.port,
+            queryPort: ports.queryPort,
+            players: 0,
+            maxPlayers: 21,
+            created: Date.now(),
+            lastSeen: Date.now()
+        };
+        /*
+            Registry Eintrag
+        */
+        this.serverRegistry.add(server);
+        /*
+            Command an Wrapper
+        */
+        const command = {
+            type: "server.start",
+            serverId,
+            name: serverName,
+            port: ports.port,
+            queryPort: ports.queryPort
+        };
+        const sent = this.rabbit.channel.sendToQueue(wrapper.commandQueue, Buffer.from(JSON.stringify(command)));
+        if (!sent) {
+            throw new Error("Server Start Command konnte nicht gesendet werden");
+        }
+        logger.info("Starting server:", server.id);
+    }
+    async stopServer(serverId) {
+        const server = this.serverRegistry.get(serverId);
+        if (!server) {
+            logger.warn("Server not found:", serverId);
+            return;
+        }
+        const wrapper = this.wrapperRegistry.get(server.wrapperId);
+        if (!wrapper) {
+            logger.warn("Wrapper not found:", server.wrapperId);
+            return;
+        }
+        const command = {
+            type: "server.stop",
+            serverId
+        };
+        this.rabbit.channel.sendToQueue(wrapper.commandQueue, Buffer.from(JSON.stringify(command)));
+        server.status =
+            "STOPPING";
+        this.serverRegistry.update(server);
+        logger.info("Stopping server:", serverId);
+    }
+    findBestWrapper() {
+        const wrappers = this.wrapperRegistry.getAll()
+            .filter(w => w.online);
+        if (wrappers.length === 0)
+            return undefined;
+        /*
+            Einfachste Version:
+
+            wenigste Server
+        */
+        wrappers.sort((a, b) => a.servers.length -
+            b.servers.length);
+        return wrappers[0];
+    }
+}
+exports.ServerManager = ServerManager;
@@ -1,3 +1,4 @@
+import { getLogger } from "./logger";
 import { Rabbit } from "./rabbit";
 import { WrapperRegistry } from "./wrapperRegistry";
 import { ServerRegistry, ServerInfo } from "./serverRegistry";
@@ -6,6 +7,8 @@ import { generateServerName } from "./nameGenerator";
 import { PortManager } from "./portManager";
 import { ServerStartCommand, ServerStopCommand } from "server-manager-shared";

+const logger = getLogger("ServerManager");
+

 export class ServerManager {

@@ -39,7 +42,7 @@ export class ServerManager {

        if(!wrapper){

-            console.log(
+            logger.warn(
                "Kein Wrapper verfügbar"
            );

@@ -208,11 +211,11 @@ export class ServerManager {



-        console.log(
+        logger.info(

-            "Server Start gesendet:",
+            "Starting server:",

-            server
+            server.id

        );

@@ -232,8 +235,8 @@ export class ServerManager {

        if(!server){

-            console.log(
-                "Server nicht gefunden:",
+            logger.warn(
+                "Server not found:",
                serverId
            );

@@ -251,8 +254,8 @@ export class ServerManager {

        if(!wrapper){

-            console.log(
-                "Wrapper nicht gefunden:",
+            logger.warn(
+                "Wrapper not found:",
                server.wrapperId
            );

@@ -298,9 +301,9 @@ export class ServerManager {



-        console.log(
-            "Server Stop gesendet:",
-            server.name
+        logger.info(
+            "Stopping server:",
+            serverId
        );


@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerRegistry = void 0;
+const logger_1 = require("./logger");
+const jsonFileStore_1 = require("./persistence/jsonFileStore");
+const logger = (0, logger_1.getLogger)("ServerRegistry");
+class ServerRegistry {
+    constructor() {
+        this.servers = new Map();
+        this.persistence = new jsonFileStore_1.JsonFileStore("serverRegistry-state.json");
+    }
+    async init() {
+        const state = await this.persistence.load();
+        if (!state)
+            return;
+        for (const serverData of state.servers) {
+            this.servers.set(serverData.id, {
+                id: serverData.id,
+                name: serverData.name,
+                wrapperId: serverData.wrapperId,
+                port: serverData.port,
+                queryPort: serverData.queryPort,
+                created: serverData.created,
+                status: "RECOVERING",
+                players: 0,
+                maxPlayers: 0,
+                lastSeen: Date.now()
+            });
+        }
+    }
+    toState() {
+        return {
+            servers: Array.from(this.servers.values()).map(server => ({
+                id: server.id,
+                name: server.name,
+                wrapperId: server.wrapperId,
+                port: server.port,
+                queryPort: server.queryPort,
+                created: server.created
+            }))
+        };
+    }
+    async saveState() {
+        await this.persistence.save(this.toState());
+    }
+    persist() {
+        void this.saveState();
+    }
+    add(server) {
+        this.servers.set(server.id, server);
+        logger.info("Server added:", server.id);
+        this.persist();
+    }
+    get(id) {
+        return this.servers.get(id);
+    }
+    getAll() {
+        return Array.from(this.servers.values());
+    }
+    update(server) {
+        this.servers.set(server.id, server);
+        this.persist();
+    }
+    remove(id) {
+        this.servers.delete(id);
+        logger.info("Server removed:", id);
+        this.persist();
+    }
+    list() {
+        logger.info("Server list output");
+        const servers = this.getAll();
+        if (servers.length === 0) {
+            logger.info("Keine Server vorhanden");
+            return;
+        }
+        for (const server of servers) {
+            logger.info({
+                id: server.id,
+                name: server.name,
+                wrapper: server.wrapperId,
+                status: server.status,
+                port: server.port,
+                queryPort: server.queryPort,
+                players: `${server.players}/${server.maxPlayers}`
+            });
+        }
+    }
+    syncWrapperStatus(data) {
+        if (!data.servers)
+            return;
+        const runningServerIds = new Set(data.servers.map(srv => srv.id));
+        for (const server of this.servers.values()) {
+            if (server.wrapperId === data.wrapperId &&
+                !runningServerIds.has(server.id)) {
+                if (server.status === "STOPPING") {
+                    logger.debug("Server cleanly stopped:", server.name);
+                    this.remove(server.id);
+                }
+                else if (server.status === "RUNNING" ||
+                    server.status === "RECOVERING") {
+                    server.status =
+                        "CRASHED";
+                    if (!server.crashedAt) {
+                        server.crashedAt =
+                            Date.now();
+                    }
+                    this.servers.set(server.id, server);
+                    logger.warn("Server crashed:", server.name);
+                }
+            }
+        }
+        for (const srv of data.servers) {
+            const server = this.servers.get(srv.id);
+            if (!server)
+                continue;
+            server.pid =
+                srv.pid;
+            server.players =
+                srv.players ?? 0;
+            server.maxPlayers =
+                srv.maxPlayers ?? 0;
+            server.lastSeen =
+                Date.now();
+            const oldStatus = server.status;
+            if (srv.alive && server.status !== "STOPPING") {
+                server.crashedAt =
+                    undefined;
+                if (!server.startedAt) {
+                    server.startedAt =
+                        srv.started;
+                }
+                server.status =
+                    "RUNNING";
+            }
+            else if (server.status === "RUNNING" ||
+                server.status === "RECOVERING") {
+                server.status =
+                    "CRASHED";
+                if (!server.crashedAt) {
+                    server.crashedAt =
+                        Date.now();
+                }
+            }
+            if (oldStatus !== server.status) {
+                logger.debug("Status change:", server.name, oldStatus, "->", server.status);
+            }
+            this.servers.set(server.id, server);
+        }
+    }
+}
+exports.ServerRegistry = ServerRegistry;
@@ -1,3 +1,9 @@
+import { getLogger } from "./logger";
+import { WrapperStatusMessage } from "server-manager-shared";
+import { JsonFileStore } from "./persistence/jsonFileStore";
+
+const logger = getLogger("ServerRegistry");
+
 export interface ServerInfo {


@@ -10,6 +16,7 @@ export interface ServerInfo {

    status:
        | "STARTING"
+        | "RECOVERING"
        | "RUNNING"
        | "STOPPING"
        | "CRASHED";
@@ -19,6 +26,8 @@ export interface ServerInfo {

    queryPort:number;

+    created:number;
+

    pid?:number;

@@ -31,9 +40,9 @@ export interface ServerInfo {
    
    emptySince?:number;

+    startedAt?:number;

-    created:number;
-
+    crashedAt?:number;

    lastSeen:number;

@@ -41,16 +50,84 @@ export interface ServerInfo {
 }


+interface ServerRegistryState {
+    servers: Array<{
+        id:string;
+        name:string;
+        wrapperId:string;
+        port:number;
+        queryPort:number;
+        created:number;
+    }>;
+}
+
+



 export class ServerRegistry {


-
    private servers =
        new Map<string, ServerInfo>();

+    private readonly persistence =
+        new JsonFileStore<ServerRegistryState>(
+            "serverRegistry-state.json"
+        );
+
+
+    async init(): Promise<void> {
+        const state = await this.persistence.load();
+
+        if (!state)
+            return;
+
+        for (const serverData of state.servers) {
+            this.servers.set(
+                serverData.id,
+                {
+                    id: serverData.id,
+                    name: serverData.name,
+                    wrapperId: serverData.wrapperId,
+                    port: serverData.port,
+                    queryPort: serverData.queryPort,
+                    created: serverData.created,
+                    status: "RECOVERING",
+                    players: 0,
+                    maxPlayers: 0,
+                    lastSeen: Date.now()
+                }
+            );
+        }
+    }
+
+    private toState(): ServerRegistryState {
+        return {
+            servers: Array.from(this.servers.values()).map(
+                server => ({
+                    id: server.id,
+                    name: server.name,
+                    wrapperId: server.wrapperId,
+                    port: server.port,
+                    queryPort: server.queryPort,
+                    created: server.created
+                })
+            )
+        };
+    }
+
+    private async saveState(): Promise<void> {
+        await this.persistence.save(
+            this.toState()
+        );
+    }
+
+
+    private persist(): void {
+        void this.saveState();
+    }
+



@@ -67,12 +144,13 @@ export class ServerRegistry {
        );


-        console.log(
-            "Server registriert:",
-            server
+        logger.info(
+            "Server added:",
+            server.id
        );


+        this.persist();
    }


@@ -126,6 +204,7 @@ export class ServerRegistry {
        );


+        this.persist();
    }


@@ -142,12 +221,13 @@ export class ServerRegistry {
        );


-        console.log(
-            "Server entfernt:",
+        logger.info(
+            "Server removed:",
            id
        );


+        this.persist();
    }


@@ -160,8 +240,8 @@ export class ServerRegistry {
    list(){


-        console.log(
-            "\n=== SERVER ÜBERSICHT ==="
+        logger.info(
+            "Server list output"
        );


@@ -175,7 +255,7 @@ export class ServerRegistry {
        if(servers.length === 0){


-            console.log(
+            logger.info(
                "Keine Server vorhanden"
            );

@@ -190,7 +270,7 @@ export class ServerRegistry {
        for(const server of servers){


-            console.log({
+            logger.info({


                id:
@@ -230,7 +310,7 @@ export class ServerRegistry {
    }


-    syncWrapperStatus(data:any){
+    syncWrapperStatus(data: WrapperStatusMessage){

    if(!data.servers)
        return;
@@ -240,7 +320,7 @@ export class ServerRegistry {
    const runningServerIds =
        new Set(
            data.servers.map(
-                (srv:any)=>srv.id
+                srv => srv.id
            )
        );

@@ -258,8 +338,8 @@ export class ServerRegistry {
            if(server.status === "STOPPING"){


-                console.log(
-                    "Server sauber beendet:",
+                logger.debug(
+                    "Server cleanly stopped:",
                    server.name
                );

@@ -270,12 +350,22 @@ export class ServerRegistry {


            }
-            else if(server.status === "RUNNING"){
+            else if(
+                server.status === "RUNNING" ||
+                server.status === "RECOVERING"
+            ){


                server.status =
                    "CRASHED";

+                if(!server.crashedAt){
+
+                    server.crashedAt =
+                        Date.now();
+
+                }
+

                this.servers.set(
                    server.id,
@@ -283,8 +373,8 @@ export class ServerRegistry {
                );


-                console.log(
-                    "Server abgestürzt:",
+                logger.warn(
+                    "Server crashed:",
                    server.name
                );

@@ -333,27 +423,45 @@ export class ServerRegistry {



-        if(srv.alive){
+        if(srv.alive && server.status !== "STOPPING"){
+
+            server.crashedAt =
+                undefined;
+
+            if(!server.startedAt){
+
+                server.startedAt =
+                    srv.started;
+
+            }

            server.status =
                "RUNNING";

        }
        else if(
-            server.status === "RUNNING"
+            server.status === "RUNNING" ||
+            server.status === "RECOVERING"
        ){

            server.status =
                "CRASHED";

+            if(!server.crashedAt){
+
+                server.crashedAt =
+                    Date.now();
+
+            }
+
        }



        if(oldStatus !== server.status){

-            console.log(
-                "Status Änderung:",
+            logger.debug(
+                "Status change:",
                server.name,
                oldStatus,
                "->",
@@ -375,4 +483,4 @@ export class ServerRegistry {
 }


-}
+}
@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerStatusManager = void 0;
+const logger_1 = require("./logger");
+const logger = (0, logger_1.getLogger)("ServerStatusManager");
+class ServerStatusManager {
+    constructor(rabbit, registry) {
+        this.rabbit = rabbit;
+        this.registry = registry;
+    }
+    async start() {
+        const queue = "server.status";
+        await this.rabbit.channel.assertQueue(queue);
+        logger.info("Warte auf Server Status...");
+        this.rabbit.channel.consume(queue, msg => {
+            if (!msg)
+                return;
+            const data = JSON.parse(msg.content.toString());
+            switch (data.type) {
+                case "server.started":
+                    this.serverStarted(data);
+                    break;
+                case "server.stopped":
+                    this.serverStopped(data);
+                    break;
+                default:
+                    logger.warn("Unbekannter Server Status:", data);
+            }
+            this.rabbit.channel.ack(msg);
+        });
+    }
+    serverStarted(data) {
+        const server = this.registry.get(data.serverId);
+        if (!server)
+            return;
+        server.status =
+            "RUNNING";
+        server.crashedAt =
+            undefined;
+        if (!server.startedAt) {
+            server.startedAt =
+                Date.now();
+        }
+        this.registry.update(server);
+        logger.info("Server started:", data.serverId);
+    }
+    serverStopped(data) {
+        const server = this.registry.get(data.serverId);
+        if (!server)
+            return;
+        server.status =
+            "CRASHED";
+        if (!server.crashedAt) {
+            server.crashedAt =
+                Date.now();
+        }
+        this.registry.update(server);
+        logger.info("Server stopped:", data.serverId);
+    }
+}
+exports.ServerStatusManager = ServerStatusManager;
@@ -1,7 +1,9 @@
+import { getLogger } from "./logger";
 import { Rabbit } from "./rabbit";
 import { ServerRegistry } from "./serverRegistry";
 import { ServerStartedEvent, ServerStoppedEvent } from "server-manager-shared";

+const logger = getLogger("ServerStatusManager");


 export class ServerStatusManager {
@@ -35,7 +37,7 @@ export class ServerStatusManager {



-        console.log(
+        logger.info(
            "Warte auf Server Status..."
        );

@@ -102,7 +104,7 @@ export class ServerStatusManager {
                    default:


-                        console.log(
+                        logger.warn(
                            "Unbekannter Server Status:",
                            data
                        );
@@ -158,6 +160,17 @@ export class ServerStatusManager {
        server.status =
            "RUNNING";

+        server.crashedAt =
+            undefined;
+
+
+        if(!server.startedAt){
+
+            server.startedAt =
+                Date.now();
+
+        }
+



@@ -168,11 +181,11 @@ export class ServerStatusManager {



-        console.log(
+        logger.info(

-            "Server läuft:",
+            "Server started:",

-            server.name
+            data.serverId

        );

@@ -211,6 +224,13 @@ export class ServerStatusManager {
        server.status =
            "CRASHED";

+        if(!server.crashedAt){
+
+            server.crashedAt =
+                Date.now();
+
+        }
+



@@ -221,11 +241,11 @@ export class ServerStatusManager {



-        console.log(
+        logger.info(

-            "Server crashed:",
+            "Server stopped:",

-            server.name
+            data.serverId

        );

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
@@ -15,10 +15,3 @@ export interface Wrapper {
 }


-export interface Message {
-
-    type: string;
-
-    [key:string]: any;
-
-}
@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebApi = void 0;
+class WebApi {
+    constructor(deps) {
+        this.deps = deps;
+    }
+    getHealth() {
+        return {
+            status: this.deps.managerStatus ?? "running",
+            timestamp: new Date().toISOString()
+        };
+    }
+    getDashboard() {
+        const wrappers = this.deps.wrapperRegistry.getAll();
+        const servers = this.deps.serverRegistry.getAll();
+        const runningServers = servers.filter(server => server.status === "RUNNING").length;
+        const totalPlayers = servers.reduce((sum, server) => sum + server.players, 0);
+        const totalCapacity = servers.reduce((sum, server) => sum + server.maxPlayers, 0);
+        const utilizationPercent = totalCapacity > 0 ? Math.round((totalPlayers / totalCapacity) * 100) : 0;
+        return {
+            managerStatus: this.deps.managerStatus ?? "running",
+            rabbitMqStatus: this.deps.rabbitMqStatus ?? "connected",
+            wrapperCount: wrappers.length,
+            onlineWrapperCount: wrappers.filter(wrapper => wrapper.online).length,
+            serverCount: servers.length,
+            runningServerCount: runningServers,
+            totalPlayers,
+            totalCapacity,
+            utilizationPercent,
+            desiredServers: this.getDesiredServers(),
+            activeServers: servers.filter(server => server.status === "RUNNING" || server.status === "STARTING").length
+        };
+    }
+    getWrappers() {
+        return this.deps.wrapperRegistry.getAll().map(wrapper => ({
+            id: wrapper.id,
+            hostname: wrapper.hostname,
+            online: wrapper.online,
+            cpu: wrapper.cpu,
+            ram: wrapper.ram,
+            ramFree: wrapper.ramFree,
+            lastHeartbeat: wrapper.lastHeartbeat,
+            serverCount: wrapper.servers.length
+        }));
+    }
+    getWrapper(id) {
+        const wrapper = this.deps.wrapperRegistry.get(id);
+        if (!wrapper) {
+            return null;
+        }
+        return {
+            id: wrapper.id,
+            hostname: wrapper.hostname,
+            online: wrapper.online,
+            cpu: wrapper.cpu,
+            ram: wrapper.ram,
+            ramFree: wrapper.ramFree,
+            lastHeartbeat: wrapper.lastHeartbeat,
+            serverCount: wrapper.servers.length,
+            servers: wrapper.servers.map(server => ({
+                id: server.id,
+                name: server.name,
+                port: server.port,
+                queryPort: server.queryPort,
+                players: server.players,
+                maxPlayers: server.maxPlayers,
+                alive: server.alive,
+                started: server.started
+            }))
+        };
+    }
+    getServers() {
+        return this.deps.serverRegistry.getAll().map(server => ({
+            id: server.id,
+            name: server.name,
+            status: server.status,
+            wrapperId: server.wrapperId,
+            pid: server.pid,
+            port: server.port,
+            queryPort: server.queryPort,
+            players: server.players,
+            maxPlayers: server.maxPlayers,
+            created: server.created,
+            startedAt: server.startedAt,
+            emptySince: server.emptySince
+        }));
+    }
+    getServer(id) {
+        const server = this.deps.serverRegistry.get(id);
+        if (!server) {
+            return null;
+        }
+        return {
+            id: server.id,
+            name: server.name,
+            status: server.status,
+            wrapperId: server.wrapperId,
+            pid: server.pid,
+            port: server.port,
+            queryPort: server.queryPort,
+            players: server.players,
+            maxPlayers: server.maxPlayers,
+            created: server.created,
+            startedAt: server.startedAt,
+            emptySince: server.emptySince
+        };
+    }
+    getDesiredServers() {
+        return this.deps.lifecycle.getDesiredServers();
+    }
+}
+exports.WebApi = WebApi;
@@ -0,0 +1,142 @@
+import { ServerRegistry } from "../serverRegistry";
+import { WrapperRegistry } from "../wrapperRegistry";
+import { ServerLifecycle } from "../serverLifecycle";
+import {
+    DashboardSummary,
+    HealthResponse,
+    ServerDetail,
+    ServerSummary,
+    WrapperDetail,
+    WrapperSummary
+} from "./types";
+
+export interface WebApiDependencies {
+    wrapperRegistry: WrapperRegistry;
+    serverRegistry: ServerRegistry;
+    lifecycle: ServerLifecycle;
+    rabbitMqStatus?: string;
+    managerStatus?: string;
+}
+
+export class WebApi {
+    constructor(private deps: WebApiDependencies) {}
+
+    getHealth(): HealthResponse {
+        return {
+            status: this.deps.managerStatus ?? "running",
+            timestamp: new Date().toISOString()
+        };
+    }
+
+    getDashboard(): DashboardSummary {
+        const wrappers = this.deps.wrapperRegistry.getAll();
+        const servers = this.deps.serverRegistry.getAll();
+
+        const runningServers = servers.filter(server => server.status === "RUNNING").length;
+        const totalPlayers = servers.reduce((sum, server) => sum + server.players, 0);
+        const totalCapacity = servers.reduce((sum, server) => sum + server.maxPlayers, 0);
+        const utilizationPercent = totalCapacity > 0 ? Math.round((totalPlayers / totalCapacity) * 100) : 0;
+
+        return {
+            managerStatus: this.deps.managerStatus ?? "running",
+            rabbitMqStatus: this.deps.rabbitMqStatus ?? "connected",
+            wrapperCount: wrappers.length,
+            onlineWrapperCount: wrappers.filter(wrapper => wrapper.online).length,
+            serverCount: servers.length,
+            runningServerCount: runningServers,
+            totalPlayers,
+            totalCapacity,
+            utilizationPercent,
+            desiredServers: this.getDesiredServers(),
+            activeServers: servers.filter(server =>
+                server.status === "RUNNING" || server.status === "STARTING"
+            ).length
+        };
+    }
+
+    getWrappers(): WrapperSummary[] {
+        return this.deps.wrapperRegistry.getAll().map(wrapper => ({
+            id: wrapper.id,
+            hostname: wrapper.hostname,
+            online: wrapper.online,
+            cpu: wrapper.cpu,
+            ram: wrapper.ram,
+            ramFree: wrapper.ramFree,
+            lastHeartbeat: wrapper.lastHeartbeat,
+            serverCount: wrapper.servers.length
+        }));
+    }
+
+    getWrapper(id: string): WrapperDetail | null {
+        const wrapper = this.deps.wrapperRegistry.get(id);
+
+        if (!wrapper) {
+            return null;
+        }
+
+        return {
+            id: wrapper.id,
+            hostname: wrapper.hostname,
+            online: wrapper.online,
+            cpu: wrapper.cpu,
+            ram: wrapper.ram,
+            ramFree: wrapper.ramFree,
+            lastHeartbeat: wrapper.lastHeartbeat,
+            serverCount: wrapper.servers.length,
+            servers: wrapper.servers.map(server => ({
+                id: server.id,
+                name: server.name,
+                port: server.port,
+                queryPort: server.queryPort,
+                players: server.players,
+                maxPlayers: server.maxPlayers,
+                alive: server.alive,
+                started: server.started
+            }))
+        };
+    }
+
+    getServers(): ServerSummary[] {
+        return this.deps.serverRegistry.getAll().map(server => ({
+            id: server.id,
+            name: server.name,
+            status: server.status,
+            wrapperId: server.wrapperId,
+            pid: server.pid,
+            port: server.port,
+            queryPort: server.queryPort,
+            players: server.players,
+            maxPlayers: server.maxPlayers,
+            created: server.created,
+            startedAt: server.startedAt,
+            emptySince: server.emptySince
+        }));
+    }
+
+    getServer(id: string): ServerDetail | null {
+        const server = this.deps.serverRegistry.get(id);
+
+        if (!server) {
+            return null;
+        }
+
+        return {
+            id: server.id,
+            name: server.name,
+            status: server.status,
+            wrapperId: server.wrapperId,
+            pid: server.pid,
+            port: server.port,
+            queryPort: server.queryPort,
+            players: server.players,
+            maxPlayers: server.maxPlayers,
+            created: server.created,
+            startedAt: server.startedAt,
+            emptySince: server.emptySince
+        };
+    }
+
+    private getDesiredServers(): number {
+        return this.deps.lifecycle.getDesiredServers();
+    }
+}
@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerRoutes = registerRoutes;
+const url_1 = require("url");
+function registerRoutes(server, api) {
+    server.on("request", (req, res) => {
+        const url = (0, url_1.parse)(req.url ?? "/", true);
+        const pathname = url.pathname ?? "/";
+        if (pathname === "/api/health") {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(api.getHealth()));
+            return;
+        }
+        if (pathname === "/api/dashboard") {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(api.getDashboard()));
+            return;
+        }
+        if (pathname === "/api/wrappers") {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(api.getWrappers()));
+            return;
+        }
+        if (pathname.startsWith("/api/wrappers/")) {
+            const id = decodeURIComponent(pathname.split("/").pop() ?? "");
+            const wrapper = api.getWrapper(id);
+            if (!wrapper) {
+                res.writeHead(404, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Wrapper not found" }));
+                return;
+            }
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(wrapper));
+            return;
+        }
+        if (pathname === "/api/servers") {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(api.getServers()));
+            return;
+        }
+        if (pathname.startsWith("/api/servers/")) {
+            const id = decodeURIComponent(pathname.split("/").pop() ?? "");
+            const server = api.getServer(id);
+            if (!server) {
+                res.writeHead(404, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Server not found" }));
+                return;
+            }
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(server));
+            return;
+        }
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Not found" }));
+    });
+}
@@ -0,0 +1,67 @@
+import { IncomingMessage, ServerResponse } from "http";
+import { parse as parseUrl } from "url";
+import { WebApi } from "./api";
+
+export function registerRoutes(server: { on: (event: string, listener: (...args: any[]) => void) => void }, api: WebApi): void {
+    server.on("request", (req: IncomingMessage, res: ServerResponse) => {
+        const url = parseUrl(req.url ?? "/", true);
+        const pathname = url.pathname ?? "/";
+
+        if (pathname === "/api/health") {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(api.getHealth()));
+            return;
+        }
+
+        if (pathname === "/api/dashboard") {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(api.getDashboard()));
+            return;
+        }
+
+        if (pathname === "/api/wrappers") {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(api.getWrappers()));
+            return;
+        }
+
+        if (pathname.startsWith("/api/wrappers/")) {
+            const id = decodeURIComponent(pathname.split("/").pop() ?? "");
+            const wrapper = api.getWrapper(id);
+
+            if (!wrapper) {
+                res.writeHead(404, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Wrapper not found" }));
+                return;
+            }
+
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(wrapper));
+            return;
+        }
+
+        if (pathname === "/api/servers") {
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(api.getServers()));
+            return;
+        }
+
+        if (pathname.startsWith("/api/servers/")) {
+            const id = decodeURIComponent(pathname.split("/").pop() ?? "");
+            const server = api.getServer(id);
+
+            if (!server) {
+                res.writeHead(404, { "Content-Type": "application/json" });
+                res.end(JSON.stringify({ error: "Server not found" }));
+                return;
+            }
+
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(JSON.stringify(server));
+            return;
+        }
+
+        res.writeHead(404, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: "Not found" }));
+    });
+}
@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createWebServer = createWebServer;
+const http_1 = require("http");
+const routes_1 = require("./routes");
+const api_1 = require("./api");
+function createWebServer(deps, port = 3000) {
+    const api = new api_1.WebApi(deps);
+    const server = (0, http_1.createServer)();
+    (0, routes_1.registerRoutes)(server, api);
+    server.listen(port, () => {
+        // no-op: startup is handled by the manager
+    });
+    return server;
+}
@@ -0,0 +1,16 @@
+import { createServer, IncomingMessage, ServerResponse } from "http";
+import { registerRoutes } from "./routes";
+import { WebApi, WebApiDependencies } from "./api";
+
+export function createWebServer(deps: WebApiDependencies, port = 3000) {
+    const api = new WebApi(deps);
+    const server = createServer();
+
+    registerRoutes(server, api);
+
+    server.listen(port, () => {
+        // no-op: startup is handled by the manager
+    });
+
+    return server;
+}
@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
@@ -0,0 +1,59 @@
+export interface HealthResponse {
+    status: string;
+    timestamp: string;
+}
+
+export interface DashboardSummary {
+    managerStatus: string;
+    rabbitMqStatus: string;
+    wrapperCount: number;
+    onlineWrapperCount: number;
+    serverCount: number;
+    runningServerCount: number;
+    totalPlayers: number;
+    totalCapacity: number;
+    utilizationPercent: number;
+    desiredServers: number;
+    activeServers: number;
+}
+
+export interface WrapperSummary {
+    id: string;
+    hostname: string;
+    online: boolean;
+    cpu: number;
+    ram: number;
+    ramFree: number;
+    lastHeartbeat: number;
+    serverCount: number;
+}
+
+export interface WrapperDetail extends WrapperSummary {
+    servers: Array<{
+        id: string;
+        name: string;
+        port: number;
+        queryPort: number;
+        players: number;
+        maxPlayers: number;
+        alive: boolean;
+        started: number;
+    }>;
+}
+
+export interface ServerSummary {
+    id: string;
+    name: string;
+    status: string;
+    wrapperId: string;
+    pid?: number;
+    port: number;
+    queryPort: number;
+    players: number;
+    maxPlayers: number;
+    created: number;
+    startedAt?: number;
+    emptySince?: number;
+}
+
+export type ServerDetail = ServerSummary;
@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WrapperManager = void 0;
+const logger_1 = require("./logger");
+const crypto_1 = require("crypto");
+const logger = (0, logger_1.getLogger)("WrapperManager");
+class WrapperManager {
+    constructor(rabbit, registry, serverRegistry) {
+        this.rabbit = rabbit;
+        this.registry = registry;
+        this.serverRegistry = serverRegistry;
+    }
+    async start() {
+        const queue = "wrapper.register";
+        await this.rabbit.channel.assertQueue(queue);
+        logger.info("Warte auf Wrapper...");
+        this.rabbit.channel.consume(queue, async (msg) => {
+            if (!msg)
+                return;
+            const data = JSON.parse(msg.content.toString());
+            switch (data.type) {
+                case "wrapper.register":
+                    await this.register(data);
+                    break;
+                case "wrapper.heartbeat":
+                    this.heartbeat(data);
+                    break;
+                case "wrapper.status":
+                    logger.debug("Status update received from wrapper-id", data.wrapperId);
+                    this.registry.updateStatus(data);
+                    this.serverRegistry.syncWrapperStatus(data);
+                    break;
+                default:
+                    logger.warn("Unbekannte Nachricht:", data);
+            }
+            this.rabbit.channel.ack(msg);
+        });
+        // Offline Check
+        setInterval(() => {
+            this.registry.checkOffline(30000);
+        }, 5000);
+    }
+    async register(data) {
+        let id = data.wrapperId;
+        /*
+            Neue Wrapper bekommen eine ID
+        */
+        if (!id) {
+            id =
+                "wrp-" +
+                    (0, crypto_1.randomUUID)()
+                        .slice(0, 8);
+            logger.debug("Neue Wrapper ID:", id);
+        }
+        const existing = this.registry.get(id);
+        /*
+            Wrapper war schon bekannt
+        */
+        if (existing) {
+            existing.online = true;
+            existing.lastHeartbeat =
+                Date.now();
+            existing.hostname =
+                data.hostname;
+            existing.cpu =
+                data.cpu;
+            existing.ram =
+                data.ram;
+            existing.ramFree =
+                data.ram;
+            // servers are updated via wrapper.status, not wrapper.register
+            this.registry.update(existing);
+        }
+        /*
+            Neuer Wrapper
+        */
+        else {
+            const commandQueue = `wrapper.${id}.commands`;
+            await this.rabbit.channel.assertQueue(commandQueue);
+            const wrapper = {
+                id,
+                hostname: data.hostname,
+                commandQueue,
+                cpu: data.cpu,
+                ram: data.ram,
+                ramFree: data.ram,
+                servers: [],
+                online: true,
+                lastHeartbeat: Date.now()
+            };
+            this.registry.add(wrapper);
+        }
+        /*
+            Antwort zurück an Wrapper
+        */
+        const wrapper = this.registry.get(id);
+        if (data.replyQueue) {
+            this.rabbit.channel.sendToQueue(data.replyQueue, Buffer.from(JSON.stringify({
+                type: "wrapper.registered",
+                wrapperId: id,
+                commandQueue: wrapper?.commandQueue
+            })));
+        }
+    }
+    heartbeat(data) {
+        this.registry.updateHeartbeat(data.wrapperId);
+        logger.debug("Heartbeat:", data.wrapperId);
+    }
+    sendCommand(wrapperId, command) {
+        const wrapper = this.registry.get(wrapperId);
+        if (!wrapper) {
+            throw new Error("Wrapper nicht gefunden");
+        }
+        this.rabbit.channel.sendToQueue(wrapper.commandQueue, Buffer.from(JSON.stringify(command)));
+    }
+    getWrappers() {
+        return this.registry.getAll();
+    }
+    listWrappers() {
+        const wrappers = this.registry.getAll();
+        logger.info("Wrapper Übersicht ausgegeben");
+        if (wrappers.length === 0) {
+            logger.info("Keine Wrapper registriert");
+            return;
+        }
+        for (const wrapper of wrappers) {
+            logger.info(`
+
+ID:
+${wrapper.id}
+
+
+Host:
+${wrapper.hostname}
+
+
+CPU:
+${wrapper.cpu} Cores
+
+
+RAM:
+${wrapper.ram} MB
+
+
+RAM frei:
+${wrapper.ramFree} MB
+
+
+Server:
+${wrapper.servers.length}
+
+
+Online:
+${wrapper.online}
+
+
+Heartbeat:
+${new Date(wrapper.lastHeartbeat).toLocaleString()}
+
+
+----------------------
+
+`);
+        }
+    }
+}
+exports.WrapperManager = WrapperManager;
@@ -1,3 +1,4 @@
+import { getLogger } from "./logger";
 import { Rabbit } from "./rabbit";
 import { randomUUID } from "crypto";
 import { WrapperRegistry, WrapperInfo } from "./wrapperRegistry";
@@ -15,6 +16,8 @@ type WrapperMessage =
  | WrapperHeartbeatMessage
  | WrapperStatusMessage;

+const logger = getLogger("WrapperManager");
+

 export class WrapperManager {

@@ -43,7 +46,7 @@ export class WrapperManager {



-        console.log(
+        logger.info(
            "Warte auf Wrapper..."
        );

@@ -99,7 +102,12 @@ export class WrapperManager {
                    case "wrapper.status":


-                        this.registry.updateStatus(
+                        logger.debug(
+                        "Status update received from wrapper-id",
+                        data.wrapperId
+                    );
+
+                    this.registry.updateStatus(
                            data
                        );

@@ -115,7 +123,7 @@ export class WrapperManager {
                    default:


-                        console.log(
+logger.warn(
                            "Unbekannte Nachricht:",
                            data
                        );
@@ -185,7 +193,7 @@ export class WrapperManager {



-            console.log(
+            logger.debug(
                "Neue Wrapper ID:",
                id
            );
@@ -414,7 +422,7 @@ export class WrapperManager {



-        console.log(
+        logger.debug(

            "Heartbeat:",

@@ -523,23 +531,9 @@ export class WrapperManager {



-        console.log(
+        logger.info(

-            "\n======================"
-
-        );
-
-
-        console.log(
-
-            " WRAPPER ÜBERSICHT "
-
-        );
-
-
-        console.log(
-
-            "======================\n"
+            "Wrapper Übersicht ausgegeben"

        );

@@ -550,7 +544,7 @@ export class WrapperManager {
        if(wrappers.length===0){


-            console.log(
+            logger.info(

                "Keine Wrapper registriert"

@@ -571,7 +565,7 @@ export class WrapperManager {



-            console.log(`
+            logger.info(`

 ID:
 ${wrapper.id}
@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WrapperRegistry = void 0;
+const logger_1 = require("./logger");
+const jsonFileStore_1 = require("./persistence/jsonFileStore");
+const logger = (0, logger_1.getLogger)("WrapperRegistry");
+class WrapperRegistry {
+    constructor() {
+        this.wrappers = new Map();
+        this.persistence = new jsonFileStore_1.JsonFileStore("wrapperRegistry-state.json");
+    }
+    async init() {
+        const state = await this.persistence.load();
+        if (!state)
+            return;
+        for (const wrapperData of state.wrappers) {
+            this.wrappers.set(wrapperData.id, {
+                id: wrapperData.id,
+                hostname: wrapperData.hostname,
+                commandQueue: wrapperData.commandQueue,
+                cpu: wrapperData.cpu,
+                ram: wrapperData.ram,
+                ramFree: wrapperData.ram,
+                online: false,
+                lastHeartbeat: 0,
+                servers: []
+            });
+        }
+    }
+    toState() {
+        return {
+            wrappers: Array.from(this.wrappers.values()).map(wrapper => ({
+                id: wrapper.id,
+                hostname: wrapper.hostname,
+                commandQueue: wrapper.commandQueue,
+                cpu: wrapper.cpu,
+                ram: wrapper.ram
+            }))
+        };
+    }
+    async saveState() {
+        await this.persistence.save(this.toState());
+    }
+    add(wrapper) {
+        this.wrappers.set(wrapper.id, wrapper);
+        logger.info("Wrapper added:", wrapper.id);
+        void this.saveState();
+    }
+    get(id) {
+        return this.wrappers.get(id);
+    }
+    getAll() {
+        return Array.from(this.wrappers.values());
+    }
+    updateHeartbeat(id) {
+        const wrapper = this.wrappers.get(id);
+        if (!wrapper)
+            return;
+        wrapper.lastHeartbeat =
+            Date.now();
+        wrapper.online =
+            true;
+    }
+    update(wrapper) {
+        this.wrappers.set(wrapper.id, wrapper);
+        void this.saveState();
+    }
+    checkOffline(timeout) {
+        const now = Date.now();
+        for (const wrapper of this.wrappers.values()) {
+            if (wrapper.online &&
+                now - wrapper.lastHeartbeat > timeout) {
+                wrapper.online = false;
+                logger.warn("Wrapper offline:", wrapper.id);
+            }
+        }
+    }
+    updateStatus(data) {
+        const wrapper = this.wrappers.get(data.wrapperId);
+        if (!wrapper)
+            return;
+        wrapper.ramFree =
+            data.ramFree;
+        wrapper.servers =
+            data.servers;
+        wrapper.lastHeartbeat =
+            Date.now();
+        wrapper.online =
+            true;
+    }
+}
+exports.WrapperRegistry = WrapperRegistry;
@@ -1,3 +1,9 @@
+import { getLogger } from "./logger";
+import { WrapperStatusMessage } from "server-manager-shared";
+import { JsonFileStore } from "./persistence/jsonFileStore";
+
+const logger = getLogger("WrapperRegistry");
+
 export interface WrapperInfo {

    id:string;
@@ -19,39 +25,95 @@ export interface WrapperInfo {
    lastHeartbeat:number;


-    servers:string[];
+    servers: WrapperStatusMessage["servers"];

 }

+interface WrapperRegistryState {
+    wrappers: Array<{
+        id:string;
+        hostname:string;
+        commandQueue:string;
+        cpu:number;
+        ram:number;
+    }>;
+}
+




 export class WrapperRegistry {

-
    private wrappers =
        new Map<string, WrapperInfo>();

+    private readonly persistence =
+        new JsonFileStore<WrapperRegistryState>(
+            "wrapperRegistry-state.json"
+        );




+
+    async init(): Promise<void> {
+        const state = await this.persistence.load();
+
+        if (!state)
+            return;
+
+        for (const wrapperData of state.wrappers) {
+            this.wrappers.set(
+                wrapperData.id,
+                {
+                    id: wrapperData.id,
+                    hostname: wrapperData.hostname,
+                    commandQueue: wrapperData.commandQueue,
+                    cpu: wrapperData.cpu,
+                    ram: wrapperData.ram,
+                    ramFree: wrapperData.ram,
+                    online: false,
+                    lastHeartbeat: 0,
+                    servers: []
+                }
+            );
+        }
+    }
+
+    private toState(): WrapperRegistryState {
+        return {
+            wrappers: Array.from(this.wrappers.values()).map(
+                wrapper => ({
+                    id: wrapper.id,
+                    hostname: wrapper.hostname,
+                    commandQueue: wrapper.commandQueue,
+                    cpu: wrapper.cpu,
+                    ram: wrapper.ram
+                })
+            )
+        };
+    }
+
+    private async saveState(): Promise<void> {
+        await this.persistence.save(
+            this.toState()
+        );
+    }
+
    add(wrapper:WrapperInfo){

-
        this.wrappers.set(
            wrapper.id,
            wrapper
        );

-
-        console.log(
-            "Wrapper gespeichert:",
+        logger.info(
+            "Wrapper added:",
            wrapper.id
        );

-
+        void this.saveState();
    }


@@ -108,13 +170,12 @@ export class WrapperRegistry {

    update(wrapper:WrapperInfo){

-
        this.wrappers.set(
            wrapper.id,
            wrapper
        );

-
+        void this.saveState();
    }


@@ -138,7 +199,7 @@ export class WrapperRegistry {
                wrapper.online = false;


-                console.log(
+                logger.warn(
                    "Wrapper offline:",
                    wrapper.id
                );
@@ -152,8 +213,7 @@ export class WrapperRegistry {

    }

-    updateStatus(data:any){
-
+    updateStatus(data: WrapperStatusMessage){

        const wrapper =
            this.wrappers.get(
@@ -5,6 +5,9 @@
    "moduleResolution": "node",
    "esModuleInterop": true,
    "strict": true,
-    "skipLibCheck": true
+    "skipLibCheck": true,
+    "types": [
+      "node"
+    ]
  }
-}
+}
@@ -0,0 +1,11 @@
+{
+    "wrappers": [
+        {
+            "id": "wrp-8adcbbf2",
+            "hostname": "anjuma-int-01",
+            "commandQueue": "wrapper.wrp-8adcbbf2.commands",
+            "cpu": 12,
+            "ram": 7932
+        }
+    ]
+}
@@ -4,6 +4,10 @@
    "workspaces": [
        "manager",
        "wrapper",
-        "shared"
-    ]
+        "shared",
+        "dashboard"
+    ],
+    "allowScripts": {
+        "esbuild@0.21.5": true
+    }
 }
@@ -7,6 +7,7 @@
    "build": "tsc -p tsconfig.json"
  },
  "devDependencies": {
-    "typescript": "^7.0.2"
+    "@types/node": "^26.1.1",
+    "typescript": "^5.7.3"
  }
 }
@@ -28,3 +28,9 @@ export interface WrapperStatusMessage {
  }>;
  ramFree: number;
 }
+
+export interface WrapperRegisteredMessage {
+  type: "wrapper.registered";
+  wrapperId: string;
+  commandQueue: string;
+}
@@ -8,7 +8,12 @@
    "rootDir": "src",
    "strict": true,
    "esModuleInterop": true,
-    "skipLibCheck": true
+    "skipLibCheck": true,
+    "types": [
+      "node"
+    ]
  },
-  "include": ["src"]
-}
+  "include": [
+    "src"
+  ]
+}
@@ -4,7 +4,8 @@
  "description": "",
  "main": "index.js",
  "scripts": {
-    "start": "ts-node src/index.ts"
+    "start": "ts-node src/index.ts",
+    "build": "tsc -p tsconfig.json"
  },
  "keywords": [],
  "author": "",
@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SERVER_WORKING_DIRECTORY = exports.SERVER_SCRIPT_PATH = exports.WRAPPER_QUERY_INTERVAL = exports.WRAPPER_STATUS_INTERVAL = exports.WRAPPER_HEARTBEAT_INTERVAL = exports.RABBITMQ_URL = void 0;
+exports.loadConfig = loadConfig;
+exports.saveConfig = saveConfig;
+const fs_1 = __importDefault(require("fs"));
+const FILE = "./config.json";
+exports.RABBITMQ_URL = "amqp://manager:gigi1337@192.168.1.74";
+exports.WRAPPER_HEARTBEAT_INTERVAL = 10000;
+exports.WRAPPER_STATUS_INTERVAL = 10000;
+exports.WRAPPER_QUERY_INTERVAL = 5000;
+exports.SERVER_SCRIPT_PATH = "/home/heroes/HeroesOfValorServer.sh";
+exports.SERVER_WORKING_DIRECTORY = "/home/heroes";
+function loadConfig() {
+    if (!fs_1.default.existsSync(FILE)) {
+        return {};
+    }
+    return JSON.parse(fs_1.default.readFileSync(FILE, "utf-8"));
+}
+function saveConfig(config) {
+    fs_1.default.writeFileSync(FILE, JSON.stringify(config, null, 4));
+}
@@ -10,6 +10,12 @@ export interface WrapperConfig {

 }

+export const RABBITMQ_URL = "amqp://manager:gigi1337@192.168.1.74";
+export const WRAPPER_HEARTBEAT_INTERVAL = 10000;
+export const WRAPPER_STATUS_INTERVAL = 10000;
+export const WRAPPER_QUERY_INTERVAL = 5000;
+export const SERVER_SCRIPT_PATH = "/home/heroes/HeroesOfValorServer.sh";
+export const SERVER_WORKING_DIRECTORY = "/home/heroes";


 export function loadConfig(): WrapperConfig {
@@ -0,0 +1,155 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const amqp = __importStar(require("amqplib"));
+const os_1 = __importDefault(require("os"));
+const config_1 = require("./config");
+const processManager_1 = require("./processManager");
+const statusReporter_1 = require("./statusReporter");
+const queryManager_1 = require("./queryManager");
+const logger_1 = require("./logger");
+const logger = (0, logger_1.getLogger)("Wrapper");
+class Wrapper {
+    constructor() {
+        this.processManager = new processManager_1.ProcessManager();
+        this.queryManager = new queryManager_1.QueryManager(this.processManager);
+    }
+    async start() {
+        const config = (0, config_1.loadConfig)();
+        logger.info("Konfiguration geladen");
+        if (config.wrapperId) {
+            this.id =
+                config.wrapperId;
+            logger.debug("Starte mit vorhandener ID:", this.id);
+        }
+        else {
+            logger.warn("Keine Wrapper ID vorhanden - neue Registrierung");
+        }
+        this.connection =
+            await amqp.connect(config_1.RABBITMQ_URL);
+        this.channel =
+            await this.connection.createChannel();
+        logger.info("RabbitMQ Verbindung hergestellt");
+        this.queryManager.start();
+        await this.register();
+    }
+    async register() {
+        const reply = await this.channel.assertQueue("", {
+            exclusive: true
+        });
+        const replyQueue = reply.queue;
+        await this.channel.consume(replyQueue, msg => {
+            if (!msg)
+                return;
+            const data = JSON.parse(msg.content.toString());
+            logger.debug("Antwort vom Manager:", data.type);
+            if (data.type === "wrapper.registered") {
+                this.id =
+                    data.wrapperId;
+                (0, config_1.saveConfig)({
+                    wrapperId: this.id
+                });
+                logger.info("Registrierung beim Manager erfolgreich");
+                logger.debug("Wrapper ID gespeichert:", this.id);
+                if (!this.id) {
+                    logger.error("Keine Wrapper ID erhalten!");
+                    return;
+                }
+                this.listenCommands(data.commandQueue);
+                const reporter = new statusReporter_1.StatusReporter(this.channel, this.processManager, this.queryManager, this.id);
+                reporter.start();
+            }
+            this.channel.ack(msg);
+        });
+        const message = {
+            type: "wrapper.register",
+            // vorhandene ID mitsenden
+            wrapperId: this.id,
+            hostname: os_1.default.hostname(),
+            cpu: os_1.default.cpus().length,
+            ram: Math.round(os_1.default.totalmem() / 1024 / 1024),
+            replyQueue
+        };
+        await this.channel.sendToQueue("wrapper.register", Buffer.from(JSON.stringify(message)));
+        logger.debug("Registrierung gesendet", this.id ?? "ohne ID");
+    }
+    async listenCommands(queue) {
+        await this.channel.consume(queue, msg => {
+            if (!msg)
+                return;
+            const rawCommand = JSON.parse(msg.content.toString());
+            const commandType = rawCommand.type;
+            switch (commandType) {
+                case "test": {
+                    const command = rawCommand;
+                    logger.debug("TEST COMMAND:", command.message);
+                    break;
+                }
+                case "server.start": {
+                    const command = rawCommand;
+                    this.processManager.startServer(command);
+                    break;
+                }
+                case "server.stop": {
+                    const command = rawCommand;
+                    this.processManager.stopServer(command.serverId);
+                    break;
+                }
+                default:
+                    logger.warn("Unbekannter Command:", commandType);
+            }
+            this.channel.ack(msg);
+        });
+        logger.debug("Warte auf Commands:", queue);
+        this.heartbeat();
+    }
+    heartbeat() {
+        logger.debug("Heartbeat gestartet");
+        setInterval(() => {
+            if (!this.id)
+                return;
+            const heartbeat = {
+                type: "wrapper.heartbeat",
+                wrapperId: this.id
+            };
+            this.channel.sendToQueue("wrapper.register", Buffer.from(JSON.stringify(heartbeat)));
+            logger.debug("Heartbeat gesendet");
+        }, config_1.WRAPPER_HEARTBEAT_INTERVAL);
+    }
+}
+new Wrapper().start();
@@ -1,6 +1,6 @@
 import * as amqp from "amqplib";
 import os from "os";
-import { loadConfig, saveConfig } from "./config";
+import { loadConfig, saveConfig, RABBITMQ_URL, WRAPPER_HEARTBEAT_INTERVAL } from "./config";
 import { ProcessManager } from "./processManager";
 import { StatusReporter } from "./statusReporter";
 import { QueryManager } from "./queryManager";
@@ -10,6 +10,9 @@ import {
  ServerStartCommand,
  ServerStopCommand
 } from "server-manager-shared";
+import { getLogger } from "./logger";
+
+const logger = getLogger("Wrapper");


 class Wrapper {
@@ -36,6 +39,7 @@ class Wrapper {
        const config =
            loadConfig();

+        logger.info("Konfiguration geladen");


        if(config.wrapperId){
@@ -46,7 +50,7 @@ class Wrapper {



-            console.log(
+            logger.debug(
                "Starte mit vorhandener ID:",
                this.id
            );
@@ -55,7 +59,7 @@ class Wrapper {
        }else{


-            console.log(
+            logger.warn(
                "Keine Wrapper ID vorhanden - neue Registrierung"
            );

@@ -67,7 +71,7 @@ class Wrapper {

        this.connection =
            await amqp.connect(
-                "amqp://manager:gigi1337@192.168.1.74"
+                RABBITMQ_URL
            );


@@ -77,8 +81,8 @@ class Wrapper {



-        console.log(
-            "RabbitMQ verbunden"
+        logger.info(
+            "RabbitMQ Verbindung hergestellt"
        );


@@ -136,9 +140,9 @@ class Wrapper {



-                console.log(
+                logger.debug(
                    "Antwort vom Manager:",
-                    data
+                    data.type
                );


@@ -162,14 +166,17 @@ class Wrapper {



-                    console.log(
+                    logger.info(
+                        "Registrierung beim Manager erfolgreich"
+                    );
+                    logger.debug(
                        "Wrapper ID gespeichert:",
                        this.id
                    );

                    if(!this.id){

-                        console.error(
+                        logger.error(
                            "Keine Wrapper ID erhalten!"
                        );

@@ -272,7 +279,7 @@ class Wrapper {



-        console.log(
+        logger.debug(
            "Registrierung gesendet",
            this.id ?? "ohne ID"
        );
@@ -301,63 +308,64 @@ class Wrapper {



-                const command =
+                const rawCommand =
                    JSON.parse(
                        msg.content.toString()
-                    ) as ServerStartCommand | ServerStopCommand | {
-                        type: string;
-                        [key: string]: unknown;
-                    };
+                    ) as unknown;



-                switch(command.type){
+                const commandType = (rawCommand as { type?: string }).type;
+                switch(commandType){



-                    case "test":
+                    case "test": {
+                        const command = rawCommand as {
+                            type: string;
+                            message?: unknown;
+                        };

-
-                        console.log(
+                        logger.debug(
                            "TEST COMMAND:",
                            command.message
                        );

-
                        break;
+                    }





-                    case "server.start":
-
+                    case "server.start": {
+                        const command = rawCommand as ServerStartCommand;

                        this.processManager.startServer(
                            command
                        );

-
                        break;
+                    }


-                    case "server.stop":
-
+                    case "server.stop": {
+                        const command = rawCommand as ServerStopCommand;

                        this.processManager.stopServer(
                            command.serverId
                        );

-
                        break;
+                    }


                    default:


-                        console.log(
+                        logger.warn(
                            "Unbekannter Command:",
-                            command
+                            commandType
                        );


@@ -375,7 +383,7 @@ class Wrapper {



-        console.log(
+        logger.debug(
            "Warte auf Commands:",
            queue
        );
@@ -391,7 +399,7 @@ class Wrapper {

    heartbeat(){

-        console.log("Heartbeat gestartet");
+        logger.debug("Heartbeat gestartet");
        setInterval(()=>{


@@ -437,13 +445,13 @@ class Wrapper {



-            console.log(
+            logger.debug(
                "Heartbeat gesendet"
            );



-        },10000);
+},WRAPPER_HEARTBEAT_INTERVAL);


    }
@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getLogger = getLogger;
+const LEVELS = {
+    DEBUG: 0,
+    INFO: 1,
+    WARN: 2,
+    ERROR: 3,
+};
+const DEFAULT_LOG_LEVEL = "INFO";
+const configuredLevel = (process.env.LOG_LEVEL ?? "").toUpperCase();
+const currentLogLevel = configuredLevel in LEVELS ? configuredLevel : DEFAULT_LOG_LEVEL;
+const currentLogLevelValue = LEVELS[currentLogLevel];
+function shouldLog(level) {
+    return LEVELS[level] >= currentLogLevelValue;
+}
+function formatMessage(level, component, message) {
+    return `${new Date().toISOString()} ${level} [${component}] ${message}`;
+}
+class Logger {
+    constructor(component) {
+        this.component = component;
+    }
+    debug(message, ...args) {
+        if (!shouldLog("DEBUG"))
+            return;
+        console.log(formatMessage("DEBUG", this.component, message), ...args);
+    }
+    info(message, ...args) {
+        if (!shouldLog("INFO"))
+            return;
+        console.log(formatMessage("INFO", this.component, message), ...args);
+    }
+    warn(message, ...args) {
+        if (!shouldLog("WARN"))
+            return;
+        console.warn(formatMessage("WARN", this.component, message), ...args);
+    }
+    error(message, ...args) {
+        if (!shouldLog("ERROR"))
+            return;
+        console.error(formatMessage("ERROR", this.component, message), ...args);
+    }
+}
+function getLogger(component) {
+    return new Logger(component);
+}
@@ -0,0 +1,62 @@
+declare const process: {
+  env: Record<string, string | undefined>;
+};
+
+type LogLevel = "DEBUG" | "INFO" | "WARN" | "ERROR";
+
+const LEVELS: Record<LogLevel, number> = {
+  DEBUG: 0,
+  INFO: 1,
+  WARN: 2,
+  ERROR: 3,
+};
+
+const DEFAULT_LOG_LEVEL: LogLevel = "INFO";
+
+const configuredLevel =
+  (process.env.LOG_LEVEL ?? "").toUpperCase() as LogLevel;
+
+const currentLogLevel: LogLevel =
+  configuredLevel in LEVELS ? configuredLevel : DEFAULT_LOG_LEVEL;
+
+const currentLogLevelValue = LEVELS[currentLogLevel];
+
+function shouldLog(level: LogLevel): boolean {
+  return LEVELS[level] >= currentLogLevelValue;
+}
+
+function formatMessage(
+  level: LogLevel,
+  component: string,
+  message: unknown
+): string {
+  return `${new Date().toISOString()} ${level} [${component}] ${message}`;
+}
+
+class Logger {
+  constructor(private component: string) {}
+
+  debug(message: unknown, ...args: unknown[]): void {
+    if (!shouldLog("DEBUG")) return;
+    console.log(formatMessage("DEBUG", this.component, message), ...args);
+  }
+
+  info(message: unknown, ...args: unknown[]): void {
+    if (!shouldLog("INFO")) return;
+    console.log(formatMessage("INFO", this.component, message), ...args);
+  }
+
+  warn(message: unknown, ...args: unknown[]): void {
+    if (!shouldLog("WARN")) return;
+    console.warn(formatMessage("WARN", this.component, message), ...args);
+  }
+
+  error(message: unknown, ...args: unknown[]): void {
+    if (!shouldLog("ERROR")) return;
+    console.error(formatMessage("ERROR", this.component, message), ...args);
+  }
+}
+
+export function getLogger(component: string): Logger {
+  return new Logger(component);
+}
@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProcessManager = void 0;
+const child_process_1 = require("child_process");
+const config_1 = require("./config");
+const logger_1 = require("./logger");
+const logger = (0, logger_1.getLogger)("ProcessManager");
+class ProcessManager {
+    constructor() {
+        this.processes = new Map();
+    }
+    startServer(data) {
+        logger.debug("Starte Game Server:", data.name);
+        const args = [
+            `-Port=${data.port}`,
+            `-QueryPort=${data.queryPort}`,
+            `-ServerName=${data.name}`
+        ];
+        const process = (0, child_process_1.spawn)(config_1.SERVER_SCRIPT_PATH, args, {
+            cwd: config_1.SERVER_WORKING_DIRECTORY,
+            stdio: "pipe",
+            detached: true
+        });
+        process.stdout?.on("data", data => {
+            logger.debug(`[${data.name}]`, data.toString());
+        });
+        process.stderr?.on("data", data => {
+            logger.error("SERVER ERROR:", data.toString());
+        });
+        process.on("exit", code => {
+            const server = this.processes.get(data.serverId);
+            if (server) {
+                logger.info("Server beendet:", server.name, code);
+                this.processes.delete(data.serverId);
+            }
+        });
+        this.processes.set(data.serverId, {
+            id: data.serverId,
+            name: data.name,
+            port: data.port,
+            queryPort: data.queryPort,
+            process,
+            started: Date.now(),
+            alive: true,
+            players: 0,
+            maxPlayers: 0
+        });
+        logger.info("Server gestartet:", {
+            id: data.serverId,
+            pid: process.pid
+        });
+    }
+    stopServer(id) {
+        const server = this.processes.get(id);
+        if (!server) {
+            logger.warn("Server nicht gefunden:", id);
+            return;
+        }
+        logger.debug("Stoppe Server:", server.name);
+        process.kill(-server.process.pid, "SIGTERM");
+    }
+    getServers() {
+        return Array.from(this.processes.values());
+    }
+    getStatus() {
+        return Array.from(this.processes.values()).map(server => ({
+            id: server.id,
+            name: server.name,
+            port: server.port,
+            queryPort: server.queryPort,
+            pid: server.process.pid,
+            alive: server.alive,
+            players: server.players,
+            maxPlayers: server.maxPlayers,
+            started: server.started
+        }));
+    }
+}
+exports.ProcessManager = ProcessManager;
@@ -1,5 +1,9 @@
 import { spawn, ChildProcess } from "child_process";
+import { ServerStartCommand } from "server-manager-shared";
+import { SERVER_SCRIPT_PATH, SERVER_WORKING_DIRECTORY } from "./config";
+import { getLogger } from "./logger";

+const logger = getLogger("ProcessManager");


 interface ServerProcess {
@@ -45,7 +49,7 @@ export class ProcessManager {



-        console.log(
+        logger.debug(
            "Starte Game Server:",
            data.name
        );
@@ -68,10 +72,10 @@ export class ProcessManager {


        const process = spawn(
-            "/home/heroes/HeroesOfValorServer.sh",
+            SERVER_SCRIPT_PATH,
            args,
            {
-                cwd:"/home/heroes",
+                cwd: SERVER_WORKING_DIRECTORY,
                stdio:"pipe",
                detached:true
            }
@@ -88,11 +92,9 @@ export class ProcessManager {
            data=>{


-                console.log(
-
+                logger.debug(
                    `[${data.name}]`,
                    data.toString()
-
                );


@@ -111,7 +113,7 @@ export class ProcessManager {
            data=>{


-                console.error(
+                logger.error(

                    "SERVER ERROR:",
                    data.toString()
@@ -140,7 +142,7 @@ export class ProcessManager {
            if(server){


-                console.log(
+                logger.info(
                    "Server beendet:",
                    server.name,
                    code
@@ -198,18 +200,12 @@ export class ProcessManager {



-        console.log(
-
+        logger.info(
            "Server gestartet:",
-
            {
-
                id:data.serverId,
-
                pid:process.pid
-
            }
-
        );


@@ -237,7 +233,7 @@ export class ProcessManager {
        if(!server){


-            console.log(
+            logger.warn(

                "Server nicht gefunden:",

@@ -255,12 +251,9 @@ export class ProcessManager {



-        console.log(
-
+        logger.debug(
            "Stoppe Server:",
-
            server.name
-
        );


@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QueryManager = void 0;
+const steam_server_query_1 = require("steam-server-query");
+const config_1 = require("./config");
+const logger_1 = require("./logger");
+const logger = (0, logger_1.getLogger)("QueryManager");
+class QueryManager {
+    constructor(processManager) {
+        this.processManager = processManager;
+    }
+    start() {
+        logger.debug("Query Manager gestartet");
+        setInterval(() => {
+            this.updateQueries();
+        }, config_1.WRAPPER_QUERY_INTERVAL);
+    }
+    async updateQueries() {
+        const servers = this.processManager.getServers();
+        for (const server of servers) {
+            try {
+                const info = await (0, steam_server_query_1.queryGameServerInfo)(`127.0.0.1:${server.queryPort}`);
+                server.players =
+                    info.players;
+                server.maxPlayers =
+                    info.maxPlayers;
+                logger.debug("Query erfolgreich:", server.name, `${server.players}/${server.maxPlayers}`);
+            }
+            catch (err) {
+                logger.warn("Query fehlgeschlagen:", server.name);
+            }
+        }
+    }
+    getStatus() {
+        return this.processManager
+            .getServers()
+            .map(server => ({
+            id: server.id,
+            players: server.players,
+            maxPlayers: server.maxPlayers
+        }));
+    }
+}
+exports.QueryManager = QueryManager;
@@ -1,6 +1,9 @@
 import { queryGameServerInfo  } from "steam-server-query";
 import { ProcessManager } from "./processManager";
+import { WRAPPER_QUERY_INTERVAL } from "./config";
+import { getLogger } from "./logger";

+const logger = getLogger("QueryManager");

 export class QueryManager {

@@ -15,7 +18,7 @@ export class QueryManager {
    start(){


-        console.log(
+        logger.debug(
            "Query Manager gestartet"
        );

@@ -27,7 +30,7 @@ export class QueryManager {
            this.updateQueries();


-        },5000);
+        },WRAPPER_QUERY_INTERVAL);


    }
@@ -72,12 +75,10 @@ export class QueryManager {



-                console.log(
-
-                    "Query:",
+                logger.debug(
+                    "Query erfolgreich:",
                    server.name,
                    `${server.players}/${server.maxPlayers}`
-
                );


@@ -85,11 +86,9 @@ export class QueryManager {
            catch(err){


-                console.log(
-
+                logger.warn(
                    "Query fehlgeschlagen:",
                    server.name
-
                );


@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StatusReporter = void 0;
+const os_1 = __importDefault(require("os"));
+const config_1 = require("./config");
+const logger_1 = require("./logger");
+const logger = (0, logger_1.getLogger)("StatusReporter");
+class StatusReporter {
+    constructor(channel, processManager, queryManager, wrapperId) {
+        this.channel = channel;
+        this.processManager = processManager;
+        this.queryManager = queryManager;
+        this.wrapperId = wrapperId;
+    }
+    start() {
+        logger.debug("Status Reporter gestartet");
+        setInterval(() => {
+            this.sendStatus();
+        }, config_1.WRAPPER_STATUS_INTERVAL);
+    }
+    sendStatus() {
+        const processes = this.processManager.getStatus();
+        const queries = this.queryManager.getStatus();
+        const servers = processes.map(server => {
+            const query = queries.find((q) => q.id === server.id);
+            return {
+                ...server,
+                players: query?.players ?? 0,
+                maxPlayers: query?.maxPlayers ?? 0
+            };
+        });
+        const status = {
+            type: "wrapper.status",
+            wrapperId: this.wrapperId,
+            servers,
+            ramFree: Math.round(os_1.default.freemem()
+                /
+                    1024
+                /
+                    1024)
+        };
+        this.channel.sendToQueue("wrapper.register", Buffer.from(JSON.stringify(status)));
+        logger.debug("Status gesendet:", servers.length, "Server");
+    }
+}
+exports.StatusReporter = StatusReporter;
@@ -3,8 +3,10 @@ import { ProcessManager } from "./processManager";
 import os from "os";
 import { QueryManager } from "./queryManager";
 import { WrapperStatusMessage } from "server-manager-shared";
+import { WRAPPER_STATUS_INTERVAL } from "./config";
+import { getLogger } from "./logger";

-
+const logger = getLogger("StatusReporter");

 export class StatusReporter {

@@ -25,7 +27,7 @@ export class StatusReporter {

    start(){

-        console.log(
+        logger.debug(
            "Status Reporter gestartet"
        );

@@ -36,7 +38,7 @@ export class StatusReporter {
            this.sendStatus();


-        },10000);
+        },WRAPPER_STATUS_INTERVAL);


    }
@@ -147,12 +149,9 @@ export class StatusReporter {



-        console.log(
-
+        logger.debug(
            "Status gesendet:",
-
            servers.length,
-
            "Server"

        );
Author	SHA1	Message	Date
xBeaTz	57d63f5bf4	initial import server-manager	2026-07-22 00:12:44 +02:00
xBeaTz	8354d94cbc	feat: improve manager recovery and expose server pid in dashboard	2026-07-21 20:45:40 +02:00
xBeaTz	268734275a	fix: prevent stopped servers from returning to running state	2026-07-21 19:38:11 +02:00
xBeaTz	984992541c	fix: preserve server startedAt from wrapper status	2026-07-21 19:29:06 +02:00
xBeaTz	6d22275a1f	Add persistence, lifecycle improvements, logging and typescript fixes	2026-07-21 14:49:09 +02:00
xBeaTz	4855bb882c	chore: stabilize monorepo build and typescript setup	2026-07-20 21:54:36 +02:00
xBeaTz	5fd48d1971	refactor: add persistence groundwork and structured logging	2026-07-20 21:48:08 +02:00
xBeaTz	7dde7378b8	Extract configuration from manager and wrapper	2026-07-20 19:40:00 +02:00
xBeaTz	3827f803c5	Complete shared message type migration	2026-07-20 19:27:36 +02:00
xBeaTz	e93524c403	Complete wrapper migration to shared message types	2026-07-20 19:18:58 +02:00
				`@@ -0,0 +1 @@`
				`{"root":["./src/main.tsx","./src/api/client.ts","./src/components/layout.tsx","./src/components/pagestate.tsx","./src/components/statusbadge.tsx","./src/pages/dashboard.tsx","./src/pages/serverdetail.tsx","./src/pages/servers.tsx","./src/pages/wrapperdetail.tsx","./src/pages/wrappers.tsx"],"version":"5.9.3"}`