@oneuptime/common 9.2.16 → 9.2.17

package/Server/Utils/Workspace/Slack/Slack.ts

@@ -1896,4 +1896,138 @@ export default class SlackUtil extends WorkspaceBase {
   public static convertMarkdownToSlackRichText(markdown: string): string {
     return SlackifyMarkdown(markdown);
   }
+
+  @CaptureSpan()
+  public static async getChannelMessages(params: {
+    channelId: string;
+    authToken: string;
+    limit?: number;
+    oldestTimestamp?: Date;
+  }): Promise<
+    Array<{
+      messageId: string;
+      text: string;
+      userId?: string;
+      username?: string;
+      timestamp: Date;
+      isBot: boolean;
+    }>
+  > {
+    const messages: Array<{
+      messageId: string;
+      text: string;
+      userId?: string;
+      username?: string;
+      timestamp: Date;
+      isBot: boolean;
+    }> = [];
+    let cursor: string | undefined = undefined;
+    const maxMessages: number = params.limit || 1000;
+    const maxPages: number = 10;
+    let pageCount: number = 0;
+
+    do {
+      const requestData: JSONObject = {
+        channel: params.channelId,
+        limit: Math.min(200, maxMessages - messages.length),
+      };
+
+      if (cursor) {
+        requestData["cursor"] = cursor;
+      }
+
+      if (params.oldestTimestamp) {
+        requestData["oldest"] = (
+          params.oldestTimestamp.getTime() / 1000
+        ).toString();
+      }
+
+      const response: HTTPErrorResponse | HTTPResponse<JSONObject> =
+        await API.post<JSONObject>({
+          url: URL.fromString("https://slack.com/api/conversations.history"),
+          data: requestData,
+          headers: {
+            Authorization: `Bearer ${params.authToken}`,
+            "Content-Type": "application/x-www-form-urlencoded",
+          },
+          options: {
+            retries: 3,
+            exponentialBackoff: true,
+          },
+        });
+
+      if (response instanceof HTTPErrorResponse) {
+        logger.error("Error response from Slack API for channel history:");
+        logger.error(response);
+        break;
+      }
+
+      const jsonData: JSONObject = response.jsonData as JSONObject;
+
+      if (jsonData["ok"] !== true) {
+        logger.error("Invalid response from Slack API for channel history:");
+        logger.error(jsonData);
+        break;
+      }
+
+      const slackMessages: Array<JSONObject> =
+        (jsonData["messages"] as Array<JSONObject>) || [];
+
+      for (const msg of slackMessages) {
+        // Skip bot messages if they're from the OneUptime bot (app messages)
+        const isBot: boolean =
+          Boolean(msg["bot_id"]) || msg["subtype"] === "bot_message";
+
+        // Extract text, handling attachments and blocks
+        let text: string = (msg["text"] as string) || "";
+
+        // If there are attachments, append their text
+        const attachments: Array<JSONObject> | undefined = msg[
+          "attachments"
+        ] as Array<JSONObject> | undefined;
+        if (attachments && Array.isArray(attachments)) {
+          for (const attachment of attachments) {
+            if (attachment && attachment["text"]) {
+              text += "\n" + (attachment["text"] as string);
+            }
+            if (attachment && attachment["fallback"]) {
+              text += "\n" + (attachment["fallback"] as string);
+            }
+          }
+        }
+
+        // Skip empty messages
+        if (!text.trim()) {
+          continue;
+        }
+
+        const timestamp: Date = msg["ts"]
+          ? new Date(parseFloat(msg["ts"] as string) * 1000)
+          : new Date();
+
+        messages.push({
+          messageId: msg["ts"] as string,
+          text: text,
+          userId: msg["user"] as string,
+          username: msg["username"] as string,
+          timestamp: timestamp,
+          isBot: isBot,
+        });
+      }
+
+      cursor = (jsonData["response_metadata"] as JSONObject)?.[
+        "next_cursor"
+      ] as string;
+      pageCount++;
+    } while (cursor && messages.length < maxMessages && pageCount < maxPages);
+
+    logger.debug(
+      `Retrieved ${messages.length} messages from Slack channel ${params.channelId}`,
+    );
+
+    // Reverse to get chronological order (Slack returns newest first)
+    messages.reverse();
+
+    return messages;
+  }
 }

