@korso/shepherd-ui 0.1.1 → 0.2.1

package/dist/components/RepoSelect.js

@@ -0,0 +1,56 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useEffect, useRef, useState } from "react";
+const EMPTY = { active: 0, done: 0 };
+/**
+ * The repo filter: a click-to-open menu of repos plus an "All repos" option,
+ * each showing its `"N active · N done"` tally. Ported from app.js
+ * `renderRepoSelect` — same markup, classes, and listbox/option roles so it
+ * stays keyboard- and screen-reader-operable.
+ *
+ * Hidden entirely when fewer than two repos exist (nothing to filter). Owns its
+ * own open/close state; the trigger toggles it and Escape closes it. Choosing a
+ * repo calls `onSelect(repo)`; choosing "All repos" calls `onSelect(null)` —
+ * matching app.js, which then stores the sentinel `"__all__"` for All repos.
+ *
+ * @param props - Repos, per-repo counts, the current selection, and the
+ *   selection callback.
+ * @returns The repo selector, or `null` when there are fewer than two repos.
+ */
+export function RepoSelect({ repos, counts, selected, onSelect, }) {
+    const [open, setOpen] = useState(false);
+    const hostRef = useRef(null);
+    // Move focus into the freshly-opened menu (the selected option, else the
+    // first) so keyboard users can Tab the options and Esc out — only on open.
+    useEffect(() => {
+        if (!open)
+            return;
+        const menu = hostRef.current?.querySelector(".repo-menu");
+        if (!menu)
+            return;
+        const target = menu.querySelector('[aria-selected="true"]') ??
+            menu.querySelector("button");
+        target?.focus();
+    }, [open]);
+    if (repos.length < 2)
+        return null;
+    const isAll = selected === null || selected === "__all__";
+    const label = isAll ? "All repos" : selected;
+    /** A single menu option; `repo === null` is the "All repos" row. */
+    const renderItem = (repo, text) => {
+        const c = repo === null ? counts.__all__ ?? EMPTY : counts[repo] ?? EMPTY;
+        const isOn = repo === null ? isAll : selected === repo;
+        const cls = "repo-mi" + (isOn ? " on" : "") + (repo === null ? " all" : "");
+        return (_jsxs("button", { type: "button", className: cls, role: "option", "aria-selected": isOn, onClick: (e) => {
+                e.stopPropagation();
+                setOpen(false);
+                onSelect(repo);
+            }, children: [_jsx("span", { children: text }), _jsx("span", { className: "ct", children: `${c.active} active · ${c.done} done` })] }, repo ?? "__all__"));
+    };
+    return (_jsxs("span", { ref: hostRef, className: "repo", onKeyDown: (e) => {
+            if (e.key === "Escape")
+                setOpen(false);
+        }, children: [_jsxs("button", { type: "button", className: "repo-trig", "aria-haspopup": "listbox", "aria-expanded": open, "aria-label": `Filter by repo (current: ${label})`, onClick: (e) => {
+                    e.stopPropagation();
+                    setOpen((o) => !o);
+                }, children: [_jsx("span", { className: "slash", children: "/" }), " " + label + " ", _jsx("span", { children: "\u25BC" })] }), open && (_jsxs("div", { className: "repo-menu", role: "listbox", children: [repos.map((r) => renderItem(r, r)), renderItem(null, "All repos")] }))] }));
+}

package/dist/components/Territory.d.ts

@@ -0,0 +1,21 @@
+import type { ReactElement } from "react";
+/** Props for {@link Territory}. */
+export interface TerritoryProps {
+    /** The claim's path globs. */
+    globs: string[];
+}
+/**
+ * A claim's territory pills. Ported from app.js `taskTerritory`. A single path
+ * (or none) renders inline under a "territory" label; two or more collapse into
+ * a native `<details>` whose summary reads `"N paths"` and expands to the full
+ * glob list.
+ *
+ * Unlike app.js the open/closed state is left to the browser's native
+ * `<details>` rather than persisted across polls: React reconciles the same
+ * element across re-renders (no `replaceChildren` rebuild), so the fold state
+ * survives without manual bookkeeping.
+ *
+ * @param props - The globs to display.
+ * @returns The territory element (inline or a collapsible `<details>`).
+ */
+export declare function Territory({ globs }: TerritoryProps): ReactElement;

package/dist/components/Territory.js

@@ -0,0 +1,21 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * A claim's territory pills. Ported from app.js `taskTerritory`. A single path
+ * (or none) renders inline under a "territory" label; two or more collapse into
+ * a native `<details>` whose summary reads `"N paths"` and expands to the full
+ * glob list.
+ *
+ * Unlike app.js the open/closed state is left to the browser's native
+ * `<details>` rather than persisted across polls: React reconciles the same
+ * element across re-renders (no `replaceChildren` rebuild), so the fold state
+ * survives without manual bookkeeping.
+ *
+ * @param props - The globs to display.
+ * @returns The territory element (inline or a collapsible `<details>`).
+ */
+export function Territory({ globs }) {
+    if (globs.length <= 1) {
+        return (_jsxs("div", { className: "terr", children: [_jsx("span", { className: "terr__lbl", children: "territory" }), globs.map((g) => (_jsx("span", { className: "glob", children: g }, g)))] }));
+    }
+    return (_jsxs("details", { className: "terrx", children: [_jsxs("summary", { children: [_jsx("span", { className: "terr__lbl", children: "territory" }), _jsxs("span", { className: "glob glob--more", children: [_jsx("span", { className: "tw", children: "\u25B6" }), ` ${globs.length} paths`] })] }), _jsx("div", { className: "terr terr--full", children: globs.map((g) => (_jsx("span", { className: "glob", children: g }, g))) })] }));
+}

