@oneuptime/common 14.0.1 → 14.0.3

package/Tests/Types/Kubernetes/KubernetesAgentChartAiAccess.test.ts

@@ -0,0 +1,306 @@
+import {
+  KUBECTL_ALLOW_NODE_OPERATIONS_ENV,
+  KUBECTL_ALLOW_WRITES_ENV,
+  KUBECTL_WRITE_NAMESPACES_ENV,
+  KUBERNETES_AGENT_RUNNER_NAME_PREFIX,
+  PROTECTED_KUBERNETES_NAMESPACES,
+  RUNNER_POD_NAMESPACE_ENV,
+  isKubernetesAgentRunnerName,
+} from "../../../Types/Kubernetes/KubernetesClusterAiAccess";
+import { describe, expect, it } from "@jest/globals";
+import fs from "fs";
+import yaml from "js-yaml";
+import path from "path";
+
+/*
+ * Contract under test — the kubernetes-agent chart and the Runner agree on
+ * the environment the chart hands the in-cluster Runner, and the chart's
+ * operator-facing copy keeps up with its own template:
+ *
+ * - the chart sets ONEUPTIME_KUBECTL_ALLOW_WRITES,
+ *   ONEUPTIME_KUBECTL_WRITE_NAMESPACES, ONEUPTIME_KUBECTL_ALLOW_NODE_OPERATIONS
+ *   and ONEUPTIME_RUNNER_POD_NAMESPACE under exactly the names Common
+ *   declares (the Runner reads them through the same constants), the pod
+ *   namespace from the downward API, and the node-operations switch from
+ *   the same two values that decide whether the node role is rendered — so
+ *   aiAccess.remediation.nodeOperations=false reaches the Runner, not only
+ *   RBAC;
+ * - every variable the chart sets itself is one aiAccess.extraEnv may not
+ *   set: the kubelet keeps the LAST definition of a duplicate name, so an
+ *   unreserved one could be silently replaced (tests/ai-runner_test.yaml
+ *   renders the refusal; this pins that the list keeps up with the env);
+ * - values.yaml and values.schema.json name every reserved variable, so an
+ *   operator learns it before the render fails;
+ * - the Runner row the chart registers is one the server recognises as the
+ *   agent's own (isKubernetesAgentRunnerName);
+ * - the values tables in the chart README and the Kubernetes agent docs
+ *   page list every aiAccess value values.yaml defines, and values.yaml
+ *   names every protected namespace.
+ *
+ * The RBAC itself is asserted by rendering, in tests/ai-runner_test.yaml.
+ */
+
+const REPO_ROOT: string = path.resolve(__dirname, "../../../../..");
+const CHART_DIR: string = path.join(
+  REPO_ROOT,
+  "HelmChart",
+  "Public",
+  "kubernetes-agent",
+);
+const TEMPLATE_PATH: string = path.join(
+  CHART_DIR,
+  "templates",
+  "ai-runner.yaml",
+);
+const VALUES_PATH: string = path.join(CHART_DIR, "values.yaml");
+const SCHEMA_PATH: string = path.join(CHART_DIR, "values.schema.json");
+const README_PATH: string = path.join(CHART_DIR, "README.md");
+const TELEMETRY_DOC_PATH: string = path.join(
+  REPO_ROOT,
+  "packages",
+  "App",
+  "FeatureSet",
+  "Docs",
+  "Content",
+  "en",
+  "telemetry",
+  "kubernetes-agent.md",
+);
+
+// The node-operations role renders only inside both switches.
+const NODE_ROLE_GATE_PATTERN: RegExp =
+  /\{\{- if \$allowWrites \}\}[\s\S]*\{\{- if \$nodeOperations \}\}[\s\S]*-ai-runner-node-operations/;
+
+function read(filePath: string): string {
+  return fs.readFileSync(filePath, "utf8");
+}
+
+// The names the Deployment's container env sets, in order.
+function getChartEnvNames(template: string): Array<string> {
+  const envBlock: string | undefined = template.split(/^ {10}env:$/m)[1];
+
+  if (!envBlock) {
+    throw new Error("templates/ai-runner.yaml has no container env block");
+  }
+
+  const envSection: string = envBlock.split(/^ {10}ports:$/m)[0] || "";
+
+  return Array.from(
+    envSection.matchAll(/^ {12}- name: ([A-Za-z0-9_]+)$/gm),
+  ).map((match: RegExpMatchArray) => {
+    return match[1]!;
+  });
+}
+
+// The names the template refuses in aiAccess.extraEnv.
+function getReservedEnvNames(template: string): Array<string> {
+  return Array.from(
+    template.matchAll(/set \$reservedEnv "([A-Za-z0-9_]+)"/g),
+  ).map((match: RegExpMatchArray) => {
+    return match[1]!;
+  });
+}
+
+// "remediation.namespaces", "image.tag", ... for every leaf under aiAccess.
+function getLeafKeys(value: unknown, prefix: string): Array<string> {
+  if (value && typeof value === "object" && !Array.isArray(value)) {
+    return Object.entries(value as Record<string, unknown>).flatMap(
+      ([key, child]: [string, unknown]) => {
+        return getLeafKeys(child, prefix ? `${prefix}.${key}` : key);
+      },
+    );
+  }
+
+  return [prefix];
+}
+
+describe("the kubernetes-agent chart's Runner environment", () => {
+  const template: string = read(TEMPLATE_PATH);
+  const envNames: Array<string> = getChartEnvNames(template);
+  const reservedEnvNames: Array<string> = getReservedEnvNames(template);
+
+  it("parses the env block it asserts on", () => {
+    /*
+     * A guard for the helpers: a template reshuffle that hides the env
+     * block must fail here, not make every assertion below vacuous.
+     */
+    expect(envNames).toContain("ONEUPTIME_URL");
+    expect(envNames).toContain("PORT");
+    expect(reservedEnvNames.length).toBeGreaterThanOrEqual(envNames.length);
+  });
+
+  it("sets the write switch, the write namespaces, the node-operations switch and the pod namespace under the names the Runner reads", () => {
+    expect(envNames).toContain(KUBECTL_ALLOW_WRITES_ENV);
+    expect(envNames).toContain(KUBECTL_WRITE_NAMESPACES_ENV);
+    expect(envNames).toContain(KUBECTL_ALLOW_NODE_OPERATIONS_ENV);
+    expect(envNames).toContain(RUNNER_POD_NAMESPACE_ENV);
+  });
+
+  it("tells the Runner node operations are on exactly when the node role is rendered", () => {
+    /*
+     * The node-operations ClusterRole renders inside `if $allowWrites` and
+     * `if $nodeOperations`, so the switch must be both: nodeOperations=false
+     * would otherwise leave an Automatic cluster auto-running a cordon that
+     * the API server refuses Forbidden. tests/ai-runner_test.yaml renders
+     * the four combinations.
+     */
+    expect(template).toContain(
+      `- name: ${KUBECTL_ALLOW_NODE_OPERATIONS_ENV}\n              value: {{ and $allowWrites $nodeOperations | quote }}`,
+    );
+    expect(template).toMatch(NODE_ROLE_GATE_PATTERN);
+  });
+
+  it("takes the pod namespace from the downward API, not from a value an operator could get wrong", () => {
+    expect(template).toContain(
+      `- name: ${RUNNER_POD_NAMESPACE_ENV}\n              valueFrom:\n                fieldRef:\n                  fieldPath: metadata.namespace`,
+    );
+  });
+
+  it("tells the Runner exactly the namespaces it bound write access in", () => {
+    expect(template).toContain(
+      `- name: ${KUBECTL_WRITE_NAMESPACES_ENV}\n              value: {{ join "," $writeNamespaces | quote }}`,
+    );
+  });
+
+  it("reserves every variable it sets, so aiAccess.extraEnv can never silently replace one", () => {
+    const unreserved: Array<string> = envNames.filter((name: string) => {
+      return !reservedEnvNames.includes(name);
+    });
+
+    expect(unreserved).toEqual([]);
+  });
+
+  it("reserves the node-operations switch with a message naming the values to change", () => {
+    expect(reservedEnvNames).toContain(KUBECTL_ALLOW_NODE_OPERATIONS_ENV);
+    expect(template).toContain(
+      `set $reservedEnv "${KUBECTL_ALLOW_NODE_OPERATIONS_ENV}" "the chart sets it from aiAccess.remediation.nodeOperations`,
+    );
+  });
+
+  it("also reserves the dashboard-issued Runner identity, which would take the Runner out of kubernetes-agent mode", () => {
+    expect(reservedEnvNames).toContain("ONEUPTIME_RUNNER_ID");
+    expect(reservedEnvNames).toContain("ONEUPTIME_RUNNER_KEY");
+  });
+
+  it("names every reserved variable in values.yaml and in the schema description", () => {
+    const values: string = read(VALUES_PATH);
+    const schema: {
+      properties: {
+        aiAccess: { properties: { extraEnv: { description: string } } };
+      };
+    } = JSON.parse(read(SCHEMA_PATH));
+    const schemaDescription: string =
+      schema.properties.aiAccess.properties.extraEnv.description;
+
+    for (const name of reservedEnvNames) {
+      expect({ name, inValuesYaml: values.includes(name) }).toEqual({
+        name,
+        inValuesYaml: true,
+      });
+      expect({
+        name,
+        inSchema: schemaDescription.includes(name),
+      }).toEqual({ name, inSchema: true });
+    }
+  });
+
+  it("registers the Runner under a name the server recognises as the agent's own", () => {
+    const runnerName: RegExpMatchArray | null = template.match(
+      /- name: ONEUPTIME_RUNNER_NAME\n\s+value: "([^"{]+)\{\{/,
+    );
+
+    expect(runnerName?.[1]).toBe(`${KUBERNETES_AGENT_RUNNER_NAME_PREFIX}/`);
+    expect(isKubernetesAgentRunnerName(`${runnerName?.[1]}prod-us`)).toBe(true);
+  });
+});
+
+describe("the kubernetes-agent chart's aiAccess copy", () => {
+  const values: Record<string, unknown> = yaml.load(
+    read(VALUES_PATH),
+  ) as Record<string, unknown>;
+  const aiAccessKeys: Array<string> = getLeafKeys(values["aiAccess"], "");
+
+  it("reads the aiAccess values it compares against", () => {
+    expect(aiAccessKeys).toEqual(
+      expect.arrayContaining([
+        "enabled",
+        "remediation.enabled",
+        "remediation.namespaces",
+        "remediation.nodeOperations",
+        "image.repository",
+        "image.tag",
+        "image.pullPolicy",
+        "extraEnv",
+      ]),
+    );
+  });
+
+  it("lists every aiAccess value in the chart README's table", () => {
+    const readme: string = read(README_PATH);
+
+    for (const key of aiAccessKeys) {
+      // resources.requests.cpu and friends share one "resources" row.
+      const rowKey: string = key.startsWith("resources.") ? "resources" : key;
+      expect({ key, listed: readme.includes(`\`${rowKey}\``) }).toEqual({
+        key,
+        listed: true,
+      });
+    }
+  });
+
+  it("lists every aiAccess value in the Kubernetes agent docs page's table", () => {
+    const doc: string = read(TELEMETRY_DOC_PATH);
+
+    for (const key of aiAccessKeys) {
+      const rowKey: string = key.startsWith("resources.")
+        ? "aiAccess.resources"
+        : `aiAccess.${key}`;
+      expect({ key, listed: doc.includes(`\`${rowKey}\``) }).toEqual({
+        key,
+        listed: true,
+      });
+    }
+  });
+
+  it("defaults to read-only, cluster-wide binding when remediation is on, and node operations on", () => {
+    const aiAccess: {
+      enabled: boolean;
+      remediation: {
+        enabled: boolean;
+        namespaces: Array<string>;
+        nodeOperations: boolean;
+      };
+      image: { tag: string; pullPolicy: string };
+    } = values["aiAccess"] as never;
+
+    expect(aiAccess.enabled).toBe(false);
+    expect(aiAccess.remediation).toEqual({
+      enabled: false,
+      namespaces: [],
+      nodeOperations: true,
+    });
+    // Empty tag = the moving `release`; empty pullPolicy = Always for it.
+    expect(aiAccess.image.tag).toBe("");
+    expect(aiAccess.image.pullPolicy).toBe("");
+  });
+
+  it("names every protected namespace where it explains the cluster-wide default", () => {
+    // Only the aiAccess block: coreDns already mentions kube-system.
+    const valuesText: string = read(VALUES_PATH);
+    const blockStart: number = valuesText.indexOf("# OneUptime AI access");
+
+    expect(blockStart).toBeGreaterThan(-1);
+
+    const aiAccessComments: string = valuesText.slice(blockStart);
+
+    for (const namespace of PROTECTED_KUBERNETES_NAMESPACES) {
+      expect({
+        namespace,
+        named: aiAccessComments.includes(namespace),
+      }).toEqual({
+        namespace,
+        named: true,
+      });
+    }
+  });
+});

package/Tests/Types/Kubernetes/KubernetesClusterAiAccess.test.ts

@@ -0,0 +1,283 @@
+import {
+  KubernetesAiRemediationMode,
+  KubernetesRunnerPosture,
+  UNATTENDED_REMEDIATION_MODES,
+  getKubernetesAgentRunnerName,
+  isInClusterPostureForCluster,
+  isKubernetesAgentRunnerPosture,
+  isSameKubernetesClusterIdentifier,
+  isUnattendedRemediationMode,
+  normalizeKubernetesClusterIdentifier,
+  parseKubernetesRunnerPosture,
+} from "../../../Types/Kubernetes/KubernetesClusterAiAccess";
+import { describe, expect, it } from "@jest/globals";
+
+/*
+ * Contract under test — the shared vocabulary of AI cluster access:
+ *
+ * - exactly four remediation modes exist and exactly two of them run
+ *   without a human (Automatic, BypassApproval); every branch that decides
+ *   "does this run unattended?" goes through isUnattendedRemediationMode,
+ *   so a new mode cannot silently become attended or unattended;
+ * - the in-cluster Runner's name is derived from the cluster identifier;
+ * - the Runner posture is parsed defensively from untrusted hostInfo;
+ * - "is this the same cluster?" is ONE rule (case-insensitive, trimmed,
+ *   never true for blanks) shared by the readiness status, the enqueue
+ *   chokepoint and the claim path, and "may this Runner run credential-less
+ *   kubectl for cluster X?" is true only for the in-cluster agent OF X.
+ */
+
+describe("KubernetesAiRemediationMode", () => {
+  it("has exactly the four operator-facing modes", () => {
+    expect(Object.values(KubernetesAiRemediationMode).sort()).toEqual(
+      ["Automatic", "BypassApproval", "Disabled", "RequireApproval"].sort(),
+    );
+  });
+
+  it("treats Automatic and BypassApproval as unattended and nothing else", () => {
+    expect(UNATTENDED_REMEDIATION_MODES).toEqual([
+      KubernetesAiRemediationMode.Automatic,
+      KubernetesAiRemediationMode.BypassApproval,
+    ]);
+
+    expect(
+      isUnattendedRemediationMode(KubernetesAiRemediationMode.Automatic),
+    ).toBe(true);
+    expect(
+      isUnattendedRemediationMode(KubernetesAiRemediationMode.BypassApproval),
+    ).toBe(true);
+    expect(
+      isUnattendedRemediationMode(KubernetesAiRemediationMode.RequireApproval),
+    ).toBe(false);
+    expect(
+      isUnattendedRemediationMode(KubernetesAiRemediationMode.Disabled),
+    ).toBe(false);
+    expect(isUnattendedRemediationMode(undefined)).toBe(false);
+  });
+
+  it("never treats a string that merely looks like a mode as unattended", () => {
+    expect(
+      isUnattendedRemediationMode(
+        "automatic" as unknown as KubernetesAiRemediationMode,
+      ),
+    ).toBe(false);
+    expect(
+      isUnattendedRemediationMode(
+        "Bypass" as unknown as KubernetesAiRemediationMode,
+      ),
+    ).toBe(false);
+  });
+});
+
+describe("getKubernetesAgentRunnerName", () => {
+  it("derives a stable, prefixed name from the cluster identifier", () => {
+    expect(getKubernetesAgentRunnerName("prod-us")).toBe(
+      "kubernetes-agent/prod-us",
+    );
+    expect(getKubernetesAgentRunnerName("prod-us")).toBe(
+      getKubernetesAgentRunnerName("prod-us"),
+    );
+  });
+});
+
+describe("parseKubernetesRunnerPosture", () => {
+  it("returns undefined for a Runner that never reported a Kubernetes posture", () => {
+    expect(parseKubernetesRunnerPosture(undefined)).toBeUndefined();
+    expect(parseKubernetesRunnerPosture(null)).toBeUndefined();
+    expect(parseKubernetesRunnerPosture("nope")).toBeUndefined();
+    expect(parseKubernetesRunnerPosture({})).toBeUndefined();
+    expect(
+      parseKubernetesRunnerPosture({ kubernetes: "not-an-object" }),
+    ).toBeUndefined();
+  });
+
+  it("parses a complete posture and only accepts literal true for the booleans", () => {
+    const posture: KubernetesRunnerPosture | undefined =
+      parseKubernetesRunnerPosture({
+        kubernetes: {
+          clusterIdentifier: "prod-us",
+          inCluster: true,
+          allowWrites: "true",
+          kubectlVersion: "v1.31.4",
+          agentChartVersion: "0.7.0",
+        },
+      });
+
+    expect(posture).toEqual({
+      clusterIdentifier: "prod-us",
+      inCluster: true,
+      allowWrites: false,
+      kubectlVersion: "v1.31.4",
+      agentChartVersion: "0.7.0",
+    });
+  });
+
+  it("drops non-string identifiers rather than coercing them", () => {
+    const posture: KubernetesRunnerPosture | undefined =
+      parseKubernetesRunnerPosture({
+        kubernetes: { clusterIdentifier: 42, kubectlVersion: {} },
+      });
+
+    expect(posture?.clusterIdentifier).toBeUndefined();
+    expect(posture?.kubectlVersion).toBeUndefined();
+    expect(posture?.inCluster).toBe(false);
+    expect(posture?.allowWrites).toBe(false);
+  });
+});
+
+describe("normalizeKubernetesClusterIdentifier", () => {
+  it("trims and lowercases a string and turns anything else into an empty string", () => {
+    expect(normalizeKubernetesClusterIdentifier("  Prod-US ")).toBe("prod-us");
+    expect(normalizeKubernetesClusterIdentifier("prod-us")).toBe("prod-us");
+    expect(normalizeKubernetesClusterIdentifier("")).toBe("");
+    expect(normalizeKubernetesClusterIdentifier("   ")).toBe("");
+    expect(normalizeKubernetesClusterIdentifier(undefined)).toBe("");
+    expect(normalizeKubernetesClusterIdentifier(null)).toBe("");
+    expect(normalizeKubernetesClusterIdentifier(42)).toBe("");
+    expect(normalizeKubernetesClusterIdentifier({ name: "prod" })).toBe("");
+  });
+});
+
+describe("isSameKubernetesClusterIdentifier", () => {
+  it("matches the same cluster across casing and surrounding whitespace", () => {
+    expect(isSameKubernetesClusterIdentifier("prod-us", "prod-us")).toBe(true);
+    expect(isSameKubernetesClusterIdentifier("Prod-US", "prod-us")).toBe(true);
+    expect(isSameKubernetesClusterIdentifier("  prod-us", "prod-us ")).toBe(
+      true,
+    );
+  });
+
+  it("never matches different clusters", () => {
+    expect(isSameKubernetesClusterIdentifier("prod-us", "prod-eu")).toBe(false);
+    expect(isSameKubernetesClusterIdentifier("prod-us", "prod-us-2")).toBe(
+      false,
+    );
+    expect(isSameKubernetesClusterIdentifier("prod", "prod-us")).toBe(false);
+  });
+
+  /*
+   * The load-bearing edge: two blanks are NOT "the same cluster". A Runner
+   * that never said which cluster it is in must not match a cluster row
+   * that has no identifier, or a credential-less command would be served
+   * to a pod nobody can place.
+   */
+  it("never matches when either side is blank or missing", () => {
+    expect(isSameKubernetesClusterIdentifier("", "")).toBe(false);
+    expect(isSameKubernetesClusterIdentifier("   ", "  ")).toBe(false);
+    expect(isSameKubernetesClusterIdentifier(undefined, undefined)).toBe(false);
+    expect(isSameKubernetesClusterIdentifier(null, null)).toBe(false);
+    expect(isSameKubernetesClusterIdentifier("prod-us", "")).toBe(false);
+    expect(isSameKubernetesClusterIdentifier("", "prod-us")).toBe(false);
+    expect(isSameKubernetesClusterIdentifier("prod-us", undefined)).toBe(false);
+    expect(isSameKubernetesClusterIdentifier(undefined, "prod-us")).toBe(false);
+  });
+
+  it("does not coerce non-strings into a match", () => {
+    expect(isSameKubernetesClusterIdentifier(42, 42)).toBe(false);
+    expect(isSameKubernetesClusterIdentifier("42", 42)).toBe(false);
+    expect(isSameKubernetesClusterIdentifier({}, {})).toBe(false);
+  });
+});
+
+describe("isKubernetesAgentRunnerPosture", () => {
+  it("is true only for an in-cluster posture that names its cluster", () => {
+    expect(
+      isKubernetesAgentRunnerPosture({
+        inCluster: true,
+        clusterIdentifier: "prod-us",
+      }),
+    ).toBe(true);
+  });
+
+  it("is false for a pod Runner that never said which cluster it is in", () => {
+    expect(isKubernetesAgentRunnerPosture({ inCluster: true })).toBe(false);
+    expect(
+      isKubernetesAgentRunnerPosture({
+        inCluster: true,
+        clusterIdentifier: "",
+      }),
+    ).toBe(false);
+    expect(
+      isKubernetesAgentRunnerPosture({
+        inCluster: true,
+        clusterIdentifier: "   ",
+      }),
+    ).toBe(false);
+  });
+
+  it("is false for an external Runner even when it names a cluster", () => {
+    expect(
+      isKubernetesAgentRunnerPosture({
+        inCluster: false,
+        clusterIdentifier: "prod-us",
+      }),
+    ).toBe(false);
+    expect(
+      isKubernetesAgentRunnerPosture({ clusterIdentifier: "prod-us" }),
+    ).toBe(false);
+  });
+
+  it("is false for no posture at all", () => {
+    expect(isKubernetesAgentRunnerPosture(undefined)).toBe(false);
+    expect(
+      isKubernetesAgentRunnerPosture(parseKubernetesRunnerPosture({})),
+    ).toBe(false);
+  });
+});
+
+describe("isInClusterPostureForCluster", () => {
+  const agentOfProdUs: KubernetesRunnerPosture = {
+    inCluster: true,
+    allowWrites: true,
+    clusterIdentifier: "prod-us",
+  };
+
+  it("is true for the in-cluster agent of that cluster, case-insensitively", () => {
+    expect(isInClusterPostureForCluster(agentOfProdUs, "prod-us")).toBe(true);
+    expect(isInClusterPostureForCluster(agentOfProdUs, "PROD-US")).toBe(true);
+    expect(isInClusterPostureForCluster(agentOfProdUs, " prod-us ")).toBe(true);
+  });
+
+  /*
+   * The finding: a Runner that is in-cluster somewhere ELSE must never be
+   * "in-cluster" for this cluster — its ServiceAccount reaches the other
+   * cluster only.
+   */
+  it("is false for the in-cluster agent of a different cluster", () => {
+    expect(isInClusterPostureForCluster(agentOfProdUs, "prod-eu")).toBe(false);
+    expect(isInClusterPostureForCluster(agentOfProdUs, "prod-us-2")).toBe(
+      false,
+    );
+  });
+
+  it("is false for an in-cluster Runner with no cluster identity", () => {
+    expect(isInClusterPostureForCluster({ inCluster: true }, "prod-us")).toBe(
+      false,
+    );
+  });
+
+  it("is false when the cluster row itself has no identifier", () => {
+    expect(isInClusterPostureForCluster(agentOfProdUs, "")).toBe(false);
+    expect(isInClusterPostureForCluster(agentOfProdUs, undefined)).toBe(false);
+  });
+
+  it("is false for an external Runner and for no posture", () => {
+    expect(
+      isInClusterPostureForCluster(
+        { inCluster: false, clusterIdentifier: "prod-us" },
+        "prod-us",
+      ),
+    ).toBe(false);
+    expect(isInClusterPostureForCluster(undefined, "prod-us")).toBe(false);
+  });
+
+  it("works on a posture parsed from raw hostInfo", () => {
+    const parsed: KubernetesRunnerPosture | undefined =
+      parseKubernetesRunnerPosture({
+        kubernetes: { inCluster: true, clusterIdentifier: "Prod-US" },
+      });
+
+    expect(isInClusterPostureForCluster(parsed, "prod-us")).toBe(true);
+    expect(isInClusterPostureForCluster(parsed, "prod-eu")).toBe(false);
+  });
+});

package/Tests/Types/Kubernetes/KubernetesRunnerPostureWriteScope.test.ts

@@ -0,0 +1,68 @@
+import {
+  KubernetesRunnerPosture,
+  parseKubernetesRunnerPosture,
+} from "../../../Types/Kubernetes/KubernetesClusterAiAccess";
+
+/*
+ * The in-cluster Runner reports where AI-composed kubectl writes may land
+ * (the namespaces its chart bound write RBAC in; an empty list is
+ * cluster-wide) and the namespace its own pod runs in, which it never
+ * writes to. The server reads both from Runner.hostInfo.kubernetes, which
+ * the Runner itself rewrites on every heartbeat — so the parse is strict
+ * about shapes and never invents a value.
+ */
+describe("parseKubernetesRunnerPosture: the write scope", () => {
+  it("parses the write namespaces and the pod namespace", () => {
+    const posture: KubernetesRunnerPosture | undefined =
+      parseKubernetesRunnerPosture({
+        kubernetes: {
+          clusterIdentifier: "prod-us",
+          inCluster: true,
+          allowWrites: true,
+          writeNamespaces: ["web", "api"],
+          podNamespace: "oneuptime-agent",
+        },
+      });
+
+    expect(posture?.writeNamespaces).toEqual(["web", "api"]);
+    expect(posture?.podNamespace).toBe("oneuptime-agent");
+  });
+
+  it("keeps an empty list, which means cluster-wide", () => {
+    expect(
+      parseKubernetesRunnerPosture({ kubernetes: { writeNamespaces: [] } })
+        ?.writeNamespaces,
+    ).toEqual([]);
+  });
+
+  it("leaves both absent for a Runner that predates them", () => {
+    const posture: KubernetesRunnerPosture | undefined =
+      parseKubernetesRunnerPosture({
+        kubernetes: { clusterIdentifier: "prod-us", inCluster: true },
+      });
+
+    expect(posture?.writeNamespaces).toBeUndefined();
+    expect(posture?.podNamespace).toBeUndefined();
+  });
+
+  it("drops values of the wrong shape rather than coercing them", () => {
+    const posture: KubernetesRunnerPosture | undefined =
+      parseKubernetesRunnerPosture({
+        kubernetes: {
+          writeNamespaces: ["web", 42, "", null, { a: 1 }, "api"],
+          podNamespace: 7,
+        },
+      });
+
+    expect(posture?.writeNamespaces).toEqual(["web", "api"]);
+    expect(posture?.podNamespace).toBeUndefined();
+
+    const notAList: KubernetesRunnerPosture | undefined =
+      parseKubernetesRunnerPosture({
+        kubernetes: { writeNamespaces: "web,api", podNamespace: "" },
+      });
+
+    expect(notAList?.writeNamespaces).toBeUndefined();
+    expect(notAList?.podNamespace).toBeUndefined();
+  });
+});