@oneuptime/common 12.0.8 → 12.0.9

package/Server/API/AIChatAPI.ts

@@ -33,14 +33,19 @@ import {
   AIChatToolActionStatus,
 } from "../../Types/AI/AIChatTypes";
 import { JSONArray, JSONObject } from "../../Types/JSON";
+import AIRunEventType from "../../Types/AI/AIRunEventType";
 import AIRunStatus from "../../Types/AI/AIRunStatus";
 import AIRunType from "../../Types/AI/AIRunType";
 import AIConversation from "../../Models/DatabaseModels/AIConversation";
-import AIConversationMessage from "../../Models/DatabaseModels/AIConversationMessage";
+import AIConversationMessage, {
+  AIConversationMessageFeedback,
+} from "../../Models/DatabaseModels/AIConversationMessage";
 import AIRun from "../../Models/DatabaseModels/AIRun";
+import AIRunEvent from "../../Models/DatabaseModels/AIRunEvent";
 import Project from "../../Models/DatabaseModels/Project";
 import AIConversationService from "../Services/AIConversationService";
 import AIConversationMessageService from "../Services/AIConversationMessageService";
+import AIRunEventService from "../Services/AIRunEventService";
 import AIRunService from "../Services/AIRunService";
 import ProjectService from "../Services/ProjectService";
 import LlmProviderService from "../Services/LlmProviderService";
@@ -54,6 +59,16 @@ import logger from "../Utils/Logger";
 const MAX_USER_MESSAGE_LENGTH: number = 8000;
 const MAX_CONCURRENT_RUNS_PER_PROJECT: number = 3;
 
+// Final message content and run error for a turn the user stopped.
+const STOPPED_BY_USER_TEXT: string = "Stopped by user.";
+
+/*
+ * Cancel's terminal event must sort after every progress event the runner
+ * emitted — same convention as the runner's own failure finalizer, which
+ * starts its event sequence at 100000.
+ */
+const CANCEL_EVENT_SEQUENCE: number = 100000;
+
 const router: ExpressRouter = Express.getRouter();
 
 /*
@@ -706,4 +721,303 @@ router.post(
   },
 );
 
+/*
+ * Stops the conversation's in-flight turn. Flips the active run to Cancelled,
+ * finalizes the in-flight assistant message as "Stopped by user." and emits a
+ * terminal run event so the polling UI sees closure. Every write is guarded on
+ * the row's current status, so racing the runner is safe: whichever side
+ * finalizes first wins and the loser's write matches zero rows (the runner
+ * also checks for cancellation cooperatively between its steps). Cancelling
+ * the run is also what releases the conversation for the next send —
+ * send-message's governor only blocks on Running/WaitingForApproval runs.
+ */
+router.post(
+  "/ai-chat/cancel-run",
+  UserMiddleware.getUserMiddleware,
+  async (
+    req: ExpressRequest,
+    res: ExpressResponse,
+    next: NextFunction,
+  ): Promise<void> => {
+    try {
+      const props: DatabaseCommonInteractionProps =
+        await CommonAPI.getDatabaseCommonInteractionProps(req);
+
+      if (!props.userId) {
+        throw new NotAuthorizedException(
+          "AI chat requires a logged-in user session.",
+        );
+      }
+
+      if (!props.tenantId) {
+        throw new BadDataException("Project ID is required (tenantid header).");
+      }
+
+      const projectId: ObjectID = props.tenantId;
+      const userId: ObjectID = props.userId;
+
+      const conversationIdString: string = req.body["conversationId"] as string;
+
+      if (!conversationIdString) {
+        throw new BadDataException("conversationId is required.");
+      }
+
+      const conversationId: ObjectID = new ObjectID(conversationIdString);
+
+      // The privacy pin makes this return null for other users' rows.
+      const conversation: AIConversation | null =
+        await AIConversationService.findOneById({
+          id: conversationId,
+          select: { _id: true },
+          props: props,
+        });
+
+      if (!conversation) {
+        throw new BadDataException("Conversation not found.");
+      }
+
+      /*
+       * The conversation's live run: actively generating (Running) or paused
+       * for the user's approval (WaitingForApproval). The per-conversation
+       * governor allows at most one, so no sort is needed.
+       */
+      const activeRun: AIRun | null = await AIRunService.findOneBy({
+        query: {
+          conversationId: conversationId,
+          projectId: projectId,
+          status: QueryHelper.any([
+            AIRunStatus.Running,
+            AIRunStatus.WaitingForApproval,
+          ]),
+        },
+        select: { _id: true },
+        props: { isRoot: true },
+      });
+
+      if (!activeRun) {
+        throw new BadDataException(
+          "No response is being generated in this conversation.",
+        );
+      }
+
+      /*
+       * Status-guarded finalization, the same shape as the runner's own
+       * finalizer: only a still-in-flight run is flipped, so a run the runner
+       * completed (or errored) inside the race window is never overwritten.
+       * updateOneBy returns the matched-row count — zero from both guards
+       * means the other side won and already wrote the final state.
+       */
+      let cancelledRunCount: number = 0;
+
+      for (const inFlightRunStatus of [
+        AIRunStatus.Running,
+        AIRunStatus.WaitingForApproval,
+      ]) {
+        cancelledRunCount += await AIRunService.updateOneBy({
+          query: {
+            _id: activeRun.id!.toString(),
+            status: inFlightRunStatus,
+          },
+          data: {
+            status: AIRunStatus.Cancelled,
+            completedAt: OneUptimeDate.getCurrentDate(),
+            errorMessage: STOPPED_BY_USER_TEXT,
+            // A cancelled turn must never be resumable.
+            pausedState: null,
+          } as never,
+          props: { isRoot: true },
+        });
+      }
+
+      /*
+       * Finalize the run's in-flight assistant message the same guarded way:
+       * a message another path already finalized — completed with its full
+       * answer, or errored — keeps what it has.
+       */
+      for (const inFlightMessageStatus of [
+        AIChatMessageStatus.InProgress,
+        AIChatMessageStatus.WaitingForApproval,
+      ]) {
+        await AIConversationMessageService.updateOneBy({
+          query: {
+            aiRunId: activeRun.id!,
+            status: inFlightMessageStatus,
+          },
+          data: {
+            status: AIChatMessageStatus.Cancelled,
+            contentInMarkdown: STOPPED_BY_USER_TEXT,
+          } as never,
+          props: { isRoot: true },
+        });
+      }
+
+      /*
+       * Terminal event, only when this request actually took the run —
+       * emitting closure over a turn the runner finished would tell the UI a
+       * completed answer failed. RunFailed is the event enum's terminal
+       * "did not finish" member; the summary carries the human reason.
+       */
+      if (cancelledRunCount > 0) {
+        try {
+          const cancelEvent: AIRunEvent = new AIRunEvent();
+          cancelEvent.projectId = projectId;
+          cancelEvent.aiRunId = activeRun.id!;
+          cancelEvent.userId = userId;
+          cancelEvent.sequence = CANCEL_EVENT_SEQUENCE;
+          cancelEvent.eventType = AIRunEventType.RunFailed;
+          cancelEvent.resultSummary = { errorMessage: STOPPED_BY_USER_TEXT };
+
+          await AIRunEventService.create({
+            data: cancelEvent,
+            props: { isRoot: true },
+          });
+        } catch (error) {
+          // Events are progress telemetry — never fail the cancel over them.
+          logger.error(
+            `Failed to emit AI chat cancel event: ${
+              error instanceof Error ? error.message : String(error)
+            }`,
+          );
+        }
+      }
+
+      Response.sendJsonObjectResponse(req, res, {
+        conversationId: conversationId.toString(),
+        aiRunId: activeRun.id!.toString(),
+        cancelled: cancelledRunCount > 0,
+      });
+      return;
+    } catch (err) {
+      next(err);
+      return;
+    }
+  },
+);
+
+/*
+ * Stores thumbs feedback on an assistant message (or clears it with null).
+ * Ownership is enforced the same way as the other routes: the message AND its
+ * conversation must resolve under the requesting user's props (the privacy
+ * pin returns null for other users' rows), and only assistant-role messages
+ * accept feedback. Persistence only — no analytics pipeline yet.
+ */
+router.post(
+  "/ai-chat/message-feedback",
+  UserMiddleware.getUserMiddleware,
+  async (
+    req: ExpressRequest,
+    res: ExpressResponse,
+    next: NextFunction,
+  ): Promise<void> => {
+    try {
+      const props: DatabaseCommonInteractionProps =
+        await CommonAPI.getDatabaseCommonInteractionProps(req);
+
+      if (!props.userId) {
+        throw new NotAuthorizedException(
+          "AI chat requires a logged-in user session.",
+        );
+      }
+
+      if (!props.tenantId) {
+        throw new BadDataException("Project ID is required (tenantid header).");
+      }
+
+      const messageIdString: string = req.body["messageId"] as string;
+
+      if (!messageIdString) {
+        throw new BadDataException("messageId is required.");
+      }
+
+      const messageId: ObjectID = new ObjectID(messageIdString);
+
+      /*
+       * Validate before any read: feedback is exactly "Up", "Down" or null
+       * (null clears). Anything else — including a missing key — is a bad
+       * request, never silently coerced.
+       */
+      if (!("feedback" in (req.body as JSONObject))) {
+        throw new BadDataException(
+          'feedback is required: "Up", "Down" or null (null clears feedback).',
+        );
+      }
+
+      const rawFeedback: string | null | undefined = req.body["feedback"] as
+        | string
+        | null
+        | undefined;
+
+      let feedback: AIConversationMessageFeedback | null = null;
+
+      if (rawFeedback !== null && rawFeedback !== undefined) {
+        if (
+          rawFeedback !== AIConversationMessageFeedback.Up &&
+          rawFeedback !== AIConversationMessageFeedback.Down
+        ) {
+          throw new BadDataException(
+            'feedback must be "Up", "Down" or null (null clears feedback).',
+          );
+        }
+
+        feedback = rawFeedback as AIConversationMessageFeedback;
+      }
+
+      // The privacy pin makes this return null for other users' rows.
+      const message: AIConversationMessage | null =
+        await AIConversationMessageService.findOneById({
+          id: messageId,
+          select: {
+            _id: true,
+            conversationId: true,
+            role: true,
+          },
+          props: props,
+        });
+
+      if (!message || !message.conversationId) {
+        throw new BadDataException("Message not found.");
+      }
+
+      /*
+       * Belt and braces, matching respond-to-approval: the message's
+       * conversation must also resolve under this user's props.
+       */
+      const conversation: AIConversation | null =
+        await AIConversationService.findOneById({
+          id: message.conversationId,
+          select: { _id: true },
+          props: props,
+        });
+
+      if (!conversation) {
+        throw new BadDataException("Message not found.");
+      }
+
+      if (message.role !== AIChatMessageRole.Assistant) {
+        throw new BadDataException(
+          "Feedback can only be left on assistant messages.",
+        );
+      }
+
+      // Root write: message columns are deliberately not user-writable.
+      await AIConversationMessageService.updateOneById({
+        id: messageId,
+        data: {
+          userFeedback: feedback,
+        } as never,
+        props: { isRoot: true },
+      });
+
+      Response.sendJsonObjectResponse(req, res, {
+        messageId: messageId.toString(),
+        feedback: feedback,
+      });
+      return;
+    } catch (err) {
+      next(err);
+      return;
+    }
+  },
+);
+
 export default router;

package/Server/API/DashboardAPI.ts

@@ -1,4 +1,7 @@
 import UserMiddleware from "../Middleware/UserAuthorization";
+import PublicDashboardRateLimit, {
+  PublicDashboardRateLimitBucket,
+} from "../Middleware/PublicDashboardRateLimit";
 import DashboardService, {
   Service as DashboardServiceType,
 } from "../Services/DashboardService";
@@ -51,8 +54,10 @@ import ProxmoxResource from "../../Models/DatabaseModels/ProxmoxResource";
 import CephResource from "../../Models/DatabaseModels/CephResource";
 import DockerSwarmResource from "../../Models/DatabaseModels/DockerSwarmResource";
 import NetworkSite from "../../Models/DatabaseModels/NetworkSite";
+import ServiceLevelObjective from "../../Models/DatabaseModels/ServiceLevelObjective";
 import Span from "../../Models/AnalyticsModels/Span";
 import Log from "../../Models/AnalyticsModels/Log";
+import SloHistory from "../../Models/AnalyticsModels/SloHistory";
 import IncidentService from "../Services/IncidentService";
 import AlertService from "../Services/AlertService";
 import MonitorService from "../Services/MonitorService";
@@ -66,13 +71,20 @@ import ProxmoxResourceService from "../Services/ProxmoxResourceService";
 import CephResourceService from "../Services/CephResourceService";
 import DockerSwarmResourceService from "../Services/DockerSwarmResourceService";
 import NetworkSiteService from "../Services/NetworkSiteService";
+import ServiceLevelObjectiveService from "../Services/ServiceLevelObjectiveService";
 import SpanService from "../Services/SpanService";
 import LogService from "../Services/LogService";
+import SloHistoryService from "../Services/SloHistoryService";
 import DashboardComponentType from "../../Types/Dashboard/DashboardComponentType";
 import { DashboardVariableType } from "../../Types/Dashboard/DashboardVariable";
 import PublicDashboardResourceListPolicy, {
   PublicDashboardResourceListPolicyResult,
 } from "../Utils/Dashboard/PublicDashboardResourceListPolicy";
+import PublicDashboardSloHistoryPolicy, {
+  PublicDashboardSloHistoryPolicyResult,
+} from "../Utils/Dashboard/PublicDashboardSloHistoryPolicy";
+import AggregationType from "../../Types/BaseDatabase/AggregationType";
+import InBetween from "../../Types/BaseDatabase/InBetween";
 import { applyIncidentSelfPrivacyFilter } from "../Utils/Incident/IncidentPrivacyFilter";
 import { applyAlertSelfPrivacyFilter } from "../Utils/Alert/AlertPrivacyFilter";
 
@@ -97,6 +109,19 @@ interface PublicDashboardResourceConfig {
   widgets: Partial<Record<DashboardComponentType, string | null>>;
 }
 
+/*
+ * Named rather than inlined below: the SLO history route selects its widget
+ * through the same registry entry as the resource-list route, so both must
+ * agree on which stored widgets count as "an SLO widget on this dashboard".
+ */
+const PUBLIC_DASHBOARD_SLO_RESOURCE: PublicDashboardResourceConfig = {
+  modelType: ServiceLevelObjective,
+  service: ServiceLevelObjectiveService,
+  widgets: {
+    [DashboardComponentType.Slo]: null,
+  },
+};
+
 const PUBLIC_DASHBOARD_RESOURCES: Record<
   string,
   PublicDashboardResourceConfig
@@ -258,6 +283,7 @@ const PUBLIC_DASHBOARD_RESOURCES: Record<
       [DashboardComponentType.LogStream]: null,
     },
   },
+  slo: PUBLIC_DASHBOARD_SLO_RESOURCE,
 };
 
 type ResolveDashboardIdOrThrowFunction = (
@@ -319,11 +345,45 @@ export default class DashboardAPI extends BaseAPI<
   public constructor() {
     super(Dashboard, DashboardService);
 
+    /*
+     * Rate limiting for the anonymous public dashboard surface. Nginx exposes
+     * every route below under /public-dashboard-api and rewrites it to
+     * /api/dashboard before it reaches us, so this router IS that prefix and
+     * the limiter goes on all of it uniformly rather than on the handful of
+     * routes that happen to be the most expensive today.
+     *
+     * Registered ahead of UserMiddleware so a flood is rejected before it
+     * costs a session lookup. See PublicDashboardRateLimit for the budgets
+     * and for why the two buckets fail in opposite directions when Redis is
+     * unreachable.
+     */
+    const publicDashboardRateLimit: (
+      req: ExpressRequest,
+      res: ExpressResponse,
+      next: NextFunction,
+    ) => Promise<void> = PublicDashboardRateLimit.getMiddleware(
+      PublicDashboardRateLimitBucket.Read,
+    );
+
+    /*
+     * /master-password verifies a bcrypt hash per request, so unthrottled it
+     * is an online password-guessing oracle that also burns a CPU-bound hash
+     * per guess. Its own, much tighter bucket.
+     */
+    const masterPasswordRateLimit: (
+      req: ExpressRequest,
+      res: ExpressResponse,
+      next: NextFunction,
+    ) => Promise<void> = PublicDashboardRateLimit.getMiddleware(
+      PublicDashboardRateLimitBucket.MasterPassword,
+    );
+
     // SEO endpoint - resolve dashboard by ID or domain
     this.router.get(
       `${new this.entityType()
         .getCrudApiPath()
         ?.toString()}/seo/:dashboardIdOrDomain`,
+      publicDashboardRateLimit,
       UserMiddleware.getUserMiddleware,
       async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
         try {
@@ -504,6 +564,7 @@ export default class DashboardAPI extends BaseAPI<
 
     this.router.post(
       overviewApiPath,
+      publicDashboardRateLimit,
       UserMiddleware.getUserMiddleware,
       overviewHandler,
     );
@@ -515,6 +576,7 @@ export default class DashboardAPI extends BaseAPI<
      */
     this.router.get(
       overviewApiPath,
+      publicDashboardRateLimit,
       UserMiddleware.getUserMiddleware,
       overviewHandler,
     );
@@ -522,6 +584,7 @@ export default class DashboardAPI extends BaseAPI<
     // Domain resolution endpoint
     this.router.post(
       `${new this.entityType().getCrudApiPath()?.toString()}/domain`,
+      publicDashboardRateLimit,
       UserMiddleware.getUserMiddleware,
       async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
         try {
@@ -567,6 +630,7 @@ export default class DashboardAPI extends BaseAPI<
       `${new this.entityType()
         .getCrudApiPath()
         ?.toString()}/metadata/:dashboardId`,
+      publicDashboardRateLimit,
       UserMiddleware.getUserMiddleware,
       async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
         try {
@@ -629,6 +693,7 @@ export default class DashboardAPI extends BaseAPI<
       `${new this.entityType()
         .getCrudApiPath()
         ?.toString()}/view-config/:dashboardId`,
+      publicDashboardRateLimit,
       UserMiddleware.getUserMiddleware,
       async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
         try {
@@ -730,6 +795,7 @@ export default class DashboardAPI extends BaseAPI<
       `${new this.entityType()
         .getCrudApiPath()
         ?.toString()}/attribute-values/:dashboardId`,
+      publicDashboardRateLimit,
       UserMiddleware.getUserMiddleware,
       async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
         try {
@@ -843,6 +909,7 @@ export default class DashboardAPI extends BaseAPI<
       `${new this.entityType()
         .getCrudApiPath()
         ?.toString()}/metric-types/:dashboardId`,
+      publicDashboardRateLimit,
       UserMiddleware.getUserMiddleware,
       async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
         try {
@@ -952,6 +1019,7 @@ export default class DashboardAPI extends BaseAPI<
       `${new this.entityType()
         .getCrudApiPath()
         ?.toString()}/metrics-aggregate/:dashboardId`,
+      publicDashboardRateLimit,
       UserMiddleware.getUserMiddleware,
       async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
         try {
@@ -1228,6 +1296,7 @@ export default class DashboardAPI extends BaseAPI<
       `${new this.entityType()
         .getCrudApiPath()
         ?.toString()}/resource-list/:dashboardId/:resourceType`,
+      publicDashboardRateLimit,
       UserMiddleware.getUserMiddleware,
       async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
         try {
@@ -1248,10 +1317,143 @@ export default class DashboardAPI extends BaseAPI<
       },
     );
 
+    /*
+     * Public SLO history aggregation for the SLO widget's Chart display.
+     *
+     * The SLO's CURRENT numbers come back through /resource-list/.../slo
+     * like every other widget's data; this route serves the time SERIES
+     * behind them, which lives in ClickHouse and so needs an aggregation
+     * rather than a list.
+     *
+     * Nothing the caller sends selects data. The SLO and the series are
+     * read out of the stored widget (identified by componentId), the
+     * aggregation columns are fixed, the bucket size is recomputed from the
+     * window, and the project is pinned to the dashboard's — so the only
+     * caller-supplied input that survives is the time window itself.
+     * Authorization reuses DashboardService.hasReadAccess.
+     */
+    this.router.post(
+      `${new this.entityType()
+        .getCrudApiPath()
+        ?.toString()}/slo-history-aggregate/:dashboardId`,
+      publicDashboardRateLimit,
+      UserMiddleware.getUserMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          const dashboardId: ObjectID = new ObjectID(
+            req.params["dashboardId"] as string,
+          );
+
+          const accessResult: {
+            hasReadAccess: boolean;
+            error?: NotAuthenticatedException | ForbiddenException;
+          } = await DashboardService.hasReadAccess({
+            dashboardId,
+            req,
+          });
+
+          if (!accessResult.hasReadAccess) {
+            throw (
+              accessResult.error ||
+              new BadDataException("Access denied to this dashboard.")
+            );
+          }
+
+          if (!req.body || !req.body["aggregateBy"]) {
+            throw new BadDataException("aggregateBy is required.");
+          }
+
+          const dashboard: Dashboard | null =
+            await DashboardService.findOneById({
+              id: dashboardId,
+              select: {
+                _id: true,
+                projectId: true,
+                dashboardViewConfig: true,
+              },
+              props: {
+                isRoot: true,
+              },
+            });
+
+          if (!dashboard || !dashboard.projectId) {
+            throw new NotFoundException("Dashboard not found");
+          }
+
+          const widget: JSONObject = DashboardAPI.selectPublicResourceWidget({
+            dashboardViewConfig: dashboard.dashboardViewConfig,
+            config: PUBLIC_DASHBOARD_SLO_RESOURCE,
+            requestedComponentId: req.body["componentId"],
+          });
+
+          const policy: PublicDashboardSloHistoryPolicyResult =
+            PublicDashboardSloHistoryPolicy.build({
+              widget,
+              requestedAggregateBy: JSONFunctions.deserialize(
+                req.body["aggregateBy"] as JSONObject,
+              ),
+            });
+
+          const aggregateResult: AggregatedResult =
+            await SloHistoryService.aggregateBy({
+              /*
+               * Narrow the assertion to `query` alone. Everything else in
+               * this literal is typed against SloHistory — the column names
+               * below are `keyof SloHistory` — so asserting the whole object
+               * would turn off exactly the check that catches a typo or a
+               * renamed column at compile time instead of at runtime.
+               */
+              query: {
+                projectId: dashboard.projectId,
+                sloId: policy.serviceLevelObjectiveId,
+                metricName: policy.metricName,
+                bucketStart: new InBetween<Date>(
+                  policy.startDate,
+                  policy.endDate,
+                ),
+              } as unknown as AggregateBy<SloHistory>["query"],
+              /*
+               * All three SLO series are instantaneous gauges, so averaging
+               * the raw buckets that fall inside one chart point is the only
+               * roll-up that means anything — same as the authenticated
+               * widget and the SLO detail page.
+               */
+              aggregationType: AggregationType.Avg,
+              aggregateColumnName: "value",
+              aggregationTimestampColumnName: "bucketStart",
+              aggregationInterval: policy.aggregationInterval,
+              startTimestamp: policy.startDate,
+              endTimestamp: policy.endDate,
+              // Oldest -> newest so the line renders left to right.
+              sort: {
+                bucketStart: SortOrder.Ascending,
+              },
+              limit: policy.limit,
+              skip: 0,
+              /*
+               * Run as root: authorization is already enforced by
+               * hasReadAccess above and the project scope is pinned in the
+               * query.
+               */
+              props: {
+                isRoot: true,
+              },
+            });
+
+          return Response.sendJsonObjectResponse(req, res, {
+            ...(aggregateResult as unknown as JSONObject),
+          });
+        } catch (err) {
+          next(err);
+        }
+      },
+    );
+
     this.router.post(
       `${new this.entityType()
         .getCrudApiPath()
         ?.toString()}/master-password/:dashboardId`,
+      masterPasswordRateLimit,
       UserMiddleware.getUserMiddleware,
       async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
         try {
@@ -1379,7 +1581,21 @@ export default class DashboardAPI extends BaseAPI<
           typeof componentObject["componentType"] === "string"
             ? componentObject["componentType"]
             : "",
-        title: getStringArgument("chartTitle") || getStringArgument("title"),
+        /*
+         * Widgets do not agree on where the author's heading lives — each
+         * one's settings form names its own argument (`chartTitle`,
+         * `gaugeTitle`, `tableTitle`, the SLO widget's `widgetTitle`, plain
+         * `title` elsewhere). Read every key that is actually a heading
+         * today, so a summary is not blank for a widget that plainly has a
+         * title on the page. A widget type added later with yet another key
+         * needs adding here too.
+         */
+        title:
+          getStringArgument("chartTitle") ||
+          getStringArgument("gaugeTitle") ||
+          getStringArgument("tableTitle") ||
+          getStringArgument("widgetTitle") ||
+          getStringArgument("title"),
         description: getStringArgument("chartDescription"),
         text: getStringArgument("text"),
         metricNames: Array.from(