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

main
ts 204 lines 7.06 KB
Raw
1 /**
2 * Runner-side browser platform for Effect worker handlers.
3 *
4 * `make` builds a `WorkerRunnerPlatform` over a `MessagePort` or `Window`.
5 * `layer` provides the platform from the global worker `self`, and
6 * `layerMessagePort` provides it from an explicit endpoint. The platform
7 * receives parent or client messages, runs Effect handlers, and posts responses
8 * back through the browser messaging channel.
9 *
10 * @stability unstable
11 * @since 4.0.0
12 */
13 import * as Cause from "effect/Cause"
14 import * as Deferred from "effect/Deferred"
15 import * as Effect from "effect/Effect"
16 import * as Exit from "effect/Exit"
17 import * as Fiber from "effect/Fiber"
18 import { identity } from "effect/Function"
19 import * as Layer from "effect/Layer"
20 import * as Queue from "effect/Queue"
21 import * as Scope from "effect/Scope"
22 import { WorkerError, WorkerReceiveError } from "effect/workers/WorkerError"
23 import * as WorkerRunner from "effect/workers/WorkerRunner"
24
25 const cachedPorts = new Set<MessagePort>()
26 function globalHandleConnect(event: MessageEvent) {
27 cachedPorts.add((event as MessageEvent).ports[0])
28 }
29 if (typeof self !== "undefined" && "onconnect" in self) {
30 self.onconnect = globalHandleConnect
31 }
32
33 /**
34 * Creates a `WorkerRunnerPlatform` service that runs worker handlers over a `MessagePort` or `Window`.
35 *
36 * @stability unstable
37 * @category constructors
38 * @since 4.0.0
39 */
40 export const make = (self: MessagePort | Window): WorkerRunner.WorkerRunnerPlatform["Service"] => ({
41 start: Effect.fnUntraced(function*<O = unknown, I = unknown>() {
42 const disconnects = yield* Queue.make<number>()
43 let currentPortId = 0
44
45 const ports = new Map<number, readonly [MessagePort, Scope.Closeable]>()
46 const sendUnsafe = (portId: number, message: O, transfer?: ReadonlyArray<unknown>) =>
47 (ports.get(portId)?.[0] ?? self).postMessage([1, message], {
48 transfer: transfer as any
49 })
50 const send = (portId: number, message: O, transfer?: ReadonlyArray<unknown>) =>
51 Effect.sync(() => sendUnsafe(portId, message, transfer))
52
53 const run = <A, E, R>(
54 handler: (portId: number, message: I) => Effect.Effect<A, E, R> | void
55 ) =>
56 Effect.scopedWith(Effect.fnUntraced(function*(scope) {
57 const closeLatch = Deferred.makeUnsafe<void, WorkerError>()
58 const trackFiber = Fiber.runIn(scope)
59 const services = yield* Effect.context<R>()
60 const runFork = Effect.runForkWith(services)
61 const onExit = (exit: Exit.Exit<any, E>) => {
62 if (exit._tag === "Failure" && !Cause.hasInterruptsOnly(exit.cause)) {
63 runFork(Effect.logError("unhandled error in worker", exit.cause))
64 }
65 }
66
67 function onMessage(portId: number) {
68 return function(event: MessageEvent) {
69 const message = event.data as WorkerRunner.PlatformMessage<I>
70 if (message[0] === 0) {
71 const result = handler(portId, message[1])
72 if (Effect.isEffect(result)) {
73 const fiber = runFork(result)
74 fiber.addObserver(onExit)
75 trackFiber(fiber)
76 }
77 } else {
78 const port = ports.get(portId)
79 if (!port) {
80 return
81 } else if (ports.size === 1) {
82 // let the last port close with the outer scope
83 return Deferred.doneUnsafe(closeLatch, Exit.void)
84 }
85 ports.delete(portId)
86 Queue.offerUnsafe(disconnects, portId)
87 Effect.runFork(Scope.close(port[1], Exit.void))
88 }
89 }
90 }
91 function onMessageError(error: MessageEvent) {
92 Deferred.doneUnsafe(
93 closeLatch,
94 new WorkerError({
95 reason: new WorkerReceiveError({
96 message: "A messageerror event was emitted",
97 cause: error.data
98 })
99 })
100 )
101 }
102 function onError(error: any) {
103 Deferred.doneUnsafe(
104 closeLatch,
105 new WorkerError({
106 reason: new WorkerReceiveError({
107 message: "An error event was emitted",
108 cause: error.error
109 })
110 })
111 )
112 }
113 function handlePort(port: MessagePort) {
114 const portScope = Scope.forkUnsafe(scope)
115 const portId = currentPortId++
116 ports.set(portId, [port, portScope])
117 const onMsg = onMessage(portId)
118 port.addEventListener("message", onMsg)
119 port.addEventListener("messageerror", onMessageError)
120 if ("start" in port) {
121 port.start()
122 }
123 port.postMessage([0])
124 Effect.runSync(Scope.addFinalizer(
125 portScope,
126 Effect.sync(() => {
127 port.removeEventListener("message", onMsg)
128 port.removeEventListener("messageerror", onMessageError)
129 port.close()
130 })
131 ))
132 }
133 self.addEventListener("error", onError)
134 let prevOnConnect: unknown | undefined
135 if ("onconnect" in self) {
136 prevOnConnect = self.onconnect
137 self.onconnect = function(event: MessageEvent) {
138 const port = (event as MessageEvent).ports[0]
139 handlePort(port)
140 }
141 for (const port of cachedPorts) {
142 handlePort(port)
143 }
144 cachedPorts.clear()
145 } else {
146 handlePort(self as any)
147 }
148 yield* Scope.addFinalizer(
149 scope,
150 Effect.sync(() => {
151 self.removeEventListener("error", onError)
152 if ("onconnect" in self) {
153 self.close()
154 self.onconnect = prevOnConnect
155 }
156 })
157 )
158
159 yield* Deferred.await(closeLatch)
160 }))
161
162 return identity<WorkerRunner.WorkerRunner<O, I>>({ run, send, sendUnsafe, disconnects })
163 }) as any
164 })
165
166 /**
167 * Layer that provides a browser `WorkerRunnerPlatform` using the global `self` worker context.
168 *
169 * **When to use**
170 *
171 * Use when you need a browser worker entry point to use the ambient `self`
172 * object as the worker transport.
173 *
174 * **Details**
175 *
176 * Delegates to `make(self)` and provides the runner-side platform used by
177 * protocols such as `RpcServer.layerProtocolWorkerRunner`.
178 *
179 * **Gotchas**
180 *
181 * This layer depends on the browser worker global `self`. Use
182 * `layerMessagePort` when the transport is an explicit `MessagePort` or
183 * `Window`.
184 *
185 * @see {@link make} for constructing a runner platform from an explicit endpoint
186 * @see {@link layerMessagePort} for providing a platform from an explicit endpoint
187 *
188 * @stability unstable
189 * @category layers
190 * @since 4.0.0
191 */
192 export const layer: Layer.Layer<WorkerRunner.WorkerRunnerPlatform> = Layer.sync(WorkerRunner.WorkerRunnerPlatform)(() =>
193 make(self)
194 )
195
196 /**
197 * Layer that provides a `WorkerRunnerPlatform` using the supplied `MessagePort` or `Window`.
198 *
199 * @stability unstable
200 * @category layers
201 * @since 4.0.0
202 */
203 export const layerMessagePort = (port: MessagePort | Window): Layer.Layer<WorkerRunner.WorkerRunnerPlatform> =>
204 Layer.succeed(WorkerRunner.WorkerRunnerPlatform)(make(port))