@oneuptime/common 14.0.0 → 14.0.2

package/Server/Infrastructure/Postgres/SchemaMigrations/1794400000000-AddKubernetesClusterAiAccess.ts

@@ -0,0 +1,129 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/*
+ * Generated with npm run generate-postgres-migration, then trimmed to this
+ * change. OneUptime AI access to a Kubernetes cluster: the cluster binds the
+ * Runner (and optional Kubernetes credential) AI uses for kubectl, plus its
+ * investigation switch, remediation mode and allowlist. RunnerJob and
+ * AutoRemediationSuggestion gain the cluster a kubectl command ran against
+ * so the cluster's AI page can list every command AI ran on it.
+ */
+export class AddKubernetesClusterAiAccess1794400000000
+  implements MigrationInterface
+{
+  public name: string = "AddKubernetesClusterAiAccess1794400000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "KubernetesCluster" ADD "aiAccessRunnerId" uuid`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "KubernetesCluster" ADD "aiAccessCredentialId" uuid`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "KubernetesCluster" ADD "isAiInvestigationEnabled" boolean NOT NULL DEFAULT false`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "KubernetesCluster" ADD "aiRemediationMode" character varying(100) NOT NULL DEFAULT 'Disabled'`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "KubernetesCluster" ADD "aiKubectlCommandAllowlist" jsonb`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "KubernetesCluster" ADD "aiAccessLastVerifiedAt" TIMESTAMP WITH TIME ZONE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "KubernetesCluster" ADD "aiAccessLastError" character varying`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "KubernetesCluster" ADD "aiAccessConfiguredAt" TIMESTAMP WITH TIME ZONE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "KubernetesCluster" ADD "aiAccessRunnerBoundAt" TIMESTAMP WITH TIME ZONE`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "RunnerJob" ADD "kubernetesClusterId" uuid`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AutoRemediationSuggestion" ADD "kubernetesClusterId" uuid`,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_9cfdcee74d277dcb577dd5889d" ON "KubernetesCluster" ("aiAccessRunnerId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_d3aac9a59774cca6c0f0299992" ON "RunnerJob" ("kubernetesClusterId") `,
+    );
+    await queryRunner.query(
+      `CREATE INDEX "IDX_8730770e8d450cbfa54236ed13" ON "AutoRemediationSuggestion" ("kubernetesClusterId") `,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "KubernetesCluster" ADD CONSTRAINT "FK_9cfdcee74d277dcb577dd5889d5" FOREIGN KEY ("aiAccessRunnerId") REFERENCES "Runner"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "KubernetesCluster" ADD CONSTRAINT "FK_b4a0ae50ee63ca22e46e396ca3e" FOREIGN KEY ("aiAccessCredentialId") REFERENCES "RunbookCredential"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "RunnerJob" ADD CONSTRAINT "FK_d3aac9a59774cca6c0f0299992a" FOREIGN KEY ("kubernetesClusterId") REFERENCES "KubernetesCluster"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AutoRemediationSuggestion" ADD CONSTRAINT "FK_8730770e8d450cbfa54236ed13a" FOREIGN KEY ("kubernetesClusterId") REFERENCES "KubernetesCluster"("_id") ON DELETE SET NULL ON UPDATE NO ACTION`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "AutoRemediationSuggestion" DROP CONSTRAINT "FK_8730770e8d450cbfa54236ed13a"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "RunnerJob" DROP CONSTRAINT "FK_d3aac9a59774cca6c0f0299992a"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "KubernetesCluster" DROP CONSTRAINT "FK_b4a0ae50ee63ca22e46e396ca3e"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "KubernetesCluster" DROP CONSTRAINT "FK_9cfdcee74d277dcb577dd5889d5"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_8730770e8d450cbfa54236ed13"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_d3aac9a59774cca6c0f0299992"`,
+    );
+    await queryRunner.query(
+      `DROP INDEX "public"."IDX_9cfdcee74d277dcb577dd5889d"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "AutoRemediationSuggestion" DROP COLUMN "kubernetesClusterId"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "RunnerJob" DROP COLUMN "kubernetesClusterId"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "KubernetesCluster" DROP COLUMN "aiAccessRunnerBoundAt"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "KubernetesCluster" DROP COLUMN "aiAccessConfiguredAt"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "KubernetesCluster" DROP COLUMN "aiAccessLastError"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "KubernetesCluster" DROP COLUMN "aiAccessLastVerifiedAt"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "KubernetesCluster" DROP COLUMN "aiKubectlCommandAllowlist"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "KubernetesCluster" DROP COLUMN "aiRemediationMode"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "KubernetesCluster" DROP COLUMN "isAiInvestigationEnabled"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "KubernetesCluster" DROP COLUMN "aiAccessCredentialId"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "KubernetesCluster" DROP COLUMN "aiAccessRunnerId"`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1794500000000-AddIncomingEmailCustomAddressToMonitor.ts

@@ -0,0 +1,25 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class AddIncomingEmailCustomAddressToMonitor1794500000000
+  implements MigrationInterface
+{
+  public name: string = "AddIncomingEmailCustomAddressToMonitor1794500000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "Monitor" ADD "incomingEmailCustomLocalPart" character varying(100)`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "Monitor" ADD CONSTRAINT "UQ_7abf86b592dbbe8bf8a38bad6e5" UNIQUE ("incomingEmailCustomLocalPart")`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "Monitor" DROP CONSTRAINT "UQ_7abf86b592dbbe8bf8a38bad6e5"`,
+    );
+    await queryRunner.query(
+      `ALTER TABLE "Monitor" DROP COLUMN "incomingEmailCustomLocalPart"`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1794600000000-AddAuthTokenExpiresAtToWorkspaceProjectAuthToken.ts

@@ -0,0 +1,20 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+export class AddAuthTokenExpiresAtToWorkspaceProjectAuthToken1794600000000
+  implements MigrationInterface
+{
+  public name: string =
+    "AddAuthTokenExpiresAtToWorkspaceProjectAuthToken1794600000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "WorkspaceProjectAuthToken" ADD "authTokenExpiresAt" TIMESTAMP WITH TIME ZONE`,
+    );
+  }
+
+  public async down(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `ALTER TABLE "WorkspaceProjectAuthToken" DROP COLUMN "authTokenExpiresAt"`,
+    );
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/1794700000000-RemoveAppAccessTokenFromWorkspaceProjectAuthTokenMiscData.ts

@@ -0,0 +1,38 @@
+import { MigrationInterface, QueryRunner } from "typeorm";
+
+/*
+ * Data cleanup: take the Microsoft Graph app token out of
+ * WorkspaceProjectAuthToken.miscData.
+ *
+ * Microsoft Teams connections cached the tenant's app-only Graph token, and
+ * its expiry, in miscData. That column is readable by every project Viewer
+ * through the CRUD API. The token now lives only in the server-only
+ * `authToken` / `authTokenExpiresAt` columns (`authToken` always held the same
+ * token), so the copies in miscData are deleted here.
+ *
+ * `authTokenExpiresAt` is deliberately not backfilled from the old miscData
+ * value. A Teams connection with no recorded expiry mints a fresh token on its
+ * next Graph call, and that records one.
+ *
+ * Only JSON objects are touched: `-` raises on a JSON scalar, and `?|` would
+ * match a scalar string equal to one of the keys.
+ *
+ * down() restores nothing. The values were short-lived credentials the server
+ * mints again on demand, and putting them back would reopen the exposure.
+ */
+export class RemoveAppAccessTokenFromWorkspaceProjectAuthTokenMiscData1794700000000
+  implements MigrationInterface
+{
+  public name: string =
+    "RemoveAppAccessTokenFromWorkspaceProjectAuthTokenMiscData1794700000000";
+
+  public async up(queryRunner: QueryRunner): Promise<void> {
+    await queryRunner.query(
+      `UPDATE "WorkspaceProjectAuthToken" SET "miscData" = "miscData" - 'appAccessToken' - 'appAccessTokenExpiresAt' - 'lastAppTokenIssuedAt' WHERE jsonb_typeof("miscData") = 'object' AND "miscData" ?| ARRAY['appAccessToken', 'appAccessTokenExpiresAt', 'lastAppTokenIssuedAt']`,
+    );
+  }
+
+  public async down(_queryRunner: QueryRunner): Promise<void> {
+    // Nothing to restore; see the note above.
+  }
+}

package/Server/Infrastructure/Postgres/SchemaMigrations/Index.ts

@@ -1,6 +1,13 @@
 import { AddAIInvestigationDecision1793700000000 } from "./1793700000000-AddAIInvestigationDecision";
 import { RemoveMonitorDescriptionLengthLimit1793800000000 } from "./1793800000000-RemoveMonitorDescriptionLengthLimit";
 import { AddEnterpriseEditionFirstSeenAt1793900000000 } from "./1793900000000-AddEnterpriseEditionFirstSeenAt";
+import { AddSloLabelAndOwnerRules1794100000000 } from "./1794100000000-AddSloLabelAndOwnerRules";
+import { AddSloMonitorRuleMonitorType1794200000000 } from "./1794200000000-AddSloMonitorRuleMonitorType";
+import { AddOAuth2WorkflowVariables1794300000000 } from "./1794300000000-AddOAuth2WorkflowVariables";
+import { AddKubernetesClusterAiAccess1794400000000 } from "./1794400000000-AddKubernetesClusterAiAccess";
+import { AddIncomingEmailCustomAddressToMonitor1794500000000 } from "./1794500000000-AddIncomingEmailCustomAddressToMonitor";
+import { AddAuthTokenExpiresAtToWorkspaceProjectAuthToken1794600000000 } from "./1794600000000-AddAuthTokenExpiresAtToWorkspaceProjectAuthToken";
+import { RemoveAppAccessTokenFromWorkspaceProjectAuthTokenMiscData1794700000000 } from "./1794700000000-RemoveAppAccessTokenFromWorkspaceProjectAuthTokenMiscData";
 import { AddConfigurableRuleCriteria1792500000000 } from "./1792500000000-AddConfigurableRuleCriteria";
 import { AddGoogleSecOpsDiagnostics1792300000000 } from "./1792300000000-AddGoogleSecOpsDiagnostics";
 import { AddIncomingCallPolicyPhoneNumbers1792600000000 } from "./1792600000000-AddIncomingCallPolicyPhoneNumbers";
@@ -1202,4 +1209,11 @@ export default [
   AddAIInvestigationDecision1793700000000,
   RemoveMonitorDescriptionLengthLimit1793800000000,
   AddEnterpriseEditionFirstSeenAt1793900000000,
+  AddSloLabelAndOwnerRules1794100000000,
+  AddSloMonitorRuleMonitorType1794200000000,
+  AddOAuth2WorkflowVariables1794300000000,
+  AddKubernetesClusterAiAccess1794400000000,
+  AddIncomingEmailCustomAddressToMonitor1794500000000,
+  AddAuthTokenExpiresAtToWorkspaceProjectAuthToken1794600000000,
+  RemoveAppAccessTokenFromWorkspaceProjectAuthTokenMiscData1794700000000,
 ];

package/Server/Middleware/MasterAdminAuthorization.ts

@@ -1,5 +1,6 @@
 import UserMiddleware from "./UserAuthorization";
 import ProjectMiddleware from "./ProjectAuthorization";
+import UserService from "../Services/UserService";
 import JSONWebToken from "../Utils/JsonWebToken";
 import Response from "../Utils/Response";
 import {
@@ -7,6 +8,8 @@ import {
   ExpressResponse,
   NextFunction,
 } from "../Utils/Express";
+import Exception from "../../Types/Exception/Exception";
+import ExceptionMessages from "../../Types/Exception/ExceptionMessages";
 import NotAuthorizedException from "../../Types/Exception/NotAuthorizedException";
 import NotAuthenticatedException from "../../Types/Exception/NotAuthenticatedException";
 import JSONWebTokenData from "../../Types/JsonWebTokenData";
@@ -54,6 +57,31 @@ export default class MasterAdminAuthorization {
         return;
       }
 
+      /*
+       * These routes read the JWT themselves rather than going through
+       * UserAuthorization, so they need the same blocked-user check: a
+       * blocked master admin's access token is still valid for up to 15
+       * minutes. Its own try, so a failed lookup is reported as what it is
+       * rather than as the invalid-token 401 below.
+       */
+      let isUserBlocked: boolean;
+
+      try {
+        isUserBlocked = await UserService.isUserBlocked(authData.userId);
+      } catch (err) {
+        Response.sendErrorResponse(req, res, err as Exception);
+        return;
+      }
+
+      if (isUserBlocked) {
+        Response.sendErrorResponse(
+          req,
+          res,
+          new NotAuthenticatedException(ExceptionMessages.UserBlocked),
+        );
+        return;
+      }
+
       next();
     } catch {
       Response.sendErrorResponse(

package/Server/Middleware/TelemetryIngest.ts

@@ -71,8 +71,19 @@ const COUNTER_UNAVAILABLE_LOG_INTERVAL_MS: number = 60 * 1000;
  */
 const UNNAMED_SURFACE_READABLE_NAME: string = "this ingest endpoint";
 
+/*
+ * The ceiling a server key gets on the Kubernetes agent Runner registration
+ * surface when its policy names none. Registration is a handful of calls
+ * per agent pod lifetime (start-up, then heartbeats through the Runner's
+ * own credential), so a leaked ingestion key hammering it is abuse, not
+ * traffic - unlike OTLP ingest, where "no limit" is the historical contract
+ * and must stay that way. An explicit per-key limit still wins.
+ */
+export const DEFAULT_KUBERNETES_AGENT_RUNNER_REQUESTS_PER_MINUTE: number = 30;
+
 type GetEffectiveRequestsPerMinuteLimitFunction = (
   policy: TelemetryIngestionKeyPolicy,
+  surface?: TelemetryIngestSurface | null | undefined,
 ) => number | null;
 
 /*
@@ -89,9 +100,18 @@ type GetEffectiveRequestsPerMinuteLimitFunction = (
  * with NULL falls back to the shipped default instead, because a public key
  * with no ceiling is the thing we are trying to stop shipping: "the customer
  * did not configure a limit" cannot be allowed to mean "unlimited" there.
+ *
+ * The one surface-dependent case is Kubernetes agent Runner registration:
+ * a server key with no configured limit is held to a conservative default
+ * there (see DEFAULT_KUBERNETES_AGENT_RUNNER_REQUESTS_PER_MINUTE), because
+ * that endpoint mints Runner identities rather than accepting telemetry.
+ * Every other surface keeps the server-key contract above untouched.
  */
 export const getEffectiveRequestsPerMinuteLimit: GetEffectiveRequestsPerMinuteLimitFunction =
-  (policy: TelemetryIngestionKeyPolicy): number | null => {
+  (
+    policy: TelemetryIngestionKeyPolicy,
+    surface?: TelemetryIngestSurface | null | undefined,
+  ): number | null => {
     /*
      * An explicit limit wins for both key types, including a Server key: a
      * customer who deliberately set a ceiling on a server key asked for one
@@ -109,6 +129,10 @@ export const getEffectiveRequestsPerMinuteLimit: GetEffectiveRequestsPerMinuteLi
       return DEFAULT_BROWSER_KEY_REQUESTS_PER_MINUTE;
     }
 
+    if (surface === TelemetryIngestSurface.KubernetesAgentRunner) {
+      return DEFAULT_KUBERNETES_AGENT_RUNNER_REQUESTS_PER_MINUTE;
+    }
+
     return null;
   };
 
@@ -428,6 +452,27 @@ export default class TelemetryIngest {
         }
       }
 
+      /*
+       * Kubernetes agent Runner registration mints a Runner identity — the
+       * one every kubectl job for a cluster is targeted at — so it takes a
+       * project-wide server key. A key pinned to one service's name was
+       * scoped by its owner to that service's telemetry; it is refused here
+       * rather than letting it stand up cluster access it was never meant
+       * to reach.
+       */
+      if (
+        surface === TelemetryIngestSurface.KubernetesAgentRunner &&
+        policy.pinnedServiceName
+      ) {
+        return Response.sendErrorResponse(
+          req,
+          res,
+          new NotAuthorizedException(
+            "This telemetry ingestion key is pinned to a single service, so it cannot register the Kubernetes agent's in-cluster Runner. Use an unpinned server ingestion key for the Kubernetes agent.",
+          ),
+        );
+      }
+
       /*
        * Rate limit.
        *
@@ -440,7 +485,7 @@ export default class TelemetryIngest {
        * today's ingest slower.
        */
       const effectiveLimitPerMinute: number | null =
-        getEffectiveRequestsPerMinuteLimit(policy);
+        getEffectiveRequestsPerMinuteLimit(policy, surface);
 
       if (effectiveLimitPerMinute !== null) {
         const decision: TelemetryIngestionKeyLimitDecision =

package/Server/Middleware/UserAuthorization.ts

@@ -18,6 +18,7 @@ import ProjectMiddleware from "./ProjectAuthorization";
 import SpanUtil from "../Utils/Telemetry/SpanUtil";
 import Dictionary from "../../Types/Dictionary";
 import Exception from "../../Types/Exception/Exception";
+import ExceptionMessages from "../../Types/Exception/ExceptionMessages";
 import NotAuthenticatedException from "../../Types/Exception/NotAuthenticatedException";
 import SsoAuthorizationException from "../../Types/Exception/SsoAuthorizationException";
 import TenantNotFoundException from "../../Types/Exception/TenantNotFoundException";
@@ -590,6 +591,42 @@ export default class UserMiddleware {
       );
     }
 
+    /*
+     * The access token is a stateless JWT that lives for 15 minutes, and
+     * blocking a user revokes their sessions but cannot recall a token already
+     * issued. Without this check a blocked user keeps full access until it
+     * expires. The answer is cached per node (UserService.isUserBlocked), so
+     * this is one primary-key lookup per user per minute, not per request.
+     *
+     * A 401, like an expired token: the client asks /refresh-token for a new
+     * one, which is refused for a blocked user, and signs them out. A lookup
+     * that fails is an error, not a pass.
+     */
+    let isUserBlocked: boolean;
+
+    try {
+      isUserBlocked = await UserService.isUserBlocked(
+        oneuptimeRequest.userAuthorization.userId,
+      );
+    } catch (err) {
+      return Response.sendErrorResponse(req, res, err as Exception);
+    }
+
+    if (isUserBlocked) {
+      if (options.treatInvalidAccessTokenAsAnonymous) {
+        // As for a token that does not decode: the public routes never read who is asking.
+        delete oneuptimeRequest.userAuthorization;
+        oneuptimeRequest.userType = UserType.Public;
+        return next();
+      }
+
+      return Response.sendErrorResponse(
+        req,
+        res,
+        new NotAuthenticatedException(ExceptionMessages.UserBlocked),
+      );
+    }
+
     if (oneuptimeRequest.userAuthorization.isMasterAdmin) {
       oneuptimeRequest.userType = UserType.MasterAdmin;
     } else {
@@ -642,6 +679,7 @@ export default class UserMiddleware {
             req,
             tenantId,
             userId: new ObjectID(userId),
+            userGlobalAccessPermission: userGlobalAccessPermissionPromise,
           }),
           TeamMemberService.getTeamIdsForUser(new ObjectID(userId), tenantId),
         ]);
@@ -689,6 +727,7 @@ export default class UserMiddleware {
             req,
             new ObjectID(userId),
             userGlobalAccessPermission.projectIds,
+            userGlobalAccessPermission,
           );
 
         if (userTenantAccessPermission) {
@@ -876,8 +915,18 @@ export default class UserMiddleware {
     req: ExpressRequest;
     tenantId: ObjectID;
     userId: ObjectID;
+    /*
+     * The user's global permission, when the caller is already resolving it.
+     * AccessTokenService checks the project against it before serving a cached
+     * permission set.
+     */
+    userGlobalAccessPermission?:
+      | Promise<UserGlobalAccessPermission | null>
+      | UserGlobalAccessPermission
+      | null
+      | undefined;
   }): Promise<UserTenantAccessPermission | null> {
-    const { req, tenantId, userId } = data;
+    const { req, tenantId, userId, userGlobalAccessPermission } = data;
 
     const isMasterAdmin: boolean =
       (req as OneUptimeRequest).userAuthorization?.isMasterAdmin === true;
@@ -912,7 +961,9 @@ export default class UserMiddleware {
         }
         throw err;
       }),
-      AccessTokenService.getUserTenantAccessPermission(userId, tenantId),
+      AccessTokenService.getUserTenantAccessPermission(userId, tenantId, {
+        userGlobalAccessPermission,
+      }),
     ]);
 
     /*
@@ -962,6 +1013,8 @@ export default class UserMiddleware {
     req: ExpressRequest,
     userId: ObjectID,
     projectIds: ObjectID[],
+    // The global permission projectIds came from, so each project skips re-reading it.
+    userGlobalAccessPermission?: UserGlobalAccessPermission | null | undefined,
   ): Promise<Dictionary<UserTenantAccessPermission> | null> {
     if (!projectIds.length) {
       return null;
@@ -1042,6 +1095,7 @@ export default class UserMiddleware {
           permission: await AccessTokenService.getUserTenantAccessPermission(
             userId,
             projectId,
+            { userGlobalAccessPermission },
           ),
         };
       }),

package/Server/Services/AIAgentService.ts

@@ -454,6 +454,7 @@ export class Service extends DatabaseService<Model> {
           templateType: EmailTemplateType.AIAgentConnectionStatusChange,
           vars: vars,
           subject: `[AI Agent ${connectionStatus}] ${aiAgent.name}`,
+          isSubjectLiteral: true,
         };
 
         const sms: SMSMessage = {