@oneuptime/common 11.5.4 → 11.5.6

package/Tests/UI/Utils/TableColumnsToCsv.test.ts

@@ -0,0 +1,523 @@
+import { afterEach, beforeEach, describe, expect, test } from "@jest/globals";
+import getJestMockFunction, { MockFunction } from "../../MockType";
+import TableColumnsToCsv from "../../../UI/Utils/TableColumnsToCsv";
+import Column from "../../../UI/Components/Table/Types/Column";
+import Columns from "../../../UI/Components/Table/Types/Columns";
+import FieldType from "../../../UI/Components/Types/FieldType";
+import OneUptimeDate from "../../../Types/Date";
+import ObjectID from "../../../Types/ObjectID";
+
+/*
+ * Concrete row shape used across the tests. A real ModelTable passes model
+ * instances, but the utility only relies on property access / getColumnValue,
+ * so plain objects exercise the same code paths.
+ */
+interface Row {
+  name?: string | undefined;
+  status?: string | undefined;
+  isActive?: boolean | undefined;
+  count?: number | undefined;
+  label?: { name?: string } | null | undefined;
+  severityText?: string | undefined;
+  _id?: string | undefined;
+}
+
+describe("TableColumnsToCsv", () => {
+  describe("escapeCsvValue", () => {
+    test("leaves a plain value untouched", () => {
+      expect(TableColumnsToCsv.escapeCsvValue("hello")).toBe("hello");
+    });
+
+    test("leaves an empty string untouched", () => {
+      expect(TableColumnsToCsv.escapeCsvValue("")).toBe("");
+    });
+
+    test("quotes a value that contains a comma", () => {
+      expect(TableColumnsToCsv.escapeCsvValue("a,b")).toBe('"a,b"');
+    });
+
+    test("quotes and doubles embedded quotes", () => {
+      expect(TableColumnsToCsv.escapeCsvValue('she said "hi"')).toBe(
+        '"she said ""hi"""',
+      );
+    });
+
+    test("quotes a value that contains a newline", () => {
+      expect(TableColumnsToCsv.escapeCsvValue("line1\nline2")).toBe(
+        '"line1\nline2"',
+      );
+    });
+
+    test("quotes a value that contains a carriage return", () => {
+      expect(TableColumnsToCsv.escapeCsvValue("line1\r\nline2")).toBe(
+        '"line1\r\nline2"',
+      );
+    });
+  });
+
+  describe("sanitizeForCsvInjection", () => {
+    test("prefixes a value starting with =", () => {
+      expect(TableColumnsToCsv.sanitizeForCsvInjection("=1+1")).toBe("'=1+1");
+    });
+
+    test("prefixes a value starting with +", () => {
+      expect(TableColumnsToCsv.sanitizeForCsvInjection("+A1")).toBe("'+A1");
+    });
+
+    test("prefixes a value starting with @", () => {
+      expect(TableColumnsToCsv.sanitizeForCsvInjection("@SUM(A1)")).toBe(
+        "'@SUM(A1)",
+      );
+    });
+
+    test("prefixes a value starting with a tab", () => {
+      expect(TableColumnsToCsv.sanitizeForCsvInjection("\tvalue")).toBe(
+        "'\tvalue",
+      );
+    });
+
+    test("does not prefix a negative number so numbers survive", () => {
+      expect(TableColumnsToCsv.sanitizeForCsvInjection("-5")).toBe("-5");
+    });
+
+    test("does not prefix a normal value", () => {
+      expect(TableColumnsToCsv.sanitizeForCsvInjection("normal")).toBe(
+        "normal",
+      );
+    });
+
+    test("leaves an empty string untouched", () => {
+      expect(TableColumnsToCsv.sanitizeForCsvInjection("")).toBe("");
+    });
+  });
+
+  describe("getRawValueByPath", () => {
+    test("reads a top-level property from a plain object", () => {
+      expect(
+        TableColumnsToCsv.getRawValueByPath({ name: "Prod" }, "name"),
+      ).toBe("Prod");
+    });
+
+    test("reads a nested property with dot notation", () => {
+      const item: Row = { label: { name: "Critical" } };
+      expect(TableColumnsToCsv.getRawValueByPath(item, "label.name")).toBe(
+        "Critical",
+      );
+    });
+
+    test("preserves the falsy value false (does not treat it as missing)", () => {
+      expect(
+        TableColumnsToCsv.getRawValueByPath({ isActive: false }, "isActive"),
+      ).toBe(false);
+    });
+
+    test("preserves the falsy value 0", () => {
+      expect(TableColumnsToCsv.getRawValueByPath({ count: 0 }, "count")).toBe(
+        0,
+      );
+    });
+
+    test("returns undefined for a missing key", () => {
+      expect(
+        TableColumnsToCsv.getRawValueByPath({ name: "x" }, "missing"),
+      ).toBeUndefined();
+    });
+
+    test("stops and returns the nullish value when a branch is null", () => {
+      const item: Row = { label: null };
+      expect(
+        TableColumnsToCsv.getRawValueByPath(item, "label.name"),
+      ).toBeNull();
+    });
+
+    test("a null branch formats to an empty CSV cell", () => {
+      const column: Column<Row> = {
+        title: "Label",
+        type: FieldType.Text,
+        key: "label.name" as keyof Row,
+      };
+      expect(TableColumnsToCsv.getCellValue({ label: null }, column)).toBe("");
+    });
+
+    test("falls back to getColumnValue for analytics-style models", () => {
+      // Analytics models keep values in an internal map, only reachable via getColumnValue.
+      const analyticsLike: {
+        data: Record<string, unknown>;
+        getColumnValue: (name: string) => unknown;
+      } = {
+        data: { severityText: "Error" },
+        getColumnValue(name: string): unknown {
+          return this.data[name];
+        },
+      };
+
+      expect(
+        TableColumnsToCsv.getRawValueByPath(analyticsLike, "severityText"),
+      ).toBe("Error");
+    });
+
+    test("prefers direct property access over getColumnValue", () => {
+      const hybrid: { name: string; getColumnValue: () => unknown } = {
+        name: "direct",
+        getColumnValue(): unknown {
+          return "from-getter";
+        },
+      };
+
+      expect(TableColumnsToCsv.getRawValueByPath(hybrid, "name")).toBe(
+        "direct",
+      );
+    });
+  });
+
+  describe("formatValueForCsv", () => {
+    test("returns empty string for null", () => {
+      expect(TableColumnsToCsv.formatValueForCsv(null, FieldType.Text)).toBe(
+        "",
+      );
+    });
+
+    test("returns empty string for undefined", () => {
+      expect(
+        TableColumnsToCsv.formatValueForCsv(undefined, FieldType.Text),
+      ).toBe("");
+    });
+
+    test("formats a Date column using the friendly date-only format", () => {
+      const date: Date = new Date("2024-01-31T10:30:00.000Z");
+      expect(TableColumnsToCsv.formatValueForCsv(date, FieldType.Date)).toBe(
+        OneUptimeDate.getDateAsUserFriendlyLocalFormattedString(date, true),
+      );
+    });
+
+    test("formats a DateTime column using the friendly date+time format", () => {
+      const date: Date = new Date("2024-01-31T10:30:00.000Z");
+      expect(
+        TableColumnsToCsv.formatValueForCsv(date, FieldType.DateTime),
+      ).toBe(
+        OneUptimeDate.getDateAsUserFriendlyLocalFormattedString(date, false),
+      );
+    });
+
+    test("formats an ISO date string for a Date column", () => {
+      const iso: string = "2024-01-31T10:30:00.000Z";
+      expect(TableColumnsToCsv.formatValueForCsv(iso, FieldType.Date)).toBe(
+        OneUptimeDate.getDateAsUserFriendlyLocalFormattedString(iso, true),
+      );
+    });
+
+    test("formats Boolean true as Yes", () => {
+      expect(TableColumnsToCsv.formatValueForCsv(true, FieldType.Boolean)).toBe(
+        "Yes",
+      );
+    });
+
+    test("formats Boolean false as No", () => {
+      expect(
+        TableColumnsToCsv.formatValueForCsv(false, FieldType.Boolean),
+      ).toBe("No");
+    });
+
+    test("formats USDCents into dollars", () => {
+      expect(
+        TableColumnsToCsv.formatValueForCsv(2500, FieldType.USDCents),
+      ).toBe("25 USD");
+    });
+
+    test("formats a Percent value", () => {
+      expect(TableColumnsToCsv.formatValueForCsv(80, FieldType.Percent)).toBe(
+        "80%",
+      );
+    });
+
+    test("stringifies a plain number for a Number column", () => {
+      expect(TableColumnsToCsv.formatValueForCsv(42, FieldType.Number)).toBe(
+        "42",
+      );
+    });
+
+    test("uses a value's custom toString (ObjectID)", () => {
+      const id: ObjectID = new ObjectID("resource-123");
+      expect(TableColumnsToCsv.formatValueForCsv(id, FieldType.ObjectID)).toBe(
+        "resource-123",
+      );
+    });
+
+    test("extracts name from an entity-like object", () => {
+      const entity: Row = { _id: "1", name: "Production" };
+      expect(
+        TableColumnsToCsv.formatValueForCsv(entity, FieldType.Entity),
+      ).toBe("Production");
+    });
+
+    test("joins arrays of scalar values with a semicolon", () => {
+      expect(
+        TableColumnsToCsv.formatValueForCsv(
+          ["one", "two", "three"],
+          FieldType.ArrayOfText,
+        ),
+      ).toBe("one; two; three");
+    });
+
+    test("joins arrays of entity-like objects using their names", () => {
+      const values: Array<Row> = [{ name: "A" }, { name: "B" }];
+      expect(
+        TableColumnsToCsv.formatValueForCsv(values, FieldType.EntityArray),
+      ).toBe("A; B");
+    });
+
+    test("skips empty elements when joining arrays", () => {
+      expect(
+        TableColumnsToCsv.formatValueForCsv(
+          ["a", "", "b"],
+          FieldType.ArrayOfText,
+        ),
+      ).toBe("a; b");
+    });
+  });
+
+  describe("getExportableColumns", () => {
+    const columns: Columns<Row> = [
+      { title: "Name", type: FieldType.Text, key: "name" },
+      { title: "Actions", type: FieldType.Actions, key: null },
+      { title: "Custom", type: FieldType.Element },
+      { title: "Status", type: FieldType.Text, key: "status" },
+    ];
+
+    test("excludes the Actions column", () => {
+      const result: Columns<Row> =
+        TableColumnsToCsv.getExportableColumns(columns);
+      expect(
+        result.find((c: Column<Row>) => {
+          return c.title === "Actions";
+        }),
+      ).toBeUndefined();
+    });
+
+    test("excludes columns without a data key", () => {
+      const result: Columns<Row> =
+        TableColumnsToCsv.getExportableColumns(columns);
+      expect(
+        result.find((c: Column<Row>) => {
+          return c.title === "Custom";
+        }),
+      ).toBeUndefined();
+    });
+
+    test("keeps columns that have a key", () => {
+      const result: Columns<Row> =
+        TableColumnsToCsv.getExportableColumns(columns);
+      expect(
+        result.map((c: Column<Row>) => {
+          return c.title;
+        }),
+      ).toEqual(["Name", "Status"]);
+    });
+
+    test("handles undefined columns gracefully", () => {
+      expect(
+        TableColumnsToCsv.getExportableColumns(
+          undefined as unknown as Columns<Row>,
+        ),
+      ).toEqual([]);
+    });
+  });
+
+  describe("getCellValue", () => {
+    test("returns empty string for a keyless column", () => {
+      const column: Column<Row> = {
+        title: "X",
+        type: FieldType.Text,
+        key: null,
+      };
+      expect(TableColumnsToCsv.getCellValue({ name: "y" }, column)).toBe("");
+    });
+
+    test("formats the value at the column key", () => {
+      const column: Column<Row> = {
+        title: "Active",
+        type: FieldType.Boolean,
+        key: "isActive",
+      };
+      expect(TableColumnsToCsv.getCellValue({ isActive: false }, column)).toBe(
+        "No",
+      );
+    });
+  });
+
+  describe("convertToCsv", () => {
+    const columns: Columns<Row> = [
+      { title: "Name", type: FieldType.Text, key: "name" },
+      { title: "Active", type: FieldType.Boolean, key: "isActive" },
+      { title: "Actions", type: FieldType.Actions, key: null },
+    ];
+
+    test("builds a header row from exportable columns only", () => {
+      const csv: string = TableColumnsToCsv.convertToCsv({
+        items: [],
+        columns: columns,
+      });
+      expect(csv).toBe("Name,Active");
+    });
+
+    test("builds one row per item and separates rows with CRLF", () => {
+      const items: Array<Row> = [
+        { name: "Alpha", isActive: true },
+        { name: "Beta", isActive: false },
+      ];
+
+      const csv: string = TableColumnsToCsv.convertToCsv({
+        items: items,
+        columns: columns,
+      });
+
+      expect(csv).toBe("Name,Active\r\nAlpha,Yes\r\nBeta,No");
+    });
+
+    test("escapes values that contain commas", () => {
+      const items: Array<Row> = [{ name: "Smith, John", isActive: true }];
+      const csv: string = TableColumnsToCsv.convertToCsv({
+        items: items,
+        columns: [{ title: "Name", type: FieldType.Text, key: "name" }],
+      });
+      expect(csv).toBe('Name\r\n"Smith, John"');
+    });
+
+    test("neutralizes formula injection in cell values", () => {
+      const items: Array<Row> = [{ name: "=cmd()" }];
+      const csv: string = TableColumnsToCsv.convertToCsv({
+        items: items,
+        columns: [{ title: "Name", type: FieldType.Text, key: "name" }],
+      });
+      expect(csv).toBe("Name\r\n'=cmd()");
+    });
+
+    test("renders missing values as empty cells", () => {
+      const items: Array<Row> = [{ name: "OnlyName" }];
+      const csv: string = TableColumnsToCsv.convertToCsv({
+        items: items,
+        columns: columns,
+      });
+      expect(csv).toBe("Name,Active\r\nOnlyName,");
+    });
+
+    test("handles undefined items gracefully", () => {
+      const csv: string = TableColumnsToCsv.convertToCsv({
+        items: undefined as unknown as Array<Row>,
+        columns: columns,
+      });
+      expect(csv).toBe("Name,Active");
+    });
+  });
+
+  describe("getExportFilename", () => {
+    test("slugifies the label and appends the csv extension", () => {
+      const filename: string =
+        TableColumnsToCsv.getExportFilename("Monitor Probes");
+      expect(filename).toMatch(
+        /^monitor-probes-export-\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}\.csv$/,
+      );
+    });
+
+    test("collapses non-alphanumeric runs and trims dashes", () => {
+      const filename: string = TableColumnsToCsv.getExportFilename(
+        "  On-Call!! Policies  ",
+      );
+      expect(filename.startsWith("on-call-policies-export-")).toBe(true);
+      expect(filename.endsWith(".csv")).toBe(true);
+    });
+
+    test("falls back to 'table' for an empty label", () => {
+      const filename: string = TableColumnsToCsv.getExportFilename("");
+      expect(filename.startsWith("table-export-")).toBe(true);
+    });
+  });
+
+  describe("downloadCsv and exportItemsToCsv", () => {
+    let createObjectURLMock: MockFunction;
+    let revokeObjectURLMock: MockFunction;
+    let clickSpy: jest.SpyInstance;
+    let createElementSpy: jest.SpyInstance;
+    let capturedAnchor: HTMLAnchorElement | null;
+
+    beforeEach(() => {
+      capturedAnchor = null;
+
+      createObjectURLMock = getJestMockFunction();
+      createObjectURLMock.mockReturnValue("blob:mock-url");
+      revokeObjectURLMock = getJestMockFunction();
+
+      (window.URL as unknown as { createObjectURL: unknown }).createObjectURL =
+        createObjectURLMock;
+      (window.URL as unknown as { revokeObjectURL: unknown }).revokeObjectURL =
+        revokeObjectURLMock;
+
+      clickSpy = jest
+        .spyOn(HTMLAnchorElement.prototype, "click")
+        .mockImplementation(() => {});
+
+      const originalCreateElement: (tagName: string) => HTMLElement =
+        document.createElement.bind(document);
+
+      createElementSpy = jest
+        .spyOn(document, "createElement")
+        .mockImplementation(
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          ((tagName: string): HTMLElement => {
+            const element: HTMLElement = originalCreateElement(tagName);
+            if (tagName === "a") {
+              capturedAnchor = element as HTMLAnchorElement;
+            }
+            return element;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          }) as any,
+        );
+    });
+
+    afterEach(() => {
+      clickSpy.mockRestore();
+      createElementSpy.mockRestore();
+    });
+
+    test("downloadCsv creates a link, triggers a download, and revokes the url", () => {
+      TableColumnsToCsv.downloadCsv({
+        csv: "a,b\r\n1,2",
+        filename: "data.csv",
+      });
+
+      expect(createObjectURLMock).toHaveBeenCalledTimes(1);
+      expect(clickSpy).toHaveBeenCalledTimes(1);
+      expect(revokeObjectURLMock).toHaveBeenCalledWith("blob:mock-url");
+      expect(capturedAnchor).not.toBeNull();
+      expect(capturedAnchor!.download).toBe("data.csv");
+      expect(capturedAnchor!.href).toContain("blob:mock-url");
+      // Anchor is cleaned up from the DOM after the click.
+      expect(document.body.contains(capturedAnchor)).toBe(false);
+    });
+
+    test("downloadCsv builds a text/csv blob", () => {
+      TableColumnsToCsv.downloadCsv({ csv: "x", filename: "x.csv" });
+
+      const blobArg: Blob = createObjectURLMock.mock.calls[0]![0] as Blob;
+      expect(blobArg).toBeInstanceOf(Blob);
+      expect(blobArg.type).toContain("text/csv");
+    });
+
+    test("exportItemsToCsv builds the CSV and downloads it end-to-end", () => {
+      const columns: Columns<Row> = [
+        { title: "Name", type: FieldType.Text, key: "name" },
+      ];
+
+      TableColumnsToCsv.exportItemsToCsv({
+        items: [{ name: "Alpha" }],
+        columns: columns,
+        label: "Monitors",
+      });
+
+      expect(createObjectURLMock).toHaveBeenCalledTimes(1);
+      expect(clickSpy).toHaveBeenCalledTimes(1);
+      expect(capturedAnchor).not.toBeNull();
+      expect(capturedAnchor!.download).toMatch(/^monitors-export-.*\.csv$/);
+    });
+  });
+});

