@oneuptime/common 11.5.7 → 11.5.9

package/Server/Infrastructure/Postgres/SchemaMigrations/1784105912819-BackfillCodeFixTaskType.ts

@@ -0,0 +1,41 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class BackfillCodeFixTaskType1784105912819
+  implements MigrationInterface
+{
+  public name = "BackfillCodeFixTaskType1784105912819";
+
+  /*
+   * A null AIRun.codeFixTaskType on a CodeFix run has always MEANT
+   * FixException: every code-fix run created before task recipes existed was
+   * an exception fix, and both the server's read path
+   * (CodeFixTaskTypeHelper.fromDatabaseValue) and the dashboard normalize the
+   * null to FixException so nobody ever sees it.
+   *
+   * That normalization only covers reads. Now that the AI Tasks list filters
+   * through the standard CRUD, a "Fix Exception" filter compiles to
+   * `codeFixTaskType IN ('FixException')`, which NULL never matches — the
+   * oldest runs would silently vanish from the filtered list. The bespoke
+   * endpoint papered over this with an equalToOrNull query it built itself;
+   * that endpoint is gone, so the meaning gets written into the data instead.
+   *
+   * Scoped to runType = 'CodeFix': codeFixTaskType is meaningless on chat and
+   * investigation runs and must stay null there.
+   */
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `UPDATE "AIRun" SET "codeFixTaskType" = 'FixException' WHERE "runType" = 'CodeFix' AND "codeFixTaskType" IS NULL`,
+    );
+  }
+
+  /*
+   * Deliberately a no-op. The rows this set are indistinguishable from rows
+   * that already said FixException, so nulling them back would corrupt data
+   * this migration never touched. Reverting is also unnecessary: the read path
+   * still normalizes null to FixException, so an older build reads these rows
+   * exactly as it did before.
+   */
+  public async down(_queryRunner: QueryRunner): Promise<void> {
+    return;
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1784124919694-AddAITaskNumberAndRunTranscript.ts

@@ -0,0 +1,95 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/*
+ * Two additions, both in service of debugging a code-fix run that went wrong.
+ *
+ * 1. AIRun.taskNumber + Project.aiRunCounter — the per-project "#42" handle,
+ *    allocated exactly like Incident.incidentNumber (ProjectService holds the
+ *    counter behind a Redis semaphore; see incrementAndGetAIRunCounter).
+ * 2. AIRunEvent.contentPayload — the verbatim prompt/response/tool transcript.
+ *
+ * The DDL here was produced by `npm run generate-postgres-migration`. Two
+ * unrelated OnCallDutyPolicyScheduleLayer default changes the generator also
+ * emitted (pre-existing whitespace drift between the entity defaults and the
+ * local schema) were dropped: they are not part of this change.
+ *
+ * The backfill rides along in the same migration rather than a follow-up so
+ * there is no window in which existing tasks are on-screen with a blank
+ * number.
+ */
+export class AddAITaskNumberAndRunTranscript1784124919694
+  implements MigrationInterface
+{
+  public name: string = "AddAITaskNumberAndRunTranscript1784124919694";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "Project" ADD "aiRunCounter" integer NOT NULL DEFAULT '0'`,
+    );
+    await queryRunner.query(`ALTER TABLE "AIRun" ADD "taskNumber" integer`);
+    await queryRunner.query(
+      `ALTER TABLE "AIRunEvent" ADD "contentPayload" jsonb`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_ede30aa8b14a167586bd555fa9" ON "AIRun" ("taskNumber") `,
+    );
+
+    /*
+     * Number the tasks that already exist, oldest first, per project — so the
+     * list does not read "#1, -, -, #2" the day this ships. Scoped to
+     * runType = 'CodeFix' because only code-fix runs are tasks; chat and
+     * investigation runs share this table and must stay null.
+     *
+     * Soft-deleted rows are numbered too. Not to prevent reuse (a skipped row
+     * would hold no number to reuse) but to keep the sequence a stable
+     * function of creation order: a run that is soft-deleted later must not
+     * renumber the runs after it, and an undeleted row must not collide with
+     * a number already handed out. The cost is gaps in what the list shows,
+     * which is the same thing incidents do.
+     */
+    await queryRunner.query(`
+      WITH numbered AS (
+        SELECT
+          "_id",
+          ROW_NUMBER() OVER (
+            PARTITION BY "projectId"
+            ORDER BY "createdAt" ASC, "_id" ASC
+          ) AS "rowNumber"
+        FROM "AIRun"
+        WHERE "runType" = 'CodeFix'
+      )
+      UPDATE "AIRun"
+      SET "taskNumber" = numbered."rowNumber"
+      FROM numbered
+      WHERE "AIRun"."_id" = numbered."_id"
+    `);
+
+    /*
+     * Advance each project's counter past what the backfill just handed out,
+     * so the next allocation continues the sequence instead of restarting at
+     * #1 and colliding. Projects with no code-fix runs keep the 0 default.
+     */
+    await queryRunner.query(`
+      UPDATE "Project"
+      SET "aiRunCounter" = "maxPerProject"."maxTaskNumber"
+      FROM (
+        SELECT "projectId", MAX("taskNumber") AS "maxTaskNumber"
+        FROM "AIRun"
+        WHERE "runType" = 'CodeFix' AND "taskNumber" IS NOT NULL
+        GROUP BY "projectId"
+      ) AS "maxPerProject"
+      WHERE "Project"."_id" = "maxPerProject"."projectId"
+    `);
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_ede30aa8b14a167586bd555fa9"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AIRunEvent" DROP COLUMN "contentPayload"`,
+    );
+    await queryRunner.query(`ALTER TABLE "AIRun" DROP COLUMN "taskNumber"`);
+    await queryRunner.query(`ALTER TABLE "Project" DROP COLUMN "aiRunCounter"`);
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1784135099754-AllowNullAiAgentOnPullRequest.ts

@@ -0,0 +1,52 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/*
+ * A pull request can now be proposed from an AI chat conversation, which has
+ * no AIAgent behind it (the AIAgent record belongs to the autonomous fix
+ * worker). aiAgentId becomes nullable so chat-authored PRs can be recorded at
+ * all — and recording them is what makes them count against the per-repository
+ * open-PR cap, which reads AIAgentTaskPullRequest rows.
+ *
+ * A null aiAgentId therefore means "proposed from chat". Existing rows all
+ * have an agent, so dropping NOT NULL needs no backfill and the down migration
+ * is safe until the first chat-authored PR exists.
+ */
+export class AllowNullAiAgentOnPullRequest1784135099754
+  implements MigrationInterface
+{
+  public name = "AllowNullAiAgentOnPullRequest1784135099754";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    /*
+     * The FK is dropped and re-added because Postgres will not alter a column's
+     * nullability while a foreign key references it. ON DELETE CASCADE is
+     * preserved exactly as it was.
+     */
+    await queryRunner.query(
+      `ALTER TABLE "AIAgentTaskPullRequest" DROP CONSTRAINT "FK_b1e01ecfe9eecfb555428471073"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AIAgentTaskPullRequest" ALTER COLUMN "aiAgentId" DROP NOT NULL`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AIAgentTaskPullRequest" ADD CONSTRAINT "FK_b1e01ecfe9eecfb555428471073" FOREIGN KEY ("aiAgentId") REFERENCES "AIAgent"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    /*
+     * Restoring NOT NULL fails if any chat-authored (null-agent) rows exist.
+     * That is deliberate: silently deleting or reassigning a customer's pull
+     * request records to satisfy a rollback would be worse than a loud failure.
+     */
+    await queryRunner.query(
+      `ALTER TABLE "AIAgentTaskPullRequest" DROP CONSTRAINT "FK_b1e01ecfe9eecfb555428471073"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AIAgentTaskPullRequest" ALTER COLUMN "aiAgentId" SET NOT NULL`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AIAgentTaskPullRequest" ADD CONSTRAINT "FK_b1e01ecfe9eecfb555428471073" FOREIGN KEY ("aiAgentId") REFERENCES "AIAgent"("_id") ON DELETE CASCADE ON UPDATE NO ACTION`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1784137457184-AddEnableMcpServerToStatusPage.ts

@@ -0,0 +1,30 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/*
+ * Status page owners can now stop AI agents from reading their status page over
+ * the public OneUptime MCP server. MCP access stays on unless it is turned off,
+ * so the column defaults to true.
+ *
+ * ADD COLUMN ... NOT NULL DEFAULT true populates every existing row with true in
+ * the same statement, so no backfill is needed and existing status pages keep
+ * working exactly as they do today. That is what makes the
+ * `enableMcpServer: true` predicate in StatusPageService.isMcpServerEnabled
+ * safe — there are no NULL rows for it to silently drop.
+ */
+export class AddEnableMcpServerToStatusPage1784137457184
+  implements MigrationInterface
+{
+  public name = "AddEnableMcpServerToStatusPage1784137457184";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "StatusPage" ADD "enableMcpServer" boolean NOT NULL DEFAULT true`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "StatusPage" DROP COLUMN "enableMcpServer"`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1784200000000-AddSnmpV3ColumnsToNetworkDeviceDiscoveryScan.ts

@@ -0,0 +1,49 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class AddSnmpV3ColumnsToNetworkDeviceDiscoveryScan1784200000000
+  implements MigrationInterface
+{
+  public name = "AddSnmpV3ColumnsToNetworkDeviceDiscoveryScan1784200000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" ADD "snmpV3SecurityLevel" character varying(100)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" ADD "snmpV3Username" character varying(100)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" ADD "snmpV3AuthProtocol" character varying(100)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" ADD "snmpV3AuthKey" text`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" ADD "snmpV3PrivProtocol" character varying(100)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" ADD "snmpV3PrivKey" text`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" DROP COLUMN "snmpV3PrivKey"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" DROP COLUMN "snmpV3PrivProtocol"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" DROP COLUMN "snmpV3AuthKey"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" DROP COLUMN "snmpV3AuthProtocol"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" DROP COLUMN "snmpV3Username"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "NetworkDeviceDiscoveryScan" DROP COLUMN "snmpV3SecurityLevel"`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/Index.ts

@@ -450,6 +450,11 @@ import { AddSentinelInsightFlags1784010274994 } from "./1784010274994-AddSentine
 import { RenameSentinelToAI1784030612266 } from "./1784030612266-RenameSentinelToAI";
 import { MigrationName1784033837629 } from "./1784033837629-MigrationName";
 import { AddCreatedByUserToUser1784048917994 } from "./1784048917994-AddCreatedByUserToUser";
+import { BackfillCodeFixTaskType1784105912819 } from "./1784105912819-BackfillCodeFixTaskType";
+import { AddAITaskNumberAndRunTranscript1784124919694 } from "./1784124919694-AddAITaskNumberAndRunTranscript";
+import { AllowNullAiAgentOnPullRequest1784135099754 } from "./1784135099754-AllowNullAiAgentOnPullRequest";
+import { AddEnableMcpServerToStatusPage1784137457184 } from "./1784137457184-AddEnableMcpServerToStatusPage";
+import { AddSnmpV3ColumnsToNetworkDeviceDiscoveryScan1784200000000 } from "./1784200000000-AddSnmpV3ColumnsToNetworkDeviceDiscoveryScan";
 
 export default [
   InitialMigration,
@@ -904,4 +909,9 @@ export default [
   RenameSentinelToAI1784030612266,
   MigrationName1784033837629,
   AddCreatedByUserToUser1784048917994,
+  BackfillCodeFixTaskType1784105912819,
+  AddAITaskNumberAndRunTranscript1784124919694,
+  AllowNullAiAgentOnPullRequest1784135099754,
+  AddEnableMcpServerToStatusPage1784137457184,
+  AddSnmpV3ColumnsToNetworkDeviceDiscoveryScan1784200000000,
 ];

package/Server/Middleware/MasterAdminAuthorization.ts

@@ -59,7 +59,7 @@ export default class MasterAdminAuthorization {
    * Same as isAuthorizedMasterAdminMiddleware, but ALSO accepts the instance-wide
    * master API key (Admin Dashboard → Settings → API Key) supplied in the
    * `apikey` header. The master key has root/master-admin access, so this lets
-   * automated callers reach the master-admin instance-health endpoints with the
+   * automated callers reach the master-admin OneUptime Health endpoints with the
    * key instead of a logged-in master-admin session.
    *
    * Deliberately scoped to the read-only health / diagnostics routes only. It is

package/Server/Middleware/ProjectAuthorization.ts

@@ -65,7 +65,7 @@ export default class ProjectMiddleware {
    * (Admin Dashboard → Settings → API Key) and that key is currently enabled.
    * The master key has root/master-admin access, so this is shared with
    * MasterAdminAuthorization to let the key reach master-admin-only endpoints
-   * (e.g. instance health) as well.
+   * (e.g. OneUptime Health) as well.
    */
   @CaptureSpan()
   public static async isMasterApiKey(apiKey: ObjectID): Promise<boolean> {

package/Server/Services/AIRunEventService.ts

@@ -2,13 +2,17 @@ import PositiveNumber from "../../Types/PositiveNumber";
 import ObjectID from "../../Types/ObjectID";
 import { JSONObject } from "../../Types/JSON";
 import AIRunEventType from "../../Types/AI/AIRunEventType";
-import { AIRunEventResultSummary } from "../../Types/AI/AIChatTypes";
+import {
+  AIRunEventContentPayload,
+  AIRunEventResultSummary,
+} from "../../Types/AI/AIChatTypes";
 import CountBy from "../Types/Database/CountBy";
 import FindBy from "../Types/Database/FindBy";
 import { OnFind } from "../Types/Database/Hooks";
 import DatabaseService from "./DatabaseService";
 import Model from "../../Models/DatabaseModels/AIRunEvent";
 import { pinQueryToRequestingUser } from "../Utils/AI/AIChatPrivacyFilter";
+import AIRunTranscript from "../Utils/AI/AIRunTranscript";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import logger from "../Utils/Logger";
 
@@ -36,6 +40,7 @@ export class Service extends DatabaseService<Model> {
     toolArguments?: JSONObject | undefined;
     resultSummary?: AIRunEventResultSummary | undefined;
     citationId?: string | undefined;
+    contentPayload?: AIRunEventContentPayload | undefined;
   }): Promise<void> {
     try {
       const sequence: number = (
@@ -63,6 +68,15 @@ export class Service extends DatabaseService<Model> {
       if (data.citationId) {
         event.citationId = data.citationId;
       }
+      /*
+       * Capped here rather than at the call sites, so no caller can write an
+       * unbounded transcript row by forgetting to clamp.
+       */
+      if (data.contentPayload) {
+        event.contentPayload = AIRunTranscript.clampPayload(
+          data.contentPayload,
+        );
+      }
 
       await this.create({
         data: event,

package/Server/Services/AIRunService.ts

@@ -12,12 +12,15 @@ import CodeFixTaskType, {
 import SortOrder from "../../Types/BaseDatabase/SortOrder";
 import QueryHelper from "../Types/Database/QueryHelper";
 import CountBy from "../Types/Database/CountBy";
+import CreateBy from "../Types/Database/CreateBy";
 import FindBy from "../Types/Database/FindBy";
-import { OnFind } from "../Types/Database/Hooks";
+import { OnCreate, OnFind } from "../Types/Database/Hooks";
 import DatabaseService from "./DatabaseService";
+import ProjectService from "./ProjectService";
 import Model from "../../Models/DatabaseModels/AIRun";
-import { pinQueryToRequestingUser } from "../Utils/AI/AIChatPrivacyFilter";
+import { applyAIRunPrivacyFilter } from "../Utils/AI/AIRunPrivacyFilter";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import logger from "../Utils/Logger";
 import { UpdateQueryBuilder, UpdateResult } from "typeorm";
 import { QueryDeepPartialEntity } from "typeorm/query-builder/QueryPartialEntity";
 
@@ -328,26 +331,59 @@ export class Service extends DatabaseService<Model> {
     return { runId: run.id, verdict: data.verdict };
   }
 
+  /*
+   * Stamp CodeFix runs with the project's next task number, so every AI task
+   * has the short human-citable handle "#42" that incidents and alerts have.
+   *
+   * CodeFix only, on purpose: chat turns and investigations share this table
+   * but are not tasks, and numbering them would advance the counter on every
+   * Ask-AI message — the AI Tasks list would then read #7, #31, #244.
+   *
+   * Best-effort. The counter needs Redis (Semaphore) and a second write; a
+   * blip there must not lose a fix run, because the number is a display
+   * convenience and the run itself is the work. On failure the run is created
+   * with a null taskNumber, which the list renders as "-" and the detail page
+   * hides — the run stays fully usable, just uncitable.
+   */
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    const projectId: ObjectID | undefined =
+      createBy.data.projectId || createBy.props.tenantId || undefined;
+
+    if (createBy.data.runType === AIRunType.CodeFix && projectId) {
+      try {
+        createBy.data.taskNumber =
+          await ProjectService.incrementAndGetAIRunCounter(projectId);
+      } catch (error) {
+        logger.error(
+          `Could not allocate a task number for a code-fix run in project ${projectId.toString()}; creating it unnumbered: ${error}`,
+        );
+      }
+    }
+
+    return { createBy, carryForward: null };
+  }
+
   protected override async onBeforeFind(
     findBy: FindBy<Model>,
   ): Promise<OnFind<Model>> {
-    findBy.query = pinQueryToRequestingUser(
-      findBy.query,
-      findBy.props,
-      "userId",
-    );
+    findBy.query = applyAIRunPrivacyFilter(findBy.query, findBy.props);
     return { findBy, carryForward: null };
   }
 
+  /*
+   * countBy MUST repeat the filter. DatabaseService has no onBeforeCount hook
+   * (only onCountSuccess / onCountError), and BaseAPI.getList issues findBy
+   * and countBy with the SAME client query, so filtering in onBeforeFind alone
+   * would return a correctly-scoped list beside an unscoped project-wide
+   * count on every page. IncidentService repeats it for the same reason.
+   */
   @CaptureSpan()
   public override async countBy(
     countBy: CountBy<Model>,
   ): Promise<PositiveNumber> {
-    countBy.query = pinQueryToRequestingUser(
-      countBy.query,
-      countBy.props,
-      "userId",
-    );
+    countBy.query = applyAIRunPrivacyFilter(countBy.query, countBy.props);
     return super.countBy(countBy);
   }
 }

package/Server/Services/LlmProviderService.ts

@@ -333,6 +333,7 @@ export class Service extends DatabaseService<Model> {
           select: {
             _id: true,
             name: true,
+            description: true,
             llmType: true,
             modelName: true,
             isDefault: true,
@@ -356,6 +357,7 @@ export class Service extends DatabaseService<Model> {
           select: {
             _id: true,
             name: true,
+            description: true,
             llmType: true,
             modelName: true,
             isDefault: true,

package/Server/Services/ProjectService.ts

@@ -2144,6 +2144,48 @@ export class ProjectService extends DatabaseService<Model> {
     }
   }
 
+  /*
+   * Allocate the next AI task number for a project. Unlike the counters
+   * above there is no companion prefix column — AI task numbers are not
+   * user-customizable, so the caller renders a plain "#N".
+   */
+  @CaptureSpan()
+  public async incrementAndGetAIRunCounter(
+    projectId: ObjectID,
+  ): Promise<number> {
+    const mutex: SemaphoreMutex = await Semaphore.lock({
+      key: projectId.toString(),
+      namespace: "ProjectService.aiRunCounter",
+    });
+
+    try {
+      await this.atomicIncrementColumnValueByOne({
+        id: projectId,
+        columnName: "aiRunCounter",
+      });
+
+      const project: Model | null = await this.findOneById({
+        id: projectId,
+        select: {
+          aiRunCounter: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      if (!project || project.aiRunCounter === undefined) {
+        throw new BadDataException(
+          `Could not read aiRunCounter for project ${projectId.toString()}`,
+        );
+      }
+
+      return project.aiRunCounter;
+    } finally {
+      await Semaphore.release(mutex);
+    }
+  }
+
   @CaptureSpan()
   public async isSMSNotificationsEnabled(
     projectId: ObjectID,

package/Server/Services/StatusPageService.ts

@@ -118,6 +118,93 @@ export class Service extends DatabaseService<StatusPage> {
     this.statusPageUrlCache.clear();
   }
 
+  /*
+   * Mirrors `resolveStatusPageIdOrThrow` in `Common/Server/API/StatusPageAPI.ts`
+   * (module-private there), but returns null instead of throwing so callers can
+   * collapse "no such page" and "page exists but is gated" into one answer.
+   * The dot check — not a UUID check — is the discriminator, so both resolvers
+   * agree on dotless hostnames like "localhost".
+   */
+  @CaptureSpan()
+  public async resolveStatusPageIdOrNull(
+    statusPageIdOrDomain: string,
+  ): Promise<ObjectID | null> {
+    if (!statusPageIdOrDomain) {
+      return null;
+    }
+
+    if (statusPageIdOrDomain.includes(".")) {
+      const statusPageDomain: StatusPageDomain | null =
+        await StatusPageDomainService.findOneBy({
+          query: {
+            fullDomain: statusPageIdOrDomain,
+            domain: {
+              isVerified: true,
+            } as any,
+          },
+          select: {
+            statusPageId: true,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+      if (!statusPageDomain || !statusPageDomain.statusPageId) {
+        return null;
+      }
+
+      return statusPageDomain.statusPageId;
+    }
+
+    try {
+      ObjectID.validateUUID(statusPageIdOrDomain);
+      return new ObjectID(statusPageIdOrDomain);
+    } catch (err) {
+      logger.error(
+        `Error converting statusPageIdOrDomain to ObjectID: ${statusPageIdOrDomain}`,
+      );
+      logger.error(err);
+      return null;
+    }
+  }
+
+  /*
+   * Folds existence and the `enableMcpServer` flag into a single query so the
+   * caller cannot distinguish "not found" from "disabled". The public MCP tools
+   * need no API key, so a distinct "disabled" message would be a status page
+   * enumeration oracle.
+   *
+   * Throws on database failure rather than returning false, so the caller
+   * reports an error instead of reporting the page as gated.
+   */
+  @CaptureSpan()
+  public async isMcpServerEnabled(
+    statusPageIdOrDomain: string,
+  ): Promise<boolean> {
+    const statusPageId: ObjectID | null =
+      await this.resolveStatusPageIdOrNull(statusPageIdOrDomain);
+
+    if (!statusPageId) {
+      return false;
+    }
+
+    const statusPage: StatusPage | null = await this.findOneBy({
+      query: {
+        _id: statusPageId,
+        enableMcpServer: true,
+      },
+      select: {
+        _id: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    return Boolean(statusPage);
+  }
+
   public static getDefaultEmailFooterText(): string {
     return "This is an automated email sent to you because you are subscribed to this Status Page.";
   }