mirror of
https://github.com/fabro-sh/fabro.git
synced 2026-10-29 06:36:51 +00:00
bc31b8d23a
Step 4 of the legacy executor deletion, third commit: the legacy event
API and every reader of it go, so that the next commits can delete the
event log, its reducer and the types beneath them.
The API:
- `GET /runs/{id}/events` pages the run stream only
(`PaginatedRunStreamList` by `after`); the legacy `since_seq`,
`before_seq` and `order` cursors, the `oneOf` envelope, the legacy
`EventEnvelope`, `PaginatedEventList`, `RunEvent`, `EventSeq`,
`AppendEventResponse` and `RunEventDetailResponse` schemas,
`POST /runs/{id}/events`, `GET /runs/{id}/events/{seq}` and
`GET /runs/{id}/stages/{stageId}/events` are deleted. `GET
/runs/{id}/attach` and `GET /attach` frame `RunStreamItem`s only.
- The Rust and TypeScript clients regenerate; the removed models leave
the TypeScript package.
The readers:
- `fabro-client` drops the legacy run event listing, tail and attach
methods and `RunEventStream`; `list_run_stream_until` bounds a stream
read.
- `fabro-tool`'s `fabro_run_events` lists, searches and details the run
stream: `after` is the exclusive `stream_seq` cursor, `event_id` the
item's id, filters match the item's name and `recorded_at`.
- `fabro-dump` writes the stream to `events.jsonl`; `fabro dump` reads
it.
- The CLI's progress renderer keeps only what the run stream drives:
the legacy event conversion, the sandbox and setup displays and their
styles go. `fabro system events` prints stream items.
- The server's demo mode folds its agent fixture straight into the
session projection and answers the attach stub with a stream item;
the demo stage events endpoint is gone.
- The web app: every run is a Petri run. The legacy event hooks,
renderer props, stage popover summary, run phases derivation and
live-event payload handling are deleted or ported to `RunStreamItem`;
toasts and board refreshes read the stream's platform records.
- Tests: the legacy API round trips and pagination tests are deleted;
the CLI's MCP, attach and system event mocks serve stream pages; the
CLI test helpers read stream items.
Still failing until the later commits: the CLI tests seeded through
`POST /runs/{id}/events`, the server tests over the legacy store, and
the legacy type tests.
Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
105 lines
2.9 KiB
TypeScript
105 lines
2.9 KiB
TypeScript
import { useEffect } from "react";
|
|
import { useSWRConfig } from "swr";
|
|
|
|
import {
|
|
subscribeToCrossTabSse,
|
|
type CrossTabSseCoordinator,
|
|
} from "./cross-tab-sse";
|
|
import { runListCacheMatchers } from "./board-cache";
|
|
import { isStreamItemPayload, streamItemName } from "./petri-stream";
|
|
import { queryKeys } from "./query-keys";
|
|
import {
|
|
createBrowserEventSource,
|
|
subscribeToSharedEventSource,
|
|
type EventPayload,
|
|
type EventSourceLike,
|
|
type MutateFn,
|
|
type SharedEventSubscription,
|
|
} from "./sse";
|
|
|
|
interface BoardEventOptions {
|
|
debounceMs?: number;
|
|
coordinator?: CrossTabSseCoordinator;
|
|
}
|
|
|
|
// The stream items that change what the board shows of a run: its status
|
|
// (Fabro's `run.lifecycle` records before and after Petri runs it, Petri's
|
|
// own run events while it does), its title, its archive state, its parent,
|
|
// its pull request, and the questions that block it (`wait.state.changed`
|
|
// turns the status to blocked, `control.requested` delivers the answer).
|
|
// Named as `streamItemName` names them: a platform record by its `kind`, a
|
|
// Petri event by its `<subject>.<verb>`.
|
|
const BOARD_STATUS_EVENTS = new Set([
|
|
"run.created",
|
|
"run.lifecycle",
|
|
"run.title",
|
|
"run.parent",
|
|
"run.archived",
|
|
"run.unarchived",
|
|
"run.superseded",
|
|
"pull_request.created",
|
|
"interview.answered",
|
|
"run.started",
|
|
"run.finished",
|
|
"run.paused",
|
|
"run.unpaused",
|
|
"run.stalled",
|
|
"invocation.cancel.requested",
|
|
"wait.state.changed",
|
|
"control.requested",
|
|
]);
|
|
|
|
const subscriptions = new Map<string, SharedEventSubscription>();
|
|
const BOARD_SUBSCRIPTION_KEY = "board";
|
|
|
|
export function shouldRefreshBoardForEvent(event: string) {
|
|
return BOARD_STATUS_EVENTS.has(event);
|
|
}
|
|
|
|
export function subscribeToBoardEvents(
|
|
mutate: MutateFn,
|
|
eventSourceFactory: (url: string) => EventSourceLike = createBrowserEventSource,
|
|
{ debounceMs = 500, coordinator }: BoardEventOptions = {},
|
|
): () => void {
|
|
return subscribeToCrossTabSse<EventPayload>({
|
|
coordinator,
|
|
subscriptionKey: BOARD_SUBSCRIPTION_KEY,
|
|
mutate,
|
|
debounceMs,
|
|
resyncKeys: () => boardRunKeys(),
|
|
resolveInvalidation: boardInvalidation,
|
|
fallbackSubscribe: () =>
|
|
subscribeToSharedEventSource<EventPayload>({
|
|
subscriptions,
|
|
subscriptionKey: BOARD_SUBSCRIPTION_KEY,
|
|
url: queryKeys.system.attachUrl(),
|
|
mutate,
|
|
eventSourceFactory,
|
|
debounceMs,
|
|
resolveInvalidation: boardInvalidation,
|
|
}),
|
|
});
|
|
}
|
|
|
|
function boardInvalidation(payload: EventPayload) {
|
|
return {
|
|
keys:
|
|
isStreamItemPayload(payload) && shouldRefreshBoardForEvent(streamItemName(payload))
|
|
? boardRunKeys()
|
|
: [],
|
|
};
|
|
}
|
|
|
|
function boardRunKeys() {
|
|
return runListCacheMatchers();
|
|
}
|
|
|
|
/**
|
|
* Synchronizes React/SWR with the shared board SSE stream. The subscription is
|
|
* closed before resubscribe and on unmount.
|
|
*/
|
|
export function useBoardEvents() {
|
|
const { mutate } = useSWRConfig();
|
|
|
|
useEffect(() => subscribeToBoardEvents(mutate as MutateFn), [mutate]);
|
|
}
|