@oneuptime/common 14.0.1 → 14.0.2

package/Models/DatabaseModels/AlertEpisodeMember.ts

@@ -654,7 +654,14 @@ export default class AlertEpisodeMember extends BaseModel {
   public createdByUserId?: ObjectID = undefined;
 
   @ColumnAccessControl({
-    create: [],
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.AlertAdmin,
+      Permission.AlertMember,
+      Permission.CreateAlertEpisodeMember,
+    ],
     read: [
       Permission.ProjectOwner,
       Permission.ProjectAdmin,

package/Models/DatabaseModels/AutoRemediationSuggestion.ts

@@ -1,6 +1,7 @@
 import Alert from "./Alert";
 import AutoRemediationRule from "./AutoRemediationRule";
 import Incident from "./Incident";
+import KubernetesCluster from "./KubernetesCluster";
 import Project from "./Project";
 import Runbook from "./Runbook";
 import User from "./User";
@@ -188,6 +189,68 @@ export default class AutoRemediationSuggestion extends BaseModel {
   })
   public ruleNameSnapshot?: string = undefined;
 
+  /*
+   * Cluster-level remediation: a suggestion produced by a cluster's own AI
+   * remediation mode (its AI page) rather than by an AutoRemediationRule.
+   * Such a suggestion has no rule; the cluster's mode and allowlist play the
+   * rule's part at execution time.
+   */
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "kubernetesClusterId",
+    type: TableColumnType.Entity,
+    modelType: KubernetesCluster,
+    title: "Kubernetes Cluster",
+    description:
+      "The cluster whose AI remediation mode produced this suggestion (cluster-level remediation, no rule).",
+  })
+  @ManyToOne(
+    () => {
+      return KubernetesCluster;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "SET NULL",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "kubernetesClusterId" })
+  public kubernetesCluster?: KubernetesCluster = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+    ],
+    update: [],
+  })
+  @Index()
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    required: false,
+    canReadOnRelationQuery: true,
+    title: "Kubernetes Cluster ID",
+    description:
+      "ID of the cluster whose AI remediation mode produced this suggestion.",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public kubernetesClusterId?: ObjectID = undefined;
+
   @ColumnAccessControl({
     create: [],
     read: [

package/Models/DatabaseModels/IncidentEpisodeMember.ts

@@ -656,7 +656,14 @@ export default class IncidentEpisodeMember extends BaseModel {
   public createdByUserId?: ObjectID = undefined;
 
   @ColumnAccessControl({
-    create: [],
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.IncidentAdmin,
+      Permission.IncidentMember,
+      Permission.CreateIncidentEpisodeMember,
+    ],
     read: [
       Permission.ProjectOwner,
       Permission.ProjectAdmin,

package/Models/DatabaseModels/IncidentEpisodePublicNote.ts

@@ -650,12 +650,19 @@ export default class IncidentEpisodePublicNote extends BaseModel {
     ],
     update: [],
   })
+  /*
+   * No static defaultValue here: when a create leaves this out, the service
+   * takes it from the episode (see PublicNoteSubscriberNotificationDefault),
+   * and a fixed "true" in the published API schema would be wrong for
+   * episodes created without notifying subscribers. The database default
+   * only applies when the episode cannot be found.
+   */
   @TableColumn({
     isDefaultValueColumn: true,
     type: TableColumnType.Boolean,
     title: "Should subscribers be notified?",
-    description: "Should subscribers be notified about this note?",
-    defaultValue: true,
+    description:
+      "Should subscribers be notified about this note? If left out, this follows the episode: true when subscribers were notified that the episode was created, false when it was created without notifying them.",
   })
   @Column({
     type: ColumnType.Boolean,

package/Models/DatabaseModels/IncidentPublicNote.ts

@@ -653,12 +653,19 @@ export default class IncidentPublicNote extends BaseModel {
     ],
     update: [],
   })
+  /*
+   * No static defaultValue here: when a create leaves this out, the service
+   * takes it from the incident (see PublicNoteSubscriberNotificationDefault),
+   * and a fixed "true" in the published API schema would be wrong for
+   * incidents declared without notifying subscribers. The database default
+   * only applies when the incident cannot be found.
+   */
   @TableColumn({
     isDefaultValueColumn: true,
     type: TableColumnType.Boolean,
     title: "Should subscribers be notified?",
-    description: "Should subscribers be notified about this note?",
-    defaultValue: true,
+    description:
+      "Should subscribers be notified about this note? If left out, this follows the incident: true when subscribers were notified that the incident was declared, false when it was declared without notifying them.",
   })
   @Column({
     type: ColumnType.Boolean,

package/Models/DatabaseModels/KubernetesCluster.ts

@@ -1,5 +1,7 @@
 import Label from "./Label";
 import Project from "./Project";
+import RunbookCredential from "./RunbookCredential";
+import Runner from "./Runner";
 import User from "./User";
 import BaseModel from "./DatabaseBaseModel/DatabaseBaseModel";
 import Route from "../../Types/API/Route";
@@ -20,6 +22,7 @@ import IconProp from "../../Types/Icon/IconProp";
 import ObjectID from "../../Types/ObjectID";
 import Permission from "../../Types/Permission";
 import TelemetryRetentionConfig from "../../Types/Telemetry/TelemetryRetentionConfig";
+import { KubernetesAiRemediationMode } from "../../Types/Kubernetes/KubernetesClusterAiAccess";
 import {
   Column,
   Entity,
@@ -990,4 +993,430 @@ export default class KubernetesCluster extends BaseModel {
     nullable: true,
   })
   public telemetryRetentionConfig?: TelemetryRetentionConfig = undefined;
+
+  /*
+   * ---- OneUptime AI access -------------------------------------------
+   *
+   * The cluster's AI page binds one Runner that can reach the cluster and
+   * decides what OneUptime AI may do with it. The in-cluster Runner the
+   * kubernetes-agent chart installs (aiAccess.enabled=true) binds itself
+   * here on registration; an operator can instead bind any existing Runner
+   * plus a Kubernetes credential. Whether AI may investigate (read-only
+   * kubectl) and how it may remediate are separate switches so a project
+   * can let AI look without letting it touch.
+   *
+   * The update ACLs below are the cluster's own on purpose: everyone who
+   * may edit the cluster may make AI do LESS (remediation Off or Ask for
+   * approval, fewer allowlist patterns, no Runner or credential, the
+   * investigation switch). Making AI do MORE — an unattended mode, a new
+   * allowlist pattern, binding a Runner or credential — is refused in
+   * KubernetesClusterService unless the caller holds one of
+   * KUBERNETES_AI_ACCESS_ADMIN_PERMISSIONS (the permissions that may author
+   * a FullAuto AutoRemediationRule), and binding a credential also needs
+   * KUBERNETES_AI_ACCESS_CREDENTIAL_PERMISSIONS. A column ACL cannot express
+   * "tightening is free", which is why the rule lives in the service. The
+   * descriptions say so, because they are the API and Terraform docs.
+   */
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.SettingsViewer,
+      Permission.ReadKubernetesCluster,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.EditKubernetesCluster,
+    ],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "aiAccessRunnerId",
+    type: TableColumnType.Entity,
+    modelType: Runner,
+    title: "AI Access Runner",
+    description:
+      "The Runner OneUptime AI uses to run kubectl against this cluster — the in-cluster Runner installed by the Kubernetes agent chart (which binds itself here when it first registers, unless a Runner was bound here before), or any Runner you created that holds a Kubernetes credential for this cluster. Another cluster's in-cluster Runner cannot be bound. Binding a Runner, or switching to a different one, needs Project Owner, Project Admin or Edit Auto Remediation Rule; anyone who may edit the cluster can clear it.",
+  })
+  @ManyToOne(
+    () => {
+      return Runner;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "SET NULL",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "aiAccessRunnerId" })
+  public aiAccessRunner?: Runner = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.SettingsViewer,
+      Permission.ReadKubernetesCluster,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.EditKubernetesCluster,
+    ],
+  })
+  @Index()
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    required: false,
+    canReadOnRelationQuery: true,
+    title: "AI Access Runner ID",
+    description:
+      "ID of the Runner OneUptime AI uses to run kubectl against this cluster. Another cluster's in-cluster Runner cannot be bound. Binding a Runner, or switching to a different one, needs Project Owner, Project Admin or Edit Auto Remediation Rule; anyone who may edit the cluster can clear it.",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public aiAccessRunnerId?: ObjectID = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.SettingsViewer,
+      Permission.ReadKubernetesCluster,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.EditKubernetesCluster,
+    ],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "aiAccessCredentialId",
+    type: TableColumnType.Entity,
+    modelType: RunbookCredential,
+    title: "AI Access Credential",
+    description:
+      "The Kubernetes credential (API server URL and ServiceAccount token) the AI access Runner uses for this cluster; it must be a Kubernetes credential of this project that is assigned to that Runner. Leave empty for the in-cluster Runner, which uses its own ServiceAccount and is never given a credential. Binding a credential needs Project Owner, Project Admin or Edit Auto Remediation Rule, and also permission to read credentials (Project Owner, Project Admin or Read Runbook Credential); anyone who may edit the cluster can clear it.",
+  })
+  @ManyToOne(
+    () => {
+      return RunbookCredential;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "SET NULL",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "aiAccessCredentialId" })
+  public aiAccessCredential?: RunbookCredential = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.SettingsViewer,
+      Permission.ReadKubernetesCluster,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.EditKubernetesCluster,
+    ],
+  })
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    required: false,
+    canReadOnRelationQuery: true,
+    title: "AI Access Credential ID",
+    description:
+      "ID of the Kubernetes credential the AI access Runner uses for this cluster; the credential must be assigned to that Runner. Empty for the in-cluster Runner, which is never given a credential. Binding a credential needs Project Owner, Project Admin or Edit Auto Remediation Rule, and also permission to read credentials (Project Owner, Project Admin or Read Runbook Credential); anyone who may edit the cluster can clear it.",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public aiAccessCredentialId?: ObjectID = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.SettingsViewer,
+      Permission.ReadKubernetesCluster,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.EditKubernetesCluster,
+    ],
+  })
+  @TableColumn({
+    isDefaultValueColumn: true,
+    required: true,
+    type: TableColumnType.Boolean,
+    title: "Let AI Investigate With kubectl",
+    description:
+      "When on, OneUptime AI runs read-only kubectl commands (get, describe, logs, events, top, rollout status) on this cluster while investigating incidents and alerts linked to it, and uses their output, with secret values redacted, as evidence. Nothing is ever changed by an investigation. Anyone who may edit the cluster can turn it on or off.",
+    defaultValue: false,
+  })
+  @Column({
+    type: ColumnType.Boolean,
+    nullable: false,
+    default: false,
+  })
+  public isAiInvestigationEnabled?: boolean = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.SettingsViewer,
+      Permission.ReadKubernetesCluster,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.EditKubernetesCluster,
+    ],
+  })
+  @TableColumn({
+    isDefaultValueColumn: true,
+    required: true,
+    type: TableColumnType.ShortText,
+    title: "AI Remediation Mode",
+    /*
+     * The API and Terraform docs for the mode: the same semantics, in the
+     * same words, as the KubernetesAiRemediationMode doc comment in
+     * Types/Kubernetes/KubernetesClusterAiAccess.ts (the canonical text).
+     */
+    description:
+      "Disabled: AI never proposes or runs a change on this cluster. RequireApproval: AI composes a kubectl plan and a human approves it with one click before anything runs. Any follow-up plan asks again. Automatic: AI runs safe changes without a human — each on ONE named object: rollout restart/undo/pause/resume of one workload, scale one workload above zero, delete one named pod, cordon/uncordon one node, label/annotate one pod or workload with unreserved keys. A riskier change (patch, set image, drain, taint, scale to zero, deleting workloads or jobs, anything touching several objects) never runs without one: when the round could only find riskier fixes it ends by proposing exactly those for one-click approval; when it also ran safe fixes, a riskier fix is proposed only if verification shows the safe ones did not recover the signal (the follow-up round, which asks). Shapes on the cluster's kubectl allowlist run on their own. BypassApproval: AI does not ask. Every change the policy allows — safe AND riskier — runs on its own, follow-up rounds included, except for what always asks (below). In EVERY mode, Bypass approval included: destructive commands (Denied tier) never run; a write in a protected namespace (kube-system, kube-public, kube-node-lease), a node drain, a node taint and a patch of a Node always need a human; the in-cluster Runner never changes its own namespace or anything outside the namespaces its chart may write; and an unattended run becomes a proposal when the hourly per-cluster circuit breaker trips or another unattended round already holds the cluster. Anyone who may edit the cluster can lower the mode (to Disabled, RequireApproval, or from BypassApproval to Automatic); raising it to Automatic or BypassApproval needs Project Owner, Project Admin or Edit Auto Remediation Rule.",
+    defaultValue: KubernetesAiRemediationMode.Disabled,
+    example: KubernetesAiRemediationMode.RequireApproval,
+  })
+  @Column({
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+    nullable: false,
+    default: KubernetesAiRemediationMode.Disabled,
+  })
+  public aiRemediationMode?: KubernetesAiRemediationMode = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.SettingsViewer,
+      Permission.ReadKubernetesCluster,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.EditKubernetesCluster,
+    ],
+  })
+  @TableColumn({
+    type: TableColumnType.JSON,
+    required: false,
+    title: "AI kubectl Allowlist",
+    description:
+      'Optional JSON array of kubectl command patterns that Automatic mode may run without approval even though they are riskier changes, for example: ["kubectl set image deployment/web * -n web"]. A pattern is compared with the command word by word: * stands for exactly one word (an image, a name), never for extra objects, flags or a second -n, every flag the command uses must be written out in the pattern, and the leading "kubectl" is optional. At most 100 patterns of at most 500 characters each; a pattern that is not one kubectl command line is refused. Destructive commands (Denied tier) never run regardless, and a write in a protected namespace (kube-system, kube-public, kube-node-lease) or a node drain still needs a human. Adding a pattern needs Project Owner, Project Admin or Edit Auto Remediation Rule; anyone who may edit the cluster can remove patterns or clear the list.',
+  })
+  @Column({
+    type: ColumnType.JSON,
+    nullable: true,
+  })
+  public aiKubectlCommandAllowlist?: Array<string> = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.SettingsViewer,
+      Permission.ReadKubernetesCluster,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.Date,
+    title: "AI Access Last Verified At",
+    description:
+      "When a kubectl command from OneUptime AI last succeeded on this cluster. Set by the server.",
+  })
+  @Column({
+    type: ColumnType.Date,
+    nullable: true,
+  })
+  public aiAccessLastVerifiedAt?: Date = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.SettingsViewer,
+      Permission.ReadKubernetesCluster,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.LongText,
+    title: "AI Access Last Error",
+    description:
+      "The most recent failure OneUptime AI hit while running kubectl on this cluster, kept until the next successful command. Set by the server.",
+  })
+  @Column({
+    type: ColumnType.LongText,
+    nullable: true,
+  })
+  public aiAccessLastError?: string = undefined;
+
+  /*
+   * When this cluster's AI access was first configured — by the in-cluster
+   * Runner's first bind, or by anyone writing an AI access setting. Only
+   * the server writes it, and nothing ever clears it. A registering agent
+   * Runner reads it to tell "never configured" (apply the chart's defaults)
+   * from "an operator chose settings, perhaps before installing the chart"
+   * (bind the Runner and keep every setting as chosen);
+   * aiAccessRunnerBoundAt below decides whether it binds at all.
+   */
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.SettingsViewer,
+      Permission.ReadKubernetesCluster,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.Date,
+    title: "AI Access Configured At",
+    description:
+      "When OneUptime AI access to this cluster was first configured: by the in-cluster Runner's first registration, or by anyone saving an AI access setting. Set by the server; never cleared, so an in-cluster Runner that registers later never overwrites a setting an operator chose.",
+  })
+  @Column({
+    type: ColumnType.Date,
+    nullable: true,
+  })
+  public aiAccessConfiguredAt?: Date = undefined;
+
+  /*
+   * When a Runner was first bound to this cluster for AI access — by the
+   * in-cluster Runner's registration or by anyone selecting a Runner on the
+   * AI page. Only the server writes it and nothing ever clears it.
+   *
+   * aiAccessConfiguredAt alone cannot tell the two cases registration must
+   * treat differently apart: an operator who chose a remediation mode
+   * BEFORE installing the chart (no Runner was ever bound — bind the agent
+   * Runner and keep their switches) and a cluster whose Runner binding was
+   * cleared or whose bound Runner was deleted (a Runner WAS bound — leave
+   * the cluster unbound until someone selects a Runner again).
+   */
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.Viewer,
+      Permission.SettingsAdmin,
+      Permission.SettingsMember,
+      Permission.SettingsViewer,
+      Permission.ReadKubernetesCluster,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.Date,
+    title: "AI Access Runner Bound At",
+    description:
+      "When a Runner was first bound to this cluster for OneUptime AI access. Set by the server; never cleared, so a cluster whose Runner was cleared or deleted is not silently re-bound when the in-cluster Runner registers again.",
+  })
+  @Column({
+    type: ColumnType.Date,
+    nullable: true,
+  })
+  public aiAccessRunnerBoundAt?: Date = undefined;
 }

