@oneuptime/common 14.0.11 → 14.0.12

package/Server/Middleware/McpOAuthRateLimit.ts

@@ -0,0 +1,287 @@
+import Redis, { ClientType } from "../Infrastructure/Redis";
+import resolveTrustedClientIp, { ClientIpRequestLike } from "../Utils/ClientIp";
+import {
+  ExpressRequest,
+  ExpressResponse,
+  NextFunction,
+} from "../Utils/Express";
+import logger from "../Utils/Logger";
+
+/*
+ * Rate limiting for the MCP authorization server's endpoints
+ * (/mcp/oauth/...).
+ *
+ * All of them answer callers nobody has identified yet, and each can be made
+ * to do something on request: registration writes a row, authorization can
+ * trigger an outbound fetch of a client metadata document, the token and
+ * revocation endpoints look a secret up, the consent endpoints read a
+ * member's projects. None of the secrets involved can be guessed - they are
+ * 256 bits - so this is load control, not the thing standing between an
+ * attacker and a token.
+ *
+ * One fixed-window counter per bucket per client address, the shape the
+ * on-call calendar feed limiter uses. The budgets are fixed rather than
+ * configurable: they are sized so that no real client comes near them even
+ * with a whole office behind one address (a connected client exchanges a
+ * token about once an hour), and an operator who has to tune them has a
+ * problem a number will not fix.
+ */
+
+export enum McpOAuthRateLimitBucket {
+  // Opening the consent flow. May fetch a client metadata document.
+  Authorize = "authorize",
+
+  // Code exchange and refresh.
+  Token = "token",
+
+  // Dynamic client registration: an anonymous database write.
+  Register = "register",
+
+  Revoke = "revoke",
+
+  // The consent screen's own calls, made with a member's session.
+  Consent = "consent",
+}
+
+export enum McpOAuthRateLimitOutcome {
+  Allowed = "allowed",
+  RateLimited = "rate-limited",
+
+  /* Redis is unreachable, so no limit can be honoured either way. */
+  CounterUnavailable = "counter-unavailable",
+}
+
+export interface McpOAuthRateLimitDecision {
+  outcome: McpOAuthRateLimitOutcome;
+  retryAfterSeconds?: number | undefined;
+
+  /* True only on the request that first crossed the line in this window. */
+  isFirstRejectionInWindow?: boolean | undefined;
+}
+
+interface BucketConfig {
+  windowSeconds: number;
+  limit: number;
+
+  /*
+   * What to do when Redis cannot be reached. Registration is the one
+   * endpoint that writes for an anonymous caller, so without a counter it is
+   * refused rather than left unbounded. Everything else is let through: a
+   * Redis blip must not sign every connected client out.
+   */
+  failClosed: boolean;
+}
+
+const WINDOW_SECONDS: number = 15 * 60;
+
+const BUCKET_CONFIG: Record<McpOAuthRateLimitBucket, BucketConfig> = {
+  [McpOAuthRateLimitBucket.Authorize]: {
+    windowSeconds: WINDOW_SECONDS,
+    limit: 300,
+    failClosed: false,
+  },
+  [McpOAuthRateLimitBucket.Token]: {
+    windowSeconds: WINDOW_SECONDS,
+    limit: 1200,
+    failClosed: false,
+  },
+  [McpOAuthRateLimitBucket.Register]: {
+    windowSeconds: WINDOW_SECONDS,
+    limit: 60,
+    failClosed: true,
+  },
+  [McpOAuthRateLimitBucket.Revoke]: {
+    windowSeconds: WINDOW_SECONDS,
+    limit: 600,
+    failClosed: false,
+  },
+  [McpOAuthRateLimitBucket.Consent]: {
+    windowSeconds: WINDOW_SECONDS,
+    limit: 600,
+    failClosed: false,
+  },
+};
+
+const KEY_PREFIX: string = "mcpoauth:rl:";
+
+/*
+ * Counter keys outlive their window by one full window, so a request landing
+ * on a boundary cannot read a key that was reclaimed mid-window.
+ */
+const TTL_MULTIPLIER: number = 2;
+
+/* Bounds a Redis key built from a caller-influenced address. */
+const MAX_KEY_SEGMENT_LENGTH: number = 64;
+
+/* How often the "counter unavailable" condition may be logged. */
+const COUNTER_UNAVAILABLE_LOG_INTERVAL_MS: number = 60 * 1000;
+
+export type McpOAuthRateLimitRejectionHandler = (data: {
+  req: ExpressRequest;
+  res: ExpressResponse;
+  statusCode: number;
+  retryAfterSeconds?: number | undefined;
+}) => void;
+
+export default class McpOAuthRateLimit {
+  private static counterUnavailableLastLoggedAt: number = 0;
+
+  public static getLimit(bucket: McpOAuthRateLimitBucket): number {
+    return BUCKET_CONFIG[bucket].limit;
+  }
+
+  /*
+   * The client address to bill this request to: read from the trusted end of
+   * X-Forwarded-For under TRUSTED_PROXY_HOPS, never the leftmost entry, which
+   * the caller writes themselves - a spoofed value per request would be a
+   * fresh bucket per request and no limit at all.
+   */
+  public static resolveClientIp(req: ExpressRequest): string {
+    const clientIp: string | undefined = resolveTrustedClientIp(
+      req as unknown as ClientIpRequestLike,
+    );
+
+    if (!clientIp) {
+      // Unidentifiable callers share one bucket: the conservative direction.
+      return "unknown";
+    }
+
+    return clientIp
+      .slice(0, MAX_KEY_SEGMENT_LENGTH)
+      .replace(/[^a-zA-Z0-9._:%\-[\]]/g, "_");
+  }
+
+  public static async consume(data: {
+    bucket: McpOAuthRateLimitBucket;
+    clientIp: string;
+  }): Promise<McpOAuthRateLimitDecision> {
+    const client: ClientType | null = Redis.getClient();
+
+    if (!client || !Redis.isConnected()) {
+      return { outcome: McpOAuthRateLimitOutcome.CounterUnavailable };
+    }
+
+    const config: BucketConfig = BUCKET_CONFIG[data.bucket];
+    const windowMs: number = config.windowSeconds * 1000;
+    const windowIndex: number = Math.floor(Date.now() / windowMs);
+    const counterKey: string = `${KEY_PREFIX}${data.bucket}:${data.clientIp}:${windowIndex}`;
+
+    try {
+      const count: unknown = await client.incr(counterKey);
+
+      if (typeof count !== "number") {
+        throw new Error("Rate limit counter returned a non-numeric value");
+      }
+
+      /*
+       * The expiry is set only by the write that created the key. Re-issuing
+       * it on every increment would slide the window for as long as the load
+       * continued, and a caller that tripped the limit once could never
+       * recover.
+       */
+      if (count === 1) {
+        await client.expire(counterKey, config.windowSeconds * TTL_MULTIPLIER);
+      }
+
+      if (count > config.limit) {
+        return {
+          outcome: McpOAuthRateLimitOutcome.RateLimited,
+          retryAfterSeconds: Math.max(
+            1,
+            Math.ceil((windowMs - (Date.now() % windowMs)) / 1000),
+          ),
+          isFirstRejectionInWindow: count === config.limit + 1,
+        };
+      }
+
+      return { outcome: McpOAuthRateLimitOutcome.Allowed };
+    } catch (err) {
+      if (McpOAuthRateLimit.shouldLogCounterUnavailable()) {
+        logger.warn(
+          `McpOAuthRateLimit: counter failed for a ${data.bucket} request from ${data.clientIp}`,
+        );
+        logger.warn(err);
+      }
+
+      return { outcome: McpOAuthRateLimitOutcome.CounterUnavailable };
+    }
+  }
+
+  /*
+   * Express middleware for one bucket. `onRejected` writes the refusal,
+   * because the endpoints do not share a body format: the OAuth ones answer
+   * `{ error, error_description }`, the consent ones the API's `{ message }`.
+   */
+  public static getMiddleware(
+    bucket: McpOAuthRateLimitBucket,
+    onRejected: McpOAuthRateLimitRejectionHandler,
+  ): (
+    req: ExpressRequest,
+    res: ExpressResponse,
+    next: NextFunction,
+  ) => Promise<void> {
+    return async (
+      req: ExpressRequest,
+      res: ExpressResponse,
+      next: NextFunction,
+    ): Promise<void> => {
+      const clientIp: string = McpOAuthRateLimit.resolveClientIp(req);
+
+      const decision: McpOAuthRateLimitDecision =
+        await McpOAuthRateLimit.consume({ bucket, clientIp });
+
+      if (decision.outcome === McpOAuthRateLimitOutcome.RateLimited) {
+        if (decision.retryAfterSeconds) {
+          res.setHeader("Retry-After", String(decision.retryAfterSeconds));
+        }
+
+        // One line per address per window, not one per refused request.
+        if (decision.isFirstRejectionInWindow) {
+          logger.warn(
+            `McpOAuthRateLimit: rejected ${bucket} requests from ${clientIp}`,
+          );
+        }
+
+        return onRejected({
+          req,
+          res,
+          statusCode: 429,
+          retryAfterSeconds: decision.retryAfterSeconds,
+        });
+      }
+
+      if (decision.outcome === McpOAuthRateLimitOutcome.CounterUnavailable) {
+        if (BUCKET_CONFIG[bucket].failClosed) {
+          return onRejected({ req, res, statusCode: 503 });
+        }
+
+        if (McpOAuthRateLimit.shouldLogCounterUnavailable()) {
+          logger.warn(
+            `McpOAuthRateLimit: rate limit counter unavailable, allowing ${bucket} requests unthrottled`,
+          );
+        }
+      }
+
+      return next();
+    };
+  }
+
+  /*
+   * A Redis outage sends EVERY request down the unavailable path, so an
+   * unguarded log line there is one per request for as long as it lasts.
+   */
+  private static shouldLogCounterUnavailable(): boolean {
+    const now: number = Date.now();
+
+    if (
+      now - McpOAuthRateLimit.counterUnavailableLastLoggedAt <
+      COUNTER_UNAVAILABLE_LOG_INTERVAL_MS
+    ) {
+      return false;
+    }
+
+    McpOAuthRateLimit.counterUnavailableLastLoggedAt = now;
+
+    return true;
+  }
+}

