npm - @korso/shepherd-ui - Versions diffs - 0.1.0 → 0.2.0 - Mend

@korso/shepherd-ui 0.1.0 → 0.2.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (99) hide show

package/dist/ShepherdProvider.d.ts +12 -0
package/dist/ShepherdProvider.js +33 -0
package/dist/ShepherdProvider.test.d.ts +1 -0
package/dist/ShepherdProvider.test.js +47 -0
package/dist/ShepherdRoot.d.ts +9 -0
package/dist/ShepherdRoot.js +88 -0
package/dist/ShepherdRoot.routing.test.d.ts +1 -0
package/dist/ShepherdRoot.routing.test.js +61 -0
package/dist/ShepherdRoot.test.d.ts +1 -0
package/dist/ShepherdRoot.test.js +37 -0
package/dist/app/assets/index-CDOCIg6s.js +11 -0
package/dist/app/index.html +12 -0
package/dist/client.d.ts +107 -0
package/dist/client.js +238 -0
package/dist/client.test.d.ts +1 -0
package/dist/client.test.js +298 -0
package/dist/components/ActiveList.d.ts +22 -0
package/dist/components/ActiveList.js +59 -0
package/dist/components/Chat.d.ts +30 -0
package/dist/components/Chat.js +61 -0
package/dist/components/Composer.d.ts +37 -0
package/dist/components/Composer.js +146 -0
package/dist/components/Crew.d.ts +23 -0
package/dist/components/Crew.js +31 -0
package/dist/components/Dashboard.d.ts +34 -0
package/dist/components/Dashboard.js +209 -0
package/dist/components/DoneList.d.ts +29 -0
package/dist/components/DoneList.js +50 -0
package/dist/components/RepoSelect.d.ts +38 -0
package/dist/components/RepoSelect.js +56 -0
package/dist/components/Territory.d.ts +21 -0
package/dist/components/Territory.js +21 -0
package/dist/config/ConnectAgent.d.ts +10 -0
package/dist/config/ConnectAgent.js +119 -0
package/dist/config/ConnectAgent.test.d.ts +1 -0
package/dist/config/ConnectAgent.test.js +92 -0
package/dist/config/EmptyState.d.ts +12 -0
package/dist/config/EmptyState.js +4 -0
package/dist/config/EmptyState.test.d.ts +1 -0
package/dist/config/EmptyState.test.js +32 -0
package/dist/config/Members.d.ts +10 -0
package/dist/config/Members.js +83 -0
package/dist/config/Members.test.d.ts +1 -0
package/dist/config/Members.test.js +66 -0
package/dist/config/Workspaces.d.ts +12 -0
package/dist/config/Workspaces.js +96 -0
package/dist/config/Workspaces.test.d.ts +1 -0
package/dist/config/Workspaces.test.js +90 -0
package/dist/config/index.d.ts +8 -0
package/dist/config/index.js +6 -0
package/dist/context.d.ts +28 -0
package/dist/context.js +36 -0
package/dist/index.cjs +5289 -0
package/dist/index.cjs.map +1 -0
package/dist/index.d.cts +149 -0
package/dist/index.d.ts +18 -0
package/dist/index.js +15 -0
package/dist/index.js.map +1 -0
package/dist/lib/Dashboard-CG6KeFQ3.js +1214 -0
package/dist/lib/index.d.ts +438 -16
package/dist/lib/index.js +455 -6
package/dist/lib/selfhost.js +9 -9
package/dist/lib/styles.css +27 -0
package/dist/logic.d.ts +208 -0
package/dist/logic.js +372 -0
package/dist/main.d.ts +1 -0
package/dist/main.js +11 -0
package/dist/selfhost/assets/{index-tSyzirZa.css → index-BZmImfYZ.css} +1 -1
package/dist/selfhost/assets/index-CS268KSw.js +40 -0
package/dist/selfhost/index.html +2 -2
package/dist/selfhost.d.ts +22 -0
package/dist/selfhost.js +97 -0
package/dist/test/mockClient.d.ts +6 -0
package/dist/test/mockClient.js +45 -0
package/dist/test/setup.d.ts +1 -0
package/dist/test/setup.js +2 -0
package/dist/useLandscapePolling.d.ts +63 -0
package/dist/useLandscapePolling.js +129 -0
package/dist/views/Chat.d.ts +5 -0
package/dist/views/Chat.js +60 -0
package/dist/views/Chat.test.d.ts +1 -0
package/dist/views/Chat.test.js +92 -0
package/dist/views/Config.d.ts +12 -0
package/dist/views/Config.js +6 -0
package/dist/views/Tasks.d.ts +5 -0
package/dist/views/Tasks.js +75 -0
package/dist/views/Tasks.test.d.ts +1 -0
package/dist/views/Tasks.test.js +115 -0
package/dist/views/useLandscape.d.ts +14 -0
package/dist/views/useLandscape.js +74 -0
package/dist/views/useLandscape.test.d.ts +1 -0
package/dist/views/useLandscape.test.js +101 -0
package/dist/views/wallboard.d.ts +46 -0
package/dist/views/wallboard.js +209 -0
package/dist/views/wallboard.test.d.ts +1 -0
package/dist/views/wallboard.test.js +143 -0
package/package.json +1 -1
package/dist/lib/Dashboard-CB6SL-J2.js +0 -1064
package/dist/selfhost/assets/index-BBx3vo2Y.js +0 -40

