SSE events bridge, PWA service worker, offline banner, lazy admin tabs

- New /api/events SSE endpoint (authed): pushes status every 5s and chat
  on log-file mtime change (~1.5s poll). Heartbeat every 15s, hard-caps
  each stream at 10min so the browser gets a clean auth refresh on
  reconnect. Auto-aborts on client disconnect.
- Factored shared helpers out of the existing routes:
  - lib/server-status.ts (probeStatus, reused by /api/status + SSE)
  - lib/chat-log.ts (parseLogLine, readChatMessages, logMtime, reused by
    /api/chat + SSE)
- EventsBridge client (mounted in Providers) opens one EventSource per
  authed session and writes live data into the TanStack Query cache for
  ["status"] and ["chat"] — no refactor needed in consuming components,
  they keep reading their usual query keys.
- Now that SSE pushes updates, polling intervals bumped: StatusCard and
  ServerControls 10s -> 60s, ChatBridge 5s -> 30s. SSE handles realtime,
  polling is safety fallback.
- OfflineBanner: sticky amber bar when navigator.onLine flips false.
- PWA: minimal public/sw.js with shell + asset cache (network-first for
  HTML, stale-while-revalidate for static assets, never touches /api/*
  or text/event-stream). ServiceWorkerRegister client registers it in
  production only.
- AdminTabs now uses next/dynamic with skeleton fallbacks for Players /
  Chat / Mods / Backups / Logs, keeping initial /admin bundle smaller.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

app/api/chat/route.ts

@@ -1,92 +1,20 @@
 import { NextRequest, NextResponse } from "next/server";
-import { readFileSync, existsSync } from "fs";
 import { auth } from "@/lib/auth";
 import { sendCommand } from "@/lib/rcon";
+import { readChatMessages } from "@/lib/chat-log";
 
 export const dynamic = "force-dynamic";
 
-const LOG_FILE = "/home/minecraft/server/logs/latest.log";
-
-type ChatMessage = {
-  time: string;
-  type: "chat" | "join" | "leave" | "death" | "server";
-  player: string;
-  message: string;
-};
-
-function parseLogLine(line: string): ChatMessage | null {
-  // [HH:MM:SS] [Server thread/INFO] [minecraft/DedicatedServer]: <Player> message
-  const chatMatch = line.match(
-    /\[(\d{2}:\d{2}:\d{2})\].*\[minecraft\/(?:DedicatedServer|MinecraftServer)\]:\s*<(\w+)>\s*(.*)/
-  );
-  if (chatMatch) {
-    return { time: chatMatch[1], type: "chat", player: chatMatch[2], message: chatMatch[3] };
-  }
-
-  // Player joins
-  const joinMatch = line.match(
-    /\[(\d{2}:\d{2}:\d{2})\].*\[minecraft\/(?:PlayerList|ServerPlayer)\]:\s*(\w+)\s+joined the game/
-  );
-  if (joinMatch) {
-    return { time: joinMatch[1], type: "join", player: joinMatch[2], message: "joined the game" };
-  }
-
-  // Player leaves
-  const leaveMatch = line.match(
-    /\[(\d{2}:\d{2}:\d{2})\].*\[minecraft\/(?:PlayerList|ServerPlayer)\]:\s*(\w+)\s+left the game/
-  );
-  if (leaveMatch) {
-    return { time: leaveMatch[1], type: "leave", player: leaveMatch[2], message: "left the game" };
-  }
-
-  // Deaths
-  const deathMatch = line.match(
-    /\[(\d{2}:\d{2}:\d{2})\].*\[minecraft\/(?:DedicatedServer|MinecraftServer)\]:\s*(\w+)\s+(was |died|drowned|burned|fell|starved|suffocated|hit|blew|withered|tried|experienced|went|walked|froze|was prick|was stung|was impaled|was squashed|was skewered|was squished|was pummeled|discovered)(.*)/
-  );
-  if (deathMatch) {
-    return {
-      time: deathMatch[1],
-      type: "death",
-      player: deathMatch[2],
-      message: deathMatch[3] + (deathMatch[4] || ""),
-    };
-  }
-
-  // Server say command
-  const sayMatch = line.match(
-    /\[(\d{2}:\d{2}:\d{2})\].*\[minecraft\/(?:DedicatedServer|MinecraftServer)\]:\s*\[Server\]\s*(.*)/
-  );
-  if (sayMatch) {
-    return { time: sayMatch[1], type: "server", player: "Server", message: sayMatch[2] };
-  }
-
-  return null;
-}
-
 export async function GET(req: NextRequest) {
   const session = await auth();
   if (!session) {
     return NextResponse.json({ error: "Unauthorized" }, { status: 403 });
   }
 
-  if (!existsSync(LOG_FILE)) {
-    return NextResponse.json([]);
-  }
-
   const maxLines = parseInt(req.nextUrl.searchParams.get("lines") || "100");
 
   try {
-    const content = readFileSync(LOG_FILE, "utf8");
-    const lines = content.split("\n");
-    const messages: ChatMessage[] = [];
-
-    // Parse from the end, collect up to maxLines relevant messages
-    for (let i = lines.length - 1; i >= 0 && messages.length < maxLines; i--) {
-      const msg = parseLogLine(lines[i]);
-      if (msg) messages.unshift(msg);
-    }
-
-    return NextResponse.json(messages);
+    return NextResponse.json(readChatMessages(maxLines));
   } catch (e) {
     return NextResponse.json(
       { error: (e as Error).message },
@@ -106,7 +34,6 @@ export async function POST(req: NextRequest) {
     return NextResponse.json({ error: "Invalid message" }, { status: 400 });
   }
 
-  // Sanitize: strip newlines/carriage returns to prevent RCON command injection
   const sanitized = message.replace(/[\r\n]/g, "").trim();
   if (!sanitized) {
     return NextResponse.json({ error: "Empty message" }, { status: 400 });

app/api/events/route.ts

@@ -0,0 +1,106 @@
+import { NextRequest } from "next/server";
+import { auth } from "@/lib/auth";
+import { probeStatus } from "@/lib/server-status";
+import { readChatMessages, logMtime } from "@/lib/chat-log";
+
+export const dynamic = "force-dynamic";
+export const runtime = "nodejs";
+
+const STATUS_INTERVAL_MS = 5000;
+const LOG_POLL_MS = 1500;
+const HEARTBEAT_MS = 15_000;
+const MAX_LIFETIME_MS = 10 * 60 * 1000;
+
+export async function GET(req: NextRequest) {
+  const session = await auth();
+  if (!session) {
+    return new Response(JSON.stringify({ error: "Unauthorized" }), {
+      status: 403,
+      headers: { "Content-Type": "application/json" },
+    });
+  }
+
+  const encoder = new TextEncoder();
+
+  const stream = new ReadableStream({
+    async start(controller) {
+      let closed = false;
+      const timers: ReturnType<typeof setTimeout>[] = [];
+      const safeSend = (data: string) => {
+        if (closed) return;
+        try {
+          controller.enqueue(encoder.encode(data));
+        } catch {
+          closed = true;
+        }
+      };
+      const send = (event: string, payload: unknown) =>
+        safeSend(`event: ${event}\ndata: ${JSON.stringify(payload)}\n\n`);
+      const heartbeat = () => safeSend(`: hb ${Date.now()}\n\n`);
+
+      const cleanup = () => {
+        if (closed) return;
+        closed = true;
+        for (const t of timers) clearTimeout(t);
+        try {
+          controller.close();
+        } catch {}
+      };
+      req.signal.addEventListener("abort", cleanup);
+
+      // Initial payload
+      try {
+        const status = await probeStatus();
+        send("status", status);
+        const chat = readChatMessages(50);
+        send("chat", chat);
+      } catch {}
+
+      let lastLogMtime = logMtime();
+
+      const pollStatus = async () => {
+        if (closed) return;
+        try {
+          const status = await probeStatus();
+          send("status", status);
+        } catch {}
+        if (!closed) timers.push(setTimeout(pollStatus, STATUS_INTERVAL_MS));
+      };
+
+      const pollLog = () => {
+        if (closed) return;
+        try {
+          const mt = logMtime();
+          if (mt && mt !== lastLogMtime) {
+            lastLogMtime = mt;
+            const chat = readChatMessages(50);
+            send("chat", chat);
+          }
+        } catch {}
+        if (!closed) timers.push(setTimeout(pollLog, LOG_POLL_MS));
+      };
+
+      const beat = () => {
+        if (closed) return;
+        heartbeat();
+        if (!closed) timers.push(setTimeout(beat, HEARTBEAT_MS));
+      };
+
+      timers.push(setTimeout(pollStatus, STATUS_INTERVAL_MS));
+      timers.push(setTimeout(pollLog, LOG_POLL_MS));
+      timers.push(setTimeout(beat, HEARTBEAT_MS));
+
+      // Hard cap stream lifetime so auth/session stays fresh on reconnect
+      timers.push(setTimeout(cleanup, MAX_LIFETIME_MS));
+    },
+  });
+
+  return new Response(stream, {
+    headers: {
+      "Content-Type": "text/event-stream; charset=utf-8",
+      "Cache-Control": "no-cache, no-transform",
+      Connection: "keep-alive",
+      "X-Accel-Buffering": "no",
+    },
+  });
+}

app/api/status/route.ts

@@ -1,57 +1,9 @@
 import { NextResponse } from "next/server";
-import { status } from "minecraft-server-util";
-import { execSync } from "child_process";
-import { MC_SERVER_IP, MC_SERVER_PORT } from "@/lib/constants";
-import { sendCommand } from "@/lib/rcon";
+import { probeStatus } from "@/lib/server-status";
 import { memoAsync } from "@/lib/cache";
 
 export const dynamic = "force-dynamic";
 
-type StatusResult = {
-  online: boolean;
-  starting?: boolean;
-  players: { online: number; max: number };
-  version?: string;
-  motd?: string;
-};
-
-async function probeStatus(): Promise<StatusResult> {
-  // Race protocol ping + RCON in parallel — whichever wins first signals "online"
-  const ping = status(MC_SERVER_IP, MC_SERVER_PORT, { timeout: 3000 }).then(
-    (r): StatusResult => ({
-      online: true,
-      players: { online: r.players.online, max: r.players.max },
-      version: r.version.name,
-      motd: r.motd.clean,
-    })
-  );
-
-  const rcon = sendCommand("list").then((response): StatusResult => {
-    const match = response.match(/There are (\d+) of a max of (\d+) players/);
-    return {
-      online: true,
-      players: {
-        online: match ? parseInt(match[1], 10) : 0,
-        max: match ? parseInt(match[2], 10) : 20,
-      },
-    };
-  });
-
-  try {
-    return await Promise.any([ping, rcon]);
-  } catch {
-    // Both failed — check if process is up
-    let starting = false;
-    try {
-      const out = execSync("systemctl is-active minecraft.service", {
-        encoding: "utf8",
-      }).trim();
-      starting = out === "active" || out === "activating";
-    } catch {}
-    return { online: false, starting, players: { online: 0, max: 0 } };
-  }
-}
-
 export async function GET() {
   const result = await memoAsync("status", 3000, probeStatus);
   return NextResponse.json(result, {