@stigmer/react 3.1.7 → 3.1.9

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

@@ -0,0 +1,241 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { renderHook, act, waitFor } from "@testing-library/react";
+import type { ReactNode } from "react";
+import { AgentShareAudience } from "@stigmer/protos/ai/stigmer/agentic/agentshare/v1/spec_pb";
+import type { AgentShare } from "@stigmer/protos/ai/stigmer/agentic/agentshare/v1/api_pb";
+import type { AgentShareInput } from "@stigmer/sdk";
+import { StigmerContext } from "../../context";
+import {
+  sharingAudienceFromProto,
+  useSaveAgentShare,
+  type AgentShareDraft,
+} from "../useSaveAgentShare";
+
+function createMockStigmer(overrides: {
+  apply?: (input: AgentShareInput) => Promise<unknown>;
+} = {}) {
+  return {
+    agentShare: {
+      apply: overrides.apply ?? 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>
+    );
+  };
+}
+
+const AGENT = {
+  metadata: {
+    id: "agt_1",
+    org: "acme",
+    slug: "support-agent",
+    name: "Support Agent",
+  },
+} as never;
+
+const FULL_DRAFT: AgentShareDraft = {
+  enabled: true,
+  audience: "public",
+  allowedOrigins: ["https://example.com", "https://docs.example.com"],
+  messages: {
+    rateLimited: "Slow down, please.",
+    unavailable: "We're out of credits.",
+    conversationEnded: "This conversation has ended.",
+  },
+  environmentRefs: [{ org: "acme", slug: "github-org-shared" }],
+};
+
+describe("useSaveAgentShare", () => {
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("applies the complete configuration — identity, agent_ref, origins, messages, and bindings", async () => {
+    const apply = vi.fn().mockResolvedValue({});
+    const client = createMockStigmer({ apply });
+
+    const { result } = renderHook(() => useSaveAgentShare(AGENT), {
+      wrapper: wrapper(client),
+    });
+
+    // No existing share: the apply creates the canonical one, keyed on
+    // the agent's own org/slug (the server's D2 default, made explicit).
+    await act(() => result.current.save(FULL_DRAFT, null));
+
+    expect(apply).toHaveBeenCalledTimes(1);
+    const input = apply.mock.calls[0][0] as AgentShareInput;
+    expect(input.org).toBe("acme");
+    expect(input.slug).toBe("support-agent");
+    expect(input.name).toBe("Support Agent");
+    expect(input.agentRef).toEqual({ org: "acme", slug: "support-agent" });
+    expect(input.enabled).toBe(true);
+    expect(input.allowedOrigins).toEqual([
+      "https://example.com",
+      "https://docs.example.com",
+    ]);
+    expect(input.messages?.rateLimited).toBe("Slow down, please.");
+    expect(input.messages?.unavailable).toBe("We're out of credits.");
+    expect(input.messages?.conversationEnded).toBe(
+      "This conversation has ended.",
+    );
+    expect(input.environmentRefs).toEqual([
+      { org: "acme", slug: "github-org-shared" },
+    ]);
+  });
+
+  it("keeps the existing share's identity when editing (a renamed share is never forked)", async () => {
+    const apply = vi.fn().mockResolvedValue({});
+    const client = createMockStigmer({ apply });
+    // A share created via manifest with a non-default slug: applying with
+    // the agent's slug would create a SECOND share instead of updating.
+    const renamedShare = {
+      metadata: { id: "ash_1", org: "acme", slug: "help-desk", name: "Help Desk" },
+      spec: { enabled: true },
+    } as AgentShare;
+
+    const { result } = renderHook(() => useSaveAgentShare(AGENT), {
+      wrapper: wrapper(client),
+    });
+
+    await act(() => result.current.save(FULL_DRAFT, renamedShare));
+
+    const input = apply.mock.calls[0][0] as AgentShareInput;
+    expect(input.slug).toBe("help-desk");
+    expect(input.name).toBe("Help Desk");
+    // The agent reference is the agent's identity regardless of share slug.
+    expect(input.agentRef).toEqual({ org: "acme", slug: "support-agent" });
+  });
+
+  it("disabling still carries origins, messages, bindings, and audience (toggle never clobbers config)", async () => {
+    const apply = vi.fn().mockResolvedValue({});
+    const client = createMockStigmer({ apply });
+
+    const { result } = renderHook(() => useSaveAgentShare(AGENT), {
+      wrapper: wrapper(client),
+    });
+
+    await act(() =>
+      result.current.save(
+        { ...FULL_DRAFT, enabled: false, audience: "org", environmentRefs: [] },
+        null,
+      ),
+    );
+
+    const input = apply.mock.calls[0][0] as AgentShareInput;
+    expect(input.enabled).toBe(false);
+    // Apply replaces the spec wholesale — a disable that dropped these
+    // fields would silently erase the owner's configuration (an audience
+    // drop would silently revert an org-only share to public).
+    expect(input.allowedOrigins).toEqual(FULL_DRAFT.allowedOrigins);
+    expect(input.messages?.rateLimited).toBe(FULL_DRAFT.messages.rateLimited);
+    expect(input.audience).toBe(AgentShareAudience.org);
+  });
+
+  it("maps the audience union to the proto enum, writing public explicitly", async () => {
+    const apply = vi.fn().mockResolvedValue({});
+    const client = createMockStigmer({ apply });
+
+    const { result } = renderHook(() => useSaveAgentShare(AGENT), {
+      wrapper: wrapper(client),
+    });
+
+    await act(() => result.current.save(FULL_DRAFT, null));
+    await act(() =>
+      result.current.save(
+        { ...FULL_DRAFT, audience: "org", environmentRefs: [] },
+        null,
+      ),
+    );
+
+    const first = apply.mock.calls[0][0] as AgentShareInput;
+    const second = apply.mock.calls[1][0] as AgentShareInput;
+    // "public" persists as the explicit enum value, never unspecified —
+    // a console-managed share can't be downgraded by a later manifest
+    // that relies on the unspecified-means-public default.
+    expect(first.audience).toBe(AgentShareAudience.public);
+    expect(second.audience).toBe(AgentShareAudience.org);
+  });
+
+  it("is a stable no-op when the agent is null", async () => {
+    const apply = vi.fn();
+    const client = createMockStigmer({ apply });
+
+    const { result } = renderHook(() => useSaveAgentShare(null), {
+      wrapper: wrapper(client),
+    });
+
+    const returned = await act(() => result.current.save(FULL_DRAFT, null));
+    expect(returned).toBeUndefined();
+    expect(apply).not.toHaveBeenCalled();
+  });
+
+  it("exposes isPending during the request", async () => {
+    let resolveRpc: (v: unknown) => void = () => {};
+    const apply = vi.fn().mockReturnValue(
+      new Promise((resolve) => {
+        resolveRpc = resolve;
+      }),
+    );
+    const client = createMockStigmer({ apply });
+
+    const { result } = renderHook(() => useSaveAgentShare(AGENT), {
+      wrapper: wrapper(client),
+    });
+
+    let pending: Promise<unknown>;
+    act(() => {
+      pending = result.current.save(FULL_DRAFT, null);
+    });
+    expect(result.current.isPending).toBe(true);
+
+    await act(async () => {
+      resolveRpc({});
+      await pending;
+    });
+    expect(result.current.isPending).toBe(false);
+  });
+
+  it("captures and rethrows RPC errors", async () => {
+    const failure = new Error("permission denied");
+    const apply = vi.fn().mockRejectedValue(failure);
+    const client = createMockStigmer({ apply });
+
+    const { result } = renderHook(() => useSaveAgentShare(AGENT), {
+      wrapper: wrapper(client),
+    });
+
+    let caught: unknown;
+    await act(async () => {
+      try {
+        await result.current.save(FULL_DRAFT, null);
+      } catch (err) {
+        caught = err;
+      }
+    });
+
+    expect(caught).toBe(failure);
+    await waitFor(() => expect(result.current.error).toBe(failure));
+    expect(result.current.isPending).toBe(false);
+  });
+});
+
+describe("sharingAudienceFromProto", () => {
+  it("maps unspecified to public (a share without an audience is anyone-with-link)", () => {
+    expect(sharingAudienceFromProto(undefined)).toBe("public");
+    expect(sharingAudienceFromProto(AgentShareAudience.unspecified)).toBe(
+      "public",
+    );
+  });
+
+  it("maps the explicit values", () => {
+    expect(sharingAudienceFromProto(AgentShareAudience.public)).toBe("public");
+    expect(sharingAudienceFromProto(AgentShareAudience.org)).toBe("org");
+  });
+});

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

