Performance: RCON pooling, route caching, parallel status probe

Server:
- lib/cache.ts: tiny TTL memo for hot paths.
- lib/rcon.ts: pooled connection with 30s idle close and one-shot retry;
  was opening a fresh TCP per RCON call.
- /api/status: race protocol-ping + RCON with Promise.any (was sequential
  with 5s timeouts) and memo 3s; adds Cache-Control.
- /api/players: memo 10s, invalidated on mutations.
- /api/mods: getModDetails memo 10s (invalidated on install/remove) —
  eliminates per-request readdirSync/statSync/AdmZip parse.
- /api/analytics: reverse-scan JSONL to window cutoff (O(window) vs O(file))
  and memo 30s.
- /api/logs: memo 2s to throttle journalctl spawns during Live mode.

Client:
- StatusCard + ServerControls: staleTime 5s, both poll every 10s, dedup
  via shared query key.
- Analytics: staleTime 30s; memoize sparkline SVG paths.
- Modrinth search icons + mc-heads avatars: width/height + loading=lazy +
  decoding=async.
- next.config.ts: images.remotePatterns for future next/image migration,
  explicit compress=true.

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

app/api/analytics/route.ts

@@ -1,6 +1,7 @@
 import { NextRequest, NextResponse } from "next/server";
 import { readFileSync, existsSync } from "fs";
 import { auth } from "@/lib/auth";
+import { memo } from "@/lib/cache";
 
 export const dynamic = "force-dynamic";
 
@@ -16,6 +17,27 @@ type MetricEntry = {
   players: string[];
 };
 
