@oneuptime/common 14.0.0 → 14.0.2

package/Tests/Server/Types/Workflow/Components/ApiComponentSsrf.test.ts

@@ -213,3 +213,52 @@ describe.each(apiComponents)(
     });
   },
 );
+
+/*
+ * sanitizeArgs validates the raw URL and then dispatches URL.fromString(url).
+ * That parse refused any first path segment containing a ":", so every API
+ * component call to the Telegram Bot API (the token is that segment) failed
+ * before a request was made, quoting the token in the error.
+ */
+describe.each(apiComponents)(
+  "API %s workflow component with a token in the first path segment",
+  (
+    _label: string,
+    apiMethodName: ApiMethodName,
+    createComponent: () => ComponentCode,
+  ) => {
+    const telegramUrl: string =
+      "https://api.telegram.org/bot8000000001:AAFakeFakeFakeFakeFakeFakeFake_-12345/sendMessage";
+
+    test("dispatches the Telegram Bot API URL unchanged", async () => {
+      getApiMock(apiMethodName).mockResolvedValue(
+        new HTTPResponse<JSONObject>(200, { ok: true }, {}),
+      );
+
+      const result: { returnValues: JSONObject } = await createComponent().run(
+        { url: telegramUrl },
+        makeOptions(),
+      );
+
+      const request: { url: { toString: () => string } } = getApiMock(
+        apiMethodName,
+      ).mock.calls[0]![0] as { url: { toString: () => string } };
+
+      expect(request.url.toString()).toBe(telegramUrl);
+      expect(result.returnValues["response-status"]).toBe(200);
+    });
+
+    test("still refuses an internal host behind the same path", async () => {
+      await expect(
+        createComponent().run(
+          {
+            url: "http://169.254.169.254/bot8000000001:AAFake/sendMessage",
+          },
+          makeOptions(),
+        ),
+      ).rejects.toThrow();
+
+      expect(getApiMock(apiMethodName)).not.toHaveBeenCalled();
+    });
+  },
+);

package/Tests/Server/Types/Workflow/Components/TelegramSendMessageToChat.test.ts

