jskelet 0.2.5 → 0.3.1

package/src/server/admin/router.js

@@ -0,0 +1,216 @@
+/**
+ * Admin paneli Express router'ı.
+ */
+import fs from "node:fs";
+import path from "node:path";
+import express from "express";
+import { FRAMEWORK_ROOT } from "../../config/index.js";
+import {
+  ACTION_HEADER,
+  authenticated,
+  clearSessionCookie,
+  createSession,
+  destroySession,
+  passwordMatches,
+  sessionCookie,
+} from "./auth.js";
+import { clearOffender, gateMiddleware, noteFailure } from "./gate.js";
+import { snapshot } from "./snapshot.js";
+import { runAction } from "./actions.js";
+import {
+  list as listLogs,
+  subscribeLive,
+} from "./event-log.js";
+import {
+  listExpressRoutes,
+  listRouteModules,
+  listViews,
+  routeActivity,
+} from "./inventory.js";
+import {
+  cloudflareConfigured,
+  fetchCacheAnalytics,
+  fetchCloudflareOverview,
+  fetchPathEdges,
+} from "../cloudflare.js";
+
+const PANEL_DIR = path.join(FRAMEWORK_ROOT, "src", "client", "admin");
+
+/**
+ * @param {() => typeof import('../../config/defaults.js').DEFAULT_ADMIN} getSettings
+ * @param {import('express').Express} app
+ * @returns {import('express').Router}
+ */
+export function createAdminRouter(getSettings, app) {
+  const api = express.Router();
+
+  api.use((req, res, next) => {
+    res.setHeader("Cache-Control", "no-store, no-cache, must-revalidate");
+    res.setHeader("X-Robots-Tag", "noindex, nofollow, noarchive, nosnippet");
+    res.setHeader("Referrer-Policy", "no-referrer");
+    next();
+  });
+
+  api.use(gateMiddleware(getSettings));
+
+  // Soft page routes → aynı shell (client path ile sekme seçer).
+  // JSON API'ler ayrı `/api/*` altında: `/logs` hem sayfa hem döküm olamaz.
+  const shellPages = ["/", "/cache", "/routes", "/views", "/logs", "/system"];
+  for (const page of shellPages) {
+    api.get(page, (req, res) => {
+      const settings = getSettings();
+      const bare = req.originalUrl.split("?")[0];
+      if (page === "/" && !bare.endsWith("/")) {
+        res.redirect(302, `${settings.basePath}/`);
+        return;
+      }
+
+      res.type("html");
+      sendFile(res, authenticated(req) ? "panel.html" : "login.html");
+    });
+  }
+
+  api.get("/panel.css", (req, res) => {
+    res.type("text/css");
+    sendFile(res, "panel.css");
+  });
+
+  api.get("/i18n.js", (req, res) => {
+    res.type("application/javascript");
+    sendFile(res, "i18n.js");
+  });
+
+  api.get("/logo.png", (req, res) => {
+    res.type("image/png");
+    fs.createReadStream(path.join(FRAMEWORK_ROOT, "src", "logo.png")).pipe(res);
+  });
+
+  api.post("/login", express.json({ limit: "4kb" }), (req, res) => {
+    const settings = getSettings();
+    const password = typeof req.body?.password === "string" ? req.body.password : "";
+
+    if (!passwordMatches(password)) {
+      noteFailure(req, password ? "wrong password" : "empty password", settings);
+      res.status(401).json({ ok: false, message: "Invalid password" });
+      return;
+    }
+
+    const { token, maxAge } = createSession(settings.sessionHours);
+    clearOffender(req);
+    res.setHeader("Set-Cookie", sessionCookie(settings.basePath, token, maxAge));
+    res.json({ ok: true });
+  });
+
+  api.use((req, res, next) => {
+    if (authenticated(req)) return next();
+
+    if (req.method !== "GET" && req.method !== "HEAD") {
+      noteFailure(req, `unauthenticated ${req.method} ${req.path}`, getSettings());
+    }
+
+    res.status(404).type("text/plain").send("Not Found");
+  });
+
+  api.post("/logout", (req, res) => {
+    const settings = getSettings();
+    destroySession(req);
+    res.setHeader("Set-Cookie", clearSessionCookie(settings.basePath));
+    res.json({ ok: true });
+  });
+
+  api.get("/panel.js", (req, res) => {
+    res.type("application/javascript");
+    sendFile(res, "panel.js");
+  });
+
+  api.get("/data", async (req, res) => {
+    const query = typeof req.query.q === "string" ? req.query.q : "";
+    res.json(await snapshot(query));
+  });
+
+  api.get("/api/routes", (req, res) => {
+    res.json({
+      routes: listExpressRoutes(app),
+      modules: listRouteModules(),
+      activity: routeActivity(),
+    });
+  });
+
+  api.get("/api/views", (req, res) => {
+    res.json({ views: listViews() });
+  });
+
+  api.get("/api/logs", (req, res) => {
+    const after = Number(req.query.after) || 0;
+    const limit = Number(req.query.limit) || 200;
+    res.json({ entries: listLogs(after, limit) });
+  });
+
+  api.get("/api/logs/stream", (req, res) => {
+    res.setHeader("Content-Type", "text/event-stream; charset=utf-8");
+    res.setHeader("Cache-Control", "no-store, no-cache");
+    res.setHeader("Connection", "keep-alive");
+    res.flushHeaders?.();
+
+    const replay = listLogs(0, 100);
+    for (const entry of replay) {
+      res.write(`data: ${JSON.stringify(entry)}\n\n`);
+    }
+
+    const unsubscribe = subscribeLive((entry) => {
+      res.write(`data: ${JSON.stringify(entry)}\n\n`);
+    });
+
+    const heartbeat = setInterval(() => {
+      res.write(": ping\n\n");
+    }, 15000);
+
+    req.on("close", () => {
+      clearInterval(heartbeat);
+      unsubscribe();
+    });
+  });
+
+  api.get("/cloudflare", async (req, res) => {
+    res.json(await fetchCloudflareOverview({ force: req.query.force === "1" }));
+  });
+
+  api.post("/cloudflare/analytics", express.json({ limit: "8kb" }), async (req, res) => {
+    if (!cloudflareConfigured()) {
+      res.json({ ok: false, error: "not configured" });
+      return;
+    }
+
+    const hours = Number(req.body?.hours) || undefined;
+    const pathValue = typeof req.body?.path === "string" ? req.body.path.trim() : "";
+    res.json(
+      pathValue
+        ? await fetchPathEdges({ path: pathValue, hours })
+        : await fetchCacheAnalytics({ hours }),
+    );
+  });
+
+  api.post("/action", express.json({ limit: "64kb" }), async (req, res) => {
+    if (req.get(ACTION_HEADER) !== "1") {
+      res.status(404).type("text/plain").send("Not Found");
+      return;
+    }
+
+    try {
+      res.json(await runAction(req.body ?? {}, req));
+    } catch (error) {
+      console.error("[admin] action failed", error);
+      res.status(500).json({ ok: false, message: "Action failed, see server logs" });
+    }
+  });
+
+  return api;
+}
+
+/**
+ * @param {import('express').Response} res
+ * @param {string} name
+ */
+function sendFile(res, name) {
+  fs.createReadStream(path.join(PANEL_DIR, name)).pipe(res);
+}

