Upload via Git Manager GUI

BungeeCord-Chrome/background.js

@@ -0,0 +1,187 @@
+// background.js
+const POLL_INTERVAL_SEC = 2;
+
+// Alarm erstellen
+chrome.runtime.onInstalled.addListener(() => {
+  chrome.alarms.create('periodicRefresh', { periodInMinutes: POLL_INTERVAL_SEC / 60 });
+});
+
+chrome.alarms.onAlarm.addListener((alarm) => {
+  if (alarm.name === 'periodicRefresh') {
+    refreshAllServers().catch(console.error);
+  }
+});
+
+// Message Listener
+chrome.runtime.onMessage.addListener((msg, sender, sendResponse) => {
+  if (msg && msg.cmd === 'refreshNow') {
+    refreshAllServers()
+      .then(statuses => sendResponse({ ok: true, statuses }))
+      .catch(err => sendResponse({ ok: false, error: String(err) }));
+    return true;
+  }
+});
+
+async function refreshAllServers() {
+  const obj = await chrome.storage.local.get('servers');
+  const servers = obj.servers || [];
+  if (servers.length === 0) {
+    await chrome.storage.local.set({ serverStatuses: {} });
+    chrome.action.setBadgeText({ text: '' });
+    return {};
+  }
+
+  const results = {};
+  let totalOnlinePlayers = 0;
+
+  const tasks = servers.map(async (srv) => {
+    try {
+      const data = await fetchServerStatus(srv, 2000);
+      results[srv.id] = { ok: true, server: srv, fetched: Date.now(), data };
+
+      if (data) {
+        if (Array.isArray(data.players)) totalOnlinePlayers += data.players.length;
+        else if (typeof data.players === 'number') totalOnlinePlayers += data.players;
+      }
+    } catch (e) {
+      results[srv.id] = { ok: false, server: srv, fetched: Date.now(), error: String(e) };
+    }
+  });
+
+  await Promise.all(tasks);
+  await chrome.storage.local.set({ serverStatuses: results });
+
+  const badgeText = totalOnlinePlayers > 0 ? String(totalOnlinePlayers) : '';
+  chrome.action.setBadgeText({ text: badgeText });
+  chrome.action.setBadgeBackgroundColor({ color: '#3b82f6' });
+
+  return results;
+}
+
+async function fetchServerStatus(server, timeoutMs = 2000) {
+  let serverObj = typeof server === 'string' ? { id: 'legacy', url: server } : server;
+  let fetchUrl = serverObj.url || '';
+
+  // 1. Direkte URL-Abfrage
+  if (fetchUrl) {
+    if (!/^https?:\/\//i.test(fetchUrl)) fetchUrl = 'http://' + fetchUrl;
+    try {
+      const startTime = performance.now();
+      const controller = new AbortController();
+      const id = setTimeout(() => controller.abort(), timeoutMs);
+
+      const resp = await fetch(fetchUrl, { method: 'GET', signal: controller.signal });
+      clearTimeout(id);
+
+      const endTime = performance.now();
+      const latency = Math.round(endTime - startTime);
+
+      if (resp.ok) {
+        let text = await resp.text();
+        const lastBrace = text.lastIndexOf('}');
+        if (lastBrace !== -1) text = text.substring(0, lastBrace + 1);
+        text = text.trim();
+
+        try {
+          const parsed = JSON.parse(text);
+          if (parsed && (typeof parsed.online !== 'undefined' || Array.isArray(parsed.players) || parsed.version)) {
+            parsed.ping = latency; // Ping hinzufügen
+            return parsed;
+          }
+        } catch (e) {
+          // Parsing fehlgeschlagen → Fallback-Objekt mit Ping
+          return {
+            online: false,
+            players: [],
+            max_players: 0,
+            version: 'unknown',
+            motd: '',
+            ping: latency > timeoutMs ? null : latency // bei Timeout kein sinnvoller Ping
+          };
+        }
+      }
+      // HTTP nicht ok → Offline mit gemessener Latenz (falls unter Timeout)
+      return {
+        online: false,
+        players: [],
+        max_players: 0,
+        version: 'unknown',
+        motd: '',
+        ping: latency > timeoutMs ? null : latency
+      };
+    } catch (e) {
+      // Timeout oder Netzwerkfehler
+      return {
+        online: false,
+        players: [],
+        max_players: 0,
+        version: 'unknown',
+        motd: '',
+        ping: null
+      };
+    }
+  }
+
+  // 2. WordPress AJAX-Abfrage
+  const wpSite = serverObj.wpSite ? String(serverObj.wpSite).replace(/\/$/, '') : null;
+  const wpServerId = serverObj.wpServerId ? String(serverObj.wpServerId) : null;
+
+  if (wpSite && wpServerId) {
+    try {
+      const ajaxUrl = wpSite + '/wp-admin/admin-ajax.php';
+      const body = 'action=mcss_fetch&server_id=' + encodeURIComponent(wpServerId);
+
+      const startTime = performance.now();
+      const controller2 = new AbortController();
+      const id2 = setTimeout(() => controller2.abort(), timeoutMs);
+
+      const resp2 = await fetch(ajaxUrl, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        body,
+        signal: controller2.signal
+      });
+      clearTimeout(id2);
+
+      const endTime = performance.now();
+      const latency = Math.round(endTime - startTime);
+
+      if (!resp2.ok) throw new Error('WP AJAX HTTP ' + resp2.status);
+
+      const json = await resp2.json();
+      if (json && (typeof json.online !== 'undefined' || Array.isArray(json.players) || json.version)) {
+        json.ping = latency; // Ping hinzufügen
+        return json;
+      }
+
+      // JSON nicht im erwarteten Format
+      return {
+        online: false,
+        players: [],
+        max_players: 0,
+        version: 'unknown',
+        motd: '',
+        ping: latency > timeoutMs ? null : latency
+      };
+    } catch (e) {
+      return {
+        online: false,
+        players: [],
+        max_players: 0,
+        version: 'unknown',
+        motd: '',
+        ping: null
+      };
+    }
+  }
+
+  // Keine gültige Konfiguration
+  return {
+    online: false,
+    players: [],
+    max_players: 0,
+    version: 'unknown',
+    motd: '',
+    ping: null
+  };
+}

BungeeCord-Chrome/manifest.json

@@ -0,0 +1,25 @@
+{
+  "manifest_version": 3,
+  "name": "Minecraft Bungee Status",
+  "description": "Zeigt den Live-Status mehrerer Bungee/Proxy-Server an. Fallback auf WordPress AJAX möglich.",
+  "version": "1.1.1",
+  "action": {
+    "default_popup": "popup.html",
+    "default_icon": {
+      "16": "icons/icon16.png",
+      "48": "icons/icon48.png",
+      "128": "icons/icon128.png"
+    }
+  },
+  "background": {
+    "service_worker": "background.js"
+  },
+  "permissions": [
+    "storage",
+    "alarms"
+  ],
+  "host_permissions": [
+    "http://*/*",
+    "https://*/*"
+  ]
+}

BungeeCord-Chrome/popup.css