@@ -0,0 +1,331 @@
+import SendMessageToChat from "../../../../../Server/Types/Workflow/Components/Telegram/SendMessageToChat";
+import {
+  RunOptions,
+  RunReturnType,
+} from "../../../../../Server/Types/Workflow/ComponentCode";
+import HTTPErrorResponse from "../../../../../Types/API/HTTPErrorResponse";
+import HTTPResponse from "../../../../../Types/API/HTTPResponse";
+import URL from "../../../../../Types/API/URL";
+import Exception from "../../../../../Types/Exception/Exception";
+import { JSONObject } from "../../../../../Types/JSON";
+import ObjectID from "../../../../../Types/ObjectID";
+import API from "../../../../../Utils/API";
+import { beforeEach, describe, expect, test } from "@jest/globals";
+
+/*
+ * "Send Message to Telegram" built its request URL with
+ * URL.fromString(`https://api.telegram.org/bot${token}/sendMessage`). Once
+ * Route began refusing scheme-like values, the bare path "bot<id>:<secret>/..."
+ * was refused, so EVERY run failed before a request was sent - with the error
+ * "Invalid route: bot<the whole token>/sendMessage", which put the credential
+ * into the run log even though the argument itself is shown as [REDACTED].
+ */
+
+jest.mock("../../../../../Utils/API", () => {
+  return {
+    __esModule: true,
+    default: { post: jest.fn() },
+  };
+});
+
+const apiPostMock: jest.Mock = API.post as unknown as jest.Mock;
+
+// Same shape as a real token: 10-digit bot id, 35-character secret.
+const BOT_TOKEN: string = "8000000001:AAFakeFakeFakeFakeFakeFakeFake_-12345";
+
+const HELP_MESSAGE: string =
+  " Note: For usernames, the user must have started a conversation with the bot first. For groups/channels, the bot must be added as a member or admin.";
+
+function makeOptions(): RunOptions {
+  return {
+    log: jest.fn() as RunOptions["log"],
+    workflowLogId: ObjectID.generate(),
+    workflowId: ObjectID.generate(),
+    projectId: ObjectID.generate(),
+    onError: ((exception: Exception): Exception => {
+      return exception;
+    }) as RunOptions["onError"],
+    executeWorkflow: async (): Promise<void> => {},
+  };
+}
+
+function makeArgs(overrides: JSONObject = {}): JSONObject {
+  return {
+    "bot-token": BOT_TOKEN,
+    "chat-id": "@mychannel",
+    text: "Deploy finished",
+    ...overrides,
+  };
+}
+
+interface PostRequest {
+  url: URL;
+  data: JSONObject;
+}
+
+function getPostRequest(): PostRequest {
+  return apiPostMock.mock.calls[0]![0] as PostRequest;
+}
+
+async function runAndGetError(args: JSONObject): Promise<Error> {
+  try {
+    await new SendMessageToChat().run(args, makeOptions());
+  } catch (err) {
+    return err as Error;
+  }
+
+  throw new Error("Expected the component to throw");
+}
+
+beforeEach(() => {
+  jest.clearAllMocks();
+});
+
+describe("Telegram SendMessageToChat - sending", () => {
+  test("sends to the Bot API sendMessage URL instead of failing on Invalid route", async () => {
+    apiPostMock.mockResolvedValue(
+      new HTTPResponse<JSONObject>(200, { ok: true, result: {} }, {}),
+    );
+
+    const result: RunReturnType = await new SendMessageToChat().run(
+      makeArgs(),
+      makeOptions(),
+    );
+
+    expect(apiPostMock).toHaveBeenCalledTimes(1);
+    expect(getPostRequest().url.toString()).toBe(
+      `https://api.telegram.org/bot${BOT_TOKEN}/sendMessage`,
+    );
+    expect(result.executePort?.id).toBe("success");
+    expect(result.returnValues).toEqual({});
+  });
+
+  test("sends the chat id and text as the request body", async () => {
+    apiPostMock.mockResolvedValue(
+      new HTTPResponse<JSONObject>(200, { ok: true }, {}),
+    );
+
+    await new SendMessageToChat().run(
+      makeArgs({ "chat-id": "-1001234567890", text: "Line 1\nLine 2" }),
+      makeOptions(),
+    );
+
+    expect(getPostRequest().data).toEqual({
+      chat_id: "-1001234567890",
+      text: "Line 1\nLine 2",
+    });
+  });
+
+  test("dials api.telegram.org over https with the token only in the path", async () => {
+    apiPostMock.mockResolvedValue(
+      new HTTPResponse<JSONObject>(200, { ok: true }, {}),
+    );
+
+    await new SendMessageToChat().run(makeArgs(), makeOptions());
+
+    const url: URL = getPostRequest().url;
+    expect(url.isHttps()).toBe(true);
+    expect(url.hostname.hostname).toBe("api.telegram.org");
+    expect(url.route.toString()).toBe(`/bot${BOT_TOKEN}/sendMessage`);
+    expect(Object.keys(url.params)).toHaveLength(0);
+  });
+
+  test("trims whitespace a pasted or stored token picked up", async () => {
+    apiPostMock.mockResolvedValue(
+      new HTTPResponse<JSONObject>(200, { ok: true }, {}),
+    );
+
+    const result: RunReturnType = await new SendMessageToChat().run(
+      makeArgs({ "bot-token": `  ${BOT_TOKEN}\n` }),
+      makeOptions(),
+    );
+
+    expect(getPostRequest().url.toString()).toBe(
+      `https://api.telegram.org/bot${BOT_TOKEN}/sendMessage`,
+    );
+    expect(result.executePort?.id).toBe("success");
+  });
+
+  test.each([
+    ["a short secret", "1:A"],
+    ["a hyphen and underscore", "123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11"],
+    ["a long bot id", "1234567890123:AAE_underscored-and-dashed"],
+  ])("accepts a token with %s", async (_label: string, token: string) => {
+    apiPostMock.mockResolvedValue(
+      new HTTPResponse<JSONObject>(200, { ok: true }, {}),
+    );
+
+    const result: RunReturnType = await new SendMessageToChat().run(
+      makeArgs({ "bot-token": token }),
+      makeOptions(),
+    );
+
+    expect(getPostRequest().url.toString()).toBe(
+      `https://api.telegram.org/bot${token}/sendMessage`,
+    );
+    expect(result.executePort?.id).toBe("success");
+  });
+});
+
+describe("Telegram SendMessageToChat - Telegram errors go to the error port", () => {
+  test("an HTTP error returns Telegram's description", async () => {
+    apiPostMock.mockResolvedValue(
+      new HTTPErrorResponse(
+        400,
+        { ok: false, description: "Bad Request: chat not found" },
+        {},
+      ),
+    );
+
+    const result: RunReturnType = await new SendMessageToChat().run(
+      makeArgs(),
+      makeOptions(),
+    );
+
+    expect(result.executePort?.id).toBe("error");
+    expect(result.returnValues["error"]).toBe(
+      "Bad Request: chat not found" + HELP_MESSAGE,
+    );
+  });
+
+  test("an HTTP error with no description falls back to a generic message", async () => {
+    apiPostMock.mockResolvedValue(new HTTPErrorResponse(502, {}, {}));
+
+    const result: RunReturnType = await new SendMessageToChat().run(
+      makeArgs(),
+      makeOptions(),
+    );
+
+    expect(result.executePort?.id).toBe("error");
+    expect(result.returnValues["error"]).toBe("Server Error." + HELP_MESSAGE);
+  });
+
+  test("a 200 with ok:false is still an error", async () => {
+    apiPostMock.mockResolvedValue(
+      new HTTPResponse<JSONObject>(
+        200,
+        { ok: false, description: "Forbidden: bot was blocked by the user" },
+        {},
+      ),
+    );
+
+    const result: RunReturnType = await new SendMessageToChat().run(
+      makeArgs(),
+      makeOptions(),
+    );
+
+    expect(result.executePort?.id).toBe("error");
+    expect(result.returnValues["error"]).toBe(
+      "Forbidden: bot was blocked by the user" + HELP_MESSAGE,
+    );
+  });
+
+  test("a thrown HTTP error response returns its description", async () => {
+    apiPostMock.mockRejectedValue(
+      new HTTPErrorResponse(
+        401,
+        { ok: false, description: "Unauthorized" },
+        {},
+      ),
+    );
+
+    const result: RunReturnType = await new SendMessageToChat().run(
+      makeArgs(),
+      makeOptions(),
+    );
+
+    expect(result.executePort?.id).toBe("error");
+    expect(result.returnValues["error"]).toBe("Unauthorized" + HELP_MESSAGE);
+  });
+
+  test("any other thrown error fails the step without quoting the token", async () => {
+    apiPostMock.mockRejectedValue(
+      new Error(
+        `connect ECONNREFUSED https://api.telegram.org/bot${BOT_TOKEN}/sendMessage`,
+      ),
+    );
+
+    const error: Error = await runAndGetError(makeArgs());
+
+    expect(error.message).toBe("Something wrong happened.");
+    expect(error.message).not.toContain(BOT_TOKEN);
+  });
+});
+
+describe("Telegram SendMessageToChat - argument validation", () => {
+  test.each([
+    ["bot-token", "Telegram Bot Token not found"],
+    ["chat-id", "Telegram Chat ID not found"],
+    ["text", "Telegram message not found"],
+  ])(
+    "refuses a missing %s without sending",
+    async (argument: string, expectedMessage: string) => {
+      const args: JSONObject = makeArgs();
+      delete args[argument];
+
+      const error: Error = await runAndGetError(args);
+
+      expect(error.message).toBe(expectedMessage);
+      expect(apiPostMock).not.toHaveBeenCalled();
+    },
+  );
+
+  test.each([
+    ["only whitespace", "   "],
+    ["no colon", "8000000001AAFakeFakeFake"],
+    ["a non-numeric bot id", "bot8000000001:AAFakeFakeFake"],
+    ["an empty secret", "8000000001:"],
+    ["an empty bot id", ":AAFakeFakeFake"],
+    ["a space inside", "8000000001:AAFake Fake"],
+    ["a path separator", "8000000001:AAFake/../../getUpdates"],
+    ["a query", "8000000001:AAFake?offset=1"],
+    ["a fragment", "8000000001:AAFake#x"],
+    ["a second colon", "8000000001:AAFake:extra"],
+    ["an '@'", "8000000001:AAFake@evil.example"],
+    ["the '<BOT_TOKEN>' placeholder", "<BOT_TOKEN>"],
+  ])(
+    "refuses a token with %s, without sending and without quoting it",
+    async (_label: string, token: string) => {
+      const error: Error = await runAndGetError(
+        makeArgs({ "bot-token": token }),
+      );
+
+      expect(error.message).toMatch(
+        /^Telegram Bot Token is not in a valid format\./,
+      );
+      if (token.trim()) {
+        expect(error.message).not.toContain(token.trim());
+      }
+      expect(apiPostMock).not.toHaveBeenCalled();
+    },
+  );
+
+  test("a malformed token never reaches the error message, even partially", async () => {
+    const secret: string = "AAFakeFakeFakeFakeFakeFakeFake_-12345";
+
+    const error: Error = await runAndGetError(
+      makeArgs({ "bot-token": `8000000001:${secret} trailing` }),
+    );
+
+    expect(error.message).not.toContain(secret);
+    expect(error.message).not.toContain("8000000001");
+  });
+});
+
+describe("Telegram SendMessageToChat.isValidBotToken", () => {
+  test.each([
+    [BOT_TOKEN, true],
+    ["123456:ABC-DEF1234ghIkl-zyx57W2v1u123ew11", true],
+    ["1:a", true],
+    ["", false],
+    ["123456", false],
+    ["abc:def", false],
+    ["123456:", false],
+    [" 123456:abc", false],
+    ["123456:abc ", false],
+    ["123456:abc/def", false],
+    ["123456:abc%2Fdef", false],
+  ])("isValidBotToken(%j) is %s", (token: string, expected: boolean) => {
+    expect(SendMessageToChat.isValidBotToken(token)).toBe(expected);
+  });
+});

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

