agent-tempo 1.0.1

package/dist/tui/sse-handler.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toMaestroPlayerInfo = toMaestroPlayerInfo;
+exports.handleSseEvent = handleSseEvent;
+const store_1 = require("./store");
+/**
+ * Project a wire `PlayerSummaryV1` into the in-memory `MaestroPlayerInfo`
+ * shape. The wire type carries two extra ISO timestamps
+ * (`lastHeartbeatAt`, `processingSince`) the TUI doesn't render today;
+ * dropping them avoids a type cast at the call site.
+ */
+function toMaestroPlayerInfo(p) {
+    return {
+        playerId: p.playerId,
+        ensemble: p.ensemble,
+        hostname: p.hostname,
+        isConductor: p.isConductor,
+        agentType: p.agentType,
+        ...(p.playerType !== undefined ? { playerType: p.playerType } : {}),
+        ...(p.phase !== undefined ? { phase: p.phase } : {}),
+        part: p.part,
+        workDir: p.workDir,
+        ...(p.gitBranch !== undefined ? { gitBranch: p.gitBranch } : {}),
+    };
+}
+/**
+ * Apply one SSE event to the TUI store. Returns a Promise so callers can
+ * `await` the gap / chat.compressed re-fetches; for purely-synchronous
+ * events (every other kind) the returned promise is already resolved.
+ */
+async function handleSseEvent(event, dispatch, ensemble, api) {
+    switch (event.type) {
+        case 'snapshot': {
+            const snap = event.payload;
+            const players = snap.players.map(toMaestroPlayerInfo);
+            dispatch({
+                type: 'REFRESH_ENSEMBLE_DATA',
+                players,
+                messages: [],
+                history: [],
+                schedules: snap.schedules,
+            });
+            dispatch({
+                type: 'SET_ENSEMBLE_CHAT',
+                chat: {
+                    messages: snap.chat.messages,
+                    total: snap.chat.total,
+                    hasMore: snap.chat.hasMore,
+                    hasConductor: snap.hasConductor,
+                },
+            });
+            dispatch({ type: 'SET_ENSEMBLE_PAUSED', paused: snap.flags.paused });
+            dispatch({ type: 'SET_ENSEMBLE_HELD', held: snap.flags.held });
+            // #358: dropped the SET_CONDUCTOR dispatch — the conductor's playerId
+            // is now derived from the `players` array at render time. The snapshot
+            // already populates `players` via REFRESH_ENSEMBLE_DATA above, so the
+            // derived view picks it up without a dedicated action.
+            dispatch({
+                type: 'SET_CONVERSATION',
+                conversation: snap.chat.messages.map(store_1.toConversationEntry),
+            });
+            return;
+        }
+        case 'player.added':
+            // Carries a full `PlayerSummaryV1` — project to the in-memory
+            // shape and let the reducer merge by `playerId`.
+            dispatch({ type: 'UPSERT_PLAYER', player: toMaestroPlayerInfo(event.payload) });
+            return;
+        case 'player.phase_changed':
+            // The wire payload here is sparse — `{ playerId, ensemble, phase,
+            // … timestamps }` per `src/http/event-types.ts`. Earlier this case
+            // fell through to the same projection as `player.added`, which
+            // synthesised empty `hostname` / `part` / `isConductor` defaults
+            // and clobbered the snapshot-cached values via the reducer's
+            // spread merge. Patching only `phase` keeps the rest intact. #351.
+            dispatch({
+                type: 'PATCH_PLAYER_PHASE',
+                playerId: event.payload.playerId,
+                phase: event.payload.phase,
+            });
+            return;
+        case 'player.removed':
+            dispatch({ type: 'REMOVE_PLAYER', playerId: event.payload.playerId });
+            return;
+        case 'chat.appended':
+            dispatch({ type: 'APPEND_CHAT_MESSAGE', message: event.payload });
+            return;
+        case 'flags.changed':
+            dispatch({ type: 'SET_ENSEMBLE_PAUSED', paused: event.payload.paused });
+            dispatch({ type: 'SET_ENSEMBLE_HELD', held: event.payload.held });
+            return;
+        case 'schedules.changed':
+            dispatch({ type: 'SET_SCHEDULES', schedules: event.payload.schedules });
+            return;
+        case 'gap': {
+            // Hard gap (epoch-mismatch or overflow). Spec §7.2 says re-fetch
+            // `/v1/state/:ensemble` and resume — we don't have a direct HTTP
+            // hook for that here, so we fan out the same Temporal queries the
+            // snapshot endpoint projects (matches the legacy poll's set). The
+            // fetch wrapper continues yielding events after the gap; we just
+            // don't want the consumer to render stale state until the next
+            // event arrives.
+            try {
+                const [players, chat, schedules, paused, held] = await Promise.all([
+                    api.getPlayers(ensemble),
+                    api.getEnsembleChat(ensemble, 0, 50),
+                    api.getSchedules(ensemble),
+                    api.isMaestroPaused(ensemble),
+                    api.isAnySessionHeld(ensemble),
+                ]);
+                dispatch({
+                    type: 'REFRESH_ENSEMBLE_DATA',
+                    players,
+                    messages: [],
+                    history: [],
+                    schedules,
+                });
+                dispatch({ type: 'SET_ENSEMBLE_CHAT', chat });
+                dispatch({ type: 'SET_ENSEMBLE_PAUSED', paused });
+                dispatch({ type: 'SET_ENSEMBLE_HELD', held });
+                dispatch({
+                    type: 'SET_CONVERSATION',
+                    conversation: chat.messages.map(store_1.toConversationEntry),
+                });
+            }
+            catch (err) {
+                console.error('[tui:sse] gap recovery failed:', err);
+            }
+            return;
+        }
+        case 'chat.compressed': {
+            // Soft gap scoped to chat (§7.6) — re-fetch the chat slice only.
+            try {
+                const chat = await api.getEnsembleChat(ensemble, 0, 50);
+                dispatch({ type: 'SET_ENSEMBLE_CHAT', chat });
+                dispatch({
+                    type: 'SET_CONVERSATION',
+                    conversation: chat.messages.map(store_1.toConversationEntry),
+                });
+            }
+            catch (err) {
+                console.error('[tui:sse] chat.compressed recovery failed:', err);
+            }
+            return;
+        }
+        // Per-ensemble view doesn't render these — global stream events
+        // (`ensemble.created`, `ensemble.destroyed`, `host_profile.changed`)
+        // are consumed by the home view's separate refresh path; heartbeat
+        // is connection-local; throttled is informational.
+        case 'heartbeat':
+        case 'throttled':
+        case 'ensemble.created':
+        case 'ensemble.destroyed':
+        case 'host_profile.changed':
+            return;
+    }
+}