Open-source status page, incident response and uptime monitoring
TypeScript alertingincident-managementmcpmcp-servermonitoringmonitoring-as-codeobservabilityon-callopen-sourcesrestatus-pagestatuspagesynthetic-monitoringterraformtinybirdtursouptimeuptime-checkeruptime-monitor
feat: add icon, custom_domain, access_type, theme, password, auth_ema… (#2012)
Thibault Le Ouaycf4978fa6a8d
diff --git a/apps/server/src/routes/rpc/services/status-page/__tests__/status-page.test.ts b/apps/server/src/routes/rpc/services/status-page/__tests__/status-page.test.tsindex 4b9e9bf74..3bf23174f 100644--- a/apps/server/src/routes/rpc/services/status-page/__tests__/status-page.test.ts+++ b/apps/server/src/routes/rpc/services/status-page/__tests__/status-page.test.ts@@ -1,5 +1,5 @@import { afterAll, beforeAll, describe, expect, test } from "bun:test";-import { db, eq } from "@openstatus/db";+import { db, eq, sql } from "@openstatus/db";import {monitor,page,@@ -47,8 +47,15 @@ let testGroupToDeleteId: number;let testGroupToUpdateId: number;let testMonitorId: number;let testSubscriberId: number;+let testPasswordPageId: number;+let testPasswordPageSlug: string;beforeAll(async () => {+ // Ensure workspace 1 has email-domain-protection enabled for AUTHENTICATED tests+ await db.run(+ sql`UPDATE workspace SET limits = json_set(COALESCE(limits, '{}'), '$."email-domain-protection"', json('true')) WHERE id = 1`,+ );+// Clean up any existing test dataawait db.delete(pageSubscriber)@@ -74,6 +81,7 @@ beforeAll(async () => {await db.delete(page).where(eq(page.slug, `${TEST_PREFIX}-slug`));await db.delete(page).where(eq(page.slug, `${TEST_PREFIX}-slug-to-delete`));await db.delete(page).where(eq(page.slug, `${TEST_PREFIX}-slug-to-update`));+ await db.delete(page).where(eq(page.slug, `${TEST_PREFIX}-password-slug`));await db.delete(monitor).where(eq(monitor.name, `${TEST_PREFIX}-monitor`));// Create a test monitor for component tests@@ -229,6 +237,26 @@ beforeAll(async () => {.returning().get();testSubscriberId = testSubscriber.id;++ // Create a test page with password protection for read tests+ const passwordPage = await db+ .insert(page)+ .values({+ workspaceId: 1,+ title: `${TEST_PREFIX}-password-page`,+ slug: `${TEST_PREFIX}-password-slug`,+ description: "Password protected test page",+ customDomain: "",+ published: true,+ accessType: "password",+ password: "test-secret-123",+ authEmailDomains: null,+ icon: "https://example.com/icon.png",+ })+ .returning()+ .get();+ testPasswordPageId = passwordPage.id;+ testPasswordPageSlug = passwordPage.slug;});afterAll(async () => {@@ -283,6 +311,16 @@ afterAll(async () => {.delete(page).where(eq(page.slug, `${TEST_PREFIX}-i18n-limit-update-slug`));+ await db.delete(page).where(eq(page.slug, `${TEST_PREFIX}-password-slug`));+ await db.delete(page).where(eq(page.slug, `${TEST_PREFIX}-icon-slug`));+ await db.delete(page).where(eq(page.slug, `${TEST_PREFIX}-domain-slug`));+ await db.delete(page).where(eq(page.slug, `${TEST_PREFIX}-theme-slug`));+ await db.delete(page).where(eq(page.slug, `${TEST_PREFIX}-pw-create-slug`));+ await db.delete(page).where(eq(page.slug, `${TEST_PREFIX}-auth-create-slug`));+ await db.delete(page).where(eq(page.slug, `${TEST_PREFIX}-public-pw-slug`));+ await db.delete(page).where(eq(page.slug, `${TEST_PREFIX}-limit-ws2-slug`));+ await db.delete(page).where(eq(page.slug, `${TEST_PREFIX}-trim-domain-slug`));+await db.delete(monitor).where(eq(monitor.name, `${TEST_PREFIX}-monitor`));});@@ -2100,3 +2138,775 @@ describe("StatusPageService.GetOverallStatus", () => {}});});++// ==========================================================================+// New Fields: icon, custom_domain, theme, access_type, password, auth_email_domains+// ==========================================================================++describe("StatusPageService.CreateStatusPage — new fields", () => {+ test("creates a page with icon", async () => {+ const res = await connectRequest(+ "CreateStatusPage",+ {+ title: `${TEST_PREFIX}-icon`,+ slug: `${TEST_PREFIX}-icon-slug`,+ icon: "https://example.com/my-icon.png",+ },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(200);+ const data = await res.json();+ expect(data.statusPage.icon).toBe("https://example.com/my-icon.png");++ await db.delete(page).where(eq(page.id, Number(data.statusPage.id)));+ });++ test("creates a page with custom_domain", async () => {+ const res = await connectRequest(+ "CreateStatusPage",+ {+ title: `${TEST_PREFIX}-domain`,+ slug: `${TEST_PREFIX}-domain-slug`,+ customDomain: "status.example.com",+ },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(200);+ const data = await res.json();+ expect(data.statusPage.customDomain).toBe("status.example.com");++ await db.delete(page).where(eq(page.id, Number(data.statusPage.id)));+ });++ test("creates a page with theme", async () => {+ const res = await connectRequest(+ "CreateStatusPage",+ {+ title: `${TEST_PREFIX}-theme`,+ slug: `${TEST_PREFIX}-theme-slug`,+ theme: "PAGE_THEME_DARK",+ },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(200);+ const data = await res.json();+ expect(data.statusPage.theme).toBe("PAGE_THEME_DARK");++ await db.delete(page).where(eq(page.id, Number(data.statusPage.id)));+ });++ test("creates a page with access_type PASSWORD_PROTECTED + password", async () => {+ const res = await connectRequest(+ "CreateStatusPage",+ {+ title: `${TEST_PREFIX}-pw-create`,+ slug: `${TEST_PREFIX}-pw-create-slug`,+ accessType: "PAGE_ACCESS_TYPE_PASSWORD_PROTECTED",+ password: "my-secret",+ },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(200);+ const data = await res.json();+ expect(data.statusPage.accessType).toBe(+ "PAGE_ACCESS_TYPE_PASSWORD_PROTECTED",+ );+ expect(data.statusPage.password).toBe("my-secret");++ await db.delete(page).where(eq(page.id, Number(data.statusPage.id)));+ });++ test("creates a page with access_type AUTHENTICATED + auth_email_domains", async () => {+ const res = await connectRequest(+ "CreateStatusPage",+ {+ title: `${TEST_PREFIX}-auth-create`,+ slug: `${TEST_PREFIX}-auth-create-slug`,+ accessType: "PAGE_ACCESS_TYPE_AUTHENTICATED",+ authEmailDomains: ["example.com", "test.com"],+ },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(200);+ const data = await res.json();+ expect(data.statusPage.accessType).toBe("PAGE_ACCESS_TYPE_AUTHENTICATED");+ expect(data.statusPage.authEmailDomains).toEqual([+ "example.com",+ "test.com",+ ]);++ await db.delete(page).where(eq(page.id, Number(data.statusPage.id)));+ });++ test("returns 400 when PASSWORD_PROTECTED without password", async () => {+ const res = await connectRequest(+ "CreateStatusPage",+ {+ title: `${TEST_PREFIX}-no-pw`,+ slug: `${TEST_PREFIX}-no-pw-slug`,+ accessType: "PAGE_ACCESS_TYPE_PASSWORD_PROTECTED",+ },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(400);+ const data = await res.json();+ expect(data.message).toContain("Password is required");+ });++ test("returns 400 when AUTHENTICATED without auth_email_domains", async () => {+ const res = await connectRequest(+ "CreateStatusPage",+ {+ title: `${TEST_PREFIX}-no-domains`,+ slug: `${TEST_PREFIX}-no-domains-slug`,+ accessType: "PAGE_ACCESS_TYPE_AUTHENTICATED",+ },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(400);+ const data = await res.json();+ expect(data.message).toContain("At least one email domain is required");+ });++ test("returns 400 when custom_domain contains openstatus", async () => {+ const res = await connectRequest(+ "CreateStatusPage",+ {+ title: `${TEST_PREFIX}-bad-domain`,+ slug: `${TEST_PREFIX}-bad-domain-slug`,+ customDomain: "my-openstatus-page.com",+ },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(400);+ });++ test("returns 400 when custom_domain starts with http://", async () => {+ const res = await connectRequest(+ "CreateStatusPage",+ {+ title: `${TEST_PREFIX}-http-domain`,+ slug: `${TEST_PREFIX}-http-domain-slug`,+ customDomain: "http://status.example.com",+ },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(400);+ });++ test("returns 400 when icon is not a valid URL", async () => {+ const res = await connectRequest(+ "CreateStatusPage",+ {+ title: `${TEST_PREFIX}-bad-icon`,+ slug: `${TEST_PREFIX}-bad-icon-slug`,+ icon: "not-a-url",+ },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(400);+ });++ test("silently ignores password when access_type is PUBLIC", async () => {+ const res = await connectRequest(+ "CreateStatusPage",+ {+ title: `${TEST_PREFIX}-public-pw`,+ slug: `${TEST_PREFIX}-public-pw-slug`,+ accessType: "PAGE_ACCESS_TYPE_PUBLIC",+ password: "should-be-ignored",+ },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(200);+ const data = await res.json();+ expect(data.statusPage.password ?? "").toBe("");++ await db.delete(page).where(eq(page.id, Number(data.statusPage.id)));+ });+});++describe("StatusPageService.UpdateStatusPage — new fields", () => {+ test("updates icon", async () => {+ const res = await connectRequest(+ "UpdateStatusPage",+ {+ id: String(testPasswordPageId),+ icon: "https://example.com/new-icon.png",+ },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(200);+ const data = await res.json();+ expect(data.statusPage.icon).toBe("https://example.com/new-icon.png");++ await db+ .update(page)+ .set({ icon: "https://example.com/icon.png" })+ .where(eq(page.id, testPasswordPageId));+ });++ test("updates custom_domain", async () => {+ const res = await connectRequest(+ "UpdateStatusPage",+ {+ id: String(testPasswordPageId),+ customDomain: "status.mysite.com",+ },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(200);+ const data = await res.json();+ expect(data.statusPage.customDomain).toBe("status.mysite.com");++ await db+ .update(page)+ .set({ customDomain: "" })+ .where(eq(page.id, testPasswordPageId));+ });++ test("updates theme", async () => {+ const res = await connectRequest(+ "UpdateStatusPage",+ {+ id: String(testPasswordPageId),+ theme: "PAGE_THEME_LIGHT",+ },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(200);+ const data = await res.json();+ expect(data.statusPage.theme).toBe("PAGE_THEME_LIGHT");++ await db+ .update(page)+ .set({ forceTheme: "system" })+ .where(eq(page.id, testPasswordPageId));+ });++ test("updates access_type to PASSWORD_PROTECTED with password", async () => {+ await db+ .update(page)+ .set({ accessType: "public", password: null })+ .where(eq(page.id, testPasswordPageId));++ const res = await connectRequest(+ "UpdateStatusPage",+ {+ id: String(testPasswordPageId),+ accessType: "PAGE_ACCESS_TYPE_PASSWORD_PROTECTED",+ password: "new-secret",+ },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(200);+ const data = await res.json();+ expect(data.statusPage.accessType).toBe(+ "PAGE_ACCESS_TYPE_PASSWORD_PROTECTED",+ );+ expect(data.statusPage.password).toBe("new-secret");++ await db+ .update(page)+ .set({ accessType: "password", password: "test-secret-123" })+ .where(eq(page.id, testPasswordPageId));+ });++ test("updates access_type to AUTHENTICATED with auth_email_domains", async () => {+ await db+ .update(page)+ .set({ accessType: "public", password: null, authEmailDomains: null })+ .where(eq(page.id, testPasswordPageId));++ const res = await connectRequest(+ "UpdateStatusPage",+ {+ id: String(testPasswordPageId),+ accessType: "PAGE_ACCESS_TYPE_AUTHENTICATED",+ authEmailDomains: ["mycompany.com"],+ },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(200);+ const data = await res.json();+ expect(data.statusPage.accessType).toBe("PAGE_ACCESS_TYPE_AUTHENTICATED");+ expect(data.statusPage.authEmailDomains).toEqual(["mycompany.com"]);++ await db+ .update(page)+ .set({+ accessType: "password",+ password: "test-secret-123",+ authEmailDomains: null,+ })+ .where(eq(page.id, testPasswordPageId));+ });++ test("returns 400 when PASSWORD_PROTECTED without password", async () => {+ const res = await connectRequest(+ "UpdateStatusPage",+ {+ id: String(testPasswordPageId),+ accessType: "PAGE_ACCESS_TYPE_PASSWORD_PROTECTED",+ },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(400);+ });++ test("returns 400 when AUTHENTICATED without auth_email_domains", async () => {+ const res = await connectRequest(+ "UpdateStatusPage",+ {+ id: String(testPasswordPageId),+ accessType: "PAGE_ACCESS_TYPE_AUTHENTICATED",+ },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(400);+ });++ test("changing only title on password page succeeds without re-validation", async () => {+ const res = await connectRequest(+ "UpdateStatusPage",+ {+ id: String(testPasswordPageId),+ title: `${TEST_PREFIX}-title-only-change`,+ },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(200);+ const data = await res.json();+ expect(data.statusPage.title).toBe(`${TEST_PREFIX}-title-only-change`);+ expect(data.statusPage.password).toBe("test-secret-123");++ await db+ .update(page)+ .set({ title: `${TEST_PREFIX}-password-page` })+ .where(eq(page.id, testPasswordPageId));+ });++ test("returns 400 when custom_domain contains openstatus", async () => {+ const res = await connectRequest(+ "UpdateStatusPage",+ {+ id: String(testPasswordPageId),+ customDomain: "openstatus-status.com",+ },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(400);+ });++ test("switching from PASSWORD_PROTECTED to PUBLIC clears password", async () => {+ await db+ .update(page)+ .set({ accessType: "password", password: "will-be-cleared" })+ .where(eq(page.id, testPasswordPageId));++ const res = await connectRequest(+ "UpdateStatusPage",+ {+ id: String(testPasswordPageId),+ accessType: "PAGE_ACCESS_TYPE_PUBLIC",+ },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(200);+ const data = await res.json();+ expect(data.statusPage.accessType).toBe("PAGE_ACCESS_TYPE_PUBLIC");+ expect(data.statusPage.password ?? "").toBe("");++ await db+ .update(page)+ .set({ accessType: "password", password: "test-secret-123" })+ .where(eq(page.id, testPasswordPageId));+ });++ test("switching from AUTHENTICATED to PUBLIC clears auth_email_domains", async () => {+ await db+ .update(page)+ .set({+ accessType: "email-domain",+ authEmailDomains: "example.com,test.com",+ password: null,+ })+ .where(eq(page.id, testPasswordPageId));++ const res = await connectRequest(+ "UpdateStatusPage",+ {+ id: String(testPasswordPageId),+ accessType: "PAGE_ACCESS_TYPE_PUBLIC",+ },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(200);+ const data = await res.json();+ expect(data.statusPage.accessType).toBe("PAGE_ACCESS_TYPE_PUBLIC");+ expect(data.statusPage.authEmailDomains ?? []).toEqual([]);++ await db+ .update(page)+ .set({+ accessType: "password",+ password: "test-secret-123",+ authEmailDomains: null,+ })+ .where(eq(page.id, testPasswordPageId));+ });++ test("clearing custom_domain with empty string succeeds", async () => {+ await db+ .update(page)+ .set({ customDomain: "status.example.com" })+ .where(eq(page.id, testPasswordPageId));++ const res = await connectRequest(+ "UpdateStatusPage",+ {+ id: String(testPasswordPageId),+ customDomain: "",+ },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(200);+ const data = await res.json();+ expect(data.statusPage.customDomain ?? "").toBe("");+ });++ test("returns 400 when icon is not a valid URL", async () => {+ const res = await connectRequest(+ "UpdateStatusPage",+ {+ id: String(testPasswordPageId),+ icon: "not-a-url",+ },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(400);+ });+});++describe("StatusPageService — new fields limit enforcement (workspace 2 / free plan)", () => {+ let ws2PageId: number;++ test("returns 403 when creating with custom_domain on free plan", async () => {+ const res = await connectRequest(+ "CreateStatusPage",+ {+ title: `${TEST_PREFIX}-limit-ws2`,+ slug: `${TEST_PREFIX}-limit-ws2-slug`,+ customDomain: "status.freeplan.com",+ },+ { "x-openstatus-key": "2" },+ );++ expect(res.status).toBe(403);+ });++ test("returns 403 when creating with PASSWORD_PROTECTED on free plan", async () => {+ const res = await connectRequest(+ "CreateStatusPage",+ {+ title: `${TEST_PREFIX}-limit-ws2-pw`,+ slug: `${TEST_PREFIX}-limit-ws2-pw-slug`,+ accessType: "PAGE_ACCESS_TYPE_PASSWORD_PROTECTED",+ password: "secret",+ },+ { "x-openstatus-key": "2" },+ );++ expect(res.status).toBe(403);+ });++ test("returns 403 when creating with AUTHENTICATED on free plan", async () => {+ const res = await connectRequest(+ "CreateStatusPage",+ {+ title: `${TEST_PREFIX}-limit-ws2-auth`,+ slug: `${TEST_PREFIX}-limit-ws2-auth-slug`,+ accessType: "PAGE_ACCESS_TYPE_AUTHENTICATED",+ authEmailDomains: ["example.com"],+ },+ { "x-openstatus-key": "2" },+ );++ expect(res.status).toBe(403);+ });++ test("returns 403 when updating with custom_domain on free plan", async () => {+ const ws2Page = await db+ .insert(page)+ .values({+ workspaceId: 2,+ title: `${TEST_PREFIX}-limit-update-ws2`,+ slug: `${TEST_PREFIX}-limit-update-ws2-slug`,+ description: "Free plan page",+ customDomain: "",+ })+ .returning()+ .get();+ ws2PageId = ws2Page.id;++ const res = await connectRequest(+ "UpdateStatusPage",+ {+ id: String(ws2PageId),+ customDomain: "status.freeplan.com",+ },+ { "x-openstatus-key": "2" },+ );++ expect(res.status).toBe(403);+ });++ test("returns 403 when updating with PASSWORD_PROTECTED on free plan", async () => {+ const res = await connectRequest(+ "UpdateStatusPage",+ {+ id: String(ws2PageId),+ accessType: "PAGE_ACCESS_TYPE_PASSWORD_PROTECTED",+ password: "secret",+ },+ { "x-openstatus-key": "2" },+ );++ expect(res.status).toBe(403);+ });++ test("returns 403 when updating with AUTHENTICATED on free plan", async () => {+ const res = await connectRequest(+ "UpdateStatusPage",+ {+ id: String(ws2PageId),+ accessType: "PAGE_ACCESS_TYPE_AUTHENTICATED",+ authEmailDomains: ["example.com"],+ },+ { "x-openstatus-key": "2" },+ );++ expect(res.status).toBe(403);++ await db.delete(page).where(eq(page.id, ws2PageId));+ });+});++describe("StatusPageService — new fields in read responses", () => {+ test("GetStatusPage returns password and auth_email_domains", async () => {+ const res = await connectRequest(+ "GetStatusPage",+ { id: String(testPasswordPageId) },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(200);+ const data = await res.json();+ expect(data.statusPage.password).toBe("test-secret-123");+ expect(data.statusPage.icon).toBe("https://example.com/icon.png");+ });++ test("GetStatusPageContent by slug does NOT return password", async () => {+ // Temporarily set to public so slug access works (validatePublicAccess requires public)+ await db+ .update(page)+ .set({ accessType: "public" })+ .where(eq(page.id, testPasswordPageId));++ const res = await connectRequest(+ "GetStatusPageContent",+ { slug: testPasswordPageSlug },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(200);+ const data = await res.json();+ expect(data.statusPage.password ?? "").toBe("");+ expect(data.statusPage.icon).toBe("https://example.com/icon.png");++ // Restore+ await db+ .update(page)+ .set({ accessType: "password" })+ .where(eq(page.id, testPasswordPageId));+ });++ test("GetStatusPageContent by ID returns password", async () => {+ const res = await connectRequest(+ "GetStatusPageContent",+ { id: String(testPasswordPageId) },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(200);+ const data = await res.json();+ expect(data.statusPage.password).toBe("test-secret-123");+ });++ test("GetStatusPageContent by slug redacts authEmailDomains", async () => {+ // Set page to public with stale authEmailDomains+ await db+ .update(page)+ .set({+ accessType: "public",+ authEmailDomains: "stale.com,leftover.com",+ password: null,+ })+ .where(eq(page.id, testPasswordPageId));++ const res = await connectRequest(+ "GetStatusPageContent",+ { slug: testPasswordPageSlug },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(200);+ const data = await res.json();+ expect(data.statusPage.authEmailDomains ?? []).toEqual([]);++ // Restore+ await db+ .update(page)+ .set({+ accessType: "password",+ password: "test-secret-123",+ authEmailDomains: null,+ })+ .where(eq(page.id, testPasswordPageId));+ });+});++// ==========================================================================+// Code review fixes: validation edge cases+// ==========================================================================++describe("StatusPageService — password trimming", () => {+ test("create with whitespace-only password returns 400", async () => {+ const res = await connectRequest(+ "CreateStatusPage",+ {+ title: `${TEST_PREFIX}-ws-pw`,+ slug: `${TEST_PREFIX}-ws-pw-slug`,+ accessType: "PAGE_ACCESS_TYPE_PASSWORD_PROTECTED",+ password: " ",+ },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(400);+ const data = await res.json();+ expect(data.message).toContain("Password is required");+ });++ test("update with whitespace-only password returns 400", async () => {+ const res = await connectRequest(+ "UpdateStatusPage",+ {+ id: String(testPasswordPageId),+ accessType: "PAGE_ACCESS_TYPE_PASSWORD_PROTECTED",+ password: " ",+ },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(400);+ const data = await res.json();+ expect(data.message).toContain("Password is required");+ });+});++describe("StatusPageService — email domain validation", () => {+ test("create with whitespace-only domain returns 400", async () => {+ const res = await connectRequest(+ "CreateStatusPage",+ {+ title: `${TEST_PREFIX}-ws-domain`,+ slug: `${TEST_PREFIX}-ws-domain-slug`,+ accessType: "PAGE_ACCESS_TYPE_AUTHENTICATED",+ authEmailDomains: [" "],+ },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(400);+ const data = await res.json();+ expect(data.message).toContain("email domain");+ });++ test("create with domain missing dot returns 400", async () => {+ const res = await connectRequest(+ "CreateStatusPage",+ {+ title: `${TEST_PREFIX}-nodot-domain`,+ slug: `${TEST_PREFIX}-nodot-domain-slug`,+ accessType: "PAGE_ACCESS_TYPE_AUTHENTICATED",+ authEmailDomains: ["nodot"],+ },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(400);+ const data = await res.json();+ expect(data.message).toContain("Invalid email domain");+ });++ test("create trims domain whitespace", async () => {+ const res = await connectRequest(+ "CreateStatusPage",+ {+ title: `${TEST_PREFIX}-trim-domain`,+ slug: `${TEST_PREFIX}-trim-domain-slug`,+ accessType: "PAGE_ACCESS_TYPE_AUTHENTICATED",+ authEmailDomains: [" example.com "],+ },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(200);+ const data = await res.json();+ expect(data.statusPage.authEmailDomains).toEqual(["example.com"]);++ await db.delete(page).where(eq(page.id, Number(data.statusPage.id)));+ });+});++describe("StatusPageService — password-only update without accessType", () => {+ test("sending password without accessType does not update password", async () => {+ const res = await connectRequest(+ "UpdateStatusPage",+ {+ id: String(testPasswordPageId),+ password: "new-password-attempt",+ },+ { "x-openstatus-key": "1" },+ );++ expect(res.status).toBe(200);+ const data = await res.json();+ expect(data.statusPage.password).toBe("test-secret-123");+ });+});diff --git a/apps/server/src/routes/rpc/services/status-page/converters.ts b/apps/server/src/routes/rpc/services/status-page/converters.tsindex a61c3de34..076e93cd0 100644--- a/apps/server/src/routes/rpc/services/status-page/converters.ts+++ b/apps/server/src/routes/rpc/services/status-page/converters.ts@@ -29,6 +29,8 @@ type DBPage = {homepageUrl: string | null;contactUrl: string | null;icon: string | null;+ password: string | null;+ authEmailDomains: string | null;defaultLocale: Locale;locales: Locale[] | null;createdAt: Date | null;@@ -220,6 +222,8 @@ export function dbPageToProto(page: DBPage): StatusPage {updatedAt: page.updatedAt?.toISOString() ?? "",defaultLocale: dbLocaleToProto(page.defaultLocale),locales: page.locales?.map(dbLocaleToProto) ?? [],+ password: page.password ?? "",+ authEmailDomains: page.authEmailDomains?.split(",").filter(Boolean) ?? [],};}diff --git a/apps/server/src/routes/rpc/services/status-page/errors.ts b/apps/server/src/routes/rpc/services/status-page/errors.tsindex 9fce592a5..02a5c9a07 100644--- a/apps/server/src/routes/rpc/services/status-page/errors.ts+++ b/apps/server/src/routes/rpc/services/status-page/errors.ts@@ -21,6 +21,10 @@ export const ErrorReason = {SUBSCRIBER_NOT_FOUND: "SUBSCRIBER_NOT_FOUND",SUBSCRIBER_CREATE_FAILED: "SUBSCRIBER_CREATE_FAILED",IDENTIFIER_REQUIRED: "IDENTIFIER_REQUIRED",+ INVALID_CUSTOM_DOMAIN: "INVALID_CUSTOM_DOMAIN",+ INVALID_ICON_URL: "INVALID_ICON_URL",+ PASSWORD_REQUIRED: "PASSWORD_REQUIRED",+ AUTH_EMAIL_DOMAINS_REQUIRED: "AUTH_EMAIL_DOMAINS_REQUIRED",} as const;export type ErrorReason = (typeof ErrorReason)[keyof typeof ErrorReason];@@ -254,3 +258,36 @@ export function identifierRequiredError(): ConnectError {ErrorReason.IDENTIFIER_REQUIRED,);}++export function invalidCustomDomainError(domain: string): ConnectError {+ return createError(+ "Custom domain must not contain 'openstatus' or start with http://, https://, or www.",+ Code.InvalidArgument,+ ErrorReason.INVALID_CUSTOM_DOMAIN,+ { "custom-domain": domain },+ );+}++export function invalidIconUrlError(): ConnectError {+ return createError(+ "Icon must be a valid URL",+ Code.InvalidArgument,+ ErrorReason.INVALID_ICON_URL,+ );+}++export function passwordRequiredError(): ConnectError {+ return createError(+ "Password is required when access_type is PASSWORD_PROTECTED",+ Code.InvalidArgument,+ ErrorReason.PASSWORD_REQUIRED,+ );+}++export function authEmailDomainsRequiredError(): ConnectError {+ return createError(+ "At least one email domain is required when access_type is AUTHENTICATED",+ Code.InvalidArgument,+ ErrorReason.AUTH_EMAIL_DOMAINS_REQUIRED,+ );+}diff --git a/apps/server/src/routes/rpc/services/status-page/index.ts b/apps/server/src/routes/rpc/services/status-page/index.tsindex 80d075d3c..9ec68d7f4 100644--- a/apps/server/src/routes/rpc/services/status-page/index.ts+++ b/apps/server/src/routes/rpc/services/status-page/index.ts@@ -23,7 +23,10 @@ import {statusReportsToPageComponents,} from "@openstatus/db/src/schema";import type { StatusPageService } from "@openstatus/proto/status_page/v1";-import { OverallStatus } from "@openstatus/proto/status_page/v1";+import {+ OverallStatus,+ PageAccessType,+} from "@openstatus/proto/status_page/v1";import { nanoid } from "nanoid";import { getRpcContext } from "../../interceptors";@@ -33,17 +36,23 @@ import {dbPageToProto,dbPageToProtoSummary,dbSubscriberToProto,+ protoAccessTypeToDb,protoLocaleToDb,+ protoThemeToDb,} from "./converters";import {+ authEmailDomainsRequiredError,componentGroupCreateFailedError,componentGroupNotFoundError,componentGroupUpdateFailedError,identifierRequiredError,+ invalidCustomDomainError,+ invalidIconUrlError,monitorNotFoundError,pageComponentCreateFailedError,pageComponentNotFoundError,pageComponentUpdateFailedError,+ passwordRequiredError,slugAlreadyExistsError,statusPageAccessDeniedError,statusPageCreateFailedError,@@ -54,7 +63,13 @@ import {subscriberCreateFailedError,subscriberNotFoundError,} from "./errors";-import { checkPageComponentLimits, checkStatusPageLimits } from "./limits";+import {+ checkCustomDomainLimit,+ checkEmailDomainProtectionLimit,+ checkPageComponentLimits,+ checkPasswordProtectionLimit,+ checkStatusPageLimits,+} from "./limits";/*** Helper to get a status page by ID with workspace scope.@@ -96,6 +111,46 @@ function validatePublicAccess(}}+function validateIconUrl(icon: string): void {+ let url: URL;+ try {+ url = new URL(icon);+ } catch {+ throw invalidIconUrlError();+ }+ if (url.protocol !== "https:") {+ throw invalidIconUrlError();+ }+}++function validateCustomDomain(domain: string): void {+ const lower = domain.toLowerCase();+ if (+ lower.includes("openstatus") ||+ lower.startsWith("http://") ||+ lower.startsWith("https://") ||+ lower.startsWith("www.")+ ) {+ throw invalidCustomDomainError(domain);+ }+}++function validateAuthEmailDomains(domains: string[]): string[] {+ const trimmed = domains.map((d) => d.trim()).filter(Boolean);+ if (trimmed.length === 0) {+ throw authEmailDomainsRequiredError();+ }+ for (const domain of trimmed) {+ if (!domain.includes(".")) {+ throw new ConnectError(+ `Invalid email domain: "${domain}"`,+ Code.InvalidArgument,+ );+ }+ }+ return trimmed;+}+/*** Helper to get a component by ID with workspace scope.*/@@ -193,6 +248,50 @@ export const statusPageServiceImpl: ServiceImpl<typeof StatusPageService> = {);}+ // Validate icon URL+ const icon = req.icon ?? "";+ if (icon) {+ validateIconUrl(icon);+ }++ // Validate custom domain+ const customDomain = req.customDomain ?? "";+ if (customDomain) {+ checkCustomDomainLimit(limits);+ validateCustomDomain(customDomain);+ }++ // Resolve theme+ const forceTheme =+ req.theme !== undefined && req.theme !== 0+ ? protoThemeToDb(req.theme)+ : "system";++ // Resolve access type and associated fields+ const reqAccessType = req.accessType;+ const hasAccessType = reqAccessType !== undefined && reqAccessType !== 0;+ const accessType = hasAccessType+ ? protoAccessTypeToDb(reqAccessType)+ : "public";++ let password: string | null = null;+ let authEmailDomains: string | null = null;++ if (hasAccessType) {+ if (reqAccessType === PageAccessType.PASSWORD_PROTECTED) {+ checkPasswordProtectionLimit(limits);+ const trimmedPassword = req.password?.trim() ?? "";+ if (!trimmedPassword) {+ throw passwordRequiredError();+ }+ password = trimmedPassword;+ } else if (reqAccessType === PageAccessType.AUTHENTICATED) {+ checkEmailDomainProtectionLimit(limits);+ const validatedDomains = validateAuthEmailDomains(req.authEmailDomains);+ authEmailDomains = validatedDomains.join(",");+ }+ }+// Create the status pageconst newPage = await db.insert(page)@@ -201,8 +300,13 @@ export const statusPageServiceImpl: ServiceImpl<typeof StatusPageService> = {title: req.title,description: req.description ?? "",slug: req.slug,- customDomain: "",+ customDomain,published: false,+ icon,+ forceTheme,+ accessType,+ password,+ authEmailDomains,homepageUrl: req.homepageUrl ?? null,contactUrl: req.contactUrl ?? null,defaultLocale,@@ -353,6 +457,53 @@ export const statusPageServiceImpl: ServiceImpl<typeof StatusPageService> = {);}+ // Handle icon+ if (req.icon !== undefined) {+ if (req.icon) {+ validateIconUrl(req.icon);+ }+ updateValues.icon = req.icon;+ }++ // Handle custom domain+ if (req.customDomain !== undefined) {+ if (req.customDomain) {+ checkCustomDomainLimit(limits);+ validateCustomDomain(req.customDomain);+ }+ updateValues.customDomain = req.customDomain;+ }++ // Handle theme+ if (req.theme !== undefined && req.theme !== 0) {+ updateValues.forceTheme = protoThemeToDb(req.theme);+ }++ // Handle access type (password and authEmailDomains only written when accessType is present)+ const reqAccessType = req.accessType;+ const hasAccessType = reqAccessType !== undefined && reqAccessType !== 0;+ if (hasAccessType) {+ if (reqAccessType === PageAccessType.PASSWORD_PROTECTED) {+ checkPasswordProtectionLimit(limits);+ const trimmedPassword = req.password?.trim() ?? "";+ if (!trimmedPassword) {+ throw passwordRequiredError();+ }+ updateValues.password = trimmedPassword;+ updateValues.authEmailDomains = null;+ } else if (reqAccessType === PageAccessType.AUTHENTICATED) {+ checkEmailDomainProtectionLimit(limits);+ const validatedDomains = validateAuthEmailDomains(req.authEmailDomains);+ updateValues.authEmailDomains = validatedDomains.join(",");+ updateValues.password = null;+ } else {+ // Switching to PUBLIC or other — clear stale data+ updateValues.password = null;+ updateValues.authEmailDomains = null;+ }+ updateValues.accessType = protoAccessTypeToDb(reqAccessType);+ }+const updatedPage = await db.update(page).set(updateValues)@@ -1023,8 +1174,14 @@ export const statusPageServiceImpl: ServiceImpl<typeof StatusPageService> = {};});+ const statusPage = dbPageToProto(pageData);+ if (isPublicAccess) {+ statusPage.password = "";+ statusPage.authEmailDomains = [];+ }+return {- statusPage: dbPageToProto(pageData),+ statusPage,components: components.map(dbComponentToProto),groups: groups.map(dbGroupToProto),statusReports,diff --git a/packages/db/src/seed.mts b/packages/db/src/seed.mtsindex ac88426e5..933b66c0a 100644--- a/packages/db/src/seed.mts+++ b/packages/db/src/seed.mts@@ -39,7 +39,7 @@ async function main() {endsAt: null,paidUntil: null,limits:- '{"monitors":50,"synthetic-checks":150000,"periodicity":["30s","1m","5m","10m","30m","1h"],"multi-region":true,"max-regions":35,"data-retention":"24 months","status-pages":20,"maintenance":true,"status-subscribers":true,"custom-domain":true,"password-protection":true,"white-label":true,"notifications":true,"sms":true,"pagerduty":true,"notification-channels":50,"members":"Unlimited","audit-log":true,"regions":["ams","arn","atl","bog","bom","bos","cdg","den","dfw","ewr","eze","fra","gdl","gig","gru","hkg","iad","jnb","lax","lhr","mad","mia","nrt","ord","otp","phx","qro","scl","sea","sin","sjc","syd","waw","yul","yyz"]}',+ '{"monitors":50,"synthetic-checks":150000,"periodicity":["30s","1m","5m","10m","30m","1h"],"multi-region":true,"max-regions":35,"data-retention":"24 months","status-pages":20,"maintenance":true,"status-subscribers":true,"custom-domain":true,"password-protection":true,"email-domain-protection":true,"white-label":true,"notifications":true,"sms":true,"pagerduty":true,"notification-channels":50,"members":"Unlimited","audit-log":true,"regions":["ams","arn","atl","bog","bom","bos","cdg","den","dfw","ewr","eze","fra","gdl","gig","gru","hkg","iad","jnb","lax","lhr","mad","mia","nrt","ord","otp","phx","qro","scl","sea","sin","sjc","syd","waw","yul","yyz"]}',},{id: 2,diff --git a/packages/proto/api/openstatus/status_page/v1/service.proto b/packages/proto/api/openstatus/status_page/v1/service.protoindex 4bfd86cfd..48dfb0b8a 100644--- a/packages/proto/api/openstatus/status_page/v1/service.proto+++ b/packages/proto/api/openstatus/status_page/v1/service.proto@@ -124,6 +124,27 @@ message CreateStatusPageRequest {// Enabled locales for the status page (optional).repeated Locale locales = 7;++ // Icon URL for the status page (optional).+ optional string icon = 8 [(buf.validate.field).string.max_len = 1024];++ // Custom domain for the status page (optional).+ optional string custom_domain = 9 [(buf.validate.field).string.max_len = 256];++ // Visual theme for the status page (optional, defaults to SYSTEM).+ optional PageTheme theme = 10;++ // Access type for the status page (optional, defaults to PUBLIC).+ optional PageAccessType access_type = 11;++ // Password for the status page (required when access_type is PASSWORD_PROTECTED).+ optional string password = 12 [(buf.validate.field).string = {+ min_len: 1+ max_len: 256+ }];++ // Email domains allowed to access the page (used when access_type is AUTHENTICATED).+ repeated string auth_email_domains = 13;}// CreateStatusPageResponse is the response after creating a status page.@@ -197,6 +218,27 @@ message UpdateStatusPageRequest {// New enabled locales for the status page (optional).repeated Locale locales = 8;++ // New icon URL for the status page (optional).+ optional string icon = 9 [(buf.validate.field).string.max_len = 1024];++ // New custom domain (optional).+ optional string custom_domain = 10 [(buf.validate.field).string.max_len = 256];++ // New visual theme (optional).+ optional PageTheme theme = 11;++ // New access type (optional).+ optional PageAccessType access_type = 12;++ // New password (optional, required when access_type is PASSWORD_PROTECTED).+ optional string password = 13 [(buf.validate.field).string = {+ min_len: 1+ max_len: 256+ }];++ // New email domains (optional, required when access_type is AUTHENTICATED).+ repeated string auth_email_domains = 14;}// UpdateStatusPageResponse is the response after updating a status page.diff --git a/packages/proto/api/openstatus/status_page/v1/status_page.proto b/packages/proto/api/openstatus/status_page/v1/status_page.protoindex 997749fbb..9d8f84564 100644--- a/packages/proto/api/openstatus/status_page/v1/status_page.proto+++ b/packages/proto/api/openstatus/status_page/v1/status_page.proto@@ -96,6 +96,12 @@ message StatusPage {// Enabled locales for the status page.repeated Locale locales = 15;++ // Password for the status page (only set when access_type is PASSWORD_PROTECTED).+ string password = 16;++ // Email domains allowed to access the page (only set when access_type is AUTHENTICATED).+ repeated string auth_email_domains = 17;}// StatusPageSummary represents metadata for a status page (used in list responses).diff --git a/packages/proto/gen/ts/openstatus/status_page/v1/service_pb.ts b/packages/proto/gen/ts/openstatus/status_page/v1/service_pb.tsindex ec172329a..8168ed6e1 100644--- a/packages/proto/gen/ts/openstatus/status_page/v1/service_pb.ts+++ b/packages/proto/gen/ts/openstatus/status_page/v1/service_pb.ts@@ -12,7 +12,7 @@ import type { PageComponent, PageComponentGroup } from "./page_component_pb.ts";import { file_openstatus_status_page_v1_page_component } from "./page_component_pb.ts";import type { PageSubscriber } from "./page_subscriber_pb.ts";import { file_openstatus_status_page_v1_page_subscriber } from "./page_subscriber_pb.ts";-import type { Locale, OverallStatus, StatusPage, StatusPageSummary } from "./status_page_pb.ts";+import type { Locale, OverallStatus, PageAccessType, PageTheme, StatusPage, StatusPageSummary } from "./status_page_pb.ts";import { file_openstatus_status_page_v1_status_page } from "./status_page_pb.ts";import type { StatusReport } from "../../status_report/v1/status_report_pb.ts";import { file_openstatus_status_report_v1_status_report } from "../../status_report/v1/status_report_pb.ts";@@ -22,7 +22,7 @@ import type { Message } from "@bufbuild/protobuf";* Describes the file openstatus/status_page/v1/service.proto.*/export const file_openstatus_status_page_v1_service: GenFile = /*@__PURE__*/- fileDesc("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", [file_buf_validate_validate, file_gnostic_openapi_v3_annotations, file_openstatus_maintenance_v1_maintenance, file_openstatus_status_page_v1_page_component, file_openstatus_status_page_v1_page_subscriber, file_openstatus_status_page_v1_status_page, file_openstatus_status_report_v1_status_report]);+ fileDesc("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", [file_buf_validate_validate, file_gnostic_openapi_v3_annotations, file_openstatus_maintenance_v1_maintenance, file_openstatus_status_page_v1_page_component, file_openstatus_status_page_v1_page_subscriber, file_openstatus_status_page_v1_status_page, file_openstatus_status_report_v1_status_report]);/*** CreateStatusPageRequest is the request to create a new status page.@@ -78,6 +78,48 @@ export type CreateStatusPageRequest = Message<"openstatus.status_page.v1.CreateS* @generated from field: repeated openstatus.status_page.v1.Locale locales = 7;*/locales: Locale[];++ /**+ * Icon URL for the status page (optional).+ *+ * @generated from field: optional string icon = 8;+ */+ icon?: string;++ /**+ * Custom domain for the status page (optional).+ *+ * @generated from field: optional string custom_domain = 9;+ */+ customDomain?: string;++ /**+ * Visual theme for the status page (optional, defaults to SYSTEM).+ *+ * @generated from field: optional openstatus.status_page.v1.PageTheme theme = 10;+ */+ theme?: PageTheme;++ /**+ * Access type for the status page (optional, defaults to PUBLIC).+ *+ * @generated from field: optional openstatus.status_page.v1.PageAccessType access_type = 11;+ */+ accessType?: PageAccessType;++ /**+ * Password for the status page (required when access_type is PASSWORD_PROTECTED).+ *+ * @generated from field: optional string password = 12;+ */+ password?: string;++ /**+ * Email domains allowed to access the page (used when access_type is AUTHENTICATED).+ *+ * @generated from field: repeated string auth_email_domains = 13;+ */+ authEmailDomains: string[];};/**@@ -267,6 +309,48 @@ export type UpdateStatusPageRequest = Message<"openstatus.status_page.v1.UpdateS* @generated from field: repeated openstatus.status_page.v1.Locale locales = 8;*/locales: Locale[];++ /**+ * New icon URL for the status page (optional).+ *+ * @generated from field: optional string icon = 9;+ */+ icon?: string;++ /**+ * New custom domain (optional).+ *+ * @generated from field: optional string custom_domain = 10;+ */+ customDomain?: string;++ /**+ * New visual theme (optional).+ *+ * @generated from field: optional openstatus.status_page.v1.PageTheme theme = 11;+ */+ theme?: PageTheme;++ /**+ * New access type (optional).+ *+ * @generated from field: optional openstatus.status_page.v1.PageAccessType access_type = 12;+ */+ accessType?: PageAccessType;++ /**+ * New password (optional, required when access_type is PASSWORD_PROTECTED).+ *+ * @generated from field: optional string password = 13;+ */+ password?: string;++ /**+ * New email domains (optional, required when access_type is AUTHENTICATED).+ *+ * @generated from field: repeated string auth_email_domains = 14;+ */+ authEmailDomains: string[];};/**diff --git a/packages/proto/gen/ts/openstatus/status_page/v1/status_page_pb.ts b/packages/proto/gen/ts/openstatus/status_page/v1/status_page_pb.tsindex 66db9c289..3adbba0eb 100644--- a/packages/proto/gen/ts/openstatus/status_page/v1/status_page_pb.ts+++ b/packages/proto/gen/ts/openstatus/status_page/v1/status_page_pb.ts@@ -11,7 +11,7 @@ import type { Message } from "@bufbuild/protobuf";* Describes the file openstatus/status_page/v1/status_page.proto.*/export const file_openstatus_status_page_v1_status_page: GenFile = /*@__PURE__*/- fileDesc("CitvcGVuc3RhdHVzL3N0YXR1c19wYWdlL3YxL3N0YXR1c19wYWdlLnByb3RvEhlvcGVuc3RhdHVzLnN0YXR1c19wYWdlLnYxIqAECgpTdGF0dXNQYWdlEgoKAmlkGAEgASgJEg0KBXRpdGxlGAIgASgJEhMKC2Rlc2NyaXB0aW9uGAMgASgJEh4KBHNsdWcYBCABKAlCELpHDToLEglhY21lLWNvcnASMAoNY3VzdG9tX2RvbWFpbhgFIAEoCUIZukcWOhQSEnN0YXR1cy5leGFtcGxlLmNvbRIRCglwdWJsaXNoZWQYBiABKAgSPgoLYWNjZXNzX3R5cGUYByABKA4yKS5vcGVuc3RhdHVzLnN0YXR1c19wYWdlLnYxLlBhZ2VBY2Nlc3NUeXBlEjMKBXRoZW1lGAggASgOMiQub3BlbnN0YXR1cy5zdGF0dXNfcGFnZS52MS5QYWdlVGhlbWUSFAoMaG9tZXBhZ2VfdXJsGAkgASgJEhMKC2NvbnRhY3RfdXJsGAogASgJEgwKBGljb24YCyABKAkSLwoKY3JlYXRlZF9hdBgMIAEoCUIbukcYOhYSFDIwMjQtMDEtMTVUMDk6MDA6MDBaEi8KCnVwZGF0ZWRfYXQYDSABKAlCG7pHGDoWEhQyMDI0LTA2LTIwVDE0OjMwOjAwWhI5Cg5kZWZhdWx0X2xvY2FsZRgOIAEoDjIhLm9wZW5zdGF0dXMuc3RhdHVzX3BhZ2UudjEuTG9jYWxlEjIKB2xvY2FsZXMYDyADKA4yIS5vcGVuc3RhdHVzLnN0YXR1c19wYWdlLnYxLkxvY2FsZSKpAQoRU3RhdHVzUGFnZVN1bW1hcnkSCgoCaWQYASABKAkSDQoFdGl0bGUYAiABKAkSDAoEc2x1ZxgDIAEoCRIRCglwdWJsaXNoZWQYBCABKAgSEgoKY3JlYXRlZF9hdBgFIAEoCRISCgp1cGRhdGVkX2F0GAYgASgJEjAKDWN1c3RvbV9kb21haW4YByABKAlCGbpHFjoUEhJzdGF0dXMuZXhhbXBsZS5jb20qnAEKDlBhZ2VBY2Nlc3NUeXBlEiAKHFBBR0VfQUNDRVNTX1RZUEVfVU5TUEVDSUZJRUQQABIbChdQQUdFX0FDQ0VTU19UWVBFX1BVQkxJQxABEicKI1BBR0VfQUNDRVNTX1RZUEVfUEFTU1dPUkRfUFJPVEVDVEVEEAISIgoeUEFHRV9BQ0NFU1NfVFlQRV9BVVRIRU5USUNBVEVEEAMqaQoJUGFnZVRoZW1lEhoKFlBBR0VfVEhFTUVfVU5TUEVDSUZJRUQQABIVChFQQUdFX1RIRU1FX1NZU1RFTRABEhQKEFBBR0VfVEhFTUVfTElHSFQQAhITCg9QQUdFX1RIRU1FX0RBUksQAypNCgZMb2NhbGUSFgoSTE9DQUxFX1VOU1BFQ0lGSUVEEAASDQoJTE9DQUxFX0VOEAESDQoJTE9DQUxFX0ZSEAISDQoJTE9DQUxFX0RFEAMq7AEKDU92ZXJhbGxTdGF0dXMSHgoaT1ZFUkFMTF9TVEFUVVNfVU5TUEVDSUZJRUQQABIeChpPVkVSQUxMX1NUQVRVU19PUEVSQVRJT05BTBABEhsKF09WRVJBTExfU1RBVFVTX0RFR1JBREVEEAISIQodT1ZFUkFMTF9TVEFUVVNfUEFSVElBTF9PVVRBR0UQAxIfChtPVkVSQUxMX1NUQVRVU19NQUpPUl9PVVRBR0UQBBIeChpPVkVSQUxMX1NUQVRVU19NQUlOVEVOQU5DRRAFEhoKFk9WRVJBTExfU1RBVFVTX1VOS05PV04QBkJaWlhnaXRodWIuY29tL29wZW5zdGF0dXNocS9vcGVuc3RhdHVzL3BhY2thZ2VzL3Byb3RvL29wZW5zdGF0dXMvc3RhdHVzX3BhZ2UvdjE7c3RhdHVzcGFnZXYxYgZwcm90bzM", [file_gnostic_openapi_v3_annotations]);+ fileDesc("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", [file_gnostic_openapi_v3_annotations]);/*** StatusPage represents a full status page with all details.@@ -123,6 +123,20 @@ export type StatusPage = Message<"openstatus.status_page.v1.StatusPage"> & {* @generated from field: repeated openstatus.status_page.v1.Locale locales = 15;*/locales: Locale[];++ /**+ * Password for the status page (only set when access_type is PASSWORD_PROTECTED).+ *+ * @generated from field: string password = 16;+ */+ password: string;++ /**+ * Email domains allowed to access the page (only set when access_type is AUTHENTICATED).+ *+ * @generated from field: repeated string auth_email_domains = 17;+ */+ authEmailDomains: string[];};/**