@oneuptime/common 9.2.27 → 9.3.0

package/Models/DatabaseModels/AIAgentTaskTelemetryException.ts

@@ -0,0 +1,388 @@
+import Project from "./Project";
+import User from "./User";
+import BaseModel from "./DatabaseBaseModel/DatabaseBaseModel";
+import Route from "../../Types/API/Route";
+import { PlanType } from "../../Types/Billing/SubscriptionPlan";
+import ColumnAccessControl from "../../Types/Database/AccessControl/ColumnAccessControl";
+import TableAccessControl from "../../Types/Database/AccessControl/TableAccessControl";
+import TableBillingAccessControl from "../../Types/Database/AccessControl/TableBillingAccessControl";
+import ColumnType from "../../Types/Database/ColumnType";
+import CrudApiEndpoint from "../../Types/Database/CrudApiEndpoint";
+import EnableDocumentation from "../../Types/Database/EnableDocumentation";
+import TableColumn from "../../Types/Database/TableColumn";
+import TableColumnType from "../../Types/Database/TableColumnType";
+import TableMetadata from "../../Types/Database/TableMetadata";
+import TenantColumn from "../../Types/Database/TenantColumn";
+import IconProp from "../../Types/Icon/IconProp";
+import ObjectID from "../../Types/ObjectID";
+import Permission from "../../Types/Permission";
+import { Column, Entity, Index, JoinColumn, ManyToOne } from "typeorm";
+import AIAgentTask from "./AIAgentTask";
+import TelemetryException from "./TelemetryException";
+
+@EnableDocumentation()
+@TenantColumn("projectId")
+@TableBillingAccessControl({
+  create: PlanType.Growth,
+  read: PlanType.Growth,
+  update: PlanType.Growth,
+  delete: PlanType.Growth,
+})
+@TableAccessControl({
+  create: [
+    Permission.ProjectOwner,
+    Permission.ProjectAdmin,
+    Permission.ProjectMember,
+    Permission.CreateProjectAIAgentTaskTelemetryException,
+  ],
+  read: [
+    Permission.ProjectOwner,
+    Permission.ProjectAdmin,
+    Permission.ProjectMember,
+    Permission.ReadProjectAIAgentTaskTelemetryException,
+  ],
+  delete: [
+    Permission.ProjectOwner,
+    Permission.ProjectAdmin,
+    Permission.ProjectMember,
+    Permission.DeleteProjectAIAgentTaskTelemetryException,
+  ],
+  update: [
+    Permission.ProjectOwner,
+    Permission.ProjectAdmin,
+    Permission.ProjectMember,
+    Permission.EditProjectAIAgentTaskTelemetryException,
+  ],
+})
+@CrudApiEndpoint(new Route("/ai-agent-task-telemetry-exception"))
+@TableMetadata({
+  tableName: "AIAgentTaskTelemetryException",
+  singularName: "AI Agent Task Exception",
+  pluralName: "AI Agent Task Exceptions",
+  icon: IconProp.Bolt,
+  tableDescription:
+    "Link between AI Agent Tasks and Telemetry Exceptions. This table tracks which exceptions are being addressed by which AI agent tasks.",
+})
+@Entity({
+  name: "AIAgentTaskTelemetryException",
+})
+export default class AIAgentTaskTelemetryException extends BaseModel {
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.CreateProjectAIAgentTaskTelemetryException,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadProjectAIAgentTaskTelemetryException,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "projectId",
+    type: TableColumnType.Entity,
+    modelType: Project,
+    title: "Project",
+    description: "Relation to Project Resource in which this object belongs",
+  })
+  @ManyToOne(
+    () => {
+      return Project;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "CASCADE",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "projectId" })
+  public project?: Project = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.CreateProjectAIAgentTaskTelemetryException,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadProjectAIAgentTaskTelemetryException,
+    ],
+    update: [],
+  })
+  @Index()
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    required: true,
+    canReadOnRelationQuery: true,
+    title: "Project ID",
+    description: "ID of your OneUptime Project in which this object belongs",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: false,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public projectId?: ObjectID = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.CreateProjectAIAgentTaskTelemetryException,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadProjectAIAgentTaskTelemetryException,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "aiAgentTaskId",
+    type: TableColumnType.Entity,
+    modelType: AIAgentTask,
+    title: "AI Agent Task",
+    description: "Relation to AI Agent Task that is addressing this exception",
+  })
+  @ManyToOne(
+    () => {
+      return AIAgentTask;
+    },
+    {
+      eager: false,
+      nullable: false,
+      onDelete: "CASCADE",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "aiAgentTaskId" })
+  public aiAgentTask?: AIAgentTask = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.CreateProjectAIAgentTaskTelemetryException,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadProjectAIAgentTaskTelemetryException,
+    ],
+    update: [],
+  })
+  @Index()
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    required: true,
+    canReadOnRelationQuery: true,
+    title: "AI Agent Task ID",
+    description: "ID of the AI Agent Task that is addressing this exception",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: false,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public aiAgentTaskId?: ObjectID = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.CreateProjectAIAgentTaskTelemetryException,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadProjectAIAgentTaskTelemetryException,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "telemetryExceptionId",
+    type: TableColumnType.Entity,
+    modelType: TelemetryException,
+    title: "Telemetry Exception",
+    description: "Relation to Telemetry Exception being addressed by this task",
+  })
+  @ManyToOne(
+    () => {
+      return TelemetryException;
+    },
+    {
+      eager: false,
+      nullable: false,
+      onDelete: "CASCADE",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "telemetryExceptionId" })
+  public telemetryException?: TelemetryException = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.CreateProjectAIAgentTaskTelemetryException,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadProjectAIAgentTaskTelemetryException,
+    ],
+    update: [],
+  })
+  @Index()
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    required: true,
+    canReadOnRelationQuery: true,
+    title: "Telemetry Exception ID",
+    description: "ID of the Telemetry Exception being addressed by this task",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: false,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public telemetryExceptionId?: ObjectID = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.CreateProjectAIAgentTaskTelemetryException,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadProjectAIAgentTaskTelemetryException,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "createdByUserId",
+    type: TableColumnType.Entity,
+    modelType: User,
+    title: "Created by User",
+    description:
+      "Relation to User who created this object (if this object was created by a User)",
+  })
+  @ManyToOne(
+    () => {
+      return User;
+    },
+    {
+      eager: false,
+      nullable: true,
+      onDelete: "SET NULL",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "createdByUserId" })
+  public createdByUser?: User = undefined;
+
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.CreateProjectAIAgentTaskTelemetryException,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadProjectAIAgentTaskTelemetryException,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    title: "Created by User ID",
+    description:
+      "User ID who created this object (if this object was created by a User)",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public createdByUserId?: ObjectID = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadProjectAIAgentTaskTelemetryException,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    manyToOneRelationColumn: "deletedByUserId",
+    type: TableColumnType.Entity,
+    title: "Deleted by User",
+    modelType: User,
+    description:
+      "Relation to User who deleted this object (if this object was deleted by a User)",
+  })
+  @ManyToOne(
+    () => {
+      return User;
+    },
+    {
+      cascade: false,
+      eager: false,
+      nullable: true,
+      onDelete: "SET NULL",
+      orphanedRowAction: "nullify",
+    },
+  )
+  @JoinColumn({ name: "deletedByUserId" })
+  public deletedByUser?: User = undefined;
+
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadProjectAIAgentTaskTelemetryException,
+    ],
+    update: [],
+  })
+  @TableColumn({
+    type: TableColumnType.ObjectID,
+    title: "Deleted by User ID",
+    description:
+      "User ID who deleted this object (if this object was deleted by a User)",
+  })
+  @Column({
+    type: ColumnType.ObjectID,
+    nullable: true,
+    transformer: ObjectID.getDatabaseTransformer(),
+  })
+  public deletedByUserId?: ObjectID = undefined;
+}

