Merge branch 'dev-ms' of github.com:fosrl/pangolin into dev-ms

Down for maintenance screen

messages/en-US.json

@@ -2121,5 +2121,30 @@
     "niceIdUpdateErrorDescription": "An error occurred while updating the Nice ID.",
     "niceIdCannotBeEmpty": "Nice ID cannot be empty",
     "enterIdentifier": "Enter identifier",
-    "identifier": "Identifier"
+    "identifier": "Identifier",
+    "maintenanceMode": "Maintenance Mode",
+    "maintenanceModeDescription": "Display a maintenance page to visitors",
+    "maintenanceModeType": "Maintenance Mode Type",
+    "showMaintenancePage": "Show a maintenance page to visitors",
+    "enableMaintenanceMode": "Enable Maintenance Mode",
+    "automatic": "Automatic",
+    "automaticModeDescription": " Show maintenance page only when all backend targets are down or unhealthy. Your resource continues working normally as long as at least one target is healthy.",
+    "forced": "Forced",
+    "forcedModeDescription": "Always show the maintenance page regardless of backend health. Use this for planned maintenance when you want to prevent all access.",
+    "warning:" : "Warning:",
+    "forcedeModeWarning": "All traffic will be directed to the maintenance page. Your backend resources will not receive any requests.",
+    "pageTitle": "Page Title",
+    "pageTitleDescription": "The main heading displayed on the maintenance page",
+    "maintenancePageMessage": "Maintenance Message",
+    "maintenancePageMessagePlaceholder": "We'll be back soon! Our site is currently undergoing scheduled maintenance.",
+    "maintenancePageMessageDescription": "Detailed message explaining the maintenance",
+    "maintenancePageTimeTitle": "Estimated Completion Time (Optional)",
+    "maintenanceTime": "e.g., 2 hours, Nov 1 at 5:00 PM",
+    "maintenanceEstimatedTimeDescription": "When you expect maintenance to be completed",
+    "editDomain": "Edit Domain",
+    "editDomainDescription": "Select a domain for your resource",
+    "maintenanceModeDisabledTooltip": "This feature requires a valid license to enable.",
+    "maintenanceScreenTitle": "Service Temporarily Unavailable",
+    "maintenanceScreenMessage": "We are currently experiencing technical difficulties. Please check back soon.",
+    "maintenanceScreenEstimatedCompletion": "Estimated Completion:"
 }

server/db/pg/schema/schema.ts

@@ -130,7 +130,15 @@ export const resources = pgTable("resources", {
     }),
     headers: text("headers"), // comma-separated list of headers to add to the request
     proxyProtocol: boolean("proxyProtocol").notNull().default(false),
-    proxyProtocolVersion: integer("proxyProtocolVersion").default(1)
+    proxyProtocolVersion: integer("proxyProtocolVersion").default(1),
+
+    maintenanceModeEnabled: boolean("maintenanceModeEnabled").notNull().default(false),
+    maintenanceModeType: text("maintenanceModeType", {
+        enum: ["forced", "automatic"]
+    }).default("forced"), // "forced" = always show, "automatic" = only when down
+    maintenanceTitle: text("maintenanceTitle"),
+    maintenanceMessage: text("maintenanceMessage"),
+    maintenanceEstimatedTime: text("maintenanceEstimatedTime"),
 });
 
 export const targets = pgTable("targets", {

server/db/sqlite/schema/schema.ts

@@ -25,7 +25,7 @@ export const dnsRecords = sqliteTable("dnsRecords", {
 
     recordType: text("recordType").notNull(), // "NS" | "CNAME" | "A" | "TXT"
     baseDomain: text("baseDomain"),
-    value: text("value").notNull(), 
+    value: text("value").notNull(),
     verified: integer("verified", { mode: "boolean" }).notNull().default(false),
 });
 
@@ -143,7 +143,17 @@ export const resources = sqliteTable("resources", {
     }),
     headers: text("headers"), // comma-separated list of headers to add to the request
     proxyProtocol: integer("proxyProtocol", { mode: "boolean" }).notNull().default(false),
-    proxyProtocolVersion: integer("proxyProtocolVersion").default(1)
+    proxyProtocolVersion: integer("proxyProtocolVersion").default(1),
+
+    maintenanceModeEnabled: integer("maintenanceModeEnabled", { mode: "boolean" })
+        .notNull()
+        .default(false),
+    maintenanceModeType: text("maintenanceModeType", {
+        enum: ["forced", "automatic"]
+    }).default("forced"), // "forced" = always show, "automatic" = only when down
+    maintenanceTitle: text("maintenanceTitle"),
+    maintenanceMessage: text("maintenanceMessage"),
+    maintenanceEstimatedTime: text("maintenanceEstimatedTime"),
 
 });
 

server/lib/isLicencedOrSubscribed.ts

@@ -0,0 +1,23 @@
+import { build } from "@server/build";
+import license from "@server/license/license";
+import { getOrgTierData } from "#dynamic/lib/billing";
+import { TierId } from "./billing/tiers";
+
+export async function isLicensedOrSubscribed(orgId: string): Promise<boolean> {
+    if (build === "enterprise") {
+        const isUnlocked = await license.isUnlocked();
+        if (!isUnlocked) {
+            return false;
+        }
+    }
+
+    if (build === "saas") {
+        const { tier } = await getOrgTierData(orgId);
+        const subscribed = tier === TierId.STANDARD;
+        if (!subscribed) {
+            return false;
+        }
+    }
+
+    return true;
+}

server/lib/readConfigFile.ts

@@ -205,7 +205,9 @@ export const configSchema = z
                     .default(["newt", "wireguard", "local"]),
                 allow_raw_resources: z.boolean().optional().default(true),
                 file_mode: z.boolean().optional().default(false),
-                pp_transport_prefix: z.string().optional().default("pp-transport-v")
+                pp_transport_prefix: z.string().optional().default("pp-transport-v"),
+                maintenance_host: z.string().optional(),
+                maintenance_port: z.number().optional().default(3002)
             })
             .optional()
             .default({}),

server/lib/traefik/getTraefikConfig.ts

@@ -59,6 +59,7 @@ export async function getTraefikConfig(
             headers: resources.headers,
             proxyProtocol: resources.proxyProtocol,
             proxyProtocolVersion: resources.proxyProtocolVersion,
+
             // Target fields
             targetId: targets.targetId,
             targetEnabled: targets.enabled,
@@ -184,7 +185,6 @@ export async function getTraefikConfig(
             });
         }
 