package/Server/Utils/Workspace/Workspace.ts

@@ -17,6 +17,16 @@ import WorkspaceUserAuthToken from "../../../Models/DatabaseModels/WorkspaceUser
 import WorkspaceUserAuthTokenService from "../../Services/WorkspaceUserAuthTokenService";
 import UserService from "../../Services/UserService";
 import CaptureSpan from "../Telemetry/CaptureSpan";
+import OneUptimeDate from "../../../Types/Date";
+
+export interface WorkspaceChannelMessage {
+  messageId: string;
+  text: string;
+  userId?: string;
+  username?: string;
+  timestamp: Date;
+  isBot: boolean;
+}
 
 export default class WorkspaceUtil {
   @CaptureSpan()
@@ -236,4 +246,120 @@ export default class WorkspaceUtil {
 
     return result;
   }
+
+  @CaptureSpan()
+  public static async getChannelMessages(params: {
+    channelId: string;
+    authToken: string;
+    projectId: ObjectID;
+    workspaceType: WorkspaceType;
+    teamId?: string;
+    limit?: number;
+    oldestTimestamp?: Date;
+  }): Promise<Array<WorkspaceChannelMessage>> {
+    switch (params.workspaceType) {
+      case WorkspaceType.Slack: {
+        const slackParams: {
+          channelId: string;
+          authToken: string;
+          limit?: number;
+          oldestTimestamp?: Date;
+        } = {
+          channelId: params.channelId,
+          authToken: params.authToken,
+        };
+
+        if (params.limit !== undefined) {
+          slackParams.limit = params.limit;
+        }
+
+        if (params.oldestTimestamp) {
+          slackParams.oldestTimestamp = params.oldestTimestamp;
+        }
+
+        return await SlackWorkspace.getChannelMessages(slackParams);
+      }
+      case WorkspaceType.MicrosoftTeams: {
+        if (!params.teamId) {
+          logger.error(
+            "Team ID is required for Microsoft Teams channel messages",
+          );
+          return [];
+        }
+
+        const teamsParams: {
+          channelId: string;
+          teamId: string;
+          projectId: ObjectID;
+          limit?: number;
+          oldestTimestamp?: Date;
+        } = {
+          channelId: params.channelId,
+          teamId: params.teamId,
+          projectId: params.projectId,
+        };
+
+        if (params.limit !== undefined) {
+          teamsParams.limit = params.limit;
+        }
+
+        if (params.oldestTimestamp) {
+          teamsParams.oldestTimestamp = params.oldestTimestamp;
+        }
+
+        return await MicrosoftTeamsUtil.getChannelMessages(teamsParams);
+      }
+      default:
+        logger.debug(
+          `Unsupported workspace type for channel messages: ${params.workspaceType}`,
+        );
+        return [];
+    }
+  }
+
+  @CaptureSpan()
+  public static formatMessagesAsContext(
+    messages: Array<WorkspaceChannelMessage>,
+    options?: {
+      includeTimestamp?: boolean;
+      includeUsername?: boolean;
+      maxLength?: number;
+    },
+  ): string {
+    const includeTimestamp: boolean = options?.includeTimestamp ?? true;
+    const includeUsername: boolean = options?.includeUsername ?? true;
+    const maxLength: number = options?.maxLength || 50000;
+
+    let context: string = "";
+
+    for (const msg of messages) {
+      let line: string = "";
+
+      if (includeTimestamp) {
+        const dateStr: string = OneUptimeDate.getDateAsFormattedString(
+          msg.timestamp,
+        );
+        line += `[${dateStr}] `;
+      }
+
+      if (includeUsername && msg.username) {
+        line += `${msg.username}: `;
+      } else if (includeUsername && msg.userId) {
+        line += `User ${msg.userId}: `;
+      }
+
+      line += msg.text;
+      line += "\n";
+
+      // Check if adding this line would exceed max length
+      if (context.length + line.length > maxLength) {
+        context += "\n... (messages truncated due to length)";
+        break;
+      }
+
+      context += line;
+    }
+
+    return context.trim();
+  }
 }

