@oneuptime/common 14.0.0 → 14.0.2

package/Server/Utils/Monitor/RootCauseList.ts

@@ -0,0 +1,139 @@
+/*
+ * The numbered list a root cause uses for a per-item breakdown.
+ *
+ * Two blocks of an incident / alert root cause break a breach down item by
+ * item: a platform monitor's "Affected Resources" (see AffectedResourceList)
+ * and a metric monitor's "Breaching Samples". Both used to be
+ * GitHub-flavoured tables, and a table reads badly everywhere a root cause
+ * is shown — it wraps into fragments in the ~416px email card, reaches Slack
+ * as raw pipe rows (mrkdwn has no tables), and lets its widest column
+ * squeeze the rest on the dashboard. So each item is a numbered list item
+ * instead: a title and a value on its first line, and everything else
+ * about it as labelled bullets nested underneath.
+ *
+ *     1. **Pod** `checkout-7d9f` — **3**
+ *        - Namespace: `payments`
+ *
+ *     1. `2026-08-14T10:30:00.000Z` — **1.07 GB**
+ *        - `a`: 537 MB
+ *        - `k8s.pod.name`: `web-1`
+ *
+ * A detail with no value is simply left out, where a table had to print
+ * "-" in its cell.
+ *
+ * Plain markdown, deliberately: marked (email), react-markdown (dashboard),
+ * slackify-markdown (Slack), the dashboard editor's WYSIWYG converters and
+ * Markdown.convertToPlainText all understand a nested list, so nothing
+ * downstream needs to know these blocks exist.
+ */
+
+export interface RootCauseListDetail {
+  /*
+   * Markdown, rendered as-is — escape plain text, or wrap an identifier
+   * with RootCauseList.code(). An empty label leaves just the value.
+   */
+  label: string;
+  // Markdown, rendered as-is. An empty value drops the whole detail.
+  value: string;
+}
+
+export interface RootCauseListItem {
+  // Markdown, rendered as-is: what the item is.
+  title: string;
+  // Markdown, rendered as-is: how bad it is, normally a bold value.
+  value: string;
+  details: Array<RootCauseListDetail>;
+}
+
+export default class RootCauseList {
+  /*
+   * The items as one ordered list, numbered from 1 in the order given. The
+   * result is just the list: the caller puts its heading above it and any
+   * summary below it, each separated from the list by a blank line.
+   */
+  public static render(items: Array<RootCauseListItem>): string {
+    const lines: Array<string> = [];
+
+    items.forEach((item: RootCauseListItem, index: number): void => {
+      const marker: string = `${index + 1}.`;
+
+      /*
+       * A nested bullet belongs to its item only when it is indented to
+       * the item's content column, which is one past the marker — three
+       * spaces under "1.", four under "10.". A fixed three-space indent
+       * would push item 10's details out into a separate top-level list.
+       */
+      const indent: string = " ".repeat(marker.length + 1);
+
+      const head: string = [item.title.trim(), item.value.trim()]
+        .filter((part: string): boolean => {
+          return part.length > 0;
+        })
+        .join(" — ");
+
+      lines.push(`${marker} ${head}`);
+
+      for (const detail of item.details) {
+        const value: string = detail.value ? detail.value.trim() : "";
+
+        if (value.length === 0) {
+          continue;
+        }
+
+        const label: string = detail.label ? detail.label.trim() : "";
+
+        lines.push(`${indent}- ${label ? `${label}: ${value}` : value}`);
+      }
+    });
+
+    return lines.join("\n");
+  }
+
+  /*
+   * A value as an inline code span.
+   *
+   * What goes in here comes from telemetry — resource names, attribute keys
+   * and values — and can contain anything. Wrapping a value that contains a
+   * backtick in single backticks closes the span early and spills the rest
+   * of it — and whatever markdown it contains — into the list. So the fence
+   * is always one backtick longer than the longest run inside the value,
+   * and padded with a space on each side when the value has any backticks
+   * at all (CommonMark strips exactly one from each side, so the padding
+   * never shows). Line breaks become spaces: a newline inside a list item
+   * would end the item.
+   *
+   * A value without backticks is a plain single-backtick span, so an ISO
+   * timestamp still reaches the dashboard as the bare inline code the
+   * MarkdownViewer re-renders in the viewer's timezone.
+   */
+  public static code(value: string | undefined | null): string {
+    if (value === undefined || value === null) {
+      return "";
+    }
+
+    const text: string = String(value)
+      .replace(/\s*[\r\n]+\s*/g, " ")
+      .trim();
+
+    if (text.length === 0) {
+      return "";
+    }
+
+    const backtickRuns: Array<string> = text.match(/`+/g) || [];
+
+    const longestRun: number = backtickRuns.reduce(
+      (longest: number, run: string): number => {
+        return Math.max(longest, run.length);
+      },
+      0,
+    );
+
+    if (longestRun === 0) {
+      return `\`${text}\``;
+    }
+
+    const fence: string = "`".repeat(longestRun + 1);
+
+    return `${fence} ${text} ${fence}`;
+  }
+}

