Add NAS status proxy

server.js

@@ -0,0 +1,311 @@
+const http = require('node:http');
+const https = require('node:https');
+const fs = require('node:fs');
+const fsp = require('node:fs/promises');
+const path = require('node:path');
+const { URL } = require('node:url');
+
+const PORT = Number(process.env.PORT || 80);
+const dockerPublicDir = path.join(__dirname, 'public');
+const PUBLIC_DIR = fs.existsSync(dockerPublicDir) ? dockerPublicDir : __dirname;
+const DOCKER_SOCKET = process.env.DOCKER_SOCKET || '/var/run/docker.sock';
+const WATCHTOWER_CONTAINER = process.env.WATCHTOWER_CONTAINER || 'watchtower';
+const DISK_TARGETS = [
+  { id: 'volume1', label: 'Volume 1', path: process.env.STATUS_VOLUME1_PATH || '/host/volume1' },
+  { id: 'volume2', label: 'Volume 2', path: process.env.STATUS_VOLUME2_PATH || '/host/volume2' },
+  { id: 'root', label: 'Root', path: '/' }
+];
+
+const MIME_TYPES = {
+  '.html': 'text/html; charset=utf-8',
+  '.css': 'text/css; charset=utf-8',
+  '.js': 'application/javascript; charset=utf-8',
+  '.json': 'application/json; charset=utf-8',
+  '.webmanifest': 'application/manifest+json; charset=utf-8',
+  '.png': 'image/png',
+  '.svg': 'image/svg+xml; charset=utf-8',
+  '.ico': 'image/x-icon'
+};
+
+const serviceUrls = [
+  'https://mischlabs.de',
+  'https://auth.mischlabs.de/realms/mischlabs/account',
+  'https://drive.mischlabs.de',
+  'https://git.mischlabs.de',
+  'https://movies.mischlabs.de',
+  'https://audiobook.mischlabs.de',
+  'https://password.mischlabs.de',
+  'https://books.mischlabs.de',
+  'https://michess.mischlabs.de',
+  'https://tom.mischlabs.de'
+];
+
+function json(res, status, payload) {
+  res.writeHead(status, {
+    'Content-Type': 'application/json; charset=utf-8',
+    'Cache-Control': 'no-store'
+  });
+  res.end(JSON.stringify(payload));
+}
+
+function dockerRequest(endpoint) {
+  return new Promise((resolve, reject) => {
+    const req = http.request({
+      socketPath: DOCKER_SOCKET,
+      path: endpoint,
+      method: 'GET'
+    }, (res) => {
+      let body = '';
+      res.setEncoding('utf8');
+      res.on('data', (chunk) => { body += chunk; });
+      res.on('end', () => {
+        if (res.statusCode < 200 || res.statusCode >= 300) {
+          reject(new Error(`Docker API ${endpoint} returned ${res.statusCode}`));
+          return;
+        }
+
+        try {
+          resolve(body ? JSON.parse(body) : null);
+        } catch (error) {
+          reject(error);
+        }
+      });
+    });
+
+    req.on('error', reject);
+    req.end();
+  });
+}
+
+function dockerLogs(container, tail = 160) {
+  return new Promise((resolve, reject) => {
+    const endpoint = `/containers/${encodeURIComponent(container)}/logs?stdout=1&stderr=1&tail=${tail}`;
+    const req = http.request({
+      socketPath: DOCKER_SOCKET,
+      path: endpoint,
+      method: 'GET'
+    }, (res) => {
+      const chunks = [];
+      res.on('data', (chunk) => chunks.push(chunk));
+      res.on('end', () => {
+        if (res.statusCode < 200 || res.statusCode >= 300) {
+          reject(new Error(`Docker logs returned ${res.statusCode}`));
+          return;
+        }
+
+        const raw = Buffer.concat(chunks);
+        const lines = [];
+        let offset = 0;
+
+        while (offset + 8 <= raw.length) {
+          const size = raw.readUInt32BE(offset + 4);
+          const start = offset + 8;
+          const end = start + size;
+          if (end > raw.length) break;
+          lines.push(raw.slice(start, end).toString('utf8'));
+          offset = end;
+        }
+
+        resolve((lines.length ? lines.join('') : raw.toString('utf8')).trim().split(/\r?\n/).filter(Boolean));
+      });
+    });
+
+    req.on('error', reject);
+    req.end();
+  });
+}
+
+async function getContainers() {
+  const containers = await dockerRequest('/containers/json?all=0');
+  return containers.map((container) => ({
+    id: container.Id.slice(0, 12),
+    name: (container.Names?.[0] || '').replace(/^\//, ''),
+    image: container.Image,
+    status: container.Status,
+    state: container.State,
+    ports: (container.Ports || []).map((port) => ({
+      privatePort: port.PrivatePort,
+      publicPort: port.PublicPort,
+      type: port.Type,
+      ip: port.IP
+    }))
+  })).sort((a, b) => a.name.localeCompare(b.name));
+}
+
+async function getDisks() {
+  const disks = [];
+
+  for (const target of DISK_TARGETS) {
+    try {
+      const stats = await fsp.statfs(target.path);
+      const total = Number(stats.blocks) * Number(stats.bsize);
+      const available = Number(stats.bavail) * Number(stats.bsize);
+      const used = total - available;
+      disks.push({
+        ...target,
+        total,
+        used,
+        available,
+        usedPercent: total ? Math.round((used / total) * 100) : null
+      });
+    } catch (error) {
+      disks.push({ ...target, error: error.message });
+    }
+  }
+
+  return disks;
+}
+
+function parseWatchtower(lines) {
+  const sessions = [];
+  let current = null;
+
+  for (const line of lines) {
+    const timeMatch = line.match(/time="([^"]+)"/);
+    const time = timeMatch?.[1] || null;
+
+    if (line.includes('Running a one time update.') || line.includes('Checking all containers')) {
+      current = current || { startedAt: time, found: [], warnings: [] };
+    }
+
+    if (line.includes('Found new')) {
+      current = current || { startedAt: time, found: [], warnings: [] };
+      current.found.push(line.replace(/^.*msg="/, '').replace(/"$/, ''));
+    }
+
+    if (line.includes('level=warning')) {
+      current = current || { startedAt: time, found: [], warnings: [] };
+      current.warnings.push(line.replace(/^.*msg="/, '').replace(/"$/, ''));
+    }
+
+    const done = line.match(/Session done" Failed=(\d+) Scanned=(\d+) Updated=(\d+)/);
+    if (done) {
+      current = current || { startedAt: time, found: [], warnings: [] };
+      current.finishedAt = time;
+      current.failed = Number(done[1]);
+      current.scanned = Number(done[2]);
+      current.updated = Number(done[3]);
+      sessions.push(current);
+      current = null;
+    }
+  }
+
+  return sessions.at(-1) || null;
+}
+
+function probeUrl(target) {
+  return new Promise((resolve) => {
+    const started = Date.now();
+    const url = new URL(target);
+    const client = url.protocol === 'http:' ? http : https;
+    const req = client.request(url, {
+      method: 'HEAD',
+      timeout: 8000,
+      headers: { 'User-Agent': 'MischLabs-Status/1.0' }
+    }, (res) => {
+      res.resume();
+      resolve({
+        url: target,
+        ok: res.statusCode >= 200 && res.statusCode < 500,
+        statusCode: res.statusCode,
+        location: res.headers.location || null,
+        contentType: res.headers['content-type'] || null,
+        ms: Date.now() - started
+      });
+    });
+
+    req.on('timeout', () => {
+      req.destroy(new Error('timeout'));
+    });
+    req.on('error', (error) => {
+      resolve({
+        url: target,
+        ok: false,
+        error: error.message,
+        ms: Date.now() - started
+      });
+    });
+    req.end();
+  });
+}
+
+async function getServices() {
+  return Promise.all(serviceUrls.map(probeUrl));
+}
+
+async function statusPayload() {
+  const [containers, disks, logs, services] = await Promise.all([
+    getContainers().catch((error) => ({ error: error.message })),
+    getDisks(),
+    dockerLogs(WATCHTOWER_CONTAINER).catch((error) => [`watchtower logs unavailable: ${error.message}`]),
+    getServices()
+  ]);
+
+  return {
+    generatedAt: new Date().toISOString(),
+    containers,
+    disks,
+    watchtower: {
+      container: WATCHTOWER_CONTAINER,
+      lastSession: Array.isArray(logs) ? parseWatchtower(logs) : null,
+      tail: Array.isArray(logs) ? logs.slice(-20) : logs
+    },
+    services
+  };
+}
+
+async function serveStatic(req, res) {
+  const requestUrl = new URL(req.url, `http://${req.headers.host}`);
+  let pathname = decodeURIComponent(requestUrl.pathname);
+  if (pathname === '/') pathname = '/index.html';
+
+  const filePath = path.normalize(path.join(PUBLIC_DIR, pathname));
+  if (!filePath.startsWith(PUBLIC_DIR)) {
+    res.writeHead(403);
+    res.end('Forbidden');
+    return;
+  }
+
+  try {
+    const stat = await fsp.stat(filePath);
+    const target = stat.isDirectory() ? path.join(filePath, 'index.html') : filePath;
+    const ext = path.extname(target);
+    const headers = {
+      'Content-Type': MIME_TYPES[ext] || 'application/octet-stream',
+      'X-Content-Type-Options': 'nosniff',
+      'Referrer-Policy': 'strict-origin-when-cross-origin',
+      'X-Frame-Options': 'SAMEORIGIN'
+    };
+
+    if (path.basename(target) === 'sw.js') {
+      headers['Cache-Control'] = 'no-store, no-cache, must-revalidate, proxy-revalidate, max-age=0';
+    } else if (path.basename(target) === 'services.json') {
+      headers['Cache-Control'] = 'no-cache';
+    } else if (['.css', '.js', '.png', '.svg'].includes(ext)) {
+      headers['Cache-Control'] = 'public, max-age=604800, immutable';
+    }
+
+    res.writeHead(200, headers);
+    fs.createReadStream(target).pipe(res);
+  } catch {
+    res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
+    res.end('Not found');
+  }
+}
+
+const server = http.createServer(async (req, res) => {
+  if (req.url?.startsWith('/api/status')) {
+    try {
+      json(res, 200, await statusPayload());
+    } catch (error) {
+      json(res, 500, { error: error.message });
+    }
+    return;
+  }
+
+  await serveStatic(req, res);
+});
+
+server.listen(PORT, () => {
+  console.log(`MischLabs dashboard listening on ${PORT}`);
+});