@oneuptime/common 14.0.9 → 14.0.11

package/Server/Services/HostService.ts

@@ -3,7 +3,15 @@ import HostLabelRuleEngineService from "./HostLabelRuleEngineService";
 import HostOwnerRuleEngineService from "./HostOwnerRuleEngineService";
 import Model from "../../Models/DatabaseModels/Host";
 import Label from "../../Models/DatabaseModels/Label";
-import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
+import { OnCreate, OnDelete, OnUpdate } from "../Types/Database/Hooks";
+import CreateBy from "../Types/Database/CreateBy";
+import DeleteBy from "../Types/Database/DeleteBy";
+import UpdateBy from "../Types/Database/UpdateBy";
+import ResourceAiAccessSettings, {
+  ResourceAiAccessFeedItem,
+} from "../Utils/AI/ResourceAccess/ResourceAiAccessSettings";
+import ResourceAiDeleteCleanup from "../Utils/AI/ResourceAccess/ResourceAiDeleteCleanup";
+import AiResourceType from "../../Types/ResourceAiAgent/AiResourceType";
 import HostFeedService from "./HostFeedService";
 import { HostFeedEventType } from "../../Models/DatabaseModels/HostFeed";
 import ResourceFeedUtil from "../Utils/ResourceFeed/ResourceFeedUtil";
@@ -119,6 +127,13 @@ export class Service extends DatabaseService<Model> {
   public async findOrCreateByHostIdentifier(data: {
     projectId: ObjectID;
     hostIdentifier: string;
+    /*
+     * Skip the in-process memo and look the row up (the memo is then
+     * refreshed with what was found or created). For a caller that learned
+     * the memoed id names a host deleted since: the memo is never
+     * invalidated by a delete, so it keeps that id for up to its TTL.
+     */
+    bypassMemo?: boolean | undefined;
   }): Promise<Model> {
     /*
      * Canonicalize the identifier (trim + lowercase, matching
@@ -141,8 +156,9 @@ export class Service extends DatabaseService<Model> {
      * the resolving call performed within the last minute.
      */
     const memoKey: string = `${data.projectId.toString()}:${hostIdentifier}`;
-    const memoedResolution: HostResolution | undefined =
-      hostResolutionInProcessMemo.get(memoKey);
+    const memoedResolution: HostResolution | undefined = data.bypassMemo
+      ? undefined
+      : hostResolutionInProcessMemo.get(memoKey);
     if (memoedResolution) {
       const memoedHost: Model = new Model();
       memoedHost._id = memoedResolution.hostIdStr;
@@ -464,8 +480,14 @@ export class Service extends DatabaseService<Model> {
       cloudAccountId: extra?.cloudAccountId ?? null,
     };
 
+    /*
+     * Change detection only, but the payload carries the cloud account id,
+     * so it is hashed with SHA-256 rather than SHA-1. The value lives in the
+     * heartbeat throttle's cache, so the switch costs each host one extra
+     * metadata write after a deploy, nothing more.
+     */
     return crypto
-      .createHash("sha1")
+      .createHash("sha256")
       .update(JSON.stringify(normalized))
       .digest("hex");
   }
@@ -739,6 +761,79 @@ export class Service extends DatabaseService<Model> {
     });
   }
 
+  /*
+   * Deleting a host settles its in-flight AI remediation rounds and removes its
+   * resource AI agent — read before the delete, done after it for the hosts
+   * actually deleted (ResourceAiDeleteCleanup, shared by every resource AI
+   * agent's resource).
+   */
+  @CaptureSpan()
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<Model>,
+  ): Promise<OnDelete<Model>> {
+    return {
+      deleteBy,
+      carryForward: await ResourceAiDeleteCleanup.beforeDelete({
+        resourceType: AiResourceType.Host,
+        service: this,
+        deleteBy,
+      }),
+    };
+  }
+
+  @CaptureSpan()
+  protected override async onDeleteSuccess(
+    onDelete: OnDelete<Model>,
+    deletedItemIds: Array<ObjectID>,
+  ): Promise<OnDelete<Model>> {
+    await ResourceAiDeleteCleanup.afterDelete({
+      resourceType: AiResourceType.Host,
+      onDelete,
+      deletedItemIds,
+    });
+
+    return onDelete;
+  }
+
+  /*
+   * A create is held to the same AI access rules as an update, judged
+   * against the never-configured defaults a new host starts from: an
+   * unusable mode or allowlist is refused for every caller, and the
+   * server-only aiAccess* columns for every caller but root (a master admin
+   * included, whom the create column ACLs never check).
+   */
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    ResourceAiAccessSettings.checkCreate({
+      resourceType: AiResourceType.Host,
+      createBy,
+    });
+
+    return { createBy, carryForward: null };
+  }
+
+  /*
+   * An operator's write of an AI access setting (the investigation switch, the
+   * remediation mode, the command allowlist) is validated and checked against
+   * who may make AI do more on this host — the rules every resource AI agent's
+   * resource shares (ResourceAiAccessSettings).
+   */
+  @CaptureSpan()
+  protected override async onBeforeUpdate(
+    updateBy: UpdateBy<Model>,
+  ): Promise<OnUpdate<Model>> {
+    return {
+      updateBy,
+      carryForward: await ResourceAiAccessSettings.checkUpdate({
+        resourceType: AiResourceType.Host,
+        service: this,
+        updateBy,
+      }),
+    };
+  }
+
   @CaptureSpan()
   protected override async onUpdateSuccess(
     onUpdate: OnUpdate<Model>,
@@ -750,6 +845,33 @@ export class Service extends DatabaseService<Model> {
       },
     );
 