package/dist/selfhost/index.html CHANGED Viewed

@@ -4,8 +4,8 @@
     <meta charset="UTF-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
     <title>Shepherd</title>
-    <script type="module" crossorigin src="/assets/index-BBx3vo2Y.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-tSyzirZa.css">
+    <script type="module" crossorigin src="/assets/index-CS268KSw.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-BZmImfYZ.css">
   </head>
   <body>
     <div id="root"></div>

package/dist/selfhost.d.ts ADDED Viewed

@@ -0,0 +1,22 @@
+import type { ReactElement } from "react";
+/**
+ * The self-host SPA root and the ONE place a team token is handled — the named
+ * auth exception to the auth-agnostic core. Everything below the provider (the
+ * client, the polling hook, the {@link Dashboard}) stays token-blind; this
+ * component owns the token's lifecycle:
+ *
+ *  - It seeds token state from `localStorage["shepherd.token"]` (back-compat with
+ *    the legacy board), so a returning viewer skips the gate.
+ *  - With NO token it renders the {@link Gate}; a successful submit persists the
+ *    token and re-renders into the dashboard.
+ *  - With a token it builds a same-origin client (`baseUrl: ""`) that injects the
+ *    `Authorization: Bearer <token>` header and, on a 401, clears the stored
+ *    token and resets state — which re-renders straight back to the gate. This is
+ *    the React analogue of app.js's `clearToken()` + re-prompt 401 flow.
+ *
+ * The client is memoised on the token so it is rebuilt only when the token
+ * actually changes, not on every freshness re-render of the dashboard subtree.
+ *
+ * @returns Either the token gate or the authenticated dashboard.
+ */
+export declare function SelfHostApp(): ReactElement;

package/dist/selfhost.js ADDED Viewed