package/Server/Utils/OnCall/OnCallShiftReminderRunner.ts

@@ -2049,6 +2049,7 @@ export default class OnCallShiftReminderRunner {
         templateType: message.templateType,
         vars: message.vars,
         subject: message.subject,
+        isSubjectLiteral: true,
       };
 
       const smsMessage: SMSMessage = {

package/Server/Utils/PushNotificationUtil.ts

@@ -517,6 +517,51 @@ export default class PushNotificationUtil {
     return PushNotificationUtil.applyDefaults(notification);
   }
 
+  /*
+   * One push per probe transition for the monitors it took down (or brought
+   * back), instead of one per monitor. The tag is shared by both directions,
+   * so on web push a reconnect replaces the disconnect it resolves.
+   */
+  public static createProbeMonitorsStatusNotification(params: {
+    probeName: string;
+    projectName: string;
+    connectionStatus: string;
+    monitorCount: number;
+    // One sentence: probe, count and project.
+    summary: string;
+    clickAction?: string;
+  }): PushNotificationMessage {
+    const {
+      probeName,
+      projectName,
+      connectionStatus,
+      monitorCount,
+      summary,
+      clickAction,
+    } = params;
+    const notification: Partial<PushNotificationMessage> = {
+      title: `Probe ${connectionStatus}: ${probeName}`,
+      body: summary,
+      tag: "probe-monitors-status",
+      requireInteraction: false,
+      data: {
+        type: "probe-monitors-status",
+        probeName: probeName,
+        projectName: projectName,
+        connectionStatus: connectionStatus,
+        monitorCount: monitorCount.toString(),
+      },
+    };
+
+    if (clickAction) {
+      notification.clickAction = clickAction;
+      notification.url = clickAction;
+      notification.data!["url"] = clickAction;
+    }
+
+    return PushNotificationUtil.applyDefaults(notification);
+  }
+
   public static createAIAgentStatusChangedNotification(params: {
     aiAgentName: string;
     projectName: string;

package/Server/Utils/Rules/OwnerRuleAssignment.ts

@@ -3,6 +3,7 @@ import DatabaseCommonInteractionProps from "../../../Types/BaseDatabase/Database
 import { LIMIT_PER_PROJECT } from "../../../Types/Database/LimitMax";
 import ObjectID from "../../../Types/ObjectID";
 import DatabaseService from "../../Services/DatabaseService";
+import TeamMemberService from "../../Services/TeamMemberService";
 import QueryHelper from "../../Types/Database/QueryHelper";
 import Query from "../../Types/Database/Query";
 import PostgresErrorTranslator from "../Database/PostgresErrorTranslator";
@@ -19,6 +20,11 @@ import PostgresErrorTranslator from "../Database/PostgresErrorTranslator";
  * cannot let one owner who is already there stop the rest from being added.
  * They filter their owner set through getOwnersNotYetAssigned first, and
  * insert through createOwner, which treats "already an owner" as done.
+ *
+ * Those owner sets are saved configuration - rules, templates, criteria -
+ * and can name a user who has since left the project. createOwner skips
+ * such a user, so a departed member is not made the owner of new work,
+ * notified about it, or listed as notified.
  */
 
 export interface OwnersToAssign {
@@ -117,15 +123,20 @@ export default class OwnerRuleAssignment {
 
   /*
    * Inserts one owner row. Resolves true when the row was written and false
-   * when the owner was already there - whether the owner service's own check
-   * found the existing row, or the unique index rejected a concurrent insert
-   * that got past it. Every other failure is thrown as before.
+   * when it was not: the owner was already there - whether the owner
+   * service's own check found the existing row, or the unique index rejected
+   * a concurrent insert that got past it - or the owner is a user who is not
+   * a member of the project. Every other failure is thrown as before.
    */
   public static async createOwner<TOwner extends BaseModel>(data: {
     ownerService: DatabaseService<TOwner>;
     owner: TOwner;
     props: DatabaseCommonInteractionProps;
   }): Promise<boolean> {
+    if (!(await OwnerRuleAssignment.isOwnerInProject(data))) {
+      return false;
+    }
+
     try {
       await data.ownerService.create({
         data: data.owner,
@@ -232,6 +243,32 @@ export default class OwnerRuleAssignment {
     return added;
   }
 
+  /*
+   * Team owners are always in the project. A user owner must be a member:
+   * see TeamMemberService.isUserMemberOfProject.
+   */
+  private static async isOwnerInProject<TOwner extends BaseModel>(data: {
+    owner: TOwner;
+    props: DatabaseCommonInteractionProps;
+  }): Promise<boolean> {
+    const userId: string | undefined = data.owner
+      .getColumnValue("userId")
+      ?.toString();
+
+    const projectId: string | undefined =
+      data.owner.getColumnValue("projectId")?.toString() ||
+      data.props.tenantId?.toString();
+
+    if (!userId || !projectId) {
+      return true;
+    }
+
+    return await TeamMemberService.isUserMemberOfProject({
+      projectId: new ObjectID(projectId),
+      userId: new ObjectID(userId),
+    });
+  }
+
   private static buildOwner<TOwner extends BaseModel>(data: {
     ownerService: DatabaseService<TOwner>;
     ownerColumn: "userId" | "teamId";

package/Server/Utils/Rules/RuleRun/RuleRunRegistry.ts

@@ -122,6 +122,11 @@ import ServerlessFunctionOwnerTeam from "../../../../Models/DatabaseModels/Serve
 import ServerlessFunctionOwnerUser from "../../../../Models/DatabaseModels/ServerlessFunctionOwnerUser";
 import Service from "../../../../Models/DatabaseModels/Service";
 import ServiceLabelRule from "../../../../Models/DatabaseModels/ServiceLabelRule";
+import ServiceLevelObjective from "../../../../Models/DatabaseModels/ServiceLevelObjective";
+import ServiceLevelObjectiveLabelRule from "../../../../Models/DatabaseModels/ServiceLevelObjectiveLabelRule";
+import ServiceLevelObjectiveOwnerRule from "../../../../Models/DatabaseModels/ServiceLevelObjectiveOwnerRule";
+import ServiceLevelObjectiveOwnerTeam from "../../../../Models/DatabaseModels/ServiceLevelObjectiveOwnerTeam";
+import ServiceLevelObjectiveOwnerUser from "../../../../Models/DatabaseModels/ServiceLevelObjectiveOwnerUser";
 import ServiceOwnerRule from "../../../../Models/DatabaseModels/ServiceOwnerRule";
 import ServiceOwnerTeam from "../../../../Models/DatabaseModels/ServiceOwnerTeam";
 import ServiceOwnerUser from "../../../../Models/DatabaseModels/ServiceOwnerUser";
@@ -265,6 +270,11 @@ import ServerlessFunctionLabelRuleService from "../../../Services/ServerlessFunc
 import ServerlessFunctionOwnerRuleEngineService from "../../../Services/ServerlessFunctionOwnerRuleEngineService";
 import ServerlessFunctionOwnerRuleService from "../../../Services/ServerlessFunctionOwnerRuleService";
 import ServerlessFunctionService from "../../../Services/ServerlessFunctionService";
+import ServiceLevelObjectiveLabelRuleEngineService from "../../../Services/ServiceLevelObjectiveLabelRuleEngineService";
+import ServiceLevelObjectiveLabelRuleService from "../../../Services/ServiceLevelObjectiveLabelRuleService";
+import ServiceLevelObjectiveOwnerRuleEngineService from "../../../Services/ServiceLevelObjectiveOwnerRuleEngineService";
+import ServiceLevelObjectiveOwnerRuleService from "../../../Services/ServiceLevelObjectiveOwnerRuleService";
+import ServiceLevelObjectiveService from "../../../Services/ServiceLevelObjectiveService";
 import ServiceLabelRuleEngineService from "../../../Services/ServiceLabelRuleEngineService";
 import ServiceLabelRuleService from "../../../Services/ServiceLabelRuleService";
 import ServiceOwnerRuleEngineService from "../../../Services/ServiceOwnerRuleEngineService";
@@ -727,6 +737,24 @@ const RULE_RUN_DEFINITIONS: Record<ResourceRuleRunType, RuleRunDefinition> = {
     resourceService: ServiceService,
     engine: ServiceLabelRuleEngineService,
   }),
+  [RuleRunType.ServiceLevelObjectiveLabelRule]: defineRuleRun({
+    ruleModelType: ServiceLevelObjectiveLabelRule,
+    resourceModelType: ServiceLevelObjective,
+    ruleService: ServiceLevelObjectiveLabelRuleService,
+    resourceService: ServiceLevelObjectiveService,
+    engine: ServiceLevelObjectiveLabelRuleEngineService,
+  }),
+  [RuleRunType.ServiceLevelObjectiveOwnerRule]: defineRuleRun({
+    ruleModelType: ServiceLevelObjectiveOwnerRule,
+    resourceModelType: ServiceLevelObjective,
+    ruleService: ServiceLevelObjectiveOwnerRuleService,
+    resourceService: ServiceLevelObjectiveService,
+    engine: ServiceLevelObjectiveOwnerRuleEngineService,
+    ownerModelTypes: [
+      ServiceLevelObjectiveOwnerUser,
+      ServiceLevelObjectiveOwnerTeam,
+    ],
+  }),
   [RuleRunType.ServiceOwnerRule]: defineRuleRun({
     ruleModelType: ServiceOwnerRule,
     resourceModelType: Service,

package/Server/Utils/Runbook/RunbookExecutePermission.ts

@@ -36,12 +36,21 @@ export const RUNBOOK_ADVANCE_PERMISSIONS: Array<Permission> = [
   Permission.EditRunbookExecution,
 ];
 
-function assertHoldsAny(data: {
+/*
+ * Does the caller hold a GRANT of any of `allowed` in this project? The
+ * primitive behind every check in this file, exported for other server-side
+ * guards that must decide "may this caller do X here" from the same props
+ * and read block rows the same way (e.g. who may loosen a Kubernetes
+ * cluster's AI access).
+ *
+ * Root and master-admin callers are the caller's business: this only reads
+ * the tenant permission rows, so a guard that exempts them must do so itself.
+ */
+export function holdsAnyPermission(data: {
   props: DatabaseCommonInteractionProps;
   projectId: ObjectID;
-  allowed: Array<Permission>;
-  deniedMessage: string;
-}): void {
+  allowed: ReadonlyArray<Permission>;
+}): boolean {
   const tenantPermission: UserTenantAccessPermission | undefined =
     data.props.userTenantAccessPermission?.[data.projectId.toString()];
 
@@ -49,13 +58,52 @@ function assertHoldsAny(data: {
    * A permission row can be a BLOCK rather than a grant, so matching on the
    * permission name alone would read a denial as an authorization.
    */
-  const hasPermission: boolean = Boolean(
+  return Boolean(
     tenantPermission?.permissions?.some((p: UserPermission): boolean => {
       return !p.isBlockPermission && data.allowed.includes(p.permission);
     }),
   );
+}
+
+/*
+ * Like holdsAnyPermission, but for deciding what a caller may SEE: a block
+ * row for any of `allowed` is a denial even when a grant is also present —
+ * a block row may be limited to some labels, and the caller of this cannot
+ * tell which object it would cover. Root and master admins see everything.
+ */
+export function holdsAnyUnblockedPermission(data: {
+  props: DatabaseCommonInteractionProps;
+  projectId: ObjectID;
+  allowed: ReadonlyArray<Permission>;
+}): boolean {
+  if (data.props.isRoot || data.props.isMasterAdmin) {
+    return true;
+  }
+
+  const permissions: Array<UserPermission> =
+    data.props.userTenantAccessPermission?.[data.projectId.toString()]
+      ?.permissions || [];
+
+  const isBlocked: boolean = permissions.some((p: UserPermission): boolean => {
+    return p.isBlockPermission === true && data.allowed.includes(p.permission);
+  });
+
+  return !isBlocked && holdsAnyPermission(data);
+}
 
-  if (!hasPermission) {
+function assertHoldsAny(data: {
+  props: DatabaseCommonInteractionProps;
+  projectId: ObjectID;
+  allowed: Array<Permission>;
+  deniedMessage: string;
+}): void {
+  if (
+    !holdsAnyPermission({
+      props: data.props,
+      projectId: data.projectId,
+      allowed: data.allowed,
+    })
+  ) {
     throw new NotAuthorizedException(data.deniedMessage);
   }
 }
@@ -89,6 +137,8 @@ export function assertCanAdvanceRunbookExecutions(
 export default {
   RUNBOOK_EXECUTE_PERMISSIONS,
   RUNBOOK_ADVANCE_PERMISSIONS,
+  holdsAnyPermission,
+  holdsAnyUnblockedPermission,
   assertCanExecuteRunbooks,
   assertCanAdvanceRunbookExecutions,
 };