@oneuptime/common 11.5.4 → 11.5.5

package/Server/Services/AIAgentTaskService.ts

@@ -1,240 +0,0 @@
-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";
-import AIAgentTaskStatus from "../../Types/AI/AIAgentTaskStatus";
-
-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 };
-  }
-
-  /*
-   * Atomically claim the oldest Scheduled task for a worker: the
-   * Scheduled -> InProgress transition is guarded on status, so when
-   * multiple workers poll concurrently only one claim succeeds
-   * (updateOneBy returns the number of rows changed — zero means another
-   * worker won the race, so we retry with the next candidate). The
-   * returned task is already InProgress and owned by the given agent.
-   */
-  @CaptureSpan()
-  public async claimNextScheduledTask(data: {
-    aiAgentId: ObjectID;
-  }): Promise<Model | null> {
-    const maxClaimAttempts: number = 5;
-
-    for (let attempt: number = 0; attempt < maxClaimAttempts; attempt++) {
-      const task: Model | null = await this.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 || !task.id) {
-        return null;
-      }
-
-      const claimedCount: number = await this.updateOneBy({
-        query: {
-          _id: task.id.toString(),
-          status: AIAgentTaskStatus.Scheduled,
-        },
-        data: {
-          status: AIAgentTaskStatus.InProgress,
-          aiAgentId: data.aiAgentId,
-          startedAt: OneUptimeDate.getCurrentDate(),
-        },
-        props: {
-          isRoot: true,
-        },
-      });
-
-      if (claimedCount > 0) {
-        return task;
-      }
-    }
-
-    return 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

@@ -1,39 +0,0 @@
-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/ServiceCodeRepositoryService.ts

@@ -1,55 +0,0 @@
-import BadDataException from "../../Types/Exception/BadDataException";
-import CreateBy from "../Types/Database/CreateBy";
-import { OnCreate } from "../Types/Database/Hooks";
-import DatabaseService from "./DatabaseService";
-import Model from "../../Models/DatabaseModels/ServiceCodeRepository";
-import ObjectID from "../../Types/ObjectID";
-import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
-
-export class Service extends DatabaseService<Model> {
-  public constructor() {
-    super(Model);
-  }
-
-  @CaptureSpan()
-  protected override async onBeforeCreate(
-    createBy: CreateBy<Model>,
-  ): Promise<OnCreate<Model>> {
-    if (!createBy.data.serviceId && !createBy.data.service) {
-      throw new BadDataException("service is required");
-    }
-
-    if (!createBy.data.codeRepository && !createBy.data.codeRepositoryId) {
-      throw new BadDataException("codeRepository is required");
-    }
-
-    const serviceId: string | ObjectID | undefined =
-      createBy.data.serviceId || createBy.data.service?._id;
-    const codeRepositoryId: string | ObjectID | undefined =
-      createBy.data.codeRepositoryId || createBy.data.codeRepository?._id;
-
-    // check if this code repository is already added to the service for this service.
-    const existingCodeRepository: Model | null = await this.findOneBy({
-      query: {
-        serviceId: serviceId as ObjectID,
-        codeRepositoryId: codeRepositoryId as ObjectID,
-      },
-      props: {
-        isRoot: true,
-      },
-    });
-
-    if (existingCodeRepository) {
-      throw new BadDataException(
-        "Code Repository already exists for this service",
-      );
-    }
-
-    return {
-      carryForward: null,
-      createBy: createBy,
-    };
-  }
-}
-
-export default new Service();

package/Tests/Server/Services/AIAgentTaskServiceClaim.test.ts