@@ -0,0 +1,97 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo, useState } from "react";
+import { createShepherdClient } from "./client.js";
+import { ShepherdClientProvider } from "./context.js";
+import { Dashboard } from "./components/Dashboard.js";
+/**
+ * localStorage key the operator's team token is stored under. Kept identical to
+ * the legacy vanilla board (packages/hub/public/app.js's `TOKEN_KEY`) so a
+ * viewer who already authenticated against the old board stays signed in after
+ * the React cutover — no re-prompt on upgrade.
+ */
+const TOKEN_KEY = "shepherd.token";
+/** localStorage read that never throws (private/quota modes return null). */
+function readToken() {
+    try {
+        return localStorage.getItem(TOKEN_KEY) ?? "";
+    }
+    catch {
+        return "";
+    }
+}
+/**
+ * The token gate, ported from the `.gate` markup in packages/hub/public/index.html.
+ * Rendered whenever no token is stored; submitting a non-empty token persists it
+ * and lifts the gate via {@link onSubmit}.
+ *
+ * @param props.onSubmit - Called with the entered token once the form is submitted.
+ */
+function Gate({ onSubmit }) {
+    const [value, setValue] = useState("");
+    const handle = (e) => {
+        e.preventDefault();
+        const trimmed = value.trim();
+        // Ignore an empty submit so the gate can't store a blank token and then
+        // bounce the viewer straight back to itself on the first 401.
+        if (trimmed !== "")
+            onSubmit(trimmed);
+    };
+    return (_jsxs("section", { id: "gate", className: "gate", children: [_jsx("h1", { children: "Shepherd" }), _jsx("p", { children: "Enter the team token to view the workspace." }), _jsxs("form", { id: "gate-form", onSubmit: handle, children: [_jsx("input", { id: "gate-input", type: "password", placeholder: "Team token", "aria-label": "Team token", autoComplete: "off", value: value, onChange: (e) => setValue(e.target.value) }), _jsx("button", { type: "submit", children: "View" })] })] }));
+}
+/**
+ * The self-host SPA root and the ONE place a team token is handled — the named
+ * auth exception to the auth-agnostic core. Everything below the provider (the
+ * client, the polling hook, the {@link Dashboard}) stays token-blind; this
+ * component owns the token's lifecycle:
+ *
+ *  - It seeds token state from `localStorage["shepherd.token"]` (back-compat with
+ *    the legacy board), so a returning viewer skips the gate.
+ *  - With NO token it renders the {@link Gate}; a successful submit persists the
+ *    token and re-renders into the dashboard.
+ *  - With a token it builds a same-origin client (`baseUrl: ""`) that injects the
+ *    `Authorization: Bearer <token>` header and, on a 401, clears the stored
+ *    token and resets state — which re-renders straight back to the gate. This is
+ *    the React analogue of app.js's `clearToken()` + re-prompt 401 flow.
+ *
+ * The client is memoised on the token so it is rebuilt only when the token
+ * actually changes, not on every freshness re-render of the dashboard subtree.
+ *
+ * @returns Either the token gate or the authenticated dashboard.
+ */
+export function SelfHostApp() {
+    const [token, setToken] = useState(readToken);
+    // Rebuild the client only when the token changes. WHY same-origin (baseUrl
+    // ""): the hub serves this SPA, so requests hit the hub's own origin and need
+    // no cross-origin base. onUnauthorized clears the token + resets state, which
+    // re-renders back to the gate — the automatic 401 re-gate.
+    const client = useMemo(() => createShepherdClient({
+        baseUrl: "",
+        getAuthHeader: () => `Bearer ${token}`,
+        onUnauthorized: () => {
+            try {
+                localStorage.removeItem(TOKEN_KEY);
+            }
+            catch {
+                // Best-effort: even if the remove fails, resetting state below still
+                // returns the viewer to the gate for this session.
+            }
+            setToken("");
+        },
+    }), [token]);
+    if (token === "") {
+        return (_jsx(Gate, { onSubmit: (t) => {
+                try {
+                    localStorage.setItem(TOKEN_KEY, t);
+                }
+                catch {
+                    // Best-effort persistence; the in-memory token still authenticates
+                    // this session even if storage is unavailable.
+                }
+                setToken(t);
+            } }));
+    }
+    // Restore the legacy board's layout container: the ported styles size `.wrap`
+    // to max-width:1100px with page gutters. The gate centers itself (`.gate`), so
+    // only the dashboard view needs the wrapper.
+    return (_jsx("div", { className: "wrap", children: _jsx(ShepherdClientProvider, { client: client, children: _jsx(Dashboard, {}) }) }));
+}

package/dist/test/mockClient.d.ts ADDED Viewed

@@ -0,0 +1,6 @@
+import { vi } from "vitest";
+import type { ShepherdClient } from "../client.js";
+export type MockClient = {
+    -readonly [K in keyof ShepherdClient]: ShepherdClient[K] extends (...a: infer A) => infer R ? ReturnType<typeof vi.fn<(...a: A) => R>> : ShepherdClient[K];
+};
+export declare function makeMockClient(overrides?: Partial<MockClient>): MockClient;

package/dist/test/mockClient.js ADDED Viewed

@@ -0,0 +1,45 @@
+import { vi } from "vitest";
+/** A schema-valid empty landscape, shared by getLandscape and landscape(). */
+const EMPTY_LANDSCAPE = {
+    agents: [],
+    tasks: [],
+    announcements: [],
+    serverTime: "2026-06-29T00:00:00.000Z",
+};
+/** A schema-valid empty announce result, shared by announce and announceTo. */
+const EMPTY_ANNOUNCE = { ok: true, announcementIds: [] };
+export function makeMockClient(overrides = {}) {
+    const base = {
+        baseUrl: "https://hub.example.run.app",
+        // --- multi-workspace management surface --------------------------------
+        listWorkspaces: vi.fn().mockResolvedValue({ workspaces: [] }),
+        createWorkspace: vi.fn().mockResolvedValue({
+            id: "ws_new",
+            slug: "new",
+            name: "New",
+            role: "admin",
+        }),
+        mintToken: vi.fn().mockResolvedValue({ token: "shp_mock", id: "tok_mock" }),
+        listTokens: vi.fn().mockResolvedValue({ tokens: [] }),
+        revokeToken: vi.fn().mockResolvedValue(undefined),
+        createInvite: vi.fn().mockResolvedValue({
+            code: "INV-MOCK",
+            expiresAt: null,
+            maxUses: 1,
+            useCount: 0,
+        }),
+        revokeInvite: vi.fn().mockResolvedValue(undefined),
+        redeemInvite: vi.fn().mockResolvedValue({
+            workspace: { id: "ws_joined", slug: "joined", name: "Joined", role: "member" },
+        }),
+        listMembers: vi.fn().mockResolvedValue({ members: [] }),
+        removeMember: vi.fn().mockResolvedValue(undefined),
+        leave: vi.fn().mockResolvedValue(undefined),
+        landscape: vi.fn().mockResolvedValue(EMPTY_LANDSCAPE),
+        announceTo: vi.fn().mockResolvedValue(EMPTY_ANNOUNCE),
+        // --- self-host singular aliases ----------------------------------------
+        getLandscape: vi.fn().mockResolvedValue(EMPTY_LANDSCAPE),
+        announce: vi.fn().mockResolvedValue(EMPTY_ANNOUNCE),
+    };
+    return Object.assign(base, overrides);
+}

