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(
+        logger.debug(
-            "Command gesendet:",
+            "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");
-
+    void webServer;
    console.log(
        "Manager gestartet"
    );
 }
-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
    ){
-
+        const removedPort = this.usedPorts.delete(
        this.usedPorts.delete(
            port
        );
-
+        const removedQueryPort = this.usedQueryPorts.delete(
        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(
+        logger.info(
-            "RabbitMQ verbunden"
+            "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
                            );
-
+                            logger.debug(
                            console.log(
                                "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.crashedAt =
-                        "Server abgestürzt erkannt:",
+                            Date.now();
-                        server.name
+
-                    );
+                        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(
+            logger.warn(
-                "Server nicht gefunden:",
+                "Server not found:",
                serverId
            );
@@ -251,8 +254,8 @@ export class ServerManager {
        if(!wrapper){
-            console.log(
+            logger.warn(
-                "Wrapper nicht gefunden:",
+                "Wrapper not found:",
                server.wrapperId
            );
@@ -298,9 +301,9 @@ export class ServerManager {
-        console.log(
+        logger.info(
-            "Server Stop gesendet:",
+            "Stopping server:",
-            server.name
+            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(
+        logger.info(
-            "Server registriert:",
+            "Server added:",
-            server
+            server.id
        );
        this.persist();
    }
@@ -126,6 +204,7 @@ export class ServerRegistry {
        );
        this.persist();
    }
@@ -142,12 +221,13 @@ export class ServerRegistry {
        );
-        console.log(
+        logger.info(
-            "Server entfernt:",
+            "Server removed:",
            id
        );
        this.persist();
    }
@@ -160,8 +240,8 @@ export class ServerRegistry {
    list(){
-        console.log(
+        logger.info(
-            "\n=== SERVER ÜBERSICHT ==="
+            "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(
+                logger.debug(
-                    "Server sauber beendet:",
+                    "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(
+                logger.warn(
-                    "Server abgestürzt:",
+                    "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(
+            logger.debug(
-                "Status Änderung:",
+                "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======================"
+            "Wrapper Übersicht ausgegeben"
        );
        console.log(
            " WRAPPER ÜBERSICHT "
        );
        console.log(
            "======================\n"
        );
@@ -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
        );
-
+        logger.info(
-        console.log(
+            "Wrapper added:",
            "Wrapper gespeichert:",
            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(
+        logger.info(
-            "RabbitMQ verbunden"
+            "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 | {
+                    ) as unknown;
                        type: string;
                        [key: string]: 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;
                        };
-
+                        logger.debug(
                        console.log(
                            "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(
+                logger.debug(
-
+                    "Query erfolgreich:",
                    "Query:",
                    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"}`
		`@@ -0,0 +1,2 @@`
							`declare const _default: import("vite").UserConfig;`
							`export default _default;`
		`@@ -0,0 +1,2 @@`
							`"use strict";`
							`Object.defineProperty(exports, "__esModule", { value: true });`