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

main
ts 163 lines 6.35 KB
Raw
1 /**
2 * Node.js HTTP and WebSocket layers for Effect Cluster runners.
3 *
4 * The main `layer` builds a sharding layer for HTTP or WebSocket transport,
5 * choosing serialization, runner health checks, runner storage, message
6 * storage, and optional client-only mode from the supplied options.
7 * `layerHttpServer` provides the Node HTTP server used by cluster runners, and
8 * this module re-exports the Kubernetes HTTP client layer used by runner health
9 * checks.
10 *
11 * @stability unstable
12 * @since 4.0.0
13 */
14 import * as HttpRunner from "effect/cluster/HttpRunner"
15 import * as MessageStorage from "effect/cluster/MessageStorage"
16 import * as RunnerHealth from "effect/cluster/RunnerHealth"
17 import * as Runners from "effect/cluster/Runners"
18 import * as RunnerStorage from "effect/cluster/RunnerStorage"
19 import type { Sharding } from "effect/cluster/Sharding"
20 import * as ShardingConfig from "effect/cluster/ShardingConfig"
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 Effect from "effect/Effect"
25 import type * as Etag from "effect/http/Etag"
26 import type { HttpPlatform } from "effect/http/HttpPlatform"
27 import type { HttpServer } from "effect/http/HttpServer"
28 import type { ServeError } from "effect/http/HttpServerError"
29 import * as Layer from "effect/Layer"
30 import * as Option from "effect/Option"
31 import * as RpcSerialization from "effect/rpc/RpcSerialization"
32 import type { SqlClient } from "effect/sql/SqlClient"
33 import { http } from "./internal/http.ts"
34 import { layerK8sHttpClient } from "./NodeClusterSocket.ts"
35 import * as NodeCrypto from "./NodeCrypto.ts"
36 import * as NodeHttpClient from "./NodeHttpClient.ts"
37 import * as NodeHttpServer from "./NodeHttpServer.ts"
38 import type { NodeServices } from "./NodeServices.ts"
39 import * as NodeSocket from "./NodeSocket.ts"
40
41 export {
42 /**
43 * Provides the Kubernetes HTTP client layer used by Kubernetes runner health checks.
44 *
45 * @stability unstable
46 * @category re-exports
47 * @since 4.0.0
48 */
49 layerK8sHttpClient
50 } from "./NodeClusterSocket.ts"
51
52 /**
53 * Builds the Node cluster HTTP/WebSocket sharding layer, configuring runner
54 * transport, RPC serialization, message storage, runner health checks, and
55 * optional client-only mode.
56 *
57 * @stability unstable
58 * @category layers
59 * @since 4.0.0
60 */
61 export const layer = <
62 const ClientOnly extends boolean = false,
63 const Storage extends "local" | "sql" | "byo" = never
64 >(options: {
65 readonly transport: "http" | "websocket"
66 readonly serialization?: "binary" | "ndjson" | undefined
67 readonly serializationMaxBufferSize?: number | "unbounded" | undefined
68 readonly clientOnly?: ClientOnly | undefined
69 readonly storage?: Storage | undefined
70 readonly runnerHealth?: "ping" | "k8s" | undefined
71 readonly runnerHealthK8s?: {
72 readonly namespace?: string | undefined
73 readonly labelSelector?: string | undefined
74 } | undefined
75 readonly shardingConfig?: Partial<ShardingConfig.ShardingConfig["Service"]> | undefined
76 }): ClientOnly extends true ? Layer.Layer<
77 Sharding | Runners.Runners | ("byo" extends Storage ? never : MessageStorage.MessageStorage),
78 Config.ConfigError,
79 "local" extends Storage ? never
80 : "byo" extends Storage ? (MessageStorage.MessageStorage | RunnerStorage.RunnerStorage)
81 : SqlClient
82 > :
83 Layer.Layer<
84 Sharding | Runners.Runners | ("byo" extends Storage ? never : MessageStorage.MessageStorage),
85 ServeError | Config.ConfigError,
86 "local" extends Storage ? never
87 : "byo" extends Storage ? (MessageStorage.MessageStorage | RunnerStorage.RunnerStorage)
88 : SqlClient
89 > =>
90 {
91 const layer: Layer.Layer<any, any, any> = options.clientOnly
92 // client only
93 ? options.transport === "http"
94 ? Layer.provide(HttpRunner.layerHttpClientOnly, NodeHttpClient.layerUndici)
95 : Layer.provide(HttpRunner.layerWebsocketClientOnly, NodeSocket.layerWebSocketConstructor)
96 // with server
97 : options.transport === "http"
98 ? Layer.provide(HttpRunner.layerHttp, [layerHttpServer, NodeHttpClient.layerUndici])
99 : Layer.provide(HttpRunner.layerWebsocket, [layerHttpServer, NodeSocket.layerWebSocketConstructor])
100
101 const runnerHealth: Layer.Layer<any, any, any> = options?.clientOnly
102 ? Layer.empty as any
103 : options?.runnerHealth === "k8s"
104 ? RunnerHealth.layerK8s(options.runnerHealthK8s).pipe(
105 Layer.provide(layerK8sHttpClient)
106 )
107 : RunnerHealth.layerPing.pipe(
108 Layer.provide(Runners.layerRpc),
109 Layer.provide(
110 options.transport === "http"
111 ? HttpRunner.layerClientProtocolHttpDefault.pipe(Layer.provide(NodeHttpClient.layerUndici))
112 : HttpRunner.layerClientProtocolWebsocketDefault.pipe(Layer.provide(NodeSocket.layerWebSocketConstructor))
113 )
114 )
115
116 return layer.pipe(
117 Layer.provide(runnerHealth),
118 Layer.provideMerge(
119 options?.storage === "local"
120 ? MessageStorage.layerNoop
121 : options?.storage === "byo"
122 ? Layer.empty
123 : SqlMessageStorage.layer.pipe(Layer.provide(NodeCrypto.layerDigest))
124 ),
125 Layer.provide(
126 options?.storage === "local"
127 ? RunnerStorage.layerMemory
128 : options?.storage === "byo"
129 ? Layer.empty
130 : Layer.orDie(SqlRunnerStorage.layer)
131 ),
132 Layer.provide(ShardingConfig.layerFromEnv(options?.shardingConfig)),
133 Layer.provide(
134 options?.serialization === "ndjson"
135 ? RpcSerialization.layerNdjsonWith({ maxBufferSize: options.serializationMaxBufferSize })
136 : RpcSerialization.layerSchemaBinary({ maxFrameSize: options.serializationMaxBufferSize })
137 )
138 ) as any
139 }
140
141 /**
142 * Provides the HTTP server and Node HTTP services used by cluster runners,
143 * listening on `ShardingConfig.runnerListenAddress` or `runnerAddress`.
144 *
145 * @stability unstable
146 * @category layers
147 * @since 4.0.0
148 */
149 export const layerHttpServer: Layer.Layer<
150 | HttpPlatform
151 | Etag.Generator
152 | NodeServices
153 | HttpServer,
154 ServeError,
155 ShardingConfig.ShardingConfig
156 > = Effect.gen(function*() {
157 const config = yield* ShardingConfig.ShardingConfig
158 const listenAddress = Option.orElse(config.runnerListenAddress, () => config.runnerAddress)
159 if (Option.isNone(listenAddress)) {
160 return yield* Effect.die("NodeClusterHttp.layerHttpServer: ShardingConfig.runnerAddress is None")
161 }
162 return NodeHttpServer.layer(http.createServer, listenAddress.value)
163 }).pipe(Layer.unwrap)