-        // Add target with its associated site data
         resourcesMap.get(key).targets.push({
             resourceId: row.resourceId,
             targetId: row.targetId,
@@ -289,12 +289,12 @@ export async function getTraefikConfig(
                 certResolver: resolverName,
                 ...(preferWildcard
                     ? {
-                          domains: [
-                              {
-                                  main: wildCard
-                              }
-                          ]
-                      }
+                        domains: [
+                            {
+                                main: wildCard
+                            }
+                        ]
+                    }
                     : {})
             };
 
@@ -535,14 +535,14 @@ export async function getTraefikConfig(
                     })(),
                     ...(resource.stickySession
                         ? {
-                              sticky: {
-                                  cookie: {
-                                      name: "p_sticky", // TODO: make this configurable via config.yml like other cookies
-                                      secure: resource.ssl,
-                                      httpOnly: true
-                                  }
-                              }
-                          }
+                            sticky: {
+                                cookie: {
+                                    name: "p_sticky", // TODO: make this configurable via config.yml like other cookies
+                                    secure: resource.ssl,
+                                    httpOnly: true
+                                }
+                            }
+                        }
                         : {})
                 }
             };
@@ -645,18 +645,18 @@ export async function getTraefikConfig(
                     })(),
                     ...(resource.proxyProtocol && protocol == "tcp"
                         ? {
-                              serversTransport: `${ppPrefix}${resource.proxyProtocolVersion || 1}@file` // TODO: does @file here cause issues?
-                          }
+                            serversTransport: `${ppPrefix}${resource.proxyProtocolVersion || 1}@file` // TODO: does @file here cause issues?
+                        }
                         : {}),
                     ...(resource.stickySession
                         ? {
-                              sticky: {
-                                  ipStrategy: {
-                                      depth: 0,
-                                      sourcePort: true
-                                  }
-                              }
-                          }
+                            sticky: {
+                                ipStrategy: {
+                                    depth: 0,
+                                    sourcePort: true
+                                }
+                            }
+                        }
                         : {})
                 }
             };

server/private/lib/traefik/getTraefikConfig.ts

@@ -87,6 +87,13 @@ export async function getTraefikConfig(
             headers: resources.headers,
             proxyProtocol: resources.proxyProtocol,
             proxyProtocolVersion: resources.proxyProtocolVersion,
+
+            maintenanceModeEnabled: resources.maintenanceModeEnabled,
+            maintenanceModeType: resources.maintenanceModeType,
+            maintenanceTitle: resources.maintenanceTitle,
+            maintenanceMessage: resources.maintenanceMessage,
+            maintenanceEstimatedTime: resources.maintenanceEstimatedTime,
+
             // Target fields
             targetId: targets.targetId,
             targetEnabled: targets.enabled,
@@ -220,7 +227,13 @@ export async function getTraefikConfig(
                 rewritePathType: row.rewritePathType,
                 priority: priority, // may be null, we fallback later
                 domainCertResolver: row.domainCertResolver,
-                preferWildcardCert: row.preferWildcardCert
+                preferWildcardCert: row.preferWildcardCert,
+
+                maintenanceModeEnabled: row.maintenanceModeEnabled,
+                maintenanceModeType: row.maintenanceModeType,
+                maintenanceTitle: row.maintenanceTitle,
+                maintenanceMessage: row.maintenanceMessage,
+                maintenanceEstimatedTime: row.maintenanceEstimatedTime,
             });
         }
 
@@ -308,6 +321,115 @@ export async function getTraefikConfig(
                 config_output.http.services = {};
             }
 
+            const availableServers = (targets as TargetWithSite[]).filter(
+                (target: TargetWithSite) => {
+                    if (!target.enabled) return false;
+
+                    const anySitesOnline = (targets as TargetWithSite[]).some(
+                        (t: TargetWithSite) => t.site.online
+                    );
+                    if (anySitesOnline && !target.site.online) return false;
+
+                    if (target.site.type === "local" || target.site.type === "wireguard") {
+                        return target.ip && target.port && target.method;
+                    } else if (target.site.type === "newt") {
+                        return target.internalPort && target.method && target.site.subnet;
+                    }
+                    return false;
+                }
+            );
+
+            const hasHealthyServers = availableServers.length > 0;
+
+            let showMaintenancePage = false;
+            if (resource.maintenanceModeEnabled) {
+                if (resource.maintenanceModeType === "forced") {
+                    showMaintenancePage = true;
+                    logger.debug(
+                        `Resource ${resource.name} (${fullDomain}) is in FORCED maintenance mode`
+                    );
+                } else if (resource.maintenanceModeType === "automatic") {
+                    showMaintenancePage = !hasHealthyServers;
+                    if (showMaintenancePage) {
+                        logger.warn(
+                            `Resource ${resource.name} (${fullDomain}) has no healthy servers - showing maintenance page (AUTOMATIC mode)`
+                        );
+                    }
+                }
+            }
+
+            if (showMaintenancePage) {
+                const maintenanceServiceName = `${key}-maintenance-service`;
+                const maintenanceRouterName = `${key}-maintenance-router`;
+                const rewriteMiddlewareName = `${key}-maintenance-rewrite`;
+
+                const entrypointHttp = config.getRawConfig().traefik.http_entrypoint;
+                const entrypointHttps = config.getRawConfig().traefik.https_entrypoint;
+
+                const fullDomain = resource.fullDomain;
+                const domainParts = fullDomain.split(".");
+                const wildCard = resource.subdomain
+                    ? `*.${domainParts.slice(1).join(".")}`
+                    : fullDomain;
+
+                const tls = {
+                    certResolver: resource.domainCertResolver?.trim() ||
+                        config.getRawConfig().traefik.cert_resolver,
+                    ...(config.getRawConfig().traefik.prefer_wildcard_cert
+                        ? { domains: [{ main: wildCard }] }
+                        : {})
+                };
+
+                const maintenancePort = config.getRawConfig().traefik?.maintenance_port;
+                const maintenanceHost = config.getRawConfig().traefik?.maintenance_host || 'dev_pangolin';
+
+                config_output.http.services[maintenanceServiceName] = {
+                    loadBalancer: {
+                        servers: [{ url: `http://${maintenanceHost}:${maintenancePort}` }],
+                        passHostHeader: true
+                    }
+                };
+
+                // middleware to rewrite path to /maintenance-screen
+                if (!config_output.http.middlewares) {
+                    config_output.http.middlewares = {};
+                }
+
+                config_output.http.middlewares[rewriteMiddlewareName] = {
+                    replacePathRegex: {
+                        regex: "^/(.*)",
+                        replacement: "/maintenance-screen"
+                    }
+                };
+
+
+                const rule = `Host(\`${fullDomain}\`)`;
+
+                console.log('DEBUG: Generated rule:', rule); // Should show: Host(`pangolin.pallavi.fosrl.io`)
+
+                config_output.http.routers[maintenanceRouterName] = {
+                    entryPoints: [resource.ssl ? entrypointHttps : entrypointHttp],
+                    service: maintenanceServiceName,
+                    middlewares: [rewriteMiddlewareName],
+                    rule: rule,
+                    priority: 2000,
+                    ...(resource.ssl ? { tls } : {})
+                };
+
+                if (resource.ssl) {
+                    config_output.http.routers[`${maintenanceRouterName}-redirect`] = {
+                        entryPoints: [entrypointHttp],
+                        middlewares: [redirectHttpsMiddlewareName, rewriteMiddlewareName],
+                        service: maintenanceServiceName,
+                        rule: rule,
+                        priority: 2000
+                    };
+                }
+
+                logger.info(`Maintenance mode active for ${fullDomain}`);
+
+                continue;
+            }
             const domainParts = fullDomain.split(".");
             let wildCard;
             if (domainParts.length <= 2) {
@@ -366,12 +488,12 @@ export async function getTraefikConfig(
                     certResolver: resolverName,
                     ...(preferWildcard
                         ? {
-                              domains: [
-                                  {
-                                      main: wildCard
-                                  }
-                              ]
-                          }
+                            domains: [
+                                {
+                                    main: wildCard
+                                }
+                            ]
+                        }
                         : {})
                 };
             } else {
@@ -624,14 +746,14 @@ export async function getTraefikConfig(
                     })(),
                     ...(resource.stickySession
                         ? {
-                              sticky: {
-                                  cookie: {
-                                      name: "p_sticky", // TODO: make this configurable via config.yml like other cookies
-                                      secure: resource.ssl,
-                                      httpOnly: true
-                                  }
-                              }
-                          }
+                            sticky: {
+                                cookie: {
+                                    name: "p_sticky", // TODO: make this configurable via config.yml like other cookies
+                                    secure: resource.ssl,
+                                    httpOnly: true
+                                }
+                            }
+                        }
                         : {})
                 }
             };
