@oneuptime/common 11.3.24 → 11.3.26

package/Server/API/SlackAPI.ts

@@ -48,6 +48,10 @@ import {
   PrivateNoteEmojis,
   PublicNoteEmojis,
 } from "../Utils/Workspace/Slack/Actions/ActionTypes";
+import WorkspaceUserAuthToken from "../../Models/DatabaseModels/WorkspaceUserAuthToken";
+import AccessTokenService from "../Services/AccessTokenService";
+import ObservabilityAssistant from "../Utils/AI/Chat/ObservabilityAssistant";
+import { AIChatCitation } from "../../Types/AI/AIChatTypes";
 
 export default class SlackAPI {
   public getRouter(): ExpressRouter {
@@ -944,6 +948,322 @@ export default class SlackAPI {
 
             return;
           }
+
+          /*
+           * Handle "AI Ops" conversational events. There are three classes:
+           *  - app_mention: the bot was @mentioned in a channel/group.
+           *  - message with channel_type "im": a direct message to the bot.
+           *  - message with channel_type "channel" | "group" | "mpim": a plain
+           *    thread reply. We only treat these as follow-ups when they land
+           *    in a thread the bot already participates in (see below), so we
+           *    never answer arbitrary channel chatter.
+           */
+          const eventChannelType: string | undefined = event["channel_type"] as
+            | string
+            | undefined;
+          const isAppMention: boolean = event["type"] === "app_mention";
+          const isDirectMessage: boolean =
+            event["type"] === "message" && eventChannelType === "im";
+          const isChannelThreadMessage: boolean =
+            event["type"] === "message" &&
+            (eventChannelType === "channel" ||
+              eventChannelType === "group" ||
+              eventChannelType === "mpim");
+
+          if (isAppMention || isDirectMessage || isChannelThreadMessage) {
+            /*
+             * Slack retries an event if it does not receive a 200 within 3
+             * seconds. Acknowledge immediately and do the (slow) assistant
+             * work detached. Also skip entirely on Slack retries so we never
+             * answer the same question twice.
+             */
+            const isSlackRetry: boolean = Boolean(
+              req.headers["x-slack-retry-num"],
+            );
+
+            Response.sendTextResponse(req, res, "ok");
+
+            if (isSlackRetry) {
+              logger.debug(
+                "Skipping Slack AI Ops event because it is a Slack retry.",
+                getLogAttributesFromRequest(req as any),
+              );
+              return;
+            }
+
+            /*
+             * CRITICAL loop-guard: never react to messages produced by a bot
+             * (including ourselves) or to message subtypes such as
+             * message_changed / bot_message. Without this the bot would answer
+             * its own replies forever.
+             */
+            const eventSubtype: string | undefined = event["subtype"] as
+              | string
+              | undefined;
+            const eventBotId: string | undefined = event["bot_id"] as
+              | string
+              | undefined;
+            const eventUserId: string | undefined = event["user"] as
+              | string
+              | undefined;
+
+            if (eventBotId || eventSubtype) {
+              logger.debug(
+                "Skipping Slack AI Ops event from a bot or with a subtype.",
+                getLogAttributesFromRequest(req as any),
+              );
+              return;
+            }
+
+            const eventText: string = (event["text"] as string) || "";
+
+            /*
+             * A mention fires BOTH app_mention and message.* events. Let the
+             * app_mention path own mentions and skip mention-bearing plain
+             * message.* events to avoid answering twice.
+             */
+            const botMentionRegex: RegExp = /<@[A-Z0-9]+>/;
+            if (isChannelThreadMessage && botMentionRegex.test(eventText)) {
+              logger.debug(
+                "Skipping channel message that mentions the bot (handled by app_mention).",
+                getLogAttributesFromRequest(req as any),
+              );
+              return;
+            }
+
+            const slackTeamId: string = payload["team_id"] as string;
+            const slackChannelId: string = event["channel"] as string;
+            const eventTs: string | undefined = event["ts"] as
+              | string
+              | undefined;
+            const eventThreadTs: string | undefined = event["thread_ts"] as
+              | string
+              | undefined;
+            /*
+             * Reply in the same thread. For app_mention the mention may be in a
+             * thread (thread_ts) or a top-level message (ts). For DMs we thread
+             * off the message ts (or its thread if present).
+             */
+            const threadTs: string = eventThreadTs || eventTs || "";
+
+            /*
+             * Detach the assistant work (fire-and-forget). Everything below is
+             * best-effort; the Slack ack has already been sent.
+             */
+            (async (): Promise<void> => {
+              const context:
+                | {
+                    projectId: ObjectID;
+                    projectAuthToken: string;
+                    botUserId: string | undefined;
+                    userId: ObjectID | undefined;
+                  }
+                | undefined = await SlackAPI.resolveSlackAiOpsContext({
+                slackTeamId: slackTeamId,
+                slackUserId: eventUserId || "",
+              });
+
+              // Workspace not connected to any project — nothing we can do.
+              if (!context) {
+                logger.debug(
+                  "Slack AI Ops event: workspace not connected to any project.",
+                  getLogAttributesFromRequest(req as any),
+                );
+                return;
+              }
+
+              /*
+               * Loop-guard: ignore messages authored by our own bot user id.
+               */
+              if (
+                context.botUserId &&
+                eventUserId &&
+                context.botUserId === eventUserId
+              ) {
+                logger.debug(
+                  "Skipping Slack AI Ops event authored by our bot user.",
+                  getLogAttributesFromRequest(req as any),
+                );
+                return;
+              }
+
+              /*
+               * Extract the question text. Strip mention tokens (for
+               * app_mention the leading <@BOTID>) and trim.
+               */
+              const questionText: string =
+                SlackAPI.cleanSlackMessageText(eventText);
+
+              if (!questionText) {
+                logger.debug(
+                  "Slack AI Ops event has no question text. Skipping.",
+                  getLogAttributesFromRequest(req as any),
+                );
+                return;
+              }
+
+              /*
+               * Build conversation history so follow-ups are context-aware.
+               *  - app_mention: history only when inside a thread.
+               *  - channel/group/mpim: MUST be inside a thread AND the bot must
+               *    already participate in that thread (it started/answered it).
+               *    Otherwise we ignore the message entirely.
+               *  - im: history from recent DM messages.
+               */
+              let history:
+                | Array<{ role: "user" | "assistant"; content: string }>
+                | undefined = undefined;
+
+              if (isChannelThreadMessage) {
+                if (!eventThreadTs) {
+                  logger.debug(
+                    "Skipping channel message not in a thread.",
+                    getLogAttributesFromRequest(req as any),
+                  );
+                  return;
+                }
+
+                const threadReplies: Array<{
+                  user?: string | undefined;
+                  bot_id?: string | undefined;
+                  text?: string | undefined;
+                  ts?: string | undefined;
+                  subtype?: string | undefined;
+                }> = await SlackUtil.getThreadReplies({
+                  authToken: context.projectAuthToken,
+                  channelId: slackChannelId,
+                  threadTs: eventThreadTs,
+                });
+
+                const botParticipatesInThread: boolean = threadReplies.some(
+                  (reply: {
+                    user?: string | undefined;
+                    bot_id?: string | undefined;
+                  }) => {
+                    return Boolean(
+                      reply.bot_id ||
+                        (context.botUserId && reply.user === context.botUserId),
+                    );
+                  },
+                );
+
+                if (!botParticipatesInThread) {
+                  logger.debug(
+                    "Skipping channel thread the bot does not participate in.",
+                    getLogAttributesFromRequest(req as any),
+                  );
+                  return;
+                }
+
+                history = SlackAPI.buildHistoryFromSlackMessages({
+                  messages: threadReplies,
+                  botUserId: context.botUserId,
+                  currentMessageTs: eventTs,
+                });
+              } else if (isAppMention && eventThreadTs) {
+                const threadReplies: Array<{
+                  user?: string | undefined;
+                  bot_id?: string | undefined;
+                  text?: string | undefined;
+                  ts?: string | undefined;
+                  subtype?: string | undefined;
+                }> = await SlackUtil.getThreadReplies({
+                  authToken: context.projectAuthToken,
+                  channelId: slackChannelId,
+                  threadTs: eventThreadTs,
+                });
+
+                history = SlackAPI.buildHistoryFromSlackMessages({
+                  messages: threadReplies,
+                  botUserId: context.botUserId,
+                  currentMessageTs: eventTs,
+                });
+              } else if (isDirectMessage) {
+                const dmMessages: Array<{
+                  messageId: string;
+                  text: string;
+                  userId?: string;
+                  username?: string;
+                  timestamp: Date;
+                  isBot: boolean;
+                }> = await SlackUtil.getChannelMessages({
+                  channelId: slackChannelId,
+                  authToken: context.projectAuthToken,
+                  limit: 30,
+                });
+
+                history = SlackAPI.buildHistoryFromSlackMessages({
+                  messages: dmMessages.map(
+                    (message: {
+                      messageId: string;
+                      text: string;
+                      userId?: string;
+                      isBot: boolean;
+                    }) => {
+                      return {
+                        user: message.userId,
+                        bot_id: message.isBot ? "bot" : undefined,
+                        text: message.text,
+                        ts: message.messageId,
+                      };
+                    },
+                  ),
+                  botUserId: context.botUserId,
+                  currentMessageTs: eventTs,
+                });
+              }
+
+              // If the user's Slack account is not connected to OneUptime.
+              if (!context.userId) {
+                await SlackUtil.sendMessageToThread({
+                  authToken: context.projectAuthToken,
+                  channelId: slackChannelId,
+                  threadTs: threadTs,
+                  text: SlackAPI.getSlackAccountNotConnectedMessage(),
+                });
+                return;
+              }
+
+              // Immediate acknowledgement so the user sees we are working.
+              try {
+                await SlackUtil.sendMessageToThread({
+                  authToken: context.projectAuthToken,
+                  channelId: slackChannelId,
+                  threadTs: threadTs,
+                  text: "Looking into it… :hourglass_flowing_sand:",
+                });
+              } catch (err) {
+                logger.error(
+                  "Error sending Slack AI Ops acknowledgement:",
+                  getLogAttributesFromRequest(req as any),
+                );
+                logger.error(err, getLogAttributesFromRequest(req as any));
+              }
+
+              const answerMarkdown: string =
+                await SlackAPI.getAiOpsAnswerMarkdown({
+                  projectId: context.projectId,
+                  userId: context.userId,
+                  question: questionText,
+                  history: history,
+                });
+
+              await SlackUtil.sendMessageToThread({
+                authToken: context.projectAuthToken,
+                channelId: slackChannelId,
+                threadTs: threadTs,
+                text: SlackUtil.convertMarkdownToSlackRichText(answerMarkdown),
+              });
+            })().catch((err: Error) => {
+              logger.error(
+                "Error handling Slack AI Ops event:",
+                getLogAttributesFromRequest(req as any),
+              );
+              logger.error(err, getLogAttributesFromRequest(req as any));
+            });
+
+            return;
+          }
         }
 
         // For any other event types, just acknowledge
@@ -951,6 +1271,127 @@ export default class SlackAPI {
       },
     );
 