package/Models/DatabaseModels/Index.ts

@@ -72,6 +72,13 @@ import OnCallDutyPolicyTimeLog from "./OnCallDutyPolicyTimeLog";
 import Probe from "./Probe";
 import ProbeOwnerTeam from "./ProbeOwnerTeam";
 import ProbeOwnerUser from "./ProbeOwnerUser";
+import AIAgent from "./AIAgent";
+import AIAgentOwnerTeam from "./AIAgentOwnerTeam";
+import AIAgentOwnerUser from "./AIAgentOwnerUser";
+import AIAgentTask from "./AIAgentTask";
+import AIAgentTaskLog from "./AIAgentTaskLog";
+import AIAgentTaskPullRequest from "./AIAgentTaskPullRequest";
+import AIAgentTaskTelemetryException from "./AIAgentTaskTelemetryException";
 import LlmProvider from "./LlmProvider";
 import LlmLog from "./LlmLog";
 import Project from "./Project";
@@ -379,6 +386,14 @@ const AllModelTypes: Array<{
   ProbeOwnerTeam,
   ProbeOwnerUser,
 
+  AIAgent,
+  AIAgentOwnerTeam,
+  AIAgentOwnerUser,
+  AIAgentTask,
+  AIAgentTaskLog,
+  AIAgentTaskPullRequest,
+  AIAgentTaskTelemetryException,
+
   LlmProvider,
   LlmLog,
 

package/Models/DatabaseModels/Monitor.ts

@@ -1029,6 +1029,39 @@ export default class Monitor extends BaseModel {
   })
   public isNoProbeEnabledOnThisMonitor?: boolean = undefined;
 
