@stigmer/react 3.1.7 → 3.1.9

package/src/sharing/__tests__/SharedAgentChat.test.tsx

@@ -0,0 +1,222 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { render, screen, cleanup, fireEvent, act } from "@testing-library/react";
+import type { UseSharedAgentProfileReturn } from "../useSharedAgentProfile";
+
+// ---------------------------------------------------------------------------
+// SharedAgentChat state machine and wiring.
+//
+// The session organisms are replaced with prop-capturing probes — their
+// behavior (including the guest-audience mapping) is covered by their own
+// tests. These tests assert the organism's states (loading / error /
+// unavailable / chat), the guest wiring it hands the viewers, and the
+// launcher→viewer handoff on session creation.
+// ---------------------------------------------------------------------------
+
+type CapturedProps = Record<string, unknown>;
+
+const newSessionViewerProps: CapturedProps[] = [];
+vi.mock("../../session/NewSessionViewer", () => ({
+  NewSessionViewer: (props: CapturedProps) => {
+    newSessionViewerProps.push(props);
+    return <div data-testid="new-session-probe" />;
+  },
+}));
+
+const sessionViewerProps: CapturedProps[] = [];
+vi.mock("../../session/SessionViewer", () => ({
+  SessionViewer: (props: CapturedProps) => {
+    sessionViewerProps.push(props);
+    return <div data-testid="session-probe" />;
+  },
+}));
+
+const profileState: { current: UseSharedAgentProfileReturn } = {
+  current: {
+    profile: null,
+    isLoading: true,
+    isRefetching: false,
+    error: null,
+    refetch: vi.fn(),
+  },
+};
+const profileHookCalls: unknown[][] = [];
+vi.mock("../useSharedAgentProfile", () => ({
+  useSharedAgentProfile: (...args: unknown[]) => {
+    profileHookCalls.push(args);
+    return profileState.current;
+  },
+}));
+
+import { SharedAgentChat } from "../SharedAgentChat";
+
+const PROFILE = {
+  org: "acme",
+  slug: "support-agent",
+  name: "Support Agent",
+  description: "Answers support questions",
+  iconUrl: "",
+  defaultInstanceId: "inst_1",
+} as never;
+
+function setProfileState(state: Partial<UseSharedAgentProfileReturn>) {
+  profileState.current = {
+    profile: null,
+    isLoading: false,
+    isRefetching: false,
+    error: null,
+    refetch: vi.fn(),
+    ...state,
+  };
+}
+
+beforeEach(() => {
+  newSessionViewerProps.length = 0;
+  sessionViewerProps.length = 0;
+  profileHookCalls.length = 0;
+});
+
+afterEach(() => {
+  cleanup();
+  vi.clearAllMocks();
+});
+
+describe("SharedAgentChat", () => {
+  it("renders a loading skeleton while the profile resolves", () => {
+    setProfileState({ isLoading: true });
+    render(<SharedAgentChat org="acme" slug="support-agent" />);
+
+    expect(screen.getByLabelText("Loading agent")).toBeTruthy();
+    expect(newSessionViewerProps).toHaveLength(0);
+  });
+
+  it("resolves via the public path by default and the member path for sharingAudience=org", () => {
+    setProfileState({ profile: PROFILE });
+    render(<SharedAgentChat org="acme" slug="support-agent" />);
+    expect(profileHookCalls[0]).toEqual([
+      "acme",
+      "support-agent",
+      { audience: "public" },
+    ]);
+
+    cleanup();
+    profileHookCalls.length = 0;
+
+    render(
+      <SharedAgentChat org="acme" slug="support-agent" sharingAudience="org" />,
+    );
+    expect(profileHookCalls[0]).toEqual([
+      "acme",
+      "support-agent",
+      { audience: "org" },
+    ]);
+    // Presentation is identical either way: the session organisms still
+    // render with the pure-chat guest audience.
+    expect(newSessionViewerProps[0]?.audience).toBe("guest");
+  });
+
+  it("renders an error state with retry on transient failures", () => {
+    const refetch = vi.fn();
+    setProfileState({ error: new Error("network down"), refetch });
+    render(<SharedAgentChat org="acme" slug="support-agent" />);
+
+    expect(screen.getByText("Something went wrong")).toBeTruthy();
+    fireEvent.click(screen.getByRole("button", { name: "Try again" }));
+    expect(refetch).toHaveBeenCalledTimes(1);
+  });
+
+  it("renders the unavailable state when the agent is not shared", () => {
+    setProfileState({ profile: null });
+    render(<SharedAgentChat org="acme" slug="support-agent" />);
+
+    expect(screen.getByText("This agent isn't available")).toBeTruthy();
+    expect(newSessionViewerProps).toHaveLength(0);
+  });
+
+  it("renders the unavailable state when the profile has no default instance", () => {
+    setProfileState({
+      profile: { ...(PROFILE as object), defaultInstanceId: "" } as never,
+    });
+    render(<SharedAgentChat org="acme" slug="support-agent" />);
+
+    expect(screen.getByText("This agent isn't available")).toBeTruthy();
+  });
+
+  it("renders the agent header and a guest launcher pinned to the shared instance", () => {
+    setProfileState({ profile: PROFILE });
+    render(<SharedAgentChat org="acme" slug="support-agent" />);
+
+    expect(screen.getByRole("heading", { name: "Support Agent" })).toBeTruthy();
+    expect(screen.getByText("Answers support questions")).toBeTruthy();
+
+    expect(newSessionViewerProps).toHaveLength(1);
+    expect(newSessionViewerProps[0]).toMatchObject({
+      org: "acme",
+      audience: "guest",
+      initialAgentRef: { org: "acme", slug: "support-agent" },
+      initialInstanceId: "inst_1",
+      enableGitHub: false,
+    });
+  });
+
+  it("hands off to a guest SessionViewer once the session is created", () => {
+    setProfileState({ profile: PROFILE });
+    const onSessionCreated = vi.fn();
+    render(
+      <SharedAgentChat
+        org="acme"
+        slug="support-agent"
+        onSessionCreated={onSessionCreated}
+      />,
+    );
+
+    const created = newSessionViewerProps[0]
+      .onSessionCreated as (id: string) => void;
+    act(() => created("ses_1"));
+
+    expect(onSessionCreated).toHaveBeenCalledWith("ses_1");
+    expect(screen.getByTestId("session-probe")).toBeTruthy();
+    expect(sessionViewerProps[0]).toMatchObject({
+      sessionId: "ses_1",
+      org: "acme",
+      audience: "guest",
+      enableGitHub: false,
+    });
+  });
+
+  it("surfaces launcher errors through the composer footer", () => {
+    setProfileState({ profile: PROFILE });
+    const { rerender } = render(
+      <SharedAgentChat org="acme" slug="support-agent" />,
+    );
+
+    const onError = newSessionViewerProps[0].onError as (msg: string) => void;
+    act(() => onError("Rate limit reached"));
+    rerender(<SharedAgentChat org="acme" slug="support-agent" />);
+
+    const footer = newSessionViewerProps.at(-1)!.footerContent;
+    expect(footer).toBeTruthy();
+  });
+
+  it("shows the Powered by Stigmer footer by default and hides it on request", () => {
+    setProfileState({ profile: PROFILE });
+    const { unmount } = render(<SharedAgentChat org="acme" slug="support-agent" />);
+    expect(screen.getByText("Powered by Stigmer")).toBeTruthy();
+    unmount();
+
+    render(
+      <SharedAgentChat org="acme" slug="support-agent" showPoweredBy={false} />,
+    );
+    expect(screen.queryByText("Powered by Stigmer")).toBeNull();
+  });
+
+  it("falls back to the slug when the profile has no display name", () => {
+    setProfileState({
+      profile: { ...(PROFILE as object), name: "" } as never,
+    });
+    render(<SharedAgentChat org="acme" slug="support-agent" />);
+
+    expect(
+      screen.getByRole("heading", { name: "support-agent" }),
+    ).toBeTruthy();
+  });
+});

