@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, 04:45 UTC

main
ts 130 lines 4.88 KB
Raw
1 /**
2 * Node.js runtime support for workers that serve Effect worker requests.
3 *
4 * `NodeWorkerRunner` supplies the Node implementation of the Effect worker
5 * runner platform. The exported `layer` runs inside a `node:worker_threads`
6 * worker through `parentPort`, or inside a child process through
7 * `process.send`. It listens for parent messages, runs handlers registered with
8 * `WorkerRunner`, sends replies over the same channel, and closes when the
9 * parent sends the close message.
10 *
11 * @stability unstable
12 * @since 4.0.0
13 */
14 import * as Cause from "effect/Cause"
15 import * as Deferred from "effect/Deferred"
16 import * as Effect from "effect/Effect"
17 import * as Exit from "effect/Exit"
18 import * as Fiber from "effect/Fiber"
19 import * as Layer from "effect/Layer"
20 import * as Scope from "effect/Scope"
21 import { WorkerError, WorkerReceiveError, WorkerSpawnError } from "effect/workers/WorkerError"
22 import * as WorkerRunner from "effect/workers/WorkerRunner"
23 import * as WorkerThreads from "node:worker_threads"
24
25 /**
26 * Provides the `WorkerRunnerPlatform` for code running inside a Node worker
27 * thread or child process, routing parent messages to the registered handler
28 * and sending responses back through the parent channel.
29 *
30 * @stability unstable
31 * @category layers
32 * @since 4.0.0
33 */
34 export const layer: Layer.Layer<WorkerRunner.WorkerRunnerPlatform> = Layer.succeed(WorkerRunner.WorkerRunnerPlatform)({
35 start<O = unknown, I = unknown>() {
36 return Effect.gen(function*() {
37 if (!WorkerThreads.parentPort && !process.send) {
38 return yield* new WorkerError({
39 reason: new WorkerSpawnError({ message: "not in a worker" })
40 })
41 }
42
43 const sendRaw = WorkerThreads.parentPort
44 ? (_portId: number, message: any, transfers?: any) => WorkerThreads.parentPort!.postMessage(message, transfers)
45 : (_portId: number, message: any, _transfers?: any) => process.send!(message)
46 const sendUnsafe = (_portId: number, message: O, transfers?: ReadonlyArray<unknown>) =>
47 sendRaw(_portId, [1, message], transfers)
48 const send = (_portId: number, message: O, transfers?: ReadonlyArray<unknown>) =>
49 Effect.sync(() => sendUnsafe(_portId, message, transfers))
50
51 const run = <A, E, R>(
52 handler: (portId: number, message: I) => Effect.Effect<A, E, R> | void
53 ): Effect.Effect<void, WorkerError, R> =>
54 Effect.scopedWith(Effect.fnUntraced(function*(scope) {
55 const closeLatch = Deferred.makeUnsafe<void, WorkerError>()
56 const trackFiber = Fiber.runIn(scope)
57 const services = yield* Effect.context<R>()
58 const runFork = Effect.runForkWith(services)
59 const onExit = (exit: Exit.Exit<any, E>) => {
60 if (exit._tag === "Failure" && !Cause.hasInterruptsOnly(exit.cause)) {
61 runFork(Effect.logError("unhandled error in worker", exit.cause))
62 }
63 }
64 const port = WorkerThreads.parentPort ?? process
65 function onMessage(message: WorkerRunner.PlatformMessage<I>) {
66 if (message[0] === 0) {
67 const result = handler(0, message[1])
68 if (Effect.isEffect(result)) {
69 const fiber = runFork(result)
70 fiber.addObserver(onExit)
71 trackFiber(fiber)
72 }
73 } else {
74 if (WorkerThreads.parentPort) {
75 WorkerThreads.parentPort.close()
76 } else {
77 process.channel?.unref()
78 }
79 Deferred.doneUnsafe(closeLatch, Exit.void)
80 }
81 }
82 port.on("message", onMessage)
83
84 function onMessageError(cause: unknown) {
85 Deferred.doneUnsafe(
86 closeLatch,
87 new WorkerError({
88 reason: new WorkerReceiveError({
89 message: "received messageerror event",
90 cause
91 })
92 })
93 )
94 }
95 function onError(cause: unknown) {
96 Deferred.doneUnsafe(
97 closeLatch,
98 new WorkerError({
99 reason: new WorkerReceiveError({
100 message: "received error event",
101 cause
102 })
103 })
104 )
105 }
106 if (WorkerThreads.parentPort) {
107 WorkerThreads.parentPort.on("messageerror", onMessageError)
108 WorkerThreads.parentPort.on("error", onError)
109 }
110
111 yield* Scope.addFinalizer(
112 scope,
113 Effect.sync(() => {
114 port.off("message", onMessage)
115 if (WorkerThreads.parentPort) {
116 WorkerThreads.parentPort.off("messageerror", onMessageError)
117 WorkerThreads.parentPort.off("error", onError)
118 }
119 })
120 )
121
122 sendRaw(0, [0])
123
124 return yield* Deferred.await(closeLatch)
125 }))
126
127 return { run, send, sendUnsafe }
128 })
129 }
130 })