+  @ColumnAccessControl({
+    create: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.CreateProjectMonitor,
+    ],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadProjectMonitor,
+    ],
+    update: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.EditProjectMonitor,
+    ],
+  })
+  @TableColumn({
+    type: TableColumnType.Number,
+    required: false,
+    title: "Minimum Probe Agreement",
+    description:
+      "Minimum number of probes that must agree on a status before the monitor status changes. If null, all enabled and connected probes must agree.",
+  })
+  @Column({
+    type: ColumnType.Number,
+    nullable: true,
+  })
+  public minimumProbeAgreement?: number = undefined;
+
   @ColumnAccessControl({
     create: [],
     read: [],

package/Models/DatabaseModels/Project.ts

@@ -1603,4 +1603,29 @@ export default class Project extends TenantModel {
     default: false,
   })
   public doNotAddGlobalProbesByDefaultOnNewMonitors?: boolean = undefined;
+
+  // GitHub App Installation ID for this project
+  @ColumnAccessControl({
+    create: [],
+    read: [
+      Permission.ProjectOwner,
+      Permission.ProjectAdmin,
+      Permission.ProjectMember,
+      Permission.ReadProject,
+    ],
+    update: [Permission.ProjectOwner, Permission.ProjectAdmin],
+  })
+  @TableColumn({
+    required: false,
+    type: TableColumnType.LongText,
+    title: "GitHub App Installation ID",
+    description:
+      "The GitHub App installation ID for this project. This is set when the GitHub App is installed on the organization.",
+  })
+  @Column({
+    type: ColumnType.LongText,
+    nullable: true,
+    unique: false,
+  })
+  public gitHubAppInstallationId?: string = undefined;
 }

package/Models/DatabaseModels/TelemetryException.ts

@@ -44,7 +44,7 @@ import TelemetryService from "./TelemetryService";
     Permission.EditTelemetryException,
   ],
 })