package/Types/CodeRepository/CodeRepositoryType.ts

@@ -1,6 +1,6 @@
 enum CodeRepositoryType {
   GitHub = "GitHub",
-  // GitLab = 'GitLab',
+  GitLab = "GitLab",
 }
 
 export default CodeRepositoryType;

package/Types/LlmLogStatus.ts

@@ -0,0 +1,7 @@
+enum LlmLogStatus {
+  Success = "Success",
+  Error = "Error",
+  InsufficientBalance = "Insufficient Balance",
+}
+
+export default LlmLogStatus;

package/Types/Permission.ts

@@ -147,6 +147,7 @@ enum Permission {
   ReadCallLog = "ReadCallLog",
   ReadPushLog = "ReadPushLog",
   ReadWorkspaceNotificationLog = "ReadWorkspaceNotificationLog",
+  ReadLlmLog = "ReadLlmLog",
 
   CreateIncidentOwnerTeam = "CreateIncidentOwnerTeam",
   DeleteIncidentOwnerTeam = "DeleteIncidentOwnerTeam",
@@ -624,6 +625,17 @@ enum Permission {
   EditServiceCatalogTelemetryService = "EditServiceCatalogTelemetryService",
   ReadServiceCatalogTelemetryService = "ReadServiceCatalogTelemetryService",
 
+  CreateServiceCatalogCodeRepository = "CreateServiceCatalogCodeRepository",
+  DeleteServiceCatalogCodeRepository = "DeleteServiceCatalogCodeRepository",
+  EditServiceCatalogCodeRepository = "EditServiceCatalogCodeRepository",
+  ReadServiceCatalogCodeRepository = "ReadServiceCatalogCodeRepository",
+
+  // Code Repository
+  CreateCodeRepository = "CreateCodeRepository",
+  DeleteCodeRepository = "DeleteCodeRepository",
+  EditCodeRepository = "EditCodeRepository",
+  ReadCodeRepository = "ReadCodeRepository",
+
   CreateProbeOwnerTeam = "CreateProbeOwnerTeam",
   DeleteProbeOwnerTeam = "DeleteProbeOwnerTeam",
   EditProbeOwnerTeam = "EditProbeOwnerTeam",
@@ -3132,6 +3144,14 @@ export class PermissionHelper {
         isAccessControlPermission: false,
       },
 
+      {
+        permission: Permission.ReadLlmLog,
+        title: "Read LLM Log",
+        description: "This permission can read LLM Logs of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+      },
+
       {
         permission: Permission.CreateMonitorProbe,
         title: "Create Monitor Probe",
@@ -3417,6 +3437,73 @@ export class PermissionHelper {
         isAccessControlPermission: false,
       },
 
+      {
+        permission: Permission.CreateServiceCatalogCodeRepository,
+        title: "Create Service Catalog Code Repository",
+        description:
+          "This permission can create Service Catalog Code Repository in this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+      },
+      {
+        permission: Permission.DeleteServiceCatalogCodeRepository,
+        title: "Delete Service Catalog Code Repository",
+        description:
+          "This permission can delete Service Catalog Code Repository of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+      },
+      {
+        permission: Permission.EditServiceCatalogCodeRepository,
+        title: "Edit Service Catalog Code Repository",
+        description:
+          "This permission can edit Service Catalog Code Repository of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+      },
+      {
+        permission: Permission.ReadServiceCatalogCodeRepository,
+        title: "Read Service Catalog Code Repository",
+        description:
+          "This permission can read Service Catalog Code Repository of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: false,
+      },
+
+      // Code Repository Permissions
+      {
+        permission: Permission.CreateCodeRepository,
+        title: "Create Code Repository",
+        description:
+          "This permission can create Code Repositories in this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: true,
+      },
+      {
+        permission: Permission.DeleteCodeRepository,
+        title: "Delete Code Repository",
+        description:
+          "This permission can delete Code Repositories of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: true,
+      },
+      {
+        permission: Permission.EditCodeRepository,
+        title: "Edit Code Repository",
+        description:
+          "This permission can edit Code Repositories of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: true,
+      },
+      {
+        permission: Permission.ReadCodeRepository,
+        title: "Read Code Repository",
+        description:
+          "This permission can read Code Repositories of this project.",
+        isAssignableToTenant: true,
+        isAccessControlPermission: true,
+      },
+
       {
         permission: Permission.CreateTelemetryServiceTraces,
         title: "Create Telemetry Service Traces",

package/Types/ServiceCatalog/CodeRepositoryImprovementAction.ts

@@ -0,0 +1,9 @@
+enum CodeRepositoryImprovementAction {
+  FixExceptions = "Fix Exceptions",
+  ImproveLogs = "Improve Logs",
+  ImproveSpans = "Improve Spans",
+  ImproveMetrics = "Improve Metrics",
+  FixPerformanceIssues = "Fix Performance Issues",
+}
+
+export default CodeRepositoryImprovementAction;

package/UI/Components/AI/AILoader.tsx

@@ -0,0 +1,95 @@
+import React, {
+  FunctionComponent,
+  ReactElement,
+  useEffect,
+  useState,
+} from "react";
+
+const loadingStages: Array<string> = ["Analyzing", "Processing", "Generating"];
+
+const AILoader: FunctionComponent = (): ReactElement => {
+  const [stageIndex, setStageIndex] = useState<number>(0);
+  const [dots, setDots] = useState<string>("");
+
+  // Cycle through stages
+  useEffect(() => {
+    const interval: NodeJS.Timeout = setInterval(() => {
+      setStageIndex((prev: number) => {
+        return (prev + 1) % loadingStages.length;
+      });
+    }, 2500);
+
+    return () => {
+      clearInterval(interval);
+    };
+  }, []);
+
+  // Animate dots
+  useEffect(() => {
+    const interval: NodeJS.Timeout = setInterval(() => {
+      setDots((prev: string) => {
+        return prev.length >= 3 ? "" : prev + ".";
+      });
+    }, 400);
+
+    return () => {
+      clearInterval(interval);
+    };
+  }, []);
+
+  return (
+    <div className="py-8 px-4">
+      <div className="flex items-center justify-center gap-3">
+        {/* Pulsing AI indicator */}
+        <div className="relative">
+          <div
+            className="w-2 h-2 bg-indigo-600 rounded-full"
+            style={{
+              animation: "aiPulse 1.5s ease-in-out infinite",
+            }}
+          />
+          <div
+            className="absolute inset-0 w-2 h-2 bg-indigo-600 rounded-full"
+            style={{
+              animation: "aiPing 1.5s ease-out infinite",
+            }}
+          />
+        </div>
+
+        {/* Status text */}
+        <span className="text-sm text-gray-600 font-medium min-w-[100px]">
+          {loadingStages[stageIndex]}
+          <span className="inline-block w-4 text-left">{dots}</span>
+        </span>
+      </div>
+
+      {/* CSS for animations */}
+      <style>
+        {`
+          @keyframes aiPulse {
+            0%, 100% {
+              opacity: 1;
+              transform: scale(1);
+            }
+            50% {
+              opacity: 0.7;
+              transform: scale(1.1);
+            }
+          }
+          @keyframes aiPing {
+            0% {
+              opacity: 0.6;
+              transform: scale(1);
+            }
+            100% {
+              opacity: 0;
+              transform: scale(2.5);
+            }
+          }
+        `}
+      </style>
+    </div>
+  );
+};
+
+export default AILoader;