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

main
ts 196 lines 7.05 KB
Raw
1 /**
2 * Native Deno socket layers for Effect Cluster runners.
3 *
4 * The main `layer` builds a sharding layer for socket transport, choosing
5 * serialization, runner health checks, runner storage, message storage, and
6 * optional client-only mode from the supplied options. Unlike Node sockets,
7 * Deno connections have no native idle-timeout option, so peer connections use
8 * only the one-second open timeout.
9 *
10 * @stability unstable
11 * @since 4.0.0
12 */
13 import * as K8sHttpClient from "effect/cluster/K8sHttpClient"
14 import * as MessageStorage from "effect/cluster/MessageStorage"
15 import * as RunnerHealth from "effect/cluster/RunnerHealth"
16 import * as Runners from "effect/cluster/Runners"
17 import * as RunnerStorage from "effect/cluster/RunnerStorage"
18 import type { Sharding } from "effect/cluster/Sharding"
19 import * as ShardingConfig from "effect/cluster/ShardingConfig"
20 import * as SocketRunner from "effect/cluster/SocketRunner"
21 import * as SqlMessageStorage from "effect/cluster/SqlMessageStorage"
22 import * as SqlRunnerStorage from "effect/cluster/SqlRunnerStorage"
23 import type * as Config from "effect/Config"
24 import * as Digest from "effect/crypto/Digest"
25 import * as Effect from "effect/Effect"
26 import * as FileSystem from "effect/FileSystem"
27 import * as Layer from "effect/Layer"
28 import * as Option from "effect/Option"
29 import * as RpcClient from "effect/rpc/RpcClient"
30 import * as RpcSerialization from "effect/rpc/RpcSerialization"
31 import { Socket } from "effect/socket/Socket"
32 import type * as SocketServer from "effect/socket/SocketServer"
33 import type { SqlClient } from "effect/sql/SqlClient"
34 import * as DenoFileSystem from "./DenoFileSystem.ts"
35 import * as DenoHttpClient from "./DenoHttpClient.ts"
36 import * as DenoSocket from "./DenoSocket.ts"
37 import * as DenoSocketServer from "./DenoSocketServer.ts"
38
39 /**
40 * Provides the cluster `RpcClientProtocol` using native Deno TCP sockets.
41 *
42 * @stability unstable
43 * @category layers
44 * @since 4.0.0
45 */
46 export const layerClientProtocol: Layer.Layer<
47 Runners.RpcClientProtocol,
48 never,
49 RpcSerialization.RpcSerialization
50 > = Layer.effect(Runners.RpcClientProtocol)(
51 Effect.gen(function*() {
52 const serialization = yield* RpcSerialization.RpcSerialization
53 return {
54 codecFor: serialization.codecFor,
55 make: Effect.fnUntraced(function*(address) {
56 const socket = yield* DenoSocket.makeTcp({
57 openTimeout: 1000,
58 hostname: address.host,
59 port: address.port
60 })
61 return yield* RpcClient.makeProtocolSocket().pipe(
62 Effect.provideService(Socket, socket),
63 Effect.provideService(RpcSerialization.RpcSerialization, serialization)
64 )
65 }, Effect.orDie)
66 }
67 })
68 )
69
70 /**
71 * Provides the socket server used by cluster runners, listening on
72 * `ShardingConfig.runnerListenAddress` or `runnerAddress`.
73 *
74 * @stability unstable
75 * @category layers
76 * @since 4.0.0
77 */
78 export const layerSocketServer: Layer.Layer<
79 SocketServer.SocketServer,
80 SocketServer.SocketServerError,
81 ShardingConfig.ShardingConfig
82 > = Effect.gen(function*() {
83 const config = yield* ShardingConfig.ShardingConfig
84 const listenAddress = Option.orElse(config.runnerListenAddress, () => config.runnerAddress)
85 if (Option.isNone(listenAddress)) {
86 return yield* Effect.die("layerSocketServer: ShardingConfig.runnerListenAddress is None")
87 }
88 return DenoSocketServer.layer({
89 host: listenAddress.value.host,
90 port: listenAddress.value.port
91 })
92 }).pipe(Layer.unwrap)
93
94 /**
95 * Creates Deno socket cluster layers, configuring serialization, storage,
96 * runner health, and optional client-only mode.
97 *
98 * @stability unstable
99 * @category layers
100 * @since 4.0.0
101 */
102 export const layer = <
103 const ClientOnly extends boolean = false,
104 const Storage extends "local" | "sql" | "byo" = never
105 >(
106 options?: {
107 readonly serialization?: "binary" | "ndjson" | undefined
108 readonly serializationMaxBufferSize?: number | "unbounded" | undefined
109 readonly clientOnly?: ClientOnly | undefined
110 readonly storage?: Storage | undefined
111 readonly runnerHealth?: "ping" | "k8s" | undefined
112 readonly runnerHealthK8s?: {
113 readonly namespace?: string | undefined
114 readonly labelSelector?: string | undefined
115 } | undefined
116 readonly shardingConfig?: Partial<ShardingConfig.ShardingConfig["Service"]> | undefined
117 }
118 ): ClientOnly extends true ? Layer.Layer<
119 Sharding | Runners.Runners | ("byo" extends Storage ? never : MessageStorage.MessageStorage),
120 Config.ConfigError,
121 "local" extends Storage ? never
122 : "byo" extends Storage ? (MessageStorage.MessageStorage | RunnerStorage.RunnerStorage)
123 : SqlClient
124 > :
125 Layer.Layer<
126 Sharding | Runners.Runners | ("byo" extends Storage ? never : MessageStorage.MessageStorage),
127 SocketServer.SocketServerError | Config.ConfigError,
128 "local" extends Storage ? never
129 : "byo" extends Storage ? (MessageStorage.MessageStorage | RunnerStorage.RunnerStorage)
130 : SqlClient
131 > =>
132 {
133 const layer: Layer.Layer<any, any, any> = options?.clientOnly
134 ? Layer.provide(SocketRunner.layerClientOnly, layerClientProtocol)
135 : Layer.provide(SocketRunner.layer, [layerSocketServer, layerClientProtocol])
136
137 const runnerHealth: Layer.Layer<any, any, any> = options?.clientOnly
138 ? Layer.empty as any
139 : options?.runnerHealth === "k8s"
140 ? RunnerHealth.layerK8s(options.runnerHealthK8s).pipe(
141 Layer.provide(layerK8sHttpClient)
142 )
143 : RunnerHealth.layerPing.pipe(
144 Layer.provide(Runners.layerRpc),
145 Layer.provide(layerClientProtocol)
146 )
147
148 return layer.pipe(
149 Layer.provide(runnerHealth),
150 Layer.provideMerge(
151 options?.storage === "local"
152 ? MessageStorage.layerNoop
153 : options?.storage === "byo"
154 ? Layer.empty
155 : SqlMessageStorage.layer.pipe(Layer.provide(Digest.layerWebCrypto))
156 ),
157 Layer.provide(
158 options?.storage === "local"
159 ? RunnerStorage.layerMemory
160 : options?.storage === "byo"
161 ? Layer.empty
162 : Layer.orDie(SqlRunnerStorage.layer)
163 ),
164 Layer.provide(ShardingConfig.layerFromEnv(options?.shardingConfig)),
165 Layer.provide(
166 options?.serialization === "ndjson"
167 ? RpcSerialization.layerNdjsonWith({ maxBufferSize: options?.serializationMaxBufferSize })
168 : RpcSerialization.layerSchemaBinary({
169 maxFrameSize: options?.serializationMaxBufferSize
170 })
171 )
172 ) as any
173 }
174
175 /**
176 * Layer that provides `K8sHttpClient`, using a scoped native Deno HTTP client
177 * with the Kubernetes service-account CA certificate when it is available.
178 *
179 * @stability unstable
180 * @category layers
181 * @since 4.0.0
182 */
183 export const layerK8sHttpClient: Layer.Layer<K8sHttpClient.K8sHttpClient> = K8sHttpClient.layer.pipe(
184 Layer.provide(Layer.unwrap(Effect.gen(function*() {
185 const fs = yield* FileSystem.FileSystem
186 const caCertOption = yield* fs.readFileString("/var/run/secrets/kubernetes.io/serviceaccount/ca.crt").pipe(
187 Effect.option
188 )
189 if (Option.isNone(caCertOption)) {
190 return DenoHttpClient.layer
191 }
192
193 return DenoHttpClient.layerOptions({ caCerts: [caCertOption.value] })
194 }))),
195 Layer.provide(DenoFileSystem.layer)
196 )