@@ -0,0 +1,285 @@
+import ClusterAccessContext, {
+  UNATTENDED_ROUND_BECOMES_PROPOSAL_SUMMARY,
+} from "../../../../Server/Utils/AI/ClusterAccess/ClusterAccessContext";
+import { KUBECTL_ALWAYS_ASKS_SUMMARY } from "../../../../Types/AutoRemediation/AiRemediationCommandPlan";
+import {
+  KubernetesAiRemediationMode,
+  KubernetesClusterAiAccessStatus,
+  PROTECTED_KUBERNETES_NAMESPACES,
+} from "../../../../Types/Kubernetes/KubernetesClusterAiAccess";
+import { describe, expect, it } from "@jest/globals";
+
+// The stale Bypass promise: a Bypass round does still ask, for some changes.
+const NOTHING_IS_ASKED_PATTERN: RegExp =
+  /nothing is ever asked|nobody is asked/i;
+const DRAIN_WORD_PATTERN: RegExp = /\bdrain\b/;
+const TAINT_WORD_PATTERN: RegExp = /\btaint\b/;
+
+/*
+ * Contract under test — the deterministic text that tells the model (and,
+ * through the panel, the human) which clusters OneUptime AI can inspect and
+ * which it cannot, and why. It is derived from the access status only,
+ * never from model output.
+ */
+
+function status(
+  overrides: Partial<KubernetesClusterAiAccessStatus> = {},
+): KubernetesClusterAiAccessStatus {
+  return {
+    clusterId: "33333333-3333-4333-8333-333333333333",
+    clusterName: "prod-us",
+    clusterIdentifier: "prod-us",
+    runner: {
+      id: "44444444-4444-4444-8444-444444444444",
+      name: "kubernetes-agent/prod-us",
+      isOnline: true,
+      canRunAiCommands: true,
+    },
+    accessMethod: "in_cluster",
+    kubectlAllowlist: [],
+    isInvestigationEnabled: true,
+    isInvestigationReady: true,
+    remediationMode: KubernetesAiRemediationMode.RequireApproval,
+    isRemediationReady: true,
+    gaps: [],
+    evaluatedAt: new Date().toISOString(),
+    ...overrides,
+  };
+}
+
+describe("ClusterAccessContext", () => {
+  it("renders nothing for a signal with no clusters", () => {
+    expect(ClusterAccessContext.buildContextSection([])).toBe("");
+  });
+
+  it("tells the model which cluster it may inspect and how remediation works", () => {
+    const section: string = ClusterAccessContext.buildContextSection([
+      status(),
+    ]);
+
+    expect(section).toContain("# Cluster access");
+    expect(section).toContain('"prod-us"');
+    expect(section).toContain(
+      "clusterId: 33333333-3333-4333-8333-333333333333",
+    );
+    expect(section).toContain("kubectl READ access available via run_kubectl");
+    expect(section).toContain("in-cluster Runner");
+    expect(section).toContain("a human approves any kubectl fix");
+  });
+
+  it("describes every remediation mode, ready or not, so the model never guesses what it may change", () => {
+    const describe: (
+      mode: KubernetesAiRemediationMode,
+      isRemediationReady: boolean,
+    ) => string = (
+      mode: KubernetesAiRemediationMode,
+      isRemediationReady: boolean,
+    ): string => {
+      return ClusterAccessContext.buildContextSection([
+        status({ remediationMode: mode, isRemediationReady }),
+      ]);
+    };
+
+    /*
+     * Changed in the round-three review: the Bypass line used to promise
+     * "nothing is ever asked" and the Automatic line that riskier fixes are
+     * "left in the recommendations". Both contradicted the canonical
+     * KubernetesAiRemediationMode comment — a Bypass round still asks for
+     * a protected-namespace write, a node drain or a taint, and becomes a
+     * proposal when the breaker trips or another round holds the cluster;
+     * an Automatic round proposes a riskier fix for one-click approval. The
+     * clause-by-clause pins are in "states every mode the way the
+     * canonical comment does" below.
+     */
+    expect(
+      describe(KubernetesAiRemediationMode.BypassApproval, true),
+    ).toContain("Bypass approval (AI does not ask:");
+    expect(
+      describe(KubernetesAiRemediationMode.BypassApproval, false),
+    ).toContain("Bypass approval, but not ready");
+
+    expect(describe(KubernetesAiRemediationMode.Automatic, true)).toContain(
+      "Automatic (safe kubectl fixes run without a human",
+    );
+    expect(describe(KubernetesAiRemediationMode.Automatic, false)).toContain(
+      "Automatic, but not ready",
+    );
+
+    expect(
+      describe(KubernetesAiRemediationMode.RequireApproval, false),
+    ).toContain("requires approval, but not ready");
+
+    expect(describe(KubernetesAiRemediationMode.Disabled, false)).toContain(
+      "disabled — AI may only inspect",
+    );
+  });
+
+  /*
+   * The canonical KubernetesAiRemediationMode comment, clause by clause:
+   * Bypass approval does not ask — except for a protected-namespace write,
+   * a node drain and a node taint, which always need a human, and a round
+   * becomes a proposal when the breaker trips or another unattended round
+   * holds the cluster; Automatic runs safe (and allowlisted) fixes and
+   * proposes a riskier one for one-click approval, never leaving it only
+   * in the recommendations.
+   */
+  it("states every mode the way the canonical comment does", () => {
+    const describeReady: (mode: KubernetesAiRemediationMode) => string = (
+      mode: KubernetesAiRemediationMode,
+    ): string => {
+      return ClusterAccessContext.buildContextSection([
+        status({ remediationMode: mode, isRemediationReady: true }),
+      ]);
+    };
+
+    const bypass: string = describeReady(
+      KubernetesAiRemediationMode.BypassApproval,
+    );
+    const automatic: string = describeReady(
+      KubernetesAiRemediationMode.Automatic,
+    );
+
+    for (const text of [bypass, automatic]) {
+      // Automatic's copy starts a sentence with it, so compare case-blind.
+      expect(text.toLowerCase()).toContain(
+        KUBECTL_ALWAYS_ASKS_SUMMARY.toLowerCase(),
+      );
+      expect(text).toMatch(DRAIN_WORD_PATTERN);
+      expect(text).toMatch(TAINT_WORD_PATTERN);
+      for (const namespace of PROTECTED_KUBERNETES_NAMESPACES) {
+        expect(text).toContain(namespace);
+      }
+      expect(text).toContain(UNATTENDED_ROUND_BECOMES_PROPOSAL_SUMMARY);
+      expect(text).toContain("destructive commands never run");
+      expect(text).not.toMatch(NOTHING_IS_ASKED_PATTERN);
+      expect(text).not.toContain("left in the recommendations");
+    }
+
+    expect(UNATTENDED_ROUND_BECOMES_PROPOSAL_SUMMARY).toContain(
+      "circuit breaker trips",
+    );
+    expect(UNATTENDED_ROUND_BECOMES_PROPOSAL_SUMMARY).toContain(
+      "another unattended round already holds the cluster",
+    );
+
+    expect(bypass).toContain("AI does not ask");
+    expect(bypass).toContain("safe and riskier");
+    expect(bypass).toContain("follow-up rounds included");
+
+    expect(automatic).toContain(
+      "riskier ones whose shape the cluster's kubectl allowlist names",
+    );
+    expect(automatic).toContain(
+      "a round that finds only riskier fixes proposes them for one-click approval",
+    );
+    expect(automatic).toContain(
+      "a riskier one is proposed only if verification shows they did not recover the signal",
+    );
+
+    // Negative control: a cluster that asks for everything says only that.
+    const requireApproval: string = describeReady(
+      KubernetesAiRemediationMode.RequireApproval,
+    );
+    expect(requireApproval).toContain("a human approves any kubectl fix");
+    expect(requireApproval).not.toContain(
+      UNATTENDED_ROUND_BECOMES_PROPOSAL_SUMMARY,
+    );
+  });
+
+  it("tells the model why a cluster is unreachable and to say so", () => {
+    const section: string = ClusterAccessContext.buildContextSection([
+      status({
+        isInvestigationReady: false,
+        gaps: [
+          {
+            code: "runner_offline",
+            title: "The Runner is offline",
+            description: "x",
+            nextStep: "y",
+            blocks: "both",
+          },
+          {
+            code: "remediation_disabled",
+            title: "AI remediation is turned off for this cluster",
+            description: "x",
+            nextStep: "y",
+            blocks: "remediation",
+          },
+        ],
+      }),
+    ]);
+
+    expect(section).toContain("NO kubectl access — The Runner is offline");
+    // A remediation-only gap is not a reason the investigation failed.
+    expect(section).not.toContain("remediation is turned off");
+    expect(section).toContain("OneUptime telemetry only");
+  });
+
+  it("builds a persona addendum that covers ready, unreachable and the report section", () => {
+    const addendum: string = ClusterAccessContext.buildPersonaAddendum([
+      status(),
+      status({
+        clusterId: "99999999-9999-4999-8999-999999999999",
+        clusterName: "staging",
+        isInvestigationReady: false,
+      }),
+    ]);
+
+    expect(addendum).toContain('can inspect directly: "prod-us"');
+    expect(addendum).toContain("Use run_kubectl for READ-ONLY inspection");
+    // Secrets are refused by the policy and output is redacted: said up front.
+    expect(addendum).toContain("Reading Secrets is refused");
+    expect(addendum).toContain("redacted from every output");
+    expect(addendum).toContain('CANNOT reach with kubectl: "staging"');
+    expect(addendum).toContain("Do NOT invent kubectl output");
+    expect(addendum).toContain(
+      `**${ClusterAccessContext.REPORT_SECTION_HEADING}**`,
+    );
+  });
+
+  /*
+   * The in-cluster Runner can be down exactly when the cluster is in
+   * trouble. The model must know that a command which did not run is not
+   * evidence, and that an unresponsive Runner means "stop trying kubectl
+   * on that cluster" rather than "try again".
+   */
+  it("tells the model a command that did not run is not evidence, and to stop on an unresponsive Runner", () => {
+    const addendum: string = ClusterAccessContext.buildPersonaAddendum([
+      status(),
+    ]);
+
+    expect(addendum).toContain("Every kubectl command that ran is cited");
+    expect(addendum).toContain(
+      "a command that could not run comes back as an error, is not evidence",
+    );
+    expect(addendum).toContain("did not pick up a command");
+    expect(addendum).toContain("do not call run_kubectl on it again");
+    expect(addendum).not.toContain("try again");
+    expect(addendum).toContain("the cluster's Runner not responding");
+  });
+
+  it("describes missing access for humans with the first blocking gap and its next step", () => {
+    const text: string = ClusterAccessContext.describeMissingAccessForHumans(
+      status({
+        isInvestigationReady: false,
+        gaps: [
+          {
+            code: "investigation_disabled",
+            title: "AI investigation is turned off for this cluster",
+            description: "x",
+            nextStep: 'Turn on "Let AI investigate with kubectl".',
+            blocks: "investigation",
+          },
+        ],
+      }),
+    );
+
+    expect(text).toBe(
+      'OneUptime AI could not run kubectl on cluster "prod-us": ai investigation is turned off for this cluster. Turn on "Let AI investigate with kubectl".',
+    );
+
+    expect(ClusterAccessContext.describeMissingAccessForHumans(status())).toBe(
+      'OneUptime AI has kubectl access to cluster "prod-us".',
+    );
+  });
+});