package/src/server/admin/snapshot.js

@@ -0,0 +1,241 @@
+/**
+ * Admin paneli cache / host / process dökümü.
+ *
+ * HTML gövdesi ve veri değerleri dönmez — yalnızca meta.
+ * System sayfasındaki çubuklar **bu sürecin** payını gösterir (makine
+ * toplamına oranla), host'un genel doluluğunu değil.
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import process from "node:process";
+import { getConfig } from "../../config/index.js";
+import {
+  FRAMEWORK_HOMEPAGE,
+  FRAMEWORK_LICENSE,
+  FRAMEWORK_NODE_RANGE,
+  FRAMEWORK_VERSION,
+} from "../../version.mjs";
+import {
+  getHtmlCacheEntries,
+  getHtmlCacheSize,
+} from "../html-cache.js";
+import {
+  getDataCacheEntries,
+  getDataCacheSize,
+} from "../data-cache.js";
+import { getRedisDetails, getRedisStatus } from "../redis.js";
+import { getUpstreamLimiterStatus } from "../upstream-limiter.js";
+import { getCloudflareStatus } from "../cloudflare.js";
+import { prewarmProgress } from "../prewarm.js";
+
+/** Listelerin üst sınırı: veri önbelleğinde on binlerce anahtar olabiliyor. */
+const MAX_LISTED = 500;
+
+/** Disk ölçümünde atlanan dizinler — node_modules her poll'da taranmasın. */
+const SKIP_DIRS = new Set([
+  "node_modules",
+  ".git",
+  ".hg",
+  ".svn",
+  "coverage",
+  ".turbo",
+  ".next",
+]);
+
+export const BOOT_ID = `${Date.now()}-${process.pid}`;
+
+/** @type {{ usage: NodeJS.CpuUsage; at: number } | null} */
+let cpuSample = null;
+
+/** @type {{ at: number, bytes: number, root: string } | null} */
+let diskSample = null;
+
+/**
+ * @param {string} query Anahtar filtresi (boş → filtre yok).
+ * @returns {Promise<object>}
+ */
+export async function snapshot(query) {
+  const term = query.trim().toLowerCase();
+  /** @param {{ key: string }} entry */
+  const matches = (entry) => !term || entry.key.toLowerCase().includes(term);
+
+  const html = getHtmlCacheEntries();
+  const data = getDataCacheEntries();
+
+  const htmlMatched = html.filter(matches);
+  const dataMatched = data.filter(matches);
+  const usage = process.memoryUsage();
+  const host = await hostStatus();
+  const cpuPercent = sampleProcessCpu(host.cpus);
+  const appDiskBytes = await sampleAppDisk(getConfig().root);
+
+  return {
+    boot: BOOT_ID,
+    generatedAt: Date.now(),
+    release: {
+      version: FRAMEWORK_VERSION,
+      license: FRAMEWORK_LICENSE,
+      node: FRAMEWORK_NODE_RANGE,
+      homepage: FRAMEWORK_HOMEPAGE,
+    },
+    host,
+    process: {
+      pid: process.pid,
+      node: process.version,
+      uptime: process.uptime(),
+      env: process.env.NODE_ENV ?? "production",
+      memory: { rss: usage.rss, heapUsed: usage.heapUsed },
+      /** 0–100: bu sürecin tüm çekirdek kapasitesine oranı. */
+      cpuPercent,
+      /** Proje kökünün (node_modules hariç) disk boyutu. */
+      diskBytes: appDiskBytes,
+    },
+    html: {
+      size: getHtmlCacheSize(),
+      maxEntries: getConfig().htmlMaxEntries,
+      bytes: html.reduce((total, entry) => total + entry.bytes, 0),
+      stale: html.filter((entry) => entry.stale).length,
+      matched: htmlMatched.length,
+      entries: htmlMatched
+        .sort((a, b) => b.bytes - a.bytes)
+        .slice(0, MAX_LISTED)
+        .map((entry) => ({
+          ...entry,
+          url: entry.key.endsWith("?") ? entry.key.slice(0, -1) : entry.key,
+        })),
+    },
+    data: {
+      size: getDataCacheSize(),
+      maxEntries: Number(getConfig().data?.maxEntries) || 0,
+      stale: data.filter((entry) => entry.stale).length,
+      matched: dataMatched.length,
+      entries: dataMatched
+        .sort((a, b) => a.expiresIn - b.expiresIn)
+        .slice(0, MAX_LISTED),
+    },
+    redis: { ...getRedisStatus(), ...getRedisDetails() },
+    cloudflare: getCloudflareStatus(),
+    upstream: getUpstreamLimiterStatus(),
+    prewarm: { ...prewarmProgress },
+  };
+}
+
+/**
+ * İki örnek arasındaki `process.cpuUsage` farkından süreç CPU yüzdesi.
+ * İlk çağrıda örnek alınır ve 0 döner — panelin bir sonraki turunda anlamlı.
+ *
+ * @param {number} cores
+ * @returns {number}
+ */
+function sampleProcessCpu(cores) {
+  const now = Date.now();
+  const current = process.cpuUsage();
+
+  if (!cpuSample) {
+    cpuSample = { usage: current, at: now };
+    return 0;
+  }
+
+  const elapsedMs = now - cpuSample.at;
+  const delta = process.cpuUsage(cpuSample.usage);
+  cpuSample = { usage: current, at: now };
+
+  if (elapsedMs <= 0 || cores <= 0) return 0;
+
+  // user+system mikro-saniye → ms; duvar süresi × çekirdek = kapasite.
+  const cpuMs = (delta.user + delta.system) / 1000;
+  const capacityMs = elapsedMs * cores;
+  return Math.max(0, Math.min(100, (cpuMs / capacityMs) * 100));
+}
+
+/**
+ * Proje kökünün boyutu (ağır dizinler atlanır). 60 sn önbellek.
+ *
+ * @param {string} root
+ * @returns {Promise<number>}
+ */
+async function sampleAppDisk(root) {
+  if (diskSample && diskSample.root === root && Date.now() - diskSample.at < 60_000) {
+    return diskSample.bytes;
+  }
+
+  const bytes = await measureDir(root);
+  diskSample = { at: Date.now(), bytes, root };
+  return bytes;
+}
+
+/**
+ * @param {string} dir
+ * @returns {Promise<number>}
+ */
+async function measureDir(dir) {
+  let total = 0;
+
+  /** @type {string[]} */
+  const stack = [dir];
+
+  while (stack.length) {
+    const current = stack.pop();
+    if (!current) continue;
+
+    let entries;
+    try {
+      entries = await fs.promises.readdir(current, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+
+    for (const entry of entries) {
+      if (entry.name === "." || entry.name === "..") continue;
+      if (entry.isDirectory() && SKIP_DIRS.has(entry.name)) continue;
+
+      const full = path.join(current, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(full);
+        continue;
+      }
+      if (!entry.isFile()) continue;
+
+      try {
+        const stats = await fs.promises.stat(full);
+        total += stats.size;
+      } catch {
+        // silinmiş / erişilemeyen dosya
+      }
+    }
+  }
+
+  return total;
+}
+
+/**
+ * @returns {Promise<object>}
+ */
+async function hostStatus() {
+  const total = os.totalmem();
+  const free = os.freemem();
+
+  /** @type {{ path: string, total: number, free: number } | null} */
+  let disk = null;
+
+  try {
+    const root = getConfig().root;
+    const stats = await fs.promises.statfs(root);
+    disk = {
+      path: root,
+      total: stats.blocks * stats.bsize,
+      free: stats.bavail * stats.bsize,
+    };
+  } catch {
+    disk = null;
+  }
+
+  return {
+    platform: `${os.platform()} ${os.arch()}`,
+    cpus: os.cpus().length,
+    load: os.loadavg()[0],
+    memory: { total, free, used: total - free },
+    disk,
+  };
+}