package/dist/test/setup.d.ts ADDED Viewed

	@@ -0,0 +1 @@
1	+ import "@testing-library/jest-dom/vitest";

package/dist/test/setup.js ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ // Testing Library matchers (toBeInTheDocument, etc.) for the jsdom lane.
2	+ import "@testing-library/jest-dom/vitest";

package/dist/useLandscapePolling.d.ts ADDED Viewed

@@ -0,0 +1,63 @@
+import type { WorkspaceLandscapeResponseT } from "@shepherd/shared";
+/**
+ * Connection state surfaced to the board chrome:
+ * - `live`: the most recent poll succeeded.
+ * - `reconnecting`: a poll failed transiently; the last good snapshot is kept.
+ * - `unauthorized`: the hub returned 401; the last good snapshot is kept while
+ *   the host-supplied client's `onUnauthorized` handles any token clearing.
+ */
+export type LandscapeStatus = "live" | "reconnecting" | "unauthorized";
+/** Options for {@link useLandscapePolling}. */
+export interface UseLandscapePollingOptions {
+    /**
+     * Workspace to poll. When given, the hook calls `client.landscape(id)` (the
+     * hosted, multi-workspace route); when omitted it calls the singular
+     * `client.getLandscape()` self-host alias. Changing it re-pulls immediately.
+     */
+    workspaceId?: string;
+    /** Poll cadence in ms; defaults to {@link DEFAULT_POLL_MS} (5000). */
+    pollMs?: number;
+}
+/** The reactive value returned by {@link useLandscapePolling}. */
+export interface LandscapePolling {
+    /** Last good landscape, or `null` until the first successful poll. */
+    snapshot: WorkspaceLandscapeResponseT | null;
+    /** Current connection state. */
+    status: LandscapeStatus;
+    /** `Date.now()` of the last successful poll, or `null` before the first. */
+    lastUpdatedMs: number | null;
+    /** Run one poll immediately (used by the composer after a successful send). */
+    refresh: () => Promise<void>;
+}
+/**
+ * Polls the Shepherd hub's whole-workspace landscape on an interval and exposes
+ * the latest good snapshot plus a connection status, mirroring the browser-only
+ * polling loop in packages/hub/public/app.js (`poll` + `tickFreshness`).
+ *
+ * The client is read from {@link useShepherdClient} (context), keeping the hook
+ * auth-agnostic — it never touches tokens or the BFF. On mount it polls once
+ * immediately, then on `setInterval(pollMs)`. A SECOND `setInterval(1000)` only
+ * bumps a tick counter so relative-time text re-renders even between polls (the
+ * React analogue of app.js's `tickFreshness`); both intervals are cleared on
+ * unmount.
+ *
+ * Failure handling preserves the original board's resilience: a 401
+ * {@link ShepherdClientError} sets `unauthorized`, and ANY other error sets
+ * `reconnecting`. In both cases the last good `snapshot`/`lastUpdatedMs` are
+ * RETAINED (app.js's `lastSnapshot` retention), so the wallboard never blanks on
+ * a transient blip. The same last-good retention holds across a `workspaceId`
+ * switch — the prior board stays on screen until the new workspace's first poll
+ * lands, and an in-flight poll for the old workspace is dropped so it can't
+ * clobber the new one.
+ *
+ * Two refinements beyond the original loop: a `workspaceId` change re-pulls the
+ * new workspace immediately (the poll effect depends on it), and the interval
+ * poll is skipped while the tab is hidden (`document.visibilityState`), resuming
+ * with an immediate poll on `visibilitychange` back to visible — a backgrounded
+ * wallboard shouldn't hammer the hub.
+ *
+ * @param opts - Optional workspace to scope to and poll cadence override.
+ * @returns The current snapshot, status, last-updated timestamp, and a manual
+ *   {@link LandscapePolling.refresh}.
+ */
+export declare function useLandscapePolling(opts?: UseLandscapePollingOptions): LandscapePolling;

