@oneuptime/common 13.0.6 → 13.0.8

package/Types/AI/AIChatPageContext.ts

@@ -1,12 +1,19 @@
 import { JSONObject } from "../JSON";
+import {
+  AIResourceSubresource,
+  AIResourceType,
+  isAIResourceSubresourceKind,
+  isAIResourceType,
+} from "./AIResourceContext";
 
 /*
  * "Page context" makes Ask AI aware of what the user is looking at in the
  * dashboard. The client detects the current page (an incident, a monitor, a
  * trace waterfall, the logs explorer, …) and attaches this small descriptor to
  * each message it sends; the server folds it into the system prompt so "this
- * incident" resolves to the entity on screen. It is a per-turn hint, never
- * persisted — the user can detach it in the composer at any time.
+ * incident" resolves to the entity on screen. The latest context is kept as
+ * the conversation's subject. Sending null explicitly detaches and clears
+ * that subject; omitting context lets a full-page conversation keep it.
  */
 enum AIChatPageContextType {
   // Entity pages — carry the entity's id (and usually a display title).
@@ -15,6 +22,8 @@ enum AIChatPageContextType {
   Monitor = "Monitor",
   ScheduledMaintenanceEvent = "ScheduledMaintenanceEvent",
   TelemetryService = "TelemetryService",
+  RumApplication = "RumApplication",
+  Resource = "Resource",
   Trace = "Trace",
   Exception = "Exception",
 
@@ -27,6 +36,9 @@ enum AIChatPageContextType {
   TracesExplorer = "TracesExplorer",
   MetricsExplorer = "MetricsExplorer",
   ExceptionsList = "ExceptionsList",
+  RumApplications = "RumApplications",
+  TelemetryServicesList = "TelemetryServicesList",
+  ResourcesList = "ResourcesList",
 }
 
 export default AIChatPageContextType;
@@ -37,6 +49,8 @@ export interface AIChatPageContext {
   entityId?: string | undefined;
   // Display title of the entity (incident title, monitor name, …). Optional.
   entityTitle?: string | undefined;
+  resourceType?: AIResourceType | undefined;
+  subresource?: AIResourceSubresource | undefined;
 }
 
 /*
@@ -58,11 +72,28 @@ const ENTITY_TYPES: Array<AIChatPageContextType> = [
   AIChatPageContextType.Monitor,
   AIChatPageContextType.ScheduledMaintenanceEvent,
   AIChatPageContextType.TelemetryService,
+  AIChatPageContextType.RumApplication,
+  AIChatPageContextType.Resource,
   AIChatPageContextType.Trace,
   AIChatPageContextType.Exception,
 ];
 
 export class AIChatPageContextHelper {
+  /*
+   * Titles are presentation hints; only the resource and child identity decide
+   * whether navigation has selected a different conversation subject.
+   */
+  public static getIdentity(context: AIChatPageContext): string {
+    return JSON.stringify([
+      context.type,
+      context.entityId || null,
+      context.resourceType || null,
+      context.subresource?.kind || null,
+      context.subresource?.key || null,
+      context.subresource?.namespace || null,
+    ]);
+  }
+
   public static isValidType(
     value: string | undefined,
   ): value is AIChatPageContextType {
@@ -97,6 +128,16 @@ export class AIChatPageContextHelper {
 
     const context: AIChatPageContext = { type: type };
 
+    if (
+      type === AIChatPageContextType.Resource ||
+      type === AIChatPageContextType.ResourcesList
+    ) {
+      if (!isAIResourceType(json["resourceType"])) {
+        return undefined;
+      }
+      context.resourceType = json["resourceType"];
+    }
+
     if (this.isEntityType(type)) {
       const entityId: string =
         typeof json["entityId"] === "string"
@@ -113,6 +154,50 @@ export class AIChatPageContextHelper {
 
       context.entityId = entityId;
 
+      if (
+        type === AIChatPageContextType.Resource &&
+        json["subresource"] !== undefined
+      ) {
+        const raw: unknown = json["subresource"];
+        if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+          return undefined;
+        }
+        const child: JSONObject = raw as JSONObject;
+        if (
+          !context.resourceType ||
+          !isAIResourceSubresourceKind(context.resourceType, child["kind"])
+        ) {
+          return undefined;
+        }
+        const subresource: AIResourceSubresource = { kind: child["kind"] };
+        if (child["key"] !== undefined) {
+          // eslint-disable-next-line no-control-regex
+          const controlCharacters: RegExp = /[\u0000-\u001F\u007F]/;
+          if (
+            typeof child["key"] !== "string" ||
+            !child["key"].trim() ||
+            child["key"].length > 512 ||
+            controlCharacters.test(child["key"])
+          ) {
+            return undefined;
+          }
+          subresource.key = child["key"].trim();
+        }
+        if (child["namespace"] !== undefined) {
+          const namespacePattern: RegExp = /^[a-z0-9](?:[-a-z0-9]*[a-z0-9])?$/;
+          if (
+            context.resourceType !== AIResourceType.KubernetesCluster ||
+            typeof child["namespace"] !== "string" ||
+            child["namespace"].length > 63 ||
+            !namespacePattern.test(child["namespace"])
+          ) {
+            return undefined;
+          }
+          subresource.namespace = child["namespace"];
+        }
+        context.subresource = subresource;
+      }
+
       if (typeof json["entityTitle"] === "string") {
         /*
          * The title is echoed into the system prompt: collapse whitespace and

package/Types/AI/AIChatTypes.ts

@@ -37,6 +37,10 @@ export enum AIChatCitationTargetType {
   Probes = "Probes",
   Teams = "Teams",
   SecurityEvents = "SecurityEvents",
+  RumApplications = "RumApplications",
+  RumApplicationView = "RumApplicationView",
+  TelemetryResources = "TelemetryResources",
+  TelemetryResourceView = "TelemetryResourceView",
 }
 
 export interface AIChatCitationTarget {

package/Types/AI/AIResourceContext.ts

@@ -0,0 +1,198 @@
+import IconProp from "../Icon/IconProp";
+import {
+  RESOURCE_FACET_CATALOG,
+  ResourceFacetDefinition,
+} from "../Telemetry/ResourceFacetCatalog";
+import ServiceType from "../Telemetry/ServiceType";
+
+export enum AIResourceType {
+  Host = "Host",
+  DockerHost = "DockerHost",
+  PodmanHost = "PodmanHost",
+  KubernetesCluster = "KubernetesCluster",
+  DockerSwarmCluster = "DockerSwarmCluster",
+  ProxmoxCluster = "ProxmoxCluster",
+  VMwareVCenter = "VMwareVCenter",
+  CephCluster = "CephCluster",
+  ServerlessFunction = "ServerlessFunction",
+  CloudResource = "CloudResource",
+  IoTFleet = "IoTFleet",
+  NetworkDevice = "NetworkDevice",
+}
+
+export enum AIResourceSubresourceKind {
+  Namespace = "Namespace",
+  Pod = "Pod",
+  Deployment = "Deployment",
+  StatefulSet = "StatefulSet",
+  DaemonSet = "DaemonSet",
+  Job = "Job",
+  CronJob = "CronJob",
+  Node = "Node",
+  Container = "Container",
+  PersistentVolumeClaim = "PersistentVolumeClaim",
+  PersistentVolume = "PersistentVolume",
+  HorizontalPodAutoscaler = "HorizontalPodAutoscaler",
+  VerticalPodAutoscaler = "VerticalPodAutoscaler",
+  Service = "Service",
+  Task = "Task",
+  Stack = "Stack",
+  Network = "Network",
+  Volume = "Volume",
+  Secret = "Secret",
+  Config = "Config",
+  Guest = "Guest",
+  Storage = "Storage",
+  Host = "Host",
+  VirtualMachine = "VirtualMachine",
+  Datastore = "Datastore",
+  Cluster = "Cluster",
+  Osd = "Osd",
+  Pool = "Pool",
+  Device = "Device",
+  Process = "Process",
+  WindowsService = "WindowsService",
+  SystemdUnit = "SystemdUnit",
+  Instance = "Instance",
+  Interface = "Interface",
+}
+
+export interface AIResourceSubresource {
+  kind: AIResourceSubresourceKind;
+  // Child names and external IDs are not OneUptime resource UUIDs.
+  key?: string | undefined;
+  namespace?: string | undefined;
+}
+
+export interface AIResourceDefinition extends ResourceFacetDefinition {
+  type: AIResourceType;
+}
+
+const RESOURCE_FACET_KEYS: Record<AIResourceType, string> = {
+  [AIResourceType.Host]: "hostId",
+  [AIResourceType.DockerHost]: "dockerHostId",
+  [AIResourceType.PodmanHost]: "podmanHostId",
+  [AIResourceType.KubernetesCluster]: "kubernetesClusterId",
+  [AIResourceType.DockerSwarmCluster]: "dockerSwarmClusterId",
+  [AIResourceType.ProxmoxCluster]: "proxmoxClusterId",
+  [AIResourceType.VMwareVCenter]: "vmwareVCenterId",
+  [AIResourceType.CephCluster]: "cephClusterId",
+  [AIResourceType.ServerlessFunction]: "serverlessFunctionId",
+  [AIResourceType.CloudResource]: "cloudResourceId",
+  [AIResourceType.IoTFleet]: "iotFleetId",
+  [AIResourceType.NetworkDevice]: "networkDeviceId",
+};
+
+/*
+ * Reuse the telemetry catalog's labels and type discriminators, including
+ * IoTFleet's historical IoTDevice discriminator. Network devices have no facet.
+ */
+export const AI_RESOURCE_DEFINITIONS: ReadonlyArray<AIResourceDefinition> =
+  Object.values(AIResourceType).map(
+    (type: AIResourceType): AIResourceDefinition => {
+      const facetKey: string = RESOURCE_FACET_KEYS[type];
+      if (type === AIResourceType.NetworkDevice) {
+        return {
+          type,
+          facetKey,
+          serviceType: ServiceType.NetworkDevice,
+          label: "Network Device",
+          pluralLabel: "Network Devices",
+          icon: IconProp.Server,
+        };
+      }
+
+      const definition: ResourceFacetDefinition | undefined =
+        RESOURCE_FACET_CATALOG.find(
+          (item: ResourceFacetDefinition): boolean => {
+            return item.facetKey === facetKey;
+          },
+        );
+      if (!definition) {
+        throw new Error(`Missing resource facet definition: ${type}`);
+      }
+      return { ...definition, type };
+    },
+  );
+
+export function getAIResourceDefinition(
+  type: AIResourceType,
+): AIResourceDefinition {
+  const definition: AIResourceDefinition | undefined =
+    AI_RESOURCE_DEFINITIONS.find((item: AIResourceDefinition): boolean => {
+      return item.type === type;
+    });
+  if (!definition) {
+    throw new Error(`Unknown AI resource type: ${type}`);
+  }
+  return definition;
+}
+
+export function isAIResourceType(value: unknown): value is AIResourceType {
+  return Object.values(AIResourceType).includes(value as AIResourceType);
+}
+
+export const AI_RESOURCE_SUBRESOURCE_KINDS: Readonly<
+  Record<AIResourceType, ReadonlyArray<AIResourceSubresourceKind>>
+> = {
+  [AIResourceType.Host]: [
+    AIResourceSubresourceKind.Process,
+    AIResourceSubresourceKind.WindowsService,
+    AIResourceSubresourceKind.SystemdUnit,
+  ],
+  [AIResourceType.DockerHost]: [AIResourceSubresourceKind.Container],
+  [AIResourceType.PodmanHost]: [AIResourceSubresourceKind.Container],
+  [AIResourceType.KubernetesCluster]: [
+    AIResourceSubresourceKind.Namespace,
+    AIResourceSubresourceKind.Pod,
+    AIResourceSubresourceKind.Deployment,
+    AIResourceSubresourceKind.StatefulSet,
+    AIResourceSubresourceKind.DaemonSet,
+    AIResourceSubresourceKind.Job,
+    AIResourceSubresourceKind.CronJob,
+    AIResourceSubresourceKind.Node,
+    AIResourceSubresourceKind.Container,
+    AIResourceSubresourceKind.PersistentVolumeClaim,
+    AIResourceSubresourceKind.PersistentVolume,
+    AIResourceSubresourceKind.HorizontalPodAutoscaler,
+    AIResourceSubresourceKind.VerticalPodAutoscaler,
+  ],
+  [AIResourceType.DockerSwarmCluster]: [
+    AIResourceSubresourceKind.Node,
+    AIResourceSubresourceKind.Service,
+    AIResourceSubresourceKind.Task,
+    AIResourceSubresourceKind.Stack,
+    AIResourceSubresourceKind.Network,
+    AIResourceSubresourceKind.Volume,
+    AIResourceSubresourceKind.Secret,
+    AIResourceSubresourceKind.Config,
+  ],
+  [AIResourceType.ProxmoxCluster]: [
+    AIResourceSubresourceKind.Node,
+    AIResourceSubresourceKind.Guest,
+    AIResourceSubresourceKind.Storage,
+  ],
+  [AIResourceType.VMwareVCenter]: [
+    AIResourceSubresourceKind.Host,
+    AIResourceSubresourceKind.VirtualMachine,
+    AIResourceSubresourceKind.Datastore,
+    AIResourceSubresourceKind.Cluster,
+  ],
+  [AIResourceType.CephCluster]: [
+    AIResourceSubresourceKind.Osd,
+    AIResourceSubresourceKind.Pool,
+  ],
+  [AIResourceType.IoTFleet]: [AIResourceSubresourceKind.Device],
+  [AIResourceType.ServerlessFunction]: [AIResourceSubresourceKind.Instance],
+  [AIResourceType.CloudResource]: [AIResourceSubresourceKind.Instance],
+  [AIResourceType.NetworkDevice]: [AIResourceSubresourceKind.Interface],
+};
+
+export function isAIResourceSubresourceKind(
+  type: AIResourceType,
+  value: unknown,
+): value is AIResourceSubresourceKind {
+  return AI_RESOURCE_SUBRESOURCE_KINDS[type].includes(
+    value as AIResourceSubresourceKind,
+  );
+}

package/Types/AI/InvestigationNotStartedReason.ts

@@ -0,0 +1,30 @@
+export type InvestigationNotStartedCode =
+  | "ai_disabled"
+  | "automatic_investigation_disabled"
+  | "provider_missing"
+  | "severity_below_threshold"
+  | "monitor_cooldown"
+  | "daily_budget_exhausted"
+  | "budget_check_failed"
+  | "enqueue_failed"
+  | "eligibility_check_failed"
+  | "no_run_recorded";
+
+/**
+ * A recorded decision is evidence from the creation hook. Current settings
+ * explain eligibility now, and must never be presented as a historical fact.
+ */
+export default interface InvestigationNotStartedReason {
+  code: InvestigationNotStartedCode;
+  title: string;
+  description: string;
+  nextStep: string;
+  source: "recorded" | "current_configuration" | "unknown";
+  evaluatedAt: string;
+}
+
+export interface InvestigationGateDetails {
+  severityName?: string | undefined;
+  minimumSeverityName?: string | undefined;
+  cooldownWindowMinutes?: number | undefined;
+}

package/Types/BaseDatabase/DatabaseCommonInteractionPropsUtil.ts

@@ -1,5 +1,7 @@
 import Permission, { UserPermission } from "../Permission";
 import DatabaseCommonInteractionProps from "./DatabaseCommonInteractionProps";
+import NotAuthenticatedException from "../Exception/NotAuthenticatedException";
+import UserType from "../UserType";
 
 export enum PermissionType {
   Allow = "Allow",
@@ -7,6 +9,44 @@ export enum PermissionType {
 }
 
 export default class DatabaseCommonInteractionPropsUtil {
+  public static readonly AUTHENTICATION_REQUIRED_MESSAGE: string =
+    "Authentication required. Please log in to access this resource.";
+
+  /*
+   * No credentials at all: no user, no project API key, no master key.
+   *
+   * In practice this is almost never a stranger. The dashboard's access-token
+   * cookie expires together with the JWT inside it, so once a tab has sat idle
+   * past the token lifetime the browser simply stops sending it, and
+   * getUserMiddleware lets the request through as Public with no userId. The
+   * caller is a signed-in user whose session needs refreshing.
+   */
+  public static isAnonymous(props: DatabaseCommonInteractionProps): boolean {
+    if (props.userId) {
+      return false;
+    }
+
+    return (
+      props.userType !== UserType.API && props.userType !== UserType.MasterAdmin
+    );
+  }
+
+  /*
+   * "Who are you?" comes before "may you?". An anonymous caller has to be
+   * refused with 401, never 422 or 400: the browser client refreshes the
+   * session and replays the request on a 401 and on nothing else, so any other
+   * status leaves a signed-in user looking at a bogus error.
+   */
+  public static assertCredentialsPresent(
+    props: DatabaseCommonInteractionProps,
+  ): void {
+    if (DatabaseCommonInteractionPropsUtil.isAnonymous(props)) {
+      throw new NotAuthenticatedException(
+        DatabaseCommonInteractionPropsUtil.AUTHENTICATION_REQUIRED_MESSAGE,
+      );
+    }
+  }
+
   public static getUserPermissions(
     props: DatabaseCommonInteractionProps,
     permissionType: PermissionType,

package/Types/Database/UniqueColumnsTogether.ts

@@ -0,0 +1,55 @@
+import GenericFunction from "../GenericFunction";
+
+/*
+ * Declares that no two rows of a model may share the same values across
+ * `columnNames`. DatabaseService.create looks for an existing row with those
+ * values before inserting and, if there is one, rejects the insert with
+ * `errorMessage` instead of writing a second row.
+ *
+ * WHY THIS EXISTS
+ *
+ * Join rows such as <Resource>OwnerTeam / <Resource>OwnerUser have side effects
+ * on create: each new row writes a feed item and notifies the owner. The
+ * dashboard hides owners that are already attached, but the REST API,
+ * workflows and internal callers all insert directly, so a duplicate row used
+ * to mean a duplicate notification (issue #3394).
+ *
+ * This is the application half of the guarantee. Declare the same columns in
+ * an `@Index([...], { unique: true })` on the entity as well: a check before an
+ * insert cannot stop two concurrent writers, and only the database can.
+ * PostgresErrorTranslator.isUniqueViolation() recognises the rejection from
+ * either layer, so a caller that wants "already there" to be a no-op needs a
+ * single check.
+ *
+ * Only creates are checked. Rows are expected to be re-keyed rarely, if ever,
+ * and the unique index covers updates.
+ */
+
+export interface UniqueColumnsTogetherMetadata {
+  columnNames: Array<string>;
+  errorMessage: string;
+}
+
+export default (columnNames: Array<string>, errorMessage: string) => {
+  return (ctr: GenericFunction) => {
+    /*
+     * Stackable. Read only this class's own list: a subclass must not
+     * append to the list its parent keeps on the parent's prototype.
+     */
+    const existing: Array<UniqueColumnsTogetherMetadata> =
+      Object.prototype.hasOwnProperty.call(
+        ctr.prototype,
+        "uniqueColumnsTogether",
+      )
+        ? ctr.prototype.uniqueColumnsTogether
+        : [];
+
+    ctr.prototype.uniqueColumnsTogether = [
+      ...existing,
+      {
+        columnNames: [...columnNames],
+        errorMessage: errorMessage,
+      },
+    ];
+  };
+};

package/Types/Metrics/MetricQueryConfigData.ts

@@ -1,6 +1,7 @@
 import AggregatedModel from "../BaseDatabase/AggregatedModel";
 import MetricAliasData from "./MetricAliasData";
 import MetricQueryData from "./MetricQueryData";
+import MetricsQuery from "./MetricsQuery";
 
 export enum MetricChartType {
   LINE = "line",
@@ -25,6 +26,13 @@ export default interface MetricQueryConfigData {
   id?: string | undefined;
   metricAliasData?: MetricAliasData | undefined;
   metricQueryData: MetricQueryData;
+  /**
+   * Resource identity for event markers when the metric list is scoped by
+   * entity membership instead of telemetry attributes (e.g. RUM, Inventory).
+   * Kept separate from the metric filter: these identifiers are not stored
+   * in its attributes map. An explicit empty scope suppresses event markers.
+   */
+  eventScope?: MetricsQuery["attributes"] | undefined;
   getSeries?: ((data: AggregatedModel) => ChartSeries) | undefined;
   chartType?: MetricChartType | undefined;
   yAxisValueFormatter?: ((value: number) => string) | undefined;

package/Types/Monitor/MonitorEvaluationSummary.ts

@@ -45,9 +45,12 @@ export interface MonitorEvaluationEvent {
   relatedIncidentId?: string | undefined;
   relatedIncidentNumber?: number | undefined;
   relatedIncidentNumberWithPrefix?: string | undefined;
+  relatedIncidentCreatedAt?: Date | undefined;
   relatedAlertId?: string | undefined;
   relatedAlertNumber?: number | undefined;
   relatedAlertNumberWithPrefix?: string | undefined;
+  relatedAlertCreatedAt?: Date | undefined;
+  // When this action occurred, distinct from an already-active entity's creation.
   at?: Date | undefined;
 }