mirror of
https://github.com/fabro-sh/fabro.git
synced 2026-11-17 09:31:45 +00:00
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>
139 lines
3.9 KiB
TypeScript
139 lines
3.9 KiB
TypeScript
import { describe, expect, test } from "bun:test";
|
|
import type { RunStreamItem } from "@qltysh/fabro-api-client";
|
|
|
|
import {
|
|
createCrossTabSseCoordinator,
|
|
type BroadcastChannelLike,
|
|
} from "./cross-tab-sse";
|
|
import { subscribeToLiveEvents } from "./live-events";
|
|
import { makePetriItem, makePlatformItem } from "./test-utils";
|
|
import type { EventSourceLike } from "./sse";
|
|
|
|
type MessageHandler = ((event: { data: string }) => void) | null;
|
|
|
|
class FakeEventSource {
|
|
onmessage: MessageHandler = null;
|
|
closed = false;
|
|
|
|
emit(payload: unknown) {
|
|
this.onmessage?.({ data: JSON.stringify(payload) });
|
|
}
|
|
|
|
close() {
|
|
this.closed = true;
|
|
}
|
|
}
|
|
|
|
class FakeBroadcastChannel implements BroadcastChannelLike {
|
|
onmessage: ((event: { data: unknown }) => void) | null = null;
|
|
|
|
postMessage() {}
|
|
|
|
close() {}
|
|
}
|
|
|
|
describe("subscribeToLiveEvents", () => {
|
|
test("coordinated mode opens /api/v1/attach and forwards every payload", async () => {
|
|
const source = new FakeEventSource();
|
|
const created: string[] = [];
|
|
const seen: RunStreamItem[] = [];
|
|
const coordinator = createCoordinator((url) => {
|
|
created.push(url);
|
|
return source;
|
|
});
|
|
|
|
const cleanup = subscribeToLiveEvents(
|
|
(payload) => seen.push(payload),
|
|
() => {
|
|
throw new Error("source should be created by coordinator");
|
|
},
|
|
{ coordinator },
|
|
);
|
|
|
|
await waitFor(() => created.length === 1);
|
|
|
|
source.emit(makePetriItem(1, { event: "step.started", firing: 1 }, { run_id: "run-a" }));
|
|
source.emit(makePlatformItem(1, { kind: "checkpoint" }, { run_id: "run-b" }));
|
|
// A frame that is not a stream item is dropped.
|
|
source.emit({ event: "stage.started", run_id: "run-c" });
|
|
|
|
expect(created).toEqual(["/api/v1/attach"]);
|
|
expect(seen.map((p) => p.run_id)).toEqual(["run-a", "run-b"]);
|
|
|
|
cleanup();
|
|
coordinator.close();
|
|
});
|
|
|
|
test("fallback mode opens /api/v1/attach (not a per-run URL) and forwards payloads", () => {
|
|
const source = new FakeEventSource();
|
|
const created: string[] = [];
|
|
const seen: RunStreamItem[] = [];
|
|
const coordinator = createFallbackCoordinator();
|
|
|
|
const cleanup = subscribeToLiveEvents(
|
|
(payload) => seen.push(payload),
|
|
(url) => {
|
|
created.push(url);
|
|
return source;
|
|
},
|
|
{ coordinator },
|
|
);
|
|
|
|
source.emit(
|
|
makePlatformItem(9, { kind: "run.lifecycle", transition: "succeeded" }, { run_id: "run-a" }),
|
|
);
|
|
source.emit(
|
|
makePlatformItem(9, { kind: "run.lifecycle", transition: "failed" }, { run_id: "run-b" }),
|
|
);
|
|
|
|
expect(created).toEqual(["/api/v1/attach"]);
|
|
expect(seen.map((p) => p.run_id)).toEqual(["run-a", "run-b"]);
|
|
|
|
cleanup();
|
|
coordinator.close();
|
|
});
|
|
|
|
test("fallback closes the shared source on the final unsubscribe", () => {
|
|
const source = new FakeEventSource();
|
|
const coordinator = createFallbackCoordinator();
|
|
const cleanup = subscribeToLiveEvents(() => {}, () => source, { coordinator });
|
|
|
|
expect(source.closed).toBe(false);
|
|
cleanup();
|
|
expect(source.closed).toBe(true);
|
|
|
|
coordinator.close();
|
|
});
|
|
});
|
|
|
|
function createCoordinator(eventSourceFactory: (url: string) => EventSourceLike) {
|
|
return createCrossTabSseCoordinator({
|
|
tabId: "live-events-test",
|
|
channelFactory: () => new FakeBroadcastChannel(),
|
|
eventSourceFactory,
|
|
addVisibilityChangeListener: () => () => {},
|
|
addPagehideListener: () => () => {},
|
|
timing: {
|
|
heartbeatMs: 10,
|
|
leaderStaleMs: 50,
|
|
electionJitterMs: 0,
|
|
},
|
|
});
|
|
}
|
|
|
|
function createFallbackCoordinator() {
|
|
return createCrossTabSseCoordinator({
|
|
channelFactory: () => {
|
|
throw new Error("BroadcastChannel unavailable");
|
|
},
|
|
});
|
|
}
|
|
|
|
async function waitFor(condition: () => boolean, timeoutMs = 200) {
|
|
const deadline = Date.now() + timeoutMs;
|
|
while (Date.now() < deadline) {
|
|
if (condition()) return;
|
|
await new Promise((resolve) => setTimeout(resolve, 2));
|
|
}
|
|
throw new Error("condition did not become true before timeout");
|
|
}
|