@oneuptime/common 14.0.9 → 14.0.10

package/Tests/Server/Middleware/TelemetryIngestBrowserKey.test.ts

@@ -647,18 +647,22 @@ describe("TelemetryIngest browser ingestion key guard", () => {
 
     test("a browser key is refused 403 on every other surface, naming the surface and pointing at a server key", async () => {
       /*
-       * Ten infrastructure / build-time pipes plus the two identity
-       * registrations (the Kubernetes agent Runner and the Kubernetes AI
-       * agent), which mint cluster credentials and must never be reachable
-       * with a key scraped off a page.
+       * Ten infrastructure / build-time pipes plus the three identity
+       * registrations (the Kubernetes agent Runner, the Kubernetes AI agent
+       * and the resource AI agents), which mint cluster or infrastructure
+       * credentials and must never be reachable with a key scraped off a
+       * page.
        */
-      expect(BROWSER_DISALLOWED_SURFACES.length).toBe(12);
+      expect(BROWSER_DISALLOWED_SURFACES.length).toBe(13);
       expect(BROWSER_DISALLOWED_SURFACES).toContain(
         TelemetryIngestSurface.KubernetesAgentRunner,
       );
       expect(BROWSER_DISALLOWED_SURFACES).toContain(
         TelemetryIngestSurface.KubernetesAiAgent,
       );
+      expect(BROWSER_DISALLOWED_SURFACES).toContain(
+        TelemetryIngestSurface.ResourceAiAgent,
+      );
 
       for (const surface of BROWSER_DISALLOWED_SURFACES) {
         jest.clearAllMocks();
@@ -804,6 +808,60 @@ describe("TelemetryIngest browser ingestion key guard", () => {
     });
   });
 
+  /*
+   * A resource AI agent (Docker, Podman, Docker Swarm, Proxmox, VMware,
+   * Ceph, a database server or a host) registers the same way and is handed
+   * the agent key every command for its resource is claimed with, so it is
+   * held to the same bar as the two Kubernetes registrations above.
+   */
+  describe("resource AI agent registration surface", () => {
+    test("a browser key is refused 403 even from an allowed origin", async () => {
+      resolveTo(buildBrowserPolicy({ allowedOrigins: [ALLOWED_ORIGIN] }));
+
+      const result: RunResult = await run(
+        TelemetryIngestSurface.ResourceAiAgent,
+        tokenHeaders({ origin: ALLOWED_ORIGIN }),
+      );
+
+      expect(result.next).not.toHaveBeenCalled();
+
+      const error: Error = refusal();
+      expect(error).toBeInstanceOf(NotAuthorizedException);
+      expect(error.message).toBe(
+        "A browser ingestion key cannot be used for infrastructure AI agent registration. Use a server ingestion key.",
+      );
+      expect((result.req as TelemetryRequest).projectId).toBeUndefined();
+    });
+
+    test("a server key is admitted and the resolved key policy (with its id) is put on the request", async () => {
+      const policy: TelemetryIngestionKeyPolicy = buildPolicy({});
+      resolveTo(policy);
+
+      const result: RunResult = await run(
+        TelemetryIngestSurface.ResourceAiAgent,
+        tokenHeaders(),
+      );
+
+      expect(Response.sendErrorResponse as MockFn).not.toHaveBeenCalled();
+      expect(result.next).toHaveBeenCalledTimes(1);
+      expect((result.req as TelemetryRequest).projectId.toString()).toBe(
+        PROJECT_ID,
+      );
+
+      /*
+       * The registration route records which ingestion key minted the
+       * agent's key (ResourceAiAgent.registeredWithIngestionKeyId) from
+       * exactly this.
+       */
+      expect((result.req as TelemetryRequest).ingestionKeyPolicy).toBe(policy);
+      expect(
+        (
+          result.req as TelemetryRequest
+        ).ingestionKeyPolicy.ingestionKeyId.toString(),
+      ).toBe(INGESTION_KEY_ID);
+    });
+  });
+
   describe("browser key origin allowlist", () => {
     test("a browser key is admitted from an origin on its allowlist", async () => {
       resolveTo(buildBrowserPolicy({ allowedOrigins: [ALLOWED_ORIGIN] }));

package/Tests/Server/Middleware/TelemetryIngestKubernetesAgentRunnerPinnedKey.test.ts

@@ -294,14 +294,112 @@ describe("TelemetryIngest refuses a service-pinned key for Kubernetes AI agent r
     "the refusal on %s names that surface's identity and says what to use instead",
     (surface: TelemetryIngestSurface) => {
       const message: string = getPinnedKeyRegistrationRefusalMessage(surface);
+      const expectedIdentity: Record<string, string> = {
+        [TelemetryIngestSurface.KubernetesAiAgent]:
+          "Kubernetes AI agent registration",
+        [TelemetryIngestSurface.KubernetesAgentRunner]:
+          "Kubernetes agent Runner registration",
+        [TelemetryIngestSurface.ResourceAiAgent]:
+          "infrastructure AI agent registration",
+      };
 
       expect(message).toContain("pinned to a single service");
       expect(message).toContain("unpinned server ingestion key");
-      expect(message).toContain(
-        surface === TelemetryIngestSurface.KubernetesAiAgent
-          ? "Kubernetes AI agent registration"
-          : "Kubernetes agent Runner registration",
-      );
+      expect(expectedIdentity[surface]).toBeDefined();
+      expect(message).toContain(expectedIdentity[surface]);
     },
   );
+
+  test("the Kubernetes surfaces keep their wording exactly", () => {
+    /*
+     * Pinned word for word: the resource AI agent got its own wording, and
+     * adding it must not have changed what a Kubernetes operator reads.
+     */
+    expect(
+      getPinnedKeyRegistrationRefusalMessage(
+        TelemetryIngestSurface.KubernetesAiAgent,
+      ),
+    ).toBe(
+      "This telemetry ingestion key is pinned to a single service, so it cannot be used for Kubernetes AI agent registration: that grants access to a Kubernetes cluster, not to one service's telemetry. Use an unpinned server ingestion key for the Kubernetes agent.",
+    );
+    expect(
+      getPinnedKeyRegistrationRefusalMessage(
+        TelemetryIngestSurface.KubernetesAgentRunner,
+      ),
+    ).toBe(
+      "This telemetry ingestion key is pinned to a single service, so it cannot be used for Kubernetes agent Runner registration: that grants access to a Kubernetes cluster, not to one service's telemetry. Use an unpinned server ingestion key for the Kubernetes agent.",
+    );
+  });
+
+  test("the resource AI agent refusal speaks of infrastructure, never of Kubernetes", () => {
+    const message: string = getPinnedKeyRegistrationRefusalMessage(
+      TelemetryIngestSurface.ResourceAiAgent,
+    );
+
+    expect(message).toBe(
+      "This telemetry ingestion key is pinned to a single service, so it cannot be used for infrastructure AI agent registration: that grants access to your infrastructure, not to one service's telemetry. Use an unpinned server ingestion key for the AI agent.",
+    );
+    expect(message).not.toContain("Kubernetes");
+    expect(message).not.toContain("Runner");
+  });
+});
+
+describe("TelemetryIngest refuses a service-pinned key for resource AI agent registration", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+
+    (TelemetryIngestionKeyService.markUsed as MockFn).mockResolvedValue(
+      undefined as never,
+    );
+    (TelemetryIngestionKeyRateLimiter.consume as MockFn).mockResolvedValue({
+      outcome: TelemetryIngestionKeyLimitOutcome.Allowed,
+    } as never);
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  test("a pinned server key is refused 403 on the resource AI agent surface, before the limiter", async () => {
+    (
+      TelemetryIngestionKeyService.getPolicyFromSecretKey as MockFn
+    ).mockResolvedValue(
+      serverPolicy({ pinnedServiceName: "checkout-api" }) as never,
+    );
+
+    const result: RunResult = await run(TelemetryIngestSurface.ResourceAiAgent);
+
+    expect(result.next).not.toHaveBeenCalled();
+    expect(
+      TelemetryIngestionKeyRateLimiter.consume as MockFn,
+    ).not.toHaveBeenCalled();
+    expect(
+      TelemetryIngestionKeyService.markUsed as MockFn,
+    ).not.toHaveBeenCalled();
+
+    const sendErrorResponse: MockFn = Response.sendErrorResponse as MockFn;
+    expect(sendErrorResponse).toHaveBeenCalledTimes(1);
+
+    const error: Error = sendErrorResponse.mock.calls[0]?.[2] as Error;
+    expect(error).toBeInstanceOf(NotAuthorizedException);
+    expect(error.message).toBe(
+      getPinnedKeyRegistrationRefusalMessage(
+        TelemetryIngestSurface.ResourceAiAgent,
+      ),
+    );
+    expect(error.message).not.toContain(SENTINEL_TOKEN);
+    expect(error.message).not.toContain("checkout-api");
+    expect((result.req as TelemetryRequest).projectId).toBeUndefined();
+  });
+
+  test("negative control: an unpinned server key reaches the resource AI agent registration", async () => {
+    (
+      TelemetryIngestionKeyService.getPolicyFromSecretKey as MockFn
+    ).mockResolvedValue(serverPolicy({ pinnedServiceName: null }) as never);
+
+    const result: RunResult = await run(TelemetryIngestSurface.ResourceAiAgent);
+
+    expect(Response.sendErrorResponse as MockFn).not.toHaveBeenCalled();
+    expect(result.next).toHaveBeenCalledTimes(1);
+  });
 });

package/Tests/Server/Middleware/TelemetryIngestKubernetesAgentRunnerRateLimit.test.ts

@@ -383,11 +383,12 @@ describe("TelemetryIngest identity registration surfaces share one rate limit ru
     jest.restoreAllMocks();
   });
 
-  test("the identity surfaces are exactly the Runner and the Kubernetes AI agent registrations", () => {
+  test("the identity surfaces are exactly the Runner, the Kubernetes AI agent and the resource AI agent registrations", () => {
     expect([...REGISTRATION_SURFACES].sort()).toEqual(
       [
         TelemetryIngestSurface.KubernetesAgentRunner,
         TelemetryIngestSurface.KubernetesAiAgent,
+        TelemetryIngestSurface.ResourceAiAgent,
       ].sort(),
     );
     expect(
@@ -438,6 +439,23 @@ describe("TelemetryIngest identity registration surfaces share one rate limit ru
     },
   );
 
+  test("a server key with no configured limit gets the registration default on the resource AI agent surface", () => {
+    expect(
+      getEffectiveRequestsPerMinuteLimit(
+        buildServerPolicy({ requestsPerMinuteLimit: null }),
+        TelemetryIngestSurface.ResourceAiAgent,
+      ),
+    ).toBe(DEFAULT_IDENTITY_REGISTRATION_REQUESTS_PER_MINUTE);
+
+    // An explicit per-key limit still wins there.
+    expect(
+      getEffectiveRequestsPerMinuteLimit(
+        buildServerPolicy({ requestsPerMinuteLimit: 7 }),
+        TelemetryIngestSurface.ResourceAiAgent,
+      ),
+    ).toBe(7);
+  });
+
   test("a Kubernetes AI agent registration over the default is refused 429 with Retry-After", async () => {
     resolveTo(buildServerPolicy({ requestsPerMinuteLimit: null }));
     limiterAnswers(TelemetryIngestionKeyLimitOutcome.RateLimited, {