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

main
ts 285 lines 10 KB
Raw
1 import * as DenoRedis from "@effect/platform-deno/DenoRedis"
2 import { assert, it } from "@effect/vitest"
3 import { RedisContainer } from "@testcontainers/redis"
4 import { Deferred, Effect, Exit, Fiber, Layer, Queue, Schema } from "effect"
5 import { CircuitBreaker, PersistedQueue, Persistence, Redis } from "effect/persistence"
6 import { TestClock } from "effect/testing"
7 import * as CircuitBreakerRedisTest from "../../../effect/test/persistence/CircuitBreakerRedisTest.ts"
8 import * as CircuitBreakerTest from "../../../effect/test/persistence/CircuitBreakerTest.ts"
9 import * as PersistedCacheTest from "../../../effect/test/persistence/PersistedCacheTest.ts"
10 import * as PersistedQueueTest from "../../../effect/test/persistence/PersistedQueueTest.ts"
11
12 const RedisLayer = Layer.unwrap(
13 Effect.gen(function*() {
14 const container = yield* Effect.acquireRelease(
15 Effect.promise(() => new RedisContainer("redis:alpine").start()),
16 (container) => Effect.promise(() => container.stop())
17 )
18 return DenoRedis.layer({
19 url: `redis://${container.getHost()}:${container.getMappedPort(6379)}`
20 })
21 }).pipe(
22 Effect.catchCause(() => Effect.fail(new PersistedCacheTest.TransientError()))
23 )
24 )
25
26 PersistedCacheTest.suite(
27 "DenoRedis",
28 Persistence.layerRedis.pipe(Layer.provide(RedisLayer))
29 )
30
31 PersistedQueueTest.suite(
32 "DenoRedis",
33 // short intervals so the periodic reset runs while the suite's takes are
34 // in flight
35 PersistedQueue.layerStoreRedis({
36 pollInterval: "50 millis",
37 lockRefreshInterval: "100 millis"
38 }).pipe(Layer.provide(RedisLayer))
39 )
40
41 CircuitBreakerTest.suite(
42 "DenoRedis",
43 (options) => CircuitBreaker.layerStoreRedis(options).pipe(Layer.provide(RedisLayer)),
44 // the store reads Redis TIME, so time only moves on the wall clock
45 (duration) => TestClock.withLive(Effect.sleep(duration))
46 )
47
48 CircuitBreakerRedisTest.suite("DenoRedis", RedisLayer)
49
50 const PersistedQueueRedisLayer = Layer.mergeAll(
51 RedisLayer,
52 PersistedQueue.layer.pipe(
53 Layer.provideMerge(
54 PersistedQueue.layerStoreRedis().pipe(Layer.provide(RedisLayer))
55 )
56 )
57 )
58
59 it.layer(PersistedQueueRedisLayer, { timeout: "30 seconds" })(
60 "PersistedQueue (DenoRedis)",
61 (it) => {
62 it.effect("receives published messages", () =>
63 Effect.gen(function*() {
64 const redis = yield* Redis.Redis
65 const subscription = yield* redis.subscribe("effect-test")
66
67 const subscribers = yield* redis.send<number>("PUBLISH", "effect-test", "hello")
68 assert.strictEqual(subscribers, 1)
69
70 assert.deepStrictEqual(yield* Queue.take(subscription), {
71 channel: "effect-test",
72 message: "hello"
73 })
74 }))
75
76 it.effect("runs blocking reads on a reserved connection without delaying shared commands", () =>
77 Effect.gen(function*() {
78 const redis = yield* Redis.Redis
79 const read = yield* redis.reserve.pipe(
80 Effect.flatMap((connection) =>
81 connection.send("XREAD", "BLOCK", "5000", "STREAMS", "effect-test-reserve", "$")
82 ),
83 Effect.scoped,
84 Effect.forkChild
85 )
86 // XREAD with "$" only sees entries added after it starts blocking
87 yield* redis.send<string>("CLIENT", "LIST").pipe(
88 Effect.repeat({ until: (clients) => clients.includes("cmd=xread") })
89 )
90 yield* redis.send("XADD", "effect-test-reserve", "*", "key", "value")
91
92 assert.include(JSON.stringify(yield* Fiber.join(read)), "value")
93 }))
94
95 it.effect("fails a reserved command when its connection drops instead of replaying it", () =>
96 Effect.gen(function*() {
97 const redis = yield* Redis.Redis
98 const list = "effect-test-reserve-drop"
99 const exit = yield* Effect.scoped(Effect.gen(function*() {
100 const connection = yield* redis.reserve
101 const id = yield* connection.send<number>("CLIENT", "ID")
102 const pop = yield* connection.send("BLPOP", list, "0").pipe(Effect.forkChild)
103 yield* redis.send<string>("CLIENT", "LIST").pipe(
104 Effect.repeat({
105 until: (clients) =>
106 clients.split("\n").some((client) => client.startsWith(`id=${id} `) && client.includes("cmd=blpop"))
107 })
108 )
109 yield* redis.send("CLIENT", "KILL", "ID", String(id))
110 yield* redis.send("LPUSH", list, "item")
111 return yield* Fiber.await(pop)
112 }))
113
114 assert.isTrue(Exit.isFailure(exit))
115 assert.strictEqual(yield* redis.send<number>("LLEN", list), 1)
116 }))
117
118 it.effect("moves exhausted elements to the failed list", () =>
119 Effect.gen(function*() {
120 const redis = yield* DenoRedis.DenoRedis
121 const queueName = "test-redis-failed"
122
123 const queue = yield* PersistedQueue.make({
124 name: queueName,
125 schema: RedisItem,
126 maxAttempts: 1
127 })
128 const id = yield* queue.offer({ n: 42 })
129 const error = yield* queue.take(() => Effect.fail("boom")).pipe(Effect.flip)
130 assert.strictEqual(error, "boom")
131
132 const failed = yield* redis.use((client) => client.lrange(`effectq:${queueName}:failed`, 0, -1))
133 assert.strictEqual(failed.length, 1)
134 const failedItem = JSON.parse(failed[0])
135 assert.strictEqual(failedItem.id, id)
136 assert.deepStrictEqual(failedItem.element, { n: 42 })
137 assert.strictEqual(failedItem.attempts, 1)
138
139 const pending = yield* redis.use((client) => client.hlen(`effectq:${queueName}:pending`))
140 assert.strictEqual(pending, 0)
141 }))
142 }
143 )
144
145 it.effect("closes the connection when interrupted during acquisition", () =>
146 Effect.gen(function*() {
147 const listener = yield* makeListener
148 const authReceived = yield* Deferred.make<void>()
149 const sendAuthReply = yield* Deferred.make<void>()
150 const server = yield* Effect.gen(function*() {
151 const connection = yield* accept(listener)
152 yield* read(connection)
153 yield* Deferred.succeed(authReceived, void 0)
154 yield* Deferred.await(sendAuthReply)
155 yield* write(connection, "+OK\r\n")
156 return yield* read(connection)
157 }).pipe(Effect.forkChild)
158
159 const port = (listener.addr as Deno.NetAddr).port
160 const layerFiber = yield* Layer.build(DenoRedis.layer({
161 url: `redis://:secret@127.0.0.1:${port}`
162 })).pipe(Effect.forkChild({ startImmediately: true }))
163
164 yield* Deferred.await(authReceived)
165 const interruptFiber = yield* Fiber.interrupt(layerFiber).pipe(
166 Effect.forkChild({ startImmediately: true })
167 )
168 yield* Deferred.succeed(sendAuthReply, void 0)
169 yield* Fiber.join(interruptFiber)
170
171 assert.isNull(yield* Fiber.join(server))
172 }))
173
174 it.effect("uses the URL username for two-argument AUTH", () =>
175 Effect.gen(function*() {
176 const listener = yield* makeListener
177 const server = yield* Effect.gen(function*() {
178 const connection = yield* accept(listener)
179 const request = yield* read(connection)
180 yield* write(connection, "+OK\r\n")
181 return request
182 }).pipe(Effect.forkChild)
183
184 const port = (listener.addr as Deno.NetAddr).port
185 yield* Layer.build(DenoRedis.layer({
186 url: `redis://alice:secret@127.0.0.1:${port}`,
187 password: undefined
188 }))
189
190 assert.strictEqual(
191 yield* Fiber.join(server),
192 "*3\r\n$4\r\nAUTH\r\n$5\r\nalice\r\n$6\r\nsecret\r\n"
193 )
194 }))
195
196 it.effect("decodes URL authority credentials once", () =>
197 Effect.gen(function*() {
198 const listener = yield* makeListener
199 const server = yield* Effect.gen(function*() {
200 const connection = yield* accept(listener)
201 const request = yield* read(connection)
202 yield* write(connection, "+OK\r\n")
203 return request
204 }).pipe(Effect.forkChild)
205
206 const port = (listener.addr as Deno.NetAddr).port
207 yield* Layer.build(DenoRedis.layer({
208 url: `redis://app%3A%2540:p%40ss%2525@127.0.0.1:${port}`
209 }))
210
211 assert.strictEqual(
212 yield* Fiber.join(server),
213 "*3\r\n$4\r\nAUTH\r\n$7\r\napp:%40\r\n$7\r\np@ss%25\r\n"
214 )
215 }))
216
217 it.effect("does not decode a query-string password twice", () =>
218 Effect.gen(function*() {
219 const listener = yield* makeListener
220 const server = yield* Effect.gen(function*() {
221 const connection = yield* accept(listener)
222 const request = yield* read(connection)
223 yield* write(connection, "+OK\r\n")
224 return request
225 }).pipe(Effect.forkChild)
226
227 const port = (listener.addr as Deno.NetAddr).port
228 yield* Layer.build(DenoRedis.layer({
229 url: `redis://alice@127.0.0.1:${port}/?password=p%2540ss`
230 }))
231
232 assert.strictEqual(
233 yield* Fiber.join(server),
234 "*3\r\n$4\r\nAUTH\r\n$5\r\nalice\r\n$6\r\np%40ss\r\n"
235 )
236 }))
237
238 it.effect("prefers explicit credentials over URL credentials", () =>
239 Effect.gen(function*() {
240 const listener = yield* makeListener
241 const server = yield* Effect.gen(function*() {
242 const connection = yield* accept(listener)
243 const request = yield* read(connection)
244 yield* write(connection, "+OK\r\n")
245 return request
246 }).pipe(Effect.forkChild)
247
248 const port = (listener.addr as Deno.NetAddr).port
249 yield* Layer.build(DenoRedis.layer({
250 url: `redis://alice:secret@127.0.0.1:${port}`,
251 username: "bob",
252 password: "other"
253 }))
254
255 assert.strictEqual(
256 yield* Fiber.join(server),
257 "*3\r\n$4\r\nAUTH\r\n$3\r\nbob\r\n$5\r\nother\r\n"
258 )
259 }))
260
261 const RedisItem = Schema.Struct({
262 n: Schema.Number
263 })
264
265 const encoder = new TextEncoder()
266 const decoder = new TextDecoder()
267
268 const makeListener = Effect.acquireRelease(
269 Effect.sync(() => Deno.listen({ hostname: "127.0.0.1", port: 0 })),
270 (listener) => Effect.sync(() => listener.close())
271 )
272
273 const accept = (listener: Deno.TcpListener) =>
274 Effect.acquireRelease(
275 Effect.promise(() => listener.accept()),
276 (connection) => Effect.sync(() => connection.close())
277 )
278
279 const read = (connection: Deno.TcpConn) =>
280 Effect.promise(() => {
281 const buffer = new Uint8Array(256)
282 return connection.read(buffer).then((size) => size === null ? null : decoder.decode(buffer.subarray(0, size)))
283 })
284
285 const write = (connection: Deno.TcpConn, value: string) => Effect.promise(() => connection.write(encoder.encode(value)))