@stigmer/react 3.1.7 → 3.1.8

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__/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/agent/v1/io_pb";
+import { StigmerContext } from "../../context";
+import { useRotateShareLink } from "../useRotateShareLink";
+
+function createMockStigmer(overrides: {
+  rotateShareLink?: (input: RotateShareLinkInput) => Promise<unknown>;
+} = {}) {
+  return {
+    agent: {
+      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 agent id and returns the updated agent", async () => {
+    const rotated = {
+      metadata: { id: "agt_1" },
+      status: { shareLinkToken: "fresh-token" },
+    };
+    const rotateShareLink = vi.fn().mockResolvedValue(rotated);
+    const client = createMockStigmer({ rotateShareLink });
+
+    const { result } = renderHook(() => useRotateShareLink("agt_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("agt_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 agentId is null", 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("agt_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);
+  });
+});

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

@@ -0,0 +1,127 @@
+import { describe, it, expect, vi, beforeAll, afterEach } from "vitest";
+import { renderHook, waitFor, cleanup } from "@testing-library/react";
+import type { ReactNode } from "react";
+import { StigmerContext } from "../../context";
+import { FetchCacheContext } from "../../internal/FetchCacheProvider";
+import { useShareAgent } from "../useShareAgent";
+
+// happy-dom does not implement the native dialog show/close methods.
+beforeAll(() => {
+  HTMLDialogElement.prototype.showModal = function showModal() {
+    this.open = true;
+  };
+  HTMLDialogElement.prototype.close = function close() {
+    this.open = false;
+  };
+});
+
+afterEach(cleanup);
+
+function createMockStigmer(overrides: {
+  isAuthorized?: boolean;
+  checkMyPermission?: (...args: unknown[]) => Promise<unknown>;
+} = {}) {
+  return {
+    iamPolicy: {
+      checkMyPermission:
+        overrides.checkMyPermission ??
+        vi.fn().mockResolvedValue({
+          isAuthorized: overrides.isAuthorized ?? true,
+        }),
+    },
+    agent: { updateSharing: vi.fn().mockResolvedValue({}) },
+    billing: { getOrCreateBillingAccount: vi.fn().mockResolvedValue(null) },
+  } 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",
+  },
+  spec: { sharing: undefined },
+} as never;
+
+describe("useShareAgent", () => {
+  it("returns a Share action in the sharing group when the user can edit", async () => {
+    const { result } = renderHook(() => useShareAgent({ agent: AGENT }), {
+      wrapper: wrapper(createMockStigmer({ isAuthorized: true })),
+    });
+
+    await waitFor(() => expect(result.current.action).not.toBeNull());
+    expect(result.current.action?.id).toBe("share");
+    expect(result.current.action?.label).toBe("Share");
+    expect(result.current.action?.group).toBe("sharing");
+  });
+
+  it("returns a null action while the agent is loading", () => {
+    const checkMyPermission = vi.fn();
+    const { result } = renderHook(() => useShareAgent({ agent: null }), {
+      wrapper: wrapper(createMockStigmer({ checkMyPermission })),
+    });
+
+    expect(result.current.action).toBeNull();
+    expect(result.current.dialog).toBeNull();
+    expect(checkMyPermission).not.toHaveBeenCalled();
+  });
+
+  it("returns a null action when the user lacks can_edit", async () => {
+    const client = createMockStigmer({ isAuthorized: false });
+    const { result } = renderHook(() => useShareAgent({ agent: AGENT }), {
+      wrapper: wrapper(client),
+    });
+
+    await waitFor(() =>
+      expect(
+        (client as { iamPolicy: { checkMyPermission: ReturnType<typeof vi.fn> } })
+          .iamPolicy.checkMyPermission,
+      ).toHaveBeenCalled(),
+    );
+    await waitFor(() => expect(result.current.action).toBeNull());
+  });
+
+  it("checks the can_edit relation on the agent", async () => {
+    const client = createMockStigmer({ isAuthorized: true });
+    renderHook(() => useShareAgent({ agent: AGENT }), {
+      wrapper: wrapper(client),
+    });
+
+    const check = (
+      client as { iamPolicy: { checkMyPermission: ReturnType<typeof vi.fn> } }
+    ).iamPolicy.checkMyPermission;
+    await waitFor(() => expect(check).toHaveBeenCalled());
+    const input = check.mock.calls[0][0] as {
+      resource?: { kind: string; id: string };
+      relation: string;
+    };
+    expect(input.relation).toBe("can_edit");
+    expect(input.resource?.kind).toBe("agent");
+    expect(input.resource?.id).toBe("agt_1");
+  });
+
+  it("opens the dialog via the action", async () => {
+    const { result } = renderHook(() => useShareAgent({ agent: AGENT }), {
+      wrapper: wrapper(createMockStigmer({ isAuthorized: true })),
+    });
+
+    await waitFor(() => expect(result.current.action).not.toBeNull());
+    expect(result.current.isOpen).toBe(false);
+
+    result.current.action?.onAction();
+    await waitFor(() => expect(result.current.isOpen).toBe(true));
+  });
+});

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