@@ -0,0 +1,131 @@
+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,
+        }),
+    },
+    agentShare: {
+      getByAgent: vi.fn().mockResolvedValue({ totalCount: 0, items: [] }),
+      apply: vi.fn().mockResolvedValue({}),
+      rotateShareLink: 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: {},
+} 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,219 @@
+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";
+import type { AgentShareDraft, SharingAudience } from "../useSaveAgentShare";
+
+function toolAgent(overrides?: { mcpUsages?: boolean }): Agent {
+  return create(AgentSchema, {
+    metadata: { id: "agt_1", org: "acme", slug: "helper" },
+    spec: {
+      instructions: "help",
+      mcpServerUsages:
+        (overrides?.mcpUsages ?? true)
+          ? [{ mcpServerRef: { org: "acme", slug: "github" } }]
+          : [],
+    },
+  });
+}
+
+function makeDraft(overrides?: {
+  enabled?: boolean;
+  audience?: SharingAudience;
+  environmentRefs?: { org: string; slug: string }[];
+}): AgentShareDraft {
+  return {
+    enabled: overrides?.enabled ?? true,
+    audience: overrides?.audience ?? "public",
+    allowedOrigins: [],
+    messages: { rateLimited: "", unavailable: "", conversationEnded: "" },
+    environmentRefs: overrides?.environmentRefs ?? [],
+  };
+}
+
+function mockStigmer(overrides: {
+  envVisibility?: Record<string, ApiResourceVisibility>;
+  envError?: boolean;
+}) {
+  return {
+    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>
+    );
+  };
+}
+
+function envLookup(client: unknown) {
+  return (
+    client as { environment: { getByReference: ReturnType<typeof vi.fn> } }
+  ).environment.getByReference;
+}
+
+describe("useShareToolReadiness", () => {
+  it("reports needs-credentials when a tool-using share has no bindings — no lookups fire", async () => {
+    const client = mockStigmer({});
+    const { result } = renderHook(
+      () => useShareToolReadiness(toolAgent(), makeDraft()),
+      { wrapper: wrapper(client) },
+    );
+
+    // A tool-using agent with zero bound environments is broken for
+    // visitors BY CONSTRUCTION (guests receive credentials only from the
+    // share's bindings) — the hook says so instead of staying silent,
+    // and needs no server round-trip to know it.
+    expect(result.current).toEqual({ status: "needs-credentials" });
+    await waitFor(() => expect(envLookup(client)).not.toHaveBeenCalled());
+  });
+
+  it("reports blocked with the private environment refs listed", async () => {
+    const client = mockStigmer({
+      envVisibility: {
+        "shared-creds": ApiResourceVisibility.visibility_org,
+      },
+    });
+
+    const { result } = renderHook(
+      () =>
+        useShareToolReadiness(
+          toolAgent(),
+          makeDraft({
+            environmentRefs: [
+              { org: "acme", slug: "private-creds" },
+              { org: "acme", slug: "shared-creds" },
+            ],
+          }),
+        ),
+      { 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({
+      envVisibility: {
+        "shared-creds": ApiResourceVisibility.visibility_org,
+      },
+    });
+
+    const { result } = renderHook(
+      () =>
+        useShareToolReadiness(
+          toolAgent(),
+          makeDraft({
+            environmentRefs: [{ org: "acme", slug: "shared-creds" }],
+          }),
+        ),
+      { wrapper: wrapper(client) },
+    );
+
+    await waitFor(() => expect(result.current).toEqual({ status: "ready" }));
+  });
+
+  it("treats an unreadable environment ref as blocking", async () => {
+    const client = mockStigmer({ envError: true });
+
+    const { result } = renderHook(
+      () =>
+        useShareToolReadiness(
+          toolAgent(),
+          makeDraft({
+            environmentRefs: [{ org: "acme", slug: "deleted-env" }],
+          }),
+        ),
+      { 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 }),
+          makeDraft({
+            environmentRefs: [{ org: "acme", slug: "shared-creds" }],
+          }),
+        ),
+      { wrapper: wrapper(client) },
+    );
+
+    expect(result.current).toEqual({ status: "na" });
+    await waitFor(() => expect(envLookup(client)).not.toHaveBeenCalled());
+  });
+
+  it("is n/a when sharing is disabled", () => {
+    const client = mockStigmer({});
+    const { result } = renderHook(
+      () => useShareToolReadiness(toolAgent(), makeDraft({ enabled: false })),
+      { wrapper: wrapper(client) },
+    );
+
+    expect(result.current).toEqual({ status: "na" });
+  });
+
+  it("is n/a for org-audience shares — bindings are public-audience only", () => {
+    const client = mockStigmer({});
+    const { result } = renderHook(
+      () => useShareToolReadiness(toolAgent(), makeDraft({ audience: "org" })),
+      { wrapper: wrapper(client) },
+    );
+
+    // Org-audience shares reject environment_refs at the proto boundary
+    // (member sessions carry no share linkage in Phase A), so there is
+    // no credential state to advise on.
+    expect(result.current).toEqual({ status: "na" });
+  });
+
+  it("is n/a in local mode — no guest runtime, no secret gating", () => {
+    const client = mockStigmer({});
+    const { result } = renderHook(
+      () => useShareToolReadiness(toolAgent(), makeDraft()),
+      { wrapper: wrapper(client, "local") },
+    );
+
+    expect(result.current).toEqual({ status: "na" });
+  });
+});