-@CrudApiEndpoint(new Route("/telemetry-exception-status"))
+@CrudApiEndpoint(new Route("/telemetry-exception"))
 @TableMetadata({
   tableName: "TelemetryException",
   singularName: "Exception",

package/Server/API/AIAgentAPI.ts

@@ -0,0 +1,200 @@
+import UserMiddleware from "../Middleware/UserAuthorization";
+import ClusterKeyAuthorization from "../Middleware/ClusterKeyAuthorization";
+import AIAgentService, {
+  Service as AIAgentServiceType,
+} from "../Services/AIAgentService";
+import {
+  ExpressRequest,
+  ExpressResponse,
+  NextFunction,
+} from "../Utils/Express";
+import Response from "../Utils/Response";
+import BaseAPI from "./BaseAPI";
+import LIMIT_MAX from "../../Types/Database/LimitMax";
+import PositiveNumber from "../../Types/PositiveNumber";
+import AIAgent, {
+  AIAgentConnectionStatus,
+} 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 Version from "../../Types/Version";
+
+export default class AIAgentAPI extends BaseAPI<AIAgent, AIAgentServiceType> {
+  public constructor() {
+    super(AIAgent, AIAgentService);
+
+    // Register Global AI Agent. Custom AI Agent can be registered via dashboard.
+    this.router.post(
+      `${new this.entityType().getCrudApiPath()?.toString()}/register`,
+      ClusterKeyAuthorization.isAuthorizedServiceMiddleware,
+      async (
+        req: ExpressRequest,
+        res: ExpressResponse,
+        next: NextFunction,
+      ): Promise<void> => {
+        try {
+          const data: JSONObject = req.body;
+
+          if (!data["aiAgentKey"]) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException("aiAgentKey is missing"),
+            );
+          }
+
+          const aiAgentKey: string = data["aiAgentKey"] as string;
+
+          const aiAgent: AIAgent | null = await AIAgentService.findOneBy({
+            query: {
+              key: aiAgentKey,
+              isGlobalAIAgent: true,
+            },
+            select: {
+              _id: true,
+            },
+            props: {
+              isRoot: true,
+            },
+          });
+
+          const defaultDescription: string =
+            "AI-powered agent that analyzes and resolves code issues, triages incidents and alerts, and helps automate operational workflows.";
+
+          if (aiAgent) {
+            await AIAgentService.updateOneById({
+              id: aiAgent.id!,
+              data: {
+                name: (data["aiAgentName"] as string) || "Global AI Agent",
+                description:
+                  (data["aiAgentDescription"] as string) || defaultDescription,
+                lastAlive: OneUptimeDate.getCurrentDate(),
+                connectionStatus: AIAgentConnectionStatus.Connected,
+              },
+              props: {
+                isRoot: true,
+              },
+            });
+
+            return Response.sendJsonObjectResponse(req, res, {
+              _id: aiAgent._id?.toString(),
+              message: "AI Agent already registered",
+            });
+          }
+
+          let newAIAgent: AIAgent = new AIAgent();
+          newAIAgent.isGlobalAIAgent = true;
+          newAIAgent.key = aiAgentKey;
+          newAIAgent.name =
+            (data["aiAgentName"] as string) || "Global AI Agent";
+          newAIAgent.description =
+            (data["aiAgentDescription"] as string) || defaultDescription;
+          newAIAgent.lastAlive = OneUptimeDate.getCurrentDate();
+          newAIAgent.connectionStatus = AIAgentConnectionStatus.Connected;
+          newAIAgent.aiAgentVersion = new Version("1.0.0");
+
+          newAIAgent = await AIAgentService.create({
+            data: newAIAgent,
+            props: {
+              isRoot: true,
+            },
+          });
+
+          return Response.sendJsonObjectResponse(req, res, {
+            _id: newAIAgent._id?.toString(),
+            message: "AI Agent registered successfully",
+          });
+        } catch (err) {
+          return next(err);
+        }
+      },
+    );
+
+    // Alive endpoint for AI Agent heartbeat
+    this.router.post(
+      `${new this.entityType().getCrudApiPath()?.toString()}/alive`,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          const data: JSONObject = req.body;
+
+          if (!data["aiAgentId"] || !data["aiAgentKey"]) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException("aiAgentId or aiAgentKey is missing"),
+            );
+          }
+
+          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,
+            },
+          });
+
+          if (!aiAgent) {
+            return Response.sendErrorResponse(
+              req,
+              res,
+              new BadDataException("Invalid AI Agent ID or AI Agent Key"),
+            );
+          }
+
+          // Update last alive
+          await AIAgentService.updateLastAlive(aiAgentId);
+
+          return Response.sendEmptySuccessResponse(req, res);
+        } catch (err) {
+          next(err);
+        }
+      },
+    );
+
+    this.router.post(
+      `${new this.entityType().getCrudApiPath()?.toString()}/global-ai-agents`,
+      UserMiddleware.getUserMiddleware,
+      async (req: ExpressRequest, res: ExpressResponse, next: NextFunction) => {
+        try {
+          const aiAgents: Array<AIAgent> = await AIAgentService.findBy({
+            query: {
+              isGlobalAIAgent: true,
+            },
+            select: {
+              name: true,
+              description: true,
+              lastAlive: true,
+              iconFileId: true,
+              connectionStatus: true,
+            },
+            props: {
+              isRoot: true,
+            },
+            skip: 0,
+            limit: LIMIT_MAX,
+          });
+
+          return Response.sendEntityArrayResponse(
+            req,
+            res,
+            aiAgents,
+            new PositiveNumber(aiAgents.length),
+            AIAgent,
+          );
+        } catch (err) {
+          next(err);
+        }
+      },
+    );
+  }
+}