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

main
ts 742 lines 31.3 KB
Raw
1 import * as Cloudflare from "@alchemy.run/cloudflare";
2 import * as RpcWebSocketClient from "@alchemy.run/cloudflare/Workers/RpcWebSocketClient";
3 import { describe, expect } from "@alchemy.run/test";
4 import * as Test from "@alchemy.run/test/Alchemy";
5 import * as Alchemy from "alchemy";
6 import type { Done, TimeoutError } from "effect/Cause";
7 import * as Context from "effect/Context";
8 import * as Data from "effect/Data";
9 import * as Deferred from "effect/Deferred";
10 import * as Effect from "effect/Effect";
11 import * as Exit from "effect/Exit";
12 import * as Fiber from "effect/Fiber";
13 import * as HttpClientRequest from "effect/http/HttpClientRequest";
14 import * as Layer from "effect/Layer";
15 import * as ManagedRuntime from "effect/ManagedRuntime";
16 import * as Queue from "effect/Queue";
17 import { RpcClient, RpcSerialization } from "effect/rpc";
18 import type { RpcClientError } from "effect/rpc/RpcClientError";
19 import * as Schedule from "effect/Schedule";
20 import * as Schema from "effect/Schema";
21 import * as Scope from "effect/Scope";
22 import * as Socket from "effect/socket/Socket";
23 import * as Stream from "effect/Stream";
24 import { requestWorker, waitUntilStable } from "../Utils/WorkerRequest.ts";
25 import { Greeting, Rejected, SocketRpcs, SocketStats } from "./fixtures/rpc-websocket/rpcs.ts";
26 import SocketWorker from "./fixtures/rpc-websocket/worker.ts";
27
28 class SocketClient extends Context.Service<SocketClient>()("SocketClient", {
29 make: RpcClient.make(SocketRpcs),
30 }) {}
31
32 const observeSockets = Effect.sync(() => {
33 const sockets: {
34 socket: WebSocket;
35 closeCodes: (number | undefined)[];
36 closed: Deferred.Deferred<{ code: number; reason: string }>;
37 }[] = [];
38 const constructor = (url: string) =>
39 Layer.effect(
40 Socket.WebSocketConstructor,
41 Effect.gen(function* () {
42 // Retry only the native handshake, before constructing the RPC client.
43 const { socket: ready } = yield* rawConnect(url);
44 let consumed = false;
45 return (url: string) => {
46 const socket = consumed ? new WebSocket(url) : ready;
47 consumed = true;
48 const closeCodes: (number | undefined)[] = [];
49 const close = socket.close.bind(socket);
50 socket.close = (code, reason) => {
51 closeCodes.push(code);
52 close(code, reason);
53 };
54 const closed = Deferred.makeUnsafe<{ code: number; reason: string }>();
55 socket.addEventListener("close", (event) =>
56 Deferred.doneUnsafe(closed, Exit.succeed({ code: event.code, reason: event.reason })),
57 );
58 sockets.push({ socket, closeCodes, closed });
59 return socket;
60 };
61 }),
62 );
63 return {
64 sockets,
65 layer: (url: string) =>
66 RpcWebSocketClient.layer(SocketClient, SocketRpcs, url.replace(/^http/, "ws"), {
67 protocol: { retryTransientErrors: false },
68 }).pipe(Layer.provide(constructor(url))),
69 assertClosed: Effect.gen(function* () {
70 expect(sockets).toHaveLength(1);
71 const { socket, closeCodes, closed } = sockets[0]!;
72 // The RPC Layer must close before rawConnect's fallback finalizer.
73 expect(closeCodes[0]).toBe(1000);
74 expect((yield* Deferred.await(closed).pipe(Effect.timeout("10 seconds"))).code).toBe(1000);
75 expect(socket.readyState).toBe(WebSocket.CLOSED);
76 expect(sockets).toHaveLength(1);
77 }),
78 };
79 });
80
81 const connect = Effect.fn(function* (url: string) {
82 const { socket: raw } = yield* rawConnect(url);
83 const protocol = RpcClient.layerProtocolSocket().pipe(
84 Layer.provide(
85 Layer.mergeAll(
86 Layer.effect(Socket.Socket, Socket.fromWebSocket(Effect.succeed(raw))),
87 RpcSerialization.layerJson,
88 ),
89 ),
90 );
91 const context = yield* Layer.build(protocol);
92 const client = yield* RpcClient.make(SocketRpcs).pipe(Effect.provide(context));
93 return { client, raw };
94 });
95
96 class WebSocketHandshakeFailed extends Data.TaggedError("WebSocketHandshakeFailed")<{
97 readonly message: string;
98 }> {}
99
100 type ClientLayerError = RpcClientError | WebSocketHandshakeFailed | TimeoutError;
101
102 const rawConnect = Effect.fn(
103 function* (url: string) {
104 const opened = yield* Deferred.make<void, WebSocketHandshakeFailed>();
105 const closed = yield* Deferred.make<{ code: number; reason: string }>();
106 const messages = yield* Queue.unbounded<string>();
107 const socket = yield* Effect.acquireRelease(
108 Effect.sync(() => {
109 const socket = new WebSocket(url.replace(/^http/, "ws"));
110 socket.addEventListener("open", () => Deferred.doneUnsafe(opened, Exit.void));
111 socket.addEventListener("error", (event) =>
112 Deferred.doneUnsafe(
113 opened,
114 Exit.fail(
115 new WebSocketHandshakeFailed({
116 message: `WebSocket handshake failed: ${"message" in event ? event.message : event.type}`,
117 }),
118 ),
119 ),
120 );
121 socket.addEventListener("message", (event) =>
122 Queue.offerUnsafe(messages, String(event.data)),
123 );
124 socket.addEventListener("close", (event) =>
125 Deferred.doneUnsafe(closed, Exit.succeed({ code: event.code, reason: event.reason })),
126 );
127 return socket;
128 }),
129 (socket) => Effect.sync(() => socket.close()),
130 );
131 yield* Deferred.await(opened).pipe(
132 Effect.timeout("10 seconds"),
133 Effect.onError(() => Effect.sync(() => socket.close())),
134 );
135 const send = (value: unknown) => Effect.sync(() => socket.send(JSON.stringify(value)));
136 const receive = Queue.take(messages).pipe(
137 Effect.flatMap((value) => Effect.try(() => JSON.parse(value))),
138 Effect.timeout("10 seconds"),
139 );
140 return {
141 socket,
142 send,
143 receive,
144 buffered: Queue.size(messages),
145 closed: Deferred.await(closed).pipe(Effect.timeout("10 seconds")),
146 };
147 },
148 Effect.retry({
149 // Bun hides rejected upgrade responses; retry only before any RPC is sent.
150 while: (error) => error._tag === "WebSocketHandshakeFailed",
151 schedule: Schedule.spaced("1 second"),
152 times: 8,
153 }),
154 );
155
156 /**
157 * Name Durable Objects per test attempt. The deployed Worker is shared across
158 * runner retries, so a fixed name would reuse an activation whose in-memory
159 * `opened`/`closed`/`cleanupStarted` state an earlier attempt already filled.
160 */
161 const freshObjects = Effect.sync(() => {
162 const suffix = crypto.randomUUID();
163 return (name: string) => `${name}-${suffix}`;
164 });
165
166 const readStats = Effect.fn(function* (url: string) {
167 const response = yield* requestWorker(HttpClientRequest.get(url));
168 if (response.status !== 200) {
169 return yield* Effect.fail(new Error(`GET ${url}: ${response.status}: ${yield* response.text}`));
170 }
171 return yield* response.json.pipe(Effect.flatMap(Schema.decodeUnknownEffect(SocketStats)));
172 }, Effect.timeout("15 seconds"));
173
174 describe.concurrent.each([
175 { dev: true, stage: `${Test.defaultStage()}-rpc-websocket-local` },
176 { dev: false, stage: `${Test.defaultStage()}-rpc-websocket-live` },
177 ])(
178 "WebSocket RPC (dev: $dev)",
179 ({ dev, stage }) => {
180 const state = dev ? Alchemy.inMemoryState() : Cloudflare.state();
181 const Stack = Alchemy.Stack(
182 "RpcWebSocketStack",
183 { providers: Cloudflare.providers(), state },
184 Effect.gen(function* () {
185 const worker = yield* SocketWorker;
186 return { url: worker.url.as<string>() };
187 }),
188 );
189 const { test, beforeAll, afterAll, deploy, destroy } = Test.make({
190 providers: Cloudflare.providers(),
191 state,
192 dev,
193 stage,
194 });
195 const stack = beforeAll(
196 Effect.gen(function* () {
197 yield* destroy(Stack);
198 const output = yield* deploy(Stack);
199 // A new version reaches Cloudflare's hosts one at a time; hosts still
200 // on the old version reject the upgrade ("Expected 101"). Require the
201 // HTTP route and a handshake to succeed several times in a row.
202 yield* waitUntilStable(
203 `RPC WebSocket worker at ${output.url}`,
204 requestWorker(HttpClientRequest.get(`${output.url}/ready`)).pipe(
205 Effect.flatMap((response) =>
206 response.text.pipe(
207 Effect.flatMap((body) =>
208 response.status === 200 && body === "ready"
209 ? Effect.void
210 : Effect.fail(new Test.WorkerNotReady({ status: response.status })),
211 ),
212 ),
213 ),
214 Effect.andThen(rawConnect(`${output.url}/rpc/ready`).pipe(Effect.scoped)),
215 Effect.as(true),
216 Effect.catchTag(["WorkerNotPropagated", "WebSocketHandshakeFailed"], () =>
217 Effect.succeed(false),
218 ),
219 ),
220 );
221 return output;
222 }),
223 { timeout: 180_000 },
224 );
225 afterAll.skipIf(!!process.env.NO_DESTROY)(destroy(Stack), { timeout: 30_000 });
226
227 test(
228 "readiness handling preserves application HTTP errors",
229 Effect.gen(function* () {
230 const { url } = yield* stack;
231 for (const [path, status] of [
232 ["not-found", 404],
233 ["server-error", 500],
234 ] as const) {
235 const response = yield* requestWorker(HttpClientRequest.get(`${url}/${path}`));
236 expect(response.status).toBe(status);
237 expect(yield* response.text).toBe("application error");
238 }
239 }).pipe(Effect.scoped),
240 { tags: [...(dev ? ["local"] : ["live"])], timeout: 30_000 },
241 );
242
243 test(
244 "typed unary, failure, streaming, and HTTP clients share one object",
245 Effect.gen(function* () {
246 const { url } = yield* stack;
247 const object = yield* freshObjects;
248 const { client } = yield* connect(`${url}/rpc/${object("roundtrip")}`);
249 const greeting = yield* client.greet({ name: "Sam" });
250 expect(greeting).toBeInstanceOf(Greeting);
251 expect(greeting.message).toBe("Hello, Sam!");
252 expect(yield* client.increment()).toBe(1);
253 expect(yield* client.reject().pipe(Effect.flip)).toBeInstanceOf(Rejected);
254 expect(yield* client.numbers({ count: 40 }).pipe(Stream.runCollect)).toEqual(
255 Array.from({ length: 40 }, (_, i) => i + 1),
256 );
257 const response = yield* requestWorker(
258 HttpClientRequest.get(`${url}/stats/${object("roundtrip")}`),
259 );
260 expect(response.status).toBe(200);
261 expect(yield* response.json).toMatchObject({ count: 1 });
262 }).pipe(Effect.scoped),
263 { tags: [...(dev ? ["local"] : ["live"])], timeout: 30_000 },
264 );
265
266 test(
267 "a Layer shares one actual socket for concurrent callers without a caller scope and closes normally",
268 Effect.gen(function* () {
269 const { url } = yield* stack;
270 const object = yield* freshObjects;
271 const endpoint = `${url}/rpc/${object("layer-client")}`;
272 const observed = yield* observeSockets;
273 const program: Effect.Effect<readonly number[], ClientLayerError> = Effect.gen(
274 function* () {
275 const results = yield* Effect.all(
276 Array.from({ length: 40 }, () =>
277 Effect.gen(function* () {
278 const client = yield* SocketClient;
279 return yield* client.increment();
280 }),
281 ),
282 { concurrency: "unbounded" },
283 );
284 const client = yield* SocketClient;
285 expect(yield* client.numbers({ count: 3 }).pipe(Stream.runCollect)).toEqual([1, 2, 3]);
286 expect(observed.sockets).toHaveLength(1);
287 expect(observed.sockets[0]!.socket.readyState).toBe(WebSocket.OPEN);
288 return results;
289 },
290 ).pipe(Effect.provide(observed.layer(endpoint)));
291 expect((yield* program).toSorted((a, b) => a - b)).toEqual(
292 Array.from({ length: 40 }, (_, i) => i + 1),
293 );
294 yield* observed.assertClosed;
295 expect((yield* readStats(`${url}/stats/${object("layer-client")}`)).count).toBe(40);
296 }),
297 { tags: [...(dev ? ["local"] : ["live"])], timeout: 30_000 },
298 );
299
300 test(
301 "a Layer closes its actual socket with code 1000 on application failure",
302 Effect.gen(function* () {
303 const { url } = yield* stack;
304 const object = yield* freshObjects;
305 const endpoint = `${url}/rpc/${object("layer-failure")}`;
306 const observed = yield* observeSockets;
307 const program: Effect.Effect<never, Rejected | ClientLayerError> = Effect.gen(function* () {
308 const client = yield* SocketClient;
309 yield* client.increment();
310 return yield* client.reject();
311 }).pipe(Effect.provide(observed.layer(endpoint)));
312 expect(yield* program.pipe(Effect.flip)).toBeInstanceOf(Rejected);
313 yield* observed.assertClosed;
314 expect((yield* readStats(`${url}/stats/${object("layer-failure")}`)).count).toBe(1);
315 }),
316 { tags: [...(dev ? ["local"] : ["live"])], timeout: 30_000 },
317 );
318
319 test(
320 "interrupting a Layer closes its actual socket with code 1000 and releases the handler",
321 Effect.gen(function* () {
322 const { url } = yield* stack;
323 const object = yield* freshObjects;
324 const endpoint = `${url}/rpc/${object("layer-interruption")}`;
325 const observed = yield* observeSockets;
326 const started = yield* Deferred.make<void>();
327 const program: Effect.Effect<void, ClientLayerError> = Effect.gen(function* () {
328 const client = yield* SocketClient;
329 yield* client
330 .watch({ key: "layer-interruption" })
331 .pipe(Stream.runForEach(() => Deferred.succeed(started, undefined)));
332 }).pipe(Effect.provide(observed.layer(endpoint)));
333 const fiber = yield* program.pipe(Effect.forkScoped);
334 yield* Deferred.await(started).pipe(Effect.timeout("10 seconds"));
335 expect(observed.sockets).toHaveLength(1);
336 yield* Fiber.interrupt(fiber);
337 expect(Exit.hasInterrupts(yield* Fiber.await(fiber))).toBe(true);
338 yield* observed.assertClosed;
339 const status = yield* readStats(`${url}/stats/${object("layer-interruption")}`).pipe(
340 Effect.repeat({
341 schedule: Schedule.spaced("250 millis"),
342 times: 40,
343 until: (state) => state.closed.includes("layer-interruption"),
344 }),
345 );
346 expect(status.closed).toEqual(["layer-interruption"]);
347 expect(status.invocations).toEqual({ "layer-interruption": 1 });
348 }).pipe(Effect.scoped),
349 { tags: [...(dev ? ["local"] : ["live"])], timeout: 30_000 },
350 );
351
352 test(
353 "ManagedRuntime.dispose closes the shared actual socket with code 1000",
354 Effect.gen(function* () {
355 const { url } = yield* stack;
356 const object = yield* freshObjects;
357 const endpoint = `${url}/rpc/${object("layer-managed")}`;
358 const observed = yield* observeSockets;
359 const runtime = yield* Effect.acquireRelease(
360 Effect.sync(() => ManagedRuntime.make(observed.layer(endpoint))),
361 (runtime) => Effect.promise(() => runtime.dispose()),
362 );
363 const call: Effect.Effect<number, RpcClientError, SocketClient> = Effect.gen(function* () {
364 const client = yield* SocketClient;
365 return yield* client.increment();
366 });
367 const results = yield* Effect.all(
368 Array.from({ length: 8 }, () =>
369 Effect.sync(() => runtime.runFork(call)).pipe(Effect.flatMap(Fiber.join)),
370 ),
371 { concurrency: "unbounded" },
372 );
373 expect(results.toSorted((a, b) => a - b)).toEqual([1, 2, 3, 4, 5, 6, 7, 8]);
374 expect(observed.sockets).toHaveLength(1);
375 expect(observed.sockets[0]!.socket.readyState).toBe(WebSocket.OPEN);
376 yield* Effect.promise(() => runtime.dispose());
377 yield* observed.assertClosed;
378 expect((yield* readStats(`${url}/stats/${object("layer-managed")}`)).count).toBe(8);
379 }).pipe(Effect.scoped),
380 { tags: [...(dev ? ["local"] : ["live"])], timeout: 30_000 },
381 );
382
383 test(
384 "a queue subscription owns a separate scope without closing the Layer socket",
385 Effect.gen(function* () {
386 const { url } = yield* stack;
387 const object = yield* freshObjects;
388 const endpoint = `${url}/rpc/${object("layer-queue")}`;
389 const observed = yield* observeSockets;
390 const program: Effect.Effect<void, ClientLayerError | Done> = Effect.gen(function* () {
391 const client = yield* SocketClient;
392 yield* Effect.gen(function* () {
393 const queue = yield* client.watch({ key: "queue" }, { asQueue: true });
394 expect(yield* Queue.take(queue)).toBe(1);
395 }).pipe(Effect.scoped);
396 expect(observed.sockets).toHaveLength(1);
397 expect(observed.sockets[0]!.socket.readyState).toBe(WebSocket.OPEN);
398 expect((yield* client.greet({ name: "still open" })).message).toBe("Hello, still open!");
399 }).pipe(Effect.provide(observed.layer(endpoint)));
400 yield* program;
401 yield* observed.assertClosed;
402 const status = yield* readStats(`${url}/stats/${object("layer-queue")}`).pipe(
403 Effect.repeat({
404 schedule: Schedule.spaced("250 millis"),
405 times: 40,
406 until: (state) => state.closed.includes("queue"),
407 }),
408 );
409 expect(status.closed).toEqual(["queue"]);
410 expect(status.invocations).toEqual({ queue: 1 });
411 }),
412 { tags: [...(dev ? ["local"] : ["live"])], timeout: 30_000 },
413 );
414
415 test(
416 "multiplexes concurrent calls without crossing instance state",
417 Effect.gen(function* () {
418 const { url } = yield* stack;
419 const object = yield* freshObjects;
420 const { client } = yield* connect(`${url}/rpc/${object("concurrent")}`);
421 const results = yield* Effect.all(
422 Array.from({ length: 40 }, () => client.increment()),
423 { concurrency: "unbounded" },
424 );
425 expect(results.sort((a, b) => a - b)).toEqual(Array.from({ length: 40 }, (_, i) => i + 1));
426 const other = yield* connect(`${url}/rpc/${object("isolated")}`);
427 expect((yield* other.client.stats()).count).toBe(0);
428 }).pipe(Effect.scoped),
429 { tags: [...(dev ? ["local"] : ["live"])], timeout: 30_000 },
430 );
431
432 test(
433 "stream interruption closes its scope and keeps the socket usable",
434 Effect.gen(function* () {
435 const { url } = yield* stack;
436 const object = yield* freshObjects;
437 const { client, raw } = yield* connect(`${url}/rpc/${object("interruption")}`);
438 const scope = yield* Scope.make();
439 const values = yield* client
440 .watch({ key: "cancel" }, { asQueue: true })
441 .pipe(Effect.provideService(Scope.Scope, scope));
442 expect(yield* Queue.take(values).pipe(Effect.timeout("10 seconds"))).toBe(1);
443 yield* Scope.close(scope, Exit.void);
444 const status = yield* client.stats().pipe(
445 Effect.repeat({
446 schedule: Schedule.spaced("250 millis"),
447 times: 40,
448 until: (state) => state.closed.includes("cancel"),
449 }),
450 );
451 expect(status.closed).toContain("cancel");
452 expect(raw.readyState).toBe(WebSocket.OPEN);
453 expect((yield* client.greet({ name: "again" })).message).toBe("Hello, again!");
454 }).pipe(Effect.scoped),
455 { tags: [...(dev ? ["local"] : ["live"])], timeout: 30_000 },
456 );
457
458 test(
459 "socket disconnect interrupts active handler resources",
460 Effect.gen(function* () {
461 const { url } = yield* stack;
462 const object = yield* freshObjects;
463 const connection = yield* rawConnect(`${url}/rpc/${object("disconnect")}`);
464 yield* connection.send({
465 _tag: "Request",
466 id: "1",
467 tag: "watch",
468 payload: { key: "disconnect" },
469 headers: [],
470 });
471 expect(yield* connection.receive).toMatchObject({ _tag: "Chunk", values: [1] });
472 yield* Effect.sync(() => connection.socket.close());
473 yield* connection.closed;
474 const status = yield* requestWorker(
475 HttpClientRequest.get(`${url}/stats/${object("disconnect")}`),
476 ).pipe(
477 Effect.flatMap((response) => response.json),
478 Effect.map((state) => state as { closed: string[] }),
479 Effect.repeat({
480 schedule: Schedule.spaced("250 millis"),
481 times: 40,
482 until: (state) => state.closed.includes("disconnect"),
483 }),
484 );
485 expect(status).toMatchObject({ opened: ["disconnect"], closed: ["disconnect"] });
486 }).pipe(Effect.scoped),
487 { tags: [...(dev ? ["local"] : ["live"])], timeout: 30_000 },
488 );
489
490 for (const mode of ["unary", "disconnect"] as const) {
491 test(
492 mode === "unary"
493 ? "unary result does not release the activation before deferred cleanup finishes"
494 : "disconnect before any output retains the activation until deferred cleanup finishes",
495 Effect.gen(function* () {
496 const { url } = yield* stack;
497 const object = yield* freshObjects;
498 const name = object(`cleanup-${mode}`);
499 const connection = yield* rawConnect(`${url}/rpc/${name}`);
500 const before = yield* readStats(`${url}/stats/${name}`);
501 yield* Effect.gen(function* () {
502 yield* connection.send({
503 _tag: "Request",
504 id: "1",
505 tag: "cleanup",
506 payload: { key: mode, waitForDisconnect: mode === "disconnect" },
507 headers: [],
508 });
509 if (mode === "unary") {
510 expect(yield* connection.receive).toMatchObject({
511 _tag: "Exit",
512 requestId: "1",
513 exit: { _tag: "Success", value: before.boots },
514 });
515 } else {
516 const entered = yield* readStats(`${url}/stats/${name}`).pipe(
517 Effect.repeat({
518 schedule: Schedule.spaced("250 millis"),
519 times: 40,
520 until: (state) => state.opened.includes(mode),
521 }),
522 );
523 expect(entered.boots).toBe(before.boots);
524 expect(entered.opened).toContain(mode);
525 expect(entered.cleanupStarted).toEqual([]);
526 expect(yield* connection.buffered).toBe(0);
527 yield* Effect.sync(() => connection.socket.close());
528 yield* connection.closed;
529 expect(yield* connection.buffered).toBe(0);
530 }
531 const started = yield* readStats(`${url}/stats/${name}`).pipe(
532 Effect.repeat({
533 schedule: Schedule.spaced("250 millis"),
534 times: 40,
535 until: (state) => state.cleanupStarted.includes(mode),
536 }),
537 );
538 expect(started.boots).toBe(before.boots);
539 expect(started.cleanupStarted).toEqual([mode]);
540 expect(started.cleanupCompleted).toEqual({});
541
542 // Raw sockets send no heartbeats; only the test process has a timer.
543 yield* Effect.sleep("20 seconds");
544 const held = yield* readStats(`${url}/stats/${name}`);
545 expect(held.boots).toBe(before.boots);
546 expect(held.cleanupStarted).toEqual([mode]);
547 expect(held.cleanupCompleted).toEqual({});
548
549 if (mode === "unary") {
550 expect(connection.socket.readyState).toBe(WebSocket.OPEN);
551 const control = yield* rawConnect(`${url}/rpc/${name}`);
552 yield* control.send({
553 _tag: "Request",
554 id: "1",
555 tag: "releaseCleanup",
556 payload: { key: mode },
557 headers: [],
558 });
559 expect(yield* control.receive).toMatchObject({
560 _tag: "Exit",
561 requestId: "1",
562 exit: { _tag: "Success", value: true },
563 });
564 } else {
565 const response = yield* requestWorker(
566 HttpClientRequest.post(`${url}/release/${name}/${mode}`),
567 );
568 expect(response.status).toBe(200);
569 expect(yield* response.json).toEqual({ released: true });
570 }
571 const completed = yield* readStats(`${url}/stats/${name}`).pipe(
572 Effect.repeat({
573 schedule: Schedule.spaced("250 millis"),
574 times: 40,
575 until: (state) => state.cleanupCompleted[mode] !== undefined,
576 }),
577 );
578 expect(completed.boots).toBe(before.boots);
579 expect(completed.cleanupCompleted).toEqual({ [mode]: before.boots });
580 }).pipe(
581 Effect.ensuring(
582 requestWorker(HttpClientRequest.post(`${url}/release/${name}/${mode}`)).pipe(
583 Effect.timeout("15 seconds"),
584 Effect.ignoreCause,
585 ),
586 ),
587 );
588 }).pipe(Effect.scoped),
589 { tags: [...(dev ? ["local"] : ["live"])], timeout: 90_000 },
590 );
591 }
592
593 test(
594 "the same Layer-owned socket survives real hibernation and serves a new RPC",
595 Effect.gen(function* () {
596 const { url } = yield* stack;
597 const object = yield* freshObjects;
598 const endpoint = `${url}/rpc/${object("idle")}`;
599 const observed = yield* observeSockets;
600 yield* Effect.gen(function* () {
601 const client = yield* SocketClient;
602 const before = yield* client.stats();
603 expect(observed.sockets).toHaveLength(1);
604 const socket = observed.sockets[0]!.socket;
605 const after = yield* Effect.gen(function* () {
606 yield* Effect.sleep("15 seconds");
607 return yield* client.stats().pipe(Effect.timeout("5 seconds"));
608 }).pipe(Effect.repeat({ times: 2, until: (state) => state.boots > before.boots }));
609 expect(after.boots).toBeGreaterThan(before.boots);
610 expect(socket.readyState).toBe(WebSocket.OPEN);
611 expect((yield* client.greet({ name: "awake" })).message).toBe("Hello, awake!");
612 expect((yield* client.stats()).boots).toBe(after.boots);
613 expect(observed.sockets).toHaveLength(1);
614 expect(observed.sockets[0]!.socket).toBe(socket);
615 }).pipe(Effect.provide(observed.layer(endpoint)));
616 yield* observed.assertClosed;
617 }),
618 { tags: [...(dev ? ["local"] : ["live"])], timeout: 110_000 },
619 );
620
621 test(
622 "hibernation resets an actual socket with an incompatible serializer attachment",
623 Effect.gen(function* () {
624 const { url } = yield* stack;
625 const object = yield* freshObjects;
626 const connection = yield* rawConnect(`${url}/rpc/${object("serialization-reset")}`);
627 const before = yield* readStats(`${url}/stats/${object("serialization-reset")}`);
628 const response = yield* requestWorker(
629 HttpClientRequest.post(`${url}/serialization/${object("serialization-reset")}`),
630 );
631 expect(response.status).toBe(200);
632 expect(yield* response.json).toEqual({ changed: 1 });
633 expect(connection.socket.readyState).toBe(WebSocket.OPEN);
634 const after = yield* Effect.gen(function* () {
635 yield* Effect.sleep("15 seconds");
636 return yield* readStats(`${url}/stats/${object("serialization-reset")}`);
637 }).pipe(Effect.repeat({ times: 2, until: (state) => state.boots > before.boots }));
638 expect(after.boots).toBeGreaterThan(before.boots);
639 expect(yield* connection.closed).toEqual({
640 code: 1012,
641 reason: "Durable Object RPC activation reset",
642 });
643 expect(connection.socket.readyState).toBe(WebSocket.CLOSED);
644 expect(yield* connection.buffered).toBe(0);
645 const replacement = yield* connect(`${url}/rpc/${object("serialization-reset")}`);
646 expect((yield* replacement.client.greet({ name: "compatible" })).message).toBe(
647 "Hello, compatible!",
648 );
649 expect((yield* replacement.client.stats()).boots).toBe(after.boots);
650 }).pipe(Effect.scoped),
651 { tags: [...(dev ? ["local"] : ["live"])], timeout: 110_000 },
652 );
653
654 test(
655 "native abort fails an active stream without replaying its request",
656 Effect.gen(function* () {
657 const { url } = yield* stack;
658 const object = yield* freshObjects;
659 const connection = yield* rawConnect(`${url}/rpc/${object("lost-stream")}`);
660 yield* connection.send({
661 _tag: "Request",
662 id: "1",
663 tag: "watch",
664 payload: { key: "lost" },
665 headers: [],
666 });
667 expect(yield* connection.receive).toMatchObject({ _tag: "Chunk", values: [1] });
668 yield* connection.send({ _tag: "Ack", requestId: "1" });
669 const before = yield* readStats(`${url}/stats/${object("lost-stream")}`);
670 expect(before.invocations).toEqual({ lost: 1 });
671 expect(before.opened).toEqual(["lost"]);
672 const response = yield* requestWorker(
673 HttpClientRequest.post(`${url}/abort/${object("lost-stream")}`),
674 ).pipe(Effect.timeout("15 seconds"));
675 expect(response.status).toBe(200);
676 expect(yield* response.json).toEqual({ aborted: true });
677 yield* connection.closed;
678 expect(connection.socket.readyState).toBe(WebSocket.CLOSED);
679 expect(yield* connection.buffered).toBe(0);
680
681 const replacement = yield* connect(`${url}/rpc/${object("lost-stream")}`);
682 const status = yield* replacement.client.stats();
683 expect(status.boots).toBeGreaterThan(before.boots);
684 expect(status.invocations).toEqual({ lost: 1 });
685 expect(status.opened).toEqual([]);
686 expect((yield* replacement.client.greet({ name: "reconnected" })).message).toBe(
687 "Hello, reconnected!",
688 );
689 expect((yield* replacement.client.stats()).invocations).toEqual({ lost: 1 });
690 }).pipe(Effect.scoped),
691 { tags: [...(dev ? ["local"] : ["live"])], timeout: 45_000 },
692 );
693
694 test(
695 "schema and unknown-method failures leave the connection usable",
696 Effect.gen(function* () {
697 const { url } = yield* stack;
698 const object = yield* freshObjects;
699 const connection = yield* rawConnect(`${url}/rpc/${object("invalid-requests")}`);
700 for (const [id, tag, payload] of [
701 ["1", "greet", { name: 42 }],
702 ["2", "missing", {}],
703 ] as const) {
704 yield* connection.send({ _tag: "Request", id, tag, payload, headers: [] });
705 expect(yield* connection.receive).toMatchObject({
706 _tag: "Exit",
707 requestId: id,
708 exit: { _tag: "Failure" },
709 });
710 }
711 yield* connection.send({
712 _tag: "Request",
713 id: "3",
714 tag: "greet",
715 payload: { name: "valid" },
716 headers: [],
717 });
718 expect(yield* connection.receive).toMatchObject({
719 _tag: "Exit",
720 requestId: "3",
721 exit: { _tag: "Success", value: { message: "Hello, valid!" } },
722 });
723 }).pipe(Effect.scoped),
724 { tags: [...(dev ? ["local"] : ["live"])], timeout: 30_000 },
725 );
726
727 test(
728 "malformed frames close the offending connection",
729 Effect.gen(function* () {
730 const { url } = yield* stack;
731 const object = yield* freshObjects;
732 const connection = yield* rawConnect(`${url}/rpc/${object("malformed")}`);
733 yield* Effect.sync(() => connection.socket.send("not json"));
734 expect((yield* connection.closed).code).toBeGreaterThanOrEqual(1002);
735 const healthy = yield* connect(`${url}/rpc/${object("malformed")}`);
736 expect((yield* healthy.client.greet({ name: "healthy" })).message).toBe("Hello, healthy!");
737 }).pipe(Effect.scoped),
738 { tags: [...(dev ? ["local"] : ["live"])], timeout: 30_000 },
739 );
740 },
741 { tags: ["provider:cloudflare", "provider:cloudflare:worker"] },
742 );