@oneuptime/common 14.0.1 → 14.0.2

package/Server/Services/AutoRemediationRuleService.ts

@@ -1,10 +1,128 @@
 import DatabaseService from "./DatabaseService";
+import RunnerService, { Service as RunnerServiceClass } from "./RunnerService";
+import CreateBy from "../Types/Database/CreateBy";
+import UpdateBy from "../Types/Database/UpdateBy";
+import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import BadDataException from "../../Types/Exception/BadDataException";
+import LIMIT_MAX from "../../Types/Database/LimitMax";
+import ObjectID from "../../Types/ObjectID";
+import { JSONObject } from "../../Types/JSON";
 import Model from "../../Models/DatabaseModels/AutoRemediationRule";
+import Runner from "../../Models/DatabaseModels/Runner";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
+
+  /*
+   * A rule's Command Runners are the hosts its AI-composed Bash/SSH commands
+   * may target. A kubernetes-agent Runner (the in-cluster Runner the agent
+   * chart registers; RunnerService.isKubernetesAgentRunnerRow) is never
+   * one: it runs policy-tiered kubectl for its own cluster only, the claim
+   * path never serves it shell work, and its identity is issued with the
+   * project's telemetry ingestion key. A rule narrowed to one could never
+   * run a command. The dashboard does not offer these Runners; this refuses
+   * them on the API path too.
+   */
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    const agentRunners: Array<Runner> =
+      await RunnerService.findKubernetesAgentRunners(
+        createBy.data.commandRunners,
+      );
+
+    if (agentRunners.length > 0) {
+      throw new BadDataException(
+        Service.getAgentCommandRunnerRefusal(agentRunners[0]!),
+      );
+    }
+
+    return { createBy, carryForward: [] };
+  }
+
+  /*
+   * The same refusal on every write of the Command Runners list, with one
+   * exception: a kubernetes-agent Runner a rule ALREADY holds (saved before
+   * this guard) may be re-posted. The dashboard's rule form re-posts every
+   * field, including a stored Runner its picker no longer lists, so
+   * refusing it would block every edit of such a rule with nothing on the
+   * form to remove. Dropping it silently would be worse: a rule narrowed to
+   * that Runner alone would widen to "any Runner" on an unrelated edit. A
+   * held agent Runner is harmless — AI is only ever offered online Runners
+   * that are not agents (RunnerService.getOnlineAiCommandRunnersForProject),
+   * so it narrows the rule to nothing it can target. Adding one is refused.
+   */
+  @CaptureSpan()
+  protected override async onBeforeUpdate(
+    updateBy: UpdateBy<Model>,
+  ): Promise<OnUpdate<Model>> {
+    const data: JSONObject = (updateBy.data || {}) as unknown as JSONObject;
+
+    const agentRunners: Array<Runner> =
+      await RunnerService.findKubernetesAgentRunners(data["commandRunners"]);
+
+    if (agentRunners.length === 0) {
+      return { updateBy, carryForward: null };
+    }
+
+    /*
+     * onBeforeUpdate runs before the framework scopes the query to the
+     * caller's project, so scope the read here: a caller's write is never
+     * judged against another project's rules.
+     */
+    const rules: Array<Model> = await this.findBy({
+      query: {
+        ...updateBy.query,
+        ...(updateBy.props.tenantId
+          ? { projectId: updateBy.props.tenantId }
+          : {}),
+      },
+      select: {
+        _id: true,
+        commandRunners: { _id: true },
+      },
+      limit: LIMIT_MAX,
+      skip: 0,
+      props: { isRoot: true },
+    });
+
+    for (const agentRunner of agentRunners) {
+      const isHeldByEveryRule: boolean = rules.every((rule: Model) => {
+        return Service.holdsRunner(rule, agentRunner);
+      });
+
+      if (!isHeldByEveryRule) {
+        throw new BadDataException(
+          Service.getAgentCommandRunnerRefusal(agentRunner),
+        );
+      }
+    }
+
+    return { updateBy, carryForward: null };
+  }
+
+  private static holdsRunner(rule: Model, runner: Runner): boolean {
+    const runnerId: string | undefined =
+      runner.id?.toString() || runner._id?.toString();
+
+    if (!runnerId) {
+      return false;
+    }
+
+    return RunnerServiceClass.readRunnerIds(rule.commandRunners).some(
+      (heldId: ObjectID) => {
+        return heldId.toString() === runnerId;
+      },
+    );
+  }
+
+  public static getAgentCommandRunnerRefusal(runner: Runner): string {
+    return `Runner "${runner.name}" is the in-cluster Runner the Kubernetes agent chart installed. It runs kubectl for its own cluster only, never the Bash or SSH commands a rule composes, so it cannot be one of this rule's Command Runners. OneUptime AI reaches that cluster through the cluster's AI page instead. Choose Runners you created under Project Settings → Runners, or leave Command Runners empty to allow any Runner with AI commands enabled.`;
+  }
 }
 
 export default new Service();