@@ -0,0 +1,435 @@
+:root {
+  --bg: #0d1117;
+  --panel: #161b27;
+  --panel2: #111620;
+  --text: #e6eef8;
+  --muted: #5a6a7a;
+  --muted2: #8899aa;
+  --accent: #3b82f6;
+  --radius: 9px;
+  --online: #22c55e;
+  --offline: #ef4444;
+  --border: rgba(255,255,255,0.07);
+}
+
+* { box-sizing: border-box; }
+
+html, body {
+  margin: 0; padding: 0;
+  font-family: Inter, Arial, sans-serif;
+  background: var(--bg);
+  color: var(--text);
+  overflow-x: hidden;
+}
+
+.root {
+  width: 560px;
+  display: flex;
+  flex-direction: column;
+}
+
+/* ── Header ── */
+header {
+  background: var(--panel);
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 13px 20px;
+  border-bottom: 1px solid var(--border);
+}
+
+header h1 {
+  font-size: 14px;
+  font-weight: 700;
+  margin: 0;
+  letter-spacing: 0.03em;
+  color: #fff;
+}
+
+header .actions { display: flex; gap: 7px; }
+
+header .actions button {
+  background: rgba(255,255,255,0.07);
+  border: 1px solid rgba(255,255,255,0.1);
+  color: var(--muted2);
+  border-radius: 7px;
+  width: 32px; height: 32px;
+  cursor: pointer;
+  font-size: 16px;
+  display: flex; align-items: center; justify-content: center;
+  transition: background 0.15s, color 0.15s;
+}
+
+header .actions button:hover {
+  background: rgba(255,255,255,0.12);
+  color: #fff;
+}
+
+/* ── Main layout ── */
+.main {
+  display: flex;
+  flex-direction: column;
+}
+
+/* ── Settings / add-form panel ── */
+.settings-panel {
+  background: var(--panel2);
+  border-bottom: 1px solid var(--border);
+  padding: 14px 20px;
+  display: flex;
+  flex-direction: column;
+  gap: 8px;
+}
+
+.settings-panel input {
+  padding: 8px 12px;
+  border-radius: 7px;
+  border: 1px solid rgba(255,255,255,0.09);
+  background: rgba(0,0,0,0.3);
+  color: var(--text);
+  font-size: 13px;
+  outline: none;
+}
+
+.settings-panel input:focus {
+  border-color: var(--accent);
+}
+
+.settings-panel button {
+  padding: 8px 12px;
+  border-radius: 7px;
+  border: none;
+  background: var(--accent);
+  color: white;
+  font-size: 13px;
+  font-weight: 600;
+  cursor: pointer;
+}
+
+/* ── Server list ── */
+.server-list-panel {
+  background: var(--panel2);
+  border-bottom: 1px solid var(--border);
+  padding: 10px 12px;
+}
+
+#serversContainer {
+  list-style: none;
+  margin: 0; padding: 0;
+  display: flex;
+  flex-direction: column;
+  gap: 4px;
+}
+
+.server-item {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  padding: 9px 12px;
+  border-radius: 8px;
+  cursor: pointer;
+  background: transparent;
+  border: 1px solid transparent;
+  transition: background 0.15s, border-color 0.15s;
+}
+
+.server-item:hover { background: rgba(255,255,255,0.04); }
+.server-item.selected { background: rgba(59,130,246,0.08); border-color: rgba(59,130,246,0.25); }
+
+.server-item .meta { display: flex; flex-direction: column; gap: 2px; }
+.server-item .meta .name { font-size: 13px; font-weight: 600; color: #fff; }
+.server-item .meta .url { font-size: 11px; color: var(--muted); }
+
+.status-bubble {
+  font-size: 11px;
+  font-weight: 600;
+  padding: 3px 10px;
+  border-radius: 999px;
+  color: #fff;
+  background: transparent;
+}
+
+/* ── Detail panel ── */
+.detail-panel {
+  padding: 18px 20px;
+  display: flex;
+  flex-direction: column;
+  gap: 16px;
+  min-height: 200px;
+}
+
+.placeholder {
+  color: var(--muted);
+  font-size: 13px;
+  padding: 24px 0;
+  text-align: center;
+}
+
+/* Server identity + online badge */
+.srv-identity {
+  display: flex;
+  justify-content: space-between;
+  align-items: flex-start;
+}
+
+.srv-name { font-size: 20px; font-weight: 700; color: #fff; margin: 0 0 4px; }
+.srv-url { font-size: 12px; color: var(--muted); }
+
+.online-badge {
+  display: flex;
+  align-items: center;
+  gap: 7px;
+  border-radius: 999px;
+  padding: 5px 14px;
+  font-size: 13px;
+  font-weight: 600;
+}
+
+.online-badge.online {
+  background: rgba(34,197,94,0.12);
+  border: 1px solid rgba(34,197,94,0.25);
+  color: #4ade80;
+}
+
+.online-badge.offline {
+  background: rgba(239,68,68,0.1);
+  border: 1px solid rgba(239,68,68,0.2);
+  color: #f87171;
+}
+
+.pulsing-dot {
+  width: 7px; height: 7px;
+  border-radius: 50%;
+  flex-shrink: 0;
+}
+
+.pulsing-dot.online {
+  background: var(--online);
+  animation: pulse-green 2s infinite;
+}
+
+.pulsing-dot.offline {
+  background: var(--offline);
+  animation: pulse-red 2s infinite;
+}
+
+@keyframes pulse-green {
+  0%,100% { box-shadow: 0 0 0 0 rgba(34,197,94,0.5); }
+  50% { box-shadow: 0 0 0 5px rgba(34,197,94,0); }
+}
+@keyframes pulse-red {
+  0%,100% { box-shadow: 0 0 0 0 rgba(239,68,68,0.5); }
+  50% { box-shadow: 0 0 0 5px rgba(239,68,68,0); }
+}
+
+/* MOTD */
+.motd-bar {
+  font-size: 12px;
+  color: var(--muted2);
+  background: rgba(255,255,255,0.03);
+  border-radius: 8px;
+  padding: 8px 14px;
+  border-left: 2px solid rgba(59,130,246,0.35);
+  font-style: italic;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  margin-top: 4px;
+}
+
+/* Stats row – 3 gleich breite Karten */
+.stats-row {
+  display: grid;
+  grid-template-columns: 1fr 1fr 1fr;
+  gap: 10px;
+  margin-top: 4px;
+}
+
+.stat-card {
+  background: var(--panel);
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  padding: 12px 16px;
+}
+
+.stat-label {
+  font-size: 10px;
+  color: var(--muted);
+  text-transform: uppercase;
+  letter-spacing: 0.08em;
+  margin-bottom: 5px;
+}
+
+.stat-val {
+  font-size: 18px;
+  font-weight: 700;
+  color: #fff;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.stat-val.small {
+  font-size: 12px;
+  padding-top: 4px;
+  font-weight: 500;
+  color: var(--muted2);
+}
+
+/* Section label */
+.section-label {
+  font-size: 11px;
+  font-weight: 700;
+  color: var(--muted);
+  text-transform: uppercase;
+  letter-spacing: 0.1em;
+  margin-bottom: 9px;
+  padding-top: 6px;
+  border-top: 1px solid var(--border);
+}
+
+/* Sub-server chips – immer 3 pro Zeile */
+.sub-servers {
+  display: grid;
+  grid-template-columns: repeat(3, 1fr);
+  gap: 8px;
+}
+
+.sub-chip {
+  display: flex;
+  align-items: center;
+  gap: 7px;
+  border-radius: 8px;
+  padding: 8px 12px;
+  font-size: 13px;
+  font-weight: 600;
+  border: 1px solid var(--border);
+  background: var(--panel);
+  color: var(--muted2);
+  cursor: default;
+  transition: background 0.15s;
+  min-width: 0;
+}
+
+.sub-chip.active {
+  background: rgba(59,130,246,0.1);
+  border-color: rgba(59,130,246,0.3);
+  color: #93c5fd;
+}
+
+.sub-chip-dot {
+  width: 7px; height: 7px;
+  border-radius: 50%;
+  background: #2a3040;
+  flex-shrink: 0;
+}
+
+.sub-chip.active .sub-chip-dot {
+  background: var(--accent);
+}
+
+.sub-chip-name {
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+  flex: 1;
+  min-width: 0;
+}
+
+.sub-chip-count {
+  font-size: 11px;
+  font-weight: 500;
+  opacity: 0.65;
+  flex-shrink: 0;
+  margin-left: auto;
+  padding-left: 4px;
+}
+
+/* Players grid – 2 Spalten */
+.players-grid {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: 8px;
+}
+
+.player-card {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+  background: var(--panel);
+  border: 1px solid var(--border);
+  border-radius: var(--radius);
+  padding: 10px 14px;
+  transition: background 0.15s;
+  min-width: 0;
+}
+
+.player-card:hover {
+  background: rgba(255,255,255,0.05);
+}
+
+.player-avatar {
+  width: 40px; height: 40px;
+  border-radius: 7px;
+  border: 1px solid rgba(255,255,255,0.1);
+  flex-shrink: 0;
+  image-rendering: pixelated;
+}
+
+.player-info { flex: 1; min-width: 0; }
+
+.player-name {
+  font-size: 14px;
+  font-weight: 700;
+  color: var(--text);
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.player-prefix {
+  font-size: 11px;
+  color: var(--muted2);
+  margin-bottom: 2px;
+  white-space: nowrap;
+  overflow: hidden;
+  text-overflow: ellipsis;
+}
+
+.player-server-tag {
+  display: inline-block;
+  margin-top: 3px;
+  font-size: 11px;
+  font-weight: 600;
+  background: rgba(59,130,246,0.18);
+  color: #93c5fd;
+  border-radius: 5px;
+  padding: 2px 7px;
+}
+
+/* Edit/Delete buttons */
+.detail-buttons {
+  display: flex;
+  gap: 10px;
+  padding-top: 10px;
+  border-top: 1px solid var(--border);
+}
+
+.detail-buttons button {
+  padding: 7px 16px;
+  border-radius: 7px;
+  border: none;
+  cursor: pointer;
+  font-size: 13px;
+  font-weight: 600;
+}
+
+#btnEdit { background: rgba(245,158,11,0.15); color: #fbbf24; border: 1px solid rgba(245,158,11,0.25); }
+#btnDelete { background: rgba(239,68,68,0.12); color: #f87171; border: 1px solid rgba(239,68,68,0.2); }
+
+.hidden { display: none !important; }
+
+::-webkit-scrollbar { width: 5px; }
+::-webkit-scrollbar-track { background: transparent; }
+::-webkit-scrollbar-thumb { background: rgba(255,255,255,0.08); border-radius: 10px; }
+::-webkit-scrollbar-thumb:hover { background: var(--accent); }

BungeeCord-Chrome/popup.html

@@ -0,0 +1,97 @@
+<!DOCTYPE html>
+<html lang="de">
+<head>
+<meta charset="UTF-8" />
+<meta name="viewport" content="width=device-width,initial-scale=1" />
+<title>Bungee Status</title>
+<link rel="stylesheet" href="popup.css">
+</head>
+<body>
+<div class="root">
+
+  <header>
+    <h1>Bungee Status</h1>
+    <div class="actions">
+      <button id="btnRefresh" title="Jetzt aktualisieren">↻</button>
+      <button id="btnToggleSettings" title="Einstellungen">⚙</button>
+    </div>
+  </header>
+
+  <div class="main">
+
+    <div id="settingsForm" class="settings-panel hidden">
+      <h3 id="settingsTitle">Neuen Server hinzufügen</h3>
+      <input id="inputName" placeholder="Name (z. B. Lobby)" />
+      <input id="inputUrl" placeholder="URL (z. B. 192.168.1.1:9191)" />
+      <input id="inputWpSite" placeholder="WP Site (z. B. https://meine-seite.de)" />
+      <input id="inputWpServerId" placeholder="WP Server ID" />
+      <button id="btnAddServer">Hinzufügen</button>
+    </div>
+
+    <div id="serverListPanel" class="server-list-panel hidden">
+      <ul id="serversContainer"></ul>
+    </div>
+
+    <div class="detail-panel">
+
+      <div id="noSelection" class="placeholder">Noch kein Server ausgewählt.</div>
+
+      <div id="detailContent" class="hidden">
+
+        <!-- Server Name + Status Badge -->
+        <div class="srv-identity">
+          <div>
+            <div class="srv-name" id="detailName"></div>
+            <div class="srv-url" id="detailUrlText"></div>
+          </div>
+          <div class="online-badge offline" id="statusBadge">
+            <div class="pulsing-dot offline" id="detailPulse"></div>
+            <span id="detailStatus">Offline</span>
+          </div>
+        </div>
+
+        <!-- MOTD -->
+        <div id="motdBar" class="motd-bar hidden"></div>
+
+        <!-- Stats: Spieler / Version / Ping -->
+        <div class="stats-row">
+          <div class="stat-card">
+            <div class="stat-label">Spieler</div>
+            <div class="stat-val" id="detailPlayers">-</div>
+          </div>
+          <div class="stat-card">
+            <div class="stat-label">Version</div>
+            <div class="stat-val small" id="detailVersion">-</div>
+          </div>
+          <div class="stat-card">
+            <div class="stat-label">Ping</div>
+            <div class="stat-val" id="detailPing">-</div>
+          </div>
+        </div>
+
+        <!-- Sub-Server -->
+        <div id="backendSection" class="hidden">
+          <div class="section-label">Sub-Server</div>
+          <div class="sub-servers" id="backendServersList"></div>
+        </div>
+
+        <!-- Online Spieler -->
+        <div>
+          <div class="section-label">Online Spieler</div>
+          <div class="players-grid" id="detailPlayerList"></div>
+        </div>
+
+        <!-- Edit / Delete -->
+        <div class="detail-buttons hidden" id="detailButtons">
+          <button id="btnEdit">Bearbeiten</button>
+          <button id="btnDelete">Löschen</button>
+        </div>
+
+      </div>
+    </div>
+
+  </div>
+</div>
+<script src="popup.js"></script>
+</body>
+</html>

BungeeCord-Chrome/popup.js

@@ -0,0 +1,430 @@
+// popup.js
+const $ = id => document.getElementById(id);
+const uid = () => 'srv_' + Math.random().toString(36).slice(2,9);
+
+let servers = [];
+let selectedId = null;
+let statuses = {};
+let previousStatuses = {};
+let settingsVisible = false;
+let editingId = null; // Welcher Server gerade bearbeitet wird
+
+document.addEventListener('DOMContentLoaded', init);
+$('btnAdd')?.addEventListener('click', handleAdd);
+$('btnAddServer')?.addEventListener('click', handleAdd);
+$('btnRefresh').addEventListener('click', manualRefresh);
+$('btnToggleSettings').addEventListener('click', toggleSettings);
+$('btnEdit').addEventListener('click', handleEdit);
+$('btnDelete').addEventListener('click', handleDelete);
+
+async function init() {
+  await loadServersFromStorage();
+  await loadStatusesFromStorage();
+  await loadSettingsVisibility();
+  renderServerList();
+  if (servers.length === 1) selectedId = servers[0].id;
+  renderDetail(selectedId);
+}
+
+// ── Minecraft color code parser ──
+function parseMinecraftColors(text) {
+  if (!text) return '';
+  const map = {
+    '§0':'#000000','§1':'#0000AA','§2':'#00AA00','§3':'#00AAAA',
+    '§4':'#AA0000','§5':'#AA00AA','§6':'#FFAA00','§7':'#AAAAAA',
+    '§8':'#555555','§9':'#5555FF','§a':'#55FF55','§b':'#55FFFF',
+    '§c':'#FF5555','§d':'#FF55FF','§e':'#FFFF55','§f':'#FFFFFF',
+    '&0':'#000000','&1':'#0000AA','&2':'#00AA00','&3':'#00AAAA',
+    '&4':'#AA0000','&5':'#AA00AA','&6':'#FFAA00','&7':'#AAAAAA',
+    '&8':'#555555','&9':'#5555FF','&a':'#55FF55','&b':'#55FFFF',
+    '&c':'#FF5555','&d':'#FF55FF','&e':'#FFFF55','&f':'#FFFFFF'
+  };
+  let html = text.replace(/[<>]/g, '');
+  let result = '';
+  let i = 0;
+  while (i < html.length) {
+    const ch = html[i];
+    if ((ch === '§' || ch === '&') && i + 1 < html.length) {
+      const code = ch + html[i+1].toLowerCase();
+      if (map[code]) {
+        result += `<span style="color:${map[code]}">`;
+        i += 2;
+        continue;
+      }
+    }
+    result += html[i];
+    i++;
+  }
+  return result;
+}
+
+function get3DAvatarUrl(name, uuid = null) {
+  return `https://mc-heads.net/head/${encodeURIComponent(name)}/64`;
+}
+
+// ── Storage ──
+async function loadSettingsVisibility() {
+  const obj = await chrome.storage.local.get(['settingsVisible']);
+  settingsVisible = !!obj.settingsVisible;
+  applySettingsVisibility();
+}
+async function saveSettingsVisibility() {
+  await chrome.storage.local.set({ settingsVisible });
+}
+function applySettingsVisibility() {
+  $('settingsForm').classList.toggle('hidden', !settingsVisible);
+  $('serverListPanel').classList.toggle('hidden', !settingsVisible);
+  $('detailButtons').classList.toggle('hidden', !settingsVisible);
+}
+async function toggleSettings() {
+  settingsVisible = !settingsVisible;
+  applySettingsVisibility();
+  await saveSettingsVisibility();
+}
+
+async function loadServersFromStorage() {
+  const obj = await chrome.storage.local.get(['servers']);
+  servers = obj.servers || [];
+  for (const s of servers) if (!s.id) s.id = uid();
+  await chrome.storage.local.set({ servers });
+}
+async function saveServersToStorage() {
+  await chrome.storage.local.set({ servers });
+}
+async function loadStatusesFromStorage() {
+  const obj = await chrome.storage.local.get(['serverStatuses']);
+  statuses = obj.serverStatuses || {};
+}
+
+// ── Server list ──
+function renderServerList() {
+  const container = $('serversContainer');
+  container.innerHTML = '';
+  if (servers.length === 0) {
+    container.innerHTML = '<div class="placeholder" style="padding:8px 0;">Noch kein Server hinzugefügt.</div>';
+    return;
+  }
+  for (const s of servers) {
+    const li = document.createElement('li');
+    li.className = 'server-item' + (s.id === selectedId ? ' selected' : '');
+    li.dataset.id = s.id;
+
+    const meta = document.createElement('div');
+    meta.className = 'meta';
+
+    const nameEl = document.createElement('div');
+    nameEl.className = 'name';
+    nameEl.textContent = s.name || '(Kein Name)';
+
+    let urlText = s.url || (s.wpSite || '');
+    urlText = urlText.replace(':9191', '');
+    const urlEl = document.createElement('div');
+    urlEl.className = 'url';
+    urlEl.textContent = urlText;
+
+    meta.append(nameEl, urlEl);
+
+    const bubble = document.createElement('div');
+    bubble.className = 'status-bubble';
+    bubble.textContent = '—';
+    li._bubble = bubble;
+
+    li.append(meta, bubble);
+    li.addEventListener('click', () => {
+      selectedId = s.id;
+      document.querySelectorAll('.server-item').forEach(el => el.classList.remove('selected'));
+      li.classList.add('selected');
+      renderDetail(selectedId);
+    });
+    container.appendChild(li);
+  }
+  updateServerListStatuses();
+}
+
+// ── Detail ──
+function renderDetail(id) {
+  if (!id) {
+    $('noSelection').classList.remove('hidden');
+    $('detailContent').classList.add('hidden');
+    return;
+  }
+  const srv = servers.find(x => x.id === id);
+  if (!srv) {
+    $('noSelection').classList.remove('hidden');
+    $('detailContent').classList.add('hidden');
+    return;
+  }
+  $('noSelection').classList.add('hidden');
+  $('detailContent').classList.remove('hidden');
+
+  $('detailName').textContent = srv.name || 'Unbenannter Server';
+  let urlToShow = srv.url || (srv.wpSite || 'Lokal');
+  urlToShow = urlToShow.replace(':9191', '');
+  $('detailUrlText').textContent = urlToShow;
+
+  updateDetailForServer(srv, true);
+}
+
+function updateDetailForServer(srv, force = false) {
+  const st = statuses[srv.id];
+  const prevSt = previousStatuses[srv.id];
+  const changed = force || JSON.stringify(st) !== JSON.stringify(prevSt);
+  if (!changed) return;
+
+  const badge = $('statusBadge');
+  const pulse = $('detailPulse');
+
+  if (!st || !st.ok || !st.data) {
+    badge.className = 'online-badge offline';
+    pulse.className = 'pulsing-dot offline';
+    $('detailStatus').textContent = 'Offline';
+    $('detailVersion').textContent = '-';
+    $('detailPlayers').textContent = '-';
+    $('detailPing').textContent = '-';
+    $('motdBar').classList.add('hidden');
+    updatePlayerList([]);
+    updateBackendServers(null);
+  } else {
+    const d = st.data;
+    const isOnline = !!d.online;
+
+    badge.className = 'online-badge ' + (isOnline ? 'online' : 'offline');
+    pulse.className = 'pulsing-dot ' + (isOnline ? 'online' : 'offline');
+    $('detailStatus').textContent = isOnline ? 'Online' : 'Offline';
+    $('detailVersion').textContent = d.version || 'unknown';
+
+    const count = Array.isArray(d.players) ? d.players.length
+      : (typeof d.players === 'number' ? d.players : 0);
+    const max = d.max_players;
+    $('detailPlayers').textContent = max && max !== '-1' ? `${count} / ${max}` : String(count);
+
+    const ping = d.ping || d.latency;
+    $('detailPing').textContent = typeof ping === 'number' ? ping + ' ms' : '-';
+
+    const motdRaw = d.motd || (d.network && d.network.motd) || '';
+    if (motdRaw) {
+      const motdEl = $('motdBar');
+      motdEl.innerHTML = parseMinecraftColors(motdRaw);
+      motdEl.classList.remove('hidden');
+    } else {
+      $('motdBar').classList.add('hidden');
+    }
+
+    const currentPlayers = Array.isArray(d.players) ? d.players : [];
+    updatePlayerList(currentPlayers);
+    updateBackendServers(d.network?.backend_servers || null);
+  }
+
+  previousStatuses[srv.id] = st ? JSON.parse(JSON.stringify(st)) : null;
+}
+
+// ── Sub-Server chips ──
+function updateBackendServers(list) {
+  const section = $('backendSection');
+  const container = $('backendServersList');
+  if (!list || list.length === 0) {
+    section.classList.add('hidden');
+    container.innerHTML = '';
+    return;
+  }
+  section.classList.remove('hidden');
+  container.innerHTML = '';
+  for (const bs of list) {
+    const count = bs.online_players || 0;
+    const chip = document.createElement('div');
+    chip.className = 'sub-chip' + (count > 0 ? ' active' : '');
+
+    const dot = document.createElement('span');
+    dot.className = 'sub-chip-dot';
+
+    const nameEl = document.createElement('span');
+    nameEl.className = 'sub-chip-name';
+    nameEl.textContent = bs.name;
+
+    const countEl = document.createElement('span');
+    countEl.className = 'sub-chip-count';
+    countEl.textContent = count > 0 ? count : 'leer';
+
+    chip.append(dot, nameEl, countEl);
+    container.appendChild(chip);
+  }
+}
+
+// ── Player list ──
+function updatePlayerList(players) {
+  const grid = $('detailPlayerList');
+  grid.innerHTML = '';
+
+  if (!players || players.length === 0) {
+    grid.innerHTML = '<div class="placeholder">Keine Spieler online.</div>';
+    return;
+  }
+
+  for (const p of players) {
+    const card = document.createElement('div');
+    card.className = 'player-card';
+
+    let name = '', uuid = null, prefix = '', serverName = null;
+
+    if (typeof p === 'object') {
+      name = p.name || p.username || p.player || '';
+      uuid = p.uuid || null;
+      prefix = p.prefix || p.group || '';
+      serverName = p.server || p.current_server || p.connected_server || null;
+    } else {
+      name = String(p);
+    }
+
+    const img = document.createElement('img');
+    img.src = (typeof p === 'object' && p.avatar) ? p.avatar : get3DAvatarUrl(name, uuid);
+    img.className = 'player-avatar';
+    img.loading = 'lazy';
+    img.onerror = function() {
+      this.onerror = null;
+      this.src = `https://mc-heads.net/avatar/${encodeURIComponent(name)}/64`;
+    };
+
+    const info = document.createElement('div');
+    info.className = 'player-info';
+
+    if (prefix) {
+      const prefixEl = document.createElement('div');
+      prefixEl.className = 'player-prefix';
+      prefixEl.innerHTML = parseMinecraftColors(prefix);
+      info.appendChild(prefixEl);
+    }
+
+    const nameEl = document.createElement('div');
+    nameEl.className = 'player-name';
+    nameEl.textContent = name;
+    info.appendChild(nameEl);
+
+    if (serverName) {
+      const tag = document.createElement('span');
+      tag.className = 'player-server-tag';
+      tag.textContent = serverName;
+      info.appendChild(tag);
+    }
+
+    card.append(img, info);
+    grid.appendChild(card);
+  }
+}
+
+// ── Server list status bubbles ──
+function updateServerListStatuses() {
+  const items = $('serversContainer').querySelectorAll('.server-item');
+  items.forEach(item => {
+    const s = servers.find(x => x.id === item.dataset.id);
+    if (!s || !item._bubble) return;
+    const st = statuses[s.id];
+    if (!st || !st.ok || !st.data || !st.data.online) {
+      item._bubble.textContent = 'Offline';
+      item._bubble.style.background = 'rgba(239,68,68,0.15)';
+      item._bubble.style.color = '#f87171';
+    } else {
+      item._bubble.textContent = 'Online';
+      item._bubble.style.background = 'rgba(34,197,94,0.15)';
+      item._bubble.style.color = '#4ade80';
+    }
+  });
+}
+
+// ── Edit / Add Mode ──
+function enterEditMode(server) {
+  editingId = server.id;
+  $('settingsTitle').textContent = 'Server bearbeiten';
+  $('btnAddServer').textContent = 'Änderungen speichern';
+  
+  $('inputName').value = server.name || '';
+  $('inputUrl').value = server.url || '';
+  $('inputWpSite').value = server.wpSite || '';
+  $('inputWpServerId').value = server.wpServerId || '';
+}
+
+function exitEditMode() {
+  editingId = null;
+  $('settingsTitle').textContent = 'Neuen Server hinzufügen';
+  $('btnAddServer').textContent = 'Hinzufügen';
+  $('inputName').value = '';
+  $('inputUrl').value = '';
+  $('inputWpSite').value = '';
+  $('inputWpServerId').value = '';
+}
+
+// ── Actions ──
+async function handleAdd() {
+  const name = $('inputName').value.trim();
+  const url = $('inputUrl').value.trim();
+  const wpSite = $('inputWpSite').value.trim();
+  const wpServerId = $('inputWpServerId').value.trim();
+
+  if (!url && !wpSite) {
+    alert('Bitte eine URL oder WordPress-Einstellungen angeben.');
+    return;
+  }
+
+  if (editingId) {
+    // === BEARBEITEN ===
+    const srv = servers.find(s => s.id === editingId);
+    if (srv) {
+      srv.name = name || url || wpSite;
+      if (url) srv.url = url;
+      if (wpSite) srv.wpSite = wpSite;
+      if (wpServerId) srv.wpServerId = wpServerId;
+    }
+    exitEditMode();
+  } else {
+    // === NEU HINZUFÜGEN ===
+    const s = { 
+      id: uid(), 
+      name: name || url || wpSite, 
+      url: url || null, 
+      wpSite: wpSite || null, 
+      wpServerId: wpServerId || null 
+    };
+    servers.push(s);
+  }
+
+  await saveServersToStorage();
+  renderServerList();
+  if (selectedId) renderDetail(selectedId);
+}
+
+async function handleEdit() {
+  if (!selectedId) return;
+  const srv = servers.find(s => s.id === selectedId);
+  if (!srv) return;
+
+  settingsVisible = true;
+  applySettingsVisibility();
+  await saveSettingsVisibility();
+
+  enterEditMode(srv);
+}
+
+async function handleDelete() {
+  if (!selectedId || !confirm('Server wirklich löschen?')) return;
+  servers = servers.filter(s => s.id !== selectedId);
+  selectedId = null;
+  await saveServersToStorage();
+  renderServerList();
+  renderDetail(null);
+  exitEditMode();
+}
+
+async function manualRefresh() {
+  try { chrome.runtime.sendMessage({ cmd: 'refreshNow' }); } catch(e) {}
+}
+
+// ── Live updates from background ──
+chrome.storage.onChanged.addListener((changes, area) => {
+  if (area === 'local' && changes.serverStatuses) {
+    statuses = changes.serverStatuses.newValue || {};
+    updateServerListStatuses();
+    if (selectedId) {
+      const srv = servers.find(s => s.id === selectedId);
+      if (srv) updateDetailForServer(srv);
+    }
+  }
+});

README.md

@@ -1,2 +1,144 @@
-# Minecraft-BungeeCord-Status
+# Minecraft BungeeCord Status
 
+StatusAPI zeigt den aktuellen Status deines Minecraft-Servers direkt auf deiner Webseite an – inklusive Online/Offline, Version, Ping, Spieleranzahl und Spieler-Avatare.
+
+**StatusAPI Repository:** [https://git.viper.ipv64.net/M_Viper/StatusAPI](https://git.viper.ipv64.net/M_Viper/StatusAPI)
+
+---
+
+## Features
+
+- Zeigt Serverstatus: **Online / Offline**
+- Zeigt Version und Ping
+- Zeigt die Anzahl der Spieler und ihre Avatare
+- Klick auf Servername kopiert die Adresse automatisch
+- Spielerübersicht wird automatisch alle **2 Sekunden** aktualisiert
+- Hinweise/Banner können vom Nutzer geschlossen werden
+- Anpassbare Darstellung für verschiedene Layouts
+
+---
+
+## Wichtige Hinweise
+
+### BungeeCord Plugin (Voraussetzung)
+
+⚠️ **Die [StatusAPI](https://git.viper.ipv64.net/M_Viper/StatusAPI) MUSS auf deinem BungeeCord-Server installiert sein!**
+
+Das Plugin **StatusAPI.jar** muss in den BungeeCord Plugin-Ordner kopiert werden, damit die API korrekt funktioniert.
+```text
+BungeeCord/
+ ├─ plugins/
+ │   └─ StatusAPI.jar   ← PFLICHT
+ └─ config.yml
+```
+
+**Download:** [https://git.viper.ipv64.net/M_Viper/StatusAPI](https://git.viper.ipv64.net/M_Viper/StatusAPI)
+
+### WordPress Integration
+
+In WordPress muss der API-Port auf **9191** eingestellt sein, damit die Serverdaten korrekt abgerufen werden.  
+Stelle sicher, dass dein Server und die Webseite auf diesen Port zugreifen können.
+
+Die StatusAPI stellt einen HTTP-Endpunkt bereit (Standard: `http://localhost:9191`), den das WordPress-Plugin abfragt.
+
+### Shortcode für WordPress
+
+Um den Serverstatus auf deiner WordPress-Seite anzuzeigen, füge einfach folgenden Shortcode ein:
+```html
+[bungeecord_status id="Bungeecord"]
+```
+
+Ersetze `"Bungeecord"` durch die ID deines Servers, falls mehrere Server eingebunden werden.
+
+---
+
+## Installation
+
+### Schritt 1: StatusAPI auf BungeeCord installieren
+
+1. Lade die **[StatusAPI](https://git.viper.ipv64.net/M_Viper/StatusAPI)** herunter
+2. Kopiere die **StatusAPI.jar** in den `plugins`-Ordner deines BungeeCord-Servers
+3. Starte den BungeeCord-Server neu
+4. Die API läuft nun standardmäßig auf Port **9191**
+
+### Schritt 2: WordPress-Plugin einrichten
+
+1. Installiere das WordPress-Plugin für den BungeeCord-Status
+2. Gehe zu den Plugin-Einstellungen
+3. Trage die **StatusAPI URL** ein (z.B. `http://localhost:9191`)
+4. Speichere die Einstellungen
+
+### Schritt 3: Shortcode einbinden
+
+Füge den Shortcode auf einer beliebigen WordPress-Seite ein:
+```html
+[bungeecord_status id="Bungeecord"]
+```
+
+---
+
+## Beispielanzeige
+
+**Status:** Online  
+**Version:** 1.8 - 1.21  
+**Ping:** 1 ms  
+**Spieler:** 1  
+
+**Avatare:**  
+![M_Viper Avatar](https://example.com/avatar/M_Viper.png) <!-- Platzhalter – wird im Plugin dynamisch geladen -->
+
+> Der Abstand zwischen dem Text „Spieler:" und den Avataren ist bewusst etwas größer, um die Übersichtlichkeit zu erhöhen.
+
+---
+
+## Nutzung
+
+1. Shortcode an der gewünschten Stelle einfügen
+2. Der Serverstatus aktualisiert sich automatisch, sodass die angezeigten Spieler und der Ping immer aktuell sind
+3. Alle Daten werden live von der StatusAPI bezogen
+
+---
+
+## Technische Details
+
+- **API-Port:** 9191 (Standard)
+- **Update-Intervall:** 2 Sekunden (automatisch)
+- **Protokoll:** HTTP/JSON
+- **Datenquelle:** StatusAPI auf BungeeCord
+
+---
+
+## Support
+
+Bei Problemen überprüfe bitte:
+
+- Ob das Plugin **[StatusAPI.jar](https://git.viper.ipv64.net/M_Viper/StatusAPI)** korrekt im BungeeCord Plugin-Ordner liegt
+- Ob der API-Port in WordPress korrekt auf **9191** eingestellt ist
+- Ob der BungeeCord-Server läuft und die StatusAPI erreichbar ist
+- Ob keine Firewall den Port 9191 blockiert
+- Ob die StatusAPI gültige JSON-Daten zurückliefert
+
+### Häufige Fehler
+
+❌ **"Server offline" obwohl Server läuft**
+- StatusAPI ist nicht installiert oder läuft nicht
+- Falscher Port in WordPress eingestellt
+- Firewall blockiert Port 9191
+
+❌ **Keine Spieler werden angezeigt**
+- StatusAPI liefert keine Spielerdaten
+- API-Verbindung fehlgeschlagen
+- WordPress kann die API-URL nicht erreichen
+
+---
+
+## Weitere Informationen
+
+Für detaillierte Informationen zur Installation, Konfiguration und Fehlerbehebung der StatusAPI:  
+**[https://git.viper.ipv64.net/M_Viper/StatusAPI](https://git.viper.ipv64.net/M_Viper/StatusAPI)**
+
+---
+
+**Copyright © 2026 - M_Viper - Alle Rechte vorbehalten**
+
+Die unbefugte Vervielfältigung, Verbreitung oder Weitergabe dieses Plugins ist strafbar und wird rechtlich verfolgt.

StatusAPI/pom.xml

@@ -1,43 +1,52 @@
-<project xmlns="http://maven.apache.org/POM/4.0.0"
+<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
-                             https://maven.apache.org/xsd/maven-4.0.0.xsd">
+                             https://maven.apache.org/xsd/maven-4.0.0.xsd">
-
+
-    <modelVersion>4.0.0</modelVersion>
+    <modelVersion>4.0.0</modelVersion>
-
+
-    <groupId>net.viper.bungee</groupId>
+    <groupId>net.viper.bungee</groupId>
-    <artifactId>StatusAPI</artifactId>
+    <artifactId>StatusAPI</artifactId>
-    <version>1.0</version>
+    <version>3.6.2</version>
-    <packaging>jar</packaging>
+    <packaging>jar</packaging>
-
+
-    <name>StatusAPI</name>
+    <name>StatusAPI</name>
-    <description>BungeeCord Status API Plugin</description>
+    <description>BungeeCord Status API Plugin</description>
-
+
-    <properties>
+    <properties>
-        <maven.compiler.source>8</maven.compiler.source>
+        <maven.compiler.source>8</maven.compiler.source>
-        <maven.compiler.target>8</maven.compiler.target>
+        <maven.compiler.target>8</maven.compiler.target>
-        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-    </properties>
+    </properties>
-
+
-    <dependencies>
+    <dependencies>
-        <!-- BungeeCord API (lokal installiert) -->
+        <!-- BungeeCord API -->
-        <dependency>
+        <dependency>
-            <groupId>net.md-5</groupId>
+            <groupId>net.md-5</groupId>
-            <artifactId>bungeecord-api</artifactId>
+            <artifactId>bungeecord-api</artifactId>
-            <version>1.20</version>
+            <version>1.20</version>
-            <scope>provided</scope>
+            <scope>provided</scope>
-        </dependency>
+        </dependency>
-    </dependencies>
+
-
+        <!-- LuckPerms API (Optional) -->
-    <build>
+        <dependency>
-        <finalName>StatusAPI</finalName>
+            <groupId>net.luckperms</groupId>
-
+            <artifactId>api</artifactId>
-        <resources>
+            <version>5.4</version>
-            <resource>
+            <scope>provided</scope>
-                <directory>src/main/resources</directory>
+            <optional>true</optional>
-                <filtering>false</filtering>
+        </dependency>
-            </resource>
+    </dependencies>
-        </resources>
+
-    </build>
+    <build>
-
+        <finalName>StatusAPI</finalName>
-</project>
+
+        <resources>
+            <resource>
+                <directory>src/main/resources</directory>
+                <filtering>false</filtering>
+            </resource>
+        </resources>
+    </build>
+
+</project>

StatusAPI/src/main/java/net/viper/status/FileDownloader.java

@@ -0,0 +1,59 @@
+package net.viper.status;
+
+import net.md_5.bungee.api.plugin.Plugin;
+
+import java.io.BufferedInputStream;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.net.URL;
+import java.util.function.Consumer;
+
+/**
+ * FileDownloader: Lädt Dateien asynchron herunter (CMILib Style).
+ */
+public class FileDownloader {
+
+    private final Plugin plugin;
+
+    public FileDownloader(Plugin plugin) {
+        this.plugin = plugin;
+    }
+
+    /**
+     * Lädt eine Datei herunter.
+     * @param urlString Die Download URL
+     * @param destination Die Zieldatei
+     * @param onSuccess Callback, der im Hauptthread ausgeführt wird, wenn fertig.
+     */
+    public void downloadFile(String urlString, File destination, Runnable onSuccess) {
+        plugin.getProxy().getScheduler().runAsync(plugin, () -> {
+            BufferedInputStream bufferedInputStream = null;
+            FileOutputStream fileOutputStream = null;
+            try {
+                URL url = new URL(urlString);
+                bufferedInputStream = new BufferedInputStream(url.openStream());
+                fileOutputStream = new FileOutputStream(destination);
+                byte[] buffer = new byte[1024];
+                int count;
+                while ((count = bufferedInputStream.read(buffer, 0, 1024)) != -1) {
+                    fileOutputStream.write(buffer, 0, count);
+                }
+                
+                // Schließen
+                fileOutputStream.close();
+                bufferedInputStream.close();
+
+                // Callback im Main Thread
+                plugin.getProxy().getScheduler().schedule(plugin, onSuccess, 1, java.util.concurrent.TimeUnit.MILLISECONDS);
+
+            } catch (Throwable e) {
+                plugin.getLogger().warning("Download fehlgeschlagen: " + e.getMessage());
+                if (destination.exists()) destination.delete();
+            } finally {
+                if (fileOutputStream != null) try { fileOutputStream.close(); } catch (IOException ignored) {}
+                if (bufferedInputStream != null) try { bufferedInputStream.close(); } catch (IOException ignored) {}
+            }
+        });
+    }
+}

StatusAPI/src/main/java/net/viper/status/StatusAPI.java

@@ -1,146 +1,293 @@
-package net.viper.status;
+package net.viper.status;
-
+
-import net.md_5.bungee.api.ProxyServer;
+import net.md_5.bungee.api.ProxyServer;
-import net.md_5.bungee.api.config.ListenerInfo;
+import net.md_5.bungee.api.config.ListenerInfo;
-import net.md_5.bungee.api.plugin.Plugin;
+import net.md_5.bungee.api.connection.ProxiedPlayer;
-
+import net.md_5.bungee.api.plugin.Plugin;
-import java.io.*;
+
-import java.net.ServerSocket;
+import java.io.BufferedReader;
-import java.net.Socket;
+import java.io.File;
-import java.util.ArrayList;
+import java.io.IOException;
-import java.util.HashMap;
+import java.io.InputStreamReader;
-import java.util.List;
+import java.io.OutputStream;
-import java.util.Map;
+import java.io.PrintWriter;
-
+import java.net.ServerSocket;
-public class StatusAPI extends Plugin implements Runnable {
+import java.net.Socket;
-
+import java.util.*;
-    private Thread thread;
+import java.util.concurrent.TimeUnit;
-    private int port = 9191;
+
-
+public class StatusAPI extends Plugin implements Runnable {
-    @Override
+
-    public void onEnable() {
+    private Thread thread;
-        getLogger().info("StatusAPI wird aktiviert...");
+    private int port = 9191;
-        getLogger().info("Starte Web-Server auf Port " + port + "...");
+    private UpdateChecker updateChecker;
-        
+    private FileDownloader fileDownloader;
-        thread = new Thread(this);
+
-        thread.start();
+    @Override
-    }
+    public void onEnable() {
-
+        getLogger().info("StatusAPI wird aktiviert...");
-    @Override
+        getLogger().info("Starte Web-Server auf Port " + port + "...");
-    public void onDisable() {
+
-        getLogger().info("Stoppe Web-Server...");
+        // Start HTTP server thread
-        if (thread != null) {
+        thread = new Thread(this, "StatusAPI-HTTP-Server");
-            thread.interrupt();
+        thread.start();
-        }
+
-    }
+        String currentVersion = getDescription() != null ? getDescription().getVersion() : "0.0.0";
-
+        updateChecker = new UpdateChecker(this, currentVersion, 6); // 6 Stunden Intervall
-    @Override
+        fileDownloader = new FileDownloader(this);
-    public void run() {
+
-        try (ServerSocket serverSocket = new ServerSocket(port)) {
+        File pluginFile = getFile();
-            serverSocket.setSoTimeout(1000);
+        File backupFile = new File(pluginFile.getParentFile(), "StatusAPI.jar.bak");
-
+
-            while (!Thread.interrupted()) {
+        // --- AUTOMATISCHES BACKUP-CLEANUP ---
-                try {
+        // Falls ein altes Update (.bak) im Ordner liegt, löschen wir es nach 1 Minute Startzeit.
-                    Socket clientSocket = serverSocket.accept();
+        // Wenn der Server kurz crashen würde, hast du noch 60 Sekunden Zeit, ihn zu stoppen,
-                    handleConnection(clientSocket);
+        // damit das Backup erhalten bleibt. Läuft er stabil, wird der Platz freigegeben.
-                } catch (java.net.SocketTimeoutException e) {
+        if (backupFile.exists()) {
-                    // Loop Check
+            ProxyServer.getInstance().getScheduler().schedule(this, () -> {
-                } catch (IOException e) {
+                if (backupFile.exists()) {
-                    // Ignorieren
+                    if (backupFile.delete()) {
-                }
+                        getLogger().info("Altes Backup (.bak) wurde erfolgreich gelöscht.");
-            }
+                    }
-        } catch (IOException e) {
+                }
-            getLogger().severe("Konnte ServerSocket nicht starten auf Port " + port);
+            }, 1, TimeUnit.MINUTES);
-            e.printStackTrace();
+        }
-        }
+        // ---------------------------------------
-    }
+
-
+        // Sofortiger Start-Check
-    private void handleConnection(Socket clientSocket) {
+        checkAndMaybeUpdate();
-        try (BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
+
-             PrintWriter out = new PrintWriter(clientSocket.getOutputStream(), true)) {
+        // Regelmäßiger Check (alle 6 Stunden)
-
+        ProxyServer.getInstance().getScheduler().schedule(this, this::checkAndMaybeUpdate, 6, 6, TimeUnit.HOURS);
-            String inputLine = in.readLine();
+    }
-            
+
-            if (inputLine != null && inputLine.startsWith("GET")) {
+    @Override
-                
+    public void onDisable() {
-                Map<String, Object> data = new HashMap<>();
+        getLogger().info("Stoppe Web-Server...");
-                data.put("online", true);
+        if (thread != null) {
-                
+            thread.interrupt();
-                // --- VERSION CLEANUP START ---
+            try { thread.join(1000); } catch (InterruptedException ignored) {}
-                String versionRaw = ProxyServer.getInstance().getVersion();
+        }
-                String versionClean = versionRaw; // Fallback
+    }
-                
+
-                // Regex um die saubere Version zu extrahieren (z.B. 1.21-R0.5-SNAPSHOT)
+    /**
-                // Aus: git:BungeeCord-Bootstrap:1.21-R0.5-SNAPSHOT:36e6154:2012
+     * Prüft Update und startet Download falls nötig.
-                if (versionRaw.matches("git-BungeeCord-Bootstrap:.*")) {
+     */
-                    String[] parts = versionRaw.split(":");
+    private void checkAndMaybeUpdate() {
-                    if(parts.length > 2) {
+        try {
-                        versionClean = parts[2];
+            updateChecker.checkNow();
-                    }
+            String currentVersion = getDescription() != null ? getDescription().getVersion() : "0.0.0";
-                }
+
-                data.put("version", versionClean);
+            if (updateChecker.isUpdateAvailable(currentVersion)) {
-                // --- VERSION CLEANUP ENDE ---
+                String newVersion = updateChecker.getLatestVersion();
-
+                String url = updateChecker.getLatestUrl();
-                data.put("max_players", ProxyServer.getInstance().getConfig().getPlayerLimit());
+                getLogger().warning("----------------------------------------");
-
+                getLogger().warning("Neue Version verfügbar: " + newVersion);
-                String motd = "BungeeCord";
+                getLogger().warning("Starte automatisches Update...");
-                try {
+                getLogger().warning("----------------------------------------");
-                    ListenerInfo listener = ProxyServer.getInstance().getConfig().getListeners().iterator().next();
+
-                    if (listener != null) {
+                // Download Starten
-                        motd = listener.getMotd();
+                File pluginFile = getFile();
-                    }
+                File newFile = new File(pluginFile.getParentFile(), "StatusAPI.jar.new");
-                } catch (Exception e) {
+
-                    // Fallback
+                fileDownloader.downloadFile(url, newFile, () -> {
-                }
+                    // Callback: Wenn Download erfolgreich
-                data.put("motd", motd);
+                    triggerUpdateScript(pluginFile, newFile);
-
+                });
-                List<String> playerNames = new ArrayList<>();
+            }
-                for (net.md_5.bungee.api.connection.ProxiedPlayer p : ProxyServer.getInstance().getPlayers()) {
+        } catch (Exception e) {
-                    playerNames.add(p.getName());
+            getLogger().severe("Fehler beim Update-Check: " + e.getMessage());
-                }
+        }
-                data.put("players", playerNames);
+    }
-
+
-                String json = buildJsonString(data);
+    /**
-
+     * Erstellt ein externes Batch-Skript, startet es und stoppt den Server.
-                out.println("HTTP/1.1 200 OK");
+     * Das Skript führt den Datei-Tausch durch, wenn der Server weg ist.
-                out.println("Content-Type: application/json");
+     */
-                out.println("Access-Control-Allow-Origin: *");
+    private void triggerUpdateScript(File currentFile, File newFile) {
-                out.println("Content-Length: " + json.length());
+        try {
-                out.println("Connection: close");
+            File pluginsFolder = currentFile.getParentFile();
-                out.println();
+            // Wir legen das Skript neben die Haupt-JAR (root) damit es nicht im Plugin-Ordner liegt
-                out.println(json);
+            File rootFolder = pluginsFolder.getParentFile();
-            }
+            File batFile = new File(rootFolder, "StatusAPI_Update_" + System.currentTimeMillis() + ".bat");
-        } catch (Exception e) {
+            
-            e.printStackTrace();
+            // Batch Inhalt
-        }
+            // 1. Wartet 5 Sekunden (Server fährt runter)
-    }
+            // 2. Geht in den Plugin Ordner
-
+            // 3. Sichert .jar zu .bak
-    private String buildJsonString(Map<String, Object> data) {
+            // 4. Benennt .new zu .jar um
-        StringBuilder sb = new StringBuilder("{");
+            // 5. Löscht sich selbst
-        boolean first = true;
+            String batContent = "@echo off\n" +
-        for (Map.Entry<String, Object> entry : data.entrySet()) {
+                    "echo Bitte warten, der Server f\"ahrt herunter...\n" +
-            if (!first) sb.append(",");
+                    "timeout /t 5 /nobreak >nul\n" + 
-            first = false;
+                    "cd /d \"" + pluginsFolder.getAbsolutePath().replace("\\", "/") + "\"\n" + 
-            sb.append("\"").append(entry.getKey()).append("\":");
+                    "echo Fuehre Datei-Tausch durch...\n" +
-
+                    "if exist StatusAPI.jar.bak del StatusAPI.jar.bak\n" +
-            Object value = entry.getValue();
+                    "if exist StatusAPI.jar (\n" +
-            if (value instanceof List) {
+                    "  ren StatusAPI.jar StatusAPI.jar.bak\n" +
-                sb.append("[");
+                    ")\n" +
-                List<?> list = (List<?>) value;
+                    "if exist StatusAPI.new.jar (\n" +
-                for (int i = 0; i < list.size(); i++) {
+                    "  ren StatusAPI.new.jar StatusAPI.jar\n" +
-                    if (i > 0) sb.append(",");
+                    "  echo Update erfolgreich!\n" +
-                    sb.append("\"").append(list.get(i)).append("\"");
+                    ") else (\n" +
-                }
+                    "  echo FEHLER: StatusAPI.new.jar nicht gefunden!\n" +
-                sb.append("]");
+                    "  pause\n" +
-            } else if (value instanceof String) {
+                    ")\n" +
-                sb.append("\"").append(((String) value).replace("\"", "\\\"")).append("\"");
+                    "del \"%~f0\""; 
-            } else if (value instanceof Boolean) {
+
-                sb.append(value);
+            try (PrintWriter out = new PrintWriter(batFile)) {
-            } else {
+                out.println(batContent);
-                sb.append("\"").append(value).append("\"");
+            }
-            }
+
-        }
+            // Spieler kicken
-        sb.append("}");
+            try {
-        return sb.toString();
+                for (ProxiedPlayer p : ProxyServer.getInstance().getPlayers()) {
-    }
+                    p.disconnect("§cServer f\"ahrt f\"ur ein Update neu herunter. Bitte etwas warten.");
+                }
+            } catch (Exception ignored) {}
+
+            // Skript starten
+            getLogger().info("Starte Update-Skript im Hintergrund...");
+            try {
+                Runtime.getRuntime().exec("cmd /c start \"Update_Proc\" \"" + batFile.getAbsolutePath() + "\"");
+            } catch (IOException e) {
+                getLogger().warning("Konnte Skript nicht starten. Update wird manuell ben\"otigt.");
+            }
+
+            // Server stoppen
+            ProxyServer.getInstance().stop();
+
+        } catch (Exception e) {
+            getLogger().severe("Fehler beim Vorbereiten des Updates: " + e.getMessage());
+        }
+    }
+
+    @Override
+    public void run() {
+        try (ServerSocket serverSocket = new ServerSocket(port)) {
+            serverSocket.setSoTimeout(1000);
+            while (!Thread.interrupted()) {
+                try {
+                    Socket clientSocket = serverSocket.accept();
+                    handleConnection(clientSocket);
+                } catch (java.net.SocketTimeoutException e) {}
+                catch (IOException e) {
+                    getLogger().warning("Fehler beim Akzeptieren einer Verbindung: " + e.getMessage());
+                }
+            }
+        } catch (IOException e) {
+            getLogger().severe("Konnte ServerSocket nicht starten auf Port " + port + ": " + e.getMessage());
+        }
+    }
+
+    private void handleConnection(Socket clientSocket) {
+        try (BufferedReader in = new BufferedReader(new InputStreamReader(clientSocket.getInputStream(), "UTF-8"));
+             OutputStream out = clientSocket.getOutputStream()) {
+
+            String inputLine = in.readLine();
+            if (inputLine != null && inputLine.startsWith("GET")) {
+                Map<String, Object> data = new LinkedHashMap<>();
+                data.put("online", true);
+
+                // Version
+                String versionRaw = ProxyServer.getInstance().getVersion();
+                String versionClean = versionRaw;
+                if (versionRaw != null && versionRaw.contains(":")) {
+                    String[] parts = versionRaw.split(":");
+                    if (parts.length >= 3) versionClean = parts[2].trim();
+                }
+                data.put("version", versionClean);
+                data.put("max_players", String.valueOf(ProxyServer.getInstance().getConfig().getPlayerLimit()));
+
+                // Motd
+                String motd = "BungeeCord";
+                try {
+                    Iterator<ListenerInfo> it = ProxyServer.getInstance().getConfig().getListeners().iterator();
+                    if (it.hasNext()) {
+                        ListenerInfo listener = it.next();
+                        if (listener != null && listener.getMotd() != null) motd = listener.getMotd();
+                    }
+                } catch (Exception ignored) {}
+                data.put("motd", motd);
+
+                // LuckPerms (Optional)
+                boolean luckPermsEnabled = ProxyServer.getInstance().getPluginManager().getPlugin("LuckPerms") != null;
+                List<Map<String, String>> playersList = new ArrayList<>();
+                for (ProxiedPlayer p : ProxyServer.getInstance().getPlayers()) {
+                    Map<String, String> playerInfo = new LinkedHashMap<>();
+                    playerInfo.put("name", p.getName());
+                    String prefix = "";
+                    if (luckPermsEnabled) {
+                        try {
+                            Class<?> providerClass = Class.forName("net.luckperms.api.LuckPermsProvider");
+                            Object luckPermsApi = providerClass.getMethod("get").invoke(null);
+                            Object userManager = luckPermsApi.getClass().getMethod("getUserManager").invoke(luckPermsApi);
+                            Object user = userManager.getClass().getMethod("getUser", UUID.class).invoke(userManager, p.getUniqueId());
+                            if (user != null) {
+                                Class<?> queryOptionsClass = Class.forName("net.luckperms.api.query.QueryOptions");
+                                Object queryOptions = queryOptionsClass.getMethod("defaultContextualOptions").invoke(null);
+                                Object cachedData = user.getClass().getMethod("getCachedData").invoke(user);
+                                Object metaData = cachedData.getClass().getMethod("getMetaData", queryOptionsClass).invoke(cachedData, queryOptions);
+                                Object result = metaData.getClass().getMethod("getPrefix").invoke(metaData);
+                                if (result != null) prefix = (String) result;
+                            }
+                        } catch (Exception ignored) {}
+                    }
+                    playerInfo.put("prefix", prefix);
+                    playersList.add(playerInfo);
+                }
+                data.put("players", playersList);
+
+                // Response
+                String json = buildJsonString(data);
+                byte[] jsonBytes = json.getBytes("UTF-8");
+                StringBuilder response = new StringBuilder();
+                response.append("HTTP/1.1 200 OK\r\n");
+                response.append("Content-Type: application/json; charset=UTF-8\r\n");
+                response.append("Access-Control-Allow-Origin: *\r\n");
+                response.append("Content-Length: ").append(jsonBytes.length).append("\r\n");
+                response.append("Connection: close\r\n\r\n");
+                out.write(response.toString().getBytes("UTF-8"));
+                out.write(jsonBytes);
+                out.flush();
+            }
+        } catch (Exception e) {
+            getLogger().severe("Fehler beim Verarbeiten der Anfrage: " + e.getMessage());
+        }
+    }
+
+    private String buildJsonString(Map<String, Object> data) {
+        StringBuilder sb = new StringBuilder("{");
+        boolean first = true;
+        for (Map.Entry<String, Object> entry : data.entrySet()) {
+            if (!first) sb.append(",");
+            first = false;
+            sb.append("\"").append(escapeJson(entry.getKey())).append("\":").append(valueToString(entry.getValue()));
+        }
+        sb.append("}");
+        return sb.toString();
+    }
+
+    private String valueToString(Object value) {
+        if (value == null) return "null";
+        else if (value instanceof Boolean) return value.toString();
+        else if (value instanceof List) {
+            StringBuilder sb = new StringBuilder("[");
+            List<?> list = (List<?>) value;
+            for (int i = 0; i < list.size(); i++) {
+                if (i > 0) sb.append(",");
+                Object item = list.get(i);
+                if (item instanceof Map) sb.append(buildJsonString((Map<String, Object>) item));
+                else sb.append("\"").append(escapeJson(String.valueOf(item))).append("\"");
+            }
+            sb.append("]");
+            return sb.toString();
+        }
+        else return "\"" + escapeJson(String.valueOf(value)) + "\"";
+    }
+
+    private String escapeJson(String s) {
+        if (s == null) return "";
+        return s.replace("\\", "\\\\").replace("\"", "\\\"").replace("\n", "\\n").replace("\r", "\\r");
+    }
 }

StatusAPI/src/main/java/net/viper/status/UpdateChecker.java

@@ -0,0 +1,151 @@
+package net.viper.status;
+
+import net.md_5.bungee.api.plugin.Plugin;
+
+import java.io.BufferedReader;
+import java.io.InputStreamReader;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.util.logging.Level;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class UpdateChecker {
+
+    private final Plugin plugin;
+    private final String currentVersion;
+    private final int intervalHours;
+
+    private final String apiUrl = "https://git.viper.ipv64.net/api/v1/repos/M_Viper/Minecraft-BungeeCord-Status/releases";
+
+    private volatile String latestVersion = "";
+    private volatile String latestUrl = "";
+
+    // Pattern für Dateinamen im Assets-Array
+    private static final Pattern ASSET_NAME_PATTERN = Pattern.compile("\"name\"\\s*:\\s*\"([^\"]+)\"", Pattern.CASE_INSENSITIVE);
+    // Pattern für Download-URL
+    private static final Pattern DOWNLOAD_PATTERN = Pattern.compile("\"browser_download_url\"\\s*:\\s*\"([^\"]+)\"", Pattern.CASE_INSENSITIVE);
+    // Pattern für Tag Version (WICHTIG: Wir suchen global, um das Haupt-Release zu finden)
+    private static final Pattern TAG_NAME_PATTERN = Pattern.compile("\"tag_name\"\\s*:\\s*\"([^\"]+)\"", Pattern.CASE_INSENSITIVE);
+
+    public UpdateChecker(Plugin plugin, String currentVersion, int intervalHours) {
+        this.plugin = plugin;
+        this.currentVersion = currentVersion != null ? currentVersion : "0.0.0";
+        this.intervalHours = Math.max(1, intervalHours);
+    }
+
+    public void checkNow() {
+        try {
+            HttpURLConnection conn = (HttpURLConnection) new URL(apiUrl).openConnection();
+            conn.setRequestMethod("GET");
+            conn.setRequestProperty("Accept", "application/json");
+            conn.setRequestProperty("User-Agent", "StatusAPI-UpdateChecker/2.0");
+            conn.setConnectTimeout(5000);
+            conn.setReadTimeout(5000);
+
+            int code = conn.getResponseCode();
+            if (code != 200) {
+                plugin.getLogger().warning("Gitea API nicht erreichbar (HTTP " + code + ")");
+                return;
+            }
+
+            StringBuilder sb = new StringBuilder();
+            try (BufferedReader br = new BufferedReader(new InputStreamReader(conn.getInputStream(), "UTF-8"))) {
+                String line;
+                while ((line = br.readLine()) != null) sb.append(line).append("\n");
+            }
+
+            String body = sb.toString();
+
+            // 1. Die LATEST Version (Tag) finden
+            // Wir suchen das erste "tag_name" im gesamten JSON, das ist meistens das neueste Release.
+            String foundVersion = null;
+            Matcher tagM = TAG_NAME_PATTERN.matcher(body);
+            if (tagM.find()) {
+                foundVersion = tagM.group(1).trim();
+            }
+
+            if (foundVersion == null) {
+                plugin.getLogger().warning("Keine Version (Tag) im Release gefunden.");
+                return;
+            }
+
+            // Version säubern (v vorne entfernen)
+            if (foundVersion.startsWith("v") || foundVersion.startsWith("V")) {
+                foundVersion = foundVersion.substring(1);
+            }
+
+            // 2. Download URL für StatusAPI.jar finden
+            // Wir suchen das Asset "StatusAPI.jar"
+            String foundUrl = null;
+            
+            Pattern releasePattern = Pattern.compile("(?s)\\{.*?\\}");
+            Matcher releaseMatcher = releasePattern.matcher(body);
+            while (releaseMatcher.find()) {
+                String block = releaseMatcher.group();
+                java.util.List<String> names = new java.util.ArrayList<>();
+                java.util.List<String> downloads = new java.util.ArrayList<>();
+
+                Matcher nm = ASSET_NAME_PATTERN.matcher(block);
+                while (nm.find()) names.add(nm.group(1));
+
+                Matcher dm = DOWNLOAD_PATTERN.matcher(block);
+                while (dm.find()) downloads.add(dm.group(1));
+
+                int pairs = Math.min(names.size(), downloads.size());
+                for (int i = 0; i < pairs; i++) {
+                    String name = names.get(i);
+                    String dl = downloads.get(i);
+                    if ("StatusAPI.jar".equalsIgnoreCase(name.trim())) {
+                        foundUrl = dl;
+                        break;
+                    }
+                }
+                if (foundUrl != null) break;
+            }
+
+            if (foundUrl == null) {
+                plugin.getLogger().warning("Keine JAR-Datei für dieses Release gefunden.");
+                return;
+            }
+
+            plugin.getLogger().info("Gefundene Version: " + foundVersion + " (Aktuell: " + currentVersion + ")");
+            
+            latestVersion = foundVersion;
+            latestUrl = foundUrl;
+
+        } catch (Exception e) {
+            plugin.getLogger().log(Level.SEVERE, "Fehler beim Update-Check: " + e.getMessage(), e);
+        }
+    }
+
+    public String getLatestVersion() {
+        return latestVersion != null ? latestVersion : "";
+    }
+
+    public String getLatestUrl() {
+        return latestUrl != null ? latestUrl : "";
+    }
+
+    public boolean isUpdateAvailable(String currentVer) {
+        String lv = getLatestVersion();
+        if (lv.isEmpty()) return false;
+        return compareVersions(lv, currentVer) > 0;
+    }
+
+    private int compareVersions(String a, String b) {
+        try {
+            String[] aa = a.split("\\.");
+            String[] bb = b.split("\\.");
+            int len = Math.max(aa.length, bb.length);
+            for (int i = 0; i < len; i++) {
+                int ai = i < aa.length ? Integer.parseInt(aa[i].replaceAll("\\D","")) : 0;
+                int bi = i < bb.length ? Integer.parseInt(bb[i].replaceAll("\\D","")) : 0;
+                if (ai != bi) return Integer.compare(ai, bi);
+            }
+            return 0;
+        } catch (Exception ex) {
+            return a.compareTo(b);
+        }
+    }
+}

StatusAPI/src/main/resources/plugin.yml

@@ -1,4 +1,13 @@
-name: StatusAPI
+name: StatusAPI
-version: 1.0
+main: net.viper.status.StatusAPI
-main: net.viper.status.StatusAPI
+version: 3.6.2
-author: M_Viper
+author: M_Viper
+description: StatusAPI für BungeeCord inkl. Update-Checker
+
+softdepend:
+  - LuckPerms
+
+permissions:
+  statusapi.update.notify:
+    description: 'Erlaubt Update-Benachrichtigungen'
+    default: op