@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, 06:00 UTC

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