package/Models/DatabaseModels/Monitor.ts

@@ -1562,6 +1562,54 @@ export default class Monitor extends BaseModel {
   })
   public incomingEmailSecretKey?: ObjectID = undefined;
 
+  @ColumnAccessControl({
+    /*
+     * Not settable on create: the column is unique across every project, so
+     * letting an import or a duplicated monitor carry it over would fail the
+     * copy. Set it on the monitor once it exists.
+     */
+    create: [],
+    /*
+     * Same lists as incomingEmailSecretKey, for the same reason: while this is
+     * set it IS the monitor's inbound address (it replaces the generated
+     * monitor-{secretKey} one), so a holder can send mail the monitor counts
+     * as a heartbeat. https://github.com/OneUptime/oneuptime/issues/3360
+     */
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.MonitorAdmin,
+      Permission.MonitorMember,
+      Permission.EditProjectMonitor,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.MonitorAdmin,
+      Permission.MonitorMember,
+      Permission.EditProjectMonitor,
+    ],
+  })
+  @TableColumn({
+    type: TableColumnType.ShortText,
+    required: false,
+    unique: true,
+    isDefaultValueColumn: false,
+    title: "Incoming Email Custom Address",
+    description:
+      "This field is for Incoming Email Monitor only. A custom name for this monitor's inbound email address: the part before the @, on the server's inbound email domain. While set, it replaces the generated monitor-{secret key} address. Must be unique across all monitors. Set to null to go back to the generated address.",
+    example: "nightly-backups",
+  })
+  @Column({
+    type: ColumnType.ShortText,
+    length: ColumnLength.ShortText,
+    nullable: true,
+    unique: true,
+  })
+  public incomingEmailCustomLocalPart?: string = undefined;
+
   @ColumnAccessControl({
     create: [],
     read: [