+function readWindow(hours: number): MetricEntry[] {
+  const cutoff = new Date(Date.now() - hours * 60 * 60 * 1000).toISOString();
+  const raw = readFileSync(ANALYTICS_FILE, "utf8");
+
+  // Reverse scan: walk from the end, collect until we pass cutoff.
+  const out: MetricEntry[] = [];
+  let end = raw.length;
+  while (end > 0) {
+    const start = raw.lastIndexOf("\n", end - 1);
+    const line = raw.slice(start + 1, end).trim();
+    end = start;
+    if (!line) continue;
+    try {
+      const entry = JSON.parse(line) as MetricEntry;
+      if (entry.ts < cutoff) break; // file is append-ordered by time
+      out.push(entry);
+    } catch {}
+  }
+  return out.reverse();
+}
+
 export async function GET(req: NextRequest) {
   const session = await auth();
   if (!session) {
@@ -32,21 +54,10 @@ export async function GET(req: NextRequest) {
   }
 
   try {
-    const lines = readFileSync(ANALYTICS_FILE, "utf8")
+    const entries = memo(`analytics:${hours}`, 30_000, () => readWindow(hours));
-      .split("\n")
+    return NextResponse.json(entries, {
-      .filter(Boolean);
+      headers: { "Cache-Control": "private, max-age=30" },
-
+    });
-    const cutoff = new Date(Date.now() - hours * 60 * 60 * 1000).toISOString();
-
-    const entries: MetricEntry[] = [];
-    for (const line of lines) {
-      try {
-        const entry = JSON.parse(line) as MetricEntry;
-        if (entry.ts >= cutoff) entries.push(entry);
-      } catch {}
-    }
-
-    return NextResponse.json(entries);
   } catch (e) {
     return NextResponse.json(
       { error: (e as Error).message },

app/api/logs/route.ts

@@ -1,6 +1,7 @@
 import { NextRequest, NextResponse } from "next/server";
 import { execSync } from "child_process";
 import { auth } from "@/lib/auth";
+import { memo } from "@/lib/cache";
 
 export const dynamic = "force-dynamic";
 
@@ -16,9 +17,11 @@ export async function GET(req: NextRequest) {
   );
 
   try {
-    const logs = execSync(
+    const logs = memo(`logs:${lines}`, 2000, () =>
-      `sudo journalctl -u minecraft.service --no-pager -n ${lines}`,
+      execSync(`sudo journalctl -u minecraft.service --no-pager -n ${lines}`, {
-      { encoding: "utf8", timeout: 5000 }
+        encoding: "utf8",
+        timeout: 5000,
+      })
     );
     return NextResponse.json({ logs });
   } catch (e) {

app/api/mods/route.ts

@@ -6,7 +6,9 @@ export const dynamic = "force-dynamic";
 export async function GET() {
   try {
     const mods = getModDetails();
-    return NextResponse.json(mods);
+    return NextResponse.json(mods, {
+      headers: { "Cache-Control": "public, max-age=10" },
+    });
   } catch (e) {
     return NextResponse.json(
       { error: (e as Error).message },

app/api/players/route.ts

@@ -2,6 +2,7 @@ import { NextRequest, NextResponse } from "next/server";
 import { readFileSync } from "fs";
 import { auth } from "@/lib/auth";
 import { sendCommand } from "@/lib/rcon";
+import { memo, invalidate } from "@/lib/cache";
 
 export const dynamic = "force-dynamic";
 
@@ -28,24 +29,27 @@ export async function GET() {
     return NextResponse.json({ error: "Unauthorized" }, { status: 403 });
   }
 
-  const ops = readJson<OpsEntry>(OPS_FILE).map((e) => ({
+  const data = memo("players", 10_000, () => {
-    name: e.name,
+    const ops = readJson<OpsEntry>(OPS_FILE).map((e) => ({
-    uuid: e.uuid,
+      name: e.name,
-    level: e.level,
+      uuid: e.uuid,
-  }));
+      level: e.level,
+    }));
+    const whitelist = readJson<WhitelistEntry>(WHITELIST_FILE).map((e) => ({
+      name: e.name,
+      uuid: e.uuid,
+    }));
+    const banned = readJson<BannedEntry>(BANNED_FILE).map((e) => ({
+      name: e.name,
+      uuid: e.uuid,
+      reason: e.reason,
+    }));
+    return { ops, whitelist, banned };
+  });
 
-  const whitelist = readJson<WhitelistEntry>(WHITELIST_FILE).map((e) => ({
+  return NextResponse.json(data, {
-    name: e.name,
+    headers: { "Cache-Control": "private, max-age=5" },
-    uuid: e.uuid,
+  });
-  }));
-
-  const banned = readJson<BannedEntry>(BANNED_FILE).map((e) => ({
-    name: e.name,
-    uuid: e.uuid,
-    reason: e.reason,
-  }));
-
-  return NextResponse.json({ ops, whitelist, banned });
 }
 
 // POST — execute a player management command
@@ -87,6 +91,7 @@ export async function POST(req: NextRequest) {
 
     // Wait for server to write JSON files to disk
     await new Promise((r) => setTimeout(r, 500));
+    invalidate("players");
 
     return NextResponse.json({ ok: true, response });
   } catch (e) {

app/api/status/route.ts

@@ -3,48 +3,58 @@ 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 { memoAsync } from "@/lib/cache";
 
 export const dynamic = "force-dynamic";
 
-export async function GET() {
+type StatusResult = {
-  // Tier 1: MC protocol ping (fastest, gives player/version info)
+  online: boolean;
-  try {
+  starting?: boolean;
-    const result = await status(MC_SERVER_IP, MC_SERVER_PORT, {
+  players: { online: number; max: number };
-      timeout: 5000,
+  version?: string;
-    });
+  motd?: string;
-    return NextResponse.json({
+};
-      online: true,
-      players: { online: result.players.online, max: result.players.max },
-      version: result.version.name,
-      motd: result.motd.clean,
-    });
-  } catch {}
 
-  // Tier 2: RCON (server is online but protocol ping failed)
+async function probeStatus(): Promise<StatusResult> {
-  try {
+  // Race protocol ping + RCON in parallel — whichever wins first signals "online"
-    const response = await sendCommand("list");
+  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 NextResponse.json({
+    return {
       online: true,
       players: {
         online: match ? parseInt(match[1], 10) : 0,
         max: match ? parseInt(match[2], 10) : 20,
       },
-    });
+    };
-  } catch {}
+  });
 
-  // Tier 3: systemctl (process alive but not yet accepting connections)
-  let starting = false;
   try {
-    const out = execSync("systemctl is-active minecraft.service", {
+    return await Promise.any([ping, rcon]);
-      encoding: "utf8",
+  } catch {
-    }).trim();
+    // Both failed — check if process is up
-    starting = out === "active" || out === "activating";
+    let starting = false;
-  } catch {}
+    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 } };
+  }
+}
 
-  return NextResponse.json({
+export async function GET() {
-    online: false,
+  const result = await memoAsync("status", 3000, probeStatus);
-    starting,
+  return NextResponse.json(result, {
-    players: { online: 0, max: 0 },
+    headers: { "Cache-Control": "public, max-age=3" },
   });
 }

components/Analytics.tsx

@@ -1,7 +1,7 @@
 "use client";
 
 import { useQuery } from "@tanstack/react-query";
-import { useState } from "react";
+import { useMemo, useState } from "react";
 import { Skeleton } from "@/components/ui/skeleton";
 import {
   Card,
@@ -55,16 +55,17 @@ function Sparkline({
     );
   }
 
-  const dataMax = max || Math.max(...data, 1);
+  const { pathD, areaD, w } = useMemo(() => {
-  const w = 300;
+    const dataMax = max || Math.max(...data, 1);
-  const points = data.map((v, i) => {
+    const width = 300;
-    const x = (i / (data.length - 1)) * w;
+    const pts = data.map((v, i) => {
-    const y = height - (v / dataMax) * (height - 10) - 5;
+      const x = (i / (data.length - 1)) * width;
-    return `${x},${y}`;
+      const y = height - (v / dataMax) * (height - 10) - 5;
-  });
+      return `${x},${y}`;
-
+    });
-  const pathD = `M${points.join(" L")}`;
+    const p = `M${pts.join(" L")}`;
-  const areaD = `${pathD} L${w},${height} L0,${height} Z`;
+    return { pathD: p, areaD: `${p} L${width},${height} L0,${height} Z`, w: width };
+  }, [data, max, height]);
 
   return (
     <div className="rounded-lg bg-muted p-4">
@@ -99,6 +100,7 @@ export function Analytics() {
     queryFn: () =>
       fetch(`/api/analytics?hours=${hours}`).then((r) => r.json()),
     refetchInterval: 60_000,
+    staleTime: 30_000,
   });
 
   const latest = metrics.length > 0 ? metrics[metrics.length - 1] : null;

components/ModManager.tsx

@@ -489,7 +489,11 @@ export function ModManager() {
                           <img
                             src={result.icon_url}
                             alt=""
-                            className="w-10 h-10 rounded-md shrink-0"
+                            width={40}
+                            height={40}
+                            loading="lazy"
+                            decoding="async"
+                            className="w-10 h-10 rounded-md shrink-0 bg-muted"
                           />
                         ) : (
                           <div className="w-10 h-10 rounded-md bg-muted shrink-0" />

components/PlayerAvatar.tsx

@@ -33,6 +33,8 @@ export function PlayerAvatar({
       alt=""
       width={size}
       height={size}
+      loading="lazy"
+      decoding="async"
       onError={() => setFailed(true)}
       className={`rounded shrink-0 bg-muted ${className}`}
     />

components/ServerControls.tsx

@@ -39,6 +39,7 @@ export function ServerControls() {
     queryKey: ["status"],
     queryFn: () => fetch("/api/status").then((r) => r.json()),
     refetchInterval: 10000,
+    staleTime: 5000,
   });
 
   const action = useMutation({

components/StatusCard.tsx

@@ -20,7 +20,8 @@ export function StatusCard() {
   const { data, isLoading } = useQuery<ServerStatus>({
     queryKey: ["status"],
     queryFn: () => fetch("/api/status").then((r) => r.json()),
-    refetchInterval: 15000,
+    refetchInterval: 10000,
+    staleTime: 5000,
   });
 
   const copyIP = () => {

lib/cache.ts

@@ -0,0 +1,29 @@
+type Entry<T> = { value: T; expires: number };
+
+const store = new Map<string, Entry<unknown>>();
+
+export function memo<T>(key: string, ttlMs: number, fn: () => T): T {
+  const now = Date.now();
+  const hit = store.get(key) as Entry<T> | undefined;
+  if (hit && hit.expires > now) return hit.value;
+  const value = fn();
+  store.set(key, { value, expires: now + ttlMs });
+  return value;
+}
+
+export async function memoAsync<T>(
+  key: string,
+  ttlMs: number,
+  fn: () => Promise<T>
+): Promise<T> {
+  const now = Date.now();
+  const hit = store.get(key) as Entry<T> | undefined;
+  if (hit && hit.expires > now) return hit.value;
+  const value = await fn();
+  store.set(key, { value, expires: now + ttlMs });
+  return value;
+}
+
+export function invalidate(prefix: string): void {
+  for (const k of store.keys()) if (k.startsWith(prefix)) store.delete(k);
+}

lib/mods.ts

@@ -18,8 +18,16 @@ import {
   MC_SERVER_PORT,
 } from "./constants";
 import { sendCommand } from "./rcon";
+import { memo, invalidate } from "./cache";
 import type { ModSide } from "./modrinth";
 
+const MODS_CACHE_KEY = "mods:details";
+const MODS_CACHE_TTL = 10_000;
+
+export function invalidateModsCache(): void {
+  invalidate("mods:");
+}
+
 const MODPACK_ZIP = "/var/www/minecraft/modpack.zip";
 const MODPACK_MODS = "/var/www/minecraft/mods";
 
@@ -56,6 +64,7 @@ export function addModMetadata(
   const metadata = loadModMetadata();
   metadata[filename] = entry;
   saveModMetadata(metadata);
+  invalidateModsCache();
 }
 
 export function removeModMetadata(filename: string): void {
@@ -108,6 +117,10 @@ function extractModMeta(
 }
 
 export function getModDetails(): ModMeta[] {
+  return memo(MODS_CACHE_KEY, MODS_CACHE_TTL, computeModDetails);
+}
+
+function computeModDetails(): ModMeta[] {
   const metadata = loadModMetadata();
 
   // Server mods
@@ -149,6 +162,7 @@ export function removeMod(filename: string): void {
   }
 
   removeModMetadata(filename);
+  invalidateModsCache();
 }
 
 export function isClientOnlyMod(filename: string): boolean {

lib/rcon.ts

@@ -1,18 +1,65 @@
 import { Rcon } from "rcon-client";
 import { MC_SERVER_IP, RCON_PORT, RCON_PASSWORD } from "./constants";
 
-export async function sendCommand(command: string): Promise<string> {
+let pooled: Rcon | null = null;
+let connecting: Promise<Rcon> | null = null;
+let idleTimer: NodeJS.Timeout | null = null;
+const IDLE_MS = 30_000;
+
+async function open(): Promise<Rcon> {
   const rcon = await Rcon.connect({
     host: MC_SERVER_IP,
     port: RCON_PORT,
     password: RCON_PASSWORD,
     timeout: 5000,
   });
+  rcon.on("end", () => {
+    if (pooled === rcon) pooled = null;
+  });
+  rcon.on("error", () => {
+    if (pooled === rcon) pooled = null;
+  });
+  return rcon;
+}
 
+function scheduleIdleClose() {
+  if (idleTimer) clearTimeout(idleTimer);
+  idleTimer = setTimeout(() => {
+    const r = pooled;
+    pooled = null;
+    idleTimer = null;
+    r?.end().catch(() => {});
+  }, IDLE_MS);
+}
+
+async function getConnection(): Promise<Rcon> {
+  if (pooled) return pooled;
+  if (connecting) return connecting;
+  connecting = open()
+    .then((r) => {
+      pooled = r;
+      return r;
+    })
+    .finally(() => {
+      connecting = null;
+    });
+  return connecting;
+}
+
+export async function sendCommand(command: string): Promise<string> {
   try {
+    const rcon = await getConnection();
     const response = await rcon.send(command);
+    scheduleIdleClose();
+    return response;
+  } catch (e) {
+    // Drop the pooled connection on any error, retry once with fresh
+    const bad = pooled;
+    pooled = null;
+    bad?.end().catch(() => {});
+    const rcon = await getConnection();
+    const response = await rcon.send(command);
+    scheduleIdleClose();
     return response;
-  } finally {
-    rcon.end();
   }
 }

next.config.ts

@@ -2,6 +2,13 @@ import type { NextConfig } from "next";
 
 const nextConfig: NextConfig = {
   serverExternalPackages: ["adm-zip"],
+  compress: true,
+  images: {
+    remotePatterns: [
+      { protocol: "https", hostname: "mc-heads.net" },
+      { protocol: "https", hostname: "cdn.modrinth.com" },
+    ],
+  },
   experimental: {
     serverActions: {
       bodySizeLimit: "100mb",