+    /*
+     * An operator's AI access write: recorded on the feed, and the host marked
+     * AI-configured.
+     */
+    await ResourceAiAccessSettings.afterUpdate({
+      service: this,
+      onUpdate,
+      updatedItemIds,
+      getResourceMarkdownLink: (
+        projectId: ObjectID,
+        hostId: ObjectID,
+      ): Promise<string> => {
+        return this.getHostMarkdownLink(projectId, hostId);
+      },
+      createFeedItem: async (item: ResourceAiAccessFeedItem): Promise<void> => {
+        await HostFeedService.createHostFeedItem({
+          hostId: item.resourceId,
+          projectId: item.projectId,
+          hostFeedEventType: HostFeedEventType.HostUpdated,
+          displayColor: item.displayColor,
+          feedInfoInMarkdown: item.feedInfoInMarkdown,
+          moreInformationInMarkdown: item.moreInformationInMarkdown,
+          userId: item.userId,
+        });
+      },
+    });
+
     return onUpdate;
   }
 

package/Server/Services/IncidentCustomFieldService.ts

@@ -1,4 +1,5 @@
 import DatabaseService from "./DatabaseService";
+import IncidentFormService from "./IncidentFormService";
 import IncidentService from "./IncidentService";
 import IncidentTemplateService from "./IncidentTemplateService";
 import Model from "../../Models/DatabaseModels/IncidentCustomField";
@@ -9,10 +10,12 @@ import LIMIT_MAX from "../../Types/Database/LimitMax";
 import Dictionary from "../../Types/Dictionary";
 import ObjectID from "../../Types/ObjectID";
 import CreateBy from "../Types/Database/CreateBy";
+import DeleteBy from "../Types/Database/DeleteBy";
 import QueryHelper from "../Types/Database/QueryHelper";
 import Query from "../Types/Database/Query";
 import UpdateBy from "../Types/Database/UpdateBy";
-import { OnCreate, OnUpdate } from "../Types/Database/Hooks";
+import { OnCreate, OnDelete, OnUpdate } from "../Types/Database/Hooks";
+import logger, { LogAttributes } from "../Utils/Logger";
 import { backfillMappedCustomFieldValues } from "../Utils/CustomField/CustomFieldDefinitionMappingHooks";
 import {
   validateCustomFieldMappingOnCreate,
@@ -33,7 +36,9 @@ import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
  *
  *   - its template key (variableKey), made from the name on create and never
  *     changed afterwards, so templates that use {{customFields.<key>}} keep
- *     working whatever the field is renamed to;
+ *     working whatever the field is renamed to - and taken off every
+ *     incident form's questions when the field is deleted (see
+ *     onDeleteSuccess);
  *   - its name, which is what incidents store its values under. Renaming a
  *     field moves those values, and the saved views that name it, to the new
  *     name (see onUpdateSuccess).
@@ -48,6 +53,17 @@ type RenameCarryForward = Dictionary<{
   projectId: ObjectID;
 }> | null;
 
+/*
+ * What onBeforeDelete hands to onDeleteSuccess: each field the delete may
+ * remove, with the project and template key it is known by - read before
+ * the rows are gone.
+ */
+type DeleteCarryForward = Array<{
+  id: string;
+  projectId: ObjectID;
+  variableKey: string;
+}> | null;
+
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
@@ -89,6 +105,100 @@ export class Service extends DatabaseService<Model> {
     return { updateBy, carryForward: carryForward };
   }
 
