@oneuptime/common 11.5.8 → 11.5.9

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

@@ -0,0 +1,223 @@
+/**
+ * StatusPageService MCP gate tests.
+ *
+ * resolveStatusPageIdOrNull and isMcpServerEnabled back the unauthenticated
+ * public status page MCP tools, so their contract is security-relevant:
+ * - a status page that does not exist and one that has MCP turned off must be
+ *   indistinguishable to the caller (otherwise the tools become a status page
+ *   enumeration oracle)
+ * - a database failure must propagate rather than collapse into "disabled", so
+ *   an outage is reported as an error instead of being silently reported as an
+ *   owner's privacy choice
+ *
+ * Both services' findOneBy are spied on, so no database is touched.
+ */
+
+import StatusPageService from "../../../Server/Services/StatusPageService";
+import StatusPageDomainService from "../../../Server/Services/StatusPageDomainService";
+import StatusPage from "../../../Models/DatabaseModels/StatusPage";
+import StatusPageDomain from "../../../Models/DatabaseModels/StatusPageDomain";
+import ObjectID from "../../../Types/ObjectID";
+import { afterEach, describe, expect, test, jest } from "@jest/globals";
+
+const VALID_UUID: string = "550e8400-e29b-41d4-a716-446655440000";
+const DOMAIN: string = "status.company.com";
+
+function statusPageDomainWith(statusPageId: ObjectID | null): StatusPageDomain {
+  return {
+    statusPageId: statusPageId ?? undefined,
+  } as unknown as StatusPageDomain;
+}
+
+function statusPageRow(): StatusPage {
+  return { _id: VALID_UUID } as unknown as StatusPage;
+}
+
+function spyOnStatusPageFindOneBy(): jest.SpyInstance {
+  return jest.spyOn(
+    StatusPageService,
+    "findOneBy",
+  ) as unknown as jest.SpyInstance;
+}
+
+function spyOnDomainFindOneBy(): jest.SpyInstance {
+  return jest.spyOn(
+    StatusPageDomainService,
+    "findOneBy",
+  ) as unknown as jest.SpyInstance;
+}
+
+describe("StatusPageService MCP gate", () => {
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe("resolveStatusPageIdOrNull", () => {
+    test("resolves a UUID without querying the domain table", async () => {
+      const domainSpy: jest.SpyInstance = spyOnDomainFindOneBy();
+
+      const result: ObjectID | null =
+        await StatusPageService.resolveStatusPageIdOrNull(VALID_UUID);
+
+      expect(result?.toString()).toBe(VALID_UUID);
+      expect(domainSpy).not.toHaveBeenCalled();
+    });
+
+    test("looks a domain up by fullDomain, requiring a verified domain", async () => {
+      const statusPageId: ObjectID = new ObjectID(VALID_UUID);
+      const domainSpy: jest.SpyInstance =
+        spyOnDomainFindOneBy().mockResolvedValue(
+          statusPageDomainWith(statusPageId) as never,
+        );
+
+      const result: ObjectID | null =
+        await StatusPageService.resolveStatusPageIdOrNull(DOMAIN);
+
+      expect(result?.toString()).toBe(VALID_UUID);
+
+      const args: Record<string, any> = domainSpy.mock.calls[0]![0] as Record<
+        string,
+        any
+      >;
+
+      expect(args["query"]["fullDomain"]).toBe(DOMAIN);
+      expect(args["query"]["domain"]).toEqual({ isVerified: true });
+      expect(args["props"]["isRoot"]).toBe(true);
+    });
+
+    test("returns null when the domain is not registered", async () => {
+      spyOnDomainFindOneBy().mockResolvedValue(null as never);
+
+      await expect(
+        StatusPageService.resolveStatusPageIdOrNull(DOMAIN),
+      ).resolves.toBeNull();
+    });
+
+    test("returns null when the domain row carries no status page", async () => {
+      spyOnDomainFindOneBy().mockResolvedValue(
+        statusPageDomainWith(null) as never,
+      );
+
+      await expect(
+        StatusPageService.resolveStatusPageIdOrNull(DOMAIN),
+      ).resolves.toBeNull();
+    });
+
+    test("returns null for an empty identifier without querying", async () => {
+      const domainSpy: jest.SpyInstance = spyOnDomainFindOneBy();
+
+      await expect(
+        StatusPageService.resolveStatusPageIdOrNull(""),
+      ).resolves.toBeNull();
+      expect(domainSpy).not.toHaveBeenCalled();
+    });
+
+    test("returns null for a malformed UUID rather than throwing", async () => {
+      await expect(
+        StatusPageService.resolveStatusPageIdOrNull("not-a-uuid"),
+      ).resolves.toBeNull();
+    });
+
+    test("returns null for a dotless hostname", async () => {
+      /*
+       * The dot is the discriminator, mirroring resolveStatusPageIdOrThrow in
+       * StatusPageAPI. "localhost" therefore goes down the UUID path and fails
+       * there. Pinned so the two resolvers cannot silently diverge.
+       */
+      await expect(
+        StatusPageService.resolveStatusPageIdOrNull("localhost"),
+      ).resolves.toBeNull();
+    });
+  });
+
+  describe("isMcpServerEnabled", () => {
+    test("is true when a UUID matches a status page with MCP enabled", async () => {
+      spyOnStatusPageFindOneBy().mockResolvedValue(statusPageRow() as never);
+
+      await expect(
+        StatusPageService.isMcpServerEnabled(VALID_UUID),
+      ).resolves.toBe(true);
+    });
+
+    test("is false when the status page has MCP disabled", async () => {
+      /*
+       * The enableMcpServer predicate is in the query, so a gated page simply
+       * does not match.
+       */
+      spyOnStatusPageFindOneBy().mockResolvedValue(null as never);
+
+      await expect(
+        StatusPageService.isMcpServerEnabled(VALID_UUID),
+      ).resolves.toBe(false);
+    });
+
+    test("folds the flag into the query and reads as root", async () => {
+      const spy: jest.SpyInstance =
+        spyOnStatusPageFindOneBy().mockResolvedValue(statusPageRow() as never);
+
+      await StatusPageService.isMcpServerEnabled(VALID_UUID);
+
+      const args: Record<string, any> = spy.mock.calls[0]![0] as Record<
+        string,
+        any
+      >;
+
+      expect(args["query"]["enableMcpServer"]).toBe(true);
+      expect(args["query"]["_id"].toString()).toBe(VALID_UUID);
+      expect(args["props"]["isRoot"]).toBe(true);
+    });
+
+    test("resolves a domain and then checks the flag", async () => {
+      spyOnDomainFindOneBy().mockResolvedValue(
+        statusPageDomainWith(new ObjectID(VALID_UUID)) as never,
+      );
+      const pageSpy: jest.SpyInstance =
+        spyOnStatusPageFindOneBy().mockResolvedValue(statusPageRow() as never);
+
+      await expect(StatusPageService.isMcpServerEnabled(DOMAIN)).resolves.toBe(
+        true,
+      );
+      expect(pageSpy).toHaveBeenCalledTimes(1);
+    });
+
+    test("is false for an unknown status page, without a second query", async () => {
+      spyOnDomainFindOneBy().mockResolvedValue(null as never);
+      const pageSpy: jest.SpyInstance = spyOnStatusPageFindOneBy();
+
+      await expect(StatusPageService.isMcpServerEnabled(DOMAIN)).resolves.toBe(
+        false,
+      );
+      expect(pageSpy).not.toHaveBeenCalled();
+    });
+
+    test("is false for an unresolvable identifier", async () => {
+      await expect(
+        StatusPageService.isMcpServerEnabled("not-a-uuid"),
+      ).resolves.toBe(false);
+    });
+
+    test("propagates a status page query failure instead of reporting disabled", async () => {
+      /*
+       * Fails closed either way, but the caller reports an error rather than
+       * telling the agent the owner turned MCP off.
+       */
+      spyOnStatusPageFindOneBy().mockRejectedValue(
+        new Error("connection terminated") as never,
+      );
+
+      await expect(
+        StatusPageService.isMcpServerEnabled(VALID_UUID),
+      ).rejects.toThrow("connection terminated");
+    });
+
+    test("propagates a domain query failure", async () => {
+      spyOnDomainFindOneBy().mockRejectedValue(
+        new Error("connection terminated") as never,
+      );
+
+      await expect(
+        StatusPageService.isMcpServerEnabled(DOMAIN),
+      ).rejects.toThrow("connection terminated");
+    });
+  });
+});

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