package/src/sharing/__tests__/useAgentShare.test.tsx

@@ -0,0 +1,149 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { renderHook, waitFor } from "@testing-library/react";
+import type { ReactNode } from "react";
+import type { GetAgentSharesByAgentRequest } from "@stigmer/protos/ai/stigmer/agentic/agentshare/v1/io_pb";
+import { StigmerContext } from "../../context";
+import { FetchCacheContext } from "../../internal/FetchCacheProvider";
+import { useAgentShare } from "../useAgentShare";
+
+function createMockStigmer(overrides: {
+  getByAgent?: (input: GetAgentSharesByAgentRequest) => Promise<unknown>;
+} = {}) {
+  return {
+    agentShare: {
+      getByAgent:
+        overrides.getByAgent ??
+        vi.fn().mockResolvedValue({ totalCount: 0, items: [] }),
+    },
+  } as never;
+}
+
+function wrapper(client: unknown) {
+  return function Wrapper({ children }: { children: ReactNode }) {
+    return (
+      <FetchCacheContext.Provider value={null}>
+        <StigmerContext.Provider value={client as never}>
+          {children}
+        </StigmerContext.Provider>
+      </FetchCacheContext.Provider>
+    );
+  };
+}
+
+const AGENT = {
+  metadata: {
+    id: "agt_1",
+    org: "acme",
+    slug: "support-agent",
+    name: "Support Agent",
+  },
+} as never;
+
+function makeShare(slug: string, id = `ash_${slug}`) {
+  return {
+    metadata: { id, org: "acme", slug },
+    spec: { enabled: true },
+  };
+}
+
+describe("useAgentShare", () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("loads the agent's shares by agent id", async () => {
+    const share = makeShare("support-agent");
+    const getByAgent = vi
+      .fn()
+      .mockResolvedValue({ totalCount: 1, items: [share] });
+    const client = createMockStigmer({ getByAgent });
+
+    const { result } = renderHook(() => useAgentShare(AGENT), {
+      wrapper: wrapper(client),
+    });
+
+    expect(result.current.isLoading).toBe(true);
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    expect(result.current.share).toBe(share);
+    expect(result.current.error).toBeNull();
+    expect(getByAgent).toHaveBeenCalledWith(
+      expect.objectContaining({ agentId: "agt_1" }),
+    );
+  });
+
+  it("resolves null (no share yet) when the agent has never been shared", async () => {
+    const client = createMockStigmer();
+
+    const { result } = renderHook(() => useAgentShare(AGENT), {
+      wrapper: wrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+
+    // The no-share state is not an error: the first save creates the share.
+    expect(result.current.share).toBeNull();
+    expect(result.current.error).toBeNull();
+  });
+
+  it("picks the slug-matching share as canonical when several exist", async () => {
+    const canonical = makeShare("support-agent");
+    const renamed = makeShare("support-help-desk");
+    const getByAgent = vi
+      .fn()
+      .mockResolvedValue({ totalCount: 2, items: [renamed, canonical] });
+    const client = createMockStigmer({ getByAgent });
+
+    const { result } = renderHook(() => useAgentShare(AGENT), {
+      wrapper: wrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.share).toBe(canonical);
+  });
+
+  it("falls back to the first share when none matches the agent slug", async () => {
+    // A manifest-created share with a custom slug is still manageable —
+    // preferring it over "no share" keeps the dialog editing the real row.
+    const renamed = makeShare("support-help-desk");
+    const getByAgent = vi
+      .fn()
+      .mockResolvedValue({ totalCount: 1, items: [renamed] });
+    const client = createMockStigmer({ getByAgent });
+
+    const { result } = renderHook(() => useAgentShare(AGENT), {
+      wrapper: wrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.share).toBe(renamed);
+  });
+
+  it("skips fetching while the agent is null (stable no-op)", () => {
+    const getByAgent = vi.fn();
+    const client = createMockStigmer({ getByAgent });
+
+    const { result } = renderHook(() => useAgentShare(null), {
+      wrapper: wrapper(client),
+    });
+
+    expect(result.current.isLoading).toBe(false);
+    expect(result.current.share).toBeNull();
+    expect(getByAgent).not.toHaveBeenCalled();
+  });
+
+  it("exposes fetch failures as errors", async () => {
+    const getByAgent = vi
+      .fn()
+      .mockRejectedValue(new Error("backend unavailable"));
+    const client = createMockStigmer({ getByAgent });
+
+    const { result } = renderHook(() => useAgentShare(AGENT), {
+      wrapper: wrapper(client),
+    });
+
+    await waitFor(() => expect(result.current.isLoading).toBe(false));
+    expect(result.current.error).toBeTruthy();
+    expect(result.current.share).toBeNull();
+  });
+});

package/src/sharing/__tests__/useRotateShareLink.test.tsx

@@ -0,0 +1,96 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { renderHook, act } from "@testing-library/react";
+import type { ReactNode } from "react";
+import type { RotateShareLinkInput } from "@stigmer/protos/ai/stigmer/agentic/agentshare/v1/io_pb";
+import { StigmerContext } from "../../context";
+import { useRotateShareLink } from "../useRotateShareLink";
+
+function createMockStigmer(overrides: {
+  rotateShareLink?: (input: RotateShareLinkInput) => Promise<unknown>;
+} = {}) {
+  return {
+    agentShare: {
+      rotateShareLink:
+        overrides.rotateShareLink ?? vi.fn().mockResolvedValue({}),
+    },
+  } as never;
+}
+
+function wrapper(client: unknown) {
+  return function Wrapper({ children }: { children: ReactNode }) {
+    return (
+      <StigmerContext.Provider value={client as never}>
+        {children}
+      </StigmerContext.Provider>
+    );
+  };
+}
+
+describe("useRotateShareLink", () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("calls rotateShareLink with the share id and returns the updated share", async () => {
+    const rotated = {
+      metadata: { id: "ash_1" },
+      status: { shareLinkToken: "fresh-token" },
+    };
+    const rotateShareLink = vi.fn().mockResolvedValue(rotated);
+    const client = createMockStigmer({ rotateShareLink });
+
+    const { result } = renderHook(() => useRotateShareLink("ash_1"), {
+      wrapper: wrapper(client),
+    });
+
+    let returned: unknown;
+    await act(async () => {
+      returned = await result.current.rotateShareLink();
+    });
+
+    expect(rotateShareLink).toHaveBeenCalledTimes(1);
+    const input = rotateShareLink.mock.calls[0][0] as RotateShareLinkInput;
+    expect(input.resourceId).toBe("ash_1");
+    // The server generates the token — the request carries nothing but the id.
+    expect(Object.keys(input)).not.toContain("linkToken");
+    expect(returned).toBe(rotated);
+    expect(result.current.error).toBeNull();
+    expect(result.current.isPending).toBe(false);
+  });
+
+  it("is a stable no-op while shareId is null (agent never shared)", async () => {
+    const rotateShareLink = vi.fn();
+    const client = createMockStigmer({ rotateShareLink });
+
+    const { result } = renderHook(() => useRotateShareLink(null), {
+      wrapper: wrapper(client),
+    });
+
+    let returned: unknown = "sentinel";
+    await act(async () => {
+      returned = await result.current.rotateShareLink();
+    });
+
+    expect(returned).toBeUndefined();
+    expect(rotateShareLink).not.toHaveBeenCalled();
+  });
+
+  it("exposes RPC failures via error and rethrows for the caller", async () => {
+    const failure = new Error("unauthorized to rotate agent share link");
+    const rotateShareLink = vi.fn().mockRejectedValue(failure);
+    const client = createMockStigmer({ rotateShareLink });
+
+    const { result } = renderHook(() => useRotateShareLink("ash_1"), {
+      wrapper: wrapper(client),
+    });
+
+    await act(async () => {
+      await expect(result.current.rotateShareLink()).rejects.toThrow(
+        "unauthorized to rotate agent share link",
+      );
+    });
+
+    expect(result.current.error).toBe(failure);
+    expect(result.current.isPending).toBe(false);
+  });
+});