+  /*
+   * The fields this delete may remove, read while they still exist: once
+   * they are gone, nothing says which forms asked them. As root, and limited
+   * to the caller's project, as prepareRename reads - the delete's own
+   * permission check has not run yet; onDeleteSuccess only acts on the rows
+   * it actually removed.
+   */
+  @CaptureSpan()
+  protected override async onBeforeDelete(
+    deleteBy: DeleteBy<Model>,
+  ): Promise<OnDelete<Model>> {
+    const query: Query<Model> =
+      !deleteBy.props.isRoot && deleteBy.props.tenantId
+        ? {
+            ...deleteBy.query,
+            projectId: deleteBy.props.tenantId,
+          }
+        : deleteBy.query;
+
+    const fields: Array<Model> = await this.findBy({
+      query: query,
+      select: {
+        _id: true,
+        projectId: true,
+        variableKey: true,
+      },
+      limit: LIMIT_MAX,
+      skip: 0,
+      props: {
+        isRoot: true,
+      },
+    });
+
+    const carryForward: DeleteCarryForward = [];
+
+    for (const field of fields) {
+      if (field.id && field.projectId && field.variableKey) {
+        carryForward.push({
+          id: field.id.toString(),
+          projectId: field.projectId,
+          variableKey: field.variableKey,
+        });
+      }
+    }
+
+    return { deleteBy, carryForward: carryForward };
+  }
+
+  /*
+   * A deleted field is taken off every incident form of its project (see
+   * IncidentFormService.removeCustomFieldFromQuestions): otherwise a field
+   * created later under the same key would appear on those public forms at
+   * once. Incident templates keep their settings for it, on purpose.
+   *
+   * The field is already gone, so a failure here is logged rather than
+   * thrown: the delete stands either way.
+   */
+  @CaptureSpan()
+  protected override async onDeleteSuccess(
+    onDelete: OnDelete<Model>,
+    itemIdsBeforeDelete: Array<ObjectID>,
+  ): Promise<OnDelete<Model>> {
+    const deletedIds: Set<string> = new Set<string>(
+      itemIdsBeforeDelete.map((id: ObjectID): string => {
+        return id.toString();
+      }),
+    );
+
+    for (const field of (onDelete.carryForward as DeleteCarryForward) || []) {
+      if (!deletedIds.has(field.id)) {
+        continue;
+      }
+
+      try {
+        await IncidentFormService.removeCustomFieldFromQuestions({
+          projectId: field.projectId,
+          variableKey: field.variableKey,
+        });
+      } catch (err) {
+        logger.error(
+          `IncidentCustomFieldService: could not take the deleted incident custom field "${field.variableKey}" off the incident forms of project ${field.projectId.toString()}; a field created later with the same key would be asked on them.`,
+          {
+            projectId: field.projectId.toString(),
+          } as LogAttributes,
+        );
+        logger.error(err, {
+          projectId: field.projectId.toString(),
+        } as LogAttributes);
+      }
+    }
+
+    return onDelete;
+  }
+
   @CaptureSpan()
   protected override async onCreateSuccess(
     _onCreate: OnCreate<Model>,

package/Server/Services/IncidentEpisodeMemberService.ts

@@ -17,9 +17,29 @@ import { IncidentEpisodeFeedEventType } from "../../Models/DatabaseModels/Incide
 import { IncidentFeedEventType } from "../../Models/DatabaseModels/IncidentFeed";
 import { Yellow500, Green500 } from "../../Types/BrandColors";
 import OneUptimeDate from "../../Types/Date";
+import { escapeMarkdownValue } from "../../Utils/Markdown/MarkdownEscape";
 import IncidentService from "./IncidentService";
 import IncidentEpisodeService from "./IncidentEpisodeService";
 
+/*
+ * An incident's or an episode's title is plain text - an incident's is typed
+ * by whoever declared it, which is anyone holding an incident form's link,
+ * and an episode's is often copied from its first incident's - and the feed
+ * items below place it into Markdown that the dashboard renders without its
+ * safe mode and that is posted to Slack and Teams. Escaped as MarkdownEscape
+ * says a title must be (as the incident's own "Incident Created" item does),
+ * so "![](https://tracker...)" is not fetched and "[Reset your password](...)"
+ * is not a link that hides where it goes, while an ordinary title reads as
+ * typed.
+ */
+type GetFeedTitleFunction = (title: string | undefined | null) => string;
+
+const getFeedTitle: GetFeedTitleFunction = (
+  title: string | undefined | null,
+): string => {
+  return escapeMarkdownValue(title || "No title");
+};
+
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
@@ -174,7 +194,7 @@ export class Service extends DatabaseService<Model> {
       projectId: createdItem.projectId,
       incidentEpisodeFeedEventType: IncidentEpisodeFeedEventType.IncidentAdded,
       displayColor: Yellow500,
-      feedInfoInMarkdown: `**Incident ${incident?.incidentNumberWithPrefix || "#" + (incident?.incidentNumber || "N/A")}** added to episode: ${incident?.title || "No title"}`,
+      feedInfoInMarkdown: `**Incident ${incident?.incidentNumberWithPrefix || "#" + (incident?.incidentNumber || "N/A")}** added to episode: ${getFeedTitle(incident?.title)}`,
       userId: createdItem.addedByUserId || undefined,
       workspaceNotification: {
         sendWorkspaceNotification: true,
@@ -188,7 +208,7 @@ export class Service extends DatabaseService<Model> {
       projectId: createdItem.projectId,
       incidentFeedEventType: IncidentFeedEventType.IncidentUpdated,
       displayColor: Yellow500,
-      feedInfoInMarkdown: `Added to **Episode ${episode?.episodeNumberWithPrefix || "#" + (episode?.episodeNumber || "N/A")}**: ${episode?.title || "No title"}`,
+      feedInfoInMarkdown: `Added to **Episode ${episode?.episodeNumberWithPrefix || "#" + (episode?.episodeNumber || "N/A")}**: ${getFeedTitle(episode?.title)}`,
       userId: createdItem.addedByUserId || undefined,
     });
 
@@ -277,7 +297,7 @@ export class Service extends DatabaseService<Model> {
               incidentEpisodeFeedEventType:
                 IncidentEpisodeFeedEventType.IncidentRemoved,
               displayColor: Green500,
-              feedInfoInMarkdown: `**Incident ${incident?.incidentNumberWithPrefix || "#" + (incident?.incidentNumber || "N/A")}** removed from episode: ${incident?.title || "No title"}`,
+              feedInfoInMarkdown: `**Incident ${incident?.incidentNumberWithPrefix || "#" + (incident?.incidentNumber || "N/A")}** removed from episode: ${getFeedTitle(incident?.title)}`,
               workspaceNotification: {
                 sendWorkspaceNotification: true,
               },
@@ -289,7 +309,7 @@ export class Service extends DatabaseService<Model> {
               projectId: member.projectId,
               incidentFeedEventType: IncidentFeedEventType.IncidentUpdated,
               displayColor: Green500,
-              feedInfoInMarkdown: `Removed from **Episode ${episode?.episodeNumberWithPrefix || "#" + (episode?.episodeNumber || "N/A")}**: ${episode?.title || "No title"}`,
+              feedInfoInMarkdown: `Removed from **Episode ${episode?.episodeNumberWithPrefix || "#" + (episode?.episodeNumber || "N/A")}**: ${getFeedTitle(episode?.title)}`,
             });
           }
         }

