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

main
ts 1,084 lines 42 KB
Raw
1 import { NodeSocket, NodeSocketServer, NodeWS } from "@effect/platform-node"
2 import { assert, describe, it } from "@effect/vitest"
3 import { Deferred, Effect, Option, Queue, Redacted } from "effect"
4 import * as Exit from "effect/Exit"
5 import * as Fiber from "effect/Fiber"
6 import type * as NetAddress from "effect/net/NetAddress"
7 import * as Scope from "effect/Scope"
8 import { Socket } from "effect/socket"
9 import * as Stream from "effect/Stream"
10 import { TestClock } from "effect/testing"
11 import * as Fs from "node:fs"
12 import * as Net from "node:net"
13 import { Duplex, PassThrough } from "node:stream"
14 import * as Tls from "node:tls"
15 import { fileURLToPath } from "node:url"
16 import { vi } from "vitest"
17 import { WS } from "vitest-websocket-mock"
18
19 vi.mock("node:net", async (importOriginal) => {
20 const original = await importOriginal<typeof Net>()
21 return { ...original, createConnection: vi.fn(original.createConnection) }
22 })
23
24 vi.mock("node:tls", async (importOriginal) => {
25 const original = await importOriginal<typeof Tls>()
26 return { ...original, connect: vi.fn(original.connect) }
27 })
28
29 // Regenerate with:
30 // openssl req -x509 -newkey ed25519 -nodes -days 36500 -subj /CN=localhost \
31 // -addext subjectAltName=DNS:localhost,IP:127.0.0.1 -keyout key.pem -out cert.pem
32 const cert = Fs.readFileSync(fileURLToPath(new URL("./fixtures/tls/cert.pem", import.meta.url)))
33 const key = Fs.readFileSync(fileURLToPath(new URL("./fixtures/tls/key.pem", import.meta.url)))
34
35 const echoHandler = Effect.fnUntraced(
36 function*(socket: Socket.Socket, upgradeOptions?: Socket.TlsUpgradeOptions) {
37 const writer = yield* socket.writer
38 const { pull, upgrade } = yield* socket.reader
39 if (upgradeOptions !== undefined) {
40 yield* upgrade(upgradeOptions)
41 }
42 while (true) {
43 yield* writer.writeAll(yield* pull)
44 }
45 },
46 (_) => Effect.scoped(_),
47 Effect.catchTag("SocketError", () => Effect.void)
48 )
49
50 const makePassThrough = Effect.acquireRelease(
51 Effect.sync(() => new PassThrough()),
52 (duplex) => Effect.sync(() => duplex.destroy())
53 )
54
55 // A duplex-backed reader with one pull parked, waiting for bytes.
56 const parkedPull = Effect.gen(function*() {
57 const duplex = yield* makePassThrough
58 const { pull } = yield* (yield* NodeSocket.fromDuplex(Effect.succeed(duplex))).reader
59 const parked = yield* Effect.forkChild(pull, { startImmediately: true })
60 return { duplex, pull, parked }
61 })
62
63 const decode = (batch: ReadonlyArray<Uint8Array | string>) =>
64 Buffer.concat(batch.map((chunk) => Buffer.from(chunk))).toString()
65
66 const sendHelloWorld = Effect.fnUntraced(function*(socket: Socket.Socket, upgradeOptions?: Socket.TlsUpgradeOptions) {
67 const writer = yield* socket.writer
68 const { pull, upgrade } = yield* socket.reader
69 if (upgradeOptions !== undefined) {
70 yield* upgrade(upgradeOptions)
71 }
72 yield* writer.writeAll(["Hello", "World"])
73 const decoder = new TextDecoder()
74 let text = ""
75 while (text.length < 10) {
76 for (const chunk of yield* pull) {
77 text += typeof chunk === "string" ? chunk : decoder.decode(chunk)
78 }
79 }
80 return text
81 }, (_) => Effect.scoped(_))
82
83 const makeServer = Effect.gen(function*() {
84 const server = yield* NodeSocketServer.make({ port: 0 })
85 yield* server.run(echoHandler).pipe(Effect.forkScoped)
86 return server
87 })
88
89 // Tests that mock native connection APIs must not overlap real connections.
90 describe("Socket", { concurrent: false }, () => {
91 it.live("preserves a native IPv6 listener address", () =>
92 Effect.gen(function*() {
93 const server = yield* NodeSocketServer.make({ host: "::1", port: 0 })
94 assert.strictEqual(server.address._tag, "InetAddressV6")
95 if (server.address._tag !== "InetAddressV6") return
96 assert.strictEqual(server.address.address.toString(), "::1")
97 assert.notStrictEqual(server.address.port, 0)
98 }))
99
100 it.live("closes with a pending pre-run socket", () =>
101 Effect.gen(function*() {
102 const scope = yield* Scope.make()
103 const server = yield* NodeSocketServer.make({ host: "127.0.0.1", port: 0 }).pipe(Scope.provide(scope))
104 assert.strictEqual(server.address._tag, "InetAddressV4")
105 if (server.address._tag !== "InetAddressV4") return
106 const socket = Net.createConnection({ host: "127.0.0.1", port: server.address.port })
107 yield* Effect.promise(() =>
108 new Promise<void>((resolve, reject) => {
109 socket.once("connect", resolve)
110 socket.once("error", reject)
111 })
112 )
113 const closing = yield* Scope.close(scope, Exit.void).pipe(Effect.forkChild)
114 const exit = yield* Fiber.await(closing).pipe(
115 Effect.timeout("1 second"),
116 Effect.ensuring(Effect.sync(() => socket.destroy()))
117 )
118 assert.isTrue(Exit.isSuccess(exit))
119 }))
120
121 it.live("closes with a pending pre-run WebSocket", () =>
122 Effect.gen(function*() {
123 const scope = yield* Scope.make()
124 const server = yield* NodeSocketServer.makeWebSocket({ host: "127.0.0.1", port: 0 }).pipe(Scope.provide(scope))
125 assert.strictEqual(server.address._tag, "InetAddressV4")
126 if (server.address._tag !== "InetAddressV4") return
127 const socket = new NodeWS.WebSocket(`ws://127.0.0.1:${server.address.port}`)
128 yield* Effect.promise(() =>
129 new Promise<void>((resolve, reject) => {
130 socket.once("open", resolve)
131 socket.once("error", reject)
132 })
133 )
134 const closing = yield* Scope.close(scope, Exit.void).pipe(Effect.forkChild)
135 const exit = yield* Fiber.await(closing).pipe(
136 Effect.timeout("1 second"),
137 Effect.ensuring(Effect.sync(() => socket.terminate()))
138 )
139 assert.isTrue(Exit.isSuccess(exit))
140 }))
141
142 it.effect("open", () =>
143 Effect.gen(function*() {
144 const server = yield* makeServer
145 const channel = NodeSocket.makeNetChannel({ port: (server.address as NetAddress.InetAddress).port })
146
147 const outputEffect = Stream.make("Hello", "World").pipe(
148 Stream.encodeText,
149 Stream.pipeThroughChannel(channel),
150 Stream.catchIf(
151 (error) => error.reason._tag === "SocketCloseError",
152 () => Stream.empty
153 ),
154 Stream.decodeText(),
155 Stream.mkString
156 )
157
158 const output = yield* outputEffect
159 assert.strictEqual(output, "HelloWorld")
160 }))
161
162 it.effect("pull batches", () =>
163 Effect.gen(function*() {
164 const server = yield* makeServer
165 const socket = yield* NodeSocket.makeNet({ port: (server.address as NetAddress.InetAddress).port })
166
167 const received = yield* Effect.gen(function*() {
168 const writer = yield* socket.writer
169 const pull = yield* Socket.readerBytes(socket)
170 yield* writer.writeAll(["Hello", "World"])
171 const received: Array<Uint8Array> = []
172 let length = 0
173 while (length < 10) {
174 const chunk = yield* pull
175 for (const data of chunk) {
176 received.push(data)
177 length += data.byteLength
178 }
179 }
180 return received
181 }).pipe(Effect.scoped)
182
183 const text = new TextDecoder().decode(
184 received.reduce((acc, chunk) => {
185 const next = new Uint8Array(acc.byteLength + chunk.byteLength)
186 next.set(acc, 0)
187 next.set(chunk, acc.byteLength)
188 return next
189 }, new Uint8Array(0))
190 )
191 assert.strictEqual(text, "HelloWorld")
192 }))
193
194 for (const chunkSize of [undefined, 2, Infinity]) {
195 it.effect(`batches synchronous duplex drains and completes in order (${chunkSize ?? "default 4096"})`, () =>
196 Effect.gen(function*() {
197 const input = "abcdefghij".repeat(1000)
198 let reads = 0
199 const duplex = yield* Effect.acquireRelease(
200 Effect.sync(() =>
201 new Duplex({
202 readableObjectMode: true,
203 readableHighWaterMark: 1,
204 read() {
205 const offset = reads++
206 this.push(offset === input.length ? null : Buffer.from(input[offset]))
207 },
208 write(_chunk, _encoding, callback) {
209 callback()
210 }
211 })
212 ),
213 (duplex) => Effect.sync(() => duplex.destroy())
214 )
215 const socket = yield* NodeSocket.fromDuplex(Effect.succeed(duplex), { chunkSize })
216 const { pull } = yield* socket.reader
217 const limit = chunkSize === Infinity ? input.length : chunkSize ?? 4096
218 const first = yield* pull
219 assert.strictEqual(first.length, limit)
220 // Node may prefetch one object into its own buffer.
221 assert.isAtMost(reads, limit + 1)
222 let received = decode(first)
223 while (received.length < input.length) {
224 const batch = yield* pull
225 assert.isAtMost(batch.length, limit)
226 received += decode(batch)
227 }
228 assert.strictEqual(received, input)
229 const error = yield* Effect.flip(pull)
230 assert.strictEqual(error.reason._tag, "SocketCloseError")
231 if (error.reason._tag === "SocketCloseError") {
232 assert.strictEqual(error.reason.code, 1000)
233 }
234 }))
235 }
236
237 it.effect("pull drains every buffered duplex chunk", () =>
238 Effect.gen(function*() {
239 const first = Buffer.from("aa")
240 const second = Buffer.from("bb")
241 const duplex = new Duplex({
242 read() {},
243 write() {}
244 })
245 duplex.pause()
246 const socket = yield* NodeSocket.fromDuplex(Effect.succeed(duplex))
247 const { pull } = yield* socket.reader
248 duplex.push(first)
249 duplex.push(second)
250 const batch = yield* pull
251 assert.strictEqual(Buffer.concat(batch.map((chunk) => chunk as Uint8Array)).toString(), "aabb")
252 // Node 26 returns one buffered chunk per `read()`, so the batch carries
253 // the pushed buffers with no copy. Earlier Node concatenates them.
254 if (batch.length === 2) {
255 assert.strictEqual(batch[0], first)
256 assert.strictEqual(batch[1], second)
257 }
258 }))
259
260 it.live("handles reader scope closure during a parked pull read", () =>
261 Effect.gen(function*() {
262 const duplex = yield* makePassThrough
263 const socket = yield* NodeSocket.fromDuplex(Effect.succeed(duplex))
264 const readScope = yield* Scope.make()
265 yield* Effect.addFinalizer(() => Scope.close(readScope, Exit.void))
266 const { pull } = yield* Scope.provide(socket.reader, readScope)
267 const parked = yield* Effect.forkChild(pull, { startImmediately: true })
268 let observed = ""
269 duplex.once("data", (chunk) => {
270 observed = chunk.toString()
271 Effect.runSync(Scope.close(readScope, Exit.void))
272 })
273
274 // Deliver synchronously so an exception stays in the test, rather than
275 // escaping from Node's next-tick readable notification.
276 duplex.write("hello")
277 duplex.emit("readable")
278 const error = yield* Fiber.join(parked).pipe(Effect.flip, Effect.timeout("1 second"))
279 assert.strictEqual(observed, "hello")
280 assert.strictEqual(error.reason._tag, "SocketCloseError")
281 if (error.reason._tag === "SocketCloseError") {
282 assert.strictEqual(error.reason.code, 1006)
283 }
284 }))
285
286 it.live("preserves a chunk when a parked pull is interrupted during read", () =>
287 Effect.gen(function*() {
288 const { duplex, parked, pull } = yield* parkedPull
289 duplex.once("data", () => Effect.runSync(Fiber.interrupt(parked)))
290 duplex.write("hello")
291 duplex.emit("readable")
292 assert.isTrue(Exit.hasInterrupts(yield* Fiber.await(parked).pipe(Effect.timeout("1 second"))))
293 const next = yield* pull.pipe(Effect.timeout("1 second"))
294 assert.strictEqual(decode(next), "hello")
295 }))
296
297 it.live("drains a retained chunk when EOF follows parked pull interruption", () =>
298 Effect.gen(function*() {
299 const { duplex, parked, pull } = yield* parkedPull
300 duplex.once("data", () => Effect.runSync(Fiber.interrupt(parked)))
301 const ended = new Promise<void>((resolve) => duplex.once("end", resolve))
302 duplex.end("hello")
303 duplex.emit("readable")
304 yield* Effect.promise(() => ended).pipe(Effect.timeout("1 second"))
305 assert.isTrue(Exit.hasInterrupts(yield* Fiber.await(parked)))
306 const next = yield* pull.pipe(Effect.timeout("1 second"))
307 assert.strictEqual(decode(next), "hello")
308 const error = yield* Effect.flip(pull).pipe(Effect.timeout("1 second"))
309 assert.strictEqual(error.reason._tag, "SocketCloseError")
310 if (error.reason._tag === "SocketCloseError") {
311 assert.strictEqual(error.reason.code, 1000)
312 }
313 }))
314
315 it.live("preserves order when a parked pull is replaced synchronously during read", () =>
316 Effect.gen(function*() {
317 const { duplex, parked, pull } = yield* parkedPull
318 const scope = yield* Effect.scope
319 let replacement: Fiber.Fiber<ReadonlyArray<Uint8Array | string>, Socket.SocketError> | undefined
320 duplex.once("data", () => {
321 Effect.runSync(Fiber.interrupt(parked))
322 // Make the second chunk available only after read() consumes the first,
323 // so this also exercises separate reads on Node versions that coalesce.
324 duplex.write("second")
325 replacement = Effect.runSync(Effect.forkIn(pull, scope, { startImmediately: true }))
326 })
327 duplex.write("first")
328 duplex.emit("readable")
329 assert.isTrue(Exit.hasInterrupts(yield* Fiber.await(parked)))
330 assert.isDefined(replacement)
331 let received = decode(yield* Fiber.join(replacement).pipe(Effect.timeout("1 second")))
332 while (received.length < "firstsecond".length) {
333 received += decode(yield* pull.pipe(Effect.timeout("1 second")))
334 }
335 assert.strictEqual(received, "firstsecond")
336 }))
337
338 it.live("respects a zero open timeout", () =>
339 Effect.gen(function*() {
340 const socket = yield* NodeSocket.fromDuplex(Effect.never, { openTimeout: 0 })
341 const error = yield* Effect.scoped(Effect.asVoid(socket.reader)).pipe(
342 Effect.flip,
343 Effect.timeout("1 second")
344 )
345 assert.strictEqual(error.reason._tag, "SocketOpenError")
346 if (error.reason._tag === "SocketOpenError") {
347 assert.strictEqual(error.reason.kind, "Timeout")
348 }
349 }))
350
351 it.live("destroys a pending TCP connection on open timeout", () => {
352 const conn = new Net.Socket()
353 const destroy = vi.spyOn(conn, "destroy")
354 const destroySoon = vi.spyOn(conn, "destroySoon").mockImplementation(() => {})
355 vi.mocked(Net.createConnection).mockReturnValueOnce(conn)
356
357 return Effect.gen(function*() {
358 const socket = yield* NodeSocket.makeNet({ host: "127.0.0.1", port: 1, openTimeout: 0 })
359 yield* Effect.scoped(Effect.asVoid(socket.reader)).pipe(Effect.flip)
360 assert.isTrue(destroy.mock.calls.length > 0)
361 assert.strictEqual(destroySoon.mock.calls.length, 0)
362 }).pipe(
363 Effect.ensuring(Effect.sync(() => {
364 destroy.mockRestore()
365 destroySoon.mockRestore()
366 conn.destroy()
367 }))
368 )
369 })
370
371 it.live("gracefully closes an established TCP connection", () => {
372 const conn = new Net.Socket()
373 const destroy = vi.spyOn(conn, "destroy")
374 const destroySoon = vi.spyOn(conn, "destroySoon").mockImplementation(() => {})
375 vi.mocked(Net.createConnection).mockImplementationOnce(() => {
376 queueMicrotask(() => conn.emit("connect"))
377 return conn
378 })
379
380 return Effect.gen(function*() {
381 const socket = yield* NodeSocket.makeNet({ host: "127.0.0.1", port: 1 })
382 yield* Effect.scoped(Effect.asVoid(socket.reader))
383 assert.strictEqual(destroy.mock.calls.length, 0)
384 assert.isTrue(destroySoon.mock.calls.length > 0)
385 }).pipe(
386 Effect.ensuring(Effect.sync(() => {
387 destroy.mockRestore()
388 destroySoon.mockRestore()
389 conn.destroy()
390 }))
391 )
392 })
393
394 describe("TLS", () => {
395 const makeTlsServer = Effect.suspend(() => {
396 const sockets = new Set<Tls.TLSSocket>()
397 return Effect.acquireRelease(
398 Effect.callback<Tls.Server>((resume) => {
399 const server = Tls.createServer({ cert, key }, (socket) => {
400 sockets.add(socket)
401 socket.on("close", () => sockets.delete(socket))
402 socket.pipe(socket)
403 })
404 server.listen(0, "127.0.0.1", () => resume(Effect.succeed(server)))
405 }),
406 (server) =>
407 Effect.sync(() => {
408 for (const socket of sockets) socket.destroy()
409 server.close()
410 })
411 )
412 })
413
414 const serverPort = (server: Tls.Server) => (server.address() as Net.AddressInfo).port
415
416 it.effect("open", () =>
417 Effect.gen(function*() {
418 const server = yield* makeTlsServer
419 const channel = NodeSocket.makeTlsChannel({
420 host: "127.0.0.1",
421 port: serverPort(server),
422 ca: [cert]
423 })
424
425 const output = yield* Stream.make("Hello", "World").pipe(
426 Stream.encodeText,
427 Stream.pipeThroughChannel(channel),
428 Stream.catchIf(
429 (error) => error.reason._tag === "SocketCloseError",
430 () => Stream.empty
431 ),
432 Stream.decodeText(),
433 Stream.mkString
434 )
435 assert.strictEqual(output, "HelloWorld")
436 }))
437
438 it.effect("echoes over the reader and writer", () =>
439 Effect.gen(function*() {
440 const server = yield* makeTlsServer
441 const socket = yield* NodeSocket.makeTls({
442 host: "127.0.0.1",
443 port: serverPort(server),
444 ca: [cert]
445 })
446
447 const received = yield* sendHelloWorld(socket)
448
449 assert.strictEqual(received, "HelloWorld")
450 }))
451
452 it.effect("fails to open against an untrusted certificate", () =>
453 Effect.gen(function*() {
454 const server = yield* makeTlsServer
455 const socket = yield* NodeSocket.makeTls({
456 host: "127.0.0.1",
457 port: serverPort(server)
458 })
459
460 const error = yield* Effect.scoped(Effect.asVoid(socket.reader)).pipe(Effect.flip)
461 assert.strictEqual(error.reason._tag, "SocketOpenError")
462 if (error.reason._tag === "SocketOpenError") {
463 assert.strictEqual(error.reason.kind, "Unknown")
464 assert.strictEqual((error.reason.cause as { code?: string }).code, "DEPTH_ZERO_SELF_SIGNED_CERT")
465 }
466 }))
467
468 it.live("destroys a pending TLS connection on open timeout", () => {
469 const conn = new Tls.TLSSocket(new Net.Socket())
470 const destroy = vi.spyOn(conn, "destroy")
471 const destroySoon = vi.spyOn(conn, "destroySoon").mockImplementation(() => {})
472 vi.mocked(Tls.connect).mockReturnValueOnce(conn)
473
474 return Effect.gen(function*() {
475 const socket = yield* NodeSocket.makeTls({ host: "127.0.0.1", port: 1, openTimeout: 0 })
476 yield* Effect.scoped(Effect.asVoid(socket.reader)).pipe(Effect.flip)
477 assert.isTrue(destroy.mock.calls.length > 0)
478 assert.strictEqual(destroySoon.mock.calls.length, 0)
479 }).pipe(
480 Effect.ensuring(Effect.sync(() => {
481 destroy.mockRestore()
482 destroySoon.mockRestore()
483 conn.destroy()
484 }))
485 )
486 })
487
488 it.effect("echoes through a NodeSocketServer.makeTls server", () =>
489 Effect.gen(function*() {
490 const server = yield* NodeSocketServer.makeTls({ host: "127.0.0.1", port: 0, cert, key })
491 yield* server.run(echoHandler).pipe(Effect.forkScoped)
492
493 const socket = yield* NodeSocket.fromDuplex(Effect.acquireRelease(
494 Effect.callback<Tls.TLSSocket>((resume) => {
495 const conn = Tls.connect({
496 host: "127.0.0.1",
497 port: (server.address as NetAddress.InetAddress).port,
498 ca: [cert]
499 })
500 conn.once("secureConnect", () => resume(Effect.succeed(conn)))
501 }),
502 (conn) => Effect.sync(() => conn.destroy())
503 ))
504
505 const received = yield* sendHelloWorld(socket)
506
507 assert.strictEqual(received, "HelloWorld")
508 }))
509
510 it.effect("upgrades a plain NodeSocketServer connection to TLS", () =>
511 Effect.gen(function*() {
512 const server = yield* NodeSocketServer.make({ host: "127.0.0.1", port: 0 })
513 yield* server.run((socket) => echoHandler(socket, { cert, key: Redacted.make(key) })).pipe(
514 Effect.forkScoped
515 )
516
517 const socket = yield* NodeSocket.makeTls({
518 host: "127.0.0.1",
519 port: (server.address as NetAddress.InetAddress).port,
520 ca: [cert]
521 })
522
523 const received = yield* sendHelloWorld(socket)
524
525 assert.strictEqual(received, "HelloWorld")
526 }))
527
528 it.effect("upgrades a makeNet client connection to TLS", () =>
529 Effect.gen(function*() {
530 const server = yield* NodeSocketServer.makeTls({ host: "127.0.0.1", port: 0, cert, key })
531 yield* server.run(echoHandler).pipe(Effect.forkScoped)
532
533 const socket = yield* NodeSocket.makeNet({
534 host: "127.0.0.1",
535 port: (server.address as NetAddress.InetAddress).port
536 })
537
538 const received = yield* sendHelloWorld(socket, {
539 ca: [cert],
540 rejectUnauthorized: true
541 })
542
543 assert.strictEqual(received, "HelloWorld")
544 }))
545
546 for (const servername of ["mail.example.test", undefined]) {
547 it.live(
548 servername === undefined
549 ? "preserves omitted client TLS upgrade servername"
550 : "forwards explicit client TLS upgrade servername",
551 () =>
552 Effect.gen(function*() {
553 const raw = yield* makePassThrough
554 const socket = yield* NodeSocket.fromDuplex(Effect.succeed(raw))
555 const { upgrade } = yield* socket.reader
556 const cause = new Error("stop before TLS handshake")
557 let received: Tls.ConnectionOptions | undefined
558 vi.mocked(Tls.connect).mockImplementationOnce((options) => {
559 received = options as Tls.ConnectionOptions
560 throw cause
561 })
562 // Use a variable so this runtime regression can run before the public option is added.
563 const options = servername === undefined
564 ? { rejectUnauthorized: true }
565 : { rejectUnauthorized: true, servername }
566 const error = yield* upgrade(options).pipe(Effect.flip)
567
568 assert.strictEqual(error.reason._tag, "SocketUpgradeError")
569 if (error.reason._tag === "SocketUpgradeError") assert.strictEqual(error.reason.cause, cause)
570 assert.strictEqual(received?.socket, raw)
571 assert.strictEqual(received?.rejectUnauthorized, true)
572 assert.strictEqual(received?.servername, servername)
573 })
574 )
575 }
576
577 it.live("requires both key and cert for server TLS upgrades", () =>
578 Effect.gen(function*() {
579 const raw = new Duplex({
580 read() {},
581 write(_chunk, _encoding, callback) {
582 callback()
583 }
584 })
585 const socket = yield* NodeSocket.fromDuplex(Effect.succeed(raw), { tlsServer: true })
586
587 const error = yield* Effect.gen(function*() {
588 const { upgrade } = yield* socket.reader
589 return yield* upgrade().pipe(Effect.flip)
590 }).pipe(Effect.scoped)
591
592 assert.strictEqual(error.reason._tag, "SocketUpgradeError")
593 if (error.reason._tag === "SocketUpgradeError") {
594 assert.strictEqual((error.reason.cause as Error).message, "server TLS upgrade requires both key and cert")
595 }
596 }))
597
598 it.live("rejects incomplete client credentials", () =>
599 Effect.gen(function*() {
600 const raw = new Duplex({
601 read() {},
602 write(_chunk, _encoding, callback) {
603 callback()
604 }
605 })
606 const socket = yield* NodeSocket.fromDuplex(Effect.succeed(raw))
607
608 const error = yield* Effect.gen(function*() {
609 const { upgrade } = yield* socket.reader
610 return yield* upgrade({ cert }).pipe(Effect.flip)
611 }).pipe(Effect.scoped)
612
613 assert.strictEqual(error.reason._tag, "SocketUpgradeError")
614 if (error.reason._tag === "SocketUpgradeError") {
615 assert.strictEqual(
616 (error.reason.cause as Error).message,
617 "TLS upgrade credentials must include both key and cert"
618 )
619 }
620 }))
621
622 it.live("fails pulls after an interrupted TLS upgrade", () =>
623 Effect.gen(function*() {
624 const raw = new Duplex({
625 read() {},
626 write(_chunk, _encoding, callback) {
627 callback()
628 }
629 })
630 const tls = new Duplex({
631 read() {},
632 write(_chunk, _encoding, callback) {
633 callback()
634 }
635 })
636 vi.mocked(Tls.connect).mockReturnValueOnce(tls as Tls.TLSSocket)
637 const socket = yield* NodeSocket.fromDuplex(Effect.succeed(raw))
638
639 const error = yield* Effect.gen(function*() {
640 const { pull, upgrade } = yield* socket.reader
641 const upgradeFiber = yield* upgrade().pipe(Effect.forkChild({ startImmediately: true }))
642 yield* Fiber.interrupt(upgradeFiber)
643 return yield* pull.pipe(Effect.flip, Effect.timeout("1 second"))
644 }).pipe(Effect.scoped)
645
646 assert.strictEqual(error.reason._tag, "SocketCloseError")
647 }))
648
649 it.live("rejects a second TLS upgrade", () =>
650 Effect.gen(function*() {
651 const server = yield* NodeSocketServer.makeTls({ host: "127.0.0.1", port: 0, cert, key })
652 yield* server.run((socket) =>
653 Effect.gen(function*() {
654 yield* Effect.asVoid(socket.reader)
655 return yield* Effect.never
656 }).pipe(Effect.scoped)
657 ).pipe(Effect.forkScoped)
658 const socket = yield* NodeSocket.makeNet({
659 host: "127.0.0.1",
660 port: (server.address as NetAddress.InetAddress).port
661 })
662
663 const error = yield* Effect.gen(function*() {
664 const { upgrade } = yield* socket.reader
665 const options = {
666 cert,
667 key: Redacted.make(key),
668 ca: [cert],
669 rejectUnauthorized: true
670 }
671 yield* upgrade(options)
672 return yield* upgrade(options).pipe(
673 Effect.flip,
674 Effect.timeout("1 second")
675 )
676 }).pipe(Effect.scoped)
677
678 assert.strictEqual(error.reason._tag, "SocketUpgradeError")
679 }))
680
681 it.effect("reports TLS handshake failures as SocketUpgradeError", () =>
682 Effect.gen(function*() {
683 const server = yield* NodeSocketServer.makeTls({ host: "127.0.0.1", port: 0, cert, key })
684 yield* server.run(() => Effect.never).pipe(Effect.forkScoped)
685 const socket = yield* NodeSocket.makeNet({
686 host: "127.0.0.1",
687 port: (server.address as NetAddress.InetAddress).port
688 })
689
690 const error = yield* Effect.gen(function*() {
691 const { upgrade } = yield* socket.reader
692 return yield* upgrade({
693 cert,
694 key: Redacted.make(key),
695 rejectUnauthorized: true
696 }).pipe(Effect.flip)
697 }).pipe(Effect.scoped)
698
699 assert.strictEqual(error.reason._tag, "SocketUpgradeError")
700 if (error.reason._tag === "SocketUpgradeError") {
701 assert.strictEqual((error.reason.cause as { code?: string }).code, "DEPTH_ZERO_SELF_SIGNED_CERT")
702 }
703 }))
704 })
705
706 describe("WebSocket", { concurrent: false }, () => {
707 const url = `ws://localhost:1234`
708
709 it.effect.each(["timeout", "interruption"] as const)(
710 "safely closes a pending ws handshake on %s",
711 (mode) =>
712 Effect.gen(function*() {
713 const accepted = yield* Deferred.make<void>()
714 const connections = new Set<Net.Socket>()
715 const server = yield* Effect.acquireRelease(
716 Effect.sync(() =>
717 Net.createServer((connection) => {
718 connections.add(connection)
719 Deferred.doneUnsafe(accepted, Effect.void)
720 })
721 ),
722 (server) =>
723 Effect.promise(() => {
724 for (const connection of connections) connection.destroy()
725 return new Promise<void>((resolve) => server.close(() => resolve()))
726 })
727 )
728 yield* Effect.promise(() =>
729 new Promise<void>((resolve, reject) => {
730 server.once("error", reject)
731 server.listen(0, "127.0.0.1", resolve)
732 })
733 )
734 const address = server.address()
735 assert.isTrue(typeof address === "object" && address !== null)
736 if (typeof address !== "object" || address === null) return
737
738 const reader = yield* Effect.gen(function*() {
739 const socket = yield* Socket.makeWebSocket(`ws://127.0.0.1:${address.port}`, { openTimeout: 100 })
740 yield* socket.reader
741 }).pipe(
742 Effect.scoped,
743 Effect.provide(NodeWS.layerWebSocketConstructor),
744 Effect.forkChild
745 )
746 // Accept TCP without ever completing the WebSocket upgrade.
747 yield* Deferred.await(accepted)
748 if (mode === "timeout") {
749 yield* TestClock.adjust(100)
750 const error = Option.getOrThrow(Exit.findErrorOption(yield* Fiber.await(reader)))
751 assert.strictEqual(error.reason._tag, "SocketOpenError")
752 if (error.reason._tag === "SocketOpenError") assert.strictEqual(error.reason.kind, "Timeout")
753 } else {
754 yield* Fiber.interrupt(reader)
755 assert.isTrue(Exit.hasInterrupts(yield* Fiber.await(reader)))
756 }
757 // ws emits the handshake-abort error asynchronously after close().
758 // Leave it unhandled by the test so Vitest detects a lifecycle regression.
759 yield* Effect.promise(() => new Promise<void>((resolve) => setImmediate(resolve)))
760 })
761 )
762
763 const makeServer = Effect.acquireRelease(
764 Effect.sync(() => new WS(url)),
765 (ws) =>
766 Effect.sync(() => {
767 ws.close()
768 WS.clean()
769 })
770 )
771
772 it.live("receives messages after handing a paused WebSocket to the reader", () =>
773 Effect.gen(function*() {
774 const serverScope = yield* Scope.make()
775 const connections = new Set<NodeWS.WebSocket>()
776 yield* Effect.addFinalizer(() =>
777 Effect.gen(function*() {
778 for (const connection of connections) connection.terminate()
779 yield* Scope.close(serverScope, Exit.void)
780 })
781 )
782 const received = yield* Deferred.make<ReadonlyArray<Uint8Array | string>>()
783 const server = yield* NodeSocketServer.makeWebSocket({ host: "127.0.0.1", port: 0 }).pipe(
784 Scope.provide(serverScope)
785 )
786 assert.strictEqual(server.address._tag, "InetAddressV4")
787 if (server.address._tag !== "InetAddressV4") return
788
789 yield* server.run((socket) =>
790 Effect.gen(function*() {
791 const native = Option.getOrThrow(yield* Effect.serviceOption(Socket.WebSocket))
792 if (native instanceof NodeWS.WebSocket) connections.add(native)
793 const { pull } = yield* socket.reader
794 const writer = yield* socket.writer
795 yield* writer.write("reader-ready")
796 yield* Deferred.succeed(received, yield* pull)
797 }).pipe(Effect.scoped)
798 ).pipe(Effect.forkIn(serverScope))
799
800 const client = new NodeWS.WebSocket(`ws://127.0.0.1:${server.address.port}`)
801 connections.add(client)
802 const open = new Promise<void>((resolve, reject) => {
803 client.once("open", resolve)
804 client.once("error", reject)
805 })
806 const ready = new Promise<string>((resolve) => {
807 client.once("message", (data) => resolve(data.toString()))
808 })
809
810 yield* Effect.promise(() => open).pipe(Effect.timeout("1 second"))
811 assert.strictEqual(yield* Effect.promise(() => ready).pipe(Effect.timeout("1 second")), "reader-ready")
812 client.send("after-ready")
813
814 assert.deepStrictEqual(
815 yield* Deferred.await(received).pipe(Effect.timeout("1 second")),
816 ["after-ready"]
817 )
818 }))
819
820 it.live.each([
821 { name: "NodeSocket.layerWebSocketConstructor", layer: NodeSocket.layerWebSocketConstructor },
822 { name: "NodeWS.layerWebSocketConstructor", layer: NodeWS.layerWebSocketConstructor }
823 ])("$name passes headers and a subprotocol to the opening handshake", ({ layer }) =>
824 Effect.gen(function*() {
825 const handshake = yield* Deferred.make<{ authorization: string | undefined; protocol: string }>()
826 const server = yield* Effect.acquireRelease(
827 Effect.callback<NodeWS.WebSocketServer>((resume) => {
828 const server = new NodeWS.WebSocketServer({ host: "127.0.0.1", port: 0 })
829 server.once("listening", () => resume(Effect.succeed(server)))
830 server.once("error", (error) => resume(Effect.die(error)))
831 server.on("connection", (client, request) => {
832 Deferred.doneUnsafe(
833 handshake,
834 Effect.succeed({
835 authorization: request.headers.authorization,
836 protocol: client.protocol
837 })
838 )
839 })
840 }),
841 (server) =>
842 Effect.promise(() => {
843 for (const client of server.clients) client.terminate()
844 return new Promise<void>((resolve) => server.close(() => resolve()))
845 })
846 )
847 const address = server.address()
848 assert.isTrue(typeof address === "object" && address !== null)
849 if (typeof address !== "object" || address === null) return
850 const options = {
851 protocols: "graphql-transport-ws",
852 headers: { Authorization: "Bearer test" }
853 }
854 const socket = yield* Socket.makeWebSocket(`ws://127.0.0.1:${address.port}`, options)
855 yield* socket.reader
856 assert.deepStrictEqual(yield* Deferred.await(handshake).pipe(Effect.timeout("1 second")), {
857 authorization: "Bearer test",
858 protocol: "graphql-transport-ws"
859 })
860 }).pipe(Effect.provide(layer)))
861
862 it.effect("passes headers to the opening handshake", () =>
863 Effect.gen(function*() {
864 const authorization = yield* Deferred.make<string | undefined>()
865 const server = yield* NodeSocketServer.makeWebSocket({
866 host: "127.0.0.1",
867 port: 0,
868 verifyClient: ({ req }: Parameters<NodeWS.VerifyClientCallbackSync>[0]) => {
869 Deferred.doneUnsafe(authorization, Effect.succeed(req.headers.authorization))
870 return true
871 }
872 })
873 assert.strictEqual(server.address._tag, "InetAddressV4")
874 if (server.address._tag !== "InetAddressV4") return
875 const port = server.address.port
876
877 const makeWebSocket = yield* Socket.WebSocketConstructor
878 const client = yield* Effect.acquireRelease(
879 Effect.sync(() =>
880 makeWebSocket(`ws://127.0.0.1:${port}`, {
881 headers: { Authorization: "Bearer test" }
882 })
883 ),
884 (client) => Effect.sync(() => client.close())
885 )
886 client.addEventListener("error", () => {})
887
888 assert.strictEqual(yield* Deferred.await(authorization).pipe(Effect.timeout("1 second")), "Bearer test")
889 }).pipe(Effect.provide(NodeWS.layerWebSocketConstructor)))
890
891 it.effect("fails TLS upgrade with SocketUpgradeError", () =>
892 Effect.gen(function*() {
893 yield* Effect.asVoid(makeServer)
894 const socket = yield* Socket.makeWebSocket(Effect.succeed(url))
895 const { upgrade } = yield* socket.reader
896 const error = yield* upgrade({ cert, key: Redacted.make(key) }).pipe(Effect.flip)
897 assert.strictEqual(error.reason._tag, "SocketUpgradeError")
898 }).pipe(
899 Effect.provideService(Socket.WebSocketConstructor, (url) => new globalThis.WebSocket(url))
900 ))
901
902 it.effect("messages", () =>
903 Effect.gen(function*() {
904 const server = yield* makeServer
905 const socket = yield* Socket.makeWebSocket(Effect.succeed(url))
906 const messages = yield* Queue.unbounded<Uint8Array>()
907 const fiber = yield* Effect.gen(function*() {
908 const pull = yield* Socket.readerBytes(socket)
909 while (true) {
910 yield* Queue.offerAll(messages, yield* pull)
911 }
912 }).pipe(Effect.scoped, Effect.forkChild)
913 yield* Effect.gen(function*() {
914 const writer = yield* socket.writer
915 yield* writer.write(new TextEncoder().encode("Hello"))
916 yield* writer.write(new TextEncoder().encode("World"))
917 }).pipe(Effect.scoped)
918 assert.deepStrictEqual(yield* Effect.promise(() => server.nextMessage), new TextEncoder().encode("Hello"))
919 assert.deepStrictEqual(yield* Effect.promise(() => server.nextMessage), new TextEncoder().encode("World"))
920
921 server.send("Right back at you!")
922 let message = yield* Queue.take(messages)
923 assert.deepStrictEqual(message, new TextEncoder().encode("Right back at you!"))
924
925 server.send(new Blob(["A Blob message"]))
926 message = yield* Queue.take(messages)
927 assert.deepStrictEqual(message, new TextEncoder().encode("A Blob message"))
928
929 server.close()
930 const exit = yield* Fiber.await(fiber)
931 assert.isTrue(Exit.isFailure(exit))
932 if (Exit.isFailure(exit)) {
933 const failure = exit.cause.reasons[0]
934 assert.strictEqual(failure._tag, "Fail")
935 if (failure._tag === "Fail" && Socket.SocketError.is(failure.error)) {
936 assert.strictEqual(failure.error.reason._tag, "SocketCloseError")
937 } else {
938 assert.fail("expected a SocketError")
939 }
940 }
941 }).pipe(
942 Effect.provideService(Socket.WebSocketConstructor, (url) => new globalThis.WebSocket(url))
943 ))
944
945 it.effect("clean closes are errors", () =>
946 Effect.gen(function*() {
947 const server = yield* makeServer
948 const socket = yield* Socket.makeWebSocket(Effect.succeed(url))
949 const fiber = yield* Effect.gen(function*() {
950 const { pull } = yield* socket.reader
951 while (true) {
952 yield* pull
953 }
954 }).pipe(Effect.scoped, Effect.forkChild)
955
956 yield* Effect.promise(() => server.connected)
957 server.close({ code: 1000, reason: "done", wasClean: true })
958
959 const exit = yield* Effect.exit(Fiber.join(fiber))
960 assert.isTrue(exit._tag === "Failure")
961 if (exit._tag === "Failure") {
962 const failure = exit.cause.reasons[0]
963 if (failure._tag === "Fail" && failure.error instanceof Socket.SocketError) {
964 assert.strictEqual(failure.error.reason._tag, "SocketCloseError")
965 if (failure.error.reason._tag === "SocketCloseError") {
966 assert.strictEqual(failure.error.reason.code, 1000)
967 assert.strictEqual(failure.error.reason.closeReason, "done")
968 }
969 } else {
970 assert.fail("expected a SocketError")
971 }
972 }
973 }).pipe(
974 Effect.provideService(Socket.WebSocketConstructor, (url) => new globalThis.WebSocket(url))
975 ))
976
977 it.effect("reports send errors as SocketError", () =>
978 Effect.gen(function*() {
979 class ThrowingWebSocket extends EventTarget {
980 readonly readyState = globalThis.WebSocket.OPEN
981
982 close(): void {}
983
984 send(): void {
985 throw new Error("send failed")
986 }
987 }
988 const webSocket = new ThrowingWebSocket()
989 const socket = yield* Socket.makeWebSocket(Effect.succeed(url)).pipe(
990 Effect.provideService(
991 Socket.WebSocketConstructor,
992 () => webSocket
993 )
994 )
995 const exit = yield* Effect.scoped(Effect.gen(function*() {
996 yield* Effect.asVoid(socket.reader)
997 const writer = yield* socket.writer
998 return yield* Effect.exit(writer.write(new Uint8Array([1])))
999 }))
1000 assert.strictEqual(exit._tag, "Failure")
1001 if (exit._tag === "Failure") {
1002 assert.strictEqual(exit.cause.reasons[0]?._tag, "Fail")
1003 const reason = exit.cause.reasons[0]
1004 if (reason?._tag === "Fail") {
1005 assert.isTrue(Socket.SocketError.is(reason.error))
1006 assert.strictEqual(reason.error.reason._tag, "SocketWriteError")
1007 }
1008 }
1009 }))
1010 })
1011
1012 describe("TransformStream", () => {
1013 it.effect("works", () =>
1014 Effect.gen(function*() {
1015 const readable = Stream.make("A", "B", "C").pipe(
1016 Stream.tap(() => Effect.sleep(50)),
1017 Stream.toReadableStream()
1018 )
1019 const decoder = new TextDecoder()
1020 const chunks: Array<string> = []
1021 const writable = new WritableStream<Uint8Array>({
1022 write(chunk) {
1023 chunks.push(decoder.decode(chunk))
1024 }
1025 })
1026
1027 const socket = yield* Socket.fromTransformStream(
1028 Effect.succeed({
1029 readable,
1030 writable
1031 })
1032 )
1033 yield* socket.writer.pipe(
1034 Effect.tap((writer) =>
1035 writer.write("Hello").pipe(
1036 Effect.andThen(writer.write("World"))
1037 )
1038 ),
1039 Effect.scoped,
1040 Effect.forkChild
1041 )
1042 const received: Array<string> = []
1043 yield* Effect.gen(function*() {
1044 const pull = yield* Socket.readerString(socket)
1045 while (true) {
1046 const chunk = yield* pull
1047 for (const data of chunk) {
1048 received.push(data)
1049 }
1050 }
1051 }).pipe(
1052 Effect.scoped,
1053 Effect.catchReason("SocketError", "SocketCloseError", () => Effect.void)
1054 )
1055
1056 assert.deepStrictEqual(chunks, ["Hello", "World"])
1057 assert.deepStrictEqual(received, ["A", "B", "C"])
1058 }))
1059
1060 it.effect("reports writable stream rejection as SocketError", () =>
1061 Effect.gen(function*() {
1062 const socket = yield* Socket.fromTransformStream(Effect.succeed({
1063 readable: new ReadableStream<Uint8Array>({}),
1064 writable: new WritableStream<Uint8Array>({
1065 write: () => Promise.reject(new Error("write failed"))
1066 })
1067 }))
1068 const exit = yield* Effect.scoped(Effect.gen(function*() {
1069 yield* Effect.asVoid(socket.reader)
1070 const writer = yield* socket.writer
1071 return yield* Effect.exit(writer.write(new Uint8Array([1])))
1072 }))
1073 assert.strictEqual(exit._tag, "Failure")
1074 if (exit._tag === "Failure") {
1075 assert.strictEqual(exit.cause.reasons[0]?._tag, "Fail")
1076 const reason = exit.cause.reasons[0]
1077 if (reason?._tag === "Fail") {
1078 assert.isTrue(Socket.SocketError.is(reason.error))
1079 assert.strictEqual(reason.error.reason._tag, "SocketWriteError")
1080 }
1081 }
1082 }))
1083 })
1084 })