package/Server/Services/BillingService.ts

@@ -2522,6 +2522,7 @@ export class BillingService extends BaseService {
                 dashboardLink: dashboardLink || "",
               },
               subject: `Invoice #${invoiceNumber} from OneUptime`,
+              isSubjectLiteral: true,
             },
             {
               projectId: projectId,

package/Server/Services/InboundEmail/Providers/SendGridInboundProvider.ts

@@ -3,6 +3,10 @@ import InboundEmailProvider, {
   ParsedInboundEmail,
 } from "../InboundEmailProvider";
 import { JSONObject } from "../../../../Types/JSON";
+import IncomingEmailMonitorAddress, {
+  IncomingEmailRecipient,
+  IncomingEmailRecipientKind,
+} from "../../../../Utils/Monitor/IncomingEmailMonitorAddress";
 
 // SendGrid uses the base config - add SendGrid-specific options here if needed in the future
 export type SendGridInboundConfig = InboundEmailProviderConfig;
@@ -86,25 +90,22 @@ export default class SendGridInboundProvider extends InboundEmailProvider {
   public extractSecretKeyFromEmail(email: string): string | null {
     /*
      * Extract from: monitor-{secretKey}@inbound.domain.com
-     * Handle email formats like "name@domain" or "Name <name@domain>"
+     * Handle email formats like "name@domain" or "Name <name@domain>".
+     * A custom monitor address carries no secret key, so it yields null.
      */
-    const emailAddress: string = this.extractEmailAddress(email);
-
-    /*
-     * Create regex pattern that matches the email prefix format
-     * The secret key is a UUID-like string
-     */
-    const pattern: RegExp = new RegExp(
-      `^monitor-([a-zA-Z0-9-]+)@${this.escapeRegex(this.config.inboundDomain)}$`,
-      "i",
-    );
-    const match: RegExpMatchArray | null = emailAddress.match(pattern);
-
-    return match ? match[1]! : null;
+    const recipient: IncomingEmailRecipient | null =
+      IncomingEmailMonitorAddress.parseRecipient({
+        emailAddress: this.extractEmailAddress(email),
+        inboundDomain: this.config.inboundDomain,
+      });
+
+    return recipient?.kind === IncomingEmailRecipientKind.Generated
+      ? recipient.secretKey
+      : null;
   }
 
   public generateMonitorEmailAddress(secretKey: string): string {
-    return `monitor-${secretKey}@${this.config.inboundDomain}`;
+    return `${IncomingEmailMonitorAddress.getGeneratedLocalPart(secretKey)}@${this.config.inboundDomain}`;
   }
 
   /**
@@ -200,11 +201,4 @@ export default class SendGridInboundProvider extends InboundEmailProvider {
       return undefined;
     }
   }
-
-  /**
-   * Escape special regex characters in a string
-   */
-  private escapeRegex(str: string): string {
-    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  }
 }

package/Server/Services/IncidentEpisodeMemberService.ts

@@ -40,6 +40,15 @@ export class Service extends DatabaseService<Model> {
       throw new BadDataException("incidentId is required");
     }
 
+    if (
+      !createBy.props.isRoot &&
+      createBy.data.isOwnerNotifiedOfIncidentAdded !== undefined
+    ) {
+      throw new BadDataException(
+        "isOwnerNotifiedOfIncidentAdded cannot be set directly",
+      );
+    }
+
     // Check if this incident is already in the episode
     const existingMember: Model | null = await this.findOneBy({
       query: {

package/Server/Services/IncidentEpisodePublicNoteService.ts

@@ -14,6 +14,8 @@ import IncidentEpisode from "../../Models/DatabaseModels/IncidentEpisode";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import StatusPageSubscriberNotificationStatus from "../../Types/StatusPage/StatusPageSubscriberNotificationStatus";
 import SubscriberUpdateNotification from "../../Types/StatusPage/SubscriberUpdateNotification";
+import PublicNoteSubscriberNotificationDefault from "../../Types/StatusPage/PublicNoteSubscriberNotificationDefault";
+import Query from "../Types/Database/Query";
 import File from "../../Models/DatabaseModels/File";
 import FileAttachmentMarkdownUtil from "../Utils/FileAttachmentMarkdownUtil";
 import { syncIsPublicForMarkdownImages } from "../Utils/InlineImageAccessTokenSync";
@@ -90,6 +92,26 @@ export class Service extends DatabaseService<Model> {
       createBy.data.postedAt = OneUptimeDate.getCurrentDate();
     }
 
+    /*
+     * A note that does not say whether to notify subscribers (Slack and
+     * Teams notes, workflows, API calls that leave the field out) follows
+     * its episode, so one created without telling subscribers stays quiet.
+     * An explicit true or false is kept as sent.
+     */
+    if (
+      createBy.data.shouldStatusPageSubscribersBeNotifiedOnNoteCreated ===
+        undefined ||
+      createBy.data.shouldStatusPageSubscribersBeNotifiedOnNoteCreated === null
+    ) {
+      const notifyByDefault: boolean | null =
+        await this.getIncidentEpisodeNotifyDefault(createBy.data);
+
+      if (notifyByDefault !== null) {
+        createBy.data.shouldStatusPageSubscribersBeNotifiedOnNoteCreated =
+          notifyByDefault;
+      }
+    }
+
     // Set notification status based on shouldStatusPageSubscribersBeNotifiedOnNoteCreated
     if (
       createBy.data.shouldStatusPageSubscribersBeNotifiedOnNoteCreated === false
@@ -111,6 +133,50 @@ export class Service extends DatabaseService<Model> {
     };
   }
 
+  /*
+   * Whether a note on this episode notifies subscribers when nobody said,
+   * or null when the episode cannot be found (the column default applies).
+   * Read as root: posting a note does not require permission to read the
+   * episode, and the answer is only this one flag.
+   */
+  private async getIncidentEpisodeNotifyDefault(
+    note: Model,
+  ): Promise<boolean | null> {
+    const incidentEpisodeId: ObjectID | null | undefined =
+      note.incidentEpisodeId || note.incidentEpisode?.id;
+
+    if (!incidentEpisodeId) {
+      return null;
+    }
+
+    const query: Query<IncidentEpisode> = {
+      _id: incidentEpisodeId.toString(),
+    };
+
+    if (note.projectId) {
+      query.projectId = note.projectId;
+    }
+
+    const incidentEpisode: IncidentEpisode | null =
+      await IncidentEpisodeService.findOneBy({
+        query: query,
+        select: {
+          shouldStatusPageSubscribersBeNotifiedOnEpisodeCreated: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    if (!incidentEpisode) {
+      return null;
+    }
+
+    return PublicNoteSubscriberNotificationDefault.shouldNotifyForIncidentEpisode(
+      incidentEpisode,
+    );
+  }
+
   /*
    * An edit tells subscribers nothing unless the editor asked for it on this
    * edit (see SubscriberUpdateNotification). When they did, queue the update

package/Server/Services/IncidentEpisodeRoleMemberService.ts

@@ -6,7 +6,10 @@ import IncidentMemberService from "./IncidentMemberService";
 import IncidentEpisodeMember from "../../Models/DatabaseModels/IncidentEpisodeMember";
 import IncidentEpisodeMemberService from "./IncidentEpisodeMemberService";
 import { OnCreate, OnDelete } from "../Types/Database/Hooks";
+import CreateBy from "../Types/Database/CreateBy";
 import DeleteBy from "../Types/Database/DeleteBy";
+import BadDataException from "../../Types/Exception/BadDataException";
+import TeamMemberService from "./TeamMemberService";
 import logger from "../Utils/Logger";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
@@ -16,6 +19,30 @@ export class Service extends DatabaseService<Model> {
     super(Model);
   }
 
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    const projectId: ObjectID | undefined =
+      createBy.data.projectId || createBy.props.tenantId;
+
+    // Only a member of the project can hold a role on its episodes.
+    if (
+      projectId &&
+      createBy.data.userId &&
+      !(await TeamMemberService.isUserMemberOfProject({
+        projectId: projectId,
+        userId: createBy.data.userId,
+      }))
+    ) {
+      throw new BadDataException(
+        "This user is not a member of this project and cannot be assigned a role on this episode.",
+      );
+    }
+
+    return { createBy, carryForward: null };
+  }
+
   @CaptureSpan()
   protected override async onBeforeDelete(
     deleteBy: DeleteBy<Model>,

package/Server/Services/IncidentEpisodeService.ts

@@ -1081,6 +1081,7 @@ export class Service extends DatabaseService<Model> {
           incidentEpisodeId: episodeId,
         },
         select: {
+          projectId: true,
           userId: true,
           user: {
             _id: true,
@@ -1102,6 +1103,7 @@ export class Service extends DatabaseService<Model> {
           incidentEpisodeId: episodeId,
         },
         select: {
+          projectId: true,
           teamId: true,
         },
         props: {
@@ -1135,7 +1137,18 @@ export class Service extends DatabaseService<Model> {
       }
     }
 
-    return Array.from(usersMap.values());
+    const projectId: ObjectID | undefined =
+      userOwners[0]?.projectId || teamOwners[0]?.projectId;
+
+    if (!projectId) {
+      return [];
+    }
+
+    // Owners who left the project are not notified, nor listed as notified.
+    return await TeamMemberService.filterUsersToProjectMembers({
+      projectId: projectId,
+      users: Array.from(usersMap.values()),
+    });
   }
 
   @CaptureSpan()

package/Server/Services/IncidentGroupingEngineService.ts

@@ -24,6 +24,7 @@ import IncidentEpisodeMemberService from "./IncidentEpisodeMemberService";
 import IncidentEpisodeOwnerUserService from "./IncidentEpisodeOwnerUserService";
 import IncidentEpisodeOwnerTeamService from "./IncidentEpisodeOwnerTeamService";
 import IncidentEpisodeRoleMemberService from "./IncidentEpisodeRoleMemberService";
+import TeamMemberService from "./TeamMemberService";
 import MonitorService from "./MonitorService";
 import Semaphore, { SemaphoreMutex } from "../Infrastructure/Semaphore";
 import IncidentEpisodeFeedService from "./IncidentEpisodeFeedService";
@@ -1008,6 +1009,16 @@ class IncidentGroupingEngineServiceClass {
             continue;
           }
           try {
+            // The rule can name a user who has since left the project.
+            if (
+              !(await TeamMemberService.isUserMemberOfProject({
+                projectId: incident.projectId!,
+                userId: new ObjectID(assignment.userId),
+              }))
+            ) {
+              continue;
+            }
+
             const roleMember: IncidentEpisodeRoleMember =
               new IncidentEpisodeRoleMember();
             roleMember.projectId = incident.projectId!;

package/Server/Services/IncidentMemberService.ts

@@ -18,6 +18,7 @@ import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import IncidentRole from "../../Models/DatabaseModels/IncidentRole";
 import IncidentRoleService from "./IncidentRoleService";
 import BadDataException from "../../Types/Exception/BadDataException";
+import TeamMemberService from "./TeamMemberService";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
@@ -40,6 +41,26 @@ export class Service extends DatabaseService<Model> {
       throw new BadDataException("incidentRoleId is required");
     }
 
+    /*
+     * Only a member of the project can hold a role on its incidents. The
+     * automatic paths (commander auto-assignment, monitor criteria, episode
+     * roles) skip a user who left before getting here; this is the backstop.
+     */
+    const projectId: ObjectID | undefined =
+      createBy.data.projectId || createBy.props.tenantId;
+
+    if (
+      projectId &&
+      !(await TeamMemberService.isUserMemberOfProject({
+        projectId: projectId,
+        userId: createBy.data.userId,
+      }))
+    ) {
+      throw new BadDataException(
+        "This user is not a member of this project and cannot be assigned a role on this incident.",
+      );
+    }
+
     // Check if this user is already assigned to this role for this incident
     const existingMember: Model | null = await this.findOneBy({
       query: {

package/Server/Services/IncidentPublicNoteService.ts

@@ -14,6 +14,8 @@ import Incident from "../../Models/DatabaseModels/Incident";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import StatusPageSubscriberNotificationStatus from "../../Types/StatusPage/StatusPageSubscriberNotificationStatus";
 import SubscriberUpdateNotification from "../../Types/StatusPage/SubscriberUpdateNotification";
+import PublicNoteSubscriberNotificationDefault from "../../Types/StatusPage/PublicNoteSubscriberNotificationDefault";
+import Query from "../Types/Database/Query";
 import File from "../../Models/DatabaseModels/File";
 import FileAttachmentMarkdownUtil from "../Utils/FileAttachmentMarkdownUtil";
 import { syncIsPublicForMarkdownImages } from "../Utils/InlineImageAccessTokenSync";
@@ -90,6 +92,26 @@ export class Service extends DatabaseService<Model> {
       createBy.data.postedAt = OneUptimeDate.getCurrentDate();
     }
 
+    /*
+     * A note that does not say whether to notify subscribers (Slack and
+     * Teams notes, workflows, API calls that leave the field out) follows
+     * its incident, so one declared without telling subscribers stays quiet.
+     * An explicit true or false is kept as sent.
+     */
+    if (
+      createBy.data.shouldStatusPageSubscribersBeNotifiedOnNoteCreated ===
+        undefined ||
+      createBy.data.shouldStatusPageSubscribersBeNotifiedOnNoteCreated === null
+    ) {
+      const notifyByDefault: boolean | null =
+        await this.getIncidentNotifyDefault(createBy.data);
+
+      if (notifyByDefault !== null) {
+        createBy.data.shouldStatusPageSubscribersBeNotifiedOnNoteCreated =
+          notifyByDefault;
+      }
+    }
+
     // Set notification status based on shouldStatusPageSubscribersBeNotifiedOnNoteCreated
     if (
       createBy.data.shouldStatusPageSubscribersBeNotifiedOnNoteCreated === false
@@ -111,6 +133,47 @@ export class Service extends DatabaseService<Model> {
     };
   }
 
+  /*
+   * Whether a note on this incident notifies subscribers when nobody said,
+   * or null when the incident cannot be found (the column default applies).
+   * Read as root: posting a note does not require permission to read the
+   * incident, and the answer is only this one flag.
+   */
+  private async getIncidentNotifyDefault(note: Model): Promise<boolean | null> {
+    const incidentId: ObjectID | null | undefined =
+      note.incidentId || note.incident?.id;
+
+    if (!incidentId) {
+      return null;
+    }
+
+    const query: Query<Incident> = {
+      _id: incidentId.toString(),
+    };
+
+    if (note.projectId) {
+      query.projectId = note.projectId;
+    }
+
+    const incident: Incident | null = await IncidentService.findOneBy({
+      query: query,
+      select: {
+        shouldStatusPageSubscribersBeNotifiedOnIncidentCreated: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!incident) {
+      return null;
+    }
+
+    return PublicNoteSubscriberNotificationDefault.shouldNotifyForIncident(
+      incident,
+    );
+  }
+
   /*
    * An edit tells subscribers nothing unless the editor asked for it on this
    * edit (see SubscriberUpdateNotification). When they did, queue the update