shinuwa/gameservers-control
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

MVP version

Browse source
This commit is contained in:
Shinuwa 2026-06-12 14:34:44 +02:00
commit 3f96943858
25 changed files with 3962 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

31
.env.example Normal file
View file

@ -0,0 +1,31 @@
# Port HTTP de l'interface web.
# Exemple: PORT=8080
PORT=3000
# Chemin du JSON de statut partage depuis la VM des serveurs de jeu.
# En production, renseigner le chemin du montage NFS.
# Exemple: GAMESERVERS_STATUS_FILE=/mnt/gameservers/status.json
GAMESERVERS_STATUS_FILE=./mocked/dev-gameservers-status.json
# Dossier de stockage local de l'application.
# Contient notamment groups.json, servers.json, launch-logs.json et server-images/.
STORAGE_DIR=./storage
# Duree de validite des sessions web, en heures.
SESSION_TTL_HOURS=12
# Profils de lancement SSH.
# Chaque serveur dans storage/servers.json reference un profil via startProfile.
# Exemple: "startProfile": "GAME_1" utilise GAME_1_SSH_TARGET, GAME_1_SSH_PORT et GAME_1_START_COMMAND.
# La cible peut etre un alias SSH, un hostname, une IP, ou user@host.
# Exemples:
# GAME_1_SSH_TARGET=game-server
# GAME_1_SSH_PORT=2222
# GAME_1_SSH_TARGET=user@192.0.2.10
GAME_1_SSH_TARGET=game-server-1
GAME_1_SSH_PORT=
GAME_1_START_COMMAND="bash /opt/game-server-1/start.sh"
GAME_2_SSH_TARGET=game-server-2
GAME_2_SSH_PORT=
GAME_2_START_COMMAND="bash /opt/game-server-2/start.sh"

7
.gitignore vendored Normal file
View file

@ -0,0 +1,7 @@
node_modules/
.env
npm-debug.log*
storage/groups.json
storage/launch-logs.json
storage/server-images.json
storage/server-images/

53
README.md Normal file
View file

@ -0,0 +1,53 @@
# gameservers-control
Interface web locale pour consulter et lancer des serveurs de jeux.
## Demarrage
```bash
npm install
cp .env.example .env
npm run dev
```
Variables utiles:
- `PORT`: port HTTP, defaut `3000`.
- `GAMESERVERS_STATUS_FILE`: chemin du JSON de statut monte en NFS.
- `STORAGE_DIR`: dossier de stockage local, defaut `storage`.
- `SESSION_TTL_HOURS`: duree des sessions, defaut `12`.
- `*_SSH_TARGET`: cible SSH du profil de lancement, alias SSH ou `user@host`.
- `*_SSH_PORT`: port SSH optionnel. Vide par defaut.
- `*_START_COMMAND`: commande distante executee sur la cible SSH.
Pour changer le port, modifier `.env`:
```env
PORT=8080
```
Exemple de lancement distant via SSH:
```env
GAME_1_SSH_TARGET=user@192.0.2.10
GAME_1_SSH_PORT=2222
GAME_1_START_COMMAND="bash /opt/game-server-1/start.sh"
```
Le serveur local doit reference ce profil dans `storage/servers.json`:
```json
{
"id": "game-1",
"startProfile": "GAME_1"
}
```
Au premier demarrage, si aucun groupe n'existe, un groupe `admin` est cree et son mot de passe temporaire est affiche dans les logs serveur.
## Stockage
- `storage/servers.json`: configuration locale des serveurs, profils de lancement, secrets.
- `storage/groups.json`: groupes et permissions.
- `storage/launch-logs.json`: lancements conserves 7 jours.
- `mocked/dev-gameservers-status.json`: statut mock de developpement.

16
mocked/dev-gameservers-status.json Normal file
View file

@ -0,0 +1,16 @@
{
"servers": [
{
"game": "Jeu 1",
"address": "srv.mocked.com:12345",
"port": 12345,
"active": false
},
{
"game": "Jeu 2",
"address": "srv.mocked.com:67890",
"port": 67890,
"active": true
}
]
}

1008
package-lock.json generated Normal file
View file

File diff suppressed because it is too large Load diff

17
package.json Normal file
View file

@ -0,0 +1,17 @@
{
"name": "gameservers-control",
"version": "1.0.0",
"description": "Interface web de controle des serveurs de jeux",
"type": "module",
"main": "src/server.js",
"scripts": {
"start": "node --env-file-if-exists=.env src/server.js",
"dev": "NODE_ENV=development node --env-file-if-exists=.env src/server.js",
"test": "node --test"
},
"dependencies": {
"express": "^5.1.0",
"multer": "^2.0.2"
},
"devDependencies": {}
}

116
public/index.html Normal file
View file

@ -0,0 +1,116 @@
<!doctype html>
<html lang="fr">
<head>
<meta charset="utf-8" />
<meta name="viewport" content="width=device-width, initial-scale=1" />
<title>Shinuwa GS Control</title>
<link rel="stylesheet" href="/styles/app.css" />
</head>
<body>
<header class="topbar">
<div class="brand">
<div class="brand__mark" aria-hidden="true">
<span></span>
</div>
<div>
<h1>Shinuwa</h1>
<p>GS Control · <span id="sessionLabel">Non connecte</span></p>
</div>
</div>
<div class="topbar__actions">
<button class="btn btn--ghost" id="refreshBtn" type="button" hidden>Rafraichir</button>
<button class="btn btn--ghost" id="logoutBtn" type="button" hidden>Deconnexion</button>
</div>
</header>
<main class="shell">
<div id="status" class="status" hidden></div>
<section class="panel login-panel" id="loginView">
<div class="login-panel__intro">
<div class="brand__mark brand__mark--large" aria-hidden="true">
<span></span>
</div>
<p class="eyebrow">Acces securise</p>
<h2>GS Control</h2>
</div>
<form id="loginForm" class="stack">
<label for="passwordInput">Mot de passe</label>
<input id="passwordInput" type="password" autocomplete="current-password" required />
<button class="btn" type="submit">Se connecter</button>
</form>
</section>
<section id="appView" hidden>
<nav class="tabs" aria-label="Navigation">
<button class="tab tab--active" data-tab="servers" type="button">Serveurs</button>
<button class="tab" data-tab="admin" type="button" id="adminTab" hidden>Admin</button>
<button class="tab" data-tab="logs" type="button" id="logsTab" hidden>Logs</button>
</nav>
<section class="panel" data-panel="servers">
<div class="panel__header">
<div>
<p class="eyebrow">Tableau de bord</p>
<h2>Serveurs disponibles</h2>
<p>Statut synchronise toutes les 5 minutes.</p>
</div>
</div>
<div class="server-grid" id="serversBody"></div>
</section>
<section class="panel" data-panel="admin" hidden>
<div class="panel__header">
<div>
<h2>Groupes</h2>
<p>Gestion des mots de passe et permissions serveur.</p>
</div>
<button class="btn btn--ghost btn--small" id="cleanupServersBtn" type="button">
Nettoyer les serveurs absents
</button>
</div>
<form id="createGroupForm" class="inline-form">
<input id="newGroupName" type="text" placeholder="Nom du groupe" required />
<input
id="newGroupPassword"
type="text"
placeholder="Mot de passe optionnel"
autocomplete="off"
/>
<div class="inline-form__actions">
<button class="btn" type="submit">Creer</button>
</div>
</form>
<div id="generatedPassword" class="notice" hidden></div>
<h3 class="section-title">Groupes existants</h3>
<div id="groupsList" class="groups-grid"></div>
</section>
<section class="panel" data-panel="logs" hidden>
<div class="panel__header">
<div>
<h2>Logs de lancement</h2>
<p>Conservation automatique sur 7 jours.</p>
</div>
</div>
<div class="table-wrap">
<table>
<thead>
<tr>
<th>Date</th>
<th>Groupe</th>
<th>Serveur</th>
</tr>
</thead>
<tbody id="logsBody"></tbody>
</table>
</div>
</section>
</section>
</main>
<script type="module" src="/scripts/app.js"></script>
</body>
</html>

583
public/scripts/app.js Normal file
View file

