@oneuptime/common 11.7.4 → 12.0.0

package/Server/Services/RumSessionService.ts

@@ -0,0 +1,123 @@
+import ClickhouseDatabase from "../Infrastructure/ClickhouseDatabase";
+import AnalyticsDatabaseService from "./AnalyticsDatabaseService";
+import RumSession from "../../Models/AnalyticsModels/RumSession";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import TableColumnType from "../../Types/AnalyticsDatabase/TableColumnType";
+import ObjectID from "../../Types/ObjectID";
+import { JSONObject } from "../../Types/JSON";
+import { SQL, Statement } from "../Utils/AnalyticsDatabase/Statement";
+import { getQuerySettings } from "../Utils/AnalyticsDatabase/QuerySettingsHelper";
+import { ResponseJSON, ResultSet } from "@clickhouse/client";
+
+export class RumSessionService extends AnalyticsDatabaseService<RumSession> {
+  public constructor(clickhouseDatabase?: ClickhouseDatabase | undefined) {
+    super({ modelType: RumSession, database: clickhouseDatabase });
+  }
+
+  /*
+   * Session-replay usage for billing.
+   *
+   * Deliberately NOT the inherited groupTelemetryUsageByService, for two
+   * reasons that both matter:
+   *
+   * 1. It meters off THIS table, never the chunk table. Chunks are
+   *    partitioned by expiry date, so a "yesterday" window over them cannot
+   *    prune partitions and would full-scan a multi-gigabyte blob table under
+   *    the 120s cap. A timeout there is not a retry - stageTelemetryUsage
+   *    always targets yesterday and nothing re-stages an older date, so the
+   *    day would be billed as zero permanently.
+   *
+   * 2. It sums the exact payloadBytes recorded at ingest rather than
+   *    byteSize(*). byteSize is ClickHouse's uncompressed in-memory row size,
+   *    which for a table whose rows are mostly a few narrow numbers would
+   *    have nothing to do with what was actually ingested.
+   *
+   * isFinalized = 1 excludes provisional headers, whose aggregates are still
+   * zero. A session that finalizes across the staging boundary is therefore
+   * billed on the following day's run at its true size, rather than being
+   * billed now at zero and never corrected.
+   *
+   * The inner ORDER BY / LIMIT 1 BY collapses ReplacingMergeTree versions:
+   * there is no FINAL support anywhere in this repo, so duplicate versions of
+   * a header are visible until a merge and would otherwise be summed twice.
+   */
+  @CaptureSpan()
+  public async groupSessionReplayUsageByEntity(data: {
+    projectId: ObjectID;
+    startDate: Date;
+    endDate: Date;
+  }): Promise<
+    Array<{
+      primaryEntityId: string;
+      primaryEntityType: string | null;
+      rowCount: number;
+      estimatedBytes: number;
+    }>
+  > {
+    if (!this.database) {
+      this.useDefaultDatabase();
+    }
+
+    const databaseName: string =
+      this.database!.getDatasourceOptions().database!;
+
+    const statement: Statement = SQL`SELECT primaryEntityId AS primaryEntityId, primaryEntityType AS primaryEntityType, count() AS rowCount, sum(payloadBytes) AS estimatedBytes FROM (SELECT projectId, sessionId, primaryEntityId, primaryEntityType, payloadBytes FROM ${databaseName}.${this.model.tableName} WHERE projectId = ${{
+      type: TableColumnType.ObjectID,
+      value: data.projectId,
+    }} AND startTime >= ${{
+      type: TableColumnType.DateTime64,
+      value: data.startDate,
+    }} AND startTime <= ${{
+      type: TableColumnType.DateTime64,
+      value: data.endDate,
+    }} AND isFinalized = 1 ORDER BY version DESC LIMIT 1 BY projectId, sessionId) GROUP BY primaryEntityId, primaryEntityType`;
+
+    /*
+     * Same reasoning as the shared billing scan: no
+     * timeout_overflow_mode='break', because a partial aggregation would
+     * silently undercount and be billed as though it were complete.
+     */
+    statement.append(getQuerySettings({ maxExecutionTimeInSeconds: 120 }));
+
+    const dbResult: ResultSet<"JSON"> = await this.executeQuery(statement);
+    const responseJSON: ResponseJSON<JSONObject> =
+      await dbResult.json<JSONObject>();
+    const items: Array<JSONObject> = responseJSON.data ? responseJSON.data : [];
+
+    const results: Array<{
+      primaryEntityId: string;
+      primaryEntityType: string | null;
+      rowCount: number;
+      estimatedBytes: number;
+    }> = [];
+
+    for (const item of items) {
+      const primaryEntityId: string = (item["primaryEntityId"] as string) || "";
+
+      if (!primaryEntityId) {
+        continue;
+      }
+
+      const entityTypeRaw: unknown = item["primaryEntityType"];
+      const primaryEntityType: string | null =
+        typeof entityTypeRaw === "string" && entityTypeRaw.trim()
+          ? entityTypeRaw
+          : null;
+
+      results.push({
+        primaryEntityId: primaryEntityId,
+        primaryEntityType: primaryEntityType,
+        /*
+         * 64-bit sums arrive from ClickHouse as JSON strings, so Number() is
+         * load-bearing rather than defensive.
+         */
+        rowCount: Number(item["rowCount"]) || 0,
+        estimatedBytes: Number(item["estimatedBytes"]) || 0,
+      });
+    }
+
+    return results;
+  }
+}
+
+export default new RumSessionService();