package/dist/useLandscapePolling.js ADDED Viewed

@@ -0,0 +1,129 @@
+import { useCallback, useEffect, useRef, useState } from "react";
+import { ShepherdClientError } from "./client.js";
+import { useShepherdClient } from "./context.js";
+/** Default poll cadence, mirroring `POLL_MS = 5000` in the original app.js. */
+const DEFAULT_POLL_MS = 5000;
+/** The freshness re-render cadence, mirroring app.js's 1s `tickFreshness` loop. */
+const FRESHNESS_MS = 1000;
+/**
+ * Polls the Shepherd hub's whole-workspace landscape on an interval and exposes
+ * the latest good snapshot plus a connection status, mirroring the browser-only
+ * polling loop in packages/hub/public/app.js (`poll` + `tickFreshness`).
+ *
+ * The client is read from {@link useShepherdClient} (context), keeping the hook
+ * auth-agnostic — it never touches tokens or the BFF. On mount it polls once
+ * immediately, then on `setInterval(pollMs)`. A SECOND `setInterval(1000)` only
+ * bumps a tick counter so relative-time text re-renders even between polls (the
+ * React analogue of app.js's `tickFreshness`); both intervals are cleared on
+ * unmount.
+ *
+ * Failure handling preserves the original board's resilience: a 401
+ * {@link ShepherdClientError} sets `unauthorized`, and ANY other error sets
+ * `reconnecting`. In both cases the last good `snapshot`/`lastUpdatedMs` are
+ * RETAINED (app.js's `lastSnapshot` retention), so the wallboard never blanks on
+ * a transient blip. The same last-good retention holds across a `workspaceId`
+ * switch — the prior board stays on screen until the new workspace's first poll
+ * lands, and an in-flight poll for the old workspace is dropped so it can't
+ * clobber the new one.
+ *
+ * Two refinements beyond the original loop: a `workspaceId` change re-pulls the
+ * new workspace immediately (the poll effect depends on it), and the interval
+ * poll is skipped while the tab is hidden (`document.visibilityState`), resuming
+ * with an immediate poll on `visibilitychange` back to visible — a backgrounded
+ * wallboard shouldn't hammer the hub.
+ *
+ * @param opts - Optional workspace to scope to and poll cadence override.
+ * @returns The current snapshot, status, last-updated timestamp, and a manual
+ *   {@link LandscapePolling.refresh}.
+ */
+export function useLandscapePolling(opts) {
+    const client = useShepherdClient();
+    const workspaceId = opts?.workspaceId;
+    const pollMs = opts?.pollMs ?? DEFAULT_POLL_MS;
+    const [snapshot, setSnapshot] = useState(null);
+    const [status, setStatus] = useState("live");
+    const [lastUpdatedMs, setLastUpdatedMs] = useState(null);
+    // A monotonically-bumped counter whose only job is to force a re-render every
+    // second so relative timestamps in the tree refresh between polls. The value
+    // itself is never read — the state change IS the freshness tick.
+    const [, setTick] = useState(0);
+    // The latest client lives in a ref so the stable `poll`/`refresh` callbacks
+    // always call through to the current provider value without re-subscribing.
+    const clientRef = useRef(client);
+    clientRef.current = client;
+    // Each poll effect run bumps this "generation". A poll captures the generation
+    // it started under and compares against the live ref before any setState, so a
+    // response that resolves after its effect was torn down — by unmount OR a
+    // `workspaceId` switch — is dropped and can't clobber a newer workspace's
+    // board. A single shared boolean can't do this: a switch runs old-cleanup then
+    // new-setup synchronously, so a boolean reset by setup would let the stale
+    // promise's late resolve sail through. The generation only ever moves forward,
+    // so a superseded poll's captured value is always behind `gen.current`.
+    const gen = useRef(0);
+    /**
+     * Runs exactly one poll, mapping the outcome onto status/snapshot. Reads
+     * `workspaceId` via closure (it's a `useCallback` dep): a non-empty id hits the
+     * workspace-scoped `landscape(id)` route, an absent one the singular
+     * `getLandscape()` alias. `myGen` is the caller's generation — the result is
+     * applied only while it's still the current one.
+     */
+    const poll = useCallback(async (myGen) => {
+        try {
+            const next = workspaceId
+                ? await clientRef.current.landscape(workspaceId)
+                : await clientRef.current.getLandscape();
+            if (myGen !== gen.current)
+                return;
+            setSnapshot(next);
+            setLastUpdatedMs(Date.now());
+            setStatus("live");
+        }
+        catch (err) {
+            if (myGen !== gen.current)
+                return;
+            // A 401 is terminal-ish: the client's onUnauthorized already ran. Keep
+            // the last good board up and flag it; everything else is a transient
+            // blip and also keeps the last good board ("reconnecting…" in app.js).
+            if (err instanceof ShepherdClientError && err.status === 401) {
+                setStatus("unauthorized");
+            }
+            else {
+                setStatus("reconnecting");
+            }
+        }
+    }, [workspaceId]);
+    // Poll once on mount, then on the cadence interval. Re-runs when `poll`
+    // changes (i.e. on a `workspaceId` switch), re-pulling the new workspace
+    // immediately. The interval tick is skipped while the tab is hidden, and a
+    // return to visibility polls right away to catch up. The 1s freshness interval
+    // is independent so a slow/failed poll never blocks the relative-time refresh.
+    useEffect(() => {
+        const myGen = ++gen.current;
+        void poll(myGen);
+        const pollTimer = setInterval(() => {
+            // A backgrounded wallboard doesn't need to poll; resume below on visible.
+            if (document.visibilityState === "hidden")
+                return;
+            void poll(myGen);
+        }, pollMs);
+        const freshnessTimer = setInterval(() => {
+            setTick((t) => t + 1);
+        }, FRESHNESS_MS);
+        const onVisible = () => {
+            if (document.visibilityState === "visible")
+                void poll(myGen);
+        };
+        document.addEventListener("visibilitychange", onVisible);
+        return () => {
+            // Bumping the generation invalidates any in-flight poll from this run.
+            gen.current++;
+            clearInterval(pollTimer);
+            clearInterval(freshnessTimer);
+            document.removeEventListener("visibilitychange", onVisible);
+        };
+    }, [poll, pollMs]);
+    // Manual refresh always runs under the current generation, so its result
+    // applies as long as the hook hasn't since switched workspace or unmounted.
+    const refresh = useCallback(() => poll(gen.current), [poll]);
+    return { snapshot, status, lastUpdatedMs, refresh };
+}

