The best way to control Claude Code, Codex and more from any computer or phone
| 1 | import * as DenoSocket from "@effect/platform-deno/DenoSocket" |
| 2 | import { assert, describe, it } from "@effect/vitest" |
| 3 | import { Deferred, Effect, Fiber, Queue } from "effect" |
| 4 | import * as Socket from "effect/socket/Socket" |
| 5 | import * as Stream from "effect/Stream" |
| 6 | |
| 7 | const ca = Deno.readTextFileSync(new URL("./fixtures/tls/ca.pem", import.meta.url)) |
| 8 | const cert = Deno.readTextFileSync(new URL("./fixtures/tls/cert.pem", import.meta.url)) |
| 9 | const key = Deno.readTextFileSync(new URL("./fixtures/tls/key.pem", import.meta.url)) |
| 10 | |
| 11 | const makeTcpServer = Effect.acquireRelease( |
| 12 | Effect.sync(() => Deno.listen({ hostname: "127.0.0.1", port: 0 })), |
| 13 | (listener) => Effect.sync(() => listener.close()) |
| 14 | ) |
| 15 | |
| 16 | const makeTlsServer = Effect.acquireRelease( |
| 17 | Effect.sync(() => Deno.listenTls({ hostname: "127.0.0.1", port: 0, cert, key })), |
| 18 | (listener) => Effect.sync(() => listener.close()) |
| 19 | ) |
| 20 | |
| 21 | const runTlsEchoServer = (listener: Deno.TlsListener) => |
| 22 | Effect.tryPromise({ |
| 23 | try: () => listener.accept().then((conn) => conn.readable.pipeTo(conn.writable)), |
| 24 | catch: (cause) => cause |
| 25 | }).pipe(Effect.ignore) |
| 26 | |
| 27 | const makeTempDir = Effect.acquireRelease( |
| 28 | Effect.promise(() => Deno.makeTempDir()), |
| 29 | (path) => Effect.promise(() => Deno.remove(path, { recursive: true })) |
| 30 | ) |
| 31 | |
| 32 | const runEchoServer = (listener: Deno.Listener) => |
| 33 | Effect.forever( |
| 34 | Effect.promise(() => listener.accept().then((conn) => conn.readable.pipeTo(conn.writable))) |
| 35 | ) |
| 36 | |
| 37 | const makeTestConn = (options?: { |
| 38 | readonly data?: Uint8Array | undefined |
| 39 | readonly pendingRead?: boolean | undefined |
| 40 | readonly closeReadableOnCloseWrite?: boolean | undefined |
| 41 | readonly setNoDelay?: ((value?: boolean) => void) | undefined |
| 42 | readonly setKeepAlive?: ((value?: boolean) => void) | undefined |
| 43 | }) => { |
| 44 | let controller!: ReadableStreamDefaultController<Uint8Array> |
| 45 | let readableClosed = false |
| 46 | let closeWrites = 0 |
| 47 | const readable = new ReadableStream<Uint8Array>({ |
| 48 | start(value) { |
| 49 | controller = value |
| 50 | if (options?.data) value.enqueue(options.data) |
| 51 | if (options?.pendingRead !== true) { |
| 52 | readableClosed = true |
| 53 | value.close() |
| 54 | } |
| 55 | } |
| 56 | }) |
| 57 | const conn = { |
| 58 | readable, |
| 59 | writable: new WritableStream<Uint8Array>(), |
| 60 | read: () => Promise.resolve(null), |
| 61 | write: (data: Uint8Array) => Promise.resolve(data.length), |
| 62 | close() { |
| 63 | if (readableClosed) return |
| 64 | readableClosed = true |
| 65 | controller.close() |
| 66 | }, |
| 67 | closeWrite() { |
| 68 | closeWrites++ |
| 69 | if (options?.closeReadableOnCloseWrite && !readableClosed) { |
| 70 | readableClosed = true |
| 71 | controller.close() |
| 72 | } |
| 73 | return Promise.resolve() |
| 74 | }, |
| 75 | ref() {}, |
| 76 | unref() {}, |
| 77 | localAddr: { transport: "tcp", hostname: "127.0.0.1", port: 0 }, |
| 78 | remoteAddr: { transport: "tcp", hostname: "127.0.0.1", port: 0 }, |
| 79 | [Symbol.dispose]() { |
| 80 | this.close() |
| 81 | }, |
| 82 | ...(options?.setNoDelay ? { setNoDelay: options.setNoDelay } : {}), |
| 83 | ...(options?.setKeepAlive ? { setKeepAlive: options.setKeepAlive } : {}) |
| 84 | } as Deno.Conn |
| 85 | return { conn, closeWrites: () => closeWrites } |
| 86 | } |
| 87 | |
| 88 | const replaceDenoConnect = ( |
| 89 | connect: (options: Deno.ConnectOptions | Deno.UnixConnectOptions) => Promise<Deno.Conn> |
| 90 | ) => |
| 91 | Effect.acquireRelease( |
| 92 | Effect.sync(() => { |
| 93 | const descriptor = Object.getOwnPropertyDescriptor(Deno, "connect")! |
| 94 | Object.defineProperty(Deno, "connect", { ...descriptor, value: connect }) |
| 95 | return descriptor |
| 96 | }), |
| 97 | (descriptor) => Effect.sync(() => Object.defineProperty(Deno, "connect", descriptor)) |
| 98 | ) |
| 99 | |
| 100 | // Tests that replace Deno APIs must not overlap native connection tests. |
| 101 | describe("DenoSocket", { concurrent: false }, () => { |
| 102 | for (const servername of ["mail.example.test", undefined]) { |
| 103 | it.effect( |
| 104 | servername === undefined |
| 105 | ? "preserves remote hostname when client TLS upgrade servername is omitted" |
| 106 | : "forwards explicit client TLS upgrade servername as hostname", |
| 107 | () => |
| 108 | Effect.gen(function*() { |
| 109 | const { conn } = makeTestConn({ pendingRead: true }) |
| 110 | const cause = new Error("stop before TLS handshake") |
| 111 | let receivedConn: Deno.TcpConn | undefined |
| 112 | let received: Deno.StartTlsOptions | undefined |
| 113 | yield* Effect.acquireRelease( |
| 114 | Effect.sync(() => { |
| 115 | const descriptor = Object.getOwnPropertyDescriptor(Deno, "startTls")! |
| 116 | Object.defineProperty(Deno, "startTls", { |
| 117 | ...descriptor, |
| 118 | value: (raw: Deno.TcpConn, options: Deno.StartTlsOptions) => { |
| 119 | receivedConn = raw |
| 120 | received = options |
| 121 | return Promise.reject(cause) |
| 122 | } |
| 123 | }) |
| 124 | return descriptor |
| 125 | }), |
| 126 | (descriptor) => Effect.sync(() => Object.defineProperty(Deno, "startTls", descriptor)) |
| 127 | ) |
| 128 | const socket = yield* DenoSocket.fromConn(Effect.succeed(conn)) |
| 129 | const { upgrade } = yield* socket.reader |
| 130 | // Use a variable so this runtime regression can run before the public option is added. |
| 131 | const options = servername === undefined |
| 132 | ? { rejectUnauthorized: true } |
| 133 | : { rejectUnauthorized: true, servername } |
| 134 | const error = yield* upgrade(options).pipe(Effect.flip) |
| 135 | |
| 136 | assert.strictEqual(error.reason._tag, "SocketUpgradeError") |
| 137 | if (error.reason._tag === "SocketUpgradeError") assert.strictEqual(error.reason.cause, cause) |
| 138 | assert.strictEqual(receivedConn, conn) |
| 139 | assert.strictEqual(received?.unsafelyDisableHostnameVerification, false) |
| 140 | assert.strictEqual(received?.hostname, servername ?? (conn.remoteAddr as Deno.NetAddr).hostname) |
| 141 | }) |
| 142 | ) |
| 143 | } |
| 144 | |
| 145 | it.effect("upgrades a TCP reader to TLS", () => |
| 146 | Effect.gen(function*() { |
| 147 | const listener = yield* makeTlsServer |
| 148 | yield* runTlsEchoServer(listener).pipe(Effect.forkScoped) |
| 149 | const address = listener.addr as Deno.NetAddr |
| 150 | const socket = yield* DenoSocket.makeTcp({ hostname: address.hostname, port: address.port }) |
| 151 | const writer = yield* socket.writer |
| 152 | const { pull, upgrade } = yield* socket.reader |
| 153 | |
| 154 | yield* upgrade({ ca: [ca] }) |
| 155 | yield* writer.writeAll(["Hello", "World"]) |
| 156 | |
| 157 | const decoder = new TextDecoder() |
| 158 | let output = "" |
| 159 | while (output.length < 10) { |
| 160 | for (const chunk of yield* pull) output += typeof chunk === "string" ? chunk : decoder.decode(chunk) |
| 161 | } |
| 162 | assert.strictEqual(output, "HelloWorld") |
| 163 | })) |
| 164 | |
| 165 | it.effect("reports TLS handshake failures as SocketUpgradeError", () => |
| 166 | Effect.gen(function*() { |
| 167 | const listener = yield* makeTlsServer |
| 168 | yield* runTlsEchoServer(listener).pipe(Effect.forkScoped) |
| 169 | const address = listener.addr as Deno.NetAddr |
| 170 | const socket = yield* DenoSocket.makeTcp({ hostname: address.hostname, port: address.port }) |
| 171 | const { pull, upgrade } = yield* socket.reader |
| 172 | |
| 173 | const error = yield* upgrade().pipe(Effect.flip) |
| 174 | assert.strictEqual(error.reason._tag, "SocketUpgradeError") |
| 175 | if (error.reason._tag === "SocketUpgradeError") assert.instanceOf(error.reason.cause, Error) |
| 176 | assert.strictEqual(yield* pull.pipe(Effect.flip), error) |
| 177 | })) |
| 178 | |
| 179 | it.effect("echoes over TCP", () => |
| 180 | Effect.gen(function*() { |
| 181 | const listener = yield* makeTcpServer |
| 182 | yield* runEchoServer(listener).pipe(Effect.forkScoped) |
| 183 | const address = listener.addr as Deno.NetAddr |
| 184 | |
| 185 | const output = yield* Stream.make("Hello", "World").pipe( |
| 186 | Stream.encodeText, |
| 187 | Stream.pipeThroughChannel(DenoSocket.makeTcpChannel({ hostname: address.hostname, port: address.port })), |
| 188 | Stream.catchIf( |
| 189 | (error) => error.reason._tag === "SocketCloseError", |
| 190 | () => Stream.empty |
| 191 | ), |
| 192 | Stream.decodeText(), |
| 193 | Stream.mkString |
| 194 | ) |
| 195 | |
| 196 | assert.strictEqual(output, "HelloWorld") |
| 197 | })) |
| 198 | |
| 199 | it.effect("keeps reading after the write side closes", () => |
| 200 | Effect.gen(function*() { |
| 201 | const listener = yield* makeTcpServer |
| 202 | const address = listener.addr as Deno.NetAddr |
| 203 | const writeClosed = yield* Deferred.make<void>() |
| 204 | const encoder = new TextEncoder() |
| 205 | const decoder = new TextDecoder() |
| 206 | |
| 207 | yield* Effect.gen(function*() { |
| 208 | const conn = yield* Effect.promise(() => listener.accept()) |
| 209 | const chunks: Array<string> = [] |
| 210 | const read: Effect.Effect<void> = Effect.suspend(() => { |
| 211 | const buffer = new Uint8Array(5) |
| 212 | return Effect.promise(() => conn.read(buffer)).pipe( |
| 213 | Effect.flatMap((size) => { |
| 214 | if (size === null) return Effect.void |
| 215 | chunks.push(decoder.decode(buffer.subarray(0, size))) |
| 216 | return read |
| 217 | }) |
| 218 | ) |
| 219 | }) |
| 220 | yield* read |
| 221 | assert.strictEqual(chunks.join(""), "Hello") |
| 222 | yield* Deferred.succeed(writeClosed, undefined) |
| 223 | const writer = conn.writable.getWriter() |
| 224 | yield* Effect.promise(() => writer.ready.then(() => writer.write(encoder.encode("Hello")))) |
| 225 | writer.releaseLock() |
| 226 | yield* Effect.promise(() => conn.closeWrite()) |
| 227 | }).pipe(Effect.forkScoped) |
| 228 | |
| 229 | const socket = yield* DenoSocket.makeTcp({ hostname: address.hostname, port: address.port }) |
| 230 | const messages = yield* Queue.unbounded<Uint8Array>() |
| 231 | const runFiber = yield* Effect.gen(function*() { |
| 232 | const pull = yield* Socket.readerBytes(socket) |
| 233 | while (true) { |
| 234 | yield* Queue.offerAll(messages, yield* pull) |
| 235 | } |
| 236 | }).pipe(Effect.scoped, Effect.catchReason("SocketError", "SocketCloseError", () => Effect.void), Effect.forkChild) |
| 237 | yield* Effect.scoped( |
| 238 | socket.writer.pipe(Effect.flatMap((writer) => writer.write(encoder.encode("Hello")))) |
| 239 | ) |
| 240 | yield* Deferred.await(writeClosed) |
| 241 | |
| 242 | assert.deepStrictEqual(yield* Queue.take(messages), encoder.encode("Hello")) |
| 243 | yield* Fiber.join(runFiber) |
| 244 | })) |
| 245 | |
| 246 | it.effect("half-closes an empty channel input", () => |
| 247 | Effect.gen(function*() { |
| 248 | const listener = yield* makeTcpServer |
| 249 | const address = listener.addr as Deno.NetAddr |
| 250 | const encoder = new TextEncoder() |
| 251 | |
| 252 | yield* Effect.gen(function*() { |
| 253 | const conn = yield* Effect.promise(() => listener.accept()) |
| 254 | assert.strictEqual(yield* Effect.promise(() => conn.read(new Uint8Array(1))), null) |
| 255 | const writer = conn.writable.getWriter() |
| 256 | yield* Effect.promise(() => writer.write(encoder.encode("Closed"))) |
| 257 | writer.releaseLock() |
| 258 | yield* Effect.promise(() => conn.closeWrite()) |
| 259 | }).pipe(Effect.forkScoped) |
| 260 | |
| 261 | const output = yield* Stream.empty.pipe( |
| 262 | Stream.pipeThroughChannel(DenoSocket.makeTcpChannel({ hostname: address.hostname, port: address.port })), |
| 263 | Stream.catchIf( |
| 264 | (error) => error.reason._tag === "SocketCloseError", |
| 265 | () => Stream.empty |
| 266 | ), |
| 267 | Stream.decodeText(), |
| 268 | Stream.mkString |
| 269 | ) |
| 270 | |
| 271 | assert.strictEqual(output, "Closed") |
| 272 | })) |
| 273 | |
| 274 | it.effect("releases the writer after the peer has closed the connection", () => |
| 275 | Effect.gen(function*() { |
| 276 | const listener = yield* makeTcpServer |
| 277 | const address = listener.addr as Deno.NetAddr |
| 278 | yield* Effect.promise(() => listener.accept().then((conn) => conn.close())).pipe(Effect.forkScoped) |
| 279 | |
| 280 | const socket = yield* DenoSocket.makeTcp({ hostname: address.hostname, port: address.port }) |
| 281 | const { pull } = yield* socket.reader |
| 282 | yield* socket.writer |
| 283 | yield* Effect.forever(pull).pipe(Effect.ignore) |
| 284 | })) |
| 285 | |
| 286 | it.effect("does not carry a consumed half-close into a second acquisition", () => |
| 287 | Effect.gen(function*() { |
| 288 | const encoder = new TextEncoder() |
| 289 | const first = makeTestConn({ pendingRead: true, closeReadableOnCloseWrite: true }) |
| 290 | const second = makeTestConn({ data: encoder.encode("Second") }) |
| 291 | const connections = [first.conn, second.conn] |
| 292 | let index = 0 |
| 293 | const socket = yield* DenoSocket.fromConn(Effect.sync(() => connections[index++]!)) |
| 294 | const opened = yield* Deferred.make<void>() |
| 295 | |
| 296 | const firstRun = yield* Effect.gen(function*() { |
| 297 | const { pull } = yield* socket.reader |
| 298 | yield* Deferred.succeed(opened, undefined) |
| 299 | while (true) { |
| 300 | yield* pull |
| 301 | } |
| 302 | }).pipe(Effect.scoped, Effect.catchReason("SocketError", "SocketCloseError", () => Effect.void), Effect.forkChild) |
| 303 | yield* Deferred.await(opened) |
| 304 | yield* Effect.scoped(socket.writer) |
| 305 | yield* Fiber.join(firstRun) |
| 306 | |
| 307 | const received: Array<Uint8Array> = [] |
| 308 | yield* Effect.gen(function*() { |
| 309 | const pull = yield* Socket.readerBytes(socket) |
| 310 | while (true) { |
| 311 | const chunk = yield* pull |
| 312 | for (const data of chunk) { |
| 313 | received.push(data) |
| 314 | } |
| 315 | } |
| 316 | }).pipe(Effect.scoped, Effect.catchReason("SocketError", "SocketCloseError", () => Effect.void)) |
| 317 | |
| 318 | assert.deepStrictEqual(received, [encoder.encode("Second")]) |
| 319 | assert.strictEqual(first.closeWrites(), 1) |
| 320 | assert.strictEqual(second.closeWrites(), 0) |
| 321 | })) |
| 322 | |
| 323 | it.effect("maps connection refusal to SocketOpenError", () => |
| 324 | Effect.gen(function*() { |
| 325 | const listener = Deno.listen({ hostname: "127.0.0.1", port: 0 }) |
| 326 | const address = listener.addr as Deno.NetAddr |
| 327 | listener.close() |
| 328 | const socket = yield* DenoSocket.makeTcp({ hostname: address.hostname, port: address.port }) |
| 329 | |
| 330 | const error = yield* Effect.scoped(Effect.asVoid(socket.reader)).pipe(Effect.flip) |
| 331 | |
| 332 | assert.instanceOf(error, Socket.SocketError) |
| 333 | assert.strictEqual(error.reason._tag, "SocketOpenError") |
| 334 | if (error.reason._tag === "SocketOpenError") { |
| 335 | assert.strictEqual(error.reason.kind, "Unknown") |
| 336 | assert.instanceOf(error.reason.cause, Deno.errors.ConnectionRefused) |
| 337 | } |
| 338 | })) |
| 339 | |
| 340 | it.effect("applies TCP tuning options and ignores them for Unix", () => |
| 341 | Effect.gen(function*() { |
| 342 | const noDelay: Array<boolean | undefined> = [] |
| 343 | const keepAlive: Array<boolean | undefined> = [] |
| 344 | const tcp = makeTestConn({ |
| 345 | setNoDelay: (value) => noDelay.push(value), |
| 346 | setKeepAlive: (value) => keepAlive.push(value) |
| 347 | }) |
| 348 | const unix = makeTestConn() |
| 349 | const connections = [tcp.conn, unix.conn] |
| 350 | const connectOptions: Array<Deno.ConnectOptions | Deno.UnixConnectOptions> = [] |
| 351 | let index = 0 |
| 352 | yield* replaceDenoConnect((options) => { |
| 353 | connectOptions.push(options) |
| 354 | return Promise.resolve(connections[index++]!) |
| 355 | }) |
| 356 | |
| 357 | const tcpSocket = yield* DenoSocket.makeTcp({ port: 1, noDelay: false, keepAlive: true }) |
| 358 | yield* Effect.scoped(Effect.asVoid(tcpSocket.reader)) |
| 359 | const unixSocket = yield* DenoSocket.makeTcp({ |
| 360 | transport: "unix", |
| 361 | path: "/unused.sock", |
| 362 | noDelay: true, |
| 363 | keepAlive: false |
| 364 | }) |
| 365 | yield* Effect.scoped(Effect.asVoid(unixSocket.reader)) |
| 366 | |
| 367 | assert.deepStrictEqual(noDelay, [false]) |
| 368 | assert.deepStrictEqual(keepAlive, [true]) |
| 369 | assert.deepStrictEqual(connectOptions, [ |
| 370 | { port: 1 }, |
| 371 | { transport: "unix", path: "/unused.sock" } |
| 372 | ]) |
| 373 | })) |
| 374 | |
| 375 | it.effect("echoes over Unix sockets", () => |
| 376 | Effect.gen(function*() { |
| 377 | const directory = yield* makeTempDir |
| 378 | const path = `${directory}/echo.sock` |
| 379 | const listener = yield* Effect.acquireRelease( |
| 380 | Effect.sync(() => Deno.listen({ transport: "unix", path })), |
| 381 | (listener) => Effect.sync(() => listener.close()) |
| 382 | ) |
| 383 | yield* runEchoServer(listener).pipe(Effect.forkScoped) |
| 384 | |
| 385 | const output = yield* Stream.make("Hello", "Unix").pipe( |
| 386 | Stream.encodeText, |
| 387 | Stream.pipeThroughChannel(DenoSocket.makeTcpChannel({ transport: "unix", path })), |
| 388 | Stream.catchIf( |
| 389 | (error) => error.reason._tag === "SocketCloseError", |
| 390 | () => Stream.empty |
| 391 | ), |
| 392 | Stream.decodeText(), |
| 393 | Stream.mkString |
| 394 | ) |
| 395 | |
| 396 | assert.strictEqual(output, "HelloUnix") |
| 397 | })) |
| 398 | |
| 399 | it.effect("rejects TLS upgrades on Unix sockets without disrupting the connection", () => |
| 400 | Effect.gen(function*() { |
| 401 | const directory = yield* makeTempDir |
| 402 | const path = `${directory}/upgrade.sock` |
| 403 | const listener = yield* Effect.acquireRelease( |
| 404 | Effect.sync(() => Deno.listen({ transport: "unix", path })), |
| 405 | (listener) => Effect.sync(() => listener.close()) |
| 406 | ) |
| 407 | yield* runEchoServer(listener).pipe(Effect.forkScoped) |
| 408 | |
| 409 | const socket = yield* DenoSocket.makeTcp({ transport: "unix", path }) |
| 410 | const writer = yield* socket.writer |
| 411 | const { pull, upgrade } = yield* socket.reader |
| 412 | |
| 413 | const error = yield* upgrade().pipe(Effect.flip) |
| 414 | assert.strictEqual(error.reason._tag, "SocketUpgradeError") |
| 415 | |
| 416 | yield* writer.write("HelloUnix") |
| 417 | const [received] = yield* pull |
| 418 | assert.strictEqual(new TextDecoder().decode(received as Uint8Array), "HelloUnix") |
| 419 | })) |
| 420 | |
| 421 | it.effect("uses Deno's native WebSocket", () => |
| 422 | Effect.gen(function*() { |
| 423 | const server = yield* Effect.acquireRelease( |
| 424 | Effect.sync(() => |
| 425 | Deno.serve( |
| 426 | { hostname: "127.0.0.1", port: 0, onListen: () => {} }, |
| 427 | (request) => { |
| 428 | const { response, socket } = Deno.upgradeWebSocket(request) |
| 429 | socket.onmessage = (event) => socket.send(event.data) |
| 430 | return response |
| 431 | } |
| 432 | ) |
| 433 | ), |
| 434 | (server) => Effect.promise(() => server.shutdown()) |
| 435 | ) |
| 436 | const address = server.addr as Deno.NetAddr |
| 437 | const messages = yield* Queue.unbounded<Uint8Array>() |
| 438 | |
| 439 | yield* Effect.gen(function*() { |
| 440 | const socket = yield* Socket.Socket |
| 441 | const runFiber = yield* Effect.gen(function*() { |
| 442 | const pull = yield* Socket.readerBytes(socket) |
| 443 | while (true) { |
| 444 | yield* Queue.offerAll(messages, yield* pull) |
| 445 | } |
| 446 | }).pipe( |
| 447 | Effect.scoped, |
| 448 | Effect.catchReason("SocketError", "SocketCloseError", () => Effect.void), |
| 449 | Effect.forkChild |
| 450 | ) |
| 451 | const writer = yield* socket.writer |
| 452 | yield* writer.write("Hello WebSocket") |
| 453 | |
| 454 | assert.deepStrictEqual(yield* Queue.take(messages), new TextEncoder().encode("Hello WebSocket")) |
| 455 | yield* Fiber.interrupt(runFiber) |
| 456 | }).pipe( |
| 457 | Effect.scoped, |
| 458 | Effect.provide(DenoSocket.layerWebSocket(`ws://${address.hostname}:${address.port}`)) |
| 459 | ) |
| 460 | })) |
| 461 | |
| 462 | it.effect("adapts a TransformStream", () => |
| 463 | Effect.gen(function*() { |
| 464 | const readable = Stream.make("A", "B", "C").pipe( |
| 465 | Stream.tap(() => Effect.sleep(50)), |
| 466 | Stream.toReadableStream() |
| 467 | ) |
| 468 | const decoder = new TextDecoder() |
| 469 | const chunks: Array<string> = [] |
| 470 | const writable = new WritableStream<Uint8Array>({ |
| 471 | write(chunk) { |
| 472 | chunks.push(decoder.decode(chunk)) |
| 473 | } |
| 474 | }) |
| 475 | |
| 476 | const socket = yield* Socket.fromTransformStream( |
| 477 | Effect.succeed({ readable, writable }) |
| 478 | ) |
| 479 | yield* socket.writer.pipe( |
| 480 | Effect.tap((writer) => writer.write("Hello").pipe(Effect.andThen(writer.write("World")))), |
| 481 | Effect.scoped, |
| 482 | Effect.forkChild |
| 483 | ) |
| 484 | const received: Array<string> = [] |
| 485 | yield* Effect.gen(function*() { |
| 486 | const pull = yield* Socket.readerString(socket) |
| 487 | while (true) { |
| 488 | const chunk = yield* pull |
| 489 | for (const data of chunk) { |
| 490 | received.push(data) |
| 491 | } |
| 492 | } |
| 493 | }).pipe(Effect.scoped, Effect.catchReason("SocketError", "SocketCloseError", () => Effect.void)) |
| 494 | |
| 495 | assert.deepStrictEqual(chunks, ["Hello", "World"]) |
| 496 | assert.deepStrictEqual(received, ["A", "B", "C"]) |
| 497 | })) |
| 498 | }) |