@korso/shepherd-ui 0.1.0 → 0.2.0

package/dist/config/ConnectAgent.test.js

@@ -0,0 +1,92 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { render, screen, waitFor } from "@testing-library/react";
+import { userEvent } from "@testing-library/user-event";
+import { ShepherdProvider } from "../ShepherdProvider.js";
+import { ConnectAgent } from "./ConnectAgent.js";
+import { makeMockClient } from "../test/mockClient.js";
+// ---------------------------------------------------------------------------
+// ConnectAgent — install-command render + token mint/revoke. DB-free: the mock
+// ShepherdClient is injected via ShepherdProvider's `client` prop.
+// ---------------------------------------------------------------------------
+describe("ConnectAgent", () => {
+    const WORKSPACE_ID = "ws_1";
+    const HUB_URL = "https://hub.example.run.app";
+    let client;
+    beforeEach(() => {
+        client = makeMockClient({
+            listTokens: vi.fn().mockResolvedValue({ tokens: [] }),
+        });
+    });
+    function renderConnect() {
+        return render(_jsx(ShepherdProvider, { client: client, children: _jsx(ConnectAgent, { workspaceId: WORKSPACE_ID, hubUrl: HUB_URL }) }));
+    }
+    it("does not show a raw token until one is minted", async () => {
+        renderConnect();
+        await waitFor(() => expect(client.listTokens).toHaveBeenCalled());
+        // The command shows a placeholder, not a real shp_ token, before minting.
+        const cmd = screen.getByTestId("install-command").textContent ?? "";
+        expect(cmd).not.toMatch(/shp_realtoken/);
+    });
+    it("renders the install command with the direct Hub URL after minting a token", async () => {
+        client.mintToken = vi
+            .fn()
+            .mockResolvedValue({ token: "shp_realtoken123", id: "tok_1" });
+        renderConnect();
+        await waitFor(() => expect(client.listTokens).toHaveBeenCalled());
+        await userEvent.click(screen.getByRole("button", { name: /generate token/i }));
+        await waitFor(() => {
+            const cmd = screen.getByTestId("install-command").textContent ?? "";
+            expect(cmd).toContain("shp_realtoken123");
+            expect(cmd).toContain(HUB_URL);
+        });
+        expect(client.mintToken).toHaveBeenCalledWith(WORKSPACE_ID, expect.any(Object));
+    });
+    it("surfaces the raw token exactly once (with a one-time notice)", async () => {
+        client.mintToken = vi
+            .fn()
+            .mockResolvedValue({ token: "shp_onceonly", id: "tok_1" });
+        renderConnect();
+        await userEvent.click(screen.getByRole("button", { name: /generate token/i }));
+        await waitFor(() => {
+            expect(screen.getByTestId("install-command").textContent).toContain("shp_onceonly");
+        });
+        // The one-time warning is shown so the operator knows to copy it now.
+        expect(screen.getByText(/won't be shown again|shown once|only.*once/i)).toBeInTheDocument();
+    });
+    it("switches the install command when a different tool is picked", async () => {
+        client.mintToken = vi
+            .fn()
+            .mockResolvedValue({ token: "shp_tok", id: "tok_1" });
+        renderConnect();
+        await userEvent.click(screen.getByRole("button", { name: /generate token/i }));
+        await waitFor(() => expect(screen.getByTestId("install-command").textContent).toContain("shp_tok"));
+        const claudeCmd = screen.getByTestId("install-command").textContent ?? "";
+        expect(claudeCmd).toMatch(/claude mcp add/);
+        // Pick Codex.
+        await userEvent.selectOptions(screen.getByLabelText(/tool/i), "codex");
+        await waitFor(() => {
+            const codexCmd = screen.getByTestId("install-command").textContent ?? "";
+            expect(codexCmd).toMatch(/codex mcp add/);
+            expect(codexCmd).toContain("shp_tok");
+        });
+    });
+    it("lists existing tokens and revokes one", async () => {
+        client.listTokens = vi.fn().mockResolvedValue({
+            tokens: [
+                {
+                    id: "tok_old",
+                    name: "laptop",
+                    lastUsedAt: null,
+                    createdAt: "2026-06-01T00:00:00.000Z",
+                    revokedAt: null,
+                },
+            ],
+        });
+        client.revokeToken = vi.fn().mockResolvedValue(undefined);
+        renderConnect();
+        await waitFor(() => expect(screen.getByText("laptop")).toBeInTheDocument());
+        await userEvent.click(screen.getByRole("button", { name: /revoke/i }));
+        await waitFor(() => expect(client.revokeToken).toHaveBeenCalledWith(WORKSPACE_ID, "tok_old"));
+    });
+});

package/dist/config/EmptyState.d.ts

@@ -0,0 +1,12 @@
+import type { ReactNode } from "react";
+export interface EmptyStateProps {
+    /** Heading text. Defaults to a generic "no workspace yet" prompt. */
+    title?: string;
+    /** Supporting copy. */
+    children?: ReactNode;
+    /** Invoked when the user clicks the call-to-action (e.g. switch to Config). */
+    onGetStarted?: () => void;
+    /** CTA label. */
+    ctaLabel?: string;
+}
+export declare function EmptyState({ title, children, onGetStarted, ctaLabel, }: EmptyStateProps): import("react").JSX.Element;

package/dist/config/EmptyState.js

@@ -0,0 +1,4 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+export function EmptyState({ title = "No workspace yet", children, onGetStarted, ctaLabel = "Go to Config", }) {
+    return (_jsxs("section", { className: "shepherd-empty-state", "aria-labelledby": "empty-state-heading", children: [_jsx("h2", { id: "empty-state-heading", children: title }), _jsx("p", { children: children ?? "Create a workspace or join one with an invite code to get started." }), onGetStarted && (_jsx("button", { type: "button", onClick: onGetStarted, children: ctaLabel }))] }));
+}

package/dist/config/EmptyState.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/config/EmptyState.test.js

@@ -0,0 +1,32 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, it, expect, vi } from "vitest";
+import { render, screen } from "@testing-library/react";
+import { userEvent } from "@testing-library/user-event";
+import { EmptyState } from "./EmptyState.js";
+// ---------------------------------------------------------------------------
+// EmptyState — the reusable "no workspace yet" prompt with an optional CTA.
+// ---------------------------------------------------------------------------
+describe("EmptyState", () => {
+    it("renders the default title, copy, and CTA label", () => {
+        render(_jsx(EmptyState, { onGetStarted: () => { } }));
+        expect(screen.getByRole("heading", { name: /no workspace yet/i })).toBeInTheDocument();
+        expect(screen.getByText(/create a workspace or join one/i)).toBeInTheDocument();
+        expect(screen.getByRole("button", { name: /go to config/i })).toBeInTheDocument();
+    });
+    it("invokes onGetStarted when the CTA is clicked", async () => {
+        const onGetStarted = vi.fn();
+        render(_jsx(EmptyState, { onGetStarted: onGetStarted }));
+        await userEvent.click(screen.getByRole("button", { name: /go to config/i }));
+        expect(onGetStarted).toHaveBeenCalledTimes(1);
+    });
+    it("honours custom title, copy, and CTA label", () => {
+        render(_jsx(EmptyState, { title: "Nothing here", ctaLabel: "Get going", onGetStarted: () => { }, children: "Custom supporting copy." }));
+        expect(screen.getByRole("heading", { name: "Nothing here" })).toBeInTheDocument();
+        expect(screen.getByText("Custom supporting copy.")).toBeInTheDocument();
+        expect(screen.getByRole("button", { name: "Get going" })).toBeInTheDocument();
+    });
+    it("omits the CTA when no handler is supplied", () => {
+        render(_jsx(EmptyState, {}));
+        expect(screen.queryByRole("button")).not.toBeInTheDocument();
+    });
+});

package/dist/config/Members.d.ts

@@ -0,0 +1,10 @@
+export interface MembersProps {
+    workspaceId: string;
+    /** Bumped by the parent to force a refetch (e.g. after an invite is redeemed). */
+    refreshKey?: number;
+    /** When true, render the per-member remove control (the caller gates on admin). */
+    canRemove?: boolean;
+    /** Called after a successful self-service leave, so the shell can refresh. */
+    onLeft?: () => void;
+}
+export declare function Members({ workspaceId, refreshKey, canRemove, onLeft }: MembersProps): import("react").JSX.Element;

package/dist/config/Members.js

@@ -0,0 +1,83 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useId, useState } from "react";
+import { useShepherdClient } from "../context.js";
+import { describeError } from "../client.js";
+export function Members({ workspaceId, refreshKey = 0, canRemove = false, onLeft }) {
+    const client = useShepherdClient();
+    const headingId = useId();
+    const [members, setMembers] = useState([]);
+    const [error, setError] = useState(null);
+    const [status, setStatus] = useState(null);
+    // True until the first load() resolves, so the initial fetch shows "Loading…"
+    // rather than the genuine "No members." empty state.
+    const [loading, setLoading] = useState(true);
+    // Per-row in-flight remove guard (by accountId) and a leave busy flag, both
+    // used to disable their buttons and block double-submit.
+    const [removingId, setRemovingId] = useState(null);
+    const [leaving, setLeaving] = useState(false);
+    // `keepError` lets the remove-failure path re-sync the roster without wiping
+    // the message it just surfaced (a fresh fetch normally clears stale errors).
+    async function load({ keepError = false } = {}) {
+        if (!keepError)
+            setError(null);
+        try {
+            const res = await client.listMembers(workspaceId);
+            setMembers(res.members);
+        }
+        catch (err) {
+            setError(describeError(err));
+        }
+        finally {
+            setLoading(false);
+        }
+    }
+    useEffect(() => {
+        setLoading(true);
+        void load();
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [client, workspaceId, refreshKey]);
+    async function remove(accountId, display) {
+        if (removingId)
+            return;
+        setRemovingId(accountId);
+        setError(null);
+        setStatus(null);
+        // Optimistically drop the row; re-sync from the server if it rejects.
+        setMembers((current) => current.filter((m) => m.accountId !== accountId));
+        try {
+            await client.removeMember(workspaceId, accountId);
+            setStatus(`Removed ${display}`);
+        }
+        catch (err) {
+            setError(describeError(err));
+            // The captured roster may be stale; recover from the server instead,
+            // preserving the failure message we just set.
+            void load({ keepError: true });
+        }
+        finally {
+            setRemovingId(null);
+        }
+    }
+    async function leave() {
+        if (leaving)
+            return;
+        setLeaving(true);
+        setError(null);
+        setStatus(null);
+        try {
+            await client.leave(workspaceId);
+            setStatus("Left workspace");
+            onLeft?.();
+        }
+        catch (err) {
+            setError(describeError(err));
+        }
+        finally {
+            setLeaving(false);
+        }
+    }
+    return (_jsxs("section", { className: "shepherd-members", "aria-labelledby": headingId, children: [_jsx("h3", { id: headingId, children: "Members" }), error && _jsx("p", { role: "alert", children: error }), status && _jsx("p", { role: "status", children: status }), loading ? (_jsx("p", { role: "status", children: "Loading\u2026" })) : members.length === 0 ? (_jsx("p", { children: "No members." })) : (_jsx("ul", { children: members.map((m) => {
+                    const display = m.displayName ?? m.githubLogin ?? m.accountId;
+                    return (_jsxs("li", { children: [_jsx("span", { children: display }), _jsx("span", { className: "role", children: m.role }), canRemove && (_jsx("button", { type: "button", "aria-label": `Remove ${display}`, onClick: () => void remove(m.accountId, display), disabled: removingId === m.accountId, children: "Remove" }))] }, m.accountId));
+                }) })), _jsx("button", { type: "button", onClick: () => void leave(), disabled: leaving, children: "Leave workspace" })] }));
+}

package/dist/config/Members.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/config/Members.test.js

@@ -0,0 +1,66 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { render, screen, waitFor } from "@testing-library/react";
+import { userEvent } from "@testing-library/user-event";
+import { ShepherdProvider } from "../ShepherdProvider.js";
+import { Members } from "./Members.js";
+import { makeMockClient } from "../test/mockClient.js";
+// ---------------------------------------------------------------------------
+// Members — the workspace roster with an admin-only remove control. Fetches the
+// list on mount and removes a member through the client.
+// ---------------------------------------------------------------------------
+const WORKSPACE_ID = "ws_1";
+describe("Members", () => {
+    let client;
+    beforeEach(() => {
+        client = makeMockClient();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    function renderMembers() {
+        return render(_jsx(ShepherdProvider, { client: client, children: _jsx(Members, { workspaceId: WORKSPACE_ID }) }));
+    }
+    it("lists members fetched from the client", async () => {
+        client.listMembers = vi.fn().mockResolvedValue({
+            members: [
+                {
+                    accountId: "acc_1",
+                    displayName: "Alice",
+                    githubLogin: "alice",
+                    avatarUrl: null,
+                    role: "admin",
+                },
+            ],
+        });
+        renderMembers();
+        await waitFor(() => expect(client.listMembers).toHaveBeenCalledWith(WORKSPACE_ID));
+        expect(await screen.findByText("Alice")).toBeInTheDocument();
+        expect(screen.getByText("admin")).toBeInTheDocument();
+    });
+    it("shows an empty state when there are no members", async () => {
+        client.listMembers = vi.fn().mockResolvedValue({ members: [] });
+        renderMembers();
+        expect(await screen.findByText(/no members/i)).toBeInTheDocument();
+    });
+    it("removes a member through the client", async () => {
+        client.listMembers = vi.fn().mockResolvedValue({
+            members: [
+                {
+                    accountId: "acc_2",
+                    displayName: "Bob",
+                    githubLogin: "bob",
+                    avatarUrl: null,
+                    role: "member",
+                },
+            ],
+        });
+        client.removeMember = vi.fn().mockResolvedValue(undefined);
+        renderMembers();
+        expect(await screen.findByText("Bob")).toBeInTheDocument();
+        await userEvent.click(screen.getByRole("button", { name: /remove/i }));
+        await waitFor(() => expect(client.removeMember).toHaveBeenCalledWith(WORKSPACE_ID, "acc_2"));
+        // Optimistically dropped from the list.
+        await waitFor(() => expect(screen.queryByText("Bob")).not.toBeInTheDocument());
+    });
+});

package/dist/config/Workspaces.d.ts

@@ -0,0 +1,12 @@
+import type { WorkspaceSummaryT } from "@shepherd/shared";
+export interface WorkspacesProps {
+    /** All workspaces the account belongs to (for the switcher / context). */
+    workspaces: WorkspaceSummaryT[];
+    /** The currently-selected workspace, or null when the account has none. */
+    selected: WorkspaceSummaryT | null;
+    /** Called after a mutation that changes membership (create / join / leave). */
+    onChanged: () => void;
+    /** Switch the active workspace (optional simple switcher). */
+    onSelect?: (workspaceId: string) => void;
+}
+export declare function Workspaces({ workspaces, selected, onChanged, onSelect }: WorkspacesProps): import("react").JSX.Element;

package/dist/config/Workspaces.js

@@ -0,0 +1,96 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useId, useState } from "react";
+import { useShepherdClient } from "../context.js";
+import { describeError } from "../client.js";
+import { Members } from "./Members.js";
+export function Workspaces({ workspaces, selected, onChanged, onSelect }) {
+    const client = useShepherdClient();
+    const headingId = useId();
+    const [name, setName] = useState("");
+    const [code, setCode] = useState("");
+    const [invite, setInvite] = useState(null);
+    const [error, setError] = useState(null);
+    const [busy, setBusy] = useState(false);
+    // Bumped after a mutation that affects the current workspace's roster, so the
+    // <Members> child refetches (e.g. after an invite is created or a join lands).
+    const [membersRefreshKey, setMembersRefreshKey] = useState(0);
+    const isAdmin = selected?.role === "admin";
+    async function create() {
+        if (!name.trim() || busy)
+            return;
+        setBusy(true);
+        setError(null);
+        try {
+            await client.createWorkspace({ name: name.trim() });
+            setName("");
+            onChanged();
+        }
+        catch (err) {
+            setError(describeError(err));
+        }
+        finally {
+            setBusy(false);
+        }
+    }
+    async function join() {
+        if (!code.trim() || busy)
+            return;
+        setBusy(true);
+        setError(null);
+        try {
+            await client.redeemInvite(code.trim());
+            setCode("");
+            onChanged();
+            setMembersRefreshKey((k) => k + 1);
+        }
+        catch (err) {
+            setError(describeError(err));
+        }
+        finally {
+            setBusy(false);
+        }
+    }
+    async function createInvite() {
+        if (!selected || busy)
+            return;
+        setBusy(true);
+        setError(null);
+        try {
+            const res = await client.createInvite(selected.id, {});
+            setInvite(res);
+            setMembersRefreshKey((k) => k + 1);
+        }
+        catch (err) {
+            setError(describeError(err));
+        }
+        finally {
+            setBusy(false);
+        }
+    }
+    async function revokeInvite() {
+        if (!selected || !invite || busy)
+            return;
+        setBusy(true);
+        setError(null);
+        try {
+            await client.revokeInvite(selected.id, invite.code);
+            setInvite(null);
+        }
+        catch (err) {
+            setError(describeError(err));
+        }
+        finally {
+            setBusy(false);
+        }
+    }
+    // Clear any displayed invite when the selected workspace changes.
+    useEffect(() => {
+        setInvite(null);
+    }, [selected?.id]);
+    // InviteResponse has no `link`; build the shareable join URL from the code.
+    // Encode the code for path-safety (parity with client.ts path encoding).
+    const joinLink = invite
+        ? `${window.location.origin}/join/${encodeURIComponent(invite.code)}`
+        : null;
+    return (_jsxs("section", { className: "shepherd-workspaces", "aria-labelledby": headingId, children: [_jsx("h3", { id: headingId, children: "Workspace management" }), error && _jsx("p", { role: "alert", children: error }), workspaces.length > 1 && onSelect && (_jsxs("div", { className: "switcher", children: [_jsx("label", { htmlFor: "ws-switcher", children: "Active workspace" }), _jsx("select", { id: "ws-switcher", value: selected?.id ?? "", onChange: (e) => onSelect(e.target.value), children: workspaces.map((w) => (_jsx("option", { value: w.id, children: w.name }, w.id))) })] })), _jsxs("div", { className: "create", children: [_jsx("label", { htmlFor: "ws-name", children: "Workspace name" }), _jsx("input", { id: "ws-name", type: "text", value: name, onChange: (e) => setName(e.target.value) }), _jsx("button", { type: "button", onClick: () => void create(), disabled: busy, children: "Create workspace" })] }), _jsxs("div", { className: "join", children: [_jsx("label", { htmlFor: "invite-code", children: "Invite code" }), _jsx("input", { id: "invite-code", type: "text", value: code, onChange: (e) => setCode(e.target.value) }), _jsx("button", { type: "button", onClick: () => void join(), disabled: busy, children: "Join" })] }), isAdmin && selected && (_jsxs("div", { className: "admin", children: [_jsxs("div", { className: "invites", children: [_jsx("button", { type: "button", onClick: () => void createInvite(), disabled: busy, children: "Create invite" }), invite && (_jsxs("div", { className: "invite-result", children: [_jsx("code", { children: invite.code }), _jsx("a", { href: joinLink ?? undefined, children: joinLink }), _jsxs("span", { className: "invite-uses", children: [invite.useCount, " / ", invite.maxUses, " uses"] }), _jsx("button", { type: "button", onClick: () => void revokeInvite(), disabled: busy, children: "Revoke invite" })] }))] }), _jsx(Members, { workspaceId: selected.id, refreshKey: membersRefreshKey, onLeft: onChanged, canRemove: true })] }))] }));
+}

package/dist/config/Workspaces.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/config/Workspaces.test.js

@@ -0,0 +1,90 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { render, screen, waitFor } from "@testing-library/react";
+import { userEvent } from "@testing-library/user-event";
+import { ShepherdProvider } from "../ShepherdProvider.js";
+import { Workspaces } from "./Workspaces.js";
+import { makeMockClient } from "../test/mockClient.js";
+// ---------------------------------------------------------------------------
+// Workspaces — create / join, plus admin-only invite + member-admin controls.
+// Admin-ness is read from the selected workspace's `role` (WorkspaceSummary.role).
+// ---------------------------------------------------------------------------
+const ADMIN_WS = { id: "ws_1", slug: "acme", name: "Acme", role: "admin" };
+const MEMBER_WS = { id: "ws_2", slug: "beta", name: "Beta", role: "member" };
+describe("Workspaces", () => {
+    let client;
+    beforeEach(() => {
+        client = makeMockClient();
+    });
+    function renderWorkspaces(props = {}) {
+        return render(_jsx(ShepherdProvider, { client: client, children: _jsx(Workspaces, { workspaces: props.workspace ? [props.workspace] : [], selected: props.workspace ?? null, onChanged: props.onChanged ?? (() => { }) }) }));
+    }
+    it("creates a workspace via the client", async () => {
+        const onChanged = vi.fn();
+        renderWorkspaces({ onChanged });
+        await userEvent.type(screen.getByLabelText(/workspace name/i), "My Team");
+        await userEvent.click(screen.getByRole("button", { name: /create workspace/i }));
+        await waitFor(() => expect(client.createWorkspace).toHaveBeenCalledWith({ name: "My Team" }));
+        expect(onChanged).toHaveBeenCalled();
+    });
+    it("joins a workspace by redeeming an invite code", async () => {
+        const onChanged = vi.fn();
+        renderWorkspaces({ onChanged });
+        await userEvent.type(screen.getByLabelText(/invite code/i), "INV-123");
+        await userEvent.click(screen.getByRole("button", { name: /join/i }));
+        await waitFor(() => expect(client.redeemInvite).toHaveBeenCalledWith("INV-123"));
+        expect(onChanged).toHaveBeenCalled();
+    });
+    it("shows invite + member-admin controls for an admin", async () => {
+        client.listMembers = vi.fn().mockResolvedValue({
+            members: [
+                {
+                    accountId: "acc_1",
+                    displayName: "Alice",
+                    githubLogin: "alice",
+                    avatarUrl: null,
+                    role: "admin",
+                },
+            ],
+        });
+        renderWorkspaces({ workspace: ADMIN_WS });
+        expect(screen.getByRole("button", { name: /create invite/i })).toBeInTheDocument();
+        await waitFor(() => expect(screen.getByText("Alice")).toBeInTheDocument());
+    });
+    it("hides invite + member-admin controls for a non-admin member", async () => {
+        renderWorkspaces({ workspace: MEMBER_WS });
+        expect(screen.queryByRole("button", { name: /create invite/i })).not.toBeInTheDocument();
+        // The member list is not even fetched for a non-admin.
+        expect(client.listMembers).not.toHaveBeenCalled();
+    });
+    it("creates an invite (admin) and shows the code", async () => {
+        client.createInvite = vi.fn().mockResolvedValue({
+            code: "INV-NEW",
+            expiresAt: null,
+            maxUses: 5,
+            useCount: 0,
+        });
+        renderWorkspaces({ workspace: ADMIN_WS });
+        await userEvent.click(screen.getByRole("button", { name: /create invite/i }));
+        await waitFor(() => expect(client.createInvite).toHaveBeenCalledWith("ws_1", expect.any(Object)));
+        await waitFor(() => expect(screen.getByText(/INV-NEW/)).toBeInTheDocument());
+    });
+    it("removes a member (admin)", async () => {
+        client.listMembers = vi.fn().mockResolvedValue({
+            members: [
+                {
+                    accountId: "acc_2",
+                    displayName: "Bob",
+                    githubLogin: "bob",
+                    avatarUrl: null,
+                    role: "member",
+                },
+            ],
+        });
+        client.removeMember = vi.fn().mockResolvedValue(undefined);
+        renderWorkspaces({ workspace: ADMIN_WS });
+        await waitFor(() => expect(screen.getByText("Bob")).toBeInTheDocument());
+        await userEvent.click(screen.getByRole("button", { name: /remove/i }));
+        await waitFor(() => expect(client.removeMember).toHaveBeenCalledWith("ws_1", "acc_2"));
+    });
+});

package/dist/config/index.d.ts

@@ -0,0 +1,8 @@
+export { ConnectAgent } from "./ConnectAgent.js";
+export type { ConnectAgentProps } from "./ConnectAgent.js";
+export { Workspaces } from "./Workspaces.js";
+export type { WorkspacesProps } from "./Workspaces.js";
+export { Members } from "./Members.js";
+export type { MembersProps } from "./Members.js";
+export { EmptyState } from "./EmptyState.js";
+export type { EmptyStateProps } from "./EmptyState.js";

package/dist/config/index.js

@@ -0,0 +1,6 @@
+// Config-surface components (Task 6.3). Re-exported so consumers can compose
+// the pieces directly if they don't use the full ShepherdRoot shell.
+export { ConnectAgent } from "./ConnectAgent.js";
+export { Workspaces } from "./Workspaces.js";
+export { Members } from "./Members.js";
+export { EmptyState } from "./EmptyState.js";

package/dist/context.d.ts

@@ -0,0 +1,28 @@
+import type { ReactNode } from "react";
+import type { ShepherdClient } from "./client.js";
+/** Props for {@link ShepherdClientProvider}. */
+export interface ShepherdClientProviderProps {
+    /** The client made available to every descendant via the context. */
+    client: ShepherdClient;
+    /** The subtree that may read the client through {@link useShepherdClient}. */
+    children: ReactNode;
+}
+/**
+ * Supplies a {@link ShepherdClient} to the React subtree. This is the seam that
+ * keeps the dashboard auth-agnostic: the host constructs a client (wiring in
+ * whatever auth it uses) and injects it here, so components below only ever see
+ * the auth-neutral client interface — never tokens or transport details.
+ *
+ * @param props - The client to provide and the children that consume it.
+ * @returns A provider element wrapping `children`.
+ */
+export declare function ShepherdClientProvider({ client, children, }: ShepherdClientProviderProps): ReactNode;
+/**
+ * Reads the {@link ShepherdClient} from context. Throws when called outside a
+ * {@link ShepherdClientProvider} so a missing provider surfaces as an immediate,
+ * named error at render time instead of a confusing null-dereference later.
+ *
+ * @returns The client supplied by the nearest provider.
+ * @throws Error When invoked with no {@link ShepherdClientProvider} ancestor.
+ */
+export declare function useShepherdClient(): ShepherdClient;

package/dist/context.js

@@ -0,0 +1,36 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { createContext, useContext } from "react";
+/**
+ * Holds the active {@link ShepherdClient}, or `null` when no provider is above
+ * a consumer. The nullable default lets {@link useShepherdClient} distinguish
+ * "no provider" from a legitimately-provided client and fail loudly rather than
+ * handing back a silent stand-in.
+ */
+const ShepherdClientContext = createContext(null);
+/**
+ * Supplies a {@link ShepherdClient} to the React subtree. This is the seam that
+ * keeps the dashboard auth-agnostic: the host constructs a client (wiring in
+ * whatever auth it uses) and injects it here, so components below only ever see
+ * the auth-neutral client interface — never tokens or transport details.
+ *
+ * @param props - The client to provide and the children that consume it.
+ * @returns A provider element wrapping `children`.
+ */
+export function ShepherdClientProvider({ client, children, }) {
+    return (_jsx(ShepherdClientContext.Provider, { value: client, children: children }));
+}
+/**
+ * Reads the {@link ShepherdClient} from context. Throws when called outside a
+ * {@link ShepherdClientProvider} so a missing provider surfaces as an immediate,
+ * named error at render time instead of a confusing null-dereference later.
+ *
+ * @returns The client supplied by the nearest provider.
+ * @throws Error When invoked with no {@link ShepherdClientProvider} ancestor.
+ */
+export function useShepherdClient() {
+    const client = useContext(ShepherdClientContext);
+    if (client === null) {
+        throw new Error("useShepherdClient must be used within <ShepherdClientProvider>");
+    }
+    return client;
+}