@oneuptime/common 9.2.27 → 9.3.1

package/Server/API/AIAgentTaskAPI.ts

@@ -0,0 +1,286 @@
+import AIAgentService from "../Services/AIAgentService";
+import AIAgentTaskService, {
+  Service as AIAgentTaskServiceType,
+} from "../Services/AIAgentTaskService";
+import {
+  ExpressRequest,
+  ExpressResponse,
+  NextFunction,
+} from "../Utils/Express";
+import Response from "../Utils/Response";
+import BaseAPI from "./BaseAPI";
+import AIAgentTask from "../../Models/DatabaseModels/AIAgentTask";
+import AIAgent from "../../Models/DatabaseModels/AIAgent";
+import BadDataException from "../../Types/Exception/BadDataException";
+import { JSONObject } from "../../Types/JSON";
+import ObjectID from "../../Types/ObjectID";
+import OneUptimeDate from "../../Types/Date";
+import AIAgentTaskStatus from "../../Types/AI/AIAgentTaskStatus";
+import SortOrder from "../../Types/BaseDatabase/SortOrder";
+import PositiveNumber from "../../Types/PositiveNumber";
+
+export default class AIAgentTaskAPI extends BaseAPI<
+  AIAgentTask,
+  AIAgentTaskServiceType
+> {
+  public constructor() {
+    super(AIAgentTask, AIAgentTaskService);
+
+    /*
+     * Get the next pending (scheduled) task for processing
+     * Validates aiAgentId and aiAgentKey before returning task
+     */
+    this.router.post(
+      `${new this.entityType().getCrudApiPath()?.toString()}/get-pending-task`,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          const data: JSONObject = req.body;
+
+          /* Validate AI Agent credentials */
+          const aiAgent: AIAgent | null = await this.validateAIAgent(data);
+
+          if (!aiAgent) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException("Invalid AI Agent ID or AI Agent Key"),
+            );
+          }
+
+          /* Fetch one scheduled task, sorted by createdAt (oldest first) */
+          const task: AIAgentTask | null = await AIAgentTaskService.findOneBy({
+            query: {
+              status: AIAgentTaskStatus.Scheduled,
+            },
+            sort: {
+              createdAt: SortOrder.Ascending,
+            },
+            select: {
+              _id: true,
+              projectId: true,
+              taskType: true,
+              metadata: true,
+              createdAt: true,
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+
+          if (!task) {
+            return Response.sendJsonObjectResponse(req, res, {
+              task: null,
+              message: "No pending tasks available",
+            });
+          }
+
+          return Response.sendJsonObjectResponse(req, res, {
+            task: {
+              _id: task._id?.toString(),
+              projectId: task.projectId?.toString(),
+              taskType: task.taskType,
+              metadata: task.metadata as JSONObject | undefined,
+              createdAt: task.createdAt,
+            },
+            message: "Task fetched successfully",
+          });
+        } catch (err) {
+          next(err);
+        }
+      },
+    );
+
+    /*
+     * Get the count of pending (scheduled) tasks for KEDA autoscaling
+     * Validates aiAgentId and aiAgentKey before returning count
+     */
+    this.router.post(
+      `${new this.entityType().getCrudApiPath()?.toString()}/get-pending-task-count`,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          const data: JSONObject = req.body;
+
+          /* Validate AI Agent credentials */
+          const aiAgent: AIAgent | null = await this.validateAIAgent(data);
+
+          if (!aiAgent) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException("Invalid AI Agent ID or AI Agent Key"),
+            );
+          }
+
+          /* Count scheduled tasks */
+          const count: PositiveNumber = await AIAgentTaskService.countBy({
+            query: {
+              status: AIAgentTaskStatus.Scheduled,
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+
+          return Response.sendJsonObjectResponse(req, res, {
+            count: count,
+            message: "Pending task count fetched successfully",
+          });
+        } catch (err) {
+          next(err);
+        }
+      },
+    );
+
+    /*
+     * Update task status (InProgress, Completed, Error)
+     * Validates aiAgentId and aiAgentKey before updating
+     */
+    this.router.post(
+      `${new this.entityType().getCrudApiPath()?.toString()}/update-task-status`,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          const data: JSONObject = req.body;
+
+          /* Validate AI Agent credentials */
+          const aiAgent: AIAgent | null = await this.validateAIAgent(data);
+
+          if (!aiAgent) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException("Invalid AI Agent ID or AI Agent Key"),
+            );
+          }
+
+          /* Validate required fields */
+          if (!data["taskId"]) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException("taskId is required"),
+            );
+          }
+
+          if (!data["status"]) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException("status is required"),
+            );
+          }
+
+          const taskId: ObjectID = new ObjectID(data["taskId"] as string);
+          const status: AIAgentTaskStatus = data["status"] as AIAgentTaskStatus;
+          const statusMessage: string | undefined = data["statusMessage"] as
+            | string
+            | undefined;
+
+          /* Validate status value */
+          const validStatuses: Array<AIAgentTaskStatus> = [
+            AIAgentTaskStatus.InProgress,
+            AIAgentTaskStatus.Completed,
+            AIAgentTaskStatus.Error,
+          ];
+
+          if (!validStatuses.includes(status)) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException(
+                `Invalid status. Must be one of: ${validStatuses.join(", ")}`,
+              ),
+            );
+          }
+
+          /* Check if task exists */
+          const existingTask: AIAgentTask | null =
+            await AIAgentTaskService.findOneById({
+              id: taskId,
+              select: {
+                _id: true,
+                status: true,
+              },
+              props: {
+                isRoot: true,
+              },
+            });
+
+          if (!existingTask) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException("Task not found"),
+            );
+          }
+
+          /* Update the task based on status */
+          if (status === AIAgentTaskStatus.InProgress) {
+            await AIAgentTaskService.updateOneById({
+              id: taskId,
+              data: {
+                status: status,
+                ...(aiAgent.id && { aiAgentId: aiAgent.id }),
+                startedAt: OneUptimeDate.getCurrentDate(),
+                ...(statusMessage && { statusMessage: statusMessage }),
+              },
+              props: {
+                isRoot: true,
+              },
+            });
+          } else if (
+            status === AIAgentTaskStatus.Completed ||
+            status === AIAgentTaskStatus.Error
+          ) {
+            await AIAgentTaskService.updateOneById({
+              id: taskId,
+              data: {
+                status: status,
+                completedAt: OneUptimeDate.getCurrentDate(),
+                ...(statusMessage && { statusMessage: statusMessage }),
+              },
+              props: {
+                isRoot: true,
+              },
+            });
+          }
+
+          return Response.sendJsonObjectResponse(req, res, {
+            taskId: taskId.toString(),
+            status: status,
+            message: "Task status updated successfully",
+          });
+        } catch (err) {
+          next(err);
+        }
+      },
+    );
+  }
+
+  /*
+   * Validate AI Agent credentials from request body
+   * Returns AIAgent if valid, null otherwise
+   */
+  private async validateAIAgent(data: JSONObject): Promise<AIAgent | null> {
+    if (!data["aiAgentId"] || !data["aiAgentKey"]) {
+      return null;
+    }
+
+    const aiAgentId: ObjectID = new ObjectID(data["aiAgentId"] as string);
+    const aiAgentKey: string = data["aiAgentKey"] as string;
+
+    const aiAgent: AIAgent | null = await AIAgentService.findOneBy({
+      query: {
+        _id: aiAgentId.toString(),
+        key: aiAgentKey,
+      },
+      select: {
+        _id: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    return aiAgent;
+  }
+}

package/Server/API/AIAgentTaskLogAPI.ts

@@ -0,0 +1,165 @@
+import AIAgentTaskLogService, {
+  Service as AIAgentTaskLogServiceType,
+} from "../Services/AIAgentTaskLogService";
+import AIAgentService from "../Services/AIAgentService";
+import AIAgentTaskService from "../Services/AIAgentTaskService";
+import {
+  ExpressRequest,
+  ExpressResponse,
+  NextFunction,
+} from "../Utils/Express";
+import Response from "../Utils/Response";
+import BaseAPI from "./BaseAPI";
+import AIAgentTaskLog from "../../Models/DatabaseModels/AIAgentTaskLog";
+import AIAgent from "../../Models/DatabaseModels/AIAgent";
+import AIAgentTask from "../../Models/DatabaseModels/AIAgentTask";
+import BadDataException from "../../Types/Exception/BadDataException";
+import { JSONObject } from "../../Types/JSON";
+import ObjectID from "../../Types/ObjectID";
+import LogSeverity from "../../Types/Log/LogSeverity";
+
+export default class AIAgentTaskLogAPI extends BaseAPI<
+  AIAgentTaskLog,
+  AIAgentTaskLogServiceType
+> {
+  public constructor() {
+    super(AIAgentTaskLog, AIAgentTaskLogService);
+
+    /*
+     * Create a log entry for an AI Agent task
+     * Validates aiAgentId and aiAgentKey before creating log
+     */
+    this.router.post(
+      `${new this.entityType().getCrudApiPath()?.toString()}/create-log`,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          const data: JSONObject = req.body;
+
+          /* Validate AI Agent credentials */
+          const aiAgent: AIAgent | null = await this.validateAIAgent(data);
+
+          if (!aiAgent) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException("Invalid AI Agent ID or AI Agent Key"),
+            );
+          }
+
+          /* Validate required fields */
+          if (!data["taskId"]) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException("taskId is required"),
+            );
+          }
+
+          if (!data["severity"]) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException("severity is required"),
+            );
+          }
+
+          if (!data["message"]) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException("message is required"),
+            );
+          }
+
+          const taskId: ObjectID = new ObjectID(data["taskId"] as string);
+          const severity: LogSeverity = data["severity"] as LogSeverity;
+          const message: string = data["message"] as string;
+
+          /* Validate severity value */
+          const validSeverities: Array<LogSeverity> =
+            Object.values(LogSeverity);
+          if (!validSeverities.includes(severity)) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException(
+                `Invalid severity. Must be one of: ${validSeverities.join(", ")}`,
+              ),
+            );
+          }
+
+          /* Check if task exists and get project ID */
+          const existingTask: AIAgentTask | null =
+            await AIAgentTaskService.findOneById({
+              id: taskId,
+              select: {
+                _id: true,
+                projectId: true,
+              },
+              props: {
+                isRoot: true,
+              },
+            });
+
+          if (!existingTask) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException("Task not found"),
+            );
+          }
+
+          /* Create the log entry */
+          const logEntry: AIAgentTaskLog = new AIAgentTaskLog();
+          logEntry.projectId = existingTask.projectId!;
+          logEntry.aiAgentTaskId = taskId;
+          logEntry.aiAgentId = aiAgent.id!;
+          logEntry.severity = severity;
+          logEntry.message = message;
+
+          await AIAgentTaskLogService.create({
+            data: logEntry,
+            props: {
+              isRoot: true,
+            },
+          });
+
+          return Response.sendJsonObjectResponse(req, res, {
+            taskId: taskId.toString(),
+            message: "Log entry created successfully",
+          });
+        } catch (err) {
+          next(err);
+        }
+      },
+    );
+  }
+
+  /*
+   * Validate AI Agent credentials from request body
+   * Returns AIAgent if valid, null otherwise
+   */
+  private async validateAIAgent(data: JSONObject): Promise<AIAgent | null> {
+    if (!data["aiAgentId"] || !data["aiAgentKey"]) {
+      return null;
+    }
+
+    const aiAgentId: ObjectID = new ObjectID(data["aiAgentId"] as string);
+    const aiAgentKey: string = data["aiAgentKey"] as string;
+
+    const aiAgent: AIAgent | null = await AIAgentService.findOneBy({
+      query: {
+        _id: aiAgentId.toString(),
+        key: aiAgentKey,
+      },
+      select: {
+        _id: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    return aiAgent;
+  }
+}

package/Server/API/AIAgentTaskPullRequestAPI.ts

@@ -0,0 +1,14 @@
+import AIAgentTaskPullRequestService, {
+  Service as AIAgentTaskPullRequestServiceType,
+} from "../Services/AIAgentTaskPullRequestService";
+import BaseAPI from "./BaseAPI";
+import AIAgentTaskPullRequest from "../../Models/DatabaseModels/AIAgentTaskPullRequest";
+
+export default class AIAgentTaskPullRequestAPI extends BaseAPI<
+  AIAgentTaskPullRequest,
+  AIAgentTaskPullRequestServiceType
+> {
+  public constructor() {
+    super(AIAgentTaskPullRequest, AIAgentTaskPullRequestService);
+  }
+}

package/Server/API/GitHubAPI.ts

@@ -7,12 +7,13 @@ import Response from "../Utils/Response";
 import BadDataException from "../../Types/Exception/BadDataException";
 import logger from "../Utils/Logger";
 import { JSONObject } from "../../Types/JSON";
-import { DashboardClientUrl, GitHubAppClientId } from "../EnvironmentConfig";
+import { DashboardClientUrl, GitHubAppName } from "../EnvironmentConfig";
 import ObjectID from "../../Types/ObjectID";
 import GitHubUtil, {
   GitHubRepository,
 } from "../Utils/CodeRepository/GitHub/GitHub";
 import CodeRepositoryService from "../Services/CodeRepositoryService";
+import ProjectService from "../Services/ProjectService";
 import CodeRepository from "../../Models/DatabaseModels/CodeRepository";
 import CodeRepositoryType from "../../Types/CodeRepository/CodeRepositoryType";
 import URL from "../../Types/API/URL";
@@ -91,10 +92,21 @@ export default class GitHubAPI {
           }
 
           /*
-           * Store the installation ID - we'll create repositories when user selects them
-           * For now, redirect back to dashboard with installation ID
+           * Store the installation ID in the project
+           * This allows reuse when connecting additional repositories
            */
-          const redirectUrl: string = `${DashboardClientUrl.toString()}/dashboard/${projectId}/code-repository?installation_id=${installationId}`;
+          await ProjectService.updateOneById({
+            id: new ObjectID(projectId),
+            data: {
+              gitHubAppInstallationId: installationId,
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+
+          // Redirect back to dashboard with installation ID
+          const redirectUrl: string = `${DashboardClientUrl.toString()}/${projectId}/code-repository?installation_id=${installationId}`;
 
           return Response.redirect(req, res, URL.fromString(redirectUrl));
         } catch (error) {
@@ -116,12 +128,12 @@ export default class GitHubAPI {
       "/github/auth/install",
       async (req: ExpressRequest, res: ExpressResponse) => {
         try {
-          if (!GitHubAppClientId) {
+          if (!GitHubAppName) {
             return Response.sendErrorResponse(
               req,
               res,
               new BadDataException(
-                "GitHub App is not configured. Please set GITHUB_APP_CLIENT_ID.",
+                "GitHub App is not configured. Please set GITHUB_APP_NAME.",
               ),
             );
           }
@@ -146,7 +158,7 @@ export default class GitHubAPI {
             JSON.stringify({ projectId, userId }),
           ).toString("base64");
 
-          const installUrl: string = `https://github.com/apps/${GitHubAppClientId}/installations/new?state=${state}`;
+          const installUrl: string = `https://github.com/apps/${GitHubAppName}/installations/new?state=${state}`;
 
           return Response.redirect(req, res, URL.fromString(installUrl));
         } catch (error) {
@@ -220,6 +232,8 @@ export default class GitHubAPI {
             body["defaultBranch"]?.toString();
           const repositoryUrl: string | undefined =
             body["repositoryUrl"]?.toString();
+          const description: string | undefined =
+            body["description"]?.toString();
 
           if (!projectId) {
             return Response.sendErrorResponse(
@@ -267,6 +281,10 @@ export default class GitHubAPI {
             codeRepository.repositoryUrl = URL.fromString(repositoryUrl);
           }
 
+          if (description) {
+            codeRepository.description = description;
+          }
+
           const createdRepository: CodeRepository =
             await CodeRepositoryService.create({
               data: codeRepository,