package/Types/AI/AIChatTypes.ts

@@ -187,6 +187,14 @@ export interface AIRunEventResultSummary {
   isTruncated?: boolean | undefined;
   bytesSentToLlm?: number | undefined;
   errorMessage?: string | undefined;
+  /*
+   * Human-readable text for events that carry a message rather than query
+   * stats — e.g. ProgressLog lines from the code-fix agent, or "Opened pull
+   * request …" on ActionExecuted. Rendered by the run activity feed.
+   */
+  message?: string | undefined;
+  // Log severity for ProgressLog events (Info/Warning/Error/…).
+  severity?: string | undefined;
 }
 
 // What was sent to which LLM during a run — the per-run egress manifest.

package/Types/AI/AIInsightEvidence.ts

@@ -0,0 +1,77 @@
+import {
+  PerformanceCodeLocation,
+  PerformanceFinding,
+} from "./CodeFixTaskContext";
+
+/*
+ * The JSON persisted on AIInsight.evidence.
+ *
+ * Evidence is computed DETERMINISTICALLY at detect time and stored verbatim
+ * because ClickHouse retention is short — the stored evidence must outlive
+ * the raw signals it was computed from (the FixPerformance taskContext
+ * precedent: by the time anyone looks, the spans/logs may already be gone).
+ * It is rendered in the dashboard and embedded in triage prompts, so every
+ * field must carry the real numbers and stand on its own.
+ *
+ * Exactly one of the per-type sections is set, matching the insight's
+ * AIInsightType. These shapes are a wire contract — do not rename
+ * fields.
+ */
+
+// Evidence for NewException and ExceptionSpike insights.
+export interface ExceptionInsightEvidence {
+  exceptionMessage?: string | undefined;
+  exceptionType?: string | undefined;
+  // Occurrences in the recent (spike) window.
+  recentOccurrenceCount?: number | undefined;
+  // Average hourly occurrences over the prior baseline window.
+  baselineHourlyAverage?: number | undefined;
+  // recent rate / baseline rate.
+  spikeMultiplier?: number | undefined;
+  // Lifetime occurrence count of the exception.
+  totalOccurrenceCount?: number | undefined;
+  // ISO-8601 — when the exception was first ever seen.
+  firstSeenAt?: string | undefined;
+}
+
+// Evidence for ErrorLogSpike insights.
+export interface LogSpikeInsightEvidence {
+  recentErrorCount: number;
+  baselineHourlyAverage: number;
+  spikeMultiplier: number;
+  windowMinutes: number;
+  topServices: Array<{ serviceName: string; count: number }>;
+}
+
+// Evidence for TraceLatencyRegression insights.
+export interface LatencyInsightEvidence {
+  recentP99Ms: number;
+  baselineP99Ms: number;
+  regressionMultiplier: number;
+  operationName?: string | undefined;
+  sampleTraceId?: string | undefined;
+  // Deterministic span-tree findings drilled from the sample trace.
+  performanceFindings?: Array<PerformanceFinding> | undefined;
+  // code.* attribute locations for stack-trace-style repo resolution.
+  codeLocations?: Array<PerformanceCodeLocation> | undefined;
+}
+
+// Evidence for MetricDrift insights (week-over-week mean comparison).
+export interface MetricDriftInsightEvidence {
+  metricName: string;
+  primaryEntityId?: string | undefined;
+  recentWeekMean: number;
+  priorWeekMean: number;
+  relativeChangePercent: number;
+  recentSampleCount: number;
+  priorSampleCount: number;
+}
+
+export interface AIInsightEvidence {
+  exception?: ExceptionInsightEvidence | undefined;
+  logSpike?: LogSpikeInsightEvidence | undefined;
+  latency?: LatencyInsightEvidence | undefined;
+  metricDrift?: MetricDriftInsightEvidence | undefined;
+}
+
+export default AIInsightEvidence;

