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

main
ts 214 lines 7.33 KB
Raw
1 import { DenoClusterSocket, DenoSocketServer } from "@effect/platform-deno"
2 import { assert, describe, it } from "@effect/vitest"
3 import { BigDecimal, Cause, Deferred, Effect, Exit, Fiber, Layer, Option, PrimaryKey, Schema } from "effect"
4 import type { Sharding } from "effect/cluster"
5 import {
6 ClusterSchema,
7 Entity,
8 MessageStorage,
9 RunnerAddress,
10 RunnerHealth,
11 RunnerStorage,
12 ShardingConfig,
13 SocketRunner
14 } from "effect/cluster"
15 import { Rpc, RpcSerialization } from "effect/rpc"
16 import * as SocketServer from "effect/socket/SocketServer"
17
18 class TestPayload extends Schema.Class<TestPayload>("TestPayload")({
19 id: Schema.String,
20 amount: Schema.BigDecimal
21 }) {
22 [PrimaryKey.symbol]() {
23 return this.id
24 }
25 }
26
27 const TestEntity = Entity
28 .make("TestEntity", [
29 Rpc.make("Process", {
30 payload: TestPayload,
31 success: Schema.Void
32 }).annotate(ClusterSchema.Persisted, true),
33 Rpc.make("ProcessVolatile", {
34 payload: TestPayload,
35 success: Schema.Void
36 }).annotate(ClusterSchema.Persisted, false)
37 ])
38 .annotateRpcs(ClusterSchema.Uninterruptible, true)
39
40 const SharedStorage = Layer.mergeAll(
41 RunnerStorage.layerMemory,
42 MessageStorage.layerMemory
43 ).pipe(
44 Layer.provide(ShardingConfig.layerDefaults)
45 )
46
47 const startRunner = Effect.fnUntraced(function*(entities: Layer.Layer<never, never, Sharding.Sharding>) {
48 const socketServer = yield* DenoSocketServer.make({ host: "127.0.0.1", port: 0 })
49 if (socketServer.address._tag !== "InetAddressV4") {
50 return yield* Effect.die("Expected a TCP socket server")
51 }
52 const port = socketServer.address.port
53 yield* entities.pipe(
54 Layer.provideMerge(SocketRunner.layer),
55 Layer.provide(RunnerHealth.layerNoop),
56 Layer.provide(Layer.succeed(SocketServer.SocketServer, socketServer)),
57 Layer.provide(DenoClusterSocket.layerClientProtocol),
58 Layer.provide(ShardingConfig.layer({
59 runnerAddress: Option.some(RunnerAddress.make("127.0.0.1", port)),
60 entityTerminationTimeout: 0,
61 entityMessagePollInterval: 5000,
62 sendRetryInterval: 100
63 })),
64 Layer.provide(RpcSerialization.layerSchemaBinary()),
65 Layer.build
66 )
67 return port
68 })
69
70 const makeClientLayer = (port: number) =>
71 SocketRunner.layerClientOnly.pipe(
72 Layer.provide(DenoClusterSocket.layerClientProtocol),
73 Layer.provide(ShardingConfig.layer({
74 runnerAddress: Option.some(RunnerAddress.make("127.0.0.1", port)),
75 runnerListenAddress: Option.some(RunnerAddress.make("127.0.0.1", port)),
76 entityTerminationTimeout: 0,
77 entityMessagePollInterval: 5000,
78 sendRetryInterval: 100
79 })),
80 Layer.provide(RpcSerialization.layerSchemaBinary())
81 )
82
83 const IsolationEntity = Entity
84 .make("IsolationEntity", [
85 Rpc.make("BadReply", {
86 payload: { id: Schema.Number },
87 success: Schema.Int
88 }),
89 Rpc.make("Slow", {
90 success: Schema.String
91 })
92 ])
93 .annotateRpcs(ClusterSchema.Persisted, false)
94
95 // BigDecimal.normalize creates a circular `normalized` self-reference.
96 // When a persisted message is sent with discard: true, the notify path in Runners.makeRpc
97 // passes the raw envelope (with circular BigDecimal payload) to the runner,
98 // causing RangeError: Maximum call stack size exceeded.
99 //
100 // Volatile discard should complete after the request is sent, without waiting for the
101 // host runner to finish handling it.
102 describe("SocketRunner", () => {
103 it.live(
104 "discarded persisted requests serialize circular values and volatile requests do not wait for replies",
105 () =>
106 Effect.gen(function*() {
107 const volatileStarted = yield* Deferred.make<void>()
108 const releaseVolatile = yield* Deferred.make<void>()
109 const TestEntityLayer = TestEntity.toLayer(
110 Effect.succeed({
111 Process: () => Effect.void,
112 ProcessVolatile: () =>
113 Deferred.succeed(volatileStarted, void 0).pipe(
114 Effect.andThen(Deferred.await(releaseVolatile))
115 )
116 })
117 )
118
119 const port = yield* startRunner(TestEntityLayer)
120 yield* Effect.gen(function*() {
121 const makeClient = yield* TestEntity.client
122 const client = makeClient("entity-1")
123
124 const amount = BigDecimal.fromStringUnsafe("123.45")
125 yield* client.Process(
126 TestPayload.make({ id: "req-1", amount }),
127 { discard: true }
128 )
129
130 const volatileFiber = yield* client.ProcessVolatile(
131 TestPayload.make({ id: "req-2", amount }),
132 { discard: true }
133 ).pipe(Effect.forkChild)
134
135 yield* Deferred.await(volatileStarted).pipe(
136 Effect.timeoutOrElse({
137 duration: "5 seconds",
138 orElse: () => Effect.die("the volatile request never reached its handler")
139 })
140 )
141 yield* Fiber.join(volatileFiber).pipe(
142 Effect.timeoutOrElse({
143 duration: "1 second",
144 orElse: () => Effect.die("volatile discard waited for the entity reply")
145 })
146 )
147 yield* Deferred.succeed(releaseVolatile, void 0)
148 }).pipe(
149 Effect.provide(makeClientLayer(port)),
150 Effect.scoped
151 )
152 }).pipe(Effect.provide(SharedStorage)),
153 30_000
154 )
155
156 it.live(
157 "a reply serialization failure fails only its own request",
158 () =>
159 Effect.gen(function*() {
160 const slowStarted = yield* Deferred.make<void>()
161 const releaseSlow = yield* Deferred.make<void>()
162 const IsolationEntityLayer = IsolationEntity.toLayer(
163 Effect.succeed({
164 BadReply: () => Effect.succeed(1.5),
165 Slow: () =>
166 Deferred.succeed(slowStarted, void 0).pipe(
167 Effect.andThen(Deferred.await(releaseSlow)),
168 Effect.as("done")
169 )
170 })
171 )
172
173 const port = yield* startRunner(IsolationEntityLayer)
174
175 yield* Effect.gen(function*() {
176 const makeClient = yield* IsolationEntity.client
177
178 const slowFiber = yield* makeClient("slow-entity").Slow().pipe(Effect.forkChild)
179 yield* Deferred.await(slowStarted).pipe(
180 Effect.timeoutOrElse({
181 duration: "5 seconds",
182 orElse: () => Effect.die("the Slow request never reached its handler")
183 })
184 )
185
186 const badExit = yield* makeClient("bad-entity").BadReply({ id: 1 }).pipe(
187 Effect.exit,
188 Effect.ensuring(Deferred.succeed(releaseSlow, void 0))
189 )
190 assert.isTrue(Exit.isFailure(badExit), "the unencodable reply must fail the request")
191 const failure = Exit.isFailure(badExit) ? String(Cause.squash(badExit.cause)) : ""
192 assert.include(failure, "MalformedMessage", "the caller must receive the real encode error")
193 assert.notInclude(
194 failure,
195 "AlreadyProcessingMessage",
196 "the request must not be re-sent into the entity's dedup guard"
197 )
198
199 const slowExit = yield* Fiber.await(slowFiber)
200 assert.isTrue(
201 Exit.isSuccess(slowExit),
202 "a sibling in-flight request on the same connection must be unaffected"
203 )
204 if (Exit.isSuccess(slowExit)) {
205 assert.strictEqual(slowExit.value, "done")
206 }
207 }).pipe(
208 Effect.provide(makeClientLayer(port)),
209 Effect.scoped
210 )
211 }).pipe(Effect.provide(SharedStorage)),
212 30_000
213 )
214 })