@oneuptime/common 9.2.26 → 9.3.0

package/Server/Services/AIAgentTaskService.ts

@@ -0,0 +1,178 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/AIAgentTask";
+import AIAgent from "../../Models/DatabaseModels/AIAgent";
+import CreateBy from "../Types/Database/CreateBy";
+import { OnCreate } from "../Types/Database/Hooks";
+import BadDataException from "../../Types/Exception/BadDataException";
+import AIAgentService from "./AIAgentService";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import ObjectID from "../../Types/ObjectID";
+import Semaphore, { SemaphoreMutex } from "../Infrastructure/Semaphore";
+import SortOrder from "../../Types/BaseDatabase/SortOrder";
+import logger from "../Utils/Logger";
+import OneUptimeDate from "../../Types/Date";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    // If no aiAgentId is provided, assign one automatically
+    if (!createBy.data.aiAgentId) {
+      createBy.data.aiAgentId = await this.getDefaultAgentId(createBy);
+    } else {
+      // Validate the provided aiAgentId
+      await this.validateAgentBelongsToProject(createBy);
+    }
+
+    // Generate task number
+    if (!createBy.data.projectId) {
+      throw new BadDataException(
+        "Project ID is required to create an AI Agent Task",
+      );
+    }
+
+    const projectId: ObjectID = createBy.data.projectId;
+
+    let mutex: SemaphoreMutex | null = null;
+
+    try {
+      mutex = await Semaphore.lock({
+        key: projectId.toString(),
+        namespace: "AIAgentTaskService.task-create",
+        lockTimeout: 15000,
+        acquireTimeout: 20000,
+      });
+
+      logger.debug(
+        "Mutex acquired - AIAgentTaskService.task-create " +
+          projectId.toString() +
+          " at " +
+          OneUptimeDate.getCurrentDateAsFormattedString(),
+      );
+    } catch (err) {
+      logger.debug(
+        "Mutex acquire failed - AIAgentTaskService.task-create " +
+          projectId.toString() +
+          " at " +
+          OneUptimeDate.getCurrentDateAsFormattedString(),
+      );
+      logger.error(err);
+    }
+
+    try {
+      const taskNumberForThisTask: number =
+        (await this.getExistingTaskNumberForProject({
+          projectId: projectId,
+        })) + 1;
+
+      createBy.data.taskNumber = taskNumberForThisTask;
+    } finally {
+      if (mutex) {
+        await Semaphore.release(mutex);
+      }
+    }
+
+    return { createBy, carryForward: null };
+  }
+
+  @CaptureSpan()
+  public async getExistingTaskNumberForProject(data: {
+    projectId: ObjectID;
+  }): Promise<number> {
+    // get last task number.
+    const lastTask: Model | null = await this.findOneBy({
+      query: {
+        projectId: data.projectId,
+      },
+      select: {
+        taskNumber: true,
+      },
+      sort: {
+        createdAt: SortOrder.Descending,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!lastTask) {
+      return 0;
+    }
+
+    return lastTask.taskNumber ? Number(lastTask.taskNumber) : 0;
+  }
+
+  @CaptureSpan()
+  private async getDefaultAgentId(
+    createBy: CreateBy<Model>,
+  ): Promise<ObjectID> {
+    if (!createBy.data.projectId) {
+      throw new BadDataException(
+        "Project ID is required to assign an AI Agent",
+      );
+    }
+
+    // Try to get the default agent for the project (or global fallback)
+    const agent: AIAgent | null = await AIAgentService.getAIAgentForProject(
+      createBy.data.projectId,
+    );
+
+    if (!agent || !agent.id) {
+      throw new BadDataException(
+        "No AI Agent available. Please configure an AI Agent for this project or ensure a global AI Agent is available.",
+      );
+    }
+
+    return agent.id!;
+  }
+
+  @CaptureSpan()
+  private async validateAgentBelongsToProject(
+    createBy: CreateBy<Model>,
+  ): Promise<void> {
+    if (!createBy.data.aiAgentId || !createBy.data.projectId) {
+      return;
+    }
+
+    const agent: AIAgent | null = await AIAgentService.findOneById({
+      id: createBy.data.aiAgentId,
+      select: {
+        _id: true,
+        projectId: true,
+        isGlobalAIAgent: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    if (!agent) {
+      throw new BadDataException("AI Agent not found");
+    }
+
+    // Allow if it's a global agent
+    if (agent.isGlobalAIAgent) {
+      return;
+    }
+
+    // Allow if the agent belongs to the same project
+    if (
+      agent.projectId &&
+      agent.projectId.toString() === createBy.data.projectId.toString()
+    ) {
+      return;
+    }
+
+    // Reject if the agent belongs to a different project
+    throw new BadDataException(
+      "The specified AI Agent does not belong to this project. Please use an AI Agent from your project or a global AI Agent.",
+    );
+  }
+}
+
+export default new Service();

package/Server/Services/AIAgentTaskTelemetryExceptionService.ts

@@ -0,0 +1,39 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/AIAgentTaskTelemetryException";
+import ObjectID from "../../Types/ObjectID";
+import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+
+export interface LinkTaskToTelemetryExceptionParams {
+  projectId: ObjectID;
+  aiAgentTaskId: ObjectID;
+  telemetryExceptionId: ObjectID;
+  props: DatabaseCommonInteractionProps;
+}
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+
+  @CaptureSpan()
+  public async linkTaskToTelemetryException(
+    params: LinkTaskToTelemetryExceptionParams,
+  ): Promise<Model> {
+    const { projectId, aiAgentTaskId, telemetryExceptionId, props } = params;
+
+    const taskExceptionLink: Model = new Model();
+    taskExceptionLink.projectId = projectId;
+    taskExceptionLink.aiAgentTaskId = aiAgentTaskId;
+    taskExceptionLink.telemetryExceptionId = telemetryExceptionId;
+
+    return await this.create({
+      data: taskExceptionLink,
+      props: {
+        ...props,
+      },
+    });
+  }
+}
+
+export default new Service();

package/Server/Services/Index.ts

@@ -64,6 +64,11 @@ import OnCallDutyPolicyScheduleService from "./OnCallDutyPolicyScheduleService";
 // On-Call Duty
 import OnCallDutyPolicyService from "./OnCallDutyPolicyService";
 import ProbeService from "./ProbeService";
+import AIAgentService from "./AIAgentService";
+import AIAgentOwnerUserService from "./AIAgentOwnerUserService";
+import AIAgentOwnerTeamService from "./AIAgentOwnerTeamService";
+import AIAgentTaskLogService from "./AIAgentTaskLogService";
+import AIAgentTaskPullRequestService from "./AIAgentTaskPullRequestService";
 import ProjectCallSMSConfigService from "./ProjectCallSMSConfigService";
 import ProjectService from "./ProjectService";
 // Project SMTP Config.
@@ -241,6 +246,11 @@ const services: Array<BaseService> = [
   ProjectService,
   ProjectSmtpConfigService,
   ProbeService,
+  AIAgentService,
+  AIAgentOwnerUserService,
+  AIAgentOwnerTeamService,
+  AIAgentTaskLogService,
+  AIAgentTaskPullRequestService,
   ProjectSsoService,
 
   ScheduledMaintenanceCustomFieldService,

package/Server/Services/TelemetryExceptionService.ts

@@ -1,10 +1,172 @@
 import DatabaseService from "./DatabaseService";
 import Model from "../../Models/DatabaseModels/TelemetryException";
+import AIAgentTask from "../../Models/DatabaseModels/AIAgentTask";
+import AIAgentTaskTelemetryException from "../../Models/DatabaseModels/AIAgentTaskTelemetryException";
+import ObjectID from "../../Types/ObjectID";
+import BadDataException from "../../Types/Exception/BadDataException";
+import AIAgentTaskType from "../../Types/AI/AIAgentTaskType";
+import AIAgentTaskStatus from "../../Types/AI/AIAgentTaskStatus";
+import { FixExceptionTaskMetadata } from "../../Types/AI/AIAgentTaskMetadata";
+import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
+import AIAgentTaskService from "./AIAgentTaskService";
+import AIAgentTaskTelemetryExceptionService from "./AIAgentTaskTelemetryExceptionService";
+import QueryHelper from "../Types/Database/QueryHelper";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+
+export interface CreateAIAgentTaskForExceptionParams {
+  telemetryExceptionId: ObjectID;
+  props: DatabaseCommonInteractionProps;
+}
 
 export class Service extends DatabaseService<Model> {
   public constructor() {
     super(Model);
   }
+
+  @CaptureSpan()
+  public async createAIAgentTaskForException(
+    params: CreateAIAgentTaskForExceptionParams,
+  ): Promise<AIAgentTask> {
+    const { telemetryExceptionId, props } = params;
+
+    // Get the telemetry exception
+    const telemetryException: Model | null = await this.findOneById({
+      id: telemetryExceptionId,
+      select: {
+        _id: true,
+        projectId: true,
+        message: true,
+        stackTrace: true,
+        telemetryServiceId: true,
+        exceptionType: true,
+      },
+      props,
+    });
+
+    if (!telemetryException || !telemetryException.projectId) {
+      throw new BadDataException("Telemetry Exception not found");
+    }
+
+    // Check if an active AI agent task already exists for this exception
+    await this.validateNoActiveTaskExists(telemetryExceptionId);
+
+    // Create the AI Agent Task
+    const createdTask: AIAgentTask = await this.createFixExceptionTask({
+      telemetryException,
+      telemetryExceptionId,
+      props,
+    });
+
+    // Link the task to the telemetry exception
+    await AIAgentTaskTelemetryExceptionService.linkTaskToTelemetryException({
+      projectId: telemetryException.projectId,
+      aiAgentTaskId: createdTask.id!,
+      telemetryExceptionId,
+      props,
+    });
+
+    return createdTask;
+  }
+
+  @CaptureSpan()
+  private async validateNoActiveTaskExists(
+    telemetryExceptionId: ObjectID,
+  ): Promise<void> {
+    const existingTaskLink: AIAgentTaskTelemetryException | null =
+      await AIAgentTaskTelemetryExceptionService.findOneBy({
+        query: {
+          telemetryExceptionId: telemetryExceptionId,
+          aiAgentTask: {
+            status: QueryHelper.notIn([
+              AIAgentTaskStatus.Completed,
+              AIAgentTaskStatus.Error,
+            ]),
+          },
+        },
+        select: {
+          _id: true,
+          aiAgentTaskId: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+    if (existingTaskLink) {
+      throw new BadDataException(
+        "An AI agent task is already in progress for this exception. Please wait for it to complete before creating a new one.",
+      );
+    }
+  }
+
+  @CaptureSpan()
+  private async createFixExceptionTask(params: {
+    telemetryException: Model;
+    telemetryExceptionId: ObjectID;
+    props: DatabaseCommonInteractionProps;
+  }): Promise<AIAgentTask> {
+    const { telemetryException, telemetryExceptionId, props } = params;
+
+    const aiAgentTask: AIAgentTask = new AIAgentTask();
+    aiAgentTask.projectId = telemetryException.projectId!;
+    aiAgentTask.taskType = AIAgentTaskType.FixException;
+    aiAgentTask.status = AIAgentTaskStatus.Scheduled;
+
+    // Set name and description based on exception details
+    const exceptionType: string =
+      telemetryException.exceptionType || "Exception";
+    const exceptionMessage: string =
+      telemetryException.message || "No message available";
+
+    aiAgentTask.name = `Fix ${exceptionType}: ${exceptionMessage}`;
+    aiAgentTask.description = `AI Agent task to fix the exception: ${exceptionMessage}`;
+
+    // Build metadata
+    aiAgentTask.metadata = this.buildFixExceptionMetadata({
+      telemetryException,
+      telemetryExceptionId,
+    });
+
+    const createdTask: AIAgentTask = await AIAgentTaskService.create({
+      data: aiAgentTask,
+      props: {
+        ...props,
+      },
+    });
+
+    if (!createdTask.id) {
+      throw new BadDataException("Failed to create AI Agent Task");
+    }
+
+    return createdTask;
+  }
+
+  private buildFixExceptionMetadata(params: {
+    telemetryException: Model;
+    telemetryExceptionId: ObjectID;
+  }): FixExceptionTaskMetadata {
+    const { telemetryException, telemetryExceptionId } = params;
+
+    const metadata: FixExceptionTaskMetadata = {
+      taskType: AIAgentTaskType.FixException,
+      exceptionId: telemetryExceptionId.toString(),
+    };
+
+    if (telemetryException.stackTrace) {
+      metadata.stackTrace = telemetryException.stackTrace;
+    }
+
+    if (telemetryException.message) {
+      metadata.errorMessage = telemetryException.message;
+    }
+
+    if (telemetryException.telemetryServiceId) {
+      metadata.telemetryServiceId =
+        telemetryException.telemetryServiceId.toString();
+    }
+
+    return metadata;
+  }
 }
 
 export default new Service();

package/Server/Types/Workflow/Components/Index.ts

@@ -28,6 +28,7 @@ import ManualTrigger from "./Manual";
 import MicrosoftTeamsSendMessageToChannel from "./MicrosoftTeams/SendMessageToChannel";
 import Schedule from "./Schedule";
 import SlackSendMessageToChannel from "./Slack/SendMessageToChannel";
+import TelegramSendMessageToChat from "./Telegram/SendMessageToChat";
 import WebhookTrigger from "./Webhook";
 import BaseModel from "../../../../Models/DatabaseModels/DatabaseBaseModel/DatabaseBaseModel";
 import Dictionary from "../../../../Types/Dictionary";
@@ -41,6 +42,7 @@ const Components: Dictionary<ComponentCode> = {
   [ComponentID.DiscordSendMessageToChannel]: new DiscordSendMessageToChannel(),
   [ComponentID.MicrosoftTeamsSendMessageToChannel]:
     new MicrosoftTeamsSendMessageToChannel(),
+  [ComponentID.TelegramSendMessageToChat]: new TelegramSendMessageToChat(),
   [ComponentID.Log]: new Log(),
   [ComponentID.Schedule]: new Schedule(),
   [ComponentID.JavaScriptCode]: new JavaScriptCode(),

package/Server/Types/Workflow/Components/Telegram/SendMessageToChat.ts

@@ -0,0 +1,146 @@
+import ComponentCode, { RunOptions, RunReturnType } from "../../ComponentCode";
+import HTTPErrorResponse from "../../../../../Types/API/HTTPErrorResponse";
+import HTTPResponse from "../../../../../Types/API/HTTPResponse";
+import URL from "../../../../../Types/API/URL";
+import APIException from "../../../../../Types/Exception/ApiException";
+import BadDataException from "../../../../../Types/Exception/BadDataException";
+import { JSONObject } from "../../../../../Types/JSON";
+import ComponentMetadata, {
+  Port,
+} from "../../../../../Types/Workflow/Component";
+import ComponentID from "../../../../../Types/Workflow/ComponentID";
+import TelegramComponents from "../../../../../Types/Workflow/Components/Telegram";
+import API from "../../../../../Utils/API";
+import CaptureSpan from "../../../../Utils/Telemetry/CaptureSpan";
+
+export default class SendMessageToChat extends ComponentCode {
+  public constructor() {
+    super();
+
+    const Component: ComponentMetadata | undefined = TelegramComponents.find(
+      (i: ComponentMetadata) => {
+        return i.id === ComponentID.TelegramSendMessageToChat;
+      },
+    );
+
+    if (!Component) {
+      throw new BadDataException("Component not found.");
+    }
+
+    this.setMetadata(Component);
+  }
+
+  @CaptureSpan()
+  public override async run(
+    args: JSONObject,
+    options: RunOptions,
+  ): Promise<RunReturnType> {
+    const successPort: Port | undefined = this.getMetadata().outPorts.find(
+      (p: Port) => {
+        return p.id === "success";
+      },
+    );
+
+    if (!successPort) {
+      throw options.onError(new BadDataException("Success port not found"));
+    }
+
+    const errorPort: Port | undefined = this.getMetadata().outPorts.find(
+      (p: Port) => {
+        return p.id === "error";
+      },
+    );
+
+    if (!errorPort) {
+      throw options.onError(new BadDataException("Error port not found"));
+    }
+
+    if (!args["bot-token"]) {
+      throw options.onError(
+        new BadDataException("Telegram Bot Token not found"),
+      );
+    }
+
+    if (!args["chat-id"]) {
+      throw options.onError(new BadDataException("Telegram Chat ID not found"));
+    }
+
+    if (!args["text"]) {
+      throw options.onError(new BadDataException("Telegram message not found"));
+    }
+
+    const botToken: string = args["bot-token"]?.toString() as string;
+    const chatId: string = args["chat-id"]?.toString() as string;
+    const text: string = args["text"]?.toString() as string;
+
+    const telegramApiUrl: URL = URL.fromString(
+      `https://api.telegram.org/bot${botToken}/sendMessage`,
+    );
+
+    let apiResult: HTTPResponse<JSONObject> | HTTPErrorResponse | null = null;
+
+    try {
+      // https://core.telegram.org/bots/api#sendmessage
+      apiResult = await API.post({
+        url: telegramApiUrl,
+        data: {
+          chat_id: chatId,
+          text: text,
+        },
+      });
+
+      const helpMessage: string =
+        " Note: For usernames, the user must have started a conversation with the bot first. For groups/channels, the bot must be added as a member or admin.";
+
+      if (apiResult instanceof HTTPErrorResponse) {
+        // Telegram returns errors in 'description' field
+        const telegramError: string =
+          (apiResult.data?.["description"] as string) ||
+          apiResult.message ||
+          "Server Error.";
+        return Promise.resolve({
+          returnValues: {
+            error: telegramError + helpMessage,
+          },
+          executePort: errorPort,
+        });
+      }
+
+      // Check if Telegram returned ok: false (some errors return 200 OK)
+      if (apiResult.data && apiResult.data["ok"] === false) {
+        const telegramError: string =
+          (apiResult.data["description"] as string) || "Telegram API Error.";
+        return Promise.resolve({
+          returnValues: {
+            error: telegramError + helpMessage,
+          },
+          executePort: errorPort,
+        });
+      }
+
+      return Promise.resolve({
+        returnValues: {},
+        executePort: successPort,
+      });
+    } catch (err) {
+      const helpMessage: string =
+        " Note: For usernames, the user must have started a conversation with the bot first. For groups/channels, the bot must be added as a member or admin.";
+
+      if (err instanceof HTTPErrorResponse) {
+        // Telegram returns errors in 'description' field
+        const telegramError: string =
+          (err.data?.["description"] as string) ||
+          err.message ||
+          "Server Error.";
+        return Promise.resolve({
+          returnValues: {
+            error: telegramError + helpMessage,
+          },
+          executePort: errorPort,
+        });
+      }
+
+      throw options.onError(new APIException("Something wrong happened."));
+    }
+  }
+}