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

main
ts 498 lines 19.2 KB
Raw
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 })