package/dist/views/Chat.d.ts ADDED Viewed

@@ -0,0 +1,5 @@
+export interface ChatProps {
+    /** The workspace whose chat to render. Selected by the shell. */
+    workspaceId: string;
+}
+export declare function Chat({ workspaceId }: ChatProps): import("react").JSX.Element;

package/dist/views/Chat.js ADDED Viewed

@@ -0,0 +1,60 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+// Chat view — the team chat ported from packages/hub/public (app.js): the
+// announcement feed (oldest→newest, top→bottom) plus a composer. Reads the feed
+// from client.landscape(workspaceId) (same 5s poll as Tasks, via useLandscape)
+// and posts through client.announce, then refreshes immediately. A typed
+// @mention matching a live agent directs the message as a DM, mirroring app.js's
+// send behavior; the autocomplete POPUP UI is intentionally not ported (visual
+// polish, deferred). Task 6.3 fixed the prop signature ({ workspaceId }).
+import { useMemo, useState } from "react";
+import { useShepherdClient } from "../ShepherdProvider.js";
+import { useLandscape } from "./useLandscape.js";
+import { describeError } from "../client.js";
+import { formatRelative, initialsFor, colorForName, extractTarget } from "./wallboard.js";
+/** One message row: avatar + sender + optional target + time + body. */
+function Message({ a, nowMs }) {
+    const cls = "msg" +
+        (a.targetAgentName || a.toAdmin ? " msg--targeted" : "") +
+        (a.fromAdmin ? " msg--me" : "");
+    return (_jsxs("div", { className: cls, children: [_jsx("div", { className: "msg__avatar", style: { background: colorForName(a.fromAgentName) }, children: initialsFor(a.fromAgentName) }), _jsxs("div", { className: "msg__body", children: [_jsxs("div", { className: "msg__head", children: [_jsx("span", { className: "msg__who", style: { color: colorForName(a.fromAgentName) }, children: a.fromAgentName }), a.fromHuman && _jsx("span", { className: "msg__human", children: a.fromHuman }), a.targetAgentName ? (_jsx("span", { className: "msg__to", children: `→ @${a.targetAgentName}` })) : a.toAdmin ? (_jsx("span", { className: "msg__to", children: "\u2192 admin" })) : null, _jsx("span", { className: "msg__time", children: formatRelative(a.createdAt, nowMs) })] }), _jsx("div", { className: "msg__text", children: a.body })] })] }));
+}
+export function Chat({ workspaceId }) {
+    const client = useShepherdClient();
+    const { data, error, loading, refresh } = useLandscape(workspaceId);
+    const [draft, setDraft] = useState("");
+    const [sending, setSending] = useState(false);
+    const [sendError, setSendError] = useState(null);
+    const nowMs = data ? Date.parse(data.serverTime) : Date.now();
+    // Memoised on `data` so they don't recompute on every composer keystroke
+    // (each `draft` change re-renders this component).
+    // The API returns newest-first; a chat reads oldest→newest, top→bottom.
+    const messages = useMemo(() => (data ? [...data.announcements].reverse() : []), [data]);
+    // Live agents are addressable by @mention (the canonical names extractTarget
+    // resolves against), matching app.js's mention pool.
+    const liveNames = useMemo(() => (data?.agents ?? [])
+        .filter((agent) => agent.presence === "live")
+        .map((agent) => agent.name), [data]);
+    async function send(e) {
+        e.preventDefault();
+        const body = draft.trim();
+        if (!body || sending)
+            return;
+        // The first @mention matching a live agent directs the message; otherwise it
+        // broadcasts (no repo scoping here — the repo selector was not ported).
+        const targetAgentName = extractTarget(body, liveNames);
+        setSending(true);
+        setSendError(null);
+        try {
+            await client.announce(workspaceId, { body, targetAgentName });
+            setDraft("");
+            await refresh(); // reflect the just-sent message without waiting for the tick
+        }
+        catch (err) {
+            setSendError(describeError(err));
+        }
+        finally {
+            setSending(false);
+        }
+    }
+    return (_jsxs("section", { "aria-labelledby": "chat-heading", children: [_jsx("h2", { id: "chat-heading", children: "Chat" }), error && (_jsx("p", { role: "alert", className: "status status--error", children: `Couldn't refresh the chat — reconnecting… (${error})` })), _jsxs("div", { className: "chat-wrap", children: [_jsx("div", { className: "chat", id: "chat", children: loading && !data ? (_jsx("div", { className: "empty", children: "Loading\u2026" })) : messages.length === 0 ? (_jsx("div", { className: "empty", children: "No announcements yet \u2014 agents will post here as they coordinate." })) : (messages.map((a) => (_jsx(Message, { a: a, nowMs: nowMs }, `${a.fromAgentName}|${a.createdAt}|${a.body}`)))) }), _jsxs("div", { className: "composer", children: [_jsxs("form", { className: "chat-form", onSubmit: send, children: [_jsx("input", { className: "chat-input", type: "text", autoComplete: "off", "aria-label": "Message the team", placeholder: "Message the team\u2026 use @name to direct it", value: draft, onChange: (e) => setDraft(e.target.value) }), _jsx("button", { className: "chat-send", type: "submit", disabled: sending || !draft.trim(), children: "Send" })] }), sendError && (_jsx("p", { role: "alert", className: "status status--error", children: sendError }))] })] })] }));
+}

