@oneuptime/common 11.5.8 → 11.5.9

package/Tests/UI/Utils/AIChatExport/ChatWidgetMarkdown.test.ts

@@ -0,0 +1,188 @@
+import { describe, expect, test } from "@jest/globals";
+import {
+  AIChatToolActionStatus,
+  AIChatWidget,
+  AIChatWidgetType,
+} from "../../../../Types/AI/AIChatTypes";
+import { JSONObject } from "../../../../Types/JSON";
+import {
+  citationsToMarkdown,
+  toolActionsToMarkdown,
+  widgetToMarkdown,
+} from "../../../../UI/Utils/AIChatExport/ChatWidgetMarkdown";
+
+/*
+ * The chat caps how much of a widget it shows, and says so. An export that
+ * quietly dropped the overflow — or quietly included it — would misrepresent
+ * the answer either way, so the caps and their captions are pinned here.
+ */
+
+function rows(count: number): Array<JSONObject> {
+  return Array.from({ length: count }, (_unused: unknown, index: number) => {
+    return { name: `row-${index}` };
+  });
+}
+
+describe("ChatWidgetMarkdown", () => {
+  describe("widgetToMarkdown", () => {
+    test("renders the title and description", () => {
+      const markdown: string = widgetToMarkdown({
+        id: "W1",
+        type: AIChatWidgetType.StatCards,
+        title: "Summary",
+        description: "Last hour",
+        data: { stats: [{ label: "Errors", value: 3 }] },
+      });
+
+      expect(markdown).toContain("#### Summary");
+      expect(markdown).toContain("_Last hour_");
+      expect(markdown).toContain("| Errors | 3 |");
+    });
+
+    test("caps table rows at 25 and says how many were shown", () => {
+      const widget: AIChatWidget = {
+        id: "W1",
+        type: AIChatWidgetType.Table,
+        title: "Rows",
+        data: {
+          columns: [{ key: "name", title: "Name" }],
+          rows: rows(40),
+        },
+      };
+
+      const markdown: string = widgetToMarkdown(widget);
+
+      expect(markdown).toContain("row-24");
+      expect(markdown).not.toContain("row-25");
+      expect(markdown).toContain("_Showing 25 of 40 rows._");
+    });
+
+    test("caps entity lists at 12", () => {
+      const widget: AIChatWidget = {
+        id: "W1",
+        type: AIChatWidgetType.IncidentList,
+        title: "Incidents",
+        data: {
+          items: Array.from({ length: 20 }, (_u: unknown, i: number) => {
+            return { title: `incident-${i}` };
+          }),
+        },
+      };
+
+      const markdown: string = widgetToMarkdown(widget);
+
+      expect(markdown).toContain("incident-11");
+      expect(markdown).not.toContain("incident-12");
+      expect(markdown).toContain("_Showing 12 of 20._");
+    });
+
+    test("escapes a pipe so it cannot break the table", () => {
+      const markdown: string = widgetToMarkdown({
+        id: "W1",
+        type: AIChatWidgetType.Table,
+        title: "Rows",
+        data: {
+          columns: [{ key: "name", title: "Name" }],
+          rows: [{ name: "a|b" }],
+        },
+      });
+
+      expect(markdown).toContain("a\\|b");
+    });
+
+    test("empty widgets say so rather than rendering an empty table", () => {
+      expect(
+        widgetToMarkdown({
+          id: "W1",
+          type: AIChatWidgetType.Table,
+          title: "Rows",
+          data: { columns: [], rows: [] },
+        }),
+      ).toContain("_No rows._");
+
+      expect(
+        widgetToMarkdown({
+          id: "W2",
+          type: AIChatWidgetType.TimeSeriesChart,
+          title: "Chart",
+          data: { series: [] },
+        }),
+      ).toContain("_No data points in this range._");
+
+      expect(
+        widgetToMarkdown({
+          id: "W3",
+          type: AIChatWidgetType.IncidentList,
+          title: "Incidents",
+          data: { items: [] },
+        }),
+      ).toContain("_Nothing here._");
+    });
+  });
+
+  describe("toolActionsToMarkdown", () => {
+    test("leads with the status so a denied action cannot read as a done one", () => {
+      const markdown: string = toolActionsToMarkdown([
+        {
+          id: "t1",
+          toolName: "restart",
+          title: "Restart payment-svc",
+          arguments: { service: "payment-svc" },
+          isMutation: true,
+          requiresApproval: true,
+          status: AIChatToolActionStatus.Denied,
+        },
+      ]);
+
+      expect(markdown).toContain("- **Denied** — Restart payment-svc");
+      expect(markdown).toContain("service: payment-svc");
+    });
+
+    test("is empty when there are no actions", () => {
+      expect(toolActionsToMarkdown([])).toBe("");
+    });
+  });
+
+  describe("citationsToMarkdown", () => {
+    test("spells out a zero row count as evidence of absence", () => {
+      const markdown: string = citationsToMarkdown([
+        {
+          id: "C1",
+          toolName: "logs.query",
+          label: "Logs for payment-svc",
+          queryArguments: { service: "payment-svc" },
+          rowCount: 0,
+        },
+      ]);
+
+      expect(markdown).toContain("checked, found nothing");
+      expect(markdown).toContain('{"service":"payment-svc"}');
+    });
+
+    test("pluralizes a real row count", () => {
+      expect(
+        citationsToMarkdown([
+          {
+            id: "C1",
+            toolName: "t",
+            label: "l",
+            queryArguments: {},
+            rowCount: 1,
+          },
+        ]),
+      ).toContain("1 row");
+
+      expect(
+        citationsToMarkdown([
+          {
+            id: "C2",
+            toolName: "t",
+            label: "l",
+            queryArguments: {},
+            rowCount: 5,
+          },
+        ]),
+      ).toContain("5 rows");
+    });
+  });
+});

