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")
-      .split("\n")
-      .filter(Boolean);
-
-    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);
+    const entries = memo(`analytics:${hours}`, 30_000, () => readWindow(hours));
+    return NextResponse.json(entries, {
+      headers: { "Cache-Control": "private, max-age=30" },
+    });
   } 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(
-      `sudo journalctl -u minecraft.service --no-pager -n ${lines}`,
-      { encoding: "utf8", timeout: 5000 }
+    const logs = memo(`logs:${lines}`, 2000, () =>
+      execSync(`sudo journalctl -u minecraft.service --no-pager -n ${lines}`, {
+        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) => ({
-    name: e.name,
-    uuid: e.uuid,
-    level: e.level,
-  }));
+  const data = memo("players", 10_000, () => {
+    const ops = readJson<OpsEntry>(OPS_FILE).map((e) => ({
+      name: e.name,
+      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) => ({
-    name: e.name,
-    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 });
+  return NextResponse.json(data, {
+    headers: { "Cache-Control": "private, max-age=5" },
+  });
 }
 
 // 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() {
-  // Tier 1: MC protocol ping (fastest, gives player/version info)
-  try {
-    const result = await status(MC_SERVER_IP, MC_SERVER_PORT, {
-      timeout: 5000,
-    });
-    return NextResponse.json({
-      online: true,
-      players: { online: result.players.online, max: result.players.max },
-      version: result.version.name,
-      motd: result.motd.clean,
-    });
-  } catch {}
+type StatusResult = {
+  online: boolean;
+  starting?: boolean;
+  players: { online: number; max: number };
+  version?: string;
+  motd?: string;
+};
 
-  // Tier 2: RCON (server is online but protocol ping failed)
-  try {
-    const response = await sendCommand("list");
+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 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", {
-      encoding: "utf8",
-    }).trim();
-    starting = out === "active" || out === "activating";
-  } catch {}
+    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 } };
+  }
+}
 
-  return NextResponse.json({
-    online: false,
-    starting,
-    players: { online: 0, max: 0 },
+export async function GET() {
+  const result = await memoAsync("status", 3000, probeStatus);
+  return NextResponse.json(result, {
+    headers: { "Cache-Control": "public, max-age=3" },
   });
 }