package/Server/Services/RunbookCredentialService.ts

@@ -0,0 +1,76 @@
+import DatabaseService from "./DatabaseService";
+import CreateBy from "../Types/Database/CreateBy";
+import { OnCreate } from "../Types/Database/Hooks";
+import BadDataException from "../../Types/Exception/BadDataException";
+import RunbookCredentialType from "../../Types/Runbook/RunbookCredentialType";
+import RunbookCredential from "../../Models/DatabaseModels/RunbookCredential";
+import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+
+export class Service extends DatabaseService<RunbookCredential> {
+  public constructor() {
+    super(RunbookCredential);
+  }
+
+  /*
+   * A credential that is missing what its type needs is not a credential —
+   * it is a step that will fail at execution time, on the far side of an
+   * approval, in front of somebody's incident. Reject it at creation.
+   */
+  @CaptureSpan()
+  protected override async onBeforeCreate(
+    createBy: CreateBy<RunbookCredential>,
+  ): Promise<OnCreate<RunbookCredential>> {
+    const type: RunbookCredentialType | undefined =
+      createBy.data.credentialType;
+
+    if (!type) {
+      throw new BadDataException("Credential type is required.");
+    }
+
+    if (type === RunbookCredentialType.SSH) {
+      if (!createBy.data.sshHostname) {
+        throw new BadDataException("SSH credentials need a hostname.");
+      }
+
+      if (!createBy.data.sshUsername) {
+        throw new BadDataException("SSH credentials need a username.");
+      }
+
+      if (!createBy.data.sshPrivateKey && !createBy.data.sshPassword) {
+        throw new BadDataException(
+          "SSH credentials need either a private key or a password.",
+        );
+      }
+    }
+
+    /*
+     * The column is free text, not a database enum, so an unrecognised type
+     * would otherwise create a credential that skips every check below and
+     * can never be executed by anything.
+     */
+    if (
+      type !== RunbookCredentialType.SSH &&
+      type !== RunbookCredentialType.Kubernetes
+    ) {
+      throw new BadDataException(`Unknown credential type: ${String(type)}`);
+    }
+
+    if (type === RunbookCredentialType.Kubernetes) {
+      if (!createBy.data.kubernetesApiServerUrl) {
+        throw new BadDataException(
+          "Kubernetes credentials need an API server URL.",
+        );
+      }
+
+      if (!createBy.data.kubernetesServiceAccountToken) {
+        throw new BadDataException(
+          "Kubernetes credentials need a service account token.",
+        );
+      }
+    }
+
+    return { createBy, carryForward: [] };
+  }
+}
+
+export default new Service();