package/Types/AI/AIAgentTaskStatus.ts

@@ -2,6 +2,12 @@ enum AIAgentTaskStatus {
   Scheduled = "Scheduled",
   InProgress = "InProgress",
   Completed = "Completed",
+  /*
+   * The agent finished cleanly but had no fix to propose, so it opened no
+   * pull request. Reported instead of Error so a negative result is not
+   * counted as a failure — see AIRunStatus.NoFixFound, which this maps to.
+   */
+  NoFixFound = "NoFixFound",
   Error = "Error",
 }
 
@@ -32,6 +38,12 @@ export class AIAgentTaskStatusHelper {
         title: "Completed",
         description: "Task has been completed successfully.",
       },
+      {
+        status: AIAgentTaskStatus.NoFixFound,
+        title: "No Fix Found",
+        description:
+          "Task ran successfully but AI did not find a fix to propose.",
+      },
       {
         status: AIAgentTaskStatus.Error,
         title: "Error",
@@ -59,6 +71,7 @@ export class AIAgentTaskStatusHelper {
   public static isTerminalStatus(status: AIAgentTaskStatus): boolean {
     return (
       status === AIAgentTaskStatus.Completed ||
+      status === AIAgentTaskStatus.NoFixFound ||
       status === AIAgentTaskStatus.Error
     );
   }

package/Types/AI/AIChatPageContext.ts

@@ -0,0 +1,137 @@
+import { JSONObject } from "../JSON";
+
+/*
+ * "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.
+ */
+enum AIChatPageContextType {
+  // Entity pages — carry the entity's id (and usually a display title).
+  Incident = "Incident",
+  Alert = "Alert",
+  Monitor = "Monitor",
+  ScheduledMaintenanceEvent = "ScheduledMaintenanceEvent",
+  TelemetryService = "TelemetryService",
+  Trace = "Trace",
+  Exception = "Exception",
+
+  // Area pages — no id; the user is browsing a list or an explorer.
+  IncidentsList = "IncidentsList",
+  AlertsList = "AlertsList",
+  MonitorsList = "MonitorsList",
+  ScheduledMaintenanceList = "ScheduledMaintenanceList",
+  LogsExplorer = "LogsExplorer",
+  TracesExplorer = "TracesExplorer",
+  MetricsExplorer = "MetricsExplorer",
+  ExceptionsList = "ExceptionsList",
+}
+
+export default AIChatPageContextType;
+
+export interface AIChatPageContext {
+  type: AIChatPageContextType;
+  // The entity on screen (UUID, or a hex trace id). Only set for entity types.
+  entityId?: string | undefined;
+  // Display title of the entity (incident title, monitor name, …). Optional.
+  entityTitle?: string | undefined;
+}
+
+/*
+ * Ids are OneUptime ObjectIDs (UUIDs) — except traces, whose ids are
+ * OpenTelemetry hex strings. Anything else is rejected: the id is echoed into
+ * the LLM prompt and into tool suggestions, so it must never carry free-form
+ * text (e.g. a static route segment like "overview" that a :id URL wildcard
+ * can capture).
+ */
+const UUID_REGEX: RegExp =
+  /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const TRACE_ID_REGEX: RegExp = /^[0-9a-fA-F]{8,64}$/;
+
+const MAX_ENTITY_TITLE_LENGTH: number = 200;
+
+const ENTITY_TYPES: Array<AIChatPageContextType> = [
+  AIChatPageContextType.Incident,
+  AIChatPageContextType.Alert,
+  AIChatPageContextType.Monitor,
+  AIChatPageContextType.ScheduledMaintenanceEvent,
+  AIChatPageContextType.TelemetryService,
+  AIChatPageContextType.Trace,
+  AIChatPageContextType.Exception,
+];
+
+export class AIChatPageContextHelper {
+  public static isValidType(
+    value: string | undefined,
+  ): value is AIChatPageContextType {
+    return Object.values(AIChatPageContextType).includes(
+      value as AIChatPageContextType,
+    );
+  }
+
+  // Entity types point at one specific record and require an entityId.
+  public static isEntityType(type: AIChatPageContextType): boolean {
+    return ENTITY_TYPES.includes(type);
+  }
+
+  /*
+   * Validate and sanitize an untrusted client-supplied page context. Returns
+   * undefined when the payload is missing or invalid — page context is a hint,
+   * so a bad one is dropped rather than failing the message.
+   */
+  public static sanitize(
+    json: JSONObject | undefined | null,
+  ): AIChatPageContext | undefined {
+    if (!json || typeof json !== "object" || Array.isArray(json)) {
+      return undefined;
+    }
+
+    const type: string | undefined =
+      typeof json["type"] === "string" ? (json["type"] as string) : undefined;
+
+    if (!this.isValidType(type)) {
+      return undefined;
+    }
+
+    const context: AIChatPageContext = { type: type };
+
+    if (this.isEntityType(type)) {
+      const entityId: string =
+        typeof json["entityId"] === "string"
+          ? (json["entityId"] as string).trim()
+          : "";
+
+      const idRegex: RegExp =
+        type === AIChatPageContextType.Trace ? TRACE_ID_REGEX : UUID_REGEX;
+
+      // An entity context without a usable id is meaningless — drop it whole.
+      if (!idRegex.test(entityId)) {
+        return undefined;
+      }
+
+      context.entityId = entityId;
+
+      if (typeof json["entityTitle"] === "string") {
+        /*
+         * The title is echoed into the system prompt: collapse whitespace and
+         * control characters so it cannot introduce new lines or fake
+         * prompt structure, and cap the length.
+         */
+        const entityTitle: string = (json["entityTitle"] as string)
+          // eslint-disable-next-line no-control-regex
+          .replace(/[\u0000-\u001F\u007F]+/g, " ")
+          .replace(/\s+/g, " ")
+          .trim()
+          .substring(0, MAX_ENTITY_TITLE_LENGTH);
+
+        if (entityTitle) {
+          context.entityTitle = entityTitle;
+        }
+      }
+    }
+
+    return context;
+  }
+}

package/Types/AI/AIChatTypes.ts

@@ -22,6 +22,8 @@ export enum AIChatCitationTargetType {
   AlertView = "AlertView",
   Monitors = "Monitors",
   MonitorView = "MonitorView",
+  ScheduledMaintenanceEvents = "ScheduledMaintenanceEvents",
+  ScheduledMaintenanceView = "ScheduledMaintenanceView",
 }
 
 export interface AIChatCitationTarget {
@@ -197,6 +199,48 @@ export interface AIRunEventResultSummary {
   severity?: string | undefined;
 }
 
+/*
+ * The verbatim content behind one run event — the raw material for debugging
+ * a bad run: exactly what was sent to the model, exactly what it said back,
+ * and exactly what a tool returned.
+ *
+ * This is the ONLY place a code-fix run's LLM content is persisted. It lives
+ * on AIRunEvent.contentPayload, whose read ACL is empty precisely because
+ * this content embeds customer source code: LlmLog deliberately redacts the
+ * same content (CodeFixAgentCompletion passes storeContentPreviews: false)
+ * because LlmLog is readable project-wide, and that redaction stays. Reach it
+ * only through GET /code-fix-run/logs, which gates on ProjectOwner or
+ * ProjectAdmin — the same "sensitive content behind a narrow endpoint" shape
+ * AIRun.pausedState and AIRun.taskContext already use.
+ *
+ * Every field is capped at write time (see AIRunTranscript.ts) so one run can
+ * never write an unbounded row.
+ */
+export interface AIRunEventContentPayload {
+  // Messages newly sent to the model on this call — not the whole history.
+  requestMessages?: Array<{
+    role: string;
+    content: string;
+  }>;
+  // The model's verbatim reply.
+  responseContent?: string | undefined;
+  // Tool calls the model asked for, with their full arguments.
+  responseToolCalls?: Array<{
+    id?: string | undefined;
+    name: string;
+    arguments?: JSONObject | undefined;
+  }>;
+  // A tool's verbatim return value (for tool events).
+  toolResult?: string | undefined;
+  modelName?: string | undefined;
+  stopReason?: string | undefined;
+  promptTokens?: number | undefined;
+  completionTokens?: number | undefined;
+  totalTokens?: number | undefined;
+  // Set when any field above was clipped to its cap.
+  isTruncated?: boolean | undefined;
+}
+
 // What was sent to which LLM during a run — the per-run egress manifest.
 export interface AIRunEgressManifestToolEntry {
   toolName: string;

package/Types/AI/AIFixReadiness.ts

@@ -0,0 +1,46 @@
+/*
+ * What a CodeFix run needs before it can complete, as a wire contract shared
+ * by the server checks and every UI that renders them. Two surfaces consume
+ * this today: the per-exception "Fix with AI Agent" panel
+ * (GET /telemetry-exception/ai-fix-readiness/:id) and the project-wide AI
+ * Tasks page (POST /ai-readiness/code-fix).
+ */
+
+/*
+ * The repository gate comes in two strengths, and they are deliberately
+ * distinct ids — a UI that conflates them would promise more than the check
+ * verified:
+ *
+ * - repositoryResolved: a repository matches THIS exception's stack trace.
+ *   Per-exception, and the stronger claim.
+ * - repositoryConnected: the project has at least one GitHub-App-connected
+ *   repository. Project-wide, and all a page-level check can honestly assert
+ *   — it says nothing about whether any given exception will resolve.
+ */
+export type AIFixReadinessCheckId =
+  | "llmProvider"
+  | "repositoryResolved"
+  | "repositoryConnected"
+  | "agentAvailable";
+
+export interface AIFixReadinessCheck {
+  id: AIFixReadinessCheckId;
+  ok: boolean;
+  /*
+   * The gate's headline. Checks fill in what they actually found where that
+   * is useful ("Repository resolved: acme/api"), so this is not a fixed
+   * label per id.
+   */
+  title: string;
+  /*
+   * When ok is false: exactly what to do next. When ok is true: what is
+   * configured, so the user can tell a project-owned provider from the
+   * shared one without leaving the page. May be empty.
+   */
+  detail: string;
+}
+
+export interface AIFixReadiness {
+  ready: boolean;
+  checks: Array<AIFixReadinessCheck>;
+}

package/Types/AI/AIRunStatus.ts

@@ -18,6 +18,16 @@ enum AIRunStatus {
    */
   WaitingForApproval = "WaitingForApproval",
   Completed = "Completed",
+  /*
+   * The run did its job and concluded there was nothing to change — the agent
+   * read the code and found no fix worth proposing, so it opened no pull
+   * request. A negative result, NOT a failure: nothing broke, and retrying the
+   * same run unchanged would likely reach the same conclusion. Kept distinct
+   * from Error so a quiet "no fix" never lands in an error rate, an alert, or
+   * a red pill. Contrast with Error, which means the run could not finish
+   * (clone failed, LLM errored, no repository resolved).
+   */
+  NoFixFound = "NoFixFound",
   Error = "Error",
   Cancelled = "Cancelled",
   Stale = "Stale",
@@ -29,6 +39,7 @@ export class AIRunStatusHelper {
   public static isTerminalStatus(status: AIRunStatus): boolean {
     return (
       status === AIRunStatus.Completed ||
+      status === AIRunStatus.NoFixFound ||
       status === AIRunStatus.Error ||
       status === AIRunStatus.Cancelled ||
       status === AIRunStatus.Stale

package/Types/Log/LogSeverity.ts

@@ -8,4 +8,65 @@ enum LogSeverity {
   Fatal = "Fatal",
 }
 
+/*
+ * The OTLP severity number stored alongside each level.
+ *
+ * These are the low end of each OTLP range (Trace 1-4, Debug 5-8, Info 9-12,
+ * Warn 13-16, Error 17-20, Fatal 21-24), so they are the inverse of the
+ * bucketing OtelLogsIngestService.getSeverityText applies on ingest. Anything
+ * that writes severityText must take the number from here too, or the row says
+ * one thing in its text and another in its number.
+ *
+ * https://opentelemetry.io/docs/specs/otel/logs/data-model/#field-severitynumber
+ */
+export const LogSeverityNumber: Record<LogSeverity, number> = {
+  [LogSeverity.Unspecified]: 0,
+  [LogSeverity.Trace]: 1,
+  [LogSeverity.Debug]: 5,
+  [LogSeverity.Information]: 9,
+  [LogSeverity.Warning]: 13,
+  [LogSeverity.Error]: 17,
+  [LogSeverity.Fatal]: 21,
+};
+
+/*
+ * Loose severity text -> the enum member actually stored on a log row.
+ *
+ * Only these seven strings ever reach the database: ingest discards whatever
+ * severityText a client sent and re-derives it from severityNumber. So a value
+ * that is merely severity-shaped ("INFO", "warn") matches nothing — and since
+ * `=` and `IN` are case-sensitive, it fails silently rather than erroring.
+ *
+ * This exists because the filter and severity-remapper dropdowns spent a long
+ * time emitting TRACE/DEBUG/INFO/WARNING/ERROR/FATAL. Those values are still
+ * sitting in saved pipeline configs, so the remapper normalises through here on
+ * the way in rather than trusting what was stored.
+ *
+ * Returns null for anything unrecognised. Callers decide what to do about it —
+ * guessing a severity is worse than admitting we cannot tell.
+ */
+export function normalizeLogSeverity(text: string): LogSeverity | null {
+  const normalized: string = (text || "").trim().toUpperCase();
+
+  if (!normalized) {
+    return null;
+  }
+
+  const aliases: Record<string, LogSeverity> = {
+    UNSPECIFIED: LogSeverity.Unspecified,
+    TRACE: LogSeverity.Trace,
+    DEBUG: LogSeverity.Debug,
+    // INFO and WARN are the two the old dropdowns got wrong by more than case.
+    INFO: LogSeverity.Information,
+    INFORMATION: LogSeverity.Information,
+    WARN: LogSeverity.Warning,
+    WARNING: LogSeverity.Warning,
+    ERR: LogSeverity.Error,
+    ERROR: LogSeverity.Error,
+    FATAL: LogSeverity.Fatal,
+  };
+
+  return aliases[normalized] || null;
+}
+
 export default LogSeverity;

package/Types/Monitor/SnmpMonitor/SnmpVersion.ts

@@ -4,4 +4,44 @@ enum SnmpVersion {
   V3 = "3",
 }
 
+/*
+ * Two spellings exist, and they belong to two different layers:
+ *
+ *   - These enum VALUES ("1"/"2c"/"3") are the probe-contract spelling.
+ *     MonitorStepSnmpMonitor.snmpVersion is typed as this enum, and
+ *     SnmpMonitor branches on it to pick the session type.
+ *   - The KEYS ("V1"/"V2c"/"V3") are the stored spelling. The free-text
+ *     snmpVersion column on NetworkDevice / NetworkDeviceDiscoveryScan holds
+ *     these: it is what every form writes, what the column default is, and
+ *     what the public API reference documents as the allowed values.
+ *
+ * parse() is the conversion at that seam, and it is the only correct way to
+ * read the column. Comparing the raw column against an enum member instead
+ * silently takes the wrong branch — a stored "V3" is not === SnmpVersion.V3
+ * ("3"), so a v3 device reads as v2c and gets polled in cleartext.
+ *
+ * parse() also accepts the value spelling and mixed case, so a row written by
+ * hand (direct API call, manual DB edit) can't strand a device in the wrong
+ * branch. No product path writes that spelling — the tolerance is a guard, not
+ * a sign that the column is expected to hold both.
+ */
+export class SnmpVersionUtil {
+  public static parse(value: string | undefined | null): SnmpVersion {
+    switch ((value || "").trim().toLowerCase()) {
+      case "1":
+      case "v1":
+        return SnmpVersion.V1;
+      case "3":
+      case "v3":
+        return SnmpVersion.V3;
+      default:
+        return SnmpVersion.V2c;
+    }
+  }
+
+  public static isV3(value: string | undefined | null): boolean {
+    return SnmpVersionUtil.parse(value) === SnmpVersion.V3;
+  }
+}
+
 export default SnmpVersion;

package/UI/Components/Charts/ChartLibrary/AreaChart/AreaChart.tsx

@@ -762,6 +762,7 @@ const AreaChart: React.ForwardRefExoticComponent<
                 transform: "translate(0, 6)",
                 fontSize: 10,
                 fontWeight: 500,
+                fill: "var(--ou-chart-tick)",
               }}
               ticks={
                 startEndOnly
@@ -802,6 +803,7 @@ const AreaChart: React.ForwardRefExoticComponent<
                 transform: "translate(-4, 0)",
                 fontSize: 10,
                 fontWeight: 500,
+                fill: "var(--ou-chart-tick)",
               }}
               fill=""
               stroke=""
@@ -822,7 +824,7 @@ const AreaChart: React.ForwardRefExoticComponent<
               )}
             </YAxis>
             <Tooltip
-              wrapperStyle={{ outline: "none" }}
+              wrapperStyle={{ outline: "none", zIndex: 10 }}
               isAnimationActive={true}
               animationDuration={100}
               cursor={{
@@ -1076,7 +1078,11 @@ const AreaChart: React.ForwardRefExoticComponent<
                     <Label
                       value="E"
                       position="center"
-                      fill="var(--ou-chart-marker-ring, #ffffff)"
+                      /*
+                       * Sits on the dot's purple, not on the surface, so it must
+                       * not follow the ring token that flips dark with the theme.
+                       */
+                      fill="#ffffff"
                       fontSize={8}
                       fontWeight={700}
                     />

package/UI/Components/Charts/ChartLibrary/BarChart/BarChart.tsx

@@ -836,6 +836,7 @@ const BarChart: React.ForwardRefExoticComponent<
                   layout !== "vertical" ? "translate(0, 6)" : undefined,
                 fontSize: 10,
                 fontWeight: 500,
+                fill: "var(--ou-chart-tick)",
               }}
               fill=""
               stroke=""
@@ -904,6 +905,7 @@ const BarChart: React.ForwardRefExoticComponent<
                     : "translate(0, 0)",
                 fontSize: 10,
                 fontWeight: 500,
+                fill: "var(--ou-chart-tick)",
               }}
               {...(layout !== "vertical"
                 ? {
@@ -940,7 +942,7 @@ const BarChart: React.ForwardRefExoticComponent<
               )}
             </YAxis>
             <Tooltip
-              wrapperStyle={{ outline: "none" }}
+              wrapperStyle={{ outline: "none", zIndex: 10 }}
               isAnimationActive={true}
               animationDuration={100}
               cursor={{