@@ -734,18 +856,18 @@ export async function getTraefikConfig(
                     })(),
                     ...(resource.proxyProtocol && protocol == "tcp" // proxy protocol only works for tcp
                         ? {
-                              serversTransport: `${ppPrefix}${resource.proxyProtocolVersion || 1}@file` // TODO: does @file here cause issues?
-                          }
+                            serversTransport: `${ppPrefix}${resource.proxyProtocolVersion || 1}@file` // TODO: does @file here cause issues?
+                        }
                         : {}),
                     ...(resource.stickySession
                         ? {
-                              sticky: {
-                                  ipStrategy: {
-                                      depth: 0,
-                                      sourcePort: true
-                                  }
-                              }
-                          }
+                            sticky: {
+                                ipStrategy: {
+                                    depth: 0,
+                                    sourcePort: true
+                                }
+                            }
+                        }
                         : {})
                 }
             };
@@ -793,10 +915,9 @@ export async function getTraefikConfig(
                     loadBalancer: {
                         servers: [
                             {
-                                url: `http://${
-                                    config.getRawConfig().server
-                                        .internal_hostname
-                                }:${config.getRawConfig().server.next_port}`
+                                url: `http://${config.getRawConfig().server
+                                    .internal_hostname
+                                    }:${config.getRawConfig().server.next_port}`
                             }
                         ]
                     }

server/private/routers/internal.ts

@@ -16,6 +16,7 @@ import * as auth from "#private/routers/auth";
 import * as orgIdp from "#private/routers/orgIdp";
 import * as billing from "#private/routers/billing";
 import * as license from "#private/routers/license";
+import * as resource from "#private/routers/resource";
 
 import { verifySessionUserMiddleware } from "@server/middlewares";
 
@@ -36,3 +37,5 @@ internalRouter.post(
 );
 
 internalRouter.get(`/license/status`, license.getLicenseStatus);
+
+internalRouter.get("/maintenance/info", resource.getMaintenanceInfo);

server/private/routers/resource/getMaintenanceInfo.ts

@@ -0,0 +1,113 @@
+/*
+ * This file is part of a proprietary work.
+ *
+ * Copyright (c) 2025 Fossorial, Inc.
+ * All rights reserved.
+ *
+ * This file is licensed under the Fossorial Commercial License.
+ * You may not use this file except in compliance with the License.
+ * Unauthorized use, copying, modification, or distribution is strictly prohibited.
+ *
+ * This file is not licensed under the AGPLv3.
+ */
+
+import { Request, Response, NextFunction } from "express";
+import { z } from "zod";
+import { db } from "@server/db";
+import { resources } from "@server/db";
+import { eq } from "drizzle-orm";
+import response from "@server/lib/response";
+import HttpCode from "@server/types/HttpCode";
+import createHttpError from "http-errors";
+import { fromError } from "zod-validation-error";
+import logger from "@server/logger";
+import { OpenAPITags, registry } from "@server/openApi";
+import { GetMaintenanceInfoResponse } from "@server/routers/resource/types";
+
+const getMaintenanceInfoSchema = z
+    .object({
+        fullDomain: z.string().min(1, "Domain is required")
+    })
+    .strict();
+
+async function query(fullDomain: string) {
+    const [res] = await db
+        .select({
+            resourceId: resources.resourceId,
+            name: resources.name,
+            fullDomain: resources.fullDomain,
+            maintenanceModeEnabled: resources.maintenanceModeEnabled,
+            maintenanceModeType: resources.maintenanceModeType,
+            maintenanceTitle: resources.maintenanceTitle,
+            maintenanceMessage: resources.maintenanceMessage,
+            maintenanceEstimatedTime: resources.maintenanceEstimatedTime
+        })
+        .from(resources)
+        .where(eq(resources.fullDomain, fullDomain))
+        .limit(1);
+    return res;
+}
+
+registry.registerPath({
+    method: "get",
+    path: "/maintenance/info",
+    description: "Get maintenance information for a resource by domain.",
+    tags: [OpenAPITags.Resource],
+    request: {
+        query: z.object({
+            fullDomain: z.string()
+        })
+    },
+    responses: {
+        200: {
+            description: "Maintenance information retrieved successfully"
+        },
+        404: {
+            description: "Resource not found"
+        }
+    }
+});
+
+export async function getMaintenanceInfo(
+    req: Request,
+    res: Response,
+    next: NextFunction
+): Promise<any> {
+    try {
+        const parsedQuery = getMaintenanceInfoSchema.safeParse(req.query);
+        if (!parsedQuery.success) {
+            return next(
+                createHttpError(
+                    HttpCode.BAD_REQUEST,
+                    fromError(parsedQuery.error).toString()
+                )
+            );
+        }
+
+        const { fullDomain } = parsedQuery.data;
+
+        const maintenanceInfo = await query(fullDomain);
+
+        if (!maintenanceInfo) {
+            return next(
+                createHttpError(HttpCode.NOT_FOUND, "Resource not found")
+            );
+        }
+
+        return response<GetMaintenanceInfoResponse>(res, {
+            data: maintenanceInfo,
+            success: true,
+            error: false,
+            message: "Maintenance information retrieved successfully",
+            status: HttpCode.OK
+        });
+    } catch (error) {
+        logger.error(error);
+        return next(
+            createHttpError(
+                HttpCode.INTERNAL_SERVER_ERROR,
+                "An error occurred while retrieving maintenance information"
+            )
+        );
+    }
+}

server/private/routers/resource/index.ts

@@ -0,0 +1,14 @@
+/*
+ * This file is part of a proprietary work.
+ *
+ * Copyright (c) 2025 Fossorial, Inc.
+ * All rights reserved.
+ *
+ * This file is licensed under the Fossorial Commercial License.
+ * You may not use this file except in compliance with the License.
+ * Unauthorized use, copying, modification, or distribution is strictly prohibited.
+ *
+ * This file is not licensed under the AGPLv3.
+ */
+
+export * from "./getMaintenanceInfo";

server/routers/external.ts

@@ -47,7 +47,6 @@ import createHttpError from "http-errors";
 import { build } from "@server/build";
 import { createStore } from "#dynamic/lib/rateLimitStore";
 import { logActionAudit } from "#dynamic/middlewares";
-import { log } from "console";
 
 // Root routes
 export const unauthenticated = Router();

server/routers/org/updateOrg.ts

@@ -10,10 +10,10 @@ import logger from "@server/logger";
 import { fromError } from "zod-validation-error";
 import { OpenAPITags, registry } from "@server/openApi";
 import { build } from "@server/build";
-import license from "#dynamic/license/license";
 import { getOrgTierData } from "#dynamic/lib/billing";
 import { TierId } from "@server/lib/billing/tiers";
 import { cache } from "@server/lib/cache";
+import { isLicensedOrSubscribed } from "@server/lib/isLicencedOrSubscribed";
 
 const updateOrgParamsSchema = z
     .object({
@@ -157,23 +157,4 @@ export async function updateOrg(
             createHttpError(HttpCode.INTERNAL_SERVER_ERROR, "An error occurred")
         );
     }
-}
-
-async function isLicensedOrSubscribed(orgId: string): Promise<boolean> {
-    if (build === "enterprise") {
-        const isUnlocked = await license.isUnlocked();
-        if (!isUnlocked) {
-            return false;
-        }
-    }
-
-    if (build === "saas") {
-        const { tier } = await getOrgTierData(orgId);
-        const subscribed = tier === TierId.STANDARD;
-        if (!subscribed) {
-            return false;
-        }
-    }
-
-    return true;
-}
+}