@@ -1,146 +0,0 @@
-import AIAgentTaskService from "../../../Server/Services/AIAgentTaskService";
-import Model from "../../../Models/DatabaseModels/AIAgentTask";
-import AIAgentTaskStatus from "../../../Types/AI/AIAgentTaskStatus";
-import ObjectID from "../../../Types/ObjectID";
-import { describe, expect, test, afterEach } from "@jest/globals";
-
-/*
- * claimNextScheduledTask is the atomic-claim fix for the get-pending-task
- * double-processing race: multiple KEDA-scaled AIAgent workers poll the same
- * endpoint, and the old plain findOneBy returned the oldest Scheduled task
- * without mutating it, so two workers could both receive — and both execute —
- * the same task.
- *
- * The claim collapses the read-then-take into findOneBy + a status-guarded
- * updateOneBy (Scheduled -> InProgress). updateOneBy returns the number of
- * rows changed: 1 means this caller won the claim; 0 means another worker
- * already took the task, and the loop retries with the next candidate.
- *
- * These tests mock the two inherited persistence helpers (no Postgres) to
- * lock in:
- *   (a) a won claim returns the task, with the guard and the InProgress
- *       transition on the exact row that was read;
- *   (b) a lost claim (0 rows) is never returned — the loop moves to the
- *       next candidate;
- *   (c) no Scheduled tasks => null, with no write at all;
- *   (d) the retry loop is bounded, so a pathological all-losses storm
- *       terminates.
- */
-
-function fakeTask(id: ObjectID): Model {
-  return {
-    id,
-    _id: id.toString(),
-    projectId: ObjectID.generate(),
-    taskType: "FixException",
-  } as unknown as Model;
-}
-
-describe("AIAgentTaskService.claimNextScheduledTask", () => {
-  const aiAgentId: ObjectID = ObjectID.generate();
-
-  afterEach(() => {
-    jest.restoreAllMocks();
-  });
-
-  test("returns the task when the claim wins, guarding on Scheduled status", async () => {
-    const task: Model = fakeTask(ObjectID.generate());
-
-    const findOneBy: jest.SpyInstance = jest
-      .spyOn(AIAgentTaskService, "findOneBy")
-      .mockResolvedValue(task);
-    const updateOneBy: jest.SpyInstance = jest
-      .spyOn(AIAgentTaskService, "updateOneBy")
-      .mockResolvedValue(1);
-
-    const claimed: Model | null =
-      await AIAgentTaskService.claimNextScheduledTask({
-        aiAgentId: aiAgentId,
-      });
-
-    expect(claimed).toBe(task);
-    expect(findOneBy).toHaveBeenCalledTimes(1);
-    expect(findOneBy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        query: { status: AIAgentTaskStatus.Scheduled },
-      }),
-    );
-    expect(updateOneBy).toHaveBeenCalledTimes(1);
-    expect(updateOneBy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        query: {
-          _id: task.id!.toString(),
-          status: AIAgentTaskStatus.Scheduled,
-        },
-        data: expect.objectContaining({
-          status: AIAgentTaskStatus.InProgress,
-          aiAgentId: aiAgentId,
-          startedAt: expect.any(Date),
-        }),
-      }),
-    );
-  });
-
-  test("retries with the next candidate when another worker wins the race", async () => {
-    const lostTask: Model = fakeTask(ObjectID.generate());
-    const wonTask: Model = fakeTask(ObjectID.generate());
-
-    const findOneBy: jest.SpyInstance = jest
-      .spyOn(AIAgentTaskService, "findOneBy")
-      .mockResolvedValueOnce(lostTask)
-      .mockResolvedValueOnce(wonTask);
-    const updateOneBy: jest.SpyInstance = jest
-      .spyOn(AIAgentTaskService, "updateOneBy")
-      .mockResolvedValueOnce(0)
-      .mockResolvedValueOnce(1);
-
-    const claimed: Model | null =
-      await AIAgentTaskService.claimNextScheduledTask({
-        aiAgentId: aiAgentId,
-      });
-
-    expect(claimed).toBe(wonTask);
-    expect(findOneBy).toHaveBeenCalledTimes(2);
-    expect(updateOneBy).toHaveBeenCalledTimes(2);
-    expect(updateOneBy).toHaveBeenLastCalledWith(
-      expect.objectContaining({
-        query: {
-          _id: wonTask.id!.toString(),
-          status: AIAgentTaskStatus.Scheduled,
-        },
-      }),
-    );
-  });
-
-  test("returns null without writing when no Scheduled task exists", async () => {
-    jest.spyOn(AIAgentTaskService, "findOneBy").mockResolvedValue(null);
-    const updateOneBy: jest.SpyInstance = jest
-      .spyOn(AIAgentTaskService, "updateOneBy")
-      .mockResolvedValue(1);
-
-    const claimed: Model | null =
-      await AIAgentTaskService.claimNextScheduledTask({
-        aiAgentId: aiAgentId,
-      });
-
-    expect(claimed).toBeNull();
-    expect(updateOneBy).not.toHaveBeenCalled();
-  });
-
-  test("gives up after a bounded number of lost claims", async () => {
-    const findOneBy: jest.SpyInstance = jest
-      .spyOn(AIAgentTaskService, "findOneBy")
-      .mockImplementation(async () => {
-        return fakeTask(ObjectID.generate());
-      });
-    jest.spyOn(AIAgentTaskService, "updateOneBy").mockResolvedValue(0);
-
-    const claimed: Model | null =
-      await AIAgentTaskService.claimNextScheduledTask({
-        aiAgentId: aiAgentId,
-      });
-
-    expect(claimed).toBeNull();
-    expect(findOneBy).toHaveBeenCalledTimes(5);
-  });
-});