package/dist/config/ConnectAgent.d.ts

@@ -0,0 +1,10 @@
+export interface ConnectAgentProps {
+    workspaceId: string;
+    /**
+     * The DIRECT Hub URL the agent connects to (public Cloud Run URL when hosted).
+     * Defaults to the dashboard client's baseUrl, which is correct for self-host
+     * where the agent and the dashboard share the Hub origin.
+     */
+    hubUrl?: string;
+}
+export declare function ConnectAgent({ workspaceId, hubUrl }: ConnectAgentProps): import("react").JSX.Element;

package/dist/config/ConnectAgent.js

@@ -0,0 +1,119 @@
+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";
+const TOOLS = [
+    { id: "claude", label: "Claude Code" },
+    { id: "codex", label: "Codex" },
+    { id: "pi", label: "Pi" },
+    { id: "generic", label: "Generic (JSON)" },
+];
+// The token placeholder shown before a real token is minted. Switching tools or
+// reading the command pre-mint shows this, never a real secret.
+const TOKEN_PLACEHOLDER = "shp_<paste-after-generating>";
+// The CLI tools differ only in the first line of the `mcp add` invocation; the
+// rest of the command (the env flags and the npx tail) is shared.
+const CLI_PREFIX = {
+    claude: "claude mcp add shepherd -s user \\",
+    codex: "codex mcp add shepherd \\",
+    pi: "pi mcp add shepherd \\",
+};
+function installCommand(tool, hubUrl, token) {
+    if (tool === "generic") {
+        return JSON.stringify({
+            mcpServers: {
+                shepherd: {
+                    command: "npx",
+                    args: ["-y", "@korso/shepherd"],
+                    env: { HUB_URL: hubUrl, SHEPHERD_TOKEN: token },
+                },
+            },
+        }, null, 2);
+    }
+    return [
+        CLI_PREFIX[tool],
+        `  -e HUB_URL=${hubUrl} \\`,
+        `  -e SHEPHERD_TOKEN=${token} \\`,
+        "  -- npx -y @korso/shepherd",
+    ].join("\n");
+}
+export function ConnectAgent({ workspaceId, hubUrl }) {
+    const client = useShepherdClient();
+    const directHubUrl = hubUrl ?? client.baseUrl;
+    const headingId = useId();
+    const [tool, setTool] = useState("claude");
+    const [name, setName] = useState("");
+    // The raw token from the most recent mint — shown once, then only as command.
+    const [rawToken, setRawToken] = useState(null);
+    const [tokens, setTokens] = useState([]);
+    const [error, setError] = useState(null);
+    const [status, setStatus] = useState(null);
+    const [busy, setBusy] = useState(false);
+    // True until the first loadTokens() resolves, so the management list shows a
+    // loading placeholder rather than the "No tokens yet." empty state.
+    const [loading, setLoading] = useState(true);
+    // Per-row in-flight revoke guard (by token id) to block double-submit.
+    const [revokingId, setRevokingId] = useState(null);
+    async function loadTokens() {
+        try {
+            const res = await client.listTokens(workspaceId);
+            setTokens(res.tokens);
+        }
+        catch (err) {
+            setError(describeError(err));
+        }
+        finally {
+            setLoading(false);
+        }
+    }
+    useEffect(() => {
+        setLoading(true);
+        void loadTokens();
+        // eslint-disable-next-line react-hooks/exhaustive-deps
+    }, [client, workspaceId]);
+    // The component is re-rendered (not remounted) across a workspace switch, so
+    // clear the once-shown raw token so it never leaks into another workspace's
+    // install command (mirrors Workspaces' setInvite(null) reset).
+    useEffect(() => {
+        setRawToken(null);
+    }, [workspaceId]);
+    async function generate() {
+        setBusy(true);
+        setError(null);
+        try {
+            const res = await client.mintToken(workspaceId, name.trim() ? { name: name.trim() } : {});
+            setRawToken(res.token);
+            setName("");
+            await loadTokens();
+        }
+        catch (err) {
+            setError(describeError(err));
+        }
+        finally {
+            setBusy(false);
+        }
+    }
+    async function revoke(tokenId) {
+        if (revokingId)
+            return;
+        setRevokingId(tokenId);
+        setError(null);
+        setStatus(null);
+        try {
+            await client.revokeToken(workspaceId, tokenId);
+            setTokens((prev) => prev.filter((t) => t.id !== tokenId));
+            setStatus("Token revoked");
+        }
+        catch (err) {
+            setError(describeError(err));
+        }
+        finally {
+            setRevokingId(null);
+        }
+    }
+    const command = installCommand(tool, directHubUrl, rawToken ?? TOKEN_PLACEHOLDER);
+    return (_jsxs("section", { className: "shepherd-connect-agent", "aria-labelledby": headingId, children: [_jsx("h3", { id: headingId, children: "Connect your agent" }), _jsx("label", { htmlFor: "connect-tool", children: "Tool" }), _jsx("select", { id: "connect-tool", value: tool, onChange: (e) => setTool(e.target.value), children: TOOLS.map((t) => (_jsx("option", { value: t.id, children: t.label }, t.id))) }), _jsxs("div", { className: "generate", children: [_jsx("label", { htmlFor: "token-name", children: "Token name (optional)" }), _jsx("input", { id: "token-name", type: "text", value: name, onChange: (e) => setName(e.target.value), placeholder: "e.g. laptop" }), _jsx("button", { type: "button", onClick: () => void generate(), disabled: busy, children: "Generate token" })] }), error && _jsx("p", { role: "alert", children: error }), status && _jsx("p", { role: "status", children: status }), rawToken && (_jsx("p", { className: "token-once", role: "status", children: "Copy this token now \u2014 it won't be shown again." })), _jsx("pre", { "data-testid": "install-command", children: command }), _jsx("h4", { children: "Existing tokens" }), loading ? (_jsx("p", { role: "status", children: "Loading\u2026" })) : tokens.length === 0 ? (_jsx("p", { children: "No tokens yet." })) : (_jsx("ul", { children: tokens.map((t) => {
+                    const name = t.name ?? t.id;
+                    return (_jsxs("li", { children: [_jsx("span", { children: name }), t.revokedAt ? (_jsx("span", { className: "revoked", children: "revoked" })) : (_jsx("button", { type: "button", "aria-label": `Revoke token ${name}`, onClick: () => void revoke(t.id), disabled: revokingId === t.id, children: "Revoke" }))] }, t.id));
+                }) }))] }));
+}

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,8 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useId } from "react";
+export function EmptyState({ title = "No workspace yet", children, onGetStarted, ctaLabel = "Go to Config", }) {
+    // A per-instance id so two EmptyStates (e.g. the Tasks and Chat panels of a
+    // no-workspace board) never collide on a duplicate `empty-state-heading` id.
+    const headingId = useId();
+    return (_jsxs("section", { className: "shepherd-empty-state", "aria-labelledby": headingId, children: [_jsx("h2", { id: headingId, 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/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/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/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;
+}

package/dist/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Public `.` entry for `@korso/shepherd-ui` — the auth-agnostic surface hosted
+ * consumers import. It deliberately does NOT export {@link SelfHostApp} (the
+ * token-gated self-host root lives behind the `./selfhost` export) and does NOT
+ * import `styles.css` — hosted consumers opt into styling via
+ * `@korso/shepherd-ui/styles.css`. This keeps the token gate out of `.` so the
+ * core stays auth-neutral.
+ */
+export { createShepherdClient, ShepherdClientError, describeError, } from "./client.js";
+export type { ShepherdClient, ShepherdClientConfig } from "./client.js";
+export { ShepherdClientProvider, useShepherdClient, } from "./context.js";
+export { ShepherdRoot } from "./ShepherdRoot.js";
+export type { ShepherdRootProps } from "./ShepherdRoot.js";
+export { Dashboard } from "./components/Dashboard.js";
+export type { DashboardProps } from "./components/Dashboard.js";
+export { Workspaces, Members, ConnectAgent, EmptyState, } from "./config/index.js";
+export type { WorkspacesProps, MembersProps, ConnectAgentProps, EmptyStateProps, } from "./config/index.js";
+export type { WorkspaceLandscapeResponseT, WorkspaceSummaryT, TokenSummaryT, MemberSummaryT, InviteResponseT, } from "@shepherd/shared";

package/dist/index.js

@@ -0,0 +1,15 @@
+/**
+ * Public `.` entry for `@korso/shepherd-ui` — the auth-agnostic surface hosted
+ * consumers import. It deliberately does NOT export {@link SelfHostApp} (the
+ * token-gated self-host root lives behind the `./selfhost` export) and does NOT
+ * import `styles.css` — hosted consumers opt into styling via
+ * `@korso/shepherd-ui/styles.css`. This keeps the token gate out of `.` so the
+ * core stays auth-neutral.
+ */
+export { createShepherdClient, ShepherdClientError, describeError, } from "./client.js";
+export { ShepherdClientProvider, useShepherdClient, } from "./context.js";
+export { ShepherdRoot } from "./ShepherdRoot.js";
+export { Dashboard } from "./components/Dashboard.js";
+// Config screens — re-exported so consumers can compose the management surface
+// directly without the full ShepherdRoot shell.
+export { Workspaces, Members, ConnectAgent, EmptyState, } from "./config/index.js";