@@ -1,7 +1,8 @@
-import TelemetryExceptionService, {
+import TelemetryExceptionService from "../../../Server/Services/TelemetryExceptionService";
+import {
   AIFixReadiness,
   AIFixReadinessCheck,
-} from "../../../Server/Services/TelemetryExceptionService";
+} from "../../../Types/AI/AIFixReadiness";
 import FixRunBudget from "../../../Server/Utils/AI/CodeFix/FixRunBudget";
 import LlmProviderService from "../../../Server/Services/LlmProviderService";
 import ProjectService from "../../../Server/Services/ProjectService";
@@ -19,7 +20,8 @@ import AIAgent, {
 import BadDataException from "../../../Types/Exception/BadDataException";
 import ObjectID from "../../../Types/ObjectID";
 import OneUptimeDate from "../../../Types/Date";
-import { describe, expect, test, afterEach } from "@jest/globals";
+import AIService from "../../../Server/Services/AIService";
+import { describe, expect, test, afterEach, beforeEach } from "@jest/globals";
 
 /*
  * "Fix with AI Agent" readiness: every prerequisite is checked BEFORE a task
@@ -121,7 +123,24 @@ function getCheck(readiness: AIFixReadiness, id: string): AIFixReadinessCheck {
   return check!;
 }
 
+/*
+ * The llmProvider check also gates on the daily autonomous token budget
+ * (AI_CODE_FIX_FEATURE is autonomous, so executeWithLogging enforces it).
+ * Default it to unset — these suites are about the other fail conditions.
+ */
+function mockBudgetNotExhausted(): void {
+  jest.spyOn(AIService, "getAutonomousDailyBudgetStatus").mockResolvedValue({
+    exhausted: false,
+    limitInTokens: null,
+    usedTokensToday: 0,
+  });
+}
+
 describe("TelemetryExceptionService.getAIFixReadiness", () => {
+  beforeEach(() => {
+    mockBudgetNotExhausted();
+  });
+
   afterEach(() => {
     jest.restoreAllMocks();
   });
@@ -237,6 +256,10 @@ describe("TelemetryExceptionService.getAIFixReadiness", () => {
  * and free-global providers consume no balance and must never require one.
  */
 describe("TelemetryExceptionService.getAIFixReadiness — AI balance gate", () => {
+  beforeEach(() => {
+    mockBudgetNotExhausted();
+  });
+
   afterEach(() => {
     jest.restoreAllMocks();
   });

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

@@ -1,4 +1,5 @@
 import TelemetryExceptionService from "../../../Server/Services/TelemetryExceptionService";
+import AIService from "../../../Server/Services/AIService";
 import FixRunBudget from "../../../Server/Utils/AI/CodeFix/FixRunBudget";
 import LlmProviderService from "../../../Server/Services/LlmProviderService";
 import ServiceService from "../../../Server/Services/ServiceService";
@@ -79,6 +80,17 @@ function mockReadinessOk(): void {
     name: "agent",
     connectionStatus: AIAgentConnectionStatus.Connected,
   } as unknown as AIAgent);
+  /*
+   * The llmProvider check also gates on the daily autonomous token budget
+   * (AI_CODE_FIX_FEATURE is autonomous, so executeWithLogging enforces it).
+   * Default it to unset — this suite is about the duplicate guard, and the
+   * budget has its own suite (AIServiceDailyBudget.test.ts).
+   */
+  jest.spyOn(AIService, "getAutonomousDailyBudgetStatus").mockResolvedValue({
+    exhausted: false,
+    limitInTokens: null,
+    usedTokensToday: 0,
+  });
 }
 
 describe("TelemetryExceptionService.createCodeFixRunForException", () => {

package/Tests/Server/Types/Markdown.test.ts

@@ -0,0 +1,106 @@
+import Markdown from "../../../Server/Types/Markdown";
+
+/*
+ * slugify turns a heading into the `id` the docs renderer emits, and therefore
+ * into the target every in-page `](#anchor)` link has to match. These tests pin
+ * the two properties that are easy to break by accident:
+ *
+ *   - non-ASCII scripts must survive (they used to be stripped to an empty id,
+ *     which silently 404'd every anchor in the ru/ja/ko/hi/zh docs), and
+ *   - existing English ids must not move, because they are published URLs.
+ */
+describe("Markdown.slugify", () => {
+  describe("English headings keep their existing ids", () => {
+    test.each([
+      [
+        "Reducing the Volume of Data Collected",
+        "reducing-the-volume-of-data-collected",
+      ],
+      ["Filtering by Log Severity", "filtering-by-log-severity"],
+      ["Step 1 — Install the Collector", "step-1-install-the-collector"],
+      ["What's New?", "whats-new"],
+      ["Namespace Filtering", "namespace-filtering"],
+    ])("%s", (heading: string, expected: string) => {
+      expect(Markdown.slugify(heading)).toBe(expected);
+    });
+  });
+
+  /*
+   * \p{L}/\p{N} do not match "_", so it is listed explicitly in the character
+   * class. The old `\w` matched it. These are real headings — dropping the
+   * underscore would change ids that are already linked to.
+   */
+  describe("underscores are preserved", () => {
+    test.each([
+      [
+        "`ceph_health_status` is 1 but no incident fires",
+        "ceph_health_status-is-1-but-no-incident-fires",
+      ],
+      [
+        "Counters like `pve_network_receive_bytes` only ever grow",
+        "counters-like-pve_network_receive_bytes-only-ever-grow",
+      ],
+    ])("%s", (heading: string, expected: string) => {
+      expect(Markdown.slugify(heading)).toBe(expected);
+    });
+  });
+
+  describe("non-Latin scripts produce a usable id, not an empty one", () => {
+    test.each([
+      ["Фильтрация по важности логов", "фильтрация-по-важности-логов"],
+      ["ログの重大度によるフィルタリング", "ログの重大度によるフィルタリング"],
+      ["按日志严重性过滤", "按日志严重性过滤"],
+      ["로그 심각도별 필터링", "로그-심각도별-필터링"],
+      [
+        "लॉग गंभीरता के अनुसार फ़िल्टर करना",
+        "लॉग-गंभीरता-के-अनुसार-फ़िल्टर-करना",
+      ],
+    ])("%s", (heading: string, expected: string) => {
+      const slug: string = Markdown.slugify(heading);
+      expect(slug).not.toBe("");
+      expect(slug).toBe(expected);
+    });
+  });
+
+  describe("accented Latin keeps the accented letter", () => {
+    test.each([
+      [
+        "Filtrage par gravité des journaux",
+        "filtrage-par-gravité-des-journaux",
+      ],
+      [
+        "Reduktion af mængden af indsamlede data",
+        "reduktion-af-mængden-af-indsamlede-data",
+      ],
+      ["Fehlerbehebung für Größen", "fehlerbehebung-für-größen"],
+    ])("%s", (heading: string, expected: string) => {
+      expect(Markdown.slugify(heading)).toBe(expected);
+    });
+  });
+
+  describe("markup and punctuation are still stripped", () => {
+    test("strips inline HTML tags", () => {
+      expect(Markdown.slugify("A <em>heading</em> here")).toBe(
+        "a-heading-here",
+      );
+    });
+
+    test("strips HTML entities", () => {
+      expect(Markdown.slugify("Tom &amp; Jerry")).toBe("tom-jerry");
+    });
+
+    test("strips punctuation but keeps hyphens", () => {
+      expect(Markdown.slugify("Set up SSO (SAML): step-by-step!")).toBe(
+        "set-up-sso-saml-step-by-step",
+      );
+    });
+
+    test("collapses whitespace runs and trims leading/trailing hyphens", () => {
+      expect(Markdown.slugify("  spaced   out  ")).toBe("spaced-out");
+    });
+
+    test("emoji are dropped rather than becoming part of the id", () => {
+      expect(Markdown.slugify("🚀 Getting Started")).toBe("getting-started");
+    });
+  });
+});

package/Tests/Server/Utils/AI/AIRunTranscript.test.ts

@@ -0,0 +1,182 @@
+import AIRunTranscript, {
+  MAX_MESSAGE_CONTENT_CHARS,
+  MAX_PAYLOAD_CHARS,
+  MAX_RESPONSE_CONTENT_CHARS,
+  MAX_TOOL_ARGUMENT_CHARS,
+  MAX_TOOL_RESULT_CHARS,
+} from "../../../../Server/Utils/AI/AIRunTranscript";
+import { AIRunEventContentPayload } from "../../../../Types/AI/AIChatTypes";
+import { describe, expect, test } from "@jest/globals";
+
+/*
+ * The run transcript is the ONE place a code-fix run's LLM content is stored
+ * (LlmLog redacts it — it is project-wide readable and these prompts embed
+ * customer source code). It stores content verbatim to be worth reading when
+ * a run goes wrong, which makes bounding it a storage requirement rather than
+ * a nicety: an agent may read large files and run test suites emitting
+ * megabytes, up to 40 times per run.
+ *
+ * These tests pin the two properties that make that safe: every field is
+ * capped, and the payload as a whole cannot exceed MAX_PAYLOAD_CHARS no
+ * matter WHICH field carries the bulk.
+ */
+
+type SerializedLengthFunction = (payload: AIRunEventContentPayload) => number;
+
+const serializedLength: SerializedLengthFunction = (
+  payload: AIRunEventContentPayload,
+): number => {
+  return JSON.stringify(payload).length;
+};
+
+describe("AIRunTranscript.clip", () => {
+  test("leaves a value under the cap untouched and unflagged", () => {
+    expect(AIRunTranscript.clip("short", 100)).toEqual({
+      value: "short",
+      isTruncated: false,
+    });
+  });
+
+  test("clips an oversized value and reports the truncation", () => {
+    const result: { value: string | undefined; isTruncated: boolean } =
+      AIRunTranscript.clip("x".repeat(50), 10);
+
+    expect(result.isTruncated).toBe(true);
+    expect(result.value).toContain("truncated");
+    expect(result.value!.startsWith("x".repeat(10))).toBe(true);
+  });
+
+  test("passes undefined through without inventing a value", () => {
+    expect(AIRunTranscript.clip(undefined, 10)).toEqual({
+      value: undefined,
+      isTruncated: false,
+    });
+  });
+});
+
+describe("AIRunTranscript.clipArguments", () => {
+  test("keeps arguments under the cap verbatim", () => {
+    const args: { path: string } = { path: "src/Index.ts" };
+    expect(AIRunTranscript.clipArguments(args)).toEqual({
+      value: args,
+      isTruncated: false,
+    });
+  });
+
+  /*
+   * A write_file call carries a whole file in its arguments — the single
+   * likeliest way one tool call bloats a row.
+   */
+  test("replaces oversized arguments with a marker that keeps a preview", () => {
+    const result: {
+      value: Record<string, unknown> | undefined;
+      isTruncated: boolean;
+    } = AIRunTranscript.clipArguments({
+      content: "y".repeat(MAX_TOOL_ARGUMENT_CHARS + 1000),
+    });
+
+    expect(result.isTruncated).toBe(true);
+    expect(result.value!["_note"]).toContain("exceeds");
+    expect(typeof result.value!["_preview"]).toBe("string");
+  });
+});
+
+describe("AIRunTranscript.clampPayload", () => {
+  test("caps each field independently and stamps isTruncated", () => {
+    const clamped: AIRunEventContentPayload = AIRunTranscript.clampPayload({
+      requestMessages: [
+        { role: "user", content: "a".repeat(MAX_MESSAGE_CONTENT_CHARS + 500) },
+      ],
+      responseContent: "b".repeat(MAX_RESPONSE_CONTENT_CHARS + 500),
+      toolResult: "c".repeat(MAX_TOOL_RESULT_CHARS + 500),
+    });
+
+    expect(clamped.isTruncated).toBe(true);
+    expect(clamped.requestMessages![0]!.content.length).toBeLessThanOrEqual(
+      MAX_MESSAGE_CONTENT_CHARS + 100,
+    );
+    expect(clamped.responseContent!.length).toBeLessThanOrEqual(
+      MAX_RESPONSE_CONTENT_CHARS + 100,
+    );
+    expect(clamped.toolResult!.length).toBeLessThanOrEqual(
+      MAX_TOOL_RESULT_CHARS + 100,
+    );
+  });
+
+  test("leaves a small payload entirely alone", () => {
+    const payload: AIRunEventContentPayload = {
+      requestMessages: [{ role: "user", content: "fix the null deref" }],
+      responseContent: "Reading the file.",
+      responseToolCalls: [{ name: "read_file", arguments: { path: "a.ts" } }],
+      totalTokens: 120,
+    };
+
+    const clamped: AIRunEventContentPayload =
+      AIRunTranscript.clampPayload(payload);
+
+    expect(clamped.isTruncated).toBeUndefined();
+    expect(clamped).toEqual(payload);
+  });
+
+  /*
+   * The regression this file exists for. A single-pass backstop that only
+   * dropped requestMessages "succeeded" by deleting a two-character user
+   * message while the row stayed ~1.5x over the ceiling, because the bulk was
+   * in responseToolCalls. The cap must hold regardless of which field is fat.
+   */
+  test("holds the ceiling when the bulk is in responseToolCalls, not messages", () => {
+    const clamped: AIRunEventContentPayload = AIRunTranscript.clampPayload({
+      requestMessages: [{ role: "user", content: "hi" }],
+      responseToolCalls: Array.from(
+        { length: 30 },
+        (_value: unknown, index: number) => {
+          return {
+            id: `call_${index}`,
+            name: "write_file",
+            arguments: { content: "z".repeat(MAX_TOOL_ARGUMENT_CHARS - 200) },
+          };
+        },
+      ),
+    });
+
+    expect(serializedLength(clamped)).toBeLessThanOrEqual(MAX_PAYLOAD_CHARS);
+    expect(clamped.isTruncated).toBe(true);
+  });
+
+  test("holds the ceiling when the bulk is a huge tool result", () => {
+    const clamped: AIRunEventContentPayload = AIRunTranscript.clampPayload({
+      toolResult: "q".repeat(MAX_PAYLOAD_CHARS * 3),
+    });
+
+    expect(serializedLength(clamped)).toBeLessThanOrEqual(MAX_PAYLOAD_CHARS);
+    expect(clamped.isTruncated).toBe(true);
+  });
+
+  /*
+   * Bounded ENTRIES are not a bounded ARRAY: with every argument already
+   * dropped, enough calls still blow the ceiling. The last resort collapses
+   * the array to a count.
+   */
+  test("holds the ceiling against a pathological number of tool calls", () => {
+    const clamped: AIRunEventContentPayload = AIRunTranscript.clampPayload({
+      responseToolCalls: Array.from(
+        { length: 20000 },
+        (_value: unknown, index: number) => {
+          return { id: `call_${index}`, name: "read_file" };
+        },
+      ),
+    });
+
+    expect(serializedLength(clamped)).toBeLessThanOrEqual(MAX_PAYLOAD_CHARS);
+    expect(clamped.isTruncated).toBe(true);
+  });
+
+  // A clipped prompt must never be presented as though it were whole.
+  test("never reports a clipped payload as complete", () => {
+    const clamped: AIRunEventContentPayload = AIRunTranscript.clampPayload({
+      responseContent: "r".repeat(MAX_RESPONSE_CONTENT_CHARS + 1),
+    });
+
+    expect(clamped.isTruncated).toBe(true);
+  });
+});