package/Server/Services/IncidentEpisodeService.ts

@@ -14,6 +14,7 @@ import Model from "../../Models/DatabaseModels/IncidentEpisode";
 import IncidentState from "../../Models/DatabaseModels/IncidentState";
 import IncidentSeverity from "../../Models/DatabaseModels/IncidentSeverity";
 import SortOrder from "../../Types/BaseDatabase/SortOrder";
+import { escapeMarkdownValue } from "../../Utils/Markdown/MarkdownEscape";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import SubscriberNotificationResendAccess from "../Utils/StatusPage/SubscriberNotificationResendAccess";
 import logger, { LogAttributes } from "../Utils/Logger";
@@ -468,9 +469,17 @@ export class Service extends DatabaseService<Model> {
       return;
     }
 
+    /*
+     * The title is plain text, often copied from the episode's first
+     * incident - whose title anyone holding an incident form's link may
+     * have typed - placed into Markdown the dashboard renders without its
+     * safe mode and posts to Slack and Teams. Escaped as MarkdownEscape
+     * says a title must be, so it cannot become an image, raw HTML or a
+     * link that hides where it goes. The description stays Markdown.
+     */
     let feedInfoInMarkdown: string = `#### Episode ${episode.episodeNumberWithPrefix || "#" + episode.episodeNumber?.toString()} Created
 
-**${episode.title || "No title provided."}**
+**${escapeMarkdownValue(episode.title || "No title provided.")}**
 
 `;