@ -0,0 +1,583 @@
const TOKEN_KEY = "gameservers-control-token";
const state = {
token: localStorage.getItem(TOKEN_KEY) || "",
session: null,
servers: [],
groups: [],
allServers: [],
};
const els = {
status: document.getElementById("status"),
sessionLabel: document.getElementById("sessionLabel"),
loginView: document.getElementById("loginView"),
appView: document.getElementById("appView"),
loginForm: document.getElementById("loginForm"),
passwordInput: document.getElementById("passwordInput"),
logoutBtn: document.getElementById("logoutBtn"),
refreshBtn: document.getElementById("refreshBtn"),
adminTab: document.getElementById("adminTab"),
logsTab: document.getElementById("logsTab"),
serversBody: document.getElementById("serversBody"),
logsBody: document.getElementById("logsBody"),
groupsList: document.getElementById("groupsList"),
createGroupForm: document.getElementById("createGroupForm"),
newGroupName: document.getElementById("newGroupName"),
newGroupPassword: document.getElementById("newGroupPassword"),
generatedPassword: document.getElementById("generatedPassword"),
cleanupServersBtn: document.getElementById("cleanupServersBtn"),
};
function setStatus(message, type = "info") {
els.status.textContent = message;
els.status.className = `status status--${type}`;
els.status.hidden = false;
}
function clearStatus() {
els.status.hidden = true;
els.status.textContent = "";
}
async function apiFetch(path, options = {}) {
const headers = new Headers(options.headers || {});
if (state.token) headers.set("Authorization", `Bearer ${state.token}`);
const isFormData = options.body instanceof FormData;
if (options.body && !isFormData && !headers.has("Content-Type")) {
headers.set("Content-Type", "application/json");
}
const response = await fetch(path, {
method: options.method || "GET",
headers,
body:
options.body && !isFormData && typeof options.body !== "string"
? JSON.stringify(options.body)
: options.body,
});
const contentType = response.headers.get("content-type") || "";
const payload = contentType.includes("application/json")
? await response.json()
: await response.text();
if (!response.ok) {
throw new Error(payload?.error || response.statusText);
}
return payload;
}
function setAuthenticated({ token, session }) {
if (token) {
state.token = token;
localStorage.setItem(TOKEN_KEY, token);
}
state.session = session;
els.loginView.hidden = true;
els.appView.hidden = false;
els.logoutBtn.hidden = false;
els.refreshBtn.hidden = false;
els.adminTab.hidden = !session.admin;
els.logsTab.hidden = !session.admin;
els.sessionLabel.textContent = session.admin ? "Administrateur" : "Connecte";
}
function setLoggedOut() {
state.token = "";
state.session = null;
localStorage.removeItem(TOKEN_KEY);
els.loginView.hidden = false;
els.appView.hidden = true;
els.logoutBtn.hidden = true;
els.refreshBtn.hidden = true;
els.sessionLabel.textContent = "Non connecte";
switchTab("servers");
}
async function loadSession() {
if (!state.token) return setLoggedOut();
try {
const data = await apiFetch("/api/session");
setAuthenticated({ session: data.session });
await refreshAll();
} catch {
setLoggedOut();
}
}
async function refreshAll() {
await loadServers();
if (state.session?.admin) {
await Promise.all([loadAdmin(), loadLogs()]);
}
}
async function loadServers() {
const data = await apiFetch("/api/servers");
state.servers = data.servers || [];
renderServers();
}
function renderServers() {
els.serversBody.innerHTML = "";
if (!state.servers.length) {
els.serversBody.innerHTML = `<div class="empty-state">Aucun serveur visible.</div>`;
return;
}
for (const server of state.servers) {
const card = document.createElement("article");
card.className = "server-card";
const heroStyle = server.heroImage
? ` style="--server-hero-image: url('${escapeCssUrl(server.heroImage)}')"`
: "";
const secrets = server.secrets && Object.keys(server.secrets).length
? Object.entries(server.secrets)
.map(
([key, value]) => `
<div class="info-row">
<span>${escapeHtml(formatSecretLabel(key))}</span>
<code>${escapeHtml(value)}</code>
</div>
`
)
.join("")
: server.hasSecrets
? `<span class="muted">Masques</span>`
: `
<div class="info-row info-row--empty">
<span>Mot de passe</span>
<strong>aucun</strong>
</div>
`;
card.innerHTML = `
<div class="server-card__hero"${heroStyle}>
<div class="server-card__icon" aria-hidden="true"></div>
<span class="chip ${server.active ? "chip--online" : "chip--offline"}">
${server.active ? "En ligne" : "Hors ligne"}
</span>
</div>
<div class="server-card__body">
<div>
<p class="server-card__kicker">Serveur jeu</p>
<h3>${escapeHtml(server.game)}</h3>
</div>
<div class="server-card__details">
<div class="info-row">
<span>Adresse IP</span>
<code>${escapeHtml(server.address || "-")}</code>
</div>
<div class="info-row">
<span>Port</span>
<strong>${server.port ?? "-"}</strong>
</div>
</div>
<div class="server-password">
${secrets}
</div>
</div>
<div class="server-card__actions">
<button class="btn btn--small" data-start="${escapeHtml(server.id)}" ${server.canStart ? "" : "disabled"}>
Lancer le serveur
</button>
${renderAdminEditButton(server)}
${renderAdminEditPanel(server)}
</div>
`;
els.serversBody.appendChild(card);
}
}
function renderAdminEditButton(server) {
if (!state.session?.admin) return "";
return `
<button
class="btn btn--small btn--ghost btn--icon"
data-edit-server="${escapeHtml(server.id)}"
type="button"
title="Editer le serveur"
aria-label="Editer le serveur"
>
✎
</button>
`;
}
function renderAdminEditPanel(server) {
if (!state.session?.admin) return "";
return `
<div class="server-edit-panel" data-edit-panel="${escapeHtml(server.id)}" hidden>
${renderPasswordControls(server)}
${renderImageControls(server)}
</div>
`;
}
function renderPasswordControls(server) {
if (!state.session?.admin) return "";
const password = getServerPasswordValue(server);
return `
<div class="password-controls">
<label class="file-control">
<span>Mot de passe</span>
<input
type="text"
value="${escapeHtml(password)}"
data-password-input="${escapeHtml(server.id)}"
autocomplete="off"
/>
</label>
<button class="btn btn--small btn--ghost" data-save-password="${escapeHtml(server.id)}" type="button">
Sauver
</button>
</div>
`;
}
function renderImageControls(server) {
if (!state.session?.admin) return "";
return `
<div class="image-controls">
<label class="file-control">
<span>Image</span>
<input type="file" accept="image/png,image/jpeg,image/webp" data-image-input="${escapeHtml(server.id)}" />
</label>
<div class="image-controls__actions">
<button class="btn btn--small btn--ghost" data-upload-image="${escapeHtml(server.id)}" type="button">
Envoyer
</button>
<button class="btn btn--small btn--danger" data-delete-image="${escapeHtml(server.id)}" type="button" ${server.heroImage ? "" : "disabled"}>
Retirer
</button>
</div>
</div>
`;
}
function getServerPasswordValue(server) {
if (!server.secrets) return "";
return server.secrets.serverPassword || server.secrets.password || "";
}
async function startServer(serverId, button) {
button.disabled = true;
const previous = button.textContent;
button.textContent = "Lancement...";
try {
await apiFetch(`/api/servers/${encodeURIComponent(serverId)}/start`, { method: "POST" });
setStatus("Lancement demande", "success");
await refreshAll();
} catch (error) {
setStatus(error.message, "error");
button.disabled = false;
} finally {
button.textContent = previous;
}
}
async function uploadServerImage(serverId) {
const input = document.querySelector(`[data-image-input="${cssEscape(serverId)}"]`);
const file = input?.files?.[0];
if (!file) {
setStatus("Choisis une image avant l'envoi", "error");
return;
}
const formData = new FormData();
formData.set("image", file);
await apiFetch(`/api/admin/servers/${encodeURIComponent(serverId)}/image`, {
method: "POST",
body: formData,
});
setStatus("Image serveur mise a jour", "success");
await refreshAll();
}
async function deleteServerImage(serverId) {
await apiFetch(`/api/admin/servers/${encodeURIComponent(serverId)}/image`, {
method: "DELETE",
});
setStatus("Image serveur retiree", "success");
await refreshAll();
}
function toggleServerEditPanel(serverId) {
const panel = document.querySelector(`[data-edit-panel="${cssEscape(serverId)}"]`);
if (!panel) return;
panel.hidden = !panel.hidden;
}
async function saveServerPassword(serverId) {
const input = document.querySelector(`[data-password-input="${cssEscape(serverId)}"]`);
await apiFetch(`/api/admin/servers/${encodeURIComponent(serverId)}/password`, {
method: "PATCH",
body: { password: input?.value || "" },
});
setStatus("Mot de passe serveur mis a jour", "success");
await refreshAll();
}
async function loadAdmin() {
const data = await apiFetch("/api/admin/groups");
state.groups = data.groups || [];
state.allServers = data.servers || [];
renderGroups();
}
function renderGroups() {
els.groupsList.innerHTML = "";
for (const group of state.groups) {
const article = document.createElement("article");
article.className = "group-card";
const permissions = group.permissions || { servers: [] };
article.innerHTML = `
<div class="group-card__header">
<input class="group-name" value="${escapeHtml(group.name)}" data-name="${escapeHtml(group.id)}" />
<span class="chip">${group.admin ? "Admin" : "Groupe"}</span>
</div>
<div class="server-perms">
${state.allServers
.map(
(server) => `
<label class="check">
<input type="checkbox" data-server-perm="${escapeHtml(group.id)}" value="${escapeHtml(server.id)}" ${permissions.servers.includes(server.id) ? "checked" : ""} ${group.admin ? "disabled" : ""} />
${escapeHtml(server.game)}
</label>
`
)
.join("")}
</div>
<div class="manual-password">
<label class="file-control">
<span>Mot de passe</span>
<input
type="text"
placeholder="Nouveau mot de passe"
data-group-password="${escapeHtml(group.id)}"
autocomplete="off"
/>
</label>
</div>
<div class="card-actions">
<button class="btn btn--small" data-save-group="${escapeHtml(group.id)}">Sauver</button>
<button class="btn btn--small btn--ghost" data-set-group-password="${escapeHtml(group.id)}">Set mdp</button>
<button class="btn btn--small btn--ghost" data-regen="${escapeHtml(group.id)}">Regenerer mdp</button>
<button class="btn btn--small btn--danger" data-delete="${escapeHtml(group.id)}" ${group.id === "admin" ? "disabled" : ""}>Supprimer</button>
</div>
`;
els.groupsList.appendChild(article);
}
}
async function saveGroup(groupId) {
const name = document.querySelector(`[data-name="${cssEscape(groupId)}"]`)?.value.trim();
const servers = Array.from(document.querySelectorAll(`[data-server-perm="${cssEscape(groupId)}"]:checked`)).map(
(input) => input.value
);
await apiFetch(`/api/admin/groups/${encodeURIComponent(groupId)}`, {
method: "PATCH",
body: {
name,
permissions: { servers },
},
});
setStatus("Groupe sauvegarde", "success");
await loadAdmin();
}
async function regeneratePassword(groupId) {
const data = await apiFetch(`/api/admin/groups/${encodeURIComponent(groupId)}/regenerate-password`, {
method: "POST",
});
showGeneratedPassword(data.group.name, data.password);
await loadAdmin();
}
async function setGroupPassword(groupId) {
const input = document.querySelector(`[data-group-password="${cssEscape(groupId)}"]`);
const password = input?.value.trim() || "";
if (!password) {
setStatus("Mot de passe requis", "error");
return;
}
const data = await apiFetch(`/api/admin/groups/${encodeURIComponent(groupId)}/password`, {
method: "PATCH",
body: { password },
});
input.value = "";
showGeneratedPassword(data.group.name, data.password);
await loadAdmin();
}
async function deleteGroup(groupId) {
await apiFetch(`/api/admin/groups/${encodeURIComponent(groupId)}`, { method: "DELETE" });
setStatus("Groupe supprime", "success");
await loadAdmin();
}
async function createGroup(event) {
event.preventDefault();
const data = await apiFetch("/api/admin/groups", {
method: "POST",
body: {
name: els.newGroupName.value.trim(),
password: els.newGroupPassword.value.trim(),
permissions: { servers: [] },
},
});
els.createGroupForm.reset();
showGeneratedPassword(data.group.name, data.password);
await loadAdmin();
}
async function cleanupServers() {
const data = await apiFetch("/api/admin/servers/cleanup", { method: "POST" });
const removedCount = data.removedServers?.length || 0;
const imageCount = data.removedImages?.length || 0;
setStatus(
`Nettoyage termine: ${removedCount} configuration(s), ${imageCount} image(s) retiree(s)`,
"success"
);
await refreshAll();
}
function showGeneratedPassword(groupName, password) {
els.generatedPassword.hidden = false;
els.generatedPassword.innerHTML = `Mot de passe pour <strong>${escapeHtml(groupName)}</strong>: <code>${escapeHtml(password)}</code>`;
}
async function loadLogs() {
const data = await apiFetch("/api/logs");
renderLogs(data.logs || []);
}
function renderLogs(logs) {
els.logsBody.innerHTML = "";
if (!logs.length) {
els.logsBody.innerHTML = `<tr><td colspan="3" class="muted">Aucun lancement sur 7 jours.</td></tr>`;
return;
}
for (const log of logs) {
const tr = document.createElement("tr");
tr.innerHTML = `
<td>${escapeHtml(new Date(log.createdAt).toLocaleString())}</td>
<td>${escapeHtml(log.groupName || log.groupId || "-")}</td>
<td>${escapeHtml(log.serverName || log.serverId || "-")}</td>
`;
els.logsBody.appendChild(tr);
}
}
function switchTab(tabName) {
document.querySelectorAll(".tab").forEach((tab) => {
tab.classList.toggle("tab--active", tab.dataset.tab === tabName);
});
document.querySelectorAll("[data-panel]").forEach((panel) => {
panel.hidden = panel.dataset.panel !== tabName;
});
}
function escapeHtml(value = "") {
return String(value)
.replace(/&/g, "&amp;")
.replace(/</g, "&lt;")
.replace(/>/g, "&gt;")
.replace(/"/g, "&quot;")
.replace(/'/g, "&#039;");
}
function escapeCssUrl(value = "") {
return String(value).replace(/['"\\\n\r]/g, "");
}
function formatSecretLabel(key = "") {
if (key === "password" || key === "serverPassword") {
return "Mot de passe";
}
return key;
}
function cssEscape(value) {
return CSS.escape(value);
}
els.loginForm.addEventListener("submit", async (event) => {
event.preventDefault();
clearStatus();
try {
const data = await apiFetch("/api/login", {
method: "POST",
body: { password: els.passwordInput.value },
});
els.passwordInput.value = "";
setAuthenticated(data);
await refreshAll();
} catch (error) {
setStatus(error.message, "error");
}
});
els.logoutBtn.addEventListener("click", async () => {
try {
await apiFetch("/api/logout", { method: "POST" });
} catch {
// Local logout remains valid if the server session already expired.
}
setLoggedOut();
});
els.refreshBtn.addEventListener("click", () => refreshAll().catch((error) => setStatus(error.message, "error")));
els.createGroupForm.addEventListener("submit", (event) =>
createGroup(event).catch((error) => setStatus(error.message, "error"))
);
els.cleanupServersBtn?.addEventListener("click", () =>
cleanupServers().catch((error) => setStatus(error.message, "error"))
);
document.addEventListener("click", (event) => {
const target = event.target;
if (!(target instanceof HTMLElement)) return;
const tab = target.closest("[data-tab]");
if (tab) switchTab(tab.dataset.tab);
const startId = target.dataset.start;
if (startId) startServer(startId, target).catch((error) => setStatus(error.message, "error"));
const saveId = target.dataset.saveGroup;
if (saveId) saveGroup(saveId).catch((error) => setStatus(error.message, "error"));
const regenId = target.dataset.regen;
if (regenId) regeneratePassword(regenId).catch((error) => setStatus(error.message, "error"));
const setPasswordId = target.dataset.setGroupPassword;
if (setPasswordId) setGroupPassword(setPasswordId).catch((error) => setStatus(error.message, "error"));
const deleteId = target.dataset.delete;
if (deleteId) deleteGroup(deleteId).catch((error) => setStatus(error.message, "error"));
const uploadImageId = target.dataset.uploadImage;
if (uploadImageId) uploadServerImage(uploadImageId).catch((error) => setStatus(error.message, "error"));
const deleteImageId = target.dataset.deleteImage;
if (deleteImageId) deleteServerImage(deleteImageId).catch((error) => setStatus(error.message, "error"));
const editServerId = target.dataset.editServer;
if (editServerId) toggleServerEditPanel(editServerId);
const savePasswordId = target.dataset.savePassword;
if (savePasswordId) saveServerPassword(savePasswordId).catch((error) => setStatus(error.message, "error"));
});
loadSession();

755
public/styles/app.css Normal file
View file

@ -0,0 +1,755 @@
:root {
color-scheme: dark;
--bg: #0d1117;
--bg-deep: #050814;
--panel: rgba(12, 18, 35, 0.82);
--panel-strong: rgba(17, 24, 43, 0.94);
--panel-soft: rgba(20, 27, 48, 0.68);
--line: rgba(115, 92, 255, 0.24);
--line-strong: rgba(119, 92, 255, 0.55);
--text: #f7f8ff;
--muted: #9da8c4;
--muted-2: #6f7a98;
--purple: #7b5cff;
--blue: #0084ff;
--cyan: #00e6d2;
--pink: #ff4d9d;
--green: #00e602;
--orange: #ffb020;
--danger: #ff4d6d;
--shadow: 0 24px 70px rgba(0, 0, 0, 0.42);
--radius: 8px;
--font-display: Orbitron, "Rajdhani", "Segoe UI", system-ui, sans-serif;
--font-body: Inter, "Segoe UI", system-ui, -apple-system, BlinkMacSystemFont, sans-serif;
}
* {
box-sizing: border-box;
}
[hidden] {
display: none !important;
}
body {
margin: 0;
min-height: 100vh;
background:
radial-gradient(circle at 8% 72%, rgba(0, 132, 255, 0.34), transparent 28%),
radial-gradient(circle at 76% 14%, rgba(123, 92, 255, 0.28), transparent 24%),
radial-gradient(circle at 52% 88%, rgba(255, 77, 157, 0.12), transparent 26%),
linear-gradient(140deg, #050814 0%, #0a1020 46%, #050814 100%);
color: var(--text);
font-family: var(--font-body);
overflow-x: hidden;
}
body::before,
body::after {
content: "";
position: fixed;
inset: 0;
pointer-events: none;
z-index: -1;
}
body::before {
background-image:
radial-gradient(circle, rgba(255, 255, 255, 0.82) 0 1px, transparent 1.5px),
radial-gradient(circle, rgba(123, 92, 255, 0.65) 0 1px, transparent 1.5px),
linear-gradient(120deg, transparent 0 60%, rgba(0, 230, 210, 0.08) 61%, transparent 75%);
background-position: 0 0, 42px 76px, 0 0;
background-size: 150px 150px, 230px 230px, 100% 100%;
opacity: 0.28;
}
body::after {
background:
linear-gradient(rgba(123, 92, 255, 0.045) 1px, transparent 1px),
linear-gradient(90deg, rgba(0, 132, 255, 0.04) 1px, transparent 1px);
background-size: 54px 54px;
mask-image: linear-gradient(to bottom, transparent, #000 16%, #000 82%, transparent);
}
button,
input {
font: inherit;
}
button {
letter-spacing: 0;
}
.topbar {
display: flex;
align-items: center;
justify-content: space-between;
gap: 1rem;
padding: 1rem 1.25rem;
border-bottom: 1px solid var(--line);
background: rgba(5, 8, 20, 0.82);
backdrop-filter: blur(18px);
position: sticky;
top: 0;
z-index: 10;
box-shadow: 0 16px 50px rgba(0, 0, 0, 0.32);
}
.brand {
display: flex;
align-items: center;
gap: 0.85rem;
min-width: 0;
}
.brand h1 {
margin: 0;
font-family: var(--font-display);
font-size: clamp(1.35rem, 2vw, 1.85rem);
line-height: 1;
letter-spacing: 0.16em;
text-transform: uppercase;
}
.brand p,
.panel p,
.topbar p {
margin: 0.28rem 0 0;
color: var(--muted);
}
.brand__mark {
width: 44px;
aspect-ratio: 1;
border: 2px solid var(--purple);
border-radius: 50%;
position: relative;
box-shadow: 0 0 22px rgba(123, 92, 255, 0.5), inset 0 0 18px rgba(0, 132, 255, 0.24);
flex: 0 0 auto;
}
.brand__mark::before {
content: "";
position: absolute;
inset: 10px -8px;
border: 3px solid transparent;
border-top-color: var(--purple);
border-bottom-color: var(--blue);
border-radius: 50%;
rotate: -34deg;
}
.brand__mark span,
.brand__mark span::before,
.brand__mark span::after {
position: absolute;
width: 7px;
aspect-ratio: 1;
background: var(--text);
box-shadow: 0 0 14px var(--blue);
transform: rotate(45deg);
}
.brand__mark span {
top: 18px;
left: 17px;
}
.brand__mark span::before,
.brand__mark span::after {
content: "";
}
.brand__mark span::before {
width: 5px;
top: -14px;
left: 13px;
}
.brand__mark span::after {
width: 4px;
top: 14px;
left: 18px;
background: var(--blue);
}
.brand__mark--large {
width: 92px;
margin: 0 auto 1.2rem;
}
.brand__mark--large span {
top: 40px;
left: 40px;
}
.topbar__actions,
.card-actions,
.inline-form {
display: flex;
gap: 0.75rem;
align-items: center;
flex-wrap: wrap;
}
.inline-form {
margin-bottom: 1rem;
}
.inline-form input[type="text"] {
flex: 1 1 280px;
}
.inline-form__actions {
flex-basis: 100%;
}
.shell {
width: min(1360px, 100%);
margin: 0 auto;
padding: 1.25rem;
}
.panel {
background: linear-gradient(145deg, var(--panel), rgba(7, 12, 26, 0.86));
border: 1px solid var(--line);
border-radius: var(--radius);
box-shadow: var(--shadow);
padding: 1.25rem;
margin-bottom: 1rem;
position: relative;
overflow: hidden;
}
.panel::before {
content: "";
position: absolute;
inset: 0;
background:
linear-gradient(90deg, rgba(123, 92, 255, 0.08), transparent 26%),
linear-gradient(180deg, rgba(0, 132, 255, 0.08), transparent 34%);
pointer-events: none;
}
.panel > * {
position: relative;
}
.login-panel {
max-width: 460px;
margin: 5rem auto 0;
padding: 2rem;
}
.login-panel__intro {
text-align: center;
margin-bottom: 1.5rem;
}
.panel__header {
display: flex;
justify-content: space-between;
gap: 1rem;
margin-bottom: 1.2rem;
}
h2,
h3 {
margin: 0;
font-family: var(--font-display);
letter-spacing: 0.08em;
text-transform: uppercase;
}
h2 {
font-size: 1.12rem;
}
h3 {
font-size: 1rem;
line-height: 1.35;
}
.eyebrow,
.server-card__kicker {
color: var(--purple);
font-family: var(--font-display);
font-size: 0.78rem;
font-weight: 800;
letter-spacing: 0.14em;
text-transform: uppercase;
}
.stack {
display: grid;
gap: 0.8rem;
}
label {
color: var(--muted);
}
input[type="text"],
input[type="password"] {
width: 100%;
color: var(--text);
background: rgba(8, 13, 30, 0.88);
border: 1px solid rgba(120, 143, 190, 0.32);
border-radius: 6px;
min-height: 2.75rem;
padding: 0.72rem 0.85rem;
box-shadow: inset 0 0 0 1px rgba(255, 255, 255, 0.02);
}
input::placeholder {
color: var(--muted-2);
}
input:focus {
outline: 2px solid rgba(123, 92, 255, 0.5);
border-color: var(--purple);
}
.btn {
border: 1px solid transparent;
border-radius: 7px;
background: linear-gradient(120deg, var(--purple), var(--blue));
color: #fff;
cursor: pointer;
font-family: var(--font-display);
font-size: 0.82rem;
font-weight: 800;
min-height: 2.55rem;
padding: 0.68rem 1rem;
text-transform: uppercase;
transition: border-color 0.16s ease, box-shadow 0.16s ease, transform 0.16s ease;
}
.btn:hover:not(:disabled) {
box-shadow: 0 0 24px rgba(0, 132, 255, 0.42);
transform: translateY(-1px);
}
.btn--small {
min-height: 2.25rem;
padding: 0.5rem 0.78rem;
}
.btn--ghost {
background: rgba(7, 12, 26, 0.38);
border-color: rgba(0, 132, 255, 0.58);
color: var(--text);
}
.btn--danger {
background: rgba(255, 77, 109, 0.14);
border-color: var(--danger);
color: #fff;
}
.btn:disabled {
cursor: not-allowed;
opacity: 0.48;
transform: none;
}
.tabs {
display: grid;
grid-template-columns: repeat(3, minmax(0, 1fr));
gap: 0.75rem;
margin-bottom: 1rem;
max-width: 620px;
}
.tab {
border: 1px solid var(--line);
border-radius: 7px;
background: rgba(10, 16, 33, 0.74);
color: var(--muted);
cursor: pointer;
font-family: var(--font-display);
font-size: 0.78rem;
font-weight: 800;
min-height: 3rem;
padding: 0.65rem 0.8rem;
text-transform: uppercase;
}
.tab--active {
background: linear-gradient(135deg, rgba(123, 92, 255, 0.36), rgba(13, 17, 40, 0.84));
color: var(--text);
border-color: var(--purple);
box-shadow: 0 0 22px rgba(123, 92, 255, 0.22);
}
.server-grid {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(290px, 1fr));
gap: 1rem;
}
.server-card {
min-height: 360px;
background: linear-gradient(180deg, rgba(22, 31, 54, 0.86), rgba(8, 13, 27, 0.94));
border: 1px solid rgba(105, 126, 184, 0.28);
border-radius: var(--radius);
box-shadow: 0 18px 50px rgba(0, 0, 0, 0.34);
display: grid;
grid-template-rows: 118px 1fr auto;
overflow: hidden;
}
.server-card__hero {
background:
linear-gradient(180deg, rgba(5, 8, 20, 0.12), rgba(5, 8, 20, 0.82)),
var(--server-hero-image, linear-gradient(135deg, rgba(20, 27, 43, 0.1), rgba(7, 16, 29, 0.1))),
radial-gradient(circle at 28% 24%, rgba(0, 230, 210, 0.36), transparent 18%),
radial-gradient(circle at 72% 30%, rgba(123, 92, 255, 0.56), transparent 24%),
linear-gradient(135deg, #141b2b, #07101d);
background-position: center;
background-size: cover;
border-bottom: 1px solid var(--line);
position: relative;
padding: 0.85rem;
display: flex;
align-items: flex-start;
justify-content: space-between;
}
.server-card__hero::before {
content: "";
position: absolute;
inset: 0;
background:
linear-gradient(120deg, transparent 0 28%, rgba(255, 255, 255, 0.08) 29%, transparent 44%),
radial-gradient(circle, rgba(255, 255, 255, 0.86) 0 1px, transparent 1.5px);
background-size: 100% 100%, 72px 72px;
opacity: 0.28;
}
.server-card__icon {
width: 34px;
aspect-ratio: 1;
border-radius: 7px;
background: linear-gradient(135deg, var(--purple), var(--blue));
box-shadow: 0 0 24px rgba(123, 92, 255, 0.62);
position: relative;
z-index: 1;
}
.server-card__icon::before {
content: "";
position: absolute;
inset: 10px 9px 10px 12px;
background: #fff;
clip-path: polygon(0 0, 100% 50%, 0 100%);
}
.server-card__body {
display: grid;
gap: 1rem;
padding: 1rem;
}
.server-card__details,
.server-password {
display: grid;
gap: 0.55rem;
}
.server-card__actions {
border-top: 1px solid rgba(115, 92, 255, 0.18);
display: grid;
grid-template-columns: 1fr auto;
gap: 0.75rem;
padding: 0.9rem 1rem 1rem;
}
.server-card__actions > .btn:not(.btn--icon) {
width: 100%;
}
.btn--icon {
align-items: center;
display: inline-flex;
justify-content: center;
min-width: 2.25rem;
padding-left: 0.65rem;
padding-right: 0.65rem;
}
.server-edit-panel {
border-top: 1px solid rgba(115, 92, 255, 0.16);
display: grid;
gap: 0.75rem;
grid-column: 1 / -1;
padding-top: 0.75rem;
}
.image-controls,
.password-controls,
.manual-password {
display: grid;
gap: 0.55rem;
}
.manual-password {
margin-bottom: 0.75rem;
}
.file-control {
display: grid;
gap: 0.4rem;
}
.file-control span {
color: var(--muted);
font-family: var(--font-display);
font-size: 0.72rem;
font-weight: 800;
letter-spacing: 0.08em;
text-transform: uppercase;
}
.file-control input {
width: 100%;
color: var(--muted);
font-size: 0.82rem;
}
.image-controls__actions {
display: grid;
grid-template-columns: 1fr 1fr;
gap: 0.55rem;
}
.info-row {
display: flex;
align-items: flex-start;
justify-content: space-between;
gap: 0.8rem;
color: var(--text);
border-bottom: 1px solid rgba(115, 92, 255, 0.14);
padding-bottom: 0.5rem;
}
.info-row span {
color: var(--muted);
}
.info-row--empty {
opacity: 0.1;
}
.table-wrap {
overflow-x: auto;
}
table {
width: 100%;
border-collapse: collapse;
min-width: 760px;
}
th,
td {
border-bottom: 1px solid rgba(115, 92, 255, 0.18);
padding: 0.8rem;
text-align: left;
vertical-align: top;
}
th {
color: var(--muted);
font-family: var(--font-display);
font-size: 0.76rem;
font-weight: 800;
text-transform: uppercase;
}
code {
background: rgba(7, 13, 28, 0.72);
border: 1px solid rgba(120, 143, 190, 0.26);
border-radius: 4px;
color: #dce7ff;
padding: 0.12rem 0.32rem;
word-break: break-word;
}
.chip {
display: inline-flex;
align-items: center;
border: 1px solid rgba(120, 143, 190, 0.28);
border-radius: 6px;
color: var(--muted);
font-family: var(--font-display);
font-size: 0.7rem;
font-weight: 800;
padding: 0.28rem 0.55rem;
text-transform: uppercase;
white-space: nowrap;
position: relative;
z-index: 1;
}
.chip::before {
content: "";
width: 7px;
aspect-ratio: 1;
border-radius: 50%;
background: currentColor;
margin-right: 0.45rem;
box-shadow: 0 0 12px currentColor;
}
.chip--online {
background: rgba(0, 230, 2, 0.08);
border-color: rgba(0, 230, 2, 0.36);
color: var(--green);
}
.chip--offline {
background: rgba(255, 77, 109, 0.08);
border-color: rgba(255, 77, 109, 0.36);
color: var(--danger);
}
.status,
.notice,
.empty-state {
border-radius: 7px;
margin-bottom: 1rem;
padding: 0.85rem 1rem;
}
.status--info,
.notice {
background: rgba(0, 132, 255, 0.1);
border: 1px solid rgba(0, 132, 255, 0.32);
}
.status--success {
background: rgba(0, 230, 210, 0.1);
border: 1px solid rgba(0, 230, 210, 0.34);
}
.status--error {
background: rgba(255, 77, 109, 0.1);
border: 1px solid rgba(255, 77, 109, 0.38);
}
.empty-state {
background: rgba(10, 16, 33, 0.72);
border: 1px dashed var(--line);
color: var(--muted);
grid-column: 1 / -1;
text-align: center;
}
.muted {
color: var(--muted);
}
.groups-grid {
display: grid;
grid-template-columns: repeat(auto-fit, minmax(300px, 1fr));
gap: 1rem;
margin-top: 1rem;
}
.section-title {
color: var(--text);
font-size: 0.92rem;
margin-top: 1.25rem;
}
.group-card {
background: linear-gradient(145deg, var(--panel-strong), rgba(9, 14, 30, 0.92));
border: 1px solid var(--line);
border-radius: var(--radius);
padding: 1rem;
}
.group-card__header {
display: flex;
gap: 0.75rem;
align-items: center;
margin-bottom: 0.75rem;
}
.group-card__header input {
flex: 1;
}
.check {
display: flex;
align-items: center;
gap: 0.5rem;
margin: 0.5rem 0;
}
.check input {
accent-color: var(--purple);
}
.server-perms {
border-top: 1px solid rgba(115, 92, 255, 0.18);
border-bottom: 1px solid rgba(115, 92, 255, 0.18);
margin: 0.75rem 0;
padding: 0.55rem 0;
}
@media (max-width: 820px) {
.topbar {
align-items: flex-start;
flex-direction: column;
}
.topbar__actions {
width: 100%;
}
.topbar__actions .btn {
flex: 1;
}
.shell {
padding: 0.85rem;
}
.tabs {
grid-template-columns: 1fr;
max-width: none;
}
.inline-form {
width: 100%;
}
.inline-form input[type="text"] {
flex: 1 1 100%;
}
}
@media (max-width: 520px) {
.brand {
align-items: flex-start;
}
.brand__mark {
width: 38px;
}
.server-grid {
grid-template-columns: 1fr;
}
.server-card {
min-height: 0;
}
.info-row {
display: grid;
gap: 0.35rem;
}
}

28
src/app.js Normal file
View file

@ -0,0 +1,28 @@
import express from "express";
import path from "node:path";
import { config } from "./config.js";
import { requireAdmin, requireAuth } from "./middlewares/auth.js";
import { adminRouter } from "./routes/admin.js";
import { authRouter } from "./routes/auth.js";
import { logsRouter } from "./routes/logs.js";
import { serversRouter } from "./routes/servers.js";
function createApp() {
const app = express();
app.use(express.json());
app.use("/server-images", express.static(config.serverImagesDir));
app.use("/api", authRouter);
app.use("/api", requireAuth, serversRouter);
app.use("/api", requireAuth, requireAdmin, logsRouter);
app.use("/api/admin", requireAuth, requireAdmin, adminRouter);
app.use(express.static(config.publicDir));
app.get("/{*splat}", (_req, res) => {
res.sendFile(path.join(config.publicDir, "index.html"));
});
return app;
}
export { createApp };

21
src/config.js Normal file
View file

@ -0,0 +1,21 @@
import path from "node:path";
const ROOT_DIR = process.cwd();
const STORAGE_DIR = process.env.STORAGE_DIR || path.join(ROOT_DIR, "storage");
const MOCKED_DIR = path.join(ROOT_DIR, "mocked");
const config = {
rootDir: ROOT_DIR,
storageDir: STORAGE_DIR,
mockedDir: MOCKED_DIR,
serverImagesDir: path.join(STORAGE_DIR, "server-images"),
publicDir: path.join(ROOT_DIR, "public"),
port: Number(process.env.PORT || 3000),
statusFile:
process.env.GAMESERVERS_STATUS_FILE ||
path.join(MOCKED_DIR, "dev-gameservers-status.json"),
sessionTtlMs: Number(process.env.SESSION_TTL_HOURS || 12) * 60 * 60 * 1000,
logRetentionMs: 7 * 24 * 60 * 60 * 1000,
};
export { config };

30
src/middlewares/auth.js Normal file
View file

@ -0,0 +1,30 @@
import { readGroups } from "../services/storage.js";
import { getSession, getTokenFromRequest } from "../services/sessions.js";
import { isAdminGroup } from "../services/permissions.js";
function requireAuth(req, res, next) {
const token = getTokenFromRequest(req);
const session = getSession(token);
if (!session) {
return res.status(401).json({ error: "Session invalide ou expiree" });
}
const group = readGroups().find((entry) => entry.id === session.groupId);
if (!group) {
return res.status(401).json({ error: "Groupe introuvable" });
}
req.authToken = token;
req.group = group;
return next();
}
function requireAdmin(req, res, next) {
if (!isAdminGroup(req.group)) {
return res.status(403).json({ error: "Acces admin requis" });
}
return next();
}
export { requireAdmin, requireAuth };

317
src/routes/admin.js Normal file
View file

@ -0,0 +1,317 @@
import express from "express";
import fs from "node:fs";
import path from "node:path";
import multer from "multer";
import { config } from "../config.js";
import { generatePassword, hashPassword } from "../services/crypto.js";
import {
isAdminGroup,
normalizePermissions,
serializeGroup,
} from "../services/permissions.js";
import {
deleteServerImage,
readGroups,
readServerImages,
readServers,
setServerImage,
writeServerImages,
writeGroups,
writeServers,
} from "../services/storage.js";
import { mergeServersWithStatus } from "../services/status.js";
const router = express.Router();
const upload = multer({
storage: multer.memoryStorage(),
limits: { fileSize: 5 * 1024 * 1024 },
});
const IMAGE_EXTENSIONS = {
"image/jpeg": "jpg",
"image/png": "png",
"image/webp": "webp",
};
router.get("/groups", (_req, res) => {
const images = readServerImages();
return res.json({
groups: readGroups().map((group) => serializeGroup(group)),
servers: getCurrentServers().map(({ id, game }) => ({
id,
game,
heroImage: images[id]?.url || null,
})),
});
});
router.post("/servers/:serverId/image", upload.single("image"), (req, res) => {
const server = getCurrentServers().find((entry) => entry.id === req.params.serverId);
if (!server) {
return res.status(404).json({ error: "Serveur introuvable" });
}
if (!req.file) {
return res.status(400).json({ error: "Image requise" });
}
const extension = IMAGE_EXTENSIONS[req.file.mimetype];
if (!extension) {
return res.status(400).json({ error: "Format image non supporte" });
}
const previous = deleteServerImage(server.id);
deleteImageFile(previous?.filename);
const filename = `${server.id}-${Date.now()}.${extension}`;
const filePath = path.join(config.serverImagesDir, filename);
fs.writeFileSync(filePath, req.file.buffer);
const image = setServerImage(server.id, {
filename,
url: `/server-images/${filename}`,
mimetype: req.file.mimetype,
size: req.file.size,
uploadedAt: new Date().toISOString(),
});
return res.json({ serverId: server.id, heroImage: image.url });
});
router.delete("/servers/:serverId/image", (req, res) => {
const server = getCurrentServers().find((entry) => entry.id === req.params.serverId);
if (!server) {
return res.status(404).json({ error: "Serveur introuvable" });
}
const previous = deleteServerImage(server.id);
deleteImageFile(previous?.filename);
return res.json({ ok: true });
});
router.patch("/servers/:serverId/password", (req, res) => {
const password = String(req.body?.password ?? "");
const servers = readServers();
const currentServer = getCurrentServers().find((entry) => entry.id === req.params.serverId);
if (!currentServer) {
return res.status(404).json({ error: "Serveur introuvable" });
}
let server = servers.find((entry) => entry.id === currentServer.id);
if (!server) {
server = {
id: currentServer.id,
game: currentServer.game,
address: currentServer.address,
port: currentServer.port,
secrets: {},
};
servers.push(server);
}
server.secrets = server.secrets || {};
const secretKey = getServerPasswordKey(server.secrets);
if (password) {
server.secrets[secretKey] = password;
} else {
delete server.secrets[secretKey];
}
writeServers(servers);
return res.json({ serverId: server.id, hasPassword: Boolean(password) });
});
router.post("/servers/cleanup", (_req, res) => {
const currentIds = new Set(getCurrentServers().map((server) => server.id));
const servers = readServers();
const removedServers = servers.filter((server) => !currentIds.has(server.id));
const keptServers = servers.filter((server) => currentIds.has(server.id));
writeServers(keptServers);
const images = readServerImages();
const keptImages = {};
const removedImages = [];
for (const [serverId, image] of Object.entries(images)) {
if (currentIds.has(serverId)) {
keptImages[serverId] = image;
} else {
removedImages.push({ serverId, image });
deleteImageFile(image?.filename);
}
}
writeServerImages(keptImages);
return res.json({
removedServers: removedServers.map(({ id, game }) => ({ id, game })),
removedImages: removedImages.map(({ serverId }) => serverId),
});
});
router.post("/groups", async (req, res) => {
const name = String(req.body?.name || "").trim();
const requestedPassword = String(req.body?.password || "");
const permissions = sanitizePermissions(req.body?.permissions, false);
if (!name) {
return res.status(400).json({ error: "Nom du groupe requis" });
}
const groups = readGroups();
const id = createGroupId(name, groups);
const password = requestedPassword || generatePassword();
const now = new Date().toISOString();
const group = {
id,
name,
admin: false,
passwordHash: await hashPassword(password),
permissions,
createdAt: now,
updatedAt: now,
};
groups.push(group);
writeGroups(groups);
return res.status(201).json({ group: serializeGroup(group), password });
});
router.patch("/groups/:groupId", async (req, res) => {
const groups = readGroups();
const group = groups.find((entry) => entry.id === req.params.groupId);
if (!group) {
return res.status(404).json({ error: "Groupe introuvable" });
}
if (req.body?.name !== undefined) {
const name = String(req.body.name || "").trim();
if (!name) {
return res.status(400).json({ error: "Nom du groupe requis" });
}
group.name = name;
}
group.admin = isAdminGroup(group);
if (req.body?.permissions !== undefined) {
group.permissions = sanitizePermissions(req.body.permissions, isAdminGroup(group));
}
group.updatedAt = new Date().toISOString();
writeGroups(groups);
return res.json({ group: serializeGroup(group) });
});
router.delete("/groups/:groupId", (req, res) => {
if (req.params.groupId === "admin") {
return res.status(400).json({ error: "Le groupe admin initial ne peut pas etre supprime" });
}
const groups = readGroups();
const nextGroups = groups.filter((entry) => entry.id !== req.params.groupId);
if (nextGroups.length === groups.length) {
return res.status(404).json({ error: "Groupe introuvable" });
}
writeGroups(nextGroups);
return res.json({ ok: true });
});
router.post("/groups/:groupId/regenerate-password", async (req, res) => {
const groups = readGroups();
const group = groups.find((entry) => entry.id === req.params.groupId);
if (!group) {
return res.status(404).json({ error: "Groupe introuvable" });
}
const password = generatePassword();
group.passwordHash = await hashPassword(password);
group.updatedAt = new Date().toISOString();
writeGroups(groups);
return res.json({ group: serializeGroup(group), password });
});
router.patch("/groups/:groupId/password", async (req, res) => {
const password = String(req.body?.password || "");
if (!password) {
return res.status(400).json({ error: "Mot de passe requis" });
}
const groups = readGroups();
const group = groups.find((entry) => entry.id === req.params.groupId);
if (!group) {
return res.status(404).json({ error: "Groupe introuvable" });
}
group.passwordHash = await hashPassword(password);
group.updatedAt = new Date().toISOString();
writeGroups(groups);
return res.json({ group: serializeGroup(group), password });
});
router.patch("/groups/:groupId/permissions", (req, res) => {
const groups = readGroups();
const group = groups.find((entry) => entry.id === req.params.groupId);
if (!group) {
return res.status(404).json({ error: "Groupe introuvable" });
}
group.admin = isAdminGroup(group);
group.permissions = sanitizePermissions(req.body, isAdminGroup(group));
group.updatedAt = new Date().toISOString();
writeGroups(groups);
return res.json({ group: serializeGroup(group) });
});
function sanitizePermissions(input = {}, admin = false) {
if (admin) {
return {
servers: getCurrentServers().map((server) => server.id),
};
}
const serverIds = new Set(getCurrentServers().map((server) => server.id));
const permissions = normalizePermissions(input);
return {
servers: permissions.servers.filter((id) => serverIds.has(id)),
};
}
function getCurrentServers() {
return mergeServersWithStatus(readServers());
}
function createGroupId(name, groups) {
const base =
name
.toLowerCase()
.normalize("NFD")
.replace(/[\u0300-\u036f]/g, "")
.replace(/[^a-z0-9]+/g, "-")
.replace(/^-|-$/g, "") || "group";
const existing = new Set(groups.map((group) => group.id));
let id = base;
let index = 2;
while (existing.has(id)) {
id = `${base}-${index}`;
index += 1;
}
return id;
}
function deleteImageFile(filename) {
if (!filename) return;
const filePath = path.join(config.serverImagesDir, path.basename(filename));
try {
fs.existsSync(filePath) && fs.unlinkSync(filePath);
} catch (error) {
console.error(`[admin] Failed to delete server image ${filename}:`, error);
}
}
function getServerPasswordKey(secrets) {
if (Object.hasOwn(secrets, "serverPassword")) return "serverPassword";
return "password";
}
export { router as adminRouter };

40
src/routes/auth.js Normal file
View file

@ -0,0 +1,40 @@
import express from "express";
import { serializeSession } from "../services/permissions.js";
import { readGroups } from "../services/storage.js";
import { createSession, destroySession } from "../services/sessions.js";
import { verifyPassword } from "../services/crypto.js";
import { requireAuth } from "../middlewares/auth.js";
const router = express.Router();
router.get("/session", requireAuth, (req, res) => {
return res.json({ session: serializeSession(req.group) });
});
router.post("/login", async (req, res) => {
const password = String(req.body?.password || "");
if (!password) {
return res.status(400).json({ error: "Mot de passe requis" });
}
const groups = readGroups();
for (const group of groups) {
if (await verifyPassword(password, group.passwordHash)) {
const session = createSession(group);
return res.json({
token: session.token,
expiresAt: new Date(session.expiresAt).toISOString(),
session: serializeSession(group),
});
}
}
return res.status(401).json({ error: "Mot de passe invalide" });
});
router.post("/logout", requireAuth, (req, res) => {
destroySession(req.authToken);
return res.json({ ok: true });
});
export { router as authRouter };

10
src/routes/logs.js Normal file
View file

@ -0,0 +1,10 @@
import express from "express";
import { pruneLogs } from "../services/storage.js";
const router = express.Router();
router.get("/logs", (_req, res) => {
return res.json({ logs: pruneLogs().toReversed() });
});
export { router as logsRouter };

63
src/routes/servers.js Normal file
View file

@ -0,0 +1,63 @@
import express from "express";
import { canAccessServer, serializeServerForGroup } from "../services/permissions.js";
import { appendLaunchLog, readServerImages, readServers } from "../services/storage.js";
import { mergeServersWithStatus } from "../services/status.js";
import { getStartProfile, launchServer } from "../services/serverLauncher.js";
const router = express.Router();
router.get("/servers", (req, res) => {
const servers = visibleServers(req.group);
return res.json({ servers: servers.map((server) => serializeServerForGroup(server, req.group)) });
});
router.post("/servers/:serverId/start", async (req, res) => {
const servers = mergeServersWithStatus(readServers());
const server = servers.find((entry) => entry.id === req.params.serverId);
if (!server || !canAccessServer(req.group, server.id)) {
return res.status(404).json({ error: "Serveur introuvable" });
}
if (server.active) {
return res.status(409).json({ error: "Le serveur est deja en ligne" });
}
if (!getStartProfile(server)) {
return res.status(400).json({ error: "Aucun profil de lancement configure" });
}
try {
const { stdout, stderr } = await launchServer(server);
appendLaunchLog({
createdAt: new Date().toISOString(),
groupId: req.group.id,
groupName: req.group.name,
serverId: server.id,
serverName: server.game,
});
return res.json({
status: "started",
server: serializeServerForGroup(server, req.group),
stdout: stdout?.trim() || "",
stderr: stderr?.trim() || "",
});
} catch (error) {
console.error(`[servers] Failed to start ${server.id}:`, error);
return res.status(500).json({ error: "Impossible de lancer le serveur" });
}
});
function visibleServers(group) {
const images = readServerImages();
return mergeServersWithStatus(readServers())
.map((server) => ({
...server,
heroImage: images[server.id]?.url || null,
}))
.filter((server) => canAccessServer(group, server.id));
}
export { router as serversRouter };

10
src/server.js Normal file
View file

@ -0,0 +1,10 @@
import { config } from "./config.js";
import { createApp } from "./app.js";
import { ensureStorageLayout } from "./services/storage.js";
await ensureStorageLayout();
const app = createApp();
app.listen(config.port, () => {
console.log(`[web] Gameservers control listening on http://localhost:${config.port}`);
});

34
src/services/crypto.js Normal file
View file

@ -0,0 +1,34 @@
import crypto from "node:crypto";
import { promisify } from "node:util";
const scryptAsync = promisify(crypto.scrypt);
const KEY_LENGTH = 64;
async function hashPassword(password) {
const salt = crypto.randomBytes(16).toString("hex");
const derivedKey = await scryptAsync(password, salt, KEY_LENGTH);
return `scrypt:${salt}:${derivedKey.toString("hex")}`;
}
async function verifyPassword(password, storedHash) {
if (!password || !storedHash) return false;
const [algorithm, salt, hash] = storedHash.split(":");
if (algorithm !== "scrypt" || !salt || !hash) return false;
const derivedKey = await scryptAsync(password, salt, KEY_LENGTH);
const expected = Buffer.from(hash, "hex");
return (
expected.length === derivedKey.length &&
crypto.timingSafeEqual(expected, derivedKey)
);
}
function generatePassword() {
return crypto.randomBytes(12).toString("base64url");
}
function generateToken() {
return crypto.randomBytes(32).toString("base64url");
}
export { generatePassword, generateToken, hashPassword, verifyPassword };

79
src/services/permissions.js Normal file
View file

@ -0,0 +1,79 @@
import { getStartProfile } from "./serverLauncher.js";
function serializeGroup(group, { includePermissions = true } = {}) {
const serialized = {
id: group.id,
name: group.name,
admin: isAdminGroup(group),
createdAt: group.createdAt,
updatedAt: group.updatedAt,
};
if (includePermissions) {
serialized.permissions = normalizePermissions(group.permissions);
}
return serialized;
}
function serializeSession(group) {
if (!isAdminGroup(group)) {
return { admin: false };
}
return {
admin: true,
name: group.name,
};
}
function normalizePermissions(permissions = {}) {
return {
servers: Array.isArray(permissions.servers) ? permissions.servers : [],
};
}
function canAccessServer(group, serverId) {
if (isAdminGroup(group)) return true;
return normalizePermissions(group?.permissions).servers.includes(serverId);
}
function isAdminGroup(group) {
return group?.id === "admin";
}
function getPublicSecrets(secrets = {}) {
return Object.fromEntries(
Object.entries(secrets).filter(([key]) => !key.toLowerCase().startsWith("admin"))
);
}
function serializeServerForGroup(server, group) {
const publicSecrets = getPublicSecrets(server.secrets);
const startProfile = getStartProfile(server);
const serialized = {
id: server.id,
game: server.game,
address: server.address,
port: server.port,
heroImage: server.heroImage || null,
active: Boolean(server.active),
canStart: canAccessServer(group, server.id) && !server.active && Boolean(startProfile),
hasSecrets: Object.keys(publicSecrets).length > 0,
};
if (canAccessServer(group, server.id)) {
serialized.secrets = publicSecrets;
}
return serialized;
}
export {
canAccessServer,
isAdminGroup,
normalizePermissions,
serializeGroup,
serializeSession,
serializeServerForGroup,
};

48
src/services/serverLauncher.js Normal file
View file

@ -0,0 +1,48 @@
import { execFile } from "node:child_process";
import { promisify } from "node:util";
const execFileAsync = promisify(execFile);
async function launchServer(server) {
const profile = getStartProfile(server);
if (!profile) {
const error = new Error("Aucun profil de lancement configure");
error.code = "MISSING_START_PROFILE";
throw error;
}
if (profile === "TEST") {
return execFileAsync("/bin/echo", ["Mock start test server"], {
timeout: 60_000,
maxBuffer: 1024 * 1024,
});
}
const target = process.env[`${profile}_SSH_TARGET`];
const port = process.env[`${profile}_SSH_PORT`];
const command = process.env[`${profile}_START_COMMAND`];
if (!target || !command) {
const error = new Error(`Profil de lancement incomplet: ${profile}`);
error.code = "INCOMPLETE_START_PROFILE";
throw error;
}
const args = [];
if (port) {
args.push("-p", port);
}
args.push(target, command);
return execFileAsync("ssh", args, {
timeout: 60_000,
maxBuffer: 1024 * 1024,
});
}
function getStartProfile(server) {
if (server.startProfile) return server.startProfile;
return "";
}
export { getStartProfile, launchServer };

35
src/services/sessions.js Normal file
View file

@ -0,0 +1,35 @@
import { config } from "../config.js";
import { generateToken } from "./crypto.js";
const sessions = new Map();
function createSession(group) {
const token = generateToken();
const expiresAt = Date.now() + config.sessionTtlMs;
sessions.set(token, { groupId: group.id, expiresAt });
return { token, expiresAt };
}
function destroySession(token) {
if (token) sessions.delete(token);
}
function getSession(token) {
const session = sessions.get(token);
if (!session) return null;
if (session.expiresAt <= Date.now()) {
sessions.delete(token);
return null;
}
return session;
}
function getTokenFromRequest(req) {
const header = req.headers.authorization || "";
if (!header.startsWith("Bearer ")) return "";
return header.slice("Bearer ".length).trim();
}
export { createSession, destroySession, getSession, getTokenFromRequest };

62
src/services/status.js Normal file
View file

@ -0,0 +1,62 @@
import fs from "node:fs";
import { config } from "../config.js";
function readStatusFile() {
try {
const raw = fs.readFileSync(config.statusFile, "utf8");
const parsed = JSON.parse(raw);
return Array.isArray(parsed?.servers) ? parsed.servers : [];
} catch (error) {
console.error(`[status] Failed to read status file ${config.statusFile}:`, error.message);
return [];
}
}
function mergeServersWithStatus(servers) {
const statuses = readStatusFile();
return statuses.map((status) => {
const server = findConfiguredServer(status, servers);
const id = status.id || server?.id || createServerId(status);
return {
...(server || {}),
id,
game: status.game || server?.game || id,
address: status.address || server?.address || "",
port: status.port ?? server?.port ?? null,
active: Boolean(status.active),
};
});
}
function findConfiguredServer(status, servers) {
return (
servers.find((server) => status.id && server.id === status.id) ||
servers.find((server) => sameEndpoint(server, status)) ||
servers.find((server) => server.game === status.game) ||
null
);
}
function sameEndpoint(server, status) {
if (!server.address || !status.address) return false;
return normalizeAddress(server.address) === normalizeAddress(status.address);
}
function normalizeAddress(address) {
return String(address).trim().toLowerCase();
}
function createServerId(status) {
const base = `${status.game || "server"}-${status.address || ""}-${status.port || ""}`;
return (
base
.toLowerCase()
.normalize("NFD")
.replace(/[\u0300-\u036f]/g, "")
.replace(/[^a-z0-9]+/g, "-")
.replace(/^-|-$/g, "") || "server"
);
}
export { createServerId, mergeServersWithStatus };

191
src/services/storage.js Normal file
View file

@ -0,0 +1,191 @@
import fs from "node:fs";
import path from "node:path";
import { config } from "../config.js";
import { generatePassword, hashPassword } from "./crypto.js";
const files = {
servers: path.join(config.storageDir, "servers.json"),
groups: path.join(config.storageDir, "groups.json"),
logs: path.join(config.storageDir, "launch-logs.json"),
devStatus: path.join(config.mockedDir, "dev-gameservers-status.json"),
serverImages: path.join(config.storageDir, "server-images.json"),
};
const defaultServers = [
{
id: "game-1",
game: "Jeu 1",
address: "srv.mocked.com:12345",
port: 12345,
startProfile: "GAME_1",
secrets: {
password: "change-me",
},
},
{
id: "game-2",
game: "Jeu 2",
address: "srv.mocked.com:67890",
port: 67890,
startProfile: "GAME_2",
secrets: {
password: "change-me",
},
},
];
const defaultStatus = {
servers: defaultServers.map(({ game, address, port }) => ({
game,
address,
port,
active: false,
})),
};
function ensureDir() {
fs.mkdirSync(config.storageDir, { recursive: true });
fs.mkdirSync(config.mockedDir, { recursive: true });
fs.mkdirSync(config.serverImagesDir, { recursive: true });
}
function readJson(file, fallback) {
try {
const raw = fs.readFileSync(file, "utf8");
return JSON.parse(raw);
} catch (error) {
if (error.code !== "ENOENT") {
console.error(`[storage] Failed to read ${file}:`, error);
}
return fallback;
}
}
function writeJson(file, data) {
ensureDir();
fs.writeFileSync(file, `${JSON.stringify(data, null, 2)}\n`);
}
async function ensureStorageLayout() {
ensureDir();
if (!fs.existsSync(files.servers)) {
writeJson(files.servers, defaultServers);
}
if (!fs.existsSync(files.logs)) {
writeJson(files.logs, []);
}
if (!fs.existsSync(files.devStatus)) {
writeJson(files.devStatus, defaultStatus);
}
if (!fs.existsSync(files.serverImages)) {
writeJson(files.serverImages, {});
}
const groups = readGroups();
if (!groups.length) {
const password = generatePassword();
const passwordHash = await hashPassword(password);
const adminGroup = {
id: "admin",
name: "Admin",
admin: true,
passwordHash,
permissions: {
servers: defaultServers.map((server) => server.id),
},
createdAt: new Date().toISOString(),
updatedAt: new Date().toISOString(),
};
writeGroups([adminGroup]);
console.log(`[auth] Initial admin password: ${password}`);
}
pruneLogs();
}
function readServers() {
const servers = readJson(files.servers, []);
return Array.isArray(servers) ? servers : [];
}
function writeServers(servers) {
writeJson(files.servers, servers);
}
function readServerImages() {
const images = readJson(files.serverImages, {});
return images && typeof images === "object" && !Array.isArray(images) ? images : {};
}
function writeServerImages(images) {
writeJson(files.serverImages, images);
}
function setServerImage(serverId, image) {
const images = readServerImages();
images[serverId] = image;
writeServerImages(images);
return image;
}
function deleteServerImage(serverId) {
const images = readServerImages();
const previous = images[serverId] || null;
delete images[serverId];
writeServerImages(images);
return previous;
}
function readGroups() {
const groups = readJson(files.groups, []);
return Array.isArray(groups) ? groups : [];
}
function writeGroups(groups) {
writeJson(files.groups, groups);
}
function readLogs() {
const logs = readJson(files.logs, []);
return Array.isArray(logs) ? logs : [];
}
function writeLogs(logs) {
writeJson(files.logs, logs);
}
function pruneLogs() {
const cutoff = Date.now() - config.logRetentionMs;
const logs = readLogs().filter((entry) => {
const time = Date.parse(entry.createdAt);
return Number.isFinite(time) && time >= cutoff;
});
writeLogs(logs);
return logs;
}
function appendLaunchLog(entry) {
const logs = pruneLogs();
logs.push(entry);
writeLogs(logs);
}
export {
appendLaunchLog,
ensureStorageLayout,
files,
pruneLogs,
readGroups,
readLogs,
readServerImages,
readServers,
setServerImage,
deleteServerImage,
writeGroups,
writeServerImages,
writeServers,
};

20
storage/servers.json Normal file
View file

@ -0,0 +1,20 @@
[
{
"id": "game-1",
"game": "Jeu 1",
"address": "srv.mocked.com:12345",
"port": 12345,
"startProfile": "GAME_1",
"secrets": {}
},
{
"id": "game-2",
"game": "Jeu 2",
"address": "srv.mocked.com:67890",
"port": 67890,
"startProfile": "GAME_2",
"secrets": {
"password": "change-me"
}
}
]

388
test/api.test.js Normal file
View file

@ -0,0 +1,388 @@
import assert from "node:assert/strict";
import fs from "node:fs";
import os from "node:os";
import path from "node:path";
import test from "node:test";
const tmpRoot = fs.mkdtempSync(path.join(os.tmpdir(), "gameservers-control-"));
process.env.STORAGE_DIR = tmpRoot;
process.env.GAMESERVERS_STATUS_FILE = path.join(tmpRoot, "status.json");
fs.mkdirSync(path.join(tmpRoot, "server-images"), { recursive: true });
const { createApp } = await import("../src/app.js");
const { hashPassword } = await import("../src/services/crypto.js");
const { pruneLogs } = await import("../src/services/storage.js");
const servers = [
{
id: "offline-server",
game: "Offline Server",
address: "games.example:1111",
port: 1111,
startProfile: "TEST",
secrets: { password: "secret-1" },
},
{
id: "online-server",
game: "Online Server",
address: "games.example:2222",
port: 2222,
startProfile: "PALWORLD",
secrets: { serverPassword: "secret-2", adminSecret: "admin-secret" },
},
];
const adminLoginPassword = "admin-password";
const playerPassword = "player-password";
fs.writeFileSync(
path.join(tmpRoot, "servers.json"),
`${JSON.stringify(servers, null, 2)}\n`
);
fs.writeFileSync(
process.env.GAMESERVERS_STATUS_FILE,
`${JSON.stringify(
{
servers: [
{ id: "offline-server", game: "Offline Server", address: "games.example:1111", port: 1111, active: false },
{ id: "online-server", game: "Online Server", address: "games.example:2222", port: 2222, active: true },
],
},
null,
2
)}\n`
);
const originalStatus = fs.readFileSync(process.env.GAMESERVERS_STATUS_FILE, "utf8");
fs.writeFileSync(
path.join(tmpRoot, "groups.json"),
`${JSON.stringify(
[
{
id: "admin",
name: "Admin",
admin: true,
passwordHash: await hashPassword(adminLoginPassword),
permissions: { servers: servers.map((server) => server.id) },
createdAt: new Date().toISOString(),
updatedAt: new Date().toISOString(),
},
{
id: "players",
name: "Players",
admin: false,
passwordHash: await hashPassword(playerPassword),
permissions: { servers: ["offline-server"] },
createdAt: new Date().toISOString(),
updatedAt: new Date().toISOString(),
},
],
null,
2
)}\n`
);
fs.writeFileSync(path.join(tmpRoot, "launch-logs.json"), "[]\n");
fs.writeFileSync(path.join(tmpRoot, "server-images.json"), "{}\n");
const app = createApp();
const server = app.listen(0);
await new Promise((resolve) => server.once("listening", resolve));
const baseUrl = `http://127.0.0.1:${server.address().port}`;
test.after(() => server.close());
test("rejects invalid password and accepts group password", async () => {
const rejected = await request("/api/login", {
method: "POST",
body: { password: "wrong" },
});
assert.equal(rejected.status, 401);
const accepted = await request("/api/login", {
method: "POST",
body: { password: playerPassword },
});
assert.equal(accepted.status, 200);
assert.deepEqual(accepted.body.session, { admin: false });
assert.equal(accepted.body.group, undefined);
assert.ok(accepted.body.token);
});
test("does not expose group details through non-admin session", async () => {
const token = await login(playerPassword);
const response = await request("/api/session", { token });
assert.equal(response.status, 200);
assert.deepEqual(response.body.session, { admin: false });
assert.equal(response.body.group, undefined);
});
test("filters servers and shows secrets for visible non-admin servers", async () => {
const token = await login(playerPassword);
const response = await request("/api/servers", { token });
assert.equal(response.status, 200);
assert.equal(response.body.servers.length, 1);
assert.equal(response.body.servers[0].id, "offline-server");
assert.equal(response.body.servers[0].secrets.password, "secret-1");
assert.equal(response.body.servers[0].hasSecrets, true);
});
test("admin sees all servers and secrets", async () => {
const token = await login(adminLoginPassword);
const response = await request("/api/servers", { token });
assert.equal(response.status, 200);
assert.equal(response.body.servers.length, 2);
assert.equal(response.body.servers[0].secrets.password, "secret-1");
assert.equal(response.body.servers[1].secrets.serverPassword, "secret-2");
assert.deepEqual(Object.keys(response.body.servers[1].secrets), ["serverPassword"]);
});
test("status file is authoritative for server list and names", async () => {
fs.writeFileSync(
process.env.GAMESERVERS_STATUS_FILE,
`${JSON.stringify(
{
servers: [
{
id: "offline-server",
game: "Renamed Server",
address: "games.example:1111",
port: 1111,
active: false,
},
{
id: "new-server",
game: "New Server",
address: "games.example:3333",
port: 3333,
active: false,
},
],
},
null,
2
)}\n`
);
const token = await login(adminLoginPassword);
const response = await request("/api/servers", { token });
const names = response.body.servers.map((server) => server.game);
assert.deepEqual(names, ["Renamed Server", "New Server"]);
assert.equal(response.body.servers[0].id, "offline-server");
assert.equal(response.body.servers[0].canStart, true);
assert.equal(response.body.servers[1].id, "new-server");
assert.equal(response.body.servers[1].canStart, false);
fs.writeFileSync(process.env.GAMESERVERS_STATUS_FILE, originalStatus);
});
test("starts an offline authorized server and writes a log", async () => {
const token = await login(playerPassword);
const start = await request("/api/servers/offline-server/start", {
method: "POST",
token,
});
assert.equal(start.status, 200);
assert.equal(start.body.status, "started");
const adminToken = await login(adminLoginPassword);
const logs = await request("/api/logs", { token: adminToken });
assert.equal(logs.status, 200);
assert.equal(logs.body.logs[0].groupId, "players");
assert.equal(logs.body.logs[0].serverId, "offline-server");
});
test("refuses to start online or unauthorized servers", async () => {
const playerToken = await login(playerPassword);
const unauthorized = await request("/api/servers/online-server/start", {
method: "POST",
token: playerToken,
});
assert.equal(unauthorized.status, 404);
const adminToken = await login(adminLoginPassword);
const online = await request("/api/servers/online-server/start", {
method: "POST",
token: adminToken,
});
assert.equal(online.status, 409);
});
test("admin can create, update, regenerate, and delete a group", async () => {
const token = await login(adminLoginPassword);
const created = await request("/api/admin/groups", {
method: "POST",
token,
body: { name: "Guests", password: "manual-password", permissions: { servers: [] } },
});
assert.equal(created.status, 201);
assert.equal(created.body.password, "manual-password");
const manualLoginToken = await login("manual-password");
assert.ok(manualLoginToken);
const groupId = created.body.group.id;
const updated = await request(`/api/admin/groups/${groupId}/permissions`, {
method: "PATCH",
token,
body: { servers: ["offline-server"] },
});
assert.equal(updated.status, 200);
assert.deepEqual(updated.body.group.permissions.servers, ["offline-server"]);
const regenerated = await request(`/api/admin/groups/${groupId}/regenerate-password`, {
method: "POST",
token,
});
assert.equal(regenerated.status, 200);
assert.ok(regenerated.body.password);
const manualPassword = await request(`/api/admin/groups/${groupId}/password`, {
method: "PATCH",
token,
body: { password: "replacement-password" },
});
assert.equal(manualPassword.status, 200);
assert.equal(manualPassword.body.password, "replacement-password");
const replacementLoginToken = await login("replacement-password");
assert.ok(replacementLoginToken);
const deleted = await request(`/api/admin/groups/${groupId}`, {
method: "DELETE",
token,
});
assert.equal(deleted.status, 200);
});
test("admin can upload and delete a server image", async () => {
const token = await login(adminLoginPassword);
const formData = new FormData();
formData.set(
"image",
new Blob([Buffer.from("fake-image")], { type: "image/png" }),
"server.png"
);
const uploaded = await request("/api/admin/servers/offline-server/image", {
method: "POST",
token,
body: formData,
});
assert.equal(uploaded.status, 200);
assert.match(uploaded.body.heroImage, /^\/server-images\/offline-server-\d+\.png$/);
const serversResponse = await request("/api/servers", { token });
assert.equal(serversResponse.body.servers[0].heroImage, uploaded.body.heroImage);
const deleted = await request("/api/admin/servers/offline-server/image", {
method: "DELETE",
token,
});
assert.equal(deleted.status, 200);
const refreshed = await request("/api/servers", { token });
assert.equal(refreshed.body.servers[0].heroImage, null);
});
test("admin can update a server password", async () => {
const token = await login(adminLoginPassword);
const updated = await request("/api/admin/servers/offline-server/password", {
method: "PATCH",
token,
body: { password: "new-server-password" },
});
assert.equal(updated.status, 200);
assert.equal(updated.body.hasPassword, true);
const serversResponse = await request("/api/servers", { token });
const server = serversResponse.body.servers.find((entry) => entry.id === "offline-server");
assert.equal(server.secrets.password, "new-server-password");
});
test("admin can cleanup local config for servers absent from status", async () => {
const token = await login(adminLoginPassword);
fs.writeFileSync(
path.join(tmpRoot, "servers.json"),
`${JSON.stringify(
[
...servers,
{
id: "deleted-server",
game: "Deleted Server",
address: "games.example:4444",
port: 4444,
startProfile: "DELETED",
secrets: { password: "old" },
},
],
null,
2
)}\n`
);
fs.writeFileSync(
path.join(tmpRoot, "server-images.json"),
`${JSON.stringify({ "deleted-server": { filename: "deleted-server.png", url: "/server-images/deleted-server.png" } })}\n`
);
fs.writeFileSync(path.join(tmpRoot, "server-images", "deleted-server.png"), "fake");
const cleaned = await request("/api/admin/servers/cleanup", {
method: "POST",
token,
});
assert.equal(cleaned.status, 200);
assert.deepEqual(cleaned.body.removedServers, [
{ id: "deleted-server", game: "Deleted Server" },
]);
assert.deepEqual(cleaned.body.removedImages, ["deleted-server"]);
const nextServers = JSON.parse(fs.readFileSync(path.join(tmpRoot, "servers.json"), "utf8"));
assert.equal(nextServers.some((server) => server.id === "deleted-server"), false);
assert.equal(fs.existsSync(path.join(tmpRoot, "server-images", "deleted-server.png")), false);
});
test("prunes launch logs older than seven days", () => {
const logsFile = path.join(tmpRoot, "launch-logs.json");
fs.writeFileSync(
logsFile,
JSON.stringify(
[
{ createdAt: new Date(Date.now() - 8 * 24 * 60 * 60 * 1000).toISOString(), groupId: "old" },
{ createdAt: new Date().toISOString(), groupId: "new" },
],
null,
2
)
);
const logs = pruneLogs();
assert.equal(logs.length, 1);
assert.equal(logs[0].groupId, "new");
});
async function login(password) {
const response = await request("/api/login", {
method: "POST",
body: { password },
});
assert.equal(response.status, 200);
return response.body.token;
}
async function request(pathname, { method = "GET", token, body } = {}) {
const headers = {};
if (token) headers.Authorization = `Bearer ${token}`;
if (body && !(body instanceof FormData)) headers["Content-Type"] = "application/json";
const response = await fetch(`${baseUrl}${pathname}`, {
method,
headers,
body: body && !(body instanceof FormData) ? JSON.stringify(body) : body,
});
const payload = await response.json();
return { status: response.status, body: payload };
}