@devries-cameron20 / t3code Mirror · read-only
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 03:37 UTC

main
ts 66 lines 2.34 KB
Raw
1 import type { ServerLifecycleStreamEvent } from "@t3tools/contracts";
2 import * as Context from "effect/Context";
3 import * as Deferred from "effect/Deferred";
4 import * as Effect from "effect/Effect";
5 import * as Layer from "effect/Layer";
6 import * as PubSub from "effect/PubSub";
7 import * as Ref from "effect/Ref";
8 import * as Stream from "effect/Stream";
9
10 type LifecycleEventInput =
11 | Omit<Extract<ServerLifecycleStreamEvent, { type: "welcome" }>, "sequence">
12 | Omit<Extract<ServerLifecycleStreamEvent, { type: "ready" }>, "sequence">
13 | Omit<Extract<ServerLifecycleStreamEvent, { type: "legacyThreadMigration" }>, "sequence">;
14
15 interface SnapshotState {
16 readonly sequence: number;
17 readonly events: ReadonlyArray<ServerLifecycleStreamEvent>;
18 }
19
20 export class ServerLifecycleEvents extends Context.Service<
21 ServerLifecycleEvents,
22 {
23 readonly publish: (event: LifecycleEventInput) => Effect.Effect<ServerLifecycleStreamEvent>;
24 readonly snapshot: Effect.Effect<SnapshotState>;
25 readonly stream: Stream.Stream<ServerLifecycleStreamEvent>;
26 /** Completes once the first ready event is published. */
27 readonly awaitReady: Effect.Effect<void>;
28 }
29 >()("t3/serverLifecycleEvents") {}
30
31 const make = Effect.gen(function* () {
32 const pubsub = yield* PubSub.unbounded<ServerLifecycleStreamEvent>();
33 const ready = yield* Deferred.make<void>();
34 const state = yield* Ref.make<SnapshotState>({
35 sequence: 0,
36 events: [],
37 });
38
39 return {
40 publish: (event) =>
41 Ref.modify(state, (current) => {
42 const nextSequence = current.sequence + 1;
43 const nextEvent = {
44 ...event,
45 sequence: nextSequence,
46 } satisfies ServerLifecycleStreamEvent;
47 const nextEvents = [
48 nextEvent,
49 ...current.events.filter((entry) => entry.type !== nextEvent.type),
50 ];
51 return [nextEvent, { sequence: nextSequence, events: nextEvents }] as const;
52 }).pipe(
53 Effect.tap((event) => PubSub.publish(pubsub, event)),
54 Effect.tap((event) =>
55 event.type === "ready" ? Deferred.succeed(ready, undefined) : Effect.void,
56 ),
57 ),
58 snapshot: Ref.get(state),
59 awaitReady: Deferred.await(ready),
60 get stream() {
61 return Stream.fromPubSub(pubsub);
62 },
63 } satisfies ServerLifecycleEvents["Service"];
64 });
65
66 export const layer = Layer.effect(ServerLifecycleEvents, make);