assistant-cloud 0.1.34 → 0.1.36

package/src/tests/AssistantCloudAPI.test.ts

@@ -1,11 +1,22 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { AssistantCloudAPI } from "../AssistantCloudAPI";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { AssistantCloudAPI, CloudAPIError } from "../AssistantCloudAPI";
+
+const createJwt = () => {
+  const payload = Buffer.from(JSON.stringify({ exp: 4_102_444_800 })).toString(
+    "base64url",
+  );
+  return `header.${payload}.signature`;
+};
 
 describe("AssistantCloudAPI", () => {
   beforeEach(() => {
     vi.restoreAllMocks();
   });
 
+  afterEach(() => {
+    vi.unstubAllGlobals();
+  });
+
   it("serializes query params, merges auth headers, and sends JSON body", async () => {
     const fetchMock = vi.fn().mockResolvedValue({
       ok: true,
@@ -90,6 +101,65 @@ describe("AssistantCloudAPI", () => {
     expect(url.toString()).toBe("https://custom.example.com/v1/threads");
   });
 
+  it("strips a trailing slash from a JWT baseUrl", async () => {
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: true,
+      headers: new Headers(),
+    });
+    vi.stubGlobal("fetch", fetchMock);
+
+    const api = new AssistantCloudAPI({
+      baseUrl: "https://custom.example.com/",
+      authToken: async () => createJwt(),
+    });
+
+    await api.makeRawRequest("/threads");
+
+    const [url] = fetchMock.mock.calls[0]!;
+    expect(url.toString()).toBe("https://custom.example.com/v1/threads");
+  });
+
+  it("strips a trailing slash from anonymous auth URLs", async () => {
+    const storage = {
+      getItem: vi.fn().mockReturnValue(null),
+      setItem: vi.fn(),
+      removeItem: vi.fn(),
+    };
+    vi.stubGlobal("localStorage", storage);
+
+    const fetchMock = vi
+      .fn()
+      .mockResolvedValueOnce({
+        ok: true,
+        json: vi.fn().mockResolvedValue({
+          access_token: createJwt(),
+          refresh_token: {
+            token: "refresh-token",
+            expires_at: "2100-01-01T00:00:00.000Z",
+          },
+        }),
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        headers: new Headers(),
+      });
+    vi.stubGlobal("fetch", fetchMock);
+
+    const api = new AssistantCloudAPI({
+      baseUrl: "https://custom.example.com/",
+      anonymous: true,
+    });
+
+    await api.makeRawRequest("/threads");
+
+    expect(fetchMock.mock.calls[0]![0]).toBe(
+      "https://custom.example.com/v1/auth/tokens/anonymous",
+    );
+    expect(fetchMock.mock.calls[1]![0].toString()).toBe(
+      "https://custom.example.com/v1/threads",
+    );
+  });
+
   it("rejects before fetch when auth token callback returns null", async () => {
     const fetchMock = vi.fn();
     vi.stubGlobal("fetch", fetchMock);
@@ -105,6 +175,15 @@ describe("AssistantCloudAPI", () => {
     expect(fetchMock).not.toHaveBeenCalled();
   });
 
+  it("returns false from initializeAuth when auth token callback returns null", async () => {
+    const api = new AssistantCloudAPI({
+      baseUrl: "https://test.example.com",
+      authToken: async () => null,
+    });
+
+    await expect(api.initializeAuth()).resolves.toBe(false);
+  });
+
   it("throws APIError with parsed message for JSON error responses", async () => {
     const fetchMock = vi.fn().mockResolvedValue({
       ok: false,
@@ -125,9 +204,10 @@ describe("AssistantCloudAPI", () => {
     });
 
     const error = await api.makeRawRequest("/threads").catch((e) => e);
-    expect(error).toBeInstanceOf(Error);
-    expect(error.name).toBe("APIError");
+    expect(error).toBeInstanceOf(CloudAPIError);
+    expect(error.name).toBe("CloudAPIError");
     expect(error.message).toBe("invalid request payload");
+    expect(error.status).toBe(400);
   });
 
   it("throws generic error with status for non-JSON error responses", async () => {
@@ -145,9 +225,10 @@ describe("AssistantCloudAPI", () => {
       workspaceId: "w-1",
     });
 
-    await expect(api.makeRawRequest("/threads")).rejects.toThrow(
-      "Request failed with status 502, Bad Gateway",
-    );
+    const error = await api.makeRawRequest("/threads").catch((e) => e);
+    expect(error).toBeInstanceOf(CloudAPIError);
+    expect(error.message).toBe("Request failed with status 502, Bad Gateway");
+    expect(error.status).toBe(502);
   });
 
   it("makeRequest returns parsed JSON from a successful response", async () => {
@@ -155,7 +236,7 @@ describe("AssistantCloudAPI", () => {
     const fetchMock = vi.fn().mockResolvedValue({
       ok: true,
       headers: new Headers(),
-      json: vi.fn().mockResolvedValue(responseData),
+      text: vi.fn().mockResolvedValue(JSON.stringify(responseData)),
     });
     vi.stubGlobal("fetch", fetchMock);
 
@@ -168,4 +249,62 @@ describe("AssistantCloudAPI", () => {
     const result = await api.makeRequest("/threads");
     expect(result).toEqual(responseData);
   });
+
+  it("makeRequest returns undefined from a successful empty response", async () => {
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: true,
+      status: 204,
+      headers: new Headers(),
+      text: vi.fn().mockResolvedValue(""),
+    });
+    vi.stubGlobal("fetch", fetchMock);
+
+    const api = new AssistantCloudAPI({
+      apiKey: "test-key",
+      userId: "u-1",
+      workspaceId: "w-1",
+    });
+
+    await expect(
+      api.makeRequest("/threads/t-1", { method: "DELETE" }),
+    ).resolves.toBeUndefined();
+  });
+
+  it("makeRequest returns undefined when content-length is zero", async () => {
+    const text = vi.fn().mockResolvedValue("");
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: true,
+      status: 200,
+      headers: new Headers({ "content-length": "0" }),
+      text,
+    });
+    vi.stubGlobal("fetch", fetchMock);
+
+    const api = new AssistantCloudAPI({
+      apiKey: "test-key",
+      userId: "u-1",
+      workspaceId: "w-1",
+    });
+
+    await expect(api.makeRequest("/threads/t-1")).resolves.toBeUndefined();
+    expect(text).not.toHaveBeenCalled();
+  });
+
+  it("makeRequest returns undefined from a whitespace-only success body", async () => {
+    const fetchMock = vi.fn().mockResolvedValue({
+      ok: true,
+      status: 200,
+      headers: new Headers(),
+      text: vi.fn().mockResolvedValue("  "),
+    });
+    vi.stubGlobal("fetch", fetchMock);
+
+    const api = new AssistantCloudAPI({
+      apiKey: "test-key",
+      userId: "u-1",
+      workspaceId: "w-1",
+    });
+
+    await expect(api.makeRequest("/threads/t-1")).resolves.toBeUndefined();
+  });
 });

package/src/tests/AssistantCloudAuthStrategy.test.ts

@@ -0,0 +1,191 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+  AssistantCloudAnonymousAuthStrategy,
+  AssistantCloudJWTAuthStrategy,
+} from "../AssistantCloudAuthStrategy";
+
+const baseUrl = "https://test.example.com";
+const accessToken = `${Buffer.from(JSON.stringify({ alg: "none" })).toString("base64url")}.${Buffer.from(JSON.stringify({ exp: 4102444800 })).toString("base64url")}.sig`;
+const refreshToken = { token: "r1", expires_at: "2099-01-01" };
+
+let originalLocalStorageDescriptor: PropertyDescriptor | undefined;
+
+const installLocalStorage = (storage: Storage): void => {
+  Object.defineProperty(globalThis, "localStorage", {
+    configurable: true,
+    value: storage,
+  });
+};
+
+const mockAnonymousTokenFetch = () => {
+  const fetchMock = vi.fn().mockResolvedValue({
+    ok: true,
+    json: vi.fn().mockResolvedValue({
+      access_token: accessToken,
+      refresh_token: refreshToken,
+    }),
+  });
+  vi.stubGlobal("fetch", fetchMock);
+  return fetchMock;
+};
+
+describe("AssistantCloudAnonymousAuthStrategy", () => {
+  beforeEach(() => {
+    originalLocalStorageDescriptor = Object.getOwnPropertyDescriptor(
+      globalThis,
+      "localStorage",
+    );
+  });
+
+  afterEach(() => {
+    vi.unstubAllGlobals();
+    if (originalLocalStorageDescriptor) {
+      Object.defineProperty(
+        globalThis,
+        "localStorage",
+        originalLocalStorageDescriptor,
+      );
+    } else {
+      delete (globalThis as { localStorage?: Storage }).localStorage;
+    }
+  });
+
+  it("persists the refresh token and returns the anonymous access token", async () => {
+    const values = new Map<string, string>();
+    installLocalStorage({
+      getItem: (key) => values.get(key) ?? null,
+      setItem: (key, value) => {
+        values.set(key, value);
+      },
+      removeItem: (key) => {
+        values.delete(key);
+      },
+    } as Storage);
+    const fetchMock = mockAnonymousTokenFetch();
+
+    const strategy = new AssistantCloudAnonymousAuthStrategy(baseUrl);
+
+    await expect(strategy.getAuthHeaders()).resolves.toEqual({
+      Authorization: `Bearer ${accessToken}`,
+    });
+    expect(values.get("aui:refresh_token")).toBe(JSON.stringify(refreshToken));
+    expect(fetchMock).toHaveBeenCalledWith(
+      `${baseUrl}/v1/auth/tokens/anonymous`,
+      { method: "POST" },
+    );
+  });
+
+  it("deduplicates concurrent anonymous token requests", async () => {
+    delete (globalThis as { localStorage?: Storage }).localStorage;
+    const fetchMock = mockAnonymousTokenFetch();
+    const strategy = new AssistantCloudAnonymousAuthStrategy(baseUrl);
+
+    await expect(
+      Promise.all([
+        strategy.getAuthHeaders(),
+        strategy.getAuthHeaders(),
+        strategy.getAuthHeaders(),
+      ]),
+    ).resolves.toEqual([
+      { Authorization: `Bearer ${accessToken}` },
+      { Authorization: `Bearer ${accessToken}` },
+      { Authorization: `Bearer ${accessToken}` },
+    ]);
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+  });
+
+  it("returns an anonymous access token without localStorage", async () => {
+    delete (globalThis as { localStorage?: Storage }).localStorage;
+    mockAnonymousTokenFetch();
+
+    const strategy = new AssistantCloudAnonymousAuthStrategy(baseUrl);
+
+    await expect(strategy.getAuthHeaders()).resolves.toEqual({
+      Authorization: `Bearer ${accessToken}`,
+    });
+  });
+
+  it("returns an anonymous access token when localStorage access is blocked", async () => {
+    Object.defineProperty(globalThis, "localStorage", {
+      configurable: true,
+      get() {
+        throw new DOMException("blocked", "SecurityError");
+      },
+    });
+    mockAnonymousTokenFetch();
+
+    const strategy = new AssistantCloudAnonymousAuthStrategy(baseUrl);
+
+    await expect(strategy.getAuthHeaders()).resolves.toEqual({
+      Authorization: `Bearer ${accessToken}`,
+    });
+  });
+
+  it("returns an anonymous access token when storage methods throw", async () => {
+    const getItem = vi
+      .fn<(key: string) => string | null>()
+      .mockReturnValueOnce(
+        JSON.stringify({ token: "expired", expires_at: "2022-01-01" }),
+      )
+      .mockImplementation(() => {
+        throw new DOMException("blocked", "SecurityError");
+      });
+    const setItem = vi.fn(() => {
+      throw new DOMException("blocked", "SecurityError");
+    });
+    const removeItem = vi.fn(() => {
+      throw new DOMException("blocked", "SecurityError");
+    });
+    installLocalStorage({ getItem, setItem, removeItem } as Storage);
+    mockAnonymousTokenFetch();
+
+    await expect(
+      new AssistantCloudAnonymousAuthStrategy(baseUrl).getAuthHeaders(),
+    ).resolves.toEqual({ Authorization: `Bearer ${accessToken}` });
+    await expect(
+      new AssistantCloudAnonymousAuthStrategy(baseUrl).getAuthHeaders(),
+    ).resolves.toEqual({ Authorization: `Bearer ${accessToken}` });
+    expect(getItem).toHaveBeenCalledTimes(2);
+    expect(setItem).toHaveBeenCalledTimes(2);
+    expect(removeItem).toHaveBeenCalledTimes(1);
+  });
+
+  it("treats corrupted refresh token JSON as absent", async () => {
+    const values = new Map([["aui:refresh_token", "not-json{"]]);
+    installLocalStorage({
+      getItem: (key) => values.get(key) ?? null,
+      setItem: (key, value) => {
+        values.set(key, value);
+      },
+      removeItem: (key) => {
+        values.delete(key);
+      },
+    } as Storage);
+    mockAnonymousTokenFetch();
+
+    const strategy = new AssistantCloudAnonymousAuthStrategy(baseUrl);
+
+    await expect(strategy.getAuthHeaders()).resolves.toEqual({
+      Authorization: `Bearer ${accessToken}`,
+    });
+    expect(values.get("aui:refresh_token")).toBe(JSON.stringify(refreshToken));
+  });
+});
+
+describe("AssistantCloudJWTAuthStrategy", () => {
+  it("retries token acquisition after a failed request", async () => {
+    const authToken = vi
+      .fn<() => Promise<string | null>>()
+      .mockRejectedValueOnce(new Error("authentication unavailable"))
+      .mockResolvedValueOnce(accessToken);
+    const strategy = new AssistantCloudJWTAuthStrategy(authToken);
+
+    await expect(strategy.getAuthHeaders()).rejects.toThrow(
+      "authentication unavailable",
+    );
+    await expect(strategy.getAuthHeaders()).resolves.toEqual({
+      Authorization: `Bearer ${accessToken}`,
+    });
+    expect(authToken).toHaveBeenCalledTimes(2);
+  });
+});

package/src/tests/AssistantCloudProjects.test.ts

@@ -0,0 +1,121 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { AssistantCloudProjects } from "../AssistantCloudProjects";
+import type { AssistantCloudAPI } from "../AssistantCloudAPI";
+
+vi.mock("../AssistantCloudAPI");
+
+describe("AssistantCloudProjects", () => {
+  let projects: AssistantCloudProjects;
+  let mockApi: AssistantCloudAPI;
+
+  beforeEach(() => {
+    mockApi = {
+      makeRequest: vi.fn().mockResolvedValue({}),
+      makeRawRequest: vi.fn(),
+      _auth: { getAuthHeaders: vi.fn() },
+      _baseUrl: "https://backend.assistant-api.com",
+    } as unknown as AssistantCloudAPI;
+
+    projects = new AssistantCloudProjects(mockApi);
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("lists project threads with the query", async () => {
+    vi.mocked(mockApi.makeRequest).mockResolvedValue({ threads: [] });
+
+    await projects.threads.list({ limit: 10, after: "t1" });
+
+    expect(mockApi.makeRequest).toHaveBeenCalledWith("/projects/threads", {
+      query: { limit: 10, after: "t1" },
+    });
+  });
+
+  it("sends both archive filter values as strings", async () => {
+    vi.mocked(mockApi.makeRequest).mockResolvedValue({ threads: [] });
+
+    await projects.threads.list({ is_archived: false });
+    expect(mockApi.makeRequest).toHaveBeenLastCalledWith("/projects/threads", {
+      query: { is_archived: "false" },
+    });
+
+    await projects.threads.list({ is_archived: true });
+    expect(mockApi.makeRequest).toHaveBeenLastCalledWith("/projects/threads", {
+      query: { is_archived: "true" },
+    });
+  });
+
+  it("lists project thread messages with the query", async () => {
+    vi.mocked(mockApi.makeRequest).mockResolvedValue({ messages: [] });
+
+    await projects.threads.messages.list("thread_123", {
+      format: "ai-sdk/v5",
+      limit: 100,
+      after: "msg_9",
+    });
+
+    expect(mockApi.makeRequest).toHaveBeenCalledWith(
+      "/projects/threads/thread_123/messages",
+      { query: { format: "ai-sdk/v5", limit: 100, after: "msg_9" } },
+    );
+  });
+
+  it("url-encodes the thread id in the messages path", async () => {
+    vi.mocked(mockApi.makeRequest).mockResolvedValue({ messages: [] });
+
+    await projects.threads.messages.list("thread/with space");
+
+    expect(mockApi.makeRequest).toHaveBeenCalledWith(
+      "/projects/threads/thread%2Fwith%20space/messages",
+      { query: undefined },
+    );
+  });
+
+  it("decodes project thread list responses", async () => {
+    vi.mocked(mockApi.makeRequest).mockResolvedValue({
+      threads: [
+        {
+          title: "Project thread",
+          last_message_at: "2026-07-16T12:30:00.000Z",
+          metadata: {},
+          external_id: null,
+          id: "thread_1",
+          project_id: "project_1",
+          created_at: "2026-07-16T12:00:00.000Z",
+          updated_at: "2026-07-16T12:15:00.000Z",
+          workspace_id: "workspace_1",
+          is_archived: false,
+        },
+      ],
+    });
+
+    const result = await projects.threads.list();
+    const thread = result.threads[0]!;
+
+    expect(thread.last_message_at instanceof Date).toBe(true);
+    expect(thread.is_archived).toBeTypeOf("boolean");
+  });
+
+  it("decodes project thread message list responses", async () => {
+    vi.mocked(mockApi.makeRequest).mockResolvedValue({
+      messages: [
+        {
+          id: "message_1",
+          parent_id: null,
+          height: 0,
+          created_at: "2026-07-16T13:00:00.000Z",
+          updated_at: "2026-07-16T13:05:00.000Z",
+          format: "aui/v0",
+          content: {},
+        },
+      ],
+    });
+
+    const result = await projects.threads.messages.list("thread_1");
+    const message = result.messages[0]!;
+
+    expect(message.created_at instanceof Date).toBe(true);
+  });
+});

package/src/tests/CloudMessagePersistence.test.ts

@@ -37,6 +37,33 @@ describe("CloudMessagePersistence", () => {
     expect(await persistence.getRemoteId("local-1")).toBe("remote-1");
   });
 
+  it("uses the current client without losing ID mappings", async () => {
+    const firstCloud = createMockCloud();
+    const secondCloud = createMockCloud();
+    let currentCloud = firstCloud;
+    persistence = new CloudMessagePersistence(() => currentCloud);
+    vi.mocked(firstCloud.threads.messages.create).mockResolvedValue({
+      message_id: "remote-parent",
+    });
+    vi.mocked(secondCloud.threads.messages.create).mockResolvedValue({
+      message_id: "remote-child",
+    });
+
+    await persistence.append("thread-1", "parent", null, "aui/v0", {
+      text: "parent",
+    });
+    currentCloud = secondCloud;
+    await persistence.append("thread-1", "child", "parent", "aui/v0", {
+      text: "child",
+    });
+
+    expect(secondCloud.threads.messages.create).toHaveBeenCalledWith(
+      "thread-1",
+      expect.objectContaining({ parent_id: "remote-parent" }),
+    );
+    expect(await persistence.getRemoteId("child")).toBe("remote-child");
+  });
+
   it("resolves parent ID from a concurrent append", async () => {
     // Parent creation is delayed — the promise won't resolve immediately
     let resolveParent!: (v: { message_id: string }) => void;
@@ -121,6 +148,19 @@ describe("CloudMessagePersistence", () => {
     );
   });
 
+  it("warns and skips update when no remote id is mapped", async () => {
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+    await persistence.update("thread-1", "unmapped-1", "aui/v0", {
+      text: "x",
+    });
+
+    expect(cloud.threads.messages.update).not.toHaveBeenCalled();
+    expect(warn).toHaveBeenCalledWith(
+      "Skipping update for message unmapped-1: no remote id is mapped.",
+    );
+  });
+
   it("cleans up ID mapping on append failure", async () => {
     vi.mocked(cloud.threads.messages.create).mockRejectedValue(
       new Error("network error"),

package/src/tests/setup.ts

@@ -1,11 +1,4 @@
-// This file contains setup code for tests
 import { vi } from "vitest";
 
-// Set up globalThis mocks if needed
-// Using a fixed date to avoid recursive calls
-const OriginalDate = globalThis.Date;
-const fixedDate = new OriginalDate("2023-01-01");
-globalThis.Date = vi.fn(() => fixedDate) as any;
-globalThis.Date.now = vi.fn(() => fixedDate.getTime());
-
-// Add any other globalThis setup needed for tests
+vi.useFakeTimers({ toFake: ["Date"] });
+vi.setSystemTime(new Date("2023-01-01T00:00:00.000Z"));