server/routers/resource/index.ts

@@ -24,4 +24,4 @@ export * from "./updateResourceRule";
 export * from "./getUserResources";
 export * from "./setResourceHeaderAuth";
 export * from "./addEmailToResourceWhitelist";
-export * from "./removeEmailFromResourceWhitelist";
+export * from "./removeEmailFromResourceWhitelist";

server/routers/resource/types.ts

@@ -0,0 +1,10 @@
+export type GetMaintenanceInfoResponse = {
+    resourceId: number;
+    name: string;
+    fullDomain: string | null;
+    maintenanceModeEnabled: boolean;
+    maintenanceModeType: "forced" | "automatic" | null;
+    maintenanceTitle: string | null;
+    maintenanceMessage: string | null;
+    maintenanceEstimatedTime: string | null;
+}

server/routers/resource/updateResource.ts

@@ -22,8 +22,8 @@ import { registry } from "@server/openApi";
 import { OpenAPITags } from "@server/openApi";
 import { createCertificate } from "#dynamic/routers/certificates/createCertificate";
 import { validateAndConstructDomain } from "@server/lib/domainUtils";
-import { validateHeaders } from "@server/lib/validators";
 import { build } from "@server/build";
+import { isLicensedOrSubscribed } from "@server/lib/isLicencedOrSubscribed";
 
 const updateResourceParamsSchema = z
     .object({
@@ -53,7 +53,13 @@ const updateHttpResourceBodySchema = z
         headers: z
             .array(z.object({ name: z.string(), value: z.string() }))
             .nullable()
-            .optional()
+            .optional(),
+        // Maintenance mode fields
+        maintenanceModeEnabled: z.boolean().optional(),
+        maintenanceModeType: z.enum(["forced", "automatic"]).optional(),
+        maintenanceTitle: z.string().max(255).nullable().optional(),
+        maintenanceMessage: z.string().max(2000).nullable().optional(),
+        maintenanceEstimatedTime: z.string().max(100).nullable().optional()
     })
     .strict()
     .refine((data) => Object.keys(data).length > 0, {
@@ -243,11 +249,11 @@ async function updateHttpResource(
             .select()
             .from(resources)
             .where(
-            and(
-                eq(resources.niceId, updateData.niceId),
-                eq(resources.orgId, resource.orgId)
-            )
-        );
+                and(
+                    eq(resources.niceId, updateData.niceId),
+                    eq(resources.orgId, resource.orgId)
+                )
+            );
 
         if (
             existingResource &&
@@ -338,6 +344,16 @@ async function updateHttpResource(
         headers = JSON.stringify(updateData.headers);
     }
 
+    const isLicensed = await isLicensedOrSubscribed(resource.orgId);
+    if (build == "enterprise" && !isLicensed) {
+        // null the maintenance mode fields if not licensed
+        updateData.maintenanceModeEnabled = undefined;
+        updateData.maintenanceModeType = undefined;
+        updateData.maintenanceTitle = undefined;
+        updateData.maintenanceMessage = undefined;
+        updateData.maintenanceEstimatedTime = undefined;
+    }
+
     const updatedResource = await db
         .update(resources)
         .set({ ...updateData, headers })
@@ -393,11 +409,11 @@ async function updateRawResource(
             .select()
             .from(resources)
             .where(
-            and(
-                eq(resources.niceId, updateData.niceId),
-                eq(resources.orgId, resource.orgId)
-            )
-        );
+                and(
+                    eq(resources.niceId, updateData.niceId),
+                    eq(resources.orgId, resource.orgId)
+                )
+            );
 
         if (
             existingResource &&

src/app/[orgId]/settings/general/page.tsx

@@ -50,7 +50,7 @@ import { useUserContext } from "@app/hooks/useUserContext";
 import { useTranslations } from "next-intl";
 import { build } from "@server/build";
 import { SwitchInput } from "@app/components/SwitchInput";
-import { SecurityFeaturesAlert } from "@app/components/SecurityFeaturesAlert";
+import { LicenseOrSubscriptionRequiredAlert } from "@app/components/SecurityFeaturesAlert";
 import { useLicenseStatusContext } from "@app/hooks/useLicenseStatusContext";
 import { useSubscriptionStatusContext } from "@app/hooks/useSubscriptionStatusContext";
 
@@ -440,7 +440,7 @@ export default function GeneralPage() {
 
                                 {build != "oss" && (
                                     <>
-                                        <SecurityFeaturesAlert />
+                                        <LicenseOrSubscriptionRequiredAlert />
 
                                         <FormField
                                             control={form.control}
@@ -600,7 +600,7 @@ export default function GeneralPage() {
                             </SettingsSectionHeader>
                             <SettingsSectionBody>
                                 <SettingsSectionForm>
-                                <SecurityFeaturesAlert />
+                                <LicenseOrSubscriptionRequiredAlert />
                                     <FormField
                                         control={form.control}
                                         name="requireTwoFactor"

src/app/[orgId]/settings/resources/[niceId]/general/page.tsx

@@ -14,6 +14,7 @@ import {
     FormMessage
 } from "@/components/ui/form";
 import { Input } from "@/components/ui/input";
+import { Textarea } from "@/components/ui/textarea";
 import { useResourceContext } from "@app/hooks/useResourceContext";
 import { ListSitesResponse } from "@server/routers/site";
 import { useEffect, useState } from "react";
@@ -39,7 +40,6 @@ import { ListDomainsResponse } from "@server/routers/domain";
 import { UpdateResourceResponse } from "@server/routers/resource";
 import { SwitchInput } from "@app/components/SwitchInput";
 import { useTranslations } from "next-intl";
-import { Checkbox } from "@app/components/ui/checkbox";
 import {
     Credenza,
     CredenzaBody,
@@ -51,7 +51,7 @@ import {
     CredenzaTitle
 } from "@app/components/Credenza";
 import DomainPicker from "@app/components/DomainPicker";
-import { Globe } from "lucide-react";
+import { AlertCircle, Globe, Info } from "lucide-react";
 import { build } from "@server/build";
 import { finalizeSubdomainSanitize } from "@app/lib/subdomain-utils";
 import { DomainRow } from "../../../../../../components/DomainsTable";
@@ -59,6 +59,15 @@ import { toASCII, toUnicode } from "punycode";
 import { useLicenseStatusContext } from "@app/hooks/useLicenseStatusContext";
 import { useSubscriptionStatusContext } from "@app/hooks/useSubscriptionStatusContext";
 import { useUserContext } from "@app/hooks/useUserContext";
+import { Alert, AlertDescription } from "@app/components/ui/alert";
+import { RadioGroup, RadioGroupItem } from "@app/components/ui/radio-group";
+import {
+    Tooltip,
+    TooltipContent,
+    TooltipProvider,
+    TooltipTrigger
+} from "@app/components/ui/tooltip";
+import { LicenseOrSubscriptionRequiredAlert } from "@app/components/SecurityFeaturesAlert";
 
 export default function GeneralForm() {
     const [formKey, setFormKey] = useState(0);
@@ -68,8 +77,9 @@ export default function GeneralForm() {
     const router = useRouter();
     const t = useTranslations();
     const [editDomainOpen, setEditDomainOpen] = useState(false);
-    const { licenseStatus } = useLicenseStatusContext();
     const subscriptionStatus = useSubscriptionStatusContext();
+    const { licenseStatus, isUnlocked } = useLicenseStatusContext();
+    const subscription = useSubscriptionStatusContext();
     const { user } = useUserContext();
 
     const { env } = useEnvContext();
@@ -97,6 +107,14 @@ export default function GeneralForm() {
         baseDomain: string;
     } | null>(null);
 
+    // Check if security features are disabled due to licensing/subscription
+    const isSecurityFeatureDisabled = () => {
+        const isEnterpriseNotLicensed = build === "enterprise" && !isUnlocked();
+        const isSaasNotSubscribed =
+            build === "saas" && !subscription?.isSubscribed();
+        return isEnterpriseNotLicensed || isSaasNotSubscribed;
+    };
+
     const GeneralFormSchema = z
         .object({
             enabled: z.boolean(),
@@ -106,6 +124,11 @@ export default function GeneralForm() {
             domainId: z.string().optional(),
             proxyPort: z.number().int().min(1).max(65535).optional(),
             // enableProxy: z.boolean().optional()
+            maintenanceModeEnabled: z.boolean().optional(),
+            maintenanceModeType: z.enum(["forced", "automatic"]).optional(),
+            maintenanceTitle: z.string().max(255).optional(),
+            maintenanceMessage: z.string().max(2000).optional(),
+            maintenanceEstimatedTime: z.string().max(100).optional()
         })
         .refine(
             (data) => {
@@ -136,10 +159,21 @@ export default function GeneralForm() {
             domainId: resource.domainId || undefined,
             proxyPort: resource.proxyPort || undefined,
             // enableProxy: resource.enableProxy || false
+            maintenanceModeEnabled: resource.maintenanceModeEnabled || false,
+            maintenanceModeType: resource.maintenanceModeType || "automatic",
+            maintenanceTitle:
+                resource.maintenanceTitle || "We'll be back soon!",
+            maintenanceMessage:
+                resource.maintenanceMessage ||
+                "We are currently performing scheduled maintenance. Please check back soon.",
+            maintenanceEstimatedTime: resource.maintenanceEstimatedTime || ""
         },
         mode: "onChange"
     });
 
+    const isMaintenanceEnabled = form.watch("maintenanceModeEnabled");
+    const maintenanceModeType = form.watch("maintenanceModeType");
+
     useEffect(() => {
         const fetchSites = async () => {
             const res = await api.get<AxiosResponse<ListSitesResponse>>(
@@ -168,7 +202,7 @@ export default function GeneralForm() {
                 const rawDomains = res.data.data.domains as DomainRow[];
                 const domains = rawDomains.map((domain) => ({
                     ...domain,
-                    baseDomain: toUnicode(domain.baseDomain),
+                    baseDomain: toUnicode(domain.baseDomain)
                 }));
                 setBaseDomains(domains);
                 setFormKey((key) => key + 1);
@@ -195,12 +229,20 @@ export default function GeneralForm() {
                     enabled: data.enabled,
                     name: data.name,
                     niceId: data.niceId,
-                    subdomain: data.subdomain ? toASCII(data.subdomain) : undefined,
+                    subdomain: data.subdomain
+                        ? toASCII(data.subdomain)
+                        : undefined,
                     domainId: data.domainId,
                     proxyPort: data.proxyPort,
                     // ...(!resource.http && {
                     //     enableProxy: data.enableProxy
                     // })
+                    maintenanceModeEnabled: data.maintenanceModeEnabled,
+                    maintenanceModeType: data.maintenanceModeType,
+                    maintenanceTitle: data.maintenanceTitle || null,
+                    maintenanceMessage: data.maintenanceMessage || null,
+                    maintenanceEstimatedTime:
+                        data.maintenanceEstimatedTime || null
                 }
             )
             .catch((e) => {
@@ -227,6 +269,11 @@ export default function GeneralForm() {
                 // ...(!resource.http && {
                 //     enableProxy: data.enableProxy
                 // })
+                maintenanceModeEnabled: data.maintenanceModeEnabled,
+                maintenanceModeType: data.maintenanceModeType,
+                maintenanceTitle: data.maintenanceTitle || null,
+                maintenanceMessage: data.maintenanceMessage || null,
+                maintenanceEstimatedTime: data.maintenanceEstimatedTime || null
             });
 
             toast({
@@ -235,7 +282,9 @@ export default function GeneralForm() {
             });
 
             if (data.niceId && data.niceId !== resource?.niceId) {
-                router.replace(`/${updated.orgId}/settings/resources/${data.niceId}/general`);
+                router.replace(
+                    `/${updated.orgId}/settings/resources/${data.niceId}/general`
+                );
             } else {
                 router.refresh();
             }
@@ -320,11 +369,15 @@ export default function GeneralForm() {
                                             name="niceId"
                                             render={({ field }) => (
                                                 <FormItem>
-                                                    <FormLabel>{t("identifier")}</FormLabel>
+                                                    <FormLabel>
+                                                        {t("identifier")}
+                                                    </FormLabel>
                                                     <FormControl>
                                                         <Input
                                                             {...field}
-                                                            placeholder={t("enterIdentifier")}
+                                                            placeholder={t(
+                                                                "enterIdentifier"
+                                                            )}
                                                             className="flex-1"
                                                         />
                                                     </FormControl>
@@ -360,10 +413,10 @@ export default function GeneralForm() {
                                                                                 .target
                                                                                 .value
                                                                                 ? parseInt(
-                                                                                    e
-                                                                                        .target
-                                                                                        .value
-                                                                                )
+                                                                                      e
+                                                                                          .target
+                                                                                          .value
+                                                                                  )
                                                                                 : undefined
                                                                         )
                                                                     }
@@ -418,62 +471,326 @@ export default function GeneralForm() {
                                         )}
 
                                         {resource.http && (
-                                            <div className="space-y-2">
-                                                <Label>
-                                                    {t("resourceDomain")}
-                                                </Label>
-                                                <div className="border p-2 rounded-md flex items-center justify-between">
-                                                    <span className="text-sm text-muted-foreground flex items-center gap-2">
-                                                        <Globe size="14" />
-                                                        {resourceFullDomain}
-                                                    </span>
-                                                    <Button
-                                                        variant="secondary"
-                                                        type="button"
-                                                        size="sm"
-                                                        onClick={() =>
-                                                            setEditDomainOpen(
-                                                                true
-                                                            )
-                                                        }
-                                                    >
-                                                        {t(
-                                                            "resourceEditDomain"
-                                                        )}
-                                                    </Button>
+                                            <>
+                                                <div className="space-y-2">
+                                                    <Label>
+                                                        {t("resourceDomain")}
+                                                    </Label>
+                                                    <div className="border p-2 rounded-md flex items-center justify-between">
+                                                        <span className="text-sm text-muted-foreground flex items-center gap-2">
+                                                            <Globe size="14" />
+                                                            {resourceFullDomain}
+                                                        </span>
+                                                        <Button
+                                                            variant="secondary"
+                                                            type="button"
+                                                            size="sm"
+                                                            onClick={() =>
+                                                                setEditDomainOpen(
+                                                                    true
+                                                                )
+                                                            }
+                                                        >
+                                                            {t(
+                                                                "resourceEditDomain"
+                                                            )}
+                                                        </Button>
+                                                    </div>
                                                 </div>
-                                            </div>
+                                            </>
                                         )}
                                     </form>
                                 </Form>
                             </SettingsSectionForm>
                         </SettingsSectionBody>
-
-                        <SettingsSectionFooter>
-                            <Button
-                                type="submit"
-                                onClick={() => {
-                                    console.log(form.getValues());
-                                }}
-                                loading={saveLoading}
-                                disabled={saveLoading}
-                                form="general-settings-form"
-                            >
-                                {t("saveSettings")}
-                            </Button>
-                        </SettingsSectionFooter>
                     </SettingsSection>
                 </SettingsContainer>
 
+                {build !== "oss" && resource.http && (
+                    <SettingsContainer>
+                        <SettingsSection>
+                            <SettingsSectionHeader>
+                                <SettingsSectionTitle>
+                                    {t("maintenanceMode")}
+                                </SettingsSectionTitle>
+                                <SettingsSectionDescription>
+                                    {t("maintenanceModeDescription")}
+                                </SettingsSectionDescription>
+                            </SettingsSectionHeader>
+
+                            <SettingsSectionBody>
+                                <LicenseOrSubscriptionRequiredAlert />
+
+                                <SettingsSectionForm>
+                                    <Form {...form}>
+                                        <form className="space-y-4">
+                                            <FormField
+                                                control={form.control}
+                                                name="maintenanceModeEnabled"
+                                                render={({ field }) => {
+                                                    const isDisabled =
+                                                        isSecurityFeatureDisabled();
+
+                                                    return (
+                                                        <FormItem>
+                                                            <div className="flex items-center space-x-2">
+                                                                <FormControl>
+                                                                    <TooltipProvider>
+                                                                        <Tooltip>
+                                                                            <TooltipTrigger
+                                                                                asChild
+                                                                            >
+                                                                                <div className="flex items-center gap-2">
+                                                                                    <SwitchInput
+                                                                                        id="enable-maintenance"
+                                                                                        checked={
+                                                                                            field.value
+                                                                                        }
+                                                                                        label={t(
+                                                                                            "enableMaintenanceMode"
+                                                                                        )}
+                                                                                        disabled={
+                                                                                            isDisabled
+                                                                                        }
+                                                                                        onCheckedChange={(
+                                                                                            val
+                                                                                        ) => {
+                                                                                            if (
+                                                                                                !isDisabled
+                                                                                            ) {
+                                                                                                form.setValue(
+                                                                                                    "maintenanceModeEnabled",
+                                                                                                    val
+                                                                                                );
+                                                                                            }
+                                                                                        }}
+                                                                                    />
+                                                                                </div>
+                                                                            </TooltipTrigger>
+                                                                        </Tooltip>
+                                                                    </TooltipProvider>
+                                                                </FormControl>
+                                                            </div>
+                                                            <FormDescription>
+                                                                {t(
+                                                                    "showMaintenancePage"
+                                                                )}
+                                                            </FormDescription>
+                                                            <FormMessage />
+                                                        </FormItem>
+                                                    );
+                                                }}
+                                            />
+
+                                            {isMaintenanceEnabled && (
+                                                <div className="space-y-4">
+                                                    <FormField
+                                                        control={form.control}
+                                                        name="maintenanceModeType"
+                                                        render={({ field }) => (
+                                                            <FormItem className="space-y-3">
+                                                                <FormLabel>
+                                                                    {t(
+                                                                        "maintenanceModeType"
+                                                                    )}
+                                                                </FormLabel>
+                                                                <FormControl>
+                                                                    <RadioGroup
+                                                                        onValueChange={
+                                                                            field.onChange
+                                                                        }
+                                                                        defaultValue={
+                                                                            field.value
+                                                                        }
+                                                                        disabled={isSecurityFeatureDisabled()}
+                                                                        className="flex flex-col space-y-1"
+                                                                    >
+                                                                        <FormItem className="flex items-start space-x-3 space-y-0">
+                                                                            <FormControl>
+                                                                                <RadioGroupItem value="automatic" />
+                                                                            </FormControl>
+                                                                            <div className="space-y-1 leading-none">
+                                                                                <FormLabel className="font-normal">
+                                                                                    <strong>
+                                                                                        {t(
+                                                                                            "automatic"
+                                                                                        )}
+                                                                                    </strong>{" "}
+                                                                                    (
+                                                                                    {t(
+                                                                                        "recommended"
+                                                                                    )}
+
+                                                                                    )
+                                                                                </FormLabel>
+                                                                                <FormDescription>
+                                                                                    {t(
+                                                                                        "automaticModeDescription"
+                                                                                    )}
+                                                                                </FormDescription>
+                                                                            </div>
+                                                                        </FormItem>
+                                                                        <FormItem className="flex items-start space-x-3 space-y-0">
+                                                                            <FormControl>
+                                                                                <RadioGroupItem value="forced" />
+                                                                            </FormControl>
+                                                                            <div className="space-y-1 leading-none">
+                                                                                <FormLabel className="font-normal">
+                                                                                    <strong>
+                                                                                        {t(
+                                                                                            "forced"
+                                                                                        )}
+                                                                                    </strong>
+                                                                                </FormLabel>
+                                                                                <FormDescription>
+                                                                                    {t(
+                                                                                        "forcedModeDescription"
+                                                                                    )}
+                                                                                </FormDescription>
+                                                                            </div>
+                                                                        </FormItem>
+                                                                    </RadioGroup>
+                                                                </FormControl>
+                                                                <FormMessage />
+                                                            </FormItem>
+                                                        )}
+                                                    />
+
+                                                    {maintenanceModeType ===
+                                                        "forced" && (
+                                                        <Alert>
+                                                            <AlertCircle className="h-4 w-4" />
+                                                            <AlertDescription>
+                                                                <strong>
+                                                                    {t(
+                                                                        "warning:"
+                                                                    )}
+                                                                </strong>{" "}
+                                                                {t(
+                                                                    "forcedeModeWarning"
+                                                                )}
+                                                            </AlertDescription>
+                                                        </Alert>
+                                                    )}
+
+                                                    <FormField
+                                                        control={form.control}
+                                                        name="maintenanceTitle"
+                                                        render={({ field }) => (
+                                                            <FormItem>
+                                                                <FormLabel>
+                                                                    {t(
+                                                                        "pageTitle"
+                                                                    )}
+                                                                </FormLabel>
+                                                                <FormControl>
+                                                                    <Input
+                                                                        {...field}
+                                                                        disabled={isSecurityFeatureDisabled()}
+                                                                        placeholder="We'll be back soon!"
+                                                                    />
+                                                                </FormControl>
+                                                                <FormDescription>
+                                                                    {t(
+                                                                        "pageTitleDescription"
+                                                                    )}
+                                                                </FormDescription>
+                                                                <FormMessage />
+                                                            </FormItem>
+                                                        )}
+                                                    />
+
+                                                    <FormField
+                                                        control={form.control}
+                                                        name="maintenanceMessage"
+                                                        render={({ field }) => (
+                                                            <FormItem>
+                                                                <FormLabel>
+                                                                    {t(
+                                                                        "maintenancePageMessage"
+                                                                    )}
+                                                                </FormLabel>
+                                                                <FormControl>
+                                                                    <Textarea
+                                                                        {...field}
+                                                                        rows={4}
+                                                                        disabled={isSecurityFeatureDisabled()}
+                                                                        placeholder={t(
+                                                                            "maintenancePageMessagePlaceholder"
+                                                                        )}
+                                                                    />
+                                                                </FormControl>
+                                                                <FormDescription>
+                                                                    {t(
+                                                                        "maintenancePageMessageDescription"
+                                                                    )}
+                                                                </FormDescription>
+                                                                <FormMessage />
+                                                            </FormItem>
+                                                        )}
+                                                    />
+
+                                                    <FormField
+                                                        control={form.control}
+                                                        name="maintenanceEstimatedTime"
+                                                        render={({ field }) => (
+                                                            <FormItem>
+                                                                <FormLabel>
+                                                                    {t(
+                                                                        "maintenancePageTimeTitle"
+                                                                    )}
+                                                                </FormLabel>
+                                                                <FormControl>
+                                                                    <Input
+                                                                        {...field}
+                                                                        disabled={isSecurityFeatureDisabled()}
+                                                                        placeholder={t(
+                                                                            "maintenanceTime"
+                                                                        )}
+                                                                    />
+                                                                </FormControl>
+                                                                <FormDescription>
+                                                                    {t(
+                                                                        "maintenanceEstimatedTimeDescription"
+                                                                    )}
+                                                                </FormDescription>
+                                                                <FormMessage />
+                                                            </FormItem>
+                                                        )}
+                                                    />
+                                                </div>
+                                            )}
+                                        </form>
+                                    </Form>
+                                </SettingsSectionForm>
+                            </SettingsSectionBody>
+                        </SettingsSection>
+                    </SettingsContainer>
+                )}
+
+                <div className="flex justify-end">
+                    <Button
+                        type="submit"
+                        onClick={() => {
+                            console.log(form.getValues());
+                        }}
+                        loading={saveLoading}
+                        disabled={saveLoading}
+                        form="general-settings-form"
+                    >
+                        {t("saveSettings")}
+                    </Button>
+                </div>
+
                 <Credenza
                     open={editDomainOpen}
                     onOpenChange={(setOpen) => setEditDomainOpen(setOpen)}
                 >
                     <CredenzaContent>
                         <CredenzaHeader>
-                            <CredenzaTitle>Edit Domain</CredenzaTitle>
+                            <CredenzaTitle>{t("editDomain")}</CredenzaTitle>
                             <CredenzaDescription>
-                                Select a domain for your resource
+                                {t("editDomainDescription")}
                             </CredenzaDescription>
                         </CredenzaHeader>
                         <CredenzaBody>
@@ -498,23 +815,35 @@ export default function GeneralForm() {
                             <Button
                                 onClick={() => {
                                     if (selectedDomain) {
-                                        const sanitizedSubdomain = selectedDomain.subdomain
-                                            ? finalizeSubdomainSanitize(selectedDomain.subdomain)
-                                            : "";
+                                        const sanitizedSubdomain =
+                                            selectedDomain.subdomain
+                                                ? finalizeSubdomainSanitize(
+                                                      selectedDomain.subdomain
+                                                  )
+                                                : "";
 
-                                        const sanitizedFullDomain = sanitizedSubdomain
-                                            ? `${sanitizedSubdomain}.${selectedDomain.baseDomain}`
-                                            : selectedDomain.baseDomain;
+                                        const sanitizedFullDomain =
+                                            sanitizedSubdomain
+                                                ? `${sanitizedSubdomain}.${selectedDomain.baseDomain}`
+                                                : selectedDomain.baseDomain;
 
-                                        setResourceFullDomain(`${resource.ssl ? "https" : "http"}://${sanitizedFullDomain}`);
-                                        form.setValue("domainId", selectedDomain.domainId);
-                                        form.setValue("subdomain", sanitizedSubdomain);
+                                        setResourceFullDomain(
+                                            `${resource.ssl ? "https" : "http"}://${sanitizedFullDomain}`
+                                        );
+                                        form.setValue(
+                                            "domainId",
+                                            selectedDomain.domainId
+                                        );
+                                        form.setValue(
+                                            "subdomain",
+                                            sanitizedSubdomain
+                                        );
 
                                         setEditDomainOpen(false);
                                     }
                                 }}
                             >
-                                Select Domain
+                                {t("selectDomain")}
                             </Button>
                         </CredenzaFooter>
                     </CredenzaContent>

src/app/maintenance-screen/page.tsx

@@ -0,0 +1,68 @@
+import { headers } from "next/headers";
+import { priv } from "@app/lib/api";
+import { GetMaintenanceInfoResponse } from "@server/routers/resource/types";
+import { getTranslations } from "next-intl/server";
+import {
+    Card,
+    CardContent,
+    CardHeader,
+    CardTitle
+} from "@app/components/ui/card";
+import { Alert, AlertTitle, AlertDescription } from "@app/components/ui/alert";
+import { Clock } from "lucide-react";
+
+export const dynamic = "force-dynamic";
+
+export default async function MaintenanceScreen() {
+    const t = await getTranslations();
+
+    let title = t("maintenanceScreenTitle");
+    let message = t("maintenanceScreenMessage");
+    let estimatedTime: string | null = null;
+
+    try {
+        const headersList = await headers();
+        const host = headersList.get("host") || "";
+        const hostname = host.split(":")[0];
+
+        const res = await priv.get<GetMaintenanceInfoResponse>(
+            `/maintenance/info?fullDomain=${encodeURIComponent(hostname)}`
+        );
+
+        if (res && res.status === 200) {
+            const maintenanceInfo = res.data;
+            title = maintenanceInfo?.maintenanceTitle || title;
+            message = maintenanceInfo?.maintenanceMessage || message;
+            estimatedTime = maintenanceInfo?.maintenanceEstimatedTime || null;
+        }
+    } catch (err) {
+        console.error(
+            "Failed to fetch maintenance info",
+            err instanceof Error ? err.message : String(err)
+        );
+    }
+
+    return (
+        <div className="min-h-screen flex items-center justify-center p-4">
+            <Card className="w-full max-w-md">
+                <CardHeader>
+                    <CardTitle>{title}</CardTitle>
+                </CardHeader>
+                <CardContent className="space-y-4">
+                    <p>{message}</p>
+                    {estimatedTime && (
+                        <Alert className="w-full" variant="neutral">
+                            <Clock className="h-5 w-5" />
+                            <AlertTitle>
+                                {t("maintenanceScreenEstimatedCompletion")}
+                            </AlertTitle>
+                            <AlertDescription className="flex flex-col space-y-2">
+                                {estimatedTime}
+                            </AlertDescription>
+                        </Alert>
+                    )}
+                </CardContent>
+            </Card>
+        </div>
+    );
+}

src/components/SecurityFeaturesAlert.tsx

@@ -5,7 +5,7 @@ import { useTranslations } from "next-intl";
 import { useLicenseStatusContext } from "@app/hooks/useLicenseStatusContext";
 import { useSubscriptionStatusContext } from "@app/hooks/useSubscriptionStatusContext";
 
-export function SecurityFeaturesAlert() {
+export function LicenseOrSubscriptionRequiredAlert() {
     const t = useTranslations();
     const { isUnlocked } = useLicenseStatusContext();
     const subscriptionStatus = useSubscriptionStatusContext();