package/Types/AI/AIInsightHumanVerdict.ts

@@ -0,0 +1,15 @@
+/*
+ * The one-click human verdict on a AIInsight. This IS the G11
+ * precision measurement: confirm/dismiss rates per insight type tell us how
+ * precise each deterministic detector is in the field. Stored on
+ * AIInsight.humanVerdict, so these strings are a wire contract — do
+ * not rename them.
+ */
+enum AIInsightHumanVerdict {
+  // A human confirmed the insight was real and worth surfacing.
+  Confirmed = "Confirmed",
+  // A human dismissed the insight as noise/not actionable.
+  Dismissed = "Dismissed",
+}
+
+export default AIInsightHumanVerdict;

package/Types/AI/AIInsightSeverity.ts

@@ -0,0 +1,13 @@
+/*
+ * How urgent a AIInsight is, assigned deterministically by the
+ * detector that produced it (e.g. by spike/regression multiplier). Stored
+ * on AIInsight.severity and rendered/filtered in the dashboard, so
+ * these strings are a wire contract — do not rename them.
+ */
+enum AIInsightSeverity {
+  High = "High",
+  Medium = "Medium",
+  Low = "Low",
+}
+
+export default AIInsightSeverity;

package/Types/AI/AIInsightStatus.ts

@@ -0,0 +1,38 @@
+/*
+ * Lifecycle of a AIInsight. Stored on AIInsight.status and
+ * filtered on in the dashboard, so these strings are a wire contract — do
+ * not rename them.
+ *
+ * Detected is the defensive initial state — the scanner routes every newly
+ * created insight to ActionRequired or FixOpened in the same tick, so a row
+ * only stays Detected if routing crashed mid-scan. Resolved and Dismissed
+ * are human actions (the terminal states).
+ */
+enum AIInsightStatus {
+  // Just created by a detector; routed onward in the same scanner tick.
+  Detected = "Detected",
+  // Waiting on a human: no automatic fix was opened for this insight.
+  ActionRequired = "ActionRequired",
+  // An AI fix task was queued for this insight (see fixAiRunId).
+  FixOpened = "FixOpened",
+  // A human marked the insight as handled. Terminal.
+  Resolved = "Resolved",
+  // A human dismissed the insight as noise/not actionable. Terminal.
+  Dismissed = "Dismissed",
+}
+
+export default AIInsightStatus;
+
+export class AIInsightStatusHelper {
+  /*
+   * Terminal = Resolved | Dismissed — the two human end states. The scanner
+   * only refreshes (dedupes into) NON-terminal insights; a terminal insight
+   * is never reopened by a detector.
+   */
+  public static isTerminalStatus(status: AIInsightStatus): boolean {
+    return (
+      status === AIInsightStatus.Resolved ||
+      status === AIInsightStatus.Dismissed
+    );
+  }
+}