package/Server/Services/{RunbookAgentJobService.ts → RunnerJobService.ts}

@@ -1,9 +1,22 @@
 import DatabaseService from "./DatabaseService";
 import ObjectID from "../../Types/ObjectID";
 import BadDataException from "../../Types/Exception/BadDataException";
-import Model from "../../Models/DatabaseModels/RunbookAgentJob";
-import RunbookAgentJobStatus from "../../Types/Runbook/RunbookAgentJobStatus";
-import RunbookStepType from "../../Types/Runbook/RunbookStepType";
+import Model from "../../Models/DatabaseModels/RunnerJob";
+import RunnerJobStatus from "../../Types/Runbook/RunnerJobStatus";
+import RunnerJobOrigin from "../../Types/Runbook/RunnerJobOrigin";
+import RunbookStepType, {
+  isRunnerExecutedStepType,
+} from "../../Types/Runbook/RunbookStepType";
+import { AI_COMMAND_STEP_TYPES } from "../../Types/AutoRemediation/AiRemediationCommandPlan";
+import CommandPolicy from "../../Utils/AiRemediation/CommandPolicy";
+import QueryHelper from "../Types/Database/QueryHelper";
+
+/*
+ * Project-wide hourly ceiling on AI-composed command jobs, counted on the
+ * RunnerJob rows themselves so every path (FullAuto inline execution,
+ * approved plans, rollbacks) shares one brake.
+ */
+export const MAX_AI_COMMAND_JOBS_PER_PROJECT_PER_HOUR: number = 30;
 import SortOrder from "../../Types/BaseDatabase/SortOrder";
 import OneUptimeDate from "../../Types/Date";
 import { JSONObject } from "../../Types/JSON";
@@ -32,15 +45,15 @@ const POLL_INTERVAL_MS: number = 500;
  * durable record of what the step did. Everything else is still in flight and
  * can be waited on.
  */
