@mycadet/assistant 0.12.7 → 0.12.8

package/src/{platform → cloud}/client.test.ts

@@ -9,30 +9,30 @@ import {
 // Mutable mock state
 // ---------------------------------------------------------------------------
 
-let mockManagedProxyCtx = {
+let mockCloudProxyCtx = {
   enabled: false,
-  platformBaseUrl: "",
+  cloudBaseUrl: "",
   assistantApiKey: "",
 };
 let mockAssistantId = "";
 const mockSecureKeys = useMemorySecureKeys();
 // Re-pointable so the probe-deadline tests can hang context resolution.
-let mockResolveManagedProxyContext: () => Promise<
-  typeof mockManagedProxyCtx
-> = async () => mockManagedProxyCtx;
+let mockResolveCloudProxyContext: () => Promise<
+  typeof mockCloudProxyCtx
+> = async () => mockCloudProxyCtx;
 
 // ---------------------------------------------------------------------------
 // Module mocks
 // ---------------------------------------------------------------------------
 
-mock.module("../providers/platform-proxy/context.js", () => ({
-  resolveManagedProxyContext: () => mockResolveManagedProxyContext(),
+mock.module("../providers/cloud-proxy/context.js", () => ({
+  resolveCloudProxyContext: () => mockResolveCloudProxyContext(),
 }));
 
 const actualEnv = await import("../config/env.js");
 mock.module("../config/env.js", () => ({
   ...actualEnv,
-  getPlatformAssistantId: () => mockAssistantId,
+  getCloudAssistantId: () => mockAssistantId,
 }));
 
 mock.module("../security/credential-key.js", () => ({
@@ -45,27 +45,27 @@ mock.module("../security/credential-key.js", () => ({
 
 import {
   _resetConfiguredProbeCacheForTests,
-  CadetPlatformClient,
-  isPlatformClientConfigured,
+  CadetCloudClient,
+  isCloudClientConfigured,
 } from "./client.js";
 
 // ---------------------------------------------------------------------------
 // Tests
 // ---------------------------------------------------------------------------
 
-describe("CadetPlatformClient", () => {
+describe("CadetCloudClient", () => {
   let originalFetch: typeof globalThis.fetch;
 
   beforeEach(() => {
     originalFetch = globalThis.fetch;
-    mockManagedProxyCtx = {
+    mockCloudProxyCtx = {
       enabled: true,
-      platformBaseUrl: "https://platform.example.com",
+      cloudBaseUrl: "https://platform.example.com",
       assistantApiKey: "sk-test-key",
     };
     mockAssistantId = "asst-123";
     reseedMemorySecureKeys(mockSecureKeys);
-    mockResolveManagedProxyContext = async () => mockManagedProxyCtx;
+    mockResolveCloudProxyContext = async () => mockCloudProxyCtx;
     _resetConfiguredProbeCacheForTests();
   });
 
@@ -75,80 +75,79 @@ describe("CadetPlatformClient", () => {
 
   describe("create()", () => {
     test("returns a client when all prerequisites are met", async () => {
-      const client = await CadetPlatformClient.create();
+      const client = await CadetCloudClient.create();
       expect(client).not.toBeNull();
       expect(client!.baseUrl).toBe("https://platform.example.com");
       expect(client!.assistantApiKey).toBe("sk-test-key");
-      expect(client!.platformAssistantId).toBe("asst-123");
+      expect(client!.cloudAssistantId).toBe("asst-123");
     });
 
-    test("returns null when managed proxy is not enabled", async () => {
-      mockManagedProxyCtx = {
+    test("returns null when cloud proxy is not enabled", async () => {
+      mockCloudProxyCtx = {
         enabled: false,
-        platformBaseUrl: "",
+        cloudBaseUrl: "",
         assistantApiKey: "",
       };
 
-      const client = await CadetPlatformClient.create();
+      const client = await CadetCloudClient.create();
       expect(client).toBeNull();
     });
 
     test("returns client with empty assistantId when assistant ID is missing", async () => {
       mockAssistantId = "";
 
-      const client = await CadetPlatformClient.create();
+      const client = await CadetCloudClient.create();
       expect(client).not.toBeNull();
-      expect(client!.platformAssistantId).toBe("");
+      expect(client!.cloudAssistantId).toBe("");
     });
 
     test("strips trailing slash from platform base URL", async () => {
-      mockManagedProxyCtx.platformBaseUrl = "https://platform.example.com///";
+      mockCloudProxyCtx.cloudBaseUrl = "https://platform.example.com///";
 
-      const client = await CadetPlatformClient.create();
+      const client = await CadetCloudClient.create();
       expect(client!.baseUrl).toBe("https://platform.example.com");
     });
 
-    test("falls back to credential store values when managed context is not rehydrated", async () => {
-      mockManagedProxyCtx = {
+    test("returns null when managed context is not rehydrated, even with stored credentials", async () => {
+      mockCloudProxyCtx = {
         enabled: false,
-        platformBaseUrl: "",
+        cloudBaseUrl: "",
         assistantApiKey: "",
       };
       mockAssistantId = "stored-assistant-id";
       reseedMemorySecureKeys(mockSecureKeys, {
-        "cadet:platform_base_url": "https://stored-platform.example.com/",
         "cadet:assistant_api_key": "stored-api-key",
         "cadet:platform_assistant_id": " vault-assistant-id ",
       });
 
-      const client = await CadetPlatformClient.create();
+      // The base URL resolves from config or CADET_CLOUD_URL only — the
+      // credential store never carried it — so a disabled context has no
+      // target to send the key to.
+      const client = await CadetCloudClient.create();
 
-      expect(client).not.toBeNull();
-      expect(client!.baseUrl).toBe("https://stored-platform.example.com");
-      expect(client!.assistantApiKey).toBe("stored-api-key");
-      expect(client!.platformAssistantId).toBe("stored-assistant-id");
+      expect(client).toBeNull();
     });
   });
 
-  describe("isPlatformClientConfigured()", () => {
+  describe("isCloudClientConfigured()", () => {
     test("true when base url, api key, and assistant id are all present", async () => {
-      expect(await isPlatformClientConfigured()).toBe(true);
+      expect(await isCloudClientConfigured()).toBe(true);
     });
 
-    test("false when the platform assistant id is missing", async () => {
+    test("false when the cloud assistant id is missing", async () => {
       mockAssistantId = "";
 
-      expect(await isPlatformClientConfigured()).toBe(false);
+      expect(await isCloudClientConfigured()).toBe(false);
     });
 
     test("false when auth prerequisites are missing", async () => {
-      mockManagedProxyCtx = {
+      mockCloudProxyCtx = {
         enabled: false,
-        platformBaseUrl: "",
+        cloudBaseUrl: "",
         assistantApiKey: "",
       };
 
-      expect(await isPlatformClientConfigured()).toBe(false);
+      expect(await isCloudClientConfigured()).toBe(false);
     });
 
     test("hung resolution answers false at the deadline, then serves the late result from cache", async () => {
@@ -156,14 +155,14 @@ describe("CadetPlatformClient", () => {
       const hang = new Promise<void>((resolve) => {
         releaseHang = resolve;
       });
-      mockResolveManagedProxyContext = async () => {
+      mockResolveCloudProxyContext = async () => {
         await hang;
-        return mockManagedProxyCtx;
+        return mockCloudProxyCtx;
       };
 
       // Resolution is hung and no result has ever settled -- the deadline
       // must answer false instead of stalling the caller.
-      expect(await isPlatformClientConfigured()).toBe(false);
+      expect(await isCloudClientConfigured()).toBe(false);
 
       // Release the abandoned resolution; it settles true in the background
       // and refreshes the cache.
@@ -171,21 +170,21 @@ describe("CadetPlatformClient", () => {
       await Bun.sleep(10);
 
       // Resolution hangs forever this time, but the cache answers true.
-      mockResolveManagedProxyContext = () => new Promise(() => {});
-      expect(await isPlatformClientConfigured()).toBe(true);
+      mockResolveCloudProxyContext = () => new Promise(() => {});
+      expect(await isCloudClientConfigured()).toBe(true);
     });
 
     test("concurrent calls share a single in-flight resolution", async () => {
       let resolutionCount = 0;
-      mockResolveManagedProxyContext = async () => {
+      mockResolveCloudProxyContext = async () => {
         resolutionCount += 1;
         await Bun.sleep(5);
-        return mockManagedProxyCtx;
+        return mockCloudProxyCtx;
       };
 
       const [first, second] = await Promise.all([
-        isPlatformClientConfigured(),
-        isPlatformClientConfigured(),
+        isCloudClientConfigured(),
+        isCloudClientConfigured(),
       ]);
 
       expect(first).toBe(true);
@@ -195,13 +194,13 @@ describe("CadetPlatformClient", () => {
 
     test("a settled flight clears, so the next call starts a fresh resolution", async () => {
       let resolutionCount = 0;
-      mockResolveManagedProxyContext = async () => {
+      mockResolveCloudProxyContext = async () => {
         resolutionCount += 1;
-        return mockManagedProxyCtx;
+        return mockCloudProxyCtx;
       };
 
-      expect(await isPlatformClientConfigured()).toBe(true);
-      expect(await isPlatformClientConfigured()).toBe(true);
+      expect(await isCloudClientConfigured()).toBe(true);
+      expect(await isCloudClientConfigured()).toBe(true);
       expect(resolutionCount).toBe(2);
     });
 
@@ -210,22 +209,22 @@ describe("CadetPlatformClient", () => {
       // The first resolution hangs forever; only the rotated-in second one
       // settles.
       const pendingHangs = [new Promise<void>(() => {})];
-      mockResolveManagedProxyContext = async () => {
+      mockResolveCloudProxyContext = async () => {
         resolutionCount += 1;
         const hang = pendingHangs.shift();
         if (hang) {
           await hang;
         }
-        return mockManagedProxyCtx;
+        return mockCloudProxyCtx;
       };
 
       // The first caller abandons the hung flight at the deadline.
-      expect(await isPlatformClientConfigured()).toBe(false);
+      expect(await isCloudClientConfigured()).toBe(false);
 
       // The hung flight is marked abandoned, so the next caller rotates in a
       // fresh resolution instead of joining it; the fresh flight settles
       // immediately and answers live.
-      expect(await isPlatformClientConfigured()).toBe(true);
+      expect(await isCloudClientConfigured()).toBe(true);
       expect(resolutionCount).toBe(2);
     });
 
@@ -237,15 +236,15 @@ describe("CadetPlatformClient", () => {
       const gate = new Promise<void>((resolve) => {
         release = resolve;
       });
-      mockResolveManagedProxyContext = async () => {
+      mockResolveCloudProxyContext = async () => {
         resolutionCount += 1;
         await gate;
-        return mockManagedProxyCtx;
+        return mockCloudProxyCtx;
       };
 
-      const first = isPlatformClientConfigured();
+      const first = isCloudClientConfigured();
       await Bun.sleep(1);
-      const second = isPlatformClientConfigured();
+      const second = isCloudClientConfigured();
       release();
 
       expect(await first).toBe(true);
@@ -259,25 +258,25 @@ describe("CadetPlatformClient", () => {
         releaseFirstHang = resolve;
       });
       const pendingHangs = [firstHang];
-      mockResolveManagedProxyContext = async () => {
+      mockResolveCloudProxyContext = async () => {
         const hang = pendingHangs.shift();
         if (hang) {
           await hang;
         }
-        return mockManagedProxyCtx;
+        return mockCloudProxyCtx;
       };
 
       // First caller abandons the hung flight; second caller rotates in a
       // fresh flight that settles true and writes the cache.
-      expect(await isPlatformClientConfigured()).toBe(false);
-      expect(await isPlatformClientConfigured()).toBe(true);
+      expect(await isCloudClientConfigured()).toBe(false);
+      expect(await isCloudClientConfigured()).toBe(true);
 
       // The rotated-out flight now settles resolving an unconfigured
       // context. Generation fencing must keep it from clobbering the newer
       // flight's cached `true`.
-      mockManagedProxyCtx = {
+      mockCloudProxyCtx = {
         enabled: false,
-        platformBaseUrl: "",
+        cloudBaseUrl: "",
         assistantApiKey: "",
       };
       releaseFirstHang();
@@ -285,8 +284,8 @@ describe("CadetPlatformClient", () => {
 
       // Resolution hangs forever, so this answer can only come from the
       // cache, which must still hold the newer flight's `true`.
-      mockResolveManagedProxyContext = () => new Promise(() => {});
-      expect(await isPlatformClientConfigured()).toBe(true);
+      mockResolveCloudProxyContext = () => new Promise(() => {});
+      expect(await isCloudClientConfigured()).toBe(true);
     });
   });
 
@@ -299,7 +298,7 @@ describe("CadetPlatformClient", () => {
         return new Response("ok", { status: 200 });
       }) as unknown as typeof globalThis.fetch;
 
-      const client = await CadetPlatformClient.create();
+      const client = await CadetCloudClient.create();
       await client!.fetch("/v1/some/endpoint/");
     });
 
@@ -312,7 +311,7 @@ describe("CadetPlatformClient", () => {
         },
       ) as unknown as typeof globalThis.fetch;
 
-      const client = await CadetPlatformClient.create();
+      const client = await CadetCloudClient.create();
       await client!.fetch("/v1/test/");
     });
 
@@ -326,7 +325,7 @@ describe("CadetPlatformClient", () => {
         },
       ) as unknown as typeof globalThis.fetch;
 
-      const client = await CadetPlatformClient.create();
+      const client = await CadetCloudClient.create();
       await client!.fetch("/v1/test/", {
         method: "POST",
         headers: { "Content-Type": "application/json" },
@@ -342,7 +341,7 @@ describe("CadetPlatformClient", () => {
         },
       ) as unknown as typeof globalThis.fetch;
 
-      const client = await CadetPlatformClient.create();
+      const client = await CadetCloudClient.create();
       await client!.fetch("/v1/test/", {
         method: "POST",
         body: '{"key":"value"}',
@@ -366,7 +365,7 @@ describe("CadetPlatformClient", () => {
         );
       }) as unknown as typeof globalThis.fetch;
 
-      const client = await CadetPlatformClient.create();
+      const client = await CadetCloudClient.create();
       const consent = await client!.getOwnerConsent();
       expect(consent).toEqual({
         shareAnalytics: true,
@@ -375,7 +374,7 @@ describe("CadetPlatformClient", () => {
       });
     });
 
-    test("defaults shareDiagnosticsAcceptedVersion to '' when the platform omits it (back-compat)", async () => {
+    test("defaults shareDiagnosticsAcceptedVersion to '' when the cloud omits it (back-compat)", async () => {
       globalThis.fetch = mock(
         async () =>
           new Response(
@@ -384,7 +383,7 @@ describe("CadetPlatformClient", () => {
           ),
       ) as unknown as typeof globalThis.fetch;
 
-      const client = await CadetPlatformClient.create();
+      const client = await CadetCloudClient.create();
       const consent = await client!.getOwnerConsent();
       expect(consent).toEqual({
         shareAnalytics: true,
@@ -405,7 +404,7 @@ describe("CadetPlatformClient", () => {
         },
       ) as unknown as typeof globalThis.fetch;
 
-      const client = await CadetPlatformClient.create();
+      const client = await CadetCloudClient.create();
       await client!.getOwnerConsent();
     });
 
@@ -414,7 +413,7 @@ describe("CadetPlatformClient", () => {
         async () => new Response("not found", { status: 404 }),
       ) as unknown as typeof globalThis.fetch;
 
-      const client = await CadetPlatformClient.create();
+      const client = await CadetCloudClient.create();
       expect(await client!.getOwnerConsent()).toBeNull();
     });
 
@@ -423,7 +422,7 @@ describe("CadetPlatformClient", () => {
         async () => new Response("error", { status: 500 }),
       ) as unknown as typeof globalThis.fetch;
 
-      const client = await CadetPlatformClient.create();
+      const client = await CadetCloudClient.create();
       expect(await client!.getOwnerConsent()).toBeNull();
     });
 
@@ -432,7 +431,7 @@ describe("CadetPlatformClient", () => {
         throw new Error("network down");
       }) as unknown as typeof globalThis.fetch;
 
-      const client = await CadetPlatformClient.create();
+      const client = await CadetCloudClient.create();
       expect(await client!.getOwnerConsent()).toBeNull();
     });
 
@@ -449,7 +448,7 @@ describe("CadetPlatformClient", () => {
           ),
       ) as unknown as typeof globalThis.fetch;
 
-      const client = await CadetPlatformClient.create();
+      const client = await CadetCloudClient.create();
       const consent = await client!.getOwnerConsent();
       expect(consent).toEqual({
         shareAnalytics: true,
@@ -471,7 +470,7 @@ describe("CadetPlatformClient", () => {
           ),
       ) as unknown as typeof globalThis.fetch;
 
-      const client = await CadetPlatformClient.create();
+      const client = await CadetCloudClient.create();
       const consent = await client!.getOwnerConsent();
       expect(consent).toEqual({
         shareAnalytics: false,
@@ -493,7 +492,7 @@ describe("CadetPlatformClient", () => {
           ),
       ) as unknown as typeof globalThis.fetch;
 
-      const client = await CadetPlatformClient.create();
+      const client = await CadetCloudClient.create();
       const consent = await client!.getOwnerConsent();
       expect(consent).toEqual({
         shareAnalytics: true,
@@ -512,7 +511,7 @@ describe("CadetPlatformClient", () => {
           ),
       ) as unknown as typeof globalThis.fetch;
 
-      const client = await CadetPlatformClient.create();
+      const client = await CadetCloudClient.create();
       expect(await client!.getOwnerConsent()).toBeNull();
     });
 
@@ -529,8 +528,8 @@ describe("CadetPlatformClient", () => {
       );
       globalThis.fetch = fetchSpy as unknown as typeof globalThis.fetch;
 
-      const client = await CadetPlatformClient.create();
-      expect(client!.platformAssistantId).toBe("");
+      const client = await CadetCloudClient.create();
+      expect(client!.cloudAssistantId).toBe("");
       expect(await client!.getOwnerConsent()).toBeNull();
       expect(fetchSpy).not.toHaveBeenCalled();
     });