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

main
ts 182 lines 7.12 KB
Raw
1 /**
2 * Bun HTTP and WebSocket layers for Effect Cluster runners.
3 *
4 * `layerHttpServer` provides the Bun HTTP server used by cluster runners. The
5 * main `layer` builds a sharding layer for HTTP or WebSocket transport,
6 * choosing serialization, runner health checks, runner storage, message
7 * storage, and optional client-only mode from the supplied options.
8 *
9 * @stability unstable
10 * @since 4.0.0
11 */
12 import * as NodeCrypto from "@effect/platform-node-shared/NodeCrypto"
13 import * as HttpRunner from "effect/cluster/HttpRunner"
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 SqlMessageStorage from "effect/cluster/SqlMessageStorage"
21 import * as SqlRunnerStorage from "effect/cluster/SqlRunnerStorage"
22 import type * as Config from "effect/Config"
23 import * as Effect from "effect/Effect"
24 import type * as Etag from "effect/http/Etag"
25 import * as FetchHttpClient from "effect/http/FetchHttpClient"
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 { layerK8sHttpClient } from "./BunClusterSocket.ts"
34 import * as BunFileSystem from "./BunFileSystem.ts"
35 import * as BunHttpServer from "./BunHttpServer.ts"
36 import type { BunServices } from "./BunServices.ts"
37 import * as BunSocket from "./BunSocket.ts"
38
39 export {
40 /**
41 * Layer that provides a Kubernetes HTTP client for runner health checks.
42 *
43 * @stability unstable
44 * @category re-exports
45 * @since 4.0.0
46 */
47 layerK8sHttpClient
48 }
49
50 /**
51 * Layer that provides a Bun HTTP server for cluster runners.
52 *
53 * @stability unstable
54 * @category layers
55 * @since 4.0.0
56 */
57 export const layerHttpServer: Layer.Layer<
58 | HttpPlatform
59 | Etag.Generator
60 | BunServices
61 | HttpServer,
62 ServeError,
63 ShardingConfig.ShardingConfig
64 > = Effect.gen(function*() {
65 const config = yield* ShardingConfig.ShardingConfig
66 const listenAddress = Option.orElse(config.runnerListenAddress, () => config.runnerAddress)
67 if (Option.isNone(listenAddress)) {
68 return yield* Effect.die("BunClusterHttp.layerHttpServer: ShardingConfig.runnerAddress is None")
69 }
70 return BunHttpServer.layer({ hostname: listenAddress.value.host, port: listenAddress.value.port })
71 }).pipe(Layer.unwrap)
72
73 /**
74 * Creates Bun cluster layers for HTTP or WebSocket transport, configuring serialization, storage, runner health, and optional client-only mode.
75 *
76 * **When to use**
77 *
78 * Use to install the complete Bun HTTP or WebSocket cluster layer, including
79 * client-only cluster access when a process should connect without serving
80 * runner RPCs.
81 *
82 * **Details**
83 *
84 * `serialization` defaults to SchemaBinary, `runnerHealth` defaults to ping
85 * checks, SQL-backed storage is used by default, and `shardingConfig` is
86 * overlaid on environment-loaded sharding configuration. `local` storage uses
87 * no-op message storage plus in-memory runner storage, while `byo` leaves both
88 * message and runner storage for the caller to provide.
89 *
90 * **Gotchas**
91 *
92 * `clientOnly` does not start the HTTP server or receive shard assignments.
93 * Non-client-only mode listens with `runnerListenAddress` when present, falling
94 * back to `runnerAddress`. HTTP and WebSocket runner RPCs use the default
95 * `HttpRunner` route.
96 *
97 * @see {@link layerHttpServer} for the server layer used by non-client-only transports
98 * @see {@link layerK8sHttpClient} for Kubernetes runner health support
99 *
100 * @stability unstable
101 * @category layers
102 * @since 4.0.0
103 */
104 export const layer = <
105 const ClientOnly extends boolean = false,
106 const Storage extends "local" | "sql" | "byo" = never
107 >(options: {
108 readonly transport: "http" | "websocket"
109 readonly serialization?: "binary" | "ndjson" | undefined
110 readonly serializationMaxBufferSize?: number | "unbounded" | undefined
111 readonly clientOnly?: ClientOnly | undefined
112 readonly storage?: Storage | undefined
113 readonly runnerHealth?: "ping" | "k8s" | undefined
114 readonly runnerHealthK8s?: {
115 readonly namespace?: string | undefined
116 readonly labelSelector?: string | undefined
117 } | undefined
118 readonly shardingConfig?: Partial<ShardingConfig.ShardingConfig["Service"]> | undefined
119 }): ClientOnly extends true ? Layer.Layer<
120 Sharding | Runners.Runners | ("byo" extends Storage ? never : MessageStorage.MessageStorage),
121 Config.ConfigError,
122 "local" extends Storage ? never
123 : "byo" extends Storage ? (MessageStorage.MessageStorage | RunnerStorage.RunnerStorage)
124 : SqlClient
125 > :
126 Layer.Layer<
127 Sharding | Runners.Runners | MessageStorage.MessageStorage,
128 ServeError | Config.ConfigError,
129 "local" extends Storage ? never
130 : "byo" extends Storage ? (MessageStorage.MessageStorage | RunnerStorage.RunnerStorage)
131 : SqlClient
132 > =>
133 {
134 const layer: Layer.Layer<any, any, any> = options.clientOnly
135 // client only
136 ? options.transport === "http"
137 ? Layer.provide(HttpRunner.layerHttpClientOnly, FetchHttpClient.layer)
138 : Layer.provide(HttpRunner.layerWebsocketClientOnly, BunSocket.layerWebSocketConstructor)
139 // with server
140 : options.transport === "http"
141 ? Layer.provide(HttpRunner.layerHttp, [layerHttpServer, FetchHttpClient.layer])
142 : Layer.provide(HttpRunner.layerWebsocket, [layerHttpServer, BunSocket.layerWebSocketConstructor])
143
144 const runnerHealth: Layer.Layer<any, any, any> = options?.clientOnly
145 ? Layer.empty as any
146 : options?.runnerHealth === "k8s"
147 ? RunnerHealth.layerK8s(options.runnerHealthK8s).pipe(
148 Layer.provide([BunFileSystem.layer, layerK8sHttpClient])
149 )
150 : RunnerHealth.layerPing.pipe(
151 Layer.provide(Runners.layerRpc),
152 Layer.provide(
153 options.transport === "http"
154 ? HttpRunner.layerClientProtocolHttpDefault.pipe(Layer.provide(FetchHttpClient.layer))
155 : HttpRunner.layerClientProtocolWebsocketDefault.pipe(Layer.provide(BunSocket.layerWebSocketConstructor))
156 )
157 )
158
159 return layer.pipe(
160 Layer.provide(runnerHealth),
161 Layer.provideMerge(
162 options?.storage === "local"
163 ? MessageStorage.layerNoop
164 : options?.storage === "byo"
165 ? Layer.empty
166 : SqlMessageStorage.layer.pipe(Layer.provide(NodeCrypto.layerDigest))
167 ),
168 Layer.provide(
169 options?.storage === "local"
170 ? RunnerStorage.layerMemory
171 : options?.storage === "byo"
172 ? Layer.empty
173 : Layer.orDie(SqlRunnerStorage.layer)
174 ),
175 Layer.provide(ShardingConfig.layerFromEnv(options?.shardingConfig)),
176 Layer.provide(
177 options?.serialization === "ndjson"
178 ? RpcSerialization.layerNdjsonWith({ maxBufferSize: options.serializationMaxBufferSize })
179 : RpcSerialization.layerSchemaBinary({ maxFrameSize: options.serializationMaxBufferSize })
180 )
181 ) as any
182 }