-const TERMINAL_STATUSES: Array<RunbookAgentJobStatus> = [
-  RunbookAgentJobStatus.Succeeded,
-  RunbookAgentJobStatus.Failed,
-  RunbookAgentJobStatus.TimedOut,
-  RunbookAgentJobStatus.Cancelled,
+const TERMINAL_STATUSES: Array<RunnerJobStatus> = [
+  RunnerJobStatus.Succeeded,
+  RunnerJobStatus.Failed,
+  RunnerJobStatus.TimedOut,
+  RunnerJobStatus.Cancelled,
 ];
 
 export function isTerminalAgentJobStatus(
-  status: RunbookAgentJobStatus | undefined,
+  status: RunnerJobStatus | undefined,
 ): boolean {
   return Boolean(status && TERMINAL_STATUSES.includes(status));
 }
@@ -79,19 +92,17 @@ export class Service extends DatabaseService<Model> {
     script: string;
     timeoutInMs: number;
     claimTimeoutInMs?: number | undefined;
+    payload?: JSONObject | undefined;
   }): Promise<Model> {
     if (!data.targetAgentId) {
       throw new BadDataException(
-        "targetAgentId is required to dispatch a step to a Runbook Agent.",
+        "targetAgentId is required to dispatch a step to a Runner.",
       );
     }
 
-    if (
-      data.stepType !== RunbookStepType.Bash &&
-      data.stepType !== RunbookStepType.JavaScript
-    ) {
+    if (!isRunnerExecutedStepType(data.stepType)) {
       throw new BadDataException(
-        `RunbookAgent does not execute step type "${data.stepType}".`,
+        `Runner does not execute step type "${data.stepType}".`,
       );
     }
 
@@ -103,12 +114,123 @@ export class Service extends DatabaseService<Model> {
     const row: Model = new Model();
     row.projectId = data.projectId;
     row.runbookExecutionId = data.runbookExecutionId;
+    row.origin = RunnerJobOrigin.Runbook;
     row.stepId = data.stepId;
     row.stepType = data.stepType;
     row.targetAgentId = data.targetAgentId;
     row.script = data.script;
+    if (data.payload) {
+      row.payload = data.payload;
+    }
     row.timeoutInMs = data.timeoutInMs;
-    row.status = RunbookAgentJobStatus.Pending;
+    row.status = RunnerJobStatus.Pending;
+    row.claimDeadlineAt = claimDeadlineAt;
+
+    return this.create({ data: row, props: { isRoot: true } });
+  }
+
+  /*
+   * Enqueue an ad-hoc AI-composed command as an AiRemediation-origin job.
+   * This is a server-side chokepoint on the path an LLM's output takes to a
+   * shell, so it re-validates what the tool layer already checked: step
+   * type and the hard command denylist. The claim path then only serves
+   * these jobs to Runners whose canRunAiCommands capability is on.
+   */
+  @CaptureSpan()
+  public async enqueueAiCommand(data: {
+    projectId: ObjectID;
+    aiRunId: ObjectID;
+    autoRemediationSuggestionId: ObjectID;
+    stepId: string;
+    stepType: RunbookStepType;
+    targetAgentId: ObjectID;
+    command: string;
+    credentialId?: string | undefined;
+    timeoutInMs: number;
+    claimTimeoutInMs?: number | undefined;
+  }): Promise<Model> {
+    if (!data.targetAgentId) {
+      throw new BadDataException(
+        "targetAgentId is required to dispatch a command to a Runner.",
+      );
+    }
+
+    if (!AI_COMMAND_STEP_TYPES.includes(data.stepType)) {
+      throw new BadDataException(
+        `AI remediation does not execute step type "${data.stepType}".`,
+      );
+    }
+
+    const command: string = (data.command || "").trim();
+    if (!command) {
+      throw new BadDataException("An AI command job needs a command.");
+    }
+
+    const denyReason: string | null = CommandPolicy.getDenyReason(command);
+    if (denyReason) {
+      throw new BadDataException(
+        `Denied by the remediation command policy: ${denyReason}.`,
+      );
+    }
+
+    if (data.stepType === RunbookStepType.SSH && !data.credentialId) {
+      throw new BadDataException("An SSH command job needs a credentialId.");
+    }
+
+    /*
+     * Project-wide hourly storm brake for the whole AI-command lane. It
+     * lives HERE, at the single enqueue chokepoint, so it also bounds the
+     * approved-plan and rollback paths — not just the FullAuto inline tool
+     * that has its own pre-check for a friendlier message to the model.
+     * Check-then-act, so a burst of concurrent runs can overshoot slightly;
+     * the cap is a storm brake, not a quota.
+     */
+    const jobsInLastHour: number = (
+      await this.countBy({
+        query: {
+          projectId: data.projectId,
+          origin: RunnerJobOrigin.AiRemediation,
+          createdAt: QueryHelper.greaterThan(OneUptimeDate.getSomeHoursAgo(1)),
+        },
+        props: { isRoot: true },
+      })
+    ).toNumber();
+
+    if (jobsInLastHour >= MAX_AI_COMMAND_JOBS_PER_PROJECT_PER_HOUR) {
+      throw new BadDataException(
+        `This project has run ${jobsInLastHour} AI remediation commands in the last hour, which is its limit (${MAX_AI_COMMAND_JOBS_PER_PROJECT_PER_HOUR}). No further AI commands can run this hour.`,
+      );
+    }
+
+    const claimDeadlineAt: Date = OneUptimeDate.addRemoveSeconds(
+      OneUptimeDate.getCurrentDate(),
+      Math.ceil((data.claimTimeoutInMs ?? DEFAULT_CLAIM_TIMEOUT_MS) / 1000),
+    );
+
+    const row: Model = new Model();
+    row.projectId = data.projectId;
+    row.origin = RunnerJobOrigin.AiRemediation;
+    row.aiRunId = data.aiRunId;
+    row.autoRemediationSuggestionId = data.autoRemediationSuggestionId;
+    row.stepId = data.stepId;
+    row.stepType = data.stepType;
+    row.targetAgentId = data.targetAgentId;
+    /*
+     * Same layout the runbook step executors use: Bash carries the command
+     * as the script; SSH carries an empty script plus structured payload,
+     * and the credential is resolved at claim time — never stored here.
+     */
+    if (data.stepType === RunbookStepType.Bash) {
+      row.script = command;
+    } else {
+      row.script = "";
+      row.payload = {
+        credentialId: data.credentialId as string,
+        command: command,
+      };
+    }
+    row.timeoutInMs = data.timeoutInMs;
+    row.status = RunnerJobStatus.Pending;
     row.claimDeadlineAt = claimDeadlineAt;
 
     return this.create({ data: row, props: { isRoot: true } });
@@ -165,6 +287,12 @@ export class Service extends DatabaseService<Model> {
     agentId: ObjectID;
     projectId: ObjectID;
     leaseMs?: number | undefined;
+    /*
+     * Which job origins this Runner's capabilities entitle it to claim.
+     * Defaults to runbook jobs only — the AiRemediation origin must be
+     * asked for explicitly by the ingress after checking canRunAiCommands.
+     */
+    allowedOrigins?: Array<RunnerJobOrigin> | undefined;
   }): Promise<Model | null> {
     const dataSource: ReturnType<typeof PostgresAppInstance.getDataSource> =
       PostgresAppInstance.getDataSource();
@@ -175,19 +303,25 @@ export class Service extends DatabaseService<Model> {
 
     const leaseMs: number = data.leaseMs ?? DEFAULT_LEASE_MS;
 
+    const allowedOrigins: Array<RunnerJobOrigin> =
+      data.allowedOrigins && data.allowedOrigins.length > 0
+        ? data.allowedOrigins
+        : [RunnerJobOrigin.Runbook];
+
     const sql: string = `
       WITH claimed AS (
-        SELECT "_id" FROM "RunbookAgentJob"
+        SELECT "_id" FROM "RunnerJob"
         WHERE "projectId" = $1::uuid
           AND "status" = $2
           AND "targetAgentId" = $3::uuid
+          AND "origin" = ANY($6::text[])
           AND "claimDeadlineAt" > NOW()
           AND "deletedAt" IS NULL
         ORDER BY "createdAt" ASC
         LIMIT 1
         FOR UPDATE SKIP LOCKED
       )
-      UPDATE "RunbookAgentJob" j
+      UPDATE "RunnerJob" j
       SET "status" = $4,
           "assignedAgentId" = $3::uuid,
           "claimedAt" = NOW(),
@@ -196,18 +330,21 @@ export class Service extends DatabaseService<Model> {
           "version" = j."version" + 1
       FROM claimed
       WHERE j."_id" = claimed."_id"
-      RETURNING j."_id", j."projectId", j."runbookExecutionId",
+      RETURNING j."_id", j."projectId", j."runbookExecutionId", j."origin",
+                j."aiRunId", j."autoRemediationSuggestionId",
                 j."stepId", j."stepType", j."targetAgentId", j."script",
-                j."timeoutInMs", j."status", j."claimedAt", j."leaseExpiresAt";
+                j."payload", j."timeoutInMs", j."status", j."claimedAt",
+                j."leaseExpiresAt";
     `;
 
     const rows: Array<JSONObject> = unwrapRows(
       await dataSource.query(sql, [
         data.projectId.toString(),
-        RunbookAgentJobStatus.Pending,
+        RunnerJobStatus.Pending,
         data.agentId.toString(),
-        RunbookAgentJobStatus.Claimed,
+        RunnerJobStatus.Claimed,
         leaseMs.toString(),
+        allowedOrigins,
       ]),
     );
 
@@ -219,13 +356,27 @@ export class Service extends DatabaseService<Model> {
     const job: Model = new Model();
     job._id = String(r["_id"]);
     job.projectId = new ObjectID(String(r["projectId"]));
-    job.runbookExecutionId = new ObjectID(String(r["runbookExecutionId"]));
+    if (r["runbookExecutionId"]) {
+      job.runbookExecutionId = new ObjectID(String(r["runbookExecutionId"]));
+    }
+    job.origin = (r["origin"] as RunnerJobOrigin) || RunnerJobOrigin.Runbook;
+    if (r["aiRunId"]) {
+      job.aiRunId = new ObjectID(String(r["aiRunId"]));
+    }
+    if (r["autoRemediationSuggestionId"]) {
+      job.autoRemediationSuggestionId = new ObjectID(
+        String(r["autoRemediationSuggestionId"]),
+      );
+    }
     job.stepId = String(r["stepId"]);
     job.stepType = r["stepType"] as RunbookStepType;
     job.targetAgentId = new ObjectID(String(r["targetAgentId"]));
     job.script = String(r["script"]);
+    if (r["payload"] && typeof r["payload"] === "object") {
+      job.payload = r["payload"] as JSONObject;
+    }
     job.timeoutInMs = Number(r["timeoutInMs"]);
-    job.status = r["status"] as RunbookAgentJobStatus;
+    job.status = r["status"] as RunnerJobStatus;
     if (r["claimedAt"]) {
       job.claimedAt = new Date(String(r["claimedAt"]));
     }
@@ -256,7 +407,7 @@ export class Service extends DatabaseService<Model> {
      * should stop executing.
      */
     const sql: string = `
-      UPDATE "RunbookAgentJob"
+      UPDATE "RunnerJob"
       SET "status" = CASE WHEN "status" = $4 THEN $5 ELSE "status" END,
           "startedAt" = COALESCE("startedAt", NOW()),
           "leaseExpiresAt" = NOW() + ($1 || ' milliseconds')::interval,
@@ -272,8 +423,8 @@ export class Service extends DatabaseService<Model> {
         leaseMs.toString(),
         data.jobId.toString(),
         data.agentId.toString(),
-        RunbookAgentJobStatus.Claimed,
-        RunbookAgentJobStatus.Running,
+        RunnerJobStatus.Claimed,
+        RunnerJobStatus.Running,
       ]),
     );
 
@@ -295,9 +446,9 @@ export class Service extends DatabaseService<Model> {
       throw new BadDataException("Database is not connected");
     }
 
-    const status: RunbookAgentJobStatus = data.success
-      ? RunbookAgentJobStatus.Succeeded
-      : RunbookAgentJobStatus.Failed;
+    const status: RunnerJobStatus = data.success
+      ? RunnerJobStatus.Succeeded
+      : RunnerJobStatus.Failed;
 
     /*
      * Only the agent that holds the lease is allowed to write the terminal
@@ -305,7 +456,7 @@ export class Service extends DatabaseService<Model> {
      * reclaimed), this is a no-op.
      */
     const sql: string = `
-      UPDATE "RunbookAgentJob"
+      UPDATE "RunnerJob"
       SET "status" = $1,
           "output" = $2,
           "exitCode" = $3,
@@ -326,8 +477,8 @@ export class Service extends DatabaseService<Model> {
         data.errorMessage ?? null,
         data.jobId.toString(),
         data.agentId.toString(),
-        RunbookAgentJobStatus.Claimed,
-        RunbookAgentJobStatus.Running,
+        RunnerJobStatus.Claimed,
+        RunnerJobStatus.Running,
       ]),
     );
 
@@ -380,7 +531,7 @@ export class Service extends DatabaseService<Model> {
 
       if (!job) {
         throw new BadDataException(
-          `RunbookAgentJob ${data.jobId.toString()} disappeared while waiting.`,
+          `RunnerJob ${data.jobId.toString()} disappeared while waiting.`,
         );
       }
 
@@ -392,7 +543,7 @@ export class Service extends DatabaseService<Model> {
 
       // Pending with claim deadline elapsed -> no agent picked it up.
       if (
-        job.status === RunbookAgentJobStatus.Pending &&
+        job.status === RunnerJobStatus.Pending &&
         job.claimDeadlineAt &&
         now > job.claimDeadlineAt
       ) {
@@ -405,8 +556,8 @@ export class Service extends DatabaseService<Model> {
 
       // Claimed/Running with lease elapsed -> agent went silent.
       if (
-        (job.status === RunbookAgentJobStatus.Claimed ||
-          job.status === RunbookAgentJobStatus.Running) &&
+        (job.status === RunnerJobStatus.Claimed ||
+          job.status === RunnerJobStatus.Running) &&
         job.leaseExpiresAt &&
         now > job.leaseExpiresAt
       ) {
@@ -445,7 +596,7 @@ export class Service extends DatabaseService<Model> {
      * state. The same agent's late-arriving result must lose to this race.
      */
     const sql: string = `
-      UPDATE "RunbookAgentJob"
+      UPDATE "RunnerJob"
       SET "status" = $1,
           "errorMessage" = $2,
           "completedAt" = NOW(),
@@ -456,13 +607,13 @@ export class Service extends DatabaseService<Model> {
       RETURNING "_id";
     `;
     await dataSource.query(sql, [
-      RunbookAgentJobStatus.TimedOut,
+      RunnerJobStatus.TimedOut,
       data.reason,
       data.jobId.toString(),
-      RunbookAgentJobStatus.Succeeded,
-      RunbookAgentJobStatus.Failed,
-      RunbookAgentJobStatus.TimedOut,
-      RunbookAgentJobStatus.Cancelled,
+      RunnerJobStatus.Succeeded,
+      RunnerJobStatus.Failed,
+      RunnerJobStatus.TimedOut,
+      RunnerJobStatus.Cancelled,
     ]);
 
     const updated: Model | null = await this.findOneById({
@@ -480,7 +631,7 @@ export class Service extends DatabaseService<Model> {
 
     if (!updated) {
       throw new BadDataException(
-        `RunbookAgentJob ${data.jobId.toString()} not found while timing out.`,
+        `RunnerJob ${data.jobId.toString()} not found while timing out.`,
       );
     }
 
@@ -498,21 +649,21 @@ export class Service extends DatabaseService<Model> {
     }
     try {
       await dataSource.query(
-        `UPDATE "RunbookAgentJob"
+        `UPDATE "RunnerJob"
          SET "status" = $1, "completedAt" = NOW(), "updatedAt" = NOW(), "version" = "version" + 1
          WHERE "runbookExecutionId" = $2::uuid
            AND "status" NOT IN ($3, $4, $5, $6)`,
         [
-          RunbookAgentJobStatus.Cancelled,
+          RunnerJobStatus.Cancelled,
           data.runbookExecutionId.toString(),
-          RunbookAgentJobStatus.Succeeded,
-          RunbookAgentJobStatus.Failed,
-          RunbookAgentJobStatus.TimedOut,
-          RunbookAgentJobStatus.Cancelled,
+          RunnerJobStatus.Succeeded,
+          RunnerJobStatus.Failed,
+          RunnerJobStatus.TimedOut,
+          RunnerJobStatus.Cancelled,
         ],
       );
     } catch (err) {
-      logger.error("Failed to cancel RunbookAgentJobs for execution");
+      logger.error("Failed to cancel RunnerJobs for execution");
       logger.error(err);
     }
   }

package/Server/Services/{RunbookAgentOwnerUserService.ts → RunnerOwnerTeamService.ts}

@@ -1,5 +1,5 @@
 import DatabaseService from "./DatabaseService";
-import Model from "../../Models/DatabaseModels/RunbookAgentOwnerUser";
+import Model from "../../Models/DatabaseModels/RunnerOwnerTeam";
 
 export class Service extends DatabaseService<Model> {
   public constructor() {

package/Server/Services/RunnerOwnerUserService.ts

@@ -0,0 +1,10 @@
+import DatabaseService from "./DatabaseService";
+import Model from "../../Models/DatabaseModels/RunnerOwnerUser";
+
+export class Service extends DatabaseService<Model> {
+  public constructor() {
+    super(Model);
+  }
+}
+
+export default new Service();