@intranefr/superbackend 1.5.0 → 1.5.2

package/src/middleware.js

@@ -1,3 +1,22 @@
+const consoleOverride = require("./services/consoleOverride.service");
+const { consoleManager } = require("./services/consoleManager.service");
+
+// Initialize console override service early to capture all logs
+// Avoid keeping timers/streams alive during Jest runs.
+if (process.env.NODE_ENV !== "test" && !process.env.JEST_WORKER_ID) {
+  consoleOverride.init()
+  
+  // Initialize console manager after a short delay to ensure consoleOverride is fully set up
+  setTimeout(() => {
+    // Set module prefix for this middleware
+    consoleManager.setModulePrefix('middleware');
+    
+    // Initialize console manager early to enable prefixing for all subsequent logs
+    consoleManager.init();
+    console.log("[Console Manager] Initialized - prefixing enabled");
+  }, 20);
+}
+
 const express = require("express");
 const path = require("path");
 const mongoose = require("mongoose");
@@ -6,17 +25,54 @@ const fs = require("fs");
 const ejs = require("ejs");
 const { basicAuth } = require("./middleware/auth");
 const endpointRegistry = require("./admin/endpointRegistry");
-const { createFeatureFlagsEjsMiddleware } = require("./services/featureFlags.service");
-const consoleOverride = require("./services/consoleOverride.service");
+const {
+  createFeatureFlagsEjsMiddleware,
+} = require("./services/featureFlags.service");
+const globalSettingsService = require("./services/globalSettings.service");
+const cronScheduler = require("./services/cronScheduler.service");
+const healthChecksScheduler = require("./services/healthChecksScheduler.service");
+const healthChecksBootstrap = require("./services/healthChecksBootstrap.service");
+const blogCronsBootstrap = require("./services/blogCronsBootstrap.service");
 const {
   hookConsoleError,
   setupProcessHandlers,
   expressErrorMiddleware,
   requestIdMiddleware,
 } = require("./middleware/errorCapture");
+const rateLimiter = require("./services/rateLimiter.service");
 
 let errorCaptureInitialized = false;
 