package/Server/Middleware/ProjectAuthorization.ts

@@ -1,4 +1,4 @@
-import ApiKeyService from "../Services/ApiKeyService";
+import ApiKeyService, { ResolvedApiKey } from "../Services/ApiKeyService";
 import GlobalConfigService from "../Services/GlobalConfigService";
 import UserService from "../Services/UserService";
 import {
@@ -19,6 +19,14 @@ import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import SpanUtil from "../Utils/Telemetry/SpanUtil";
 
 export default class ProjectMiddleware {
+  /*
+   * What the audit trail calls the instance-wide master API key. It has no
+   * row in ApiKey - it is a column on GlobalConfig - so there is no id or
+   * name to record, and without a label a change made with it reads as the
+   * master admin user having made it by hand.
+   */
+  public static readonly MASTER_API_KEY_AUDIT_NAME: string = "Master API Key";
+
   @CaptureSpan()
   public static getProjectId(req: ExpressRequest): ObjectID | null {
     let projectId: ObjectID | null = null;
@@ -189,7 +197,7 @@ export default class ProjectMiddleware {
        * Cached lookup — see ApiKeyService.findApiKey. Hot path for any
        * automated caller hitting the API by key.
        */
-      const apiKeyRow: { id: ObjectID; projectId: ObjectID } | null =
+      const apiKeyRow: ResolvedApiKey | null =
         await ApiKeyService.findApiKey(apiKey);
 
       if (apiKeyRow) {
@@ -198,6 +206,17 @@ export default class ProjectMiddleware {
         (req as OneUptimeRequest).tenantId = tenantId;
         (req as OneUptimeRequest).userType = UserType.API;
 
+        /*
+         * Which key this is, for the audit trail. A key request carries no
+         * userId, so these two are the only thing that lets an audit entry
+         * tell one key's changes from another's. Nothing below reads them.
+         */
+        (req as OneUptimeRequest).apiKeyId = apiKeyRow.id;
+
+        if (apiKeyRow.name) {
+          (req as OneUptimeRequest).apiKeyName = apiKeyRow.name;
+        }
+
         /*
          * The two halves of an API key's authority. The global half is the
          * fixed marker set every key carries (see APIKeyAccessPermission); the
@@ -233,6 +252,8 @@ export default class ProjectMiddleware {
 
         if (isMasterApiKey) {
           (req as OneUptimeRequest).userType = UserType.MasterAdmin;
+          (req as OneUptimeRequest).apiKeyName =
+            ProjectMiddleware.MASTER_API_KEY_AUDIT_NAME;
 
           // get master admin user
 

package/Server/Middleware/UserAuthorization.ts

@@ -14,6 +14,7 @@ import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import JSONWebToken from "../Utils/JsonWebToken";
 import logger, { getLogAttributesFromRequest } from "../Utils/Logger";
 import Response from "../Utils/Response";
+import McpDelegationAuthorization from "./McpDelegationAuthorization";
 import ProjectMiddleware from "./ProjectAuthorization";
 import SpanUtil from "../Utils/Telemetry/SpanUtil";
 import Dictionary from "../../Types/Dictionary";
@@ -540,6 +541,17 @@ export default class UserMiddleware {
     next: NextFunction,
     options: { treatInvalidAccessTokenAsAnonymous: boolean },
   ): Promise<void> {
+    /*
+     * A request the MCP server makes for a member who connected a client with
+     * OAuth. Claimed before anything else is read: its project comes from the
+     * credential, so not even the tenant header below is to be trusted, and a
+     * request that presents this credential must be answered as that - never
+     * quietly authenticated some other way, or as nobody.
+     */
+    if (McpDelegationAuthorization.hasDelegationToken(req)) {
+      return await McpDelegationAuthorization.authorize(req, res, next);
+    }
+
     const tenantId: ObjectID | null = ProjectMiddleware.getProjectId(req);
     const oneuptimeRequest: OneUptimeRequest = req as OneUptimeRequest;
 

package/Server/Services/AIService.ts

@@ -781,8 +781,8 @@ export class Service extends BaseService {
 
       if (budget.exhausted) {
         const settingsLocation: string = request.incidentId
-          ? "Incidents > AI > Investigation"
-          : "Alerts > AI > Investigation";
+          ? "Incidents > Settings > AI"
+          : "Alerts > Settings > AI";
         const budgetMessage: string = `Daily autonomous AI token budget exhausted (${budget.usedTokensToday.toLocaleString()} of ${budget.limitInTokens?.toLocaleString()} tokens used today). Autonomous AI requests resume tomorrow (UTC) — raise or unset the limit under ${settingsLocation}.`;
 
         logEntry.status = LlmLogStatus.BudgetExceeded;

package/Server/Services/AnalyticsDatabaseService.ts

@@ -56,6 +56,7 @@ import Route from "../../Types/API/Route";
 import URL from "../../Types/API/URL";
 import AnalyticsTableColumn from "../../Types/AnalyticsDatabase/TableColumn";
 import TableColumnType from "../../Types/AnalyticsDatabase/TableColumnType";
+import DatabaseCommonInteractionPropsUtil from "../../Types/BaseDatabase/DatabaseCommonInteractionPropsUtil";
 import SortOrder from "../../Types/BaseDatabase/SortOrder";
 import OneUptimeDate from "../../Types/Date";
 import BadDataException from "../../Types/Exception/BadDataException";
@@ -1200,13 +1201,16 @@ export default class AnalyticsDatabaseService<
   }
 
   /**
-   * Read-side retention filter. TTL is `retentionDate DELETE` with
-   * ttl_only_drop_parts=1, so a part survives until EVERY row in it has
-   * expired — rows past their per-service retention stay on disk (and
-   * were queryable) for up to a partition's worth of extra time. For
+   * Read-side retention filter. TTL deletes rows by `retentionDate`, and
+   * ClickHouse applies it only when it merges: on a table with
+   * ttl_only_drop_parts=1 a part survives until EVERY row in it has
+   * expired, and on the metric and log tables, whose TTL is rounded up
+   * to the midnight after retentionDate (RetentionTtl), an expired row
+   * survives until that midnight - up to a day. Either way rows past
+   * their retention stay on disk (and were queryable) for a while. For
    * models that carry a retentionDate column, every centrally generated
    * read appends this predicate so expired rows become invisible the
-   * moment they expire rather than when their part finally drops.
+   * moment they expire rather than when they are finally removed.
    *
    * Returns the raw SQL fragment (server-evaluated now(), no parameter)
    * or "" when the model has no retentionDate column.
@@ -1904,6 +1908,11 @@ export default class AnalyticsDatabaseService<
 
   private async _deleteBy(deleteBy: DeleteBy<TBaseModel>): Promise<void> {
     try {
+      // Refused before any hook runs; see assertCredentialCanWrite.
+      DatabaseCommonInteractionPropsUtil.assertCredentialCanWrite(
+        deleteBy.props,
+      );
+
       const onDelete: OnDelete<TBaseModel> = deleteBy.props.ignoreHooks
         ? { deleteBy, carryForward: [] }
         : await this.onBeforeDelete(deleteBy);
@@ -1965,6 +1974,11 @@ export default class AnalyticsDatabaseService<
 
   private async _updateBy(updateBy: UpdateBy<TBaseModel>): Promise<void> {
     try {
+      // Refused before any hook runs; see assertCredentialCanWrite.
+      DatabaseCommonInteractionPropsUtil.assertCredentialCanWrite(
+        updateBy.props,
+      );
+
       const onUpdate: OnUpdate<TBaseModel> = updateBy.props.ignoreHooks
         ? { updateBy, carryForward: [] }
         : await this.onBeforeUpdate(updateBy);
@@ -2222,6 +2236,9 @@ export default class AnalyticsDatabaseService<
   public async createMany(
     createBy: CreateManyBy<TBaseModel>,
   ): Promise<Array<TBaseModel>> {
+    // Refused before any hook runs; see assertCredentialCanWrite.
+    DatabaseCommonInteractionPropsUtil.assertCredentialCanWrite(createBy.props);
+
     // add tenantId if present.
     const tenantColumnName: string | null =
       this.model.getTenantColumn()?.key || null;

package/Server/Services/ApiKeyService.ts

@@ -25,12 +25,26 @@ const NEGATIVE_TTL_MS: number = 10 * 1000;
 interface CachedApiKey {
   id: string;
   projectId: string;
+  name: string | null;
+}
+
+export interface ResolvedApiKey {
+  id: ObjectID;
+  projectId: ObjectID;
+
+  /*
+   * The key's display name, for the audit trail: "which key did this" is
+   * answered by a name an administrator recognises, not by an id. Never part
+   * of an authorization decision. Up to a minute stale on other nodes after
+   * a rename, like everything else this cache holds.
+   */
+  name?: string | undefined;
 }
 
 export class Service extends DatabaseService<Model> {
   /*
-   * Cache of `apiKey -> { id, projectId }`. The project-auth middleware hits
-   * this on every API-key-authenticated request; without it that's a
+   * Cache of `apiKey -> { id, projectId, name }`. The project-auth middleware
+   * hits this on every API-key-authenticated request; without it that's a
    * Postgres findOneBy per request for automated callers.
    */
   private apiKeyCache: InMemoryTTLCache<CachedApiKey | null> =
@@ -75,9 +89,7 @@ export class Service extends DatabaseService<Model> {
    * calling `findOneBy` directly.
    */
   @CaptureSpan()
-  public async findApiKey(
-    apiKey: ObjectID,
-  ): Promise<{ id: ObjectID; projectId: ObjectID } | null> {
+  public async findApiKey(apiKey: ObjectID): Promise<ResolvedApiKey | null> {
     const cacheKey: string = apiKey.toString();
     const cached: CachedApiKey | null | undefined =
       this.apiKeyCache.get(cacheKey);
@@ -88,6 +100,7 @@ export class Service extends DatabaseService<Model> {
       return {
         id: new ObjectID(cached.id),
         projectId: new ObjectID(cached.projectId),
+        ...(cached.name ? { name: cached.name } : {}),
       };
     }
 
@@ -99,6 +112,7 @@ export class Service extends DatabaseService<Model> {
       select: {
         _id: true,
         projectId: true,
+        name: true,
       },
       props: { isRoot: true },
     });
@@ -108,12 +122,22 @@ export class Service extends DatabaseService<Model> {
       return null;
     }
 
+    const name: string | null = row.name ? row.name.toString() : null;
+
     this.apiKeyCache.set(
       cacheKey,
-      { id: row.id.toString(), projectId: row.projectId.toString() },
+      {
+        id: row.id.toString(),
+        projectId: row.projectId.toString(),
+        name,
+      },
       POSITIVE_TTL_MS,
     );
-    return { id: row.id, projectId: row.projectId };
+    return {
+      id: row.id,
+      projectId: row.projectId,
+      ...(name ? { name } : {}),
+    };
   }
 }
 

package/Server/Services/AutoRemediationRuleEngineService.ts

@@ -1160,20 +1160,20 @@ class AutoRemediationRuleEngineServiceClass {
     alert?: Alert | undefined;
   }): Promise<void> {
     /*
-     * Project-level kill switch. === false so a missing column (older rows,
-     * self-hosted defaults) counts as enabled — same semantics as enableAi.
+     * Project-level kill switch: Enable AI, the project's only AI switch,
+     * stops every lane below — cluster and resource rounds, AI rules and
+     * deterministic runbook rules alike. === false because the column is
+     * NOT NULL DEFAULT true: undefined means "not selected", never "off".
      */
     const project: Project | null = await ProjectService.findOneById({
       id: data.projectId,
       select: {
         enableAi: true,
-        enableAutoRemediation: true,
-        enableAiCommandExecution: true,
       },
       props: { isRoot: true },
     });
 
-    if (!project || project.enableAutoRemediation === false) {
+    if (!project || project.enableAi === false) {
       return;
     }
 
@@ -1326,7 +1326,10 @@ class AutoRemediationRuleEngineServiceClass {
         }),
     );
 
-    // Lazily evaluated once: AI rules need AI enabled and a provider.
+    /*
+     * Lazily evaluated once: AI rules need a provider. AI itself is on —
+     * the kill switch above already returned otherwise.
+     */
     let aiAvailable: boolean | null = null;
 
     for (const rule of matchedRules) {
@@ -1345,7 +1348,6 @@ class AutoRemediationRuleEngineServiceClass {
       if (rule.aiComposesCommands) {
         if (aiAvailable === null) {
           aiAvailable =
-            project.enableAi !== false &&
             (await LlmProviderService.getLLMProviderForProject(
               data.projectId,
             )) !== null;
@@ -1353,20 +1355,7 @@ class AutoRemediationRuleEngineServiceClass {
 
         if (!aiAvailable) {
           logger.debug(
-            `AutoRemediationRuleEngine: skipping AI command rule ${rule.id?.toString()} — AI disabled or no LLM provider configured.`,
-            { projectId: data.projectId.toString() } as LogAttributes,
-          );
-          continue;
-        }
-
-        /*
-         * Opt-in semantics (=== true): the project must have explicitly
-         * enabled AI command execution, on top of the AI/auto-remediation
-         * kill switches.
-         */
-        if (project.enableAiCommandExecution !== true) {
-          logger.debug(
-            `AutoRemediationRuleEngine: skipping AI command rule ${rule.id?.toString()} — the project has not enabled AI command execution.`,
+            `AutoRemediationRuleEngine: skipping AI command rule ${rule.id?.toString()} — no LLM provider configured.`,
             { projectId: data.projectId.toString() } as LogAttributes,
           );
           continue;
@@ -1384,7 +1373,6 @@ class AutoRemediationRuleEngineServiceClass {
       if (rule.aiSelectsRunbook) {
         if (aiAvailable === null) {
           aiAvailable =
-            project.enableAi !== false &&
             (await LlmProviderService.getLLMProviderForProject(
               data.projectId,
             )) !== null;
@@ -1392,7 +1380,7 @@ class AutoRemediationRuleEngineServiceClass {
 
         if (!aiAvailable) {
           logger.debug(
-            `AutoRemediationRuleEngine: skipping AI rule ${rule.id?.toString()} — AI disabled or no LLM provider configured.`,
+            `AutoRemediationRuleEngine: skipping AI rule ${rule.id?.toString()} — no LLM provider configured.`,
             { projectId: data.projectId.toString() } as LogAttributes,
           );
           continue;
@@ -1673,11 +1661,11 @@ class AutoRemediationRuleEngineServiceClass {
     try {
       const project: Project | null = await ProjectService.findOneById({
         id: data.projectId,
-        select: { enableAutoRemediation: true },
+        select: { enableAi: true },
         props: { isRoot: true },
       });
 
-      if (!project || project.enableAutoRemediation === false) {
+      if (!project || project.enableAi === false) {
         return false;
       }
 
@@ -2061,11 +2049,11 @@ class AutoRemediationRuleEngineServiceClass {
 
       const project: Project | null = await ProjectService.findOneById({
         id: data.projectId,
-        select: { enableAutoRemediation: true },
+        select: { enableAi: true },
         props: { isRoot: true },
       });
 
-      if (!project || project.enableAutoRemediation === false) {
+      if (!project || project.enableAi === false) {
         return false;
       }
 

package/Server/Services/AutoRemediationRuleService.ts

@@ -121,7 +121,7 @@ export class Service extends DatabaseService<Model> {
   }
 
   public static getAgentCommandRunnerRefusal(runner: Runner): string {
-    return `Runner "${runner.name}" is the in-cluster Runner the Kubernetes agent chart installed. It runs kubectl for its own cluster only, never the Bash or SSH commands a rule composes, so it cannot be one of this rule's Command Runners. OneUptime AI reaches that cluster through its Kubernetes AI agent instead (the cluster's AI → Agent page). Choose Runners you created under Project Settings → Runners, or leave Command Runners empty to allow any Runner with AI commands enabled.`;
+    return `Runner "${runner.name}" is the in-cluster Runner the Kubernetes agent chart installed. It runs kubectl for its own cluster only, never the Bash or SSH commands a rule composes, so it cannot be one of this rule's Command Runners. OneUptime AI reaches that cluster through its Kubernetes AI agent instead (the cluster's AI → Agent page). Choose Runners you created under Runbooks → Runners, or leave Command Runners empty to allow any Runner with AI commands enabled.`;
   }
 }
 

package/Server/Services/DashboardService.ts

@@ -154,11 +154,16 @@ export class Service extends DatabaseService<Model> {
           ipWhitelist: true,
           enableMasterPassword: true,
           masterPassword: true,
+          isArchived: true,
         },
       });
 
-      // If dashboard is not public, deny access
-      if (dashboard && !dashboard.isPublicDashboard) {
+      /*
+       * If dashboard is not public, deny access. An archived dashboard is
+       * not public either, whatever its public setting says: the setting is
+       * kept so unarchiving puts the public link back exactly as it was.
+       */
+      if (dashboard && (!dashboard.isPublicDashboard || dashboard.isArchived)) {
         return {
           hasReadAccess: false,
           error: new NotAuthenticatedException(