package/dist/views/Chat.test.d.ts ADDED Viewed

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

package/dist/views/Chat.test.js ADDED Viewed

@@ -0,0 +1,92 @@
+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 { Chat } from "./Chat.js";
+import { makeMockClient } from "../test/mockClient.js";
+// ---------------------------------------------------------------------------
+// Chat — the ported team chat (announcement feed + composer). Reads the feed
+// from client.landscape(workspaceId), posts via client.announce. DB-free.
+// ---------------------------------------------------------------------------
+const WORKSPACE_ID = "ws_1";
+function landscape(over = {}) {
+    return {
+        serverTime: "2026-06-29T01:00:00.000Z",
+        agents: [],
+        tasks: [],
+        announcements: [],
+        ...over,
+    };
+}
+describe("Chat", () => {
+    let client;
+    beforeEach(() => {
+        client = makeMockClient();
+    });
+    function renderChat() {
+        return render(_jsx(ShepherdProvider, { client: client, children: _jsx(Chat, { workspaceId: WORKSPACE_ID }) }));
+    }
+    it("renders announcements from the landscape feed", async () => {
+        client.landscape = vi.fn().mockResolvedValue(landscape({
+            announcements: [
+                {
+                    fromAgentName: "RedDragon",
+                    fromHuman: "daichi",
+                    body: "shipping the parser fix",
+                    targetAgentName: null,
+                    repo: "acme/web",
+                    fromAdmin: false,
+                    toAdmin: false,
+                    createdAt: "2026-06-29T00:50:00.000Z",
+                },
+            ],
+        }));
+        renderChat();
+        await waitFor(() => expect(client.landscape).toHaveBeenCalledWith(WORKSPACE_ID));
+        await waitFor(() => expect(screen.getByText("shipping the parser fix")).toBeInTheDocument());
+        expect(screen.getByText("RedDragon")).toBeInTheDocument();
+    });
+    it("posts a composed message via announce, then refreshes the feed", async () => {
+        client.landscape = vi.fn().mockResolvedValue(landscape());
+        client.announce = vi.fn().mockResolvedValue({ ok: true, announcementIds: ["a_1"] });
+        renderChat();
+        await waitFor(() => expect(client.landscape).toHaveBeenCalledTimes(1));
+        await userEvent.type(screen.getByRole("textbox"), "hello team");
+        await userEvent.click(screen.getByRole("button", { name: /send/i }));
+        await waitFor(() => expect(client.announce).toHaveBeenCalledWith(WORKSPACE_ID, expect.objectContaining({ body: "hello team" })));
+        // Refresh after send: landscape re-fetched.
+        await waitFor(() => expect(client.landscape.mock.calls.length).toBeGreaterThan(1));
+    });
+    it("directs the message to the first @mention matching a live agent", async () => {
+        client.landscape = vi.fn().mockResolvedValue(landscape({
+            agents: [
+                {
+                    name: "RedDragon",
+                    human: "daichi",
+                    program: "claude",
+                    model: "opus",
+                    repo: "acme/web",
+                    branch: "main",
+                    lastHeartbeatAt: "2026-06-29T00:59:00.000Z",
+                    presence: "live",
+                },
+            ],
+        }));
+        client.announce = vi.fn().mockResolvedValue({ ok: true, announcementIds: ["a_1"] });
+        renderChat();
+        await waitFor(() => expect(client.landscape).toHaveBeenCalled());
+        await userEvent.type(screen.getByRole("textbox"), "@reddragon ping");
+        await userEvent.click(screen.getByRole("button", { name: /send/i }));
+        await waitFor(() => expect(client.announce).toHaveBeenCalledWith(WORKSPACE_ID, expect.objectContaining({ body: "@reddragon ping", targetAgentName: "RedDragon" })));
+    });
+    it("renders a non-crashing error state when landscape fails", async () => {
+        client.landscape = vi.fn().mockRejectedValue(new Error("boom"));
+        renderChat();
+        await waitFor(() => expect(screen.getByRole("alert")).toBeInTheDocument());
+        expect(screen.getByRole("heading", { name: /chat/i })).toBeInTheDocument();
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+});

package/dist/views/Config.d.ts ADDED Viewed

@@ -0,0 +1,12 @@
+import type { WorkspaceSummaryT } from "@shepherd/shared";
+export interface ConfigProps {
+    workspaces: WorkspaceSummaryT[];
+    selected: WorkspaceSummaryT | null;
+    /** The DIRECT Hub URL embedded in the agent install command (decision #2). */
+    hubUrl?: string;
+    /** Refetch the workspace list after a create/join. */
+    onChanged: () => void;
+    /** Switch the active workspace. */
+    onSelect?: (workspaceId: string) => void;
+}
+export declare function Config({ workspaces, selected, hubUrl, onChanged, onSelect }: ConfigProps): import("react").JSX.Element;

package/dist/views/Config.js ADDED Viewed

@@ -0,0 +1,6 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { ConnectAgent } from "../config/ConnectAgent.js";
+import { Workspaces } from "../config/Workspaces.js";
+export function Config({ workspaces, selected, hubUrl, onChanged, onSelect }) {
+    return (_jsxs("section", { "aria-labelledby": "config-heading", children: [_jsx("h2", { id: "config-heading", children: "Config" }), _jsx(Workspaces, { workspaces: workspaces, selected: selected, onChanged: onChanged, onSelect: onSelect }), selected && _jsx(ConnectAgent, { workspaceId: selected.id, hubUrl: hubUrl })] }));
+}

package/dist/views/Tasks.d.ts ADDED Viewed

@@ -0,0 +1,5 @@
+export interface TasksProps {
+    /** The workspace whose wallboard to render. Selected by the shell. */
+    workspaceId: string;
+}
+export declare function Tasks({ workspaceId }: TasksProps): import("react").JSX.Element;