package/Types/AI/AIAgentTaskMetadata.ts

@@ -1,25 +0,0 @@
-import AIAgentTaskType from "./AIAgentTaskType";
-
-// Base interface for all task metadata
-export interface AIAgentTaskMetadataBase {
-  taskType: AIAgentTaskType;
-}
-
-// Metadata for FixException task type
-export interface FixExceptionTaskMetadata extends AIAgentTaskMetadataBase {
-  taskType: AIAgentTaskType.FixException;
-  exceptionId: string;
-  serviceId?: string;
-  stackTrace?: string;
-  errorMessage?: string;
-}
-
-// Union type for all task metadata types
-export type AIAgentTaskMetadata = FixExceptionTaskMetadata; // More tasks can be added here in the future
-
-// Type guard functions
-export function isFixExceptionMetadata(
-  metadata: AIAgentTaskMetadata,
-): metadata is FixExceptionTaskMetadata {
-  return metadata.taskType === AIAgentTaskType.FixException;
-}

package/Types/AI/AIAgentTaskType.ts

@@ -1,40 +0,0 @@
-enum AIAgentTaskType {
-  FixException = "FixException",
-}
-
-export default AIAgentTaskType;
-
-export interface AIAgentTaskTypeProps {
-  taskType: AIAgentTaskType;
-  title: string;
-  description: string;
-}
-
-export class AIAgentTaskTypeHelper {
-  public static getAllTaskTypeProps(): Array<AIAgentTaskTypeProps> {
-    return [
-      {
-        taskType: AIAgentTaskType.FixException,
-        title: "Fix Exception",
-        description:
-          "Analyze and fix an exception that occurred in your application.",
-      },
-    ];
-  }
-
-  public static getDescription(taskType: AIAgentTaskType): string {
-    const props: AIAgentTaskTypeProps | undefined =
-      this.getAllTaskTypeProps().find((p: AIAgentTaskTypeProps) => {
-        return p.taskType === taskType;
-      });
-    return props?.description || "";
-  }
-
-  public static getTitle(taskType: AIAgentTaskType): string {
-    const props: AIAgentTaskTypeProps | undefined =
-      this.getAllTaskTypeProps().find((p: AIAgentTaskTypeProps) => {
-        return p.taskType === taskType;
-      });
-    return props?.title || "";
-  }
-}