@oneuptime/common 11.5.8 → 11.5.9

package/Server/Services/AIRunService.ts

@@ -12,12 +12,15 @@ import CodeFixTaskType, {
 import SortOrder from "../../Types/BaseDatabase/SortOrder";
 import QueryHelper from "../Types/Database/QueryHelper";
 import CountBy from "../Types/Database/CountBy";
+import CreateBy from "../Types/Database/CreateBy";
 import FindBy from "../Types/Database/FindBy";
-import { OnFind } from "../Types/Database/Hooks";
+import { OnCreate, OnFind } from "../Types/Database/Hooks";
 import DatabaseService from "./DatabaseService";
+import ProjectService from "./ProjectService";
 import Model from "../../Models/DatabaseModels/AIRun";
 import { applyAIRunPrivacyFilter } from "../Utils/AI/AIRunPrivacyFilter";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import logger from "../Utils/Logger";
 import { UpdateQueryBuilder, UpdateResult } from "typeorm";
 import { QueryDeepPartialEntity } from "typeorm/query-builder/QueryPartialEntity";
 
@@ -328,6 +331,40 @@ export class Service extends DatabaseService<Model> {
     return { runId: run.id, verdict: data.verdict };
   }
 
+  /*
+   * Stamp CodeFix runs with the project's next task number, so every AI task
+   * has the short human-citable handle "#42" that incidents and alerts have.
+   *
+   * CodeFix only, on purpose: chat turns and investigations share this table
+   * but are not tasks, and numbering them would advance the counter on every
+   * Ask-AI message — the AI Tasks list would then read #7, #31, #244.
+   *
+   * Best-effort. The counter needs Redis (Semaphore) and a second write; a
+   * blip there must not lose a fix run, because the number is a display
+   * convenience and the run itself is the work. On failure the run is created
+   * with a null taskNumber, which the list renders as "-" and the detail page
+   * hides — the run stays fully usable, just uncitable.
+   */
+  protected override async onBeforeCreate(
+    createBy: CreateBy<Model>,
+  ): Promise<OnCreate<Model>> {
+    const projectId: ObjectID | undefined =
+      createBy.data.projectId || createBy.props.tenantId || undefined;
+
+    if (createBy.data.runType === AIRunType.CodeFix && projectId) {
+      try {
+        createBy.data.taskNumber =
+          await ProjectService.incrementAndGetAIRunCounter(projectId);
+      } catch (error) {
+        logger.error(
+          `Could not allocate a task number for a code-fix run in project ${projectId.toString()}; creating it unnumbered: ${error}`,
+        );
+      }
+    }
+
+    return { createBy, carryForward: null };
+  }
+
   protected override async onBeforeFind(
     findBy: FindBy<Model>,
   ): Promise<OnFind<Model>> {

package/Server/Services/LlmProviderService.ts

@@ -333,6 +333,7 @@ export class Service extends DatabaseService<Model> {
           select: {
             _id: true,
             name: true,
+            description: true,
             llmType: true,
             modelName: true,
             isDefault: true,
@@ -356,6 +357,7 @@ export class Service extends DatabaseService<Model> {
           select: {
             _id: true,
             name: true,
+            description: true,
             llmType: true,
             modelName: true,
             isDefault: true,

package/Server/Services/ProjectService.ts

@@ -2144,6 +2144,48 @@ export class ProjectService extends DatabaseService<Model> {
     }
   }
 
+  /*
+   * Allocate the next AI task number for a project. Unlike the counters
+   * above there is no companion prefix column — AI task numbers are not
+   * user-customizable, so the caller renders a plain "#N".
+   */
+  @CaptureSpan()
+  public async incrementAndGetAIRunCounter(
+    projectId: ObjectID,
+  ): Promise<number> {
+    const mutex: SemaphoreMutex = await Semaphore.lock({
+      key: projectId.toString(),
+      namespace: "ProjectService.aiRunCounter",
+    });
+
+    try {
+      await this.atomicIncrementColumnValueByOne({
+        id: projectId,
+        columnName: "aiRunCounter",
+      });
+
+      const project: Model | null = await this.findOneById({
+        id: projectId,
+        select: {
+          aiRunCounter: true,
+        },
+        props: {
+          isRoot: true,
+        },
+      });
+
+      if (!project || project.aiRunCounter === undefined) {
+        throw new BadDataException(
+          `Could not read aiRunCounter for project ${projectId.toString()}`,
+        );
+      }
+
+      return project.aiRunCounter;
+    } finally {
+      await Semaphore.release(mutex);
+    }
+  }
+
   @CaptureSpan()
   public async isSMSNotificationsEnabled(
     projectId: ObjectID,

package/Server/Services/StatusPageService.ts

@@ -118,6 +118,93 @@ export class Service extends DatabaseService<StatusPage> {
     this.statusPageUrlCache.clear();
   }
 
+  /*
+   * Mirrors `resolveStatusPageIdOrThrow` in `Common/Server/API/StatusPageAPI.ts`
+   * (module-private there), but returns null instead of throwing so callers can
+   * collapse "no such page" and "page exists but is gated" into one answer.
+   * The dot check — not a UUID check — is the discriminator, so both resolvers
+   * agree on dotless hostnames like "localhost".
+   */
+  @CaptureSpan()
+  public async resolveStatusPageIdOrNull(
+    statusPageIdOrDomain: string,
+  ): Promise<ObjectID | null> {
+    if (!statusPageIdOrDomain) {
+      return null;
+    }
+
+    if (statusPageIdOrDomain.includes(".")) {
+      const statusPageDomain: StatusPageDomain | null =
+        await StatusPageDomainService.findOneBy({
+          query: {
+            fullDomain: statusPageIdOrDomain,
+            domain: {
+              isVerified: true,
+            } as any,
+          },
+          select: {
+            statusPageId: true,
+          },
+          props: {
+            isRoot: true,
+          },
+        });
+
+      if (!statusPageDomain || !statusPageDomain.statusPageId) {
+        return null;
+      }
+
+      return statusPageDomain.statusPageId;
+    }
+
+    try {
+      ObjectID.validateUUID(statusPageIdOrDomain);
+      return new ObjectID(statusPageIdOrDomain);
+    } catch (err) {
+      logger.error(
+        `Error converting statusPageIdOrDomain to ObjectID: ${statusPageIdOrDomain}`,
+      );
+      logger.error(err);
+      return null;
+    }
+  }
+
+  /*
+   * Folds existence and the `enableMcpServer` flag into a single query so the
+   * caller cannot distinguish "not found" from "disabled". The public MCP tools
+   * need no API key, so a distinct "disabled" message would be a status page
+   * enumeration oracle.
+   *
+   * Throws on database failure rather than returning false, so the caller
+   * reports an error instead of reporting the page as gated.
+   */
+  @CaptureSpan()
+  public async isMcpServerEnabled(
+    statusPageIdOrDomain: string,
+  ): Promise<boolean> {
+    const statusPageId: ObjectID | null =
+      await this.resolveStatusPageIdOrNull(statusPageIdOrDomain);
+
+    if (!statusPageId) {
+      return false;
+    }
+
+    const statusPage: StatusPage | null = await this.findOneBy({
+      query: {
+        _id: statusPageId,
+        enableMcpServer: true,
+      },
+      select: {
+        _id: true,
+      },
+      props: {
+        isRoot: true,
+      },
+    });
+
+    return Boolean(statusPage);
+  }
+
   public static getDefaultEmailFooterText(): string {
     return "This is an automated email sent to you because you are subscribed to this Status Page.";
   }

package/Server/Services/TelemetryExceptionService.ts

@@ -13,20 +13,18 @@ import CodeFixTaskType, {
 import DatabaseCommonInteractionProps from "../../Types/BaseDatabase/DatabaseCommonInteractionProps";
 import AIRunService from "./AIRunService";
 import FixRunBudget from "../Utils/AI/CodeFix/FixRunBudget";
-import AIAgentService from "./AIAgentService";
-import LlmProviderService from "./LlmProviderService";
-import ProjectService from "./ProjectService";
+import CodeFixReadiness from "../Utils/AI/CodeFix/CodeFixReadiness";
 import ServiceService from "./ServiceService";
 import CodeRepositoryService from "./CodeRepositoryService";
 import { RepoResolution } from "../Utils/CodeRepository/StackTraceRepoResolver";
-import AIAgent from "../../Models/DatabaseModels/AIAgent";
-import LlmProvider from "../../Models/DatabaseModels/LlmProvider";
-import Project from "../../Models/DatabaseModels/Project";
+import {
+  AIFixReadiness,
+  AIFixReadinessCheck,
+} from "../../Types/AI/AIFixReadiness";
 import TelemetryService from "../../Models/DatabaseModels/Service";
 import QueryHelper from "../Types/Database/QueryHelper";
 import ModelPermission from "../Types/Database/Permissions/Index";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
-import { IsBillingEnabled } from "../EnvironmentConfig";
 import Query from "../Types/Database/Query";
 import Includes from "../../Types/BaseDatabase/Includes";
 import logger from "../Utils/Logger";
@@ -46,24 +44,6 @@ export interface CreateCodeFixRunForExceptionParams {
   taskType?: CodeFixTaskType | undefined;
 }
 
-export type AIFixReadinessCheckId =
-  | "llmProvider"
-  | "repositoryResolved"
-  | "agentAvailable";
-
-export interface AIFixReadinessCheck {
-  id: AIFixReadinessCheckId;
-  ok: boolean;
-  title: string;
-  // Shown to the user when ok is false — says exactly what to do next.
-  detail: string;
-}
-
-export interface AIFixReadiness {
-  ready: boolean;
-  checks: Array<AIFixReadinessCheck>;
-}
-
 export interface DashboardServiceSummary {
   /*
    * Polymorphic: a real Service, a Host/DockerHost/KubernetesCluster id, or
@@ -124,55 +104,16 @@ export class Service extends DatabaseService<Model> {
     const projectId: ObjectID = telemetryException.projectId;
 
     /*
-     * 1. An LLM provider the agent may use. Agent completions are
-     * server-mediated and metered (B4 Tier 0), so the shared global
-     * provider is a valid fallback on cloud too — a project-owned provider
-     * simply wins when one exists.
-     */
-    const llmProvider: LlmProvider | null =
-      await LlmProviderService.getLlmProviderForMeteredAgentPath(projectId);
-
-    let llmOk: boolean = Boolean(llmProvider);
-    let llmDetail: string = llmOk
-      ? ""
-      : "AI fix tasks need an LLM provider. Add one in Project Settings > AI > LLM Providers. Self-hosted instances can alternatively set the GLOBAL_LLM_PROVIDER_* environment variables to register a global provider for every project.";
-
-    /*
-     * A resolved provider must also be PAYABLE, or the run passes readiness
-     * here and dies at its first completion call instead. Mirrors the
-     * billing gate in AIService.executeWithLogging: only a COSTED global
-     * provider on cloud bills the project's AI balance per call —
-     * project-owned and free-global providers consume no balance and must
-     * not require one.
+     * 1. An LLM provider the agent may use — the same gate the project-wide
+     * AI Tasks page renders, so the two surfaces can never disagree about
+     * whether this project has a usable provider.
      */
-    const billingEnabled: boolean = params.billingEnabled ?? IsBillingEnabled;
-
-    if (
-      llmProvider &&
-      billingEnabled &&
-      (llmProvider.isGlobalLlm || false) &&
-      (llmProvider.costPerMillionTokensInUSDCents || 0) > 0
-    ) {
-      const project: Project | null = await ProjectService.findOneById({
-        id: projectId,
-        select: { aiCurrentBalanceInUSDCents: true },
-        props: { isRoot: true },
+    const llmCheck: AIFixReadinessCheck =
+      await CodeFixReadiness.getLlmProviderCheck({
+        projectId,
+        billingEnabled: params.billingEnabled,
       });
 
-      if (!project || (project.aiCurrentBalanceInUSDCents || 0) <= 0) {
-        llmOk = false;
-        llmDetail =
-          "AI fix tasks would use the OneUptime-hosted LLM provider, which is billed against your AI balance — and the project's balance is empty. Recharge it in Project Settings > AI Credits, or add your own LLM provider in Project Settings > AI > LLM Providers.";
-      }
-    }
-
-    const llmCheck: AIFixReadinessCheck = {
-      id: "llmProvider",
-      ok: llmOk,
-      title: "LLM provider",
-      detail: llmDetail,
-    };
-
     /*
      * 2. A repository must RESOLVE for this exception — computed at runtime
      * from the stack trace (path matching over connected repos), falling
@@ -223,25 +164,11 @@ export class Service extends DatabaseService<Model> {
       };
     }
 
-    // 4. An agent must be alive to pick the task up.
-    const anyAgent: AIAgent | null =
-      await AIAgentService.getAIAgentForProject(projectId);
-    const connectedAgent: AIAgent | null = anyAgent
-      ? AIAgentService.isAgentAlive(anyAgent)
-        ? anyAgent
-        : null
-      : null;
-
-    const agentCheck: AIFixReadinessCheck = {
-      id: "agentAvailable",
-      ok: Boolean(connectedAgent),
-      title: "AI agent online",
-      detail: connectedAgent
-        ? ""
-        : anyAgent
-          ? `The AI agent "${anyAgent.name || "agent"}" has not reported in — check that its container is running.`
-          : "No AI agent is available for this project. Self-hosted: create an agent under Settings > AI > AI Agents and run its container. Cloud: the shared fleet appears here automatically once enabled.",
-    };
+    // 3. An agent must be alive to pick the task up.
+    const agentCheck: AIFixReadinessCheck =
+      await CodeFixReadiness.getAgentCheck({
+        projectId,
+      });
 
     const checks: Array<AIFixReadinessCheck> = [
       llmCheck,
@@ -387,8 +314,10 @@ export class Service extends DatabaseService<Model> {
           taskType === CodeFixTaskType.FixException
             ? QueryHelper.equalToOrNull(CodeFixTaskType.FixException)
             : taskType,
+        // Every terminal status — see AIRunStatusHelper.isTerminalStatus.
         status: QueryHelper.notIn([
           AIRunStatus.Completed,
+          AIRunStatus.NoFixFound,
           AIRunStatus.Error,
           AIRunStatus.Cancelled,
           AIRunStatus.Stale,

package/Server/Types/Markdown.ts

@@ -1,5 +1,6 @@
 import { Renderer, marked } from "marked";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
+import markdownSlugify from "./MarkdownSlugify";
 
 export type MarkdownRenderer = Renderer;
 
@@ -235,15 +236,14 @@ export default class Markdown {
     return renderer;
   }
 
-  private static slugify(text: string): string {
-    return text
-      .toLowerCase()
-      .replace(/<[^>]*>/g, "")
-      .replace(/&[^;]+;/g, "")
-      .replace(/[^\w\s-]/g, "")
-      .replace(/\s+/g, "-")
-      .replace(/-+/g, "-")
-      .replace(/^-|-$/g, "");
+  /*
+   * Heading text -> the `id` used for in-page anchors. The rules live in
+   * MarkdownSlugify.ts, a dependency-free module, so the docs anchor scripts
+   * (Scripts/Docs/CheckAnchors.ts, FixAnchors.ts) can share them without
+   * pulling in marked or the telemetry stack — see the comment there.
+   */
+  public static slugify(text: string): string {
+    return markdownSlugify(text);
   }
 
   private static getDocsRenderer(): Renderer {

package/Server/Types/MarkdownSlugify.ts

@@ -0,0 +1,47 @@
+/*
+ * Heading text -> the `id` used for in-page anchors.
+ *
+ * This is the single source of truth for anchor ids. The docs renderer
+ * (Common/Server/Types/Markdown.ts) exposes it as Markdown.slugify, and the
+ * docs anchor scripts (Scripts/Docs/CheckAnchors.ts, Scripts/Docs/FixAnchors.ts)
+ * import it directly; a second copy of these rules would drift and then pass a
+ * link the renderer serves as a 404.
+ *
+ * It lives in its own module with ZERO imports on purpose: Markdown.ts pulls in
+ * marked and the telemetry stack, which only resolve inside a fully installed
+ * package. The scripts run in CI with nothing but the root npm install, so they
+ * must be able to load the slugify rules without any of that.
+ *
+ * The character class keeps letters and numbers in ANY script, via \p{L} and
+ * \p{N} with the /u flag. It used to be `\w`, which is ASCII-only — so every
+ * Cyrillic, CJK and Devanagari heading was stripped to nothing and rendered
+ * as id="", breaking every anchor in those locales. Accented Latin lost the
+ * accented letter alone ("gravité" -> "gravit").
+ *
+ * \p{M} (combining marks) is required alongside \p{L}: Devanagari matras and
+ * Arabic/Thai vowel signs are marks, not letters, so without it Hindi headings
+ * come out mangled rather than merely transliterated ("लॉग" -> "लग"). It also
+ * covers decomposed (NFD) Latin, where "é" is "e" + a combining accent.
+ *
+ * Variation selectors are dropped first. They are marks too, so \p{M} would
+ * otherwise keep them — and an emoji heading like "⚠️ Important" carries an
+ * invisible U+FE0F that would survive its emoji and lead the id.
+ *
+ * `_` is listed explicitly because \p{L}/\p{N} do not cover it but the old
+ * `\w` did, and real headings depend on it — e.g. "`ceph_health_status` is 1
+ * but no incident fires". Dropping it would silently renumber existing
+ * English anchors and break inbound deep links.
+ */
+const slugify: (text: string) => string = (text: string): string => {
+  return text
+    .toLowerCase()
+    .replace(/<[^>]*>/g, "")
+    .replace(/&[^;]+;/g, "")
+    .replace(/[\uFE00-\uFE0F\u{E0100}-\u{E01EF}]/gu, "")
+    .replace(/[^\p{L}\p{N}\p{M}_\s-]/gu, "")
+    .replace(/\s+/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "");
+};
+
+export default slugify;