@devries-cameron20 / t3code Mirror · read-only
Fork 0

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

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 04:45 UTC

main
ts 188 lines 6.5 KB
Raw
1 /**
2 * Node.js 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. This module also
7 * re-exports the shared socket client and server protocol layers, and provides
8 * Kubernetes-aware Undici dispatcher and HTTP client layers for runner health
9 * checks.
10 *
11 * @stability unstable
12 * @since 4.0.0
13 */
14 import { layerClientProtocol, layerSocketServer } from "@effect/platform-node-shared/NodeClusterSocket"
15 import * as K8sHttpClient from "effect/cluster/K8sHttpClient"
16 import * as MessageStorage from "effect/cluster/MessageStorage"
17 import * as RunnerHealth from "effect/cluster/RunnerHealth"
18 import * as Runners from "effect/cluster/Runners"
19 import * as RunnerStorage from "effect/cluster/RunnerStorage"
20 import type { Sharding } from "effect/cluster/Sharding"
21 import * as ShardingConfig from "effect/cluster/ShardingConfig"
22 import * as SocketRunner from "effect/cluster/SocketRunner"
23 import * as SqlMessageStorage from "effect/cluster/SqlMessageStorage"
24 import * as SqlRunnerStorage from "effect/cluster/SqlRunnerStorage"
25 import type { ConfigError } from "effect/Config"
26 import * as Effect from "effect/Effect"
27 import * as FileSystem from "effect/FileSystem"
28 import * as Layer from "effect/Layer"
29 import * as RpcSerialization from "effect/rpc/RpcSerialization"
30 import type * as SocketServer from "effect/socket/SocketServer"
31 import type { SqlClient } from "effect/sql/SqlClient"
32 import * as NodeCrypto from "./NodeCrypto.ts"
33 import * as NodeFileSystem from "./NodeFileSystem.ts"
34 import * as NodeHttpClient from "./NodeHttpClient.ts"
35
36 export {
37 /**
38 * Provides the cluster `RpcClientProtocol` using the shared socket client
39 * implementation.
40 *
41 * @stability unstable
42 * @category re-exports
43 * @since 4.0.0
44 */
45 layerClientProtocol,
46 /**
47 * Provides the socket server used by Node cluster runners through the shared
48 * socket server implementation.
49 *
50 * @stability unstable
51 * @category re-exports
52 * @since 4.0.0
53 */
54 layerSocketServer
55 }
56
57 /**
58 * Builds the Node cluster socket sharding layer, configuring RPC
59 * serialization, message storage, runner health checks, and optional
60 * client-only mode.
61 *
62 * @stability unstable
63 * @category layers
64 * @since 4.0.0
65 */
66 export const layer = <
67 const ClientOnly extends boolean = false,
68 const Storage extends "local" | "sql" | "byo" = never
69 >(
70 options?: {
71 readonly serialization?: "binary" | "ndjson" | undefined
72 readonly serializationMaxBufferSize?: number | "unbounded" | undefined
73 readonly clientOnly?: ClientOnly | undefined
74 readonly storage?: Storage | undefined
75 readonly runnerHealth?: "ping" | "k8s" | undefined
76 readonly runnerHealthK8s?: {
77 readonly namespace?: string | undefined
78 readonly labelSelector?: string | undefined
79 } | undefined
80 readonly shardingConfig?: Partial<ShardingConfig.ShardingConfig["Service"]> | undefined
81 }
82 ): ClientOnly extends true ? Layer.Layer<
83 Sharding | Runners.Runners | ("byo" extends Storage ? never : MessageStorage.MessageStorage),
84 ConfigError,
85 "local" extends Storage ? never
86 : "byo" extends Storage ? (MessageStorage.MessageStorage | RunnerStorage.RunnerStorage)
87 : SqlClient
88 > :
89 Layer.Layer<
90 Sharding | Runners.Runners | ("byo" extends Storage ? never : MessageStorage.MessageStorage),
91 SocketServer.SocketServerError | ConfigError,
92 "local" extends Storage ? never
93 : "byo" extends Storage ? (MessageStorage.MessageStorage | RunnerStorage.RunnerStorage)
94 : SqlClient
95 > =>
96 {
97 const layer: Layer.Layer<any, any, any> = options?.clientOnly
98 // client only
99 ? Layer.provide(SocketRunner.layerClientOnly, layerClientProtocol)
100 // with server
101 : Layer.provide(SocketRunner.layer, [layerSocketServer, layerClientProtocol])
102
103 const runnerHealth: Layer.Layer<any, any, any> = options?.clientOnly
104 ? Layer.empty as any
105 : options?.runnerHealth === "k8s"
106 ? RunnerHealth.layerK8s(options.runnerHealthK8s).pipe(
107 Layer.provide(layerK8sHttpClient)
108 )
109 : RunnerHealth.layerPing.pipe(
110 Layer.provide(Runners.layerRpc),
111 Layer.provide(layerClientProtocol)
112 )
113
114 return layer.pipe(
115 Layer.provide(runnerHealth),
116 Layer.provideMerge(
117 options?.storage === "local"
118 ? MessageStorage.layerNoop
119 : options?.storage === "byo"
120 ? Layer.empty
121 : SqlMessageStorage.layer.pipe(Layer.provide(NodeCrypto.layerDigest))
122 ),
123 Layer.provide(
124 options?.storage === "local"
125 ? RunnerStorage.layerMemory
126 : options?.storage === "byo"
127 ? Layer.empty
128 : Layer.orDie(SqlRunnerStorage.layer)
129 ),
130 Layer.provide(ShardingConfig.layerFromEnv(options?.shardingConfig)),
131 Layer.provide(
132 options?.serialization === "ndjson"
133 ? RpcSerialization.layerNdjsonWith({ maxBufferSize: options?.serializationMaxBufferSize })
134 : RpcSerialization.layerSchemaBinary({
135 maxFrameSize: options?.serializationMaxBufferSize
136 })
137 )
138 ) as any
139 }
140
141 /**
142 * Provides an Undici dispatcher for Kubernetes API calls, using the service
143 * account CA certificate when it is available and falling back to the default
144 * dispatcher otherwise.
145 *
146 * @stability unstable
147 * @category layers
148 * @since 4.0.0
149 */
150 export const layerDispatcherK8s: Layer.Layer<NodeHttpClient.Dispatcher> = Layer.effect(NodeHttpClient.Dispatcher)(
151 Effect.gen(function*() {
152 const fs = yield* FileSystem.FileSystem
153 const caCertOption = yield* fs.readFileString("/var/run/secrets/kubernetes.io/serviceaccount/ca.crt").pipe(
154 Effect.option
155 )
156 if (caCertOption._tag === "Some") {
157 const Undici = yield* Effect.promise(() => import("./Undici.ts"))
158 return yield* Effect.acquireRelease(
159 Effect.sync(() =>
160 new Undici.Agent({
161 connect: {
162 ca: caCertOption.value
163 }
164 })
165 ),
166 (agent) => Effect.promise(() => agent.destroy())
167 )
168 }
169
170 return yield* NodeHttpClient.makeDispatcher
171 })
172 ).pipe(
173 Layer.provide(NodeFileSystem.layer)
174 )
175
176 /**
177 * Provides a `K8sHttpClient` backed by the Undici HTTP client and the
178 * Kubernetes-aware dispatcher.
179 *
180 * @stability unstable
181 * @category layers
182 * @since 4.0.0
183 */
184 export const layerK8sHttpClient: Layer.Layer<K8sHttpClient.K8sHttpClient> = K8sHttpClient.layer.pipe(
185 Layer.provide(Layer.fresh(NodeHttpClient.layerUndiciNoDispatcher)),
186 Layer.provide(layerDispatcherK8s),
187 Layer.provide(NodeFileSystem.layer)
188 )