+/**
+ * Check if console manager should be enabled based on environment variable and global settings
+ * Priority: Environment Variable > Global Settings > Default (true)
+ * @returns {Promise<boolean>} Whether console manager should be enabled
+ */
+async function isConsoleManagerEnabled() {
+  // Environment variable takes highest priority
+  const envEnabled = process.env.CONSOLE_MANAGER_ENABLED;
+  if (envEnabled !== undefined) {
+    const enabled = String(envEnabled).toLowerCase() !== 'false';
+    console.log(`[Console Manager] Environment variable CONSOLE_MANAGER_ENABLED=${envEnabled}, ${enabled ? 'enabled' : 'disabled'}`);
+    return enabled;
+  }
+
+  // Check global settings if environment variable not set
+  try {
+    const enabledRaw = await globalSettingsService.getSettingValue(
+      "CONSOLE_MANAGER_ENABLED",
+      "true"
+    );
+    const enabled = String(enabledRaw) === "true";
+    console.log(`[Console Manager] Global setting CONSOLE_MANAGER_ENABLED=${enabledRaw}, ${enabled ? 'enabled' : 'disabled'}`);
+    return enabled;
+  } catch (error) {
+    console.error("[Console Manager] Error loading global setting:", error);
+    console.log("[Console Manager] Fallback to enabled due to error");
+    return true; // Fallback to enabled on error
+  }
+}
+
 /**
  * Creates and configures the SaaS backend middleware
  * @param {Object} options - Configuration options
@@ -30,16 +86,55 @@ let errorCaptureInitialized = false;
 function createMiddleware(options = {}) {
   const router = express.Router();
   const adminPath = options.adminPath || "/admin";
+  const pagesPrefix = options.pagesPrefix || "/";
+
+  const normalizeBasePath = (value) => {
+    const v = String(value || "").trim();
+    if (!v) return "/files";
+    return v.startsWith("/") ? v : `/${v}`;
+  };
+
+  const fileManagerPublicConfig = {
+    enabled: false,
+    basePath: "/files",
+    loaded: false,
+  };
+
+  // Restart-required behavior: we load settings once and keep the values in memory.
+  (async () => {
+    try {
+      const enabledRaw = await globalSettingsService.getSettingValue(
+        "FILE_MANAGER_ENABLED",
+        "false",
+      );
+      const basePathRaw = await globalSettingsService.getSettingValue(
+        "FILE_MANAGER_BASE_PATH",
+        "/files",
+      );
+
+      fileManagerPublicConfig.enabled = String(enabledRaw) === "true";
+      fileManagerPublicConfig.basePath = normalizeBasePath(basePathRaw);
+      fileManagerPublicConfig.loaded = true;
+    } catch (error) {
+      console.error("Error loading File Manager public config:", error);
+      fileManagerPublicConfig.loaded = true;
+    }
+  })();
 
-  // Expose adminPath and WS attachment helper
+  // Expose adminPath, pagesPrefix and WS attachment helper
   router.adminPath = adminPath;
+  router.pagesPrefix = pagesPrefix;
   router.attachWs = (server) => {
-    const { attachTerminalWebsocketServer } = require('./services/terminalsWs.service');
+    const {
+      attachTerminalWebsocketServer,
+    } = require("./services/terminalsWs.service");
     attachTerminalWebsocketServer(server, { basePathPrefix: adminPath });
-  };
 
-  // Initialize console override service early to capture all logs
-  consoleOverride.init();
+    const {
+      attachExperimentsWebsocketServer,
+    } = require("./services/experimentsWs.service");
+    attachExperimentsWebsocketServer(server);
+  };
 
   if (!errorCaptureInitialized) {
     errorCaptureInitialized = true;
@@ -47,9 +142,14 @@ function createMiddleware(options = {}) {
     setupProcessHandlers();
   }
 
+  // Console manager will be initialized after database connection
+
   // Database connection
   const mongoUri =
-    options.mongodbUri || options.dbConnection || process.env.MONGODB_URI || process.env.MONGO_URI;
+    options.mongodbUri ||
+    options.dbConnection ||
+    process.env.MONGODB_URI ||
+    process.env.MONGO_URI;
 
   if (!mongoUri && mongoose.connection.readyState !== 1) {
     console.warn(
@@ -60,23 +160,135 @@ function createMiddleware(options = {}) {
       serverSelectionTimeoutMS: 5000,
       maxPoolSize: 10,
     };
-    
+
     // Return a promise that resolves when connection is established
     const connectionPromise = mongoose
       .connect(mongoUri, connectionOptions)
-      .then(() => {
+      .then(async () => {
         console.log("✅ Middleware: Connected to MongoDB");
+        // Start cron scheduler after DB connection
+        await cronScheduler.start();
+        await healthChecksScheduler.start();
+        await healthChecksBootstrap.bootstrap();
+        await blogCronsBootstrap.bootstrap();
+        await require("./services/experimentsCronsBootstrap.service").bootstrap();
+        
+        // Console manager is already initialized early in the middleware
+        console.log("[Console Manager] MongoDB connection established");
+        
         return true;
       })
       .catch((err) => {
         console.error("❌ Middleware: MongoDB connection error:", err);
         return false;
       });
-    
+
+    router.get(`${adminPath}/health-checks`, basicAuth, (req, res) => {
+      const templatePath = path.join(
+        __dirname,
+        "..",
+        "views",
+        "admin-health-checks.ejs",
+      );
+      fs.readFile(templatePath, "utf8", (err, template) => {
+        if (err) {
+          console.error("Error reading template:", err);
+          return res.status(500).send("Error loading page");
+        }
+        try {
+          const html = ejs.render(
+            template,
+            {
+              baseUrl: req.baseUrl,
+              adminPath,
+            },
+            {
+              filename: templatePath,
+            },
+          );
+          res.send(html);
+        } catch (renderErr) {
+          console.error("Error rendering template:", renderErr);
+          res.status(500).send("Error rendering page");
+        }
+      });
+    });
+
+    router.get(`${adminPath}/console-manager`, basicAuth, (req, res) => {
+      const templatePath = path.join(
+        __dirname,
+        "..",
+        "views",
+        "admin-console-manager.ejs",
+      );
+      fs.readFile(templatePath, "utf8", (err, template) => {
+        if (err) {
+          console.error("Error reading template:", err);
+          return res.status(500).send("Error loading page");
+        }
+        try {
+          const html = ejs.render(
+            template,
+            {
+              baseUrl: req.baseUrl,
+              adminPath,
+            },
+            {
+              filename: templatePath,
+            },
+          );
+          res.send(html);
+        } catch (renderErr) {
+          console.error("Error rendering template:", renderErr);
+          res.status(500).send("Error rendering page");
+        }
+      });
+    });
+
     // Store the promise so it can be awaited if needed
     router.connectionPromise = connectionPromise;
   } else if (mongoose.connection.readyState === 1) {
     console.log("✅ Middleware: Using existing MongoDB connection");
+    // Start cron scheduler for existing connection
+    cronScheduler.start().catch((err) => {
+      console.error("Failed to start cron scheduler:", err);
+    });
+    healthChecksScheduler.start().catch((err) => {
+      console.error("Failed to start health checks scheduler:", err);
+    });
+    healthChecksBootstrap.bootstrap().catch((err) => {
+      console.error("Failed to bootstrap health checks:", err);
+    });
+    blogCronsBootstrap.bootstrap().catch((err) => {
+      console.error("Failed to bootstrap blog crons:", err);
+    });
+
+    require("./services/experimentsCronsBootstrap.service")
+      .bootstrap()
+      .catch((err) => {
+        console.error("Failed to bootstrap experiments crons:", err);
+      });
+    
+    // Initialize console manager AFTER database is already connected
+    if (process.env.NODE_ENV !== "test" && !process.env.JEST_WORKER_ID) {
+      isConsoleManagerEnabled().then(consoleManagerEnabled => {
+        if (consoleManagerEnabled) {
+          consoleManager.init();
+          // Set module prefix after initialization
+          consoleManager.setModulePrefix('middleware');
+          console.log("[Console Manager] Initialized");
+        } else {
+          console.log("[Console Manager] Disabled - console methods not overridden");
+        }
+      }).catch(error => {
+        console.error("[Console Manager] Error checking enabled status:", error);
+        console.log("[Console Manager] Fallback to enabled due to error");
+        consoleManager.init();
+        // Set module prefix after initialization
+        consoleManager.setModulePrefix('middleware');
+        console.log("[Console Manager] Initialized (fallback)");
+      });
+    }
   }
 
   // CORS configuration
@@ -138,6 +350,12 @@ function createMiddleware(options = {}) {
     webhookHandler,
   );
 
+  router.use(
+    "/proxy",
+    express.raw({ type: "*/*", limit: "10mb" }),
+    require("./routes/proxy.routes"),
+  );
+
   // Regular JSON parsing for other routes (skip if parent app already handles it)
   if (!options.skipBodyParser) {
     router.use(express.json());
@@ -146,6 +364,8 @@ function createMiddleware(options = {}) {
 
   router.use(requestIdMiddleware);
 
+  router.use("/api", rateLimiter.limit("globalApiLimiter"));
+
   // Serve public static files (e.g. /og/og-default.png)
   router.use(express.static(path.join(__dirname, "..", "public")));
 
@@ -164,6 +384,53 @@ function createMiddleware(options = {}) {
   // EJS locals: feature flags for server-rendered pages
   router.use(createFeatureFlagsEjsMiddleware());
 
+  // Public File Manager SPA (gated by global settings; restart required)
+  router.get("*", (req, res, next) => {
+    try {
+      if (!fileManagerPublicConfig.enabled) return next();
+
+      const basePath = fileManagerPublicConfig.basePath || "/files";
+      const reqPath = req.path;
+      const matches =
+        reqPath === basePath ||
+        reqPath === `${basePath}/` ||
+        reqPath.startsWith(`${basePath}/`);
+
+      if (!matches) return next();
+      if (req.method !== "GET") return next();
+
+      const templatePath = path.join(
+        __dirname,
+        "..",
+        "views",
+        "file-manager.ejs",
+      );
+      fs.readFile(templatePath, "utf8", (err, template) => {
+        if (err) {
+          console.error("Error reading template:", err);
+          return res.status(500).send("Error loading page");
+        }
+        try {
+          const html = ejs.render(
+            template,
+            {
+              baseUrl: req.baseUrl,
+              fileManagerBasePath: basePath,
+            },
+            { filename: templatePath },
+          );
+          res.send(html);
+        } catch (renderErr) {
+          console.error("Error rendering template:", renderErr);
+          res.status(500).send("Error rendering page");
+        }
+      });
+    } catch (error) {
+      console.error("Error serving File Manager SPA:", error);
+      next();
+    }
+  });
+
   // API Routes
   router.use("/api/auth", require("./routes/auth.routes"));
   router.use("/api/billing", require("./routes/billing.routes"));
@@ -177,22 +444,96 @@ function createMiddleware(options = {}) {
   );
   router.use("/api/admin/orgs", require("./routes/orgAdmin.routes"));
   router.use("/api/admin/users", require("./routes/userAdmin.routes"));
-  router.use("/api/admin/notifications", require("./routes/notificationAdmin.routes"));
+  router.use("/api/admin/rbac", require("./routes/adminRbac.routes"));
+  router.use(
+    "/api/admin/notifications",
+    require("./routes/notificationAdmin.routes"),
+  );
   router.use("/api/admin/stripe", require("./routes/stripeAdmin.routes"));
-  
+
   // Stats Routes
   const adminStatsController = require("./controllers/adminStats.controller");
-  router.get("/api/admin/stats/overview", basicAuth, adminStatsController.getOverviewStats);
-  
+  router.get(
+    "/api/admin/stats/overview",
+    basicAuth,
+    adminStatsController.getOverviewStats,
+  );
+
   router.get(`${adminPath}/stats/dashboard-home`, basicAuth, (req, res) => {
-    const templatePath = path.join(__dirname, "..", "views", "admin-dashboard-home.ejs");
+    const templatePath = path.join(
+      __dirname,
+      "..",
+      "views",
+      "admin-dashboard-home.ejs",
+    );
     fs.readFile(templatePath, "utf8", (err, template) => {
       if (err) {
         console.error("Error reading template:", err);
         return res.status(500).send("Error loading page");
       }
       try {
-        const html = ejs.render(template, { baseUrl: req.baseUrl, adminPath }, { filename: templatePath });
+        const html = ejs.render(
+          template,
+          { baseUrl: req.baseUrl, adminPath },
+          { filename: templatePath },
+        );
+        res.send(html);
+      } catch (renderErr) {
+        console.error("Error rendering template:", renderErr);
+        res.status(500).send("Error rendering page");
+      }
+    });
+  });
+
+  router.get(`${adminPath}/experiments`, basicAuth, (req, res) => {
+    const templatePath = path.join(
+      __dirname,
+      "..",
+      "views",
+      "admin-experiments.ejs",
+    );
+    fs.readFile(templatePath, "utf8", (err, template) => {
+      if (err) {
+        console.error("Error reading template:", err);
+        return res.status(500).send("Error loading page");
+      }
+      try {
+        const html = ejs.render(
+          template,
+          {
+            baseUrl: req.baseUrl,
+            adminPath,
+          },
+          {
+            filename: templatePath,
+          },
+        );
+        res.send(html);
+      } catch (renderErr) {
+        console.error("Error rendering template:", renderErr);
+        res.status(500).send("Error rendering page");
+      }
+    });
+  });
+
+  router.get(`${adminPath}/rbac`, basicAuth, (req, res) => {
+    const templatePath = path.join(__dirname, "..", "views", "admin-rbac.ejs");
+    fs.readFile(templatePath, "utf8", (err, template) => {
+      if (err) {
+        console.error("Error reading template:", err);
+        return res.status(500).send("Error loading page");
+      }
+      try {
+        const html = ejs.render(
+          template,
+          {
+            baseUrl: req.baseUrl,
+            adminPath,
+          },
+          {
+            filename: templatePath,
+          },
+        );
         res.send(html);
       } catch (renderErr) {
         console.error("Error rendering template:", renderErr);
@@ -265,6 +606,89 @@ function createMiddleware(options = {}) {
     });
   });
 
+  router.get(`${adminPath}/crons`, basicAuth, (req, res) => {
+    const templatePath = path.join(__dirname, "..", "views", "admin-crons.ejs");
+    fs.readFile(templatePath, "utf8", (err, template) => {
+      if (err) {
+        console.error("Error reading template:", err);
+        return res.status(500).send("Error loading page");
+      }
+      try {
+        const html = ejs.render(
+          template,
+          {
+            baseUrl: req.baseUrl,
+            adminPath,
+          },
+          {
+            filename: templatePath,
+          },
+        );
+        res.send(html);
+      } catch (renderErr) {
+        console.error("Error rendering template:", renderErr);
+        res.status(500).send("Error rendering page");
+      }
+    });
+  });
+
+  router.get(`${adminPath}/cache`, basicAuth, (req, res) => {
+    const templatePath = path.join(__dirname, "..", "views", "admin-cache.ejs");
+    fs.readFile(templatePath, "utf8", (err, template) => {
+      if (err) {
+        console.error("Error reading template:", err);
+        return res.status(500).send("Error loading page");
+      }
+      try {
+        const html = ejs.render(
+          template,
+          {
+            baseUrl: req.baseUrl,
+            adminPath,
+          },
+          {
+            filename: templatePath,
+          },
+        );
+        res.send(html);
+      } catch (renderErr) {
+        console.error("Error rendering template:", renderErr);
+        res.status(500).send("Error rendering page");
+      }
+    });
+  });
+
+  router.get(`${adminPath}/db-browser`, basicAuth, (req, res) => {
+    const templatePath = path.join(
+      __dirname,
+      "..",
+      "views",
+      "admin-db-browser.ejs",
+    );
+    fs.readFile(templatePath, "utf8", (err, template) => {
+      if (err) {
+        console.error("Error reading template:", err);
+        return res.status(500).send("Error loading page");
+      }
+      try {
+        const html = ejs.render(
+          template,
+          {
+            baseUrl: req.baseUrl,
+            adminPath,
+          },
+          {
+            filename: templatePath,
+          },
+        );
+        res.send(html);
+      } catch (renderErr) {
+        console.error("Error rendering template:", renderErr);
+        res.status(500).send("Error rendering page");
+      }
+    });
+  });
+
   router.use("/api/admin", require("./routes/admin.routes"));
   router.use("/api/admin/settings", require("./routes/globalSettings.routes"));
   router.use(
@@ -275,6 +699,11 @@ function createMiddleware(options = {}) {
     "/api/admin/json-configs",
     require("./routes/adminJsonConfigs.routes"),
   );
+  router.use(
+    "/api/admin/rate-limits",
+    require("./routes/adminRateLimits.routes"),
+  );
+  router.use("/api/admin/proxy", require("./routes/adminProxy.routes"));
   router.use(
     "/api/admin/seo-config",
     require("./routes/adminSeoConfig.routes"),
@@ -282,19 +711,52 @@ function createMiddleware(options = {}) {
   router.use("/api/admin/i18n", require("./routes/adminI18n.routes"));
   router.use("/api/admin/headless", require("./routes/adminHeadless.routes"));
   router.use("/api/admin/scripts", require("./routes/adminScripts.routes"));
+  router.use("/api/admin/crons", require("./routes/adminCrons.routes"));
+  router.use(
+    "/api/admin/health-checks",
+    require("./routes/adminHealthChecks.routes"),
+  );
+  router.use("/api/admin/cache", require("./routes/adminCache.routes"));
+  router.use(
+    "/api/admin/console-manager",
+    require("./routes/adminConsoleManager.routes"),
+  );
+  router.use(
+    "/api/admin/db-browser",
+    require("./routes/adminDbBrowser.routes"),
+  );
   router.use("/api/admin/terminals", require("./routes/adminTerminals.routes"));
+  router.use("/api/admin/experiments", require("./routes/adminExperiments.routes"));
   router.use("/api/admin/assets", require("./routes/adminAssets.routes"));
   router.use(
     "/api/admin/upload-namespaces",
     require("./routes/adminUploadNamespaces.routes"),
   );
-  router.use("/api/admin/ui-components", require("./routes/adminUiComponents.routes"));
+  router.use(
+    "/api/admin/ui-components",
+    require("./routes/adminUiComponents.routes"),
+  );
   router.use("/api/admin/migration", require("./routes/adminMigration.routes"));
-  router.use("/api/admin/errors", basicAuth, require("./routes/adminErrors.routes"));
-  router.use("/api/admin/audit", basicAuth, require("./routes/adminAudit.routes"));
+  router.use(
+    "/api/admin/errors",
+    basicAuth,
+    require("./routes/adminErrors.routes"),
+  );
+  router.use(
+    "/api/admin/audit",
+    basicAuth,
+    require("./routes/adminAudit.routes"),
+  );
   router.use("/api/admin/llm", require("./routes/adminLlm.routes"));
-  router.use("/api/admin/ejs-virtual", require("./routes/adminEjsVirtual.routes"));
-  router.use("/api/workflows", basicAuth, require("./routes/workflows.routes"));
+  router.use(
+    "/api/admin/ejs-virtual",
+    require("./routes/adminEjsVirtual.routes"),
+  );
+  router.use("/api/admin/pages", require("./routes/adminPages.routes"));
+  router.use("/api/admin", require("./routes/adminBlog.routes"));
+  router.use("/api/admin", require("./routes/adminBlogAi.routes"));
+  router.use("/api/admin", require("./routes/adminBlogAutomation.routes"));
+  router.use("/api/admin/workflows", basicAuth, require("./routes/workflows.routes"));
   router.use("/w", require("./routes/workflowWebhook.routes"));
   router.use("/api/webhooks", require("./routes/webhook.routes"));
   router.use("/api/settings", require("./routes/globalSettings.routes"));
@@ -310,21 +772,47 @@ function createMiddleware(options = {}) {
   router.use("/api/log", require("./routes/log.routes"));
   router.use("/api/error-tracking", require("./routes/errorTracking.routes"));
   router.use("/api/ui-components", require("./routes/uiComponentsPublic.routes"));
-  router.use("/api/llm/ui", require("./routes/llmUi.routes"));
+  router.use("/api/rbac", require("./routes/rbac.routes"));
+  router.use("/api/file-manager", require("./routes/fileManager.routes"));
+  router.use("/api/experiments", require("./routes/experiments.routes"));
+
+  // Public blog APIs (headless)
+  router.use("/api", require("./routes/blogPublic.routes"));
+
+  // Internal blog endpoints (used by HTTP CronJobs)
+  router.use("/api/internal", require("./routes/blogInternal.routes"));
+
+  // Internal experiments endpoints (used by HTTP CronJobs)
+  router.use("/api/internal", require("./routes/internalExperiments.routes"));
+
+  // Public health checks status (gated by global setting)
+  router.use(
+    "/api/health-checks",
+    require("./routes/healthChecksPublic.routes"),
+  );
 
   // Public assets proxy
   router.use("/public/assets", require("./routes/publicAssets.routes"));
 
   // Admin dashboard (polished view)
   router.get(adminPath, basicAuth, (req, res) => {
-    const templatePath = path.join(__dirname, "..", "views", "admin-dashboard.ejs");
+    const templatePath = path.join(
+      __dirname,
+      "..",
+      "views",
+      "admin-dashboard.ejs",
+    );
     fs.readFile(templatePath, "utf8", (err, template) => {
       if (err) {
         console.error("Error reading template:", err);
         return res.status(500).send("Error loading page");
       }
       try {
-        const html = ejs.render(template, { baseUrl: req.baseUrl, adminPath }, { filename: templatePath });
+        const html = ejs.render(
+          template,
+          { baseUrl: req.baseUrl, adminPath },
+          { filename: templatePath },
+        );
         res.send(html);
       } catch (renderErr) {
         console.error("Error rendering template:", renderErr);
@@ -362,7 +850,12 @@ function createMiddleware(options = {}) {
   });
 
   router.get(`${adminPath}/migration`, basicAuth, (req, res) => {
-    const templatePath = path.join(__dirname, "..", "views", "admin-migration.ejs");
+    const templatePath = path.join(
+      __dirname,
+      "..",
+      "views",
+      "admin-migration.ejs",
+    );
     fs.readFile(templatePath, "utf8", (err, template) => {
       if (err) {
         console.error("Error reading template:", err);
@@ -390,12 +883,59 @@ function createMiddleware(options = {}) {
 
   // Admin LLM/AI page (protected by basic auth)
   router.get(`${adminPath}/admin-llm`, basicAuth, (req, res) => {
+    const templatePath = path.join(__dirname, "..", "views", "admin-llm.ejs");
+    fs.readFile(templatePath, "utf8", (err, template) => {
+      if (err) {
+        console.error("Error reading template:", err);
+        return res.status(500).send("Error loading page");
+      }
+      try {
+        const html = ejs.render(
+          template,
+          {
+            baseUrl: req.baseUrl,
+            adminPath,
+          },
+          {
+            filename: templatePath,
+          },
+        );
+        res.send(html);
+      } catch (renderErr) {
+        console.error("Error rendering template:", renderErr);
+        res.status(500).send("Error rendering page");
+      }
+    });
+  });
+
+  router.get(`${adminPath}/workflows/:id`, basicAuth, (req, res) => {
     const templatePath = path.join(
       __dirname,
       "..",
       "views",
-      "admin-llm.ejs",
+      "admin-workflows.ejs",
     );
+    fs.readFile(templatePath, "utf8", (err, template) => {
+      if (err) {
+        console.error("Error reading template:", err);
+        return res.status(500).send("Error loading page");
+      }
+      try {
+        const html = ejs.render(
+          template,
+          { baseUrl: req.baseUrl, adminPath },
+          { filename: templatePath },
+        );
+        res.send(html);
+      } catch (renderErr) {
+        console.error("Error rendering template:", renderErr);
+        res.status(500).send("Error rendering page");
+      }
+    });
+  });
+
+  router.get(`${adminPath}/pages`, basicAuth, (req, res) => {
+    const templatePath = path.join(__dirname, "..", "views", "admin-pages.ejs");
     fs.readFile(templatePath, "utf8", (err, template) => {
       if (err) {
         console.error("Error reading template:", err);
@@ -420,15 +960,133 @@ function createMiddleware(options = {}) {
     });
   });
 
-  router.get(`${adminPath}/workflows/:id`, basicAuth, (req, res) => {
-    const templatePath = path.join(__dirname, "..", "views", "admin-workflows.ejs");
+  router.get(`${adminPath}/blog`, basicAuth, (req, res) => {
+    const templatePath = path.join(__dirname, "..", "views", "admin-blog.ejs");
     fs.readFile(templatePath, "utf8", (err, template) => {
       if (err) {
         console.error("Error reading template:", err);
         return res.status(500).send("Error loading page");
       }
       try {
-        const html = ejs.render(template, { baseUrl: req.baseUrl, adminPath }, { filename: templatePath });
+        const html = ejs.render(
+          template,
+          { baseUrl: req.baseUrl, adminPath },
+          { filename: templatePath },
+        );
+        res.send(html);
+      } catch (renderErr) {
+        console.error("Error rendering template:", renderErr);
+        res.status(500).send("Error rendering page");
+      }
+    });
+  });
+
+  router.get(`${adminPath}/blog-automation`, basicAuth, (req, res) => {
+    const templatePath = path.join(
+      __dirname,
+      "..",
+      "views",
+      "admin-blog-automation.ejs",
+    );
+    fs.readFile(templatePath, "utf8", (err, template) => {
+      if (err) {
+        console.error("Error reading template:", err);
+        return res.status(500).send("Error loading page");
+      }
+      try {
+        const html = ejs.render(
+          template,
+          { baseUrl: req.baseUrl, adminPath },
+          { filename: templatePath },
+        );
+        res.send(html);
+      } catch (renderErr) {
+        console.error("Error rendering template:", renderErr);
+        res.status(500).send("Error rendering page");
+      }
+    });
+  });
+
+  router.get(`${adminPath}/blog/new`, basicAuth, (req, res) => {
+    const templatePath = path.join(
+      __dirname,
+      "..",
+      "views",
+      "admin-blog-edit.ejs",
+    );
+    fs.readFile(templatePath, "utf8", (err, template) => {
+      if (err) {
+        console.error("Error reading template:", err);
+        return res.status(500).send("Error loading page");
+      }
+      try {
+        const html = ejs.render(
+          template,
+          { baseUrl: req.baseUrl, adminPath, postId: "", mode: "new" },
+          { filename: templatePath },
+        );
+        res.send(html);
+      } catch (renderErr) {
+        console.error("Error rendering template:", renderErr);
+        res.status(500).send("Error rendering page");
+      }
+    });
+  });
+
+  router.get(`${adminPath}/blog/edit/:id`, basicAuth, (req, res) => {
+    const templatePath = path.join(
+      __dirname,
+      "..",
+      "views",
+      "admin-blog-edit.ejs",
+    );
+    fs.readFile(templatePath, "utf8", (err, template) => {
+      if (err) {
+        console.error("Error reading template:", err);
+        return res.status(500).send("Error loading page");
+      }
+      try {
+        const html = ejs.render(
+          template,
+          {
+            baseUrl: req.baseUrl,
+            adminPath,
+            postId: String(req.params.id || ""),
+            mode: "edit",
+          },
+          { filename: templatePath },
+        );
+        res.send(html);
+      } catch (renderErr) {
+        console.error("Error rendering template:", renderErr);
+        res.status(500).send("Error rendering page");
+      }
+    });
+  });
+
+  router.get(`${adminPath}/file-manager`, basicAuth, (req, res) => {
+    const templatePath = path.join(
+      __dirname,
+      "..",
+      "views",
+      "admin-file-manager.ejs",
+    );
+    fs.readFile(templatePath, "utf8", (err, template) => {
+      if (err) {
+        console.error("Error reading template:", err);
+        return res.status(500).send("Error loading page");
+      }
+      try {
+        const html = ejs.render(
+          template,
+          {
+            baseUrl: req.baseUrl,
+            adminPath,
+          },
+          {
+            filename: templatePath,
+          },
+        );
         res.send(html);
       } catch (renderErr) {
         console.error("Error rendering template:", renderErr);
@@ -438,7 +1096,12 @@ function createMiddleware(options = {}) {
   });
 
   router.get(`${adminPath}/ejs-virtual`, basicAuth, (req, res) => {
-    const templatePath = path.join(__dirname, "..", "views", "admin-ejs-virtual.ejs");
+    const templatePath = path.join(
+      __dirname,
+      "..",
+      "views",
+      "admin-ejs-virtual.ejs",
+    );
     fs.readFile(templatePath, "utf8", (err, template) => {
       if (err) {
         console.error("Error reading template:", err);
@@ -464,7 +1127,12 @@ function createMiddleware(options = {}) {
   });
 
   router.get(`${adminPath}/seo-config`, basicAuth, (req, res) => {
-    const templatePath = path.join(__dirname, "..", "views", "admin-seo-config.ejs");
+    const templatePath = path.join(
+      __dirname,
+      "..",
+      "views",
+      "admin-seo-config.ejs",
+    );
     fs.readFile(templatePath, "utf8", (err, template) => {
       if (err) {
         console.error("Error reading template:", err);
@@ -498,7 +1166,11 @@ function createMiddleware(options = {}) {
         return res.status(500).send("Error loading page");
       }
       try {
-        const html = ejs.render(template, { baseUrl: req.baseUrl, adminPath }, { filename: templatePath });
+        const html = ejs.render(
+          template,
+          { baseUrl: req.baseUrl, adminPath },
+          { filename: templatePath },
+        );
         res.send(html);
       } catch (renderErr) {
         console.error("Error rendering template:", renderErr);
@@ -520,7 +1192,11 @@ function createMiddleware(options = {}) {
         return res.status(500).send("Error loading page");
       }
       try {
-        const html = ejs.render(template, { baseUrl: req.baseUrl, adminPath }, { filename: templatePath });
+        const html = ejs.render(
+          template,
+          { baseUrl: req.baseUrl, adminPath },
+          { filename: templatePath },
+        );
         res.send(html);
       } catch (renderErr) {
         console.error("Error rendering template:", renderErr);
@@ -784,12 +1460,7 @@ function createMiddleware(options = {}) {
 
   // Admin users page (protected by basic auth)
   router.get(`${adminPath}/users`, basicAuth, (req, res) => {
-    const templatePath = path.join(
-      __dirname,
-      "..",
-      "views",
-      "admin-users.ejs",
-    );
+    const templatePath = path.join(__dirname, "..", "views", "admin-users.ejs");
     fs.readFile(templatePath, "utf8", (err, template) => {
       if (err) {
         console.error("Error reading template:", err);
@@ -908,6 +1579,31 @@ function createMiddleware(options = {}) {
     });
   });
 
+  router.get(`${adminPath}/rate-limiter`, basicAuth, (req, res) => {
+    const templatePath = path.join(
+      __dirname,
+      "..",
+      "views",
+      "admin-rate-limiter.ejs",
+    );
+    fs.readFile(templatePath, "utf8", (err, template) => {
+      if (err) {
+        console.error("Error reading template:", err);
+        return res.status(500).send("Error loading page");
+      }
+      try {
+        const html = ejs.render(template, {
+          baseUrl: req.baseUrl,
+          adminPath,
+        });
+        res.send(html);
+      } catch (renderErr) {
+        console.error("Error rendering template:", renderErr);
+        res.status(500).send("Error rendering page");
+      }
+    });
+  });
+
   // Admin global settings page (protected by basic auth) - render manually
   router.get(`${adminPath}/global-settings`, basicAuth, (req, res) => {
     const templatePath = path.join(
@@ -932,14 +1628,23 @@ function createMiddleware(options = {}) {
   });
 
   router.get(`${adminPath}/errors`, basicAuth, (req, res) => {
-    const templatePath = path.join(__dirname, "..", "views", "admin-errors.ejs");
+    const templatePath = path.join(
+      __dirname,
+      "..",
+      "views",
+      "admin-errors.ejs",
+    );
     fs.readFile(templatePath, "utf8", (err, template) => {
       if (err) {
         console.error("Error reading template:", err);
         return res.status(500).send("Error loading page");
       }
       try {
-        const html = ejs.render(template, { baseUrl: req.baseUrl, adminPath }, { filename: templatePath });
+        const html = ejs.render(
+          template,
+          { baseUrl: req.baseUrl, adminPath },
+          { filename: templatePath },
+        );
         res.send(html);
       } catch (renderErr) {
         console.error("Error rendering template:", renderErr);
@@ -956,7 +1661,11 @@ function createMiddleware(options = {}) {
         return res.status(500).send("Error loading page");
       }
       try {
-        const html = ejs.render(template, { baseUrl: req.baseUrl, adminPath }, { filename: templatePath });
+        const html = ejs.render(
+          template,
+          { baseUrl: req.baseUrl, adminPath },
+          { filename: templatePath },
+        );
         res.send(html);
       } catch (renderErr) {
         console.error("Error rendering template:", renderErr);
@@ -966,14 +1675,44 @@ function createMiddleware(options = {}) {
   });
 
   router.get(`${adminPath}/coolify-deploy`, basicAuth, (req, res) => {
-    const templatePath = path.join(__dirname, "..", "views", "admin-coolify-deploy.ejs");
+    const templatePath = path.join(
+      __dirname,
+      "..",
+      "views",
+      "admin-coolify-deploy.ejs",
+    );
     fs.readFile(templatePath, "utf8", (err, template) => {
       if (err) {
         console.error("Error reading template:", err);
         return res.status(500).send("Error loading page");
       }
       try {
-        const html = ejs.render(template, { baseUrl: req.baseUrl, adminPath }, { filename: templatePath });
+        const html = ejs.render(
+          template,
+          { baseUrl: req.baseUrl, adminPath },
+          { filename: templatePath },
+        );
+        res.send(html);
+      } catch (renderErr) {
+        console.error("Error rendering template:", renderErr);
+        res.status(500).send("Error rendering page");
+      }
+    });
+  });
+
+  router.get(`${adminPath}/proxy`, basicAuth, (req, res) => {
+    const templatePath = path.join(__dirname, "..", "views", "admin-proxy.ejs");
+    fs.readFile(templatePath, "utf8", (err, template) => {
+      if (err) {
+        console.error("Error reading template:", err);
+        return res.status(500).send("Error loading page");
+      }
+      try {
+        const html = ejs.render(
+          template,
+          { baseUrl: req.baseUrl, adminPath },
+          { filename: templatePath },
+        );
         res.send(html);
       } catch (renderErr) {
         console.error("Error rendering template:", renderErr);
@@ -983,14 +1722,23 @@ function createMiddleware(options = {}) {
   });
 
   router.get(`${adminPath}/webhooks`, basicAuth, (req, res) => {
-    const templatePath = path.join(__dirname, "..", "views", "admin-webhooks.ejs");
+    const templatePath = path.join(
+      __dirname,
+      "..",
+      "views",
+      "admin-webhooks.ejs",
+    );
     fs.readFile(templatePath, "utf8", (err, template) => {
       if (err) {
         console.error("Error reading template:", err);
         return res.status(500).send("Error loading page");
       }
       try {
-        const html = ejs.render(template, { baseUrl: req.baseUrl, adminPath }, { filename: templatePath });
+        const html = ejs.render(
+          template,
+          { baseUrl: req.baseUrl, adminPath },
+          { filename: templatePath },
+        );
         res.send(html);
       } catch (renderErr) {
         console.error("Error rendering template:", renderErr);
@@ -999,7 +1747,7 @@ function createMiddleware(options = {}) {
     });
   });
 
-  router.get("/health", (req, res) => {
+  router.get("/health", rateLimiter.limit("healthRateLimiter"), (req, res) => {
     res.json({
       status: "ok",
       mode: "middleware",
@@ -1011,6 +1759,20 @@ function createMiddleware(options = {}) {
   router.use("/api/ejs-virtual", require("./routes/adminEjsVirtual.routes"));
   router.use("/api/webhooks", require("./routes/webhook.routes"));
 
+  // Store pagesPrefix and adminPath on app for pages router
+  router.use((req, res, next) => {
+    if (!req.app.get("pagesPrefix")) {
+      req.app.set("pagesPrefix", pagesPrefix);
+    }
+    if (!req.app.get("adminPath")) {
+      req.app.set("adminPath", adminPath);
+    }
+    next();
+  });
+
+  // Public pages router (catch-all, must be last before error handler)
+  router.use(require("./routes/pages.routes"));
+
   // Error handling middleware
   router.use(expressErrorMiddleware);