jskelet 0.2.2 → 0.2.4

package/src/server/cache-panel.js

@@ -26,10 +26,18 @@
  */
 import crypto from "node:crypto";
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import process from "node:process";
 import express from "express";
+import * as log from "../log.mjs";
 import { FRAMEWORK_ROOT, getConfig } from "../config/index.js";
+import {
+  FRAMEWORK_HOMEPAGE,
+  FRAMEWORK_LICENSE,
+  FRAMEWORK_NODE_RANGE,
+  FRAMEWORK_VERSION,
+} from "../version.mjs";
 import { safeEqual } from "../http/cookies.js";
 import {
   clearHtmlCache,
@@ -44,8 +52,25 @@ import {
   getDataCacheEntries,
   getDataCacheSize,
 } from "./data-cache.js";
-import { getRedisStatus, redisDropMatching } from "./redis.js";
+import {
+  getRedisDetails,
+  getRedisStatus,
+  inspectRedis,
+  redisDropMatching,
+} from "./redis.js";
 import { getUpstreamLimiterStatus } from "./upstream-limiter.js";
+import {
+  clearCloudflareCacheReserve,
+  cloudflareConfigured,
+  fetchCacheAnalytics,
+  fetchCloudflareOverview,
+  fetchPathEdges,
+  getCloudflareStatus,
+  purgeCloudflare,
+  setCloudflareFeature,
+  setCloudflareSetting,
+  toCloudflareUrls,
+} from "./cloudflare.js";
 import { prewarm, prewarmProgress } from "./prewarm.js";
 
 /** Panel dosyaları framework paketinden servis edilir, uygulamadan değil. */
@@ -199,9 +224,9 @@ function notFound(res) {
  * göndermenin faydası yok.
  *
  * @param {string} query Anahtar filtresi (boş → filtre yok).
- * @returns {object}
+ * @returns {Promise<object>}
  */
-function snapshot(query) {
+async function snapshot(query) {
   const term = query.trim().toLowerCase();
   /** @param {{ key: string }} entry */
   const matches = (entry) => !term || entry.key.toLowerCase().includes(term);
@@ -216,6 +241,13 @@ function snapshot(query) {
   return {
     boot: BOOT_ID,
     generatedAt: Date.now(),
+    release: {
+      version: FRAMEWORK_VERSION,
+      license: FRAMEWORK_LICENSE,
+      node: FRAMEWORK_NODE_RANGE,
+      homepage: FRAMEWORK_HOMEPAGE,
+    },
+    host: await hostStatus(),
     process: {
       pid: process.pid,
       node: process.version,
@@ -231,7 +263,14 @@ function snapshot(query) {
       matched: htmlMatched.length,
       entries: htmlMatched
         .sort((a, b) => b.bytes - a.bytes)
-        .slice(0, MAX_LISTED),
+        .slice(0, MAX_LISTED)
+        // Anahtar `yol?query`; query boşken sonda yalnız bir `?` kalıyor.
+        // Silme işlemleri gerçek anahtarı kullanmaya devam eder, panel
+        // ziyaret edilebilir yolu gösterir.
+        .map((entry) => ({
+          ...entry,
+          url: entry.key.endsWith("?") ? entry.key.slice(0, -1) : entry.key,
+        })),
     },
     data: {
       size: getDataCacheSize(),
@@ -242,16 +281,68 @@ function snapshot(query) {
         .sort((a, b) => a.expiresIn - b.expiresIn)
         .slice(0, MAX_LISTED),
     },
-    redis: getRedisStatus(),
+    redis: { ...getRedisStatus(), ...getRedisDetails() },
+    // Cloudflare yalnızca kurulum özeti: zone bilgisi ve analitik ağa çıkıyor
+    // ve döküm birkaç saniyede bir yenileniyor. Ayrıntı ayrı uçta.
+    cloudflare: getCloudflareStatus(),
     upstream: getUpstreamLimiterStatus(),
     prewarm: { ...prewarmProgress },
   };
 }
 
+/**
+ * Makinenin RAM ve disk durumu.
+ *
+ * Paylaşımlı kademe kapalıyken önbelleğin tamamı bu sürecin belleğinde
+ * yaşıyor ve `maxEntries` ile RAM arasındaki ilişki panelde görünmediği sürece
+ * ayarlanamıyor: "500 girdi çok mu" sorusunun cevabı makinede ne kadar boş
+ * bellek kaldığına bağlı. Disk, HTML önbelleğinin kendisi için değil, ısıtma
+ * ve build çıktısının yaşadığı yer için: dolu bir diskte `jskelet build`
+ * sessizce hatalı manifest bırakıyor.
+ *
+ * `statfs` desteklenmeyen bir platform ya da erişilemeyen bir yol sadece
+ * `null` disk demek; panel yine açılır.
+ *
+ * @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,
+      // `bavail`, `bfree` değil: ayrılmış blokları boş göstermek yanıltıcı.
+      free: stats.bavail * stats.bsize,
+    };
+  } catch {
+    disk = null;
+  }
+
+  return {
+    platform: `${os.platform()} ${os.arch()}`,
+    cpus: os.cpus().length,
+    // Windows'ta `loadavg()` her zaman sıfır döner; panel bunu gizler.
+    load: os.loadavg()[0],
+    memory: { total, free, used: total - free },
+    disk,
+  };
+}
+
 /* --------------------------------------------------------------- aksiyonlar */
 
 /**
- * Panelden gelen işlemi uygular ve kullanıcıya gösterilecek özeti döner.
+ * Panelden gelen işlemi uygular ve sonucu **metin değil kod** olarak döner.
+ *
+ * Cümleyi panel kuruyor (`i18n.js`): panel iki dilde konuşuyor, sunucunun
+ * arayüz dilini bilmesi için bir sebep yok. `params` yer tutucuları besler,
+ * `parts` ise eksik kalabilen parçalı cevaplar için.
  *
  * Her işlem yerel kademeyi düşürüp paylaşımlı kademeye de yayılıyor (bkz.
  * `html-cache.js`, `data-cache.js`): tek node'un önbelleğini boşaltmak,
@@ -259,7 +350,9 @@ function snapshot(query) {
  *
  * @param {Record<string, any>} body
  * @param {import('express').Request} req
- * @returns {Promise<{ ok: boolean, message: string }>}
+ * @returns {Promise<{ ok: boolean, code?: string,
+ *   params?: Record<string, string | number>,
+ *   parts?: ({ code: string, params?: Record<string, string | number> } | null)[] }>}
  */
 async function runAction(body, req) {
   const type = String(body?.type ?? "");
@@ -268,51 +361,63 @@ async function runAction(body, req) {
     case "html:clear": {
       const size = getHtmlCacheSize();
       clearHtmlCache();
-      return { ok: true, message: `HTML cache cleared (${size} entries)` };
+      return { ok: true, code: "html.cleared", params: { count: size } };
     }
 
     case "data:clear": {
       const prefix = typeof body.prefix === "string" && body.prefix ? body.prefix : undefined;
       const removed = clearDataCache(prefix);
-      return {
-        ok: true,
-        message: prefix
-          ? `${removed} data entries dropped under \`${prefix}\``
-          : `Data cache cleared (${removed} entries)`,
-      };
+      return prefix
+        ? { ok: true, code: "data.clearedPrefix", params: { count: removed, prefix } }
+        : { ok: true, code: "data.cleared", params: { count: removed } };
     }
 
     case "html:invalidate": {
       const target = String(body.target ?? "");
       if (!target.startsWith("/")) {
-        return { ok: false, message: "Target must start with `/`" };
+        return { ok: false, code: "target.invalid" };
       }
 
       const hard = body.hard === true;
       const count = invalidateHtmlCache(target, { hard });
       return {
         ok: true,
-        message: `${count} entries ${hard ? "dropped" : "marked stale"} for \`${target}\``,
+        code: hard ? "html.dropped" : "html.marked",
+        params: { count, target },
       };
     }
 
     case "html:drop": {
       const key = String(body.key ?? "");
-      if (!key) return { ok: false, message: "Missing key" };
+      if (!key) return { ok: false, code: "key.missing" };
       const existed = dropHtmlCacheKey(key);
-      return {
-        ok: true,
-        message: existed ? `Dropped \`${key}\`` : `\`${key}\` was not cached`,
-      };
+      return { ok: true, code: existed ? "entry.dropped" : "entry.absent", params: { key } };
     }
 
     case "data:drop": {
       const key = String(body.key ?? "");
-      if (!key) return { ok: false, message: "Missing key" };
+      if (!key) return { ok: false, code: "key.missing" };
       const existed = dropDataCacheKey(key);
+      return { ok: true, code: existed ? "entry.dropped" : "entry.absent", params: { key } };
+    }
+
+    case "redis:inspect": {
+      const result = await inspectRedis();
+      if (!result.ok) return { ok: false, code: "redis.unreachable" };
+
+      // Sayım tek cümle değil parçalar hâlinde dönüyor: `DBSIZE` ve
+      // `used_memory` komut kısıtlı bir Redis'te okunamıyor ve eksik parçayı
+      // cümleden düşürme kararı panelin.
       return {
         ok: true,
-        message: existed ? `Dropped \`${key}\`` : `\`${key}\` was not cached`,
+        parts: [
+          { code: "redis.htmlKeys", params: { count: result.html } },
+          { code: "redis.dataKeys", params: { count: result.data } },
+          result.totalKeys !== null
+            ? { code: "redis.dbKeys", params: { count: result.totalKeys } }
+            : null,
+          result.usedMemory ? { code: "redis.memory", params: { value: result.usedMemory } } : null,
+        ].filter(Boolean),
       };
     }
 
@@ -320,16 +425,96 @@ async function runAction(body, req) {
       const kind = body.kind === "data" ? "data" : "html";
       const status = getRedisStatus();
       if (!status.connected) {
-        return { ok: false, message: "Redis is not connected" };
+        return { ok: false, code: "redis.notConnected" };
       }
 
       const dropped = await redisDropMatching(kind);
-      return { ok: true, message: `${dropped} shared ${kind} keys dropped` };
+      return {
+        ok: true,
+        code: kind === "data" ? "redis.droppedData" : "redis.droppedHtml",
+        params: { count: dropped },
+      };
+    }
+
+    /* ------------------------------------------------------- cloudflare */
+
+    case "cf:purge-everything": {
+      const result = await purgeCloudflare({ everything: true });
+      return result.ok
+        ? { ok: true, code: "cf.purgedEverything" }
+        : cloudflareFailure(result.error);
+    }
+
+    case "cf:purge-urls": {
+      // Panelin elindeki HTML anahtarları yol; Cloudflare tam URL istiyor.
+      // Origin, isteğin geldiği host'tan türetilir ki tek zone'lu kurulumda
+      // ayrıca ayar gerekmesin.
+      const paths = Array.isArray(body.paths) ? body.paths.map(String) : [];
+      if (!paths.length) return { ok: false, code: "cf.noPaths" };
+
+      const urls = toCloudflareUrls(paths, originOf(req));
+      if (!urls.length) return { ok: false, code: "cf.noHostname" };
+
+      const result = await purgeCloudflare({ files: urls });
+      return result.ok
+        ? {
+            ok: true,
+            code: "cf.purgedUrls",
+            params: { count: result.purged, batches: result.batches },
+          }
+        : cloudflareFailure(result.error);
+    }
+
+    case "cf:purge-keys": {
+      /** @type {"prefixes" | "hosts" | "tags"} */
+      const kind =
+        body.kind === "hosts" ? "hosts" : body.kind === "tags" ? "tags" : "prefixes";
+
+      const values = String(body.values ?? "")
+        .split(/[\s,]+/)
+        .filter(Boolean);
+
+      if (!values.length) return { ok: false, code: "cf.nothingToPurge" };
+
+      const result = await purgeCloudflare({ [kind]: values });
+      return result.ok
+        ? { ok: true, code: "cf.purgedKeys", params: { count: result.purged, kind } }
+        : cloudflareFailure(result.error);
+    }
+
+    case "cf:setting": {
+      const result = await setCloudflareSetting(body.id, body.value);
+      return result.ok
+        ? {
+            ok: true,
+            code: "cf.settingChanged",
+            params: { id: String(body.id), value: String(result.value) },
+          }
+        : cloudflareFailure(result.error);
+    }
+
+    case "cf:feature": {
+      const value = body.value === "on" ? "on" : "off";
+      const result = await setCloudflareFeature(body.feature, value);
+      return result.ok
+        ? {
+            ok: true,
+            code: "cf.featureChanged",
+            params: { feature: String(body.feature), value },
+          }
+        : cloudflareFailure(result.error);
+    }
+
+    case "cf:clear-reserve": {
+      const result = await clearCloudflareCacheReserve();
+      return result.ok
+        ? { ok: true, code: "cf.reserveClearing" }
+        : cloudflareFailure(result.error);
     }
 
     case "prewarm": {
       if (prewarmProgress.active) {
-        return { ok: false, message: "A prewarm round is already running" };
+        return { ok: false, code: "prewarm.busy" };
       }
 
       const requested = Array.isArray(body.paths) ? body.paths : [];
@@ -347,17 +532,27 @@ async function runAction(body, req) {
         console.error("[cache-panel] prewarm failed", error);
       });
 
-      return {
-        ok: true,
-        message: paths.length ? `Prewarming ${paths.length} paths` : "Prewarming all paths",
-      };
+      return paths.length
+        ? { ok: true, code: "prewarm.paths", params: { count: paths.length } }
+        : { ok: true, code: "prewarm.all" };
     }
 
     default:
-      return { ok: false, message: `Unknown action: ${type}` };
+      return { ok: false, code: "action.unknown", params: { type } };
   }
 }
 
+/**
+ * Cloudflare hatası tek bir kodla döner: hata metni Cloudflare'den geliyor ve
+ * çevrilemez, ama etrafındaki cümle çevrilebilir.
+ *
+ * @param {string | undefined} error
+ * @returns {{ ok: false, code: string, params: { error: string } }}
+ */
+function cloudflareFailure(error) {
+  return { ok: false, code: "cf.failed", params: { error: error ?? "unknown error" } };
+}
+
 /* ------------------------------------------------------------------ router */
 
 /**
@@ -396,13 +591,24 @@ function router() {
     sendFile(res, authenticated(req) ? "panel.html" : "login.html");
   });
 
-  // Stil giriş sayfasında da gerekiyor, yani oturumdan önce servis edilir.
-  // İçinde durum bilgisi yok.
+  // Stil ve logo giriş sayfasında da gerekiyor, yani oturumdan önce servis
+  // edilir. İkisinde de durum bilgisi yok.
   api.get("/panel.css", (req, res) => {
     res.type("text/css");
     sendFile(res, "panel.css");
   });
 
+  // Sözlük giriş sayfasında da gerekiyor: dil seçimi oturumdan önce yapılıyor.
+  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 password = typeof req.body?.password === "string" ? req.body.password : "";
 
@@ -441,7 +647,15 @@ function router() {
   api.use((req, res, next) => {
     if (authenticated(req)) return next();
 
-    noteFailure(req, `unauthenticated ${req.method} ${req.path}`);
+    // Yetkisiz **okuma** sayaca yazılmaz. Süreç yeniden başladığında eski
+    // oturumlar ölüyor ve açık kalmış bir panel sekmesi yoklamaya devam
+    // ediyor: sayarsak operatör kendi IP'sini üç saniyede yasaklıyor. Okuma
+    // zaten `404` dönüyor, yani saymamanın bir bedeli yok — korunması gereken
+    // şey şifre denemesi ve durumu değiştiren istek.
+    if (req.method !== "GET" && req.method !== "HEAD") {
+      noteFailure(req, `unauthenticated ${req.method} ${req.path}`);
+    }
+
     notFound(res);
   });
 
@@ -457,9 +671,29 @@ function router() {
     sendFile(res, "panel.js");
   });
 
-  api.get("/data", (req, res) => {
+  api.get("/data", async (req, res) => {
     const query = typeof req.query.q === "string" ? req.query.q : "";
-    res.json(snapshot(query));
+    res.json(await snapshot(query));
+  });
+
+  // Cloudflare ayrı uçlarda: her ikisi de ağa çıkıyor ve döküm turuna
+  // bağlanırlarsa panel Cloudflare'in gecikmesi kadar yavaşlar.
+  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 path = typeof req.body?.path === "string" ? req.body.path.trim() : "";
+
+    // Yol verildiyse soru "bu sayfa hangi edge'lerden servis edildi", yoksa
+    // "zone genelinde cache oranı ne".
+    res.json(path ? await fetchPathEdges({ path, hours }) : await fetchCacheAnalytics({ hours }));
   });
 
   api.post("/action", express.json({ limit: "64kb" }), async (req, res) => {
@@ -479,6 +713,18 @@ function router() {
   return api;
 }
 
+/**
+ * Purge URL'lerinin kökü. `cloudflare.hostname` verilmediğinde panelin
+ * açıldığı origin kullanılır: tek zone'lu bir kurulumda ikisi zaten aynı.
+ *
+ * @param {import('express').Request} req
+ * @returns {string | undefined}
+ */
+function originOf(req) {
+  const host = req.get("host");
+  return host ? `${req.protocol}://${host}` : undefined;
+}
+
 /**
  * @param {import('express').Response} res
  * @param {string} name
@@ -497,9 +743,17 @@ export function mountCachePanel(app) {
 
   app.use(settings.basePath, router());
 
+  // Şifre akışın içinde tek bir satır olarak kaybolmamalı: kullanıcı onu bir
+  // kez görüyor ve her restart'ta değişiyor.
   const port = process.env.PORT ?? 3000;
-  console.log(
-    `[cache-panel] http://localhost:${port}${settings.basePath} — ` +
-      `password for this run: ${PASSWORD}`,
-  );
+  log.box({
+    title: "CACHE PANEL",
+    lines: [
+      `http://localhost:${port}${settings.basePath}`,
+      "",
+      `password  ${PASSWORD}`,
+      "",
+      "Valid until this process restarts.",
+    ],
+  });
 }