@@ -0,0 +1,182 @@
+import { describe, it, expect, vi } from "vitest";
+import { renderHook, waitFor } from "@testing-library/react";
+import type { ReactNode } from "react";
+import { create } from "@bufbuild/protobuf";
+import { AgentSchema } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/api_pb";
+import type { Agent } from "@stigmer/protos/ai/stigmer/agentic/agent/v1/api_pb";
+import { ApiResourceVisibility } from "@stigmer/protos/ai/stigmer/commons/apiresource/enum_pb";
+import { StigmerContext } from "../../context";
+import { DeploymentModeContext } from "../../deployment-mode";
+import { useShareToolReadiness } from "../useShareToolReadiness";
+
+function toolAgent(overrides?: {
+  mcpUsages?: boolean;
+  defaultInstanceId?: string;
+}): Agent {
+  return create(AgentSchema, {
+    metadata: { id: "agt_1", org: "acme", slug: "helper" },
+    spec: {
+      instructions: "help",
+      mcpServerUsages:
+        (overrides?.mcpUsages ?? true)
+          ? [{ mcpServerRef: { org: "acme", slug: "github" } }]
+          : [],
+    },
+    status: {
+      defaultInstanceId: overrides?.defaultInstanceId ?? "agi_1",
+    },
+  });
+}
+
+function mockStigmer(overrides: {
+  instanceEnvRefs?: { org: string; slug: string }[];
+  envVisibility?: Record<string, ApiResourceVisibility>;
+  envError?: boolean;
+}) {
+  return {
+    agentInstance: {
+      get: vi.fn().mockResolvedValue({
+        spec: { environmentRefs: overrides.instanceEnvRefs ?? [] },
+      }),
+    },
+    environment: {
+      getByReference: vi.fn().mockImplementation(
+        ({ slug }: { org: string; slug: string }) => {
+          if (overrides.envError) {
+            return Promise.reject(new Error("not found"));
+          }
+          return Promise.resolve({
+            metadata: {
+              visibility:
+                overrides.envVisibility?.[slug] ??
+                ApiResourceVisibility.visibility_private,
+            },
+          });
+        },
+      ),
+    },
+  } as never;
+}
+
+function wrapper(client: unknown, mode: "cloud" | "local" = "cloud") {
+  return function Wrapper({ children }: { children: ReactNode }) {
+    return (
+      <StigmerContext.Provider value={client as never}>
+        <DeploymentModeContext.Provider value={mode}>
+          {children}
+        </DeploymentModeContext.Provider>
+      </StigmerContext.Provider>
+    );
+  };
+}
+
+describe("useShareToolReadiness", () => {
+  it("reports blocked with the private environment refs listed", async () => {
+    const client = mockStigmer({
+      instanceEnvRefs: [
+        { org: "acme", slug: "private-creds" },
+        { org: "acme", slug: "shared-creds" },
+      ],
+      envVisibility: {
+        "shared-creds": ApiResourceVisibility.visibility_org,
+      },
+    });
+
+    const { result } = renderHook(
+      () => useShareToolReadiness(toolAgent(), true),
+      { wrapper: wrapper(client) },
+    );
+
+    await waitFor(() =>
+      expect(result.current).toEqual({
+        status: "blocked",
+        privateEnvironments: ["acme/private-creds"],
+      }),
+    );
+  });
+
+  it("reports ready when every bound environment is org-shared", async () => {
+    const client = mockStigmer({
+      instanceEnvRefs: [{ org: "acme", slug: "shared-creds" }],
+      envVisibility: {
+        "shared-creds": ApiResourceVisibility.visibility_org,
+      },
+    });
+
+    const { result } = renderHook(
+      () => useShareToolReadiness(toolAgent(), true),
+      { wrapper: wrapper(client) },
+    );
+
+    await waitFor(() => expect(result.current).toEqual({ status: "ready" }));
+  });
+
+  it("treats an unreadable environment ref as blocking", async () => {
+    const client = mockStigmer({
+      instanceEnvRefs: [{ org: "acme", slug: "deleted-env" }],
+      envError: true,
+    });
+
+    const { result } = renderHook(
+      () => useShareToolReadiness(toolAgent(), true),
+      { wrapper: wrapper(client) },
+    );
+
+    await waitFor(() =>
+      expect(result.current).toEqual({
+        status: "blocked",
+        privateEnvironments: ["acme/deleted-env"],
+      }),
+    );
+  });
+
+  it("is n/a for agents without MCP tools — no lookups fire", async () => {
+    const client = mockStigmer({});
+    const { result } = renderHook(
+      () => useShareToolReadiness(toolAgent({ mcpUsages: false }), true),
+      { wrapper: wrapper(client) },
+    );
+
+    expect(result.current).toEqual({ status: "na" });
+    await waitFor(() => {
+      expect(
+        (client as { agentInstance: { get: ReturnType<typeof vi.fn> } })
+          .agentInstance.get,
+      ).not.toHaveBeenCalled();
+    });
+  });
+
+  it("is n/a when sharing is disabled", () => {
+    const client = mockStigmer({
+      instanceEnvRefs: [{ org: "acme", slug: "private-creds" }],
+    });
+    const { result } = renderHook(
+      () => useShareToolReadiness(toolAgent(), false),
+      { wrapper: wrapper(client) },
+    );
+
+    expect(result.current).toEqual({ status: "na" });
+  });
+
+  it("is n/a in local mode — no guest runtime, no secret gating", () => {
+    const client = mockStigmer({
+      instanceEnvRefs: [{ org: "acme", slug: "private-creds" }],
+    });
+    const { result } = renderHook(
+      () => useShareToolReadiness(toolAgent(), true),
+      { wrapper: wrapper(client, "local") },
+    );
+
+    expect(result.current).toEqual({ status: "na" });
+  });
+
+  it("is n/a when the instance has no bound environments (no warning on a guess)", async () => {
+    const client = mockStigmer({ instanceEnvRefs: [] });
+    const { result } = renderHook(
+      () => useShareToolReadiness(toolAgent(), true),
+      { wrapper: wrapper(client) },
+    );
+
+    await waitFor(() => expect(result.current).toEqual({ status: "na" }));
+  });
+});