+    /*
+     * Slash command endpoint: `/oneuptime ask <question>` (or bare
+     * `/oneuptime <question>`). Slack posts an application/x-www-form-urlencoded
+     * body and expects a 200 within 3 seconds. We acknowledge instantly with an
+     * ephemeral message, then run the assistant detached and POST the final
+     * answer back to the command's response_url.
+     */
+    router.post(
+      "/slack/command",
+      SlackAuthorization.isAuthorizedSlackRequest,
+      async (req: ExpressRequest, res: ExpressResponse) => {
+        logger.debug(
+          "Slack slash command received",
+          getLogAttributesFromRequest(req as any),
+        );
+
+        const body: JSONObject = req.body;
+
+        const slackTeamId: string = (body["team_id"] as string) || "";
+        const slackUserId: string = (body["user_id"] as string) || "";
+        const responseUrl: string = (body["response_url"] as string) || "";
+
+        /*
+         * Slack sends everything after the command word in `text`. We also
+         * accept a leading "ask" keyword (e.g. `/oneuptime ask <question>`).
+         */
+        const askPrefixRegex: RegExp = /^ask\s+/i;
+        let questionText: string = ((body["text"] as string) || "").trim();
+        if (askPrefixRegex.test(questionText)) {
+          questionText = questionText.replace(askPrefixRegex, "").trim();
+        }
+
+        // Empty command -> ephemeral usage help.
+        if (!questionText) {
+          return Response.sendJsonObjectResponse(req, res, {
+            response_type: "ephemeral",
+            text: "Usage: `/oneuptime ask which monitors are down?` — ask OneUptime AI about your logs, traces, metrics, incidents and monitors.",
+          });
+        }
+
+        /*
+         * Acknowledge instantly so Slack does not time out. The real answer is
+         * delivered to response_url below.
+         */
+        Response.sendJsonObjectResponse(req, res, {
+          response_type: "ephemeral",
+          text: "On it… :hourglass_flowing_sand:",
+        });
+
+        // Detached work (fire-and-forget). Ack has already been sent.
+        (async (): Promise<void> => {
+          const context:
+            | {
+                projectId: ObjectID;
+                projectAuthToken: string;
+                botUserId: string | undefined;
+                userId: ObjectID | undefined;
+              }
+            | undefined = await SlackAPI.resolveSlackAiOpsContext({
+            slackTeamId: slackTeamId,
+            slackUserId: slackUserId,
+          });
+
+          if (!context) {
+            // Workspace not connected — tell the user ephemerally.
+            await API.post({
+              url: URL.fromString(responseUrl),
+              data: {
+                response_type: "ephemeral",
+                text: "This Slack workspace is not connected to any OneUptime project.",
+              },
+              headers: {
+                ["Content-Type"]: "application/json",
+              },
+            });
+            return;
+          }
+
+          if (!context.userId) {
+            // User's Slack account is not connected to OneUptime.
+            await API.post({
+              url: URL.fromString(responseUrl),
+              data: {
+                response_type: "ephemeral",
+                text: SlackAPI.getSlackAccountNotConnectedMessage(),
+              },
+              headers: {
+                ["Content-Type"]: "application/json",
+              },
+            });
+            return;
+          }
+
+          const answerMarkdown: string = await SlackAPI.getAiOpsAnswerMarkdown({
+            projectId: context.projectId,
+            userId: context.userId,
+            question: questionText,
+          });
+
+          await API.post({
+            url: URL.fromString(responseUrl),
+            data: {
+              response_type: "in_channel",
+              text: SlackUtil.convertMarkdownToSlackRichText(answerMarkdown),
+            },
+            headers: {
+              ["Content-Type"]: "application/json",
+            },
+          });
+        })().catch((err: Error) => {
+          logger.error(
+            "Error handling Slack slash command:",
+            getLogAttributesFromRequest(req as any),
+          );
+          logger.error(err, getLogAttributesFromRequest(req as any));
+        });
+
+        return;
+      },
+    );
+
     // options load endpoint.
 
     router.post(
@@ -965,4 +1406,226 @@ export default class SlackAPI {
 
     return router;
   }
+
+  /*
+   * Shared "AI Ops" resolution used by both @mentions / DMs (Events API) and
+   * the /oneuptime slash command. Resolves the Slack team_id -> OneUptime
+   * project and the Slack user id -> OneUptime user using the same
+   * WorkspaceProjectAuthToken / WorkspaceUserAuthToken pattern as
+   * SlackAuthAction.isAuthorized. Returns undefined when the workspace is not
+   * connected to any OneUptime project at all.
+   */
+  private static async resolveSlackAiOpsContext(data: {
+    slackTeamId: string;
+    slackUserId: string;
+  }): Promise<
+    | {
+        projectId: ObjectID;
+        projectAuthToken: string;
+        botUserId: string | undefined;
+        userId: ObjectID | undefined;
+      }
+    | undefined
+  > {
+    const { slackTeamId, slackUserId } = data;
+
+    if (!slackTeamId) {
+      return undefined;
+    }
+
+    const projectAuth: WorkspaceProjectAuthToken | null =
+      await WorkspaceProjectAuthTokenService.findOneBy({
+        query: {
+          workspaceProjectId: slackTeamId,
+        },
+        select: {
+          projectId: true,
+          authToken: true,
+          miscData: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    if (!projectAuth || !projectAuth.projectId || !projectAuth.authToken) {
+      return undefined;
+    }
+
+    const projectId: ObjectID = projectAuth.projectId;
+
+    const userAuth: WorkspaceUserAuthToken | null =
+      await WorkspaceUserAuthTokenService.findOneBy({
+        query: {
+          workspaceUserId: slackUserId,
+          projectId: projectId,
+        },
+        select: {
+          userId: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    return {
+      projectId: projectId,
+      projectAuthToken: projectAuth.authToken,
+      botUserId: (projectAuth.miscData as SlackMiscData)?.botUserId,
+      userId: userAuth?.userId,
+    };
+  }
+
+  /*
+   * Runs the observability assistant for a resolved user + project and returns
+   * the finished markdown answer with a compact "Sources" footer appended.
+   * `history` (oldest-first prior turns, excluding the current question) makes
+   * threaded / DM follow-ups context-aware.
+   */
+  private static async getAiOpsAnswerMarkdown(data: {
+    projectId: ObjectID;
+    userId: ObjectID;
+    question: string;
+    history?:
+      | Array<{ role: "user" | "assistant"; content: string }>
+      | undefined;
+  }): Promise<string> {
+    const props: DatabaseCommonInteractionProps =
+      await AccessTokenService.getDatabaseCommonInteractionPropsByUserAndProject(
+        {
+          userId: data.userId,
+          projectId: data.projectId,
+        },
+      );
+
+    const result: {
+      contentInMarkdown: string;
+      citations: Array<AIChatCitation>;
+      totalTokens: number;
+      llmCallCount: number;
+      toolCallCount: number;
+      providerName?: string | undefined;
+      modelName?: string | undefined;
+    } = await ObservabilityAssistant.answerQuestion({
+      projectId: data.projectId,
+      userId: data.userId,
+      props: props,
+      question: data.question,
+      history: data.history,
+      feature: "Slack ChatOps",
+    });
+
+    let answerMarkdown: string = result.contentInMarkdown || "";
+
+    // Append a compact "Sources" footer from the server-minted citations.
+    if (result.citations && result.citations.length > 0) {
+      const sourceLines: Array<string> = result.citations.map(
+        (citation: AIChatCitation) => {
+          return `• ${citation.label} (${citation.rowCount} rows)`;
+        },
+      );
+
+      answerMarkdown =
+        answerMarkdown + "\n\n*Sources*\n" + sourceLines.join("\n");
+    }
+
+    return answerMarkdown;
+  }
+
+  /*
+   * Removes Slack `<@USER>` / `<@USER|name>` mention tokens and trims the text.
+   * Used both to extract the question and to clean history turns.
+   */
+  private static cleanSlackMessageText(text: string | undefined): string {
+    return (text || "")
+      .replace(/<@[^>]+>/g, " ")
+      .replace(/\s+/g, " ")
+      .trim();
+  }
+
+  /*
+   * The bot posts transient acknowledgements ("Looking into it…", "On it…")
+   * before the real answer. These must never enter the assistant's history or
+   * they pollute context.
+   */
+  private static isTransientAckMessage(text: string): boolean {
+    const normalized: string = text.trim().toLowerCase();
+    return (
+      normalized.startsWith("looking into it") || normalized.startsWith("on it")
+    );
+  }
+
+  /*
+   * Builds oldest-first conversation history for the observability assistant
+   * from a list of Slack messages (thread replies or recent DM messages).
+   *
+   * - Each message becomes a turn: authored by the bot -> "assistant",
+   *   otherwise -> "user".
+   * - Text is stripped of mention tokens; empty messages are skipped.
+   * - The bot's transient acknowledgements are filtered out.
+   * - The current triggering message (matched by its ts) is excluded because it
+   *   is passed separately as the `question`.
+   * - Capped to the most recent ~12 turns.
+   */
+  private static buildHistoryFromSlackMessages(data: {
+    messages: Array<{
+      user?: string | undefined;
+      bot_id?: string | undefined;
+      text?: string | undefined;
+      ts?: string | undefined;
+      subtype?: string | undefined;
+    }>;
+    botUserId: string | undefined;
+    currentMessageTs: string | undefined;
+  }): Array<{ role: "user" | "assistant"; content: string }> {
+    const MAX_HISTORY_TURNS: number = 12;
+
+    const history: Array<{ role: "user" | "assistant"; content: string }> = [];
+
+    for (const message of data.messages) {
+      // Exclude the message that triggered this run.
+      if (
+        data.currentMessageTs &&
+        message.ts &&
+        message.ts === data.currentMessageTs
+      ) {
+        continue;
+      }
+
+      const content: string = SlackAPI.cleanSlackMessageText(message.text);
+
+      if (!content) {
+        continue;
+      }
+
+      const isAssistant: boolean = Boolean(
+        message.bot_id || (data.botUserId && message.user === data.botUserId),
+      );
+
+      // Drop the bot's own transient acknowledgements.
+      if (isAssistant && SlackAPI.isTransientAckMessage(content)) {
+        continue;
+      }
+
+      history.push({
+        role: isAssistant ? "assistant" : "user",
+        content: content,
+      });
+    }
+
+    // Keep only the most recent turns.
+    if (history.length > MAX_HISTORY_TURNS) {
+      return history.slice(history.length - MAX_HISTORY_TURNS);
+    }
+
+    return history;
+  }
+
+  /*
+   * Message shown to a Slack user whose Slack account is not connected to
+   * OneUptime. Mirrors the copy used in SlackAuthAction.isAuthorized.
+   */
+  private static getSlackAccountNotConnectedMessage(): string {
+    return "Unfortunately your Slack account is not connected to OneUptime. Please log into your OneUptime account, click on User Settings and then connect your Slack account.";
+  }
 }