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

main
ts 590 lines 24.5 KB
Raw
1 import * as Alchemy from "alchemy";
2 import * as Axiom from "@alchemy.run/axiom";
3 import * as Cloudflare from "@alchemy.run/cloudflare";
4 import * as Drizzle from "@alchemy.run/drizzle/Postgres";
5 import * as Config from "effect/Config";
6 import * as Cause from "effect/Cause";
7 import * as DateTime from "effect/DateTime";
8 import * as Digest from "effect/crypto/Digest";
9 import * as Mac from "effect/crypto/Mac";
10 import * as SecureRandom from "effect/crypto/SecureRandom";
11 import * as Signature from "effect/crypto/Signature";
12 import * as Effect from "effect/Effect";
13 import * as Layer from "effect/Layer";
14 import * as Option from "effect/Option";
15 import * as Redacted from "effect/Redacted";
16 import * as Stream from "effect/Stream";
17 import * as Etag from "effect/http/Etag";
18 import * as HttpMiddleware from "effect/http/HttpMiddleware";
19 import * as HttpPlatform from "effect/http/HttpPlatform";
20 import * as HttpRouter from "effect/http/HttpRouter";
21 import * as HttpApiBuilder from "effect/http-api/HttpApiBuilder";
22 import * as HttpApiScalar from "effect/http-api/HttpApiScalar";
23
24 import { RelayApi } from "@t3tools/contracts/relay";
25
26 import {
27 RELAY_HTTP_ROUTER_CONFIG,
28 traceRelayHttpRequestWith,
29 withoutCapturedParentSpan,
30 } from "./http/Api.ts";
31 import * as CloudMintSigner from "./auth/CloudMintSigner.ts";
32 import * as RelayHttpApi from "./http/Api.ts";
33 import { ManagedEndpointZone, RelayApiZone, RelayDeploymentConfig } from "./zone.ts";
34 import { RelayObservability } from "./observability.ts";
35 import * as Observability from "./observability.ts";
36 import * as DeliveryAttempts from "./agentActivity/DeliveryAttempts.ts";
37 import * as AgentActivityRows from "./agentActivity/AgentActivityRows.ts";
38 import * as Devices from "./agentActivity/Devices.ts";
39 import * as DpopProofs from "./auth/DpopProofs.ts";
40 import * as RelayTokens from "./auth/RelayTokens.ts";
41 import * as EnvironmentCredentials from "./environments/EnvironmentCredentials.ts";
42 import * as EnvironmentLinks from "./environments/EnvironmentLinks.ts";
43 import * as ManagedEndpointAllocations from "./environments/ManagedEndpointAllocations.ts";
44 import * as LiveActivities from "./agentActivity/LiveActivities.ts";
45 import * as RelayDb from "./db.ts";
46 import {
47 RelayApnsDeliveryDeadLetterQueue,
48 RelayApnsDeliveryQueue,
49 RelayFcmDeliveryQueue,
50 RelayFcmDeliveryDeadLetterQueue,
51 } from "./queues.ts";
52 import * as WebCrypto from "./WebCrypto.ts";
53 import * as FcmAssertionSigner from "./agentActivity/FcmAssertionSigner.ts";
54 import * as FcmClient from "./agentActivity/FcmClient.ts";
55 import * as FcmDeliveryQueueSender from "./agentActivity/FcmDeliveryQueueSender.ts";
56 import * as FcmDeliveries from "./agentActivity/FcmDeliveries.ts";
57 import * as FcmDeliveryQueueConsumer from "./agentActivity/FcmDeliveryQueueConsumer.ts";
58 import * as RelayConfiguration from "./Config.ts";
59 import * as AgentActivityPublisher from "./agentActivity/AgentActivityPublisher.ts";
60 import * as ApnsClient from "./agentActivity/ApnsClient.ts";
61 import * as ApnsProviderTokens from "./agentActivity/ApnsProviderTokens.ts";
62 import * as ApnsDeliveryQueue from "./agentActivity/ApnsDeliveryQueue.ts";
63 import * as ApnsDeliveries from "./agentActivity/ApnsDeliveries.ts";
64 import * as CloudflareApiPause from "./environments/CloudflareApiPause.ts";
65 import * as EnvironmentConnector from "./environments/EnvironmentConnector.ts";
66 import * as EnvironmentLinker from "./environments/EnvironmentLinker.ts";
67 import * as EnvironmentPublishSignatures from "./environments/EnvironmentPublishSignatures.ts";
68 import * as ManagedEndpointProvider from "./environments/ManagedEndpointProvider.ts";
69 import * as ManagedEndpointReaper from "./environments/ManagedEndpointReaper.ts";
70 import * as ManagedTunnelLimits from "./environments/ManagedTunnelLimits.ts";
71 import * as T3ChatAccounts from "./t3chat/T3ChatAccounts.ts";
72 import * as MobileRegistrations from "./agentActivity/MobileRegistrations.ts";
73 import * as HookForwarder from "./hooks/HookForwarder.ts";
74 import * as HeldHooks from "./hooks/HeldHooks.ts";
75 import * as HookInbox from "./hooks/HookInbox.ts";
76 import * as HookInboxObject from "./hooks/HookInboxObject.ts";
77 import * as MobileTelemetry from "./mobileTelemetry/MobileTelemetry.ts";
78
79 const layerWebcrypto = Layer.mergeAll(
80 Digest.layerWebCrypto,
81 Mac.layerWebCrypto,
82 Signature.layerWebCrypto,
83 ).pipe(Layer.provideMerge(SecureRandom.layerWebCrypto));
84
85 const layerHttpPlatformNotSupported = Layer.succeed(HttpPlatform.HttpPlatform, {
86 platform: "web",
87 compression: {
88 algorithms: new Set<HttpPlatform.CompressionAlgorithm>(),
89 compressResponse: (response) => Effect.succeed(response),
90 },
91 fileResponse: Effect.fn("HttpPlatform.fileResponse")(function () {
92 return Effect.die("Relay API does not serve filesystem responses");
93 }),
94 fileWebResponse: Effect.fn("HttpPlatform.fileWebResponse")(function () {
95 return Effect.die("Relay API does not serve file responses");
96 }),
97 });
98
99 const layerRelayApi = Layer.mergeAll(
100 RelayHttpApi.layerHealthApi,
101 RelayHttpApi.layerMetadataApi,
102 RelayHttpApi.layerMobileApi,
103 RelayHttpApi.layerClientApi,
104 RelayHttpApi.layerTokenApi,
105 RelayHttpApi.layerDpopClientApi,
106 RelayHttpApi.layerServerApi,
107 );
108
109 const CloudMintKeyPair = Alchemy.KeyPair("CloudMintKeyPair");
110 const ApnsDeliveryJobSigningSecret = Alchemy.makeRandom("ApnsDeliveryJobSigningSecret", {
111 bytes: 32,
112 });
113
114 export class Api extends Cloudflare.Worker<Api, {}>()("Api") {}
115
116 export const layer = Api.make(
117 RelayDeploymentConfig.pipe(
118 Effect.map(({ relayPublicDomain }) => ({
119 main: import.meta.filename,
120 compatibility: {
121 date: "2026-05-22",
122 flags: ["nodejs_compat"],
123 },
124 // Requests run several Postgres queries in sequence. At the user's edge
125 // each one paid the round trip to the database (~300 ms from JNB); next
126 // to PlanetScale `us-west` the request pays that distance once.
127 placement: { region: "aws:us-west-2" },
128 domain: relayPublicDomain,
129 // Workers Logs bills per GB, and every request, queue batch, and DO call is
130 // an invocation log. Axiom traces carry the full detail; keep a sample for
131 // crashes and limit errors that never export a span.
132 observability: {
133 enabled: true,
134 logs: { enabled: true, invocationLogs: true, headSamplingRate: 0.01 },
135 },
136 })),
137 Effect.orDie,
138 ),
139 Effect.gen(function* () {
140 const { relayPublicOrigin, stage } = yield* RelayDeploymentConfig;
141 const apnsDeliveryQueue = yield* RelayApnsDeliveryQueue;
142 const apnsDeliveryDeadLetterQueue = yield* RelayApnsDeliveryDeadLetterQueue;
143 const fcmDeliveryQueue = yield* RelayFcmDeliveryQueue;
144 const fcmDeliveryDeadLetterQueue = yield* RelayFcmDeliveryDeadLetterQueue;
145 const cloudMintKeyPair = yield* CloudMintKeyPair;
146 const relayApiZone = yield* RelayApiZone;
147 const managedEndpointZone = yield* ManagedEndpointZone;
148 const randomApnsDeliveryJobSigningSecret = yield* ApnsDeliveryJobSigningSecret;
149 const observability = yield* RelayObservability;
150
151 const apnsEnabled = yield* Config.Boolean("APNS_ENABLED").pipe(Config.withDefault(true));
152 const apnsCredentials = apnsEnabled
153 ? {
154 environment: yield* Config.schema(RelayConfiguration.ApnsEnvironment, "APNS_ENVIRONMENT"),
155 teamId: yield* Config.String("APNS_TEAM_ID"),
156 keyId: yield* Config.String("APNS_KEY_ID"),
157 bundleId: yield* Config.String("APNS_BUNDLE_ID"),
158 privateKey: yield* Config.Redacted("APNS_PRIVATE_KEY"),
159 }
160 : null;
161 const fcmServiceAccount = Option.getOrUndefined(
162 Option.filter(
163 yield* Config.option(Config.Redacted("FCM_SERVICE_ACCOUNT")),
164 (value) => Redacted.value(value).trim().length > 0,
165 ),
166 );
167 const apnsDeliveryJobSigningSecret = yield* randomApnsDeliveryJobSigningSecret;
168 const apnsDeliveryQueueSender = yield* Cloudflare.Queues.WriteQueue(apnsDeliveryQueue);
169 const fcmDeliveryQueueSender = yield* Cloudflare.Queues.WriteQueue(fcmDeliveryQueue);
170
171 const clerkSecretKey = yield* Config.Redacted("CLERK_SECRET_KEY");
172 const clerkPublishableKey = yield* Config.String("CLERK_PUBLISHABLE_KEY");
173 const clerkJwtAudience = yield* Config.String("CLERK_JWT_AUDIENCE");
174 const t3ChatLinkSecret = Option.getOrUndefined(
175 Option.filter(
176 yield* Config.option(Config.Redacted("T3CHAT_LINK_SECRET")),
177 (value) => Redacted.value(value).trim().length > 0,
178 ),
179 );
180 const t3ChatBaseUrl = yield* Config.String("T3CHAT_URL").pipe(
181 Config.withDefault("https://t3.chat"),
182 );
183
184 const cloudMintPrivateKey = yield* cloudMintKeyPair.privateKey;
185 const cloudMintPublicKey = yield* cloudMintKeyPair.publicKey;
186 const hyperdrive = yield* Cloudflare.Hyperdrive.Connect(yield* RelayDb.RelayHyperdrive);
187 // Named statements collide behind Hyperdrive transaction pooling (Effect-TS/effect#8320); use unnamed statements.
188 const db = yield* Drizzle.Postgres(hyperdrive.connectionString, {
189 client: { prepare: false },
190 });
191
192 const managedEndpointTunnelBinding = yield* Cloudflare.Tunnel.ReadWriteTunnel();
193 // Keep Worker custom-domain reconciliation ordered after API zone provisioning.
194 yield* yield* relayApiZone.zoneId;
195 const managedEndpointDnsBinding = yield* Cloudflare.DNS.ReadWriteDns(managedEndpointZone);
196 const managedEndpointZoneName = yield* managedEndpointZone.name;
197 const managedEndpointCleanupMode = yield* RelayConfiguration.managedEndpointCleanupModeConfig;
198 const legacyManagedEndpointCleanupMode =
199 yield* RelayConfiguration.legacyManagedEndpointCleanupModeConfig;
200 const legacyTunnelGraceMinutes = Option.getOrUndefined(
201 yield* RelayConfiguration.legacyTunnelGraceMinutesConfig,
202 );
203 // Endpoint keys and their hashes differ by stage, including in shared accounts.
204 const hookRateLimit = yield* Cloudflare.RateLimit("HOOK_RATE_LIMIT", {
205 namespaceId: 1001,
206 simple: {
207 limit: HookForwarder.RELAY_HOOK_RATE_LIMIT.limit,
208 period: HookForwarder.RELAY_HOOK_RATE_LIMIT.periodSeconds,
209 },
210 });
211 const hookEndpointRateLimit = yield* Cloudflare.RateLimit("HOOK_ENDPOINT_RATE_LIMIT", {
212 namespaceId: 1002,
213 simple: {
214 limit: HookForwarder.RELAY_HOOK_ENDPOINT_RATE_LIMIT.limit,
215 period: HookForwarder.RELAY_HOOK_ENDPOINT_RATE_LIMIT.periodSeconds,
216 },
217 });
218 const hookInboxes = yield* HookInboxObject.HookInboxObject;
219 const mobileTelemetryRateLimit = yield* Cloudflare.RateLimit("MOBILE_TELEMETRY_RATE_LIMIT", {
220 namespaceId: 1003,
221 simple: {
222 limit: MobileTelemetry.MOBILE_TELEMETRY_RATE_LIMIT.limit,
223 period: MobileTelemetry.MOBILE_TELEMETRY_RATE_LIMIT.periodSeconds,
224 },
225 });
226 const mobileSourceMaps = yield* Cloudflare.R2.ReadBucket(observability.mobileSourceMaps);
227 const mobileTelemetryToken = yield* observability.mobileTelemetryIngestToken.token;
228 const mobileTracesUrl = yield* observability.traces.otelTracesEndpoint;
229 const mobileTracesDataset = yield* observability.traces.name;
230 const mobileLogsUrl = yield* observability.mobileLogs.otelLogsEndpoint;
231 const mobileLogsDataset = yield* observability.mobileLogs.name;
232 const mobileMetricsUrl = yield* observability.mobileMetrics.otelMetricsEndpoint;
233 const mobileMetricsDataset = yield* observability.mobileMetrics.name;
234
235 const alchemyRuntimeContext: Alchemy.BaseRuntimeContext = yield* Cloudflare.Worker;
236
237 const loadSettings = Effect.gen(function* () {
238 return RelayConfiguration.RelayConfiguration.of({
239 relayIssuer: relayPublicOrigin,
240 ...(fcmServiceAccount ? { fcmServiceAccount } : {}),
241 apns: apnsCredentials,
242 apnsDeliveryJobSigningSecret: yield* apnsDeliveryJobSigningSecret,
243 clerkSecretKey,
244 clerkPublishableKey,
245 clerkJwtAudience,
246 cloudMintPrivateKey: yield* cloudMintPrivateKey,
247 cloudMintPublicKey: yield* cloudMintPublicKey,
248 managedEndpointBaseDomain: yield* managedEndpointZoneName,
249 managedEndpointNamespace: stage,
250 managedEndpointCleanupMode,
251 legacyManagedEndpointCleanupMode,
252 ...(legacyTunnelGraceMinutes === undefined ? {} : { legacyTunnelGraceMinutes }),
253 ...(t3ChatLinkSecret
254 ? { t3Chat: { baseUrl: t3ChatBaseUrl, linkSecret: t3ChatLinkSecret } }
255 : {}),
256 });
257 });
258
259 const inboxCall =
260 <A>(operation: HookInbox.HookInboxError["operation"], endpointKey: string) =>
261 (effect: Effect.Effect<A, never, Alchemy.RuntimeContext>) =>
262 effect.pipe(
263 Effect.provideService(Alchemy.RuntimeContext, alchemyRuntimeContext),
264 Effect.catchCause((cause) =>
265 Effect.fail(
266 new HookInbox.HookInboxError({
267 operation,
268 endpointKey,
269 cause: Cause.squash(cause),
270 }),
271 ),
272 ),
273 );
274 const layerHookInbox = Layer.succeed(HookInbox.HookInbox, {
275 hold: Effect.fn("HookInbox.hold")(function ({ endpointKey, baseUrl, hook }) {
276 return hookInboxes
277 .getByName(endpointKey)
278 .hold(hook, baseUrl)
279 .pipe(inboxCall("hold", endpointKey));
280 }),
281 wake: Effect.fn("HookInbox.wake")(function ({ endpointKey, baseUrl }) {
282 return hookInboxes
283 .getByName(endpointKey)
284 .wake(baseUrl)
285 .pipe(inboxCall("wake", endpointKey));
286 }),
287 clear: Effect.fn("HookInbox.clear")(function ({ endpointKey }) {
288 return hookInboxes.getByName(endpointKey).clear().pipe(inboxCall("clear", endpointKey));
289 }),
290 });
291
292 const layerRuntime = Layer.empty.pipe(
293 Layer.provideMerge(MobileRegistrations.layer),
294 Layer.provideMerge(AgentActivityPublisher.layer),
295 Layer.provideMerge(EnvironmentConnector.layer),
296 Layer.provideMerge(EnvironmentLinker.layer),
297 Layer.provideMerge(
298 Layer.mergeAll(
299 EnvironmentPublishSignatures.layer,
300 ManagedEndpointReaper.layer,
301 HeldHooks.layer,
302 ),
303 ),
304 Layer.provideMerge(
305 ManagedEndpointProvider.layerCloudflareBindings(
306 managedEndpointTunnelBinding,
307 managedEndpointDnsBinding,
308 alchemyRuntimeContext,
309 ),
310 ),
311 Layer.provideMerge(DpopProofs.layer),
312 Layer.provideMerge(ApnsDeliveries.layer),
313 Layer.provideMerge(
314 FcmDeliveries.layer.pipe(
315 Layer.provide(
316 Layer.succeed(FcmDeliveryQueueSender.FcmDeliveryQueueSender, {
317 send: Effect.fn("FcmDeliveryQueueSender.send")(
318 function* (body) {
319 return yield* fcmDeliveryQueueSender.send(body);
320 },
321 Effect.provideService(Alchemy.RuntimeContext, alchemyRuntimeContext),
322 ),
323 }),
324 ),
325 Layer.provideMerge(
326 FcmClient.layer.pipe(
327 Layer.provide(FcmAssertionSigner.layer),
328 Layer.provide(
329 Layer.succeed(WebCrypto.WebCrypto, { subtle: globalThis.crypto.subtle }),
330 ),
331 ),
332 ),
333 ),
334 ),
335 Layer.provideMerge(ApnsClient.layer.pipe(Layer.provideMerge(ApnsProviderTokens.layer))),
336 Layer.provideMerge(
337 ApnsDeliveryQueue.layerCloudflareQueues(apnsDeliveryQueueSender, alchemyRuntimeContext),
338 ),
339 Layer.provideMerge(Layer.mergeAll(AgentActivityRows.layer, Devices.layer, layerHookInbox)),
340 Layer.provideMerge(EnvironmentCredentials.layer),
341 Layer.provideMerge(
342 Layer.mergeAll(
343 CloudflareApiPause.layer,
344 EnvironmentLinks.layer,
345 ManagedEndpointAllocations.layer,
346 ManagedTunnelLimits.layer,
347 ),
348 ),
349 Layer.provideMerge(Layer.mergeAll(LiveActivities.layer, T3ChatAccounts.layer)),
350 Layer.provideMerge(DeliveryAttempts.layer),
351 Layer.provideMerge(RelayTokens.layer.pipe(Layer.provideMerge(CloudMintSigner.layer))),
352 Layer.provideMerge(
353 RelayDb.RelayTransactions.layer.pipe(
354 Layer.provideMerge(Layer.succeed(RelayDb.RelayDb, db)),
355 ),
356 ),
357 Layer.provideMerge(Layer.effect(RelayConfiguration.RelayConfiguration, loadSettings)),
358 Layer.provideMerge(layerWebcrypto),
359 );
360
361 // Fails open: a limiter outage must not drop webhooks or app telemetry.
362 const allowWith =
363 (
364 limiter: typeof hookRateLimit,
365 failedOpenAttribute = "relay.hook.rate_limiter_failed_open",
366 ) =>
367 (key: string): Effect.Effect<boolean> =>
368 limiter.limit({ key }).pipe(
369 Effect.map((result) => result.success),
370 Effect.provideService(Alchemy.RuntimeContext, alchemyRuntimeContext),
371 Effect.catch((error) =>
372 Effect.logWarning("Rate limiter unavailable", { error: error.message }).pipe(
373 Effect.andThen(Effect.annotateCurrentSpan({ [failedOpenAttribute]: true })),
374 Effect.as(true),
375 ),
376 ),
377 );
378 const layerHookRateLimiter = Layer.succeed(HookForwarder.HookRateLimiter, {
379 allowHook: allowWith(hookRateLimit),
380 allowEndpoint: allowWith(hookEndpointRateLimit),
381 });
382
383 // `fetch` rebuilds its layers per request; the source map cache must outlive one.
384 const mobileSourceMapLookups = yield* MobileTelemetry.SourceMaps.pipe(
385 Effect.provide(MobileTelemetry.layerSourceMaps),
386 Effect.provideService(MobileTelemetry.SourceMapObjects, {
387 get: (key) =>
388 mobileSourceMaps.get(key).pipe(
389 Effect.map((object) =>
390 object === null
391 ? undefined
392 : {
393 size: object.size,
394 text: object.text().pipe(
395 Effect.provideService(Alchemy.RuntimeContext, alchemyRuntimeContext),
396 Effect.mapError(
397 (cause) => new MobileTelemetry.SourceMapObjectError({ key, cause }),
398 ),
399 ),
400 },
401 ),
402 Effect.provideService(Alchemy.RuntimeContext, alchemyRuntimeContext),
403 Effect.mapError((cause) => new MobileTelemetry.SourceMapObjectError({ key, cause })),
404 ),
405 }),
406 );
407 const layerMobileTelemetry = MobileTelemetry.layer.pipe(
408 Layer.provide(
409 Layer.mergeAll(
410 Layer.effect(
411 MobileTelemetry.MobileTelemetrySettings,
412 Effect.gen(function* () {
413 return MobileTelemetry.MobileTelemetrySettings.of({
414 axiomToken: yield* mobileTelemetryToken,
415 destinations: {
416 traces: { url: yield* mobileTracesUrl, dataset: yield* mobileTracesDataset },
417 logs: { url: yield* mobileLogsUrl, dataset: yield* mobileLogsDataset },
418 metrics: { url: yield* mobileMetricsUrl, dataset: yield* mobileMetricsDataset },
419 },
420 });
421 }),
422 ),
423 Layer.succeed(MobileTelemetry.MobileTelemetryRateLimiter, {
424 allow: allowWith(
425 mobileTelemetryRateLimit,
426 "relay.mobile_telemetry.rate_limiter_failed_open",
427 ),
428 }),
429 Layer.succeed(MobileTelemetry.SourceMaps, mobileSourceMapLookups),
430 ),
431 ),
432 );
433
434 const layerApp = Layer.mergeAll(
435 layerRelayApi,
436 HookForwarder.layerApi.pipe(
437 Layer.provide(HookForwarder.layer),
438 Layer.provide(layerHookRateLimiter),
439 ),
440 MobileTelemetry.layerApi.pipe(Layer.provide(layerMobileTelemetry)),
441 ).pipe(
442 Layer.provideMerge(RelayHttpApi.layerClientAuth),
443 Layer.provideMerge(RelayHttpApi.layerDpopClientAuth),
444 Layer.provideMerge(RelayHttpApi.layerEnvironmentAuth),
445 Layer.provide(layerRuntime),
446 );
447
448 yield* Cloudflare.Queues.consumeQueueMessages<unknown>(
449 apnsDeliveryQueue,
450 {
451 batchSize: 10,
452 maxRetries: 5,
453 maxWaitTime: "5 seconds",
454 retryDelay: "30 seconds",
455 deadLetterQueue: apnsDeliveryDeadLetterQueue.queueName as unknown as string,
456 },
457 (stream) =>
458 Effect.flatMap(ApnsDeliveries.ApnsDeliveries, (deliveries) =>
459 deliveries.processBatch(stream),
460 ).pipe(Effect.provide(layerRuntime)),
461 );
462
463 yield* Cloudflare.Queues.consumeQueueMessages<unknown>(
464 fcmDeliveryQueue,
465 {
466 batchSize: 10,
467 maxRetries: 5,
468 maxWaitTime: "1 second",
469 retryDelay: "30 seconds",
470 deadLetterQueue: fcmDeliveryDeadLetterQueue.queueName as unknown as string,
471 },
472 (stream) =>
473 stream.pipe(
474 Stream.withSpan("relay.fcm_delivery_queue.process_batch"),
475 Stream.runForEach(FcmDeliveryQueueConsumer.processMessage),
476 Effect.provide(layerRuntime),
477 ),
478 );
479
480 yield* Cloudflare.Workers.cron("*/5 * * * *", () =>
481 Effect.all(
482 [
483 DpopProofs.DpopProofReplay.pipe(
484 Effect.flatMap((dpopProofs) => dpopProofs.pruneExpired),
485 Effect.andThen(
486 Effect.all([AgentActivityRows.AgentActivityRows, DateTime.now]).pipe(
487 Effect.flatMap(([activityRows, now]) =>
488 activityRows.pruneTerminal({
489 updatedBefore: DateTime.formatIso(DateTime.subtract(now, { minutes: 30 })),
490 }),
491 ),
492 ),
493 ),
494 Effect.andThen(
495 DeliveryAttempts.DeliveryAttempts.pipe(
496 Effect.flatMap((attempts) => attempts.pruneExpired),
497 ),
498 ),
499 Effect.catchCause((cause) =>
500 Cause.hasInterrupts(cause)
501 ? Effect.interrupt
502 : Effect.logWarning("Failed to prune expired relay state", { cause }),
503 ),
504 ),
505 ManagedEndpointReaper.ManagedEndpointReaper.pipe(
506 Effect.flatMap((reaper) => reaper.sweep.pipe(Effect.timeout("2 minutes"))),
507 Effect.tap((result) =>
508 result.scanned > 0
509 ? Effect.logInfo("Finished managed tunnel cleanup", result)
510 : Effect.void,
511 ),
512 Effect.catchCause((cause) =>
513 Cause.hasInterrupts(cause)
514 ? Effect.interrupt
515 : Effect.logWarning("Failed to clean up inactive managed tunnels", { cause }),
516 ),
517 ),
518 AgentActivityPublisher.AgentActivityPublisher.pipe(
519 Effect.flatMap((publisher) => publisher.endIdleLiveActivities),
520 Effect.catchCause((cause) =>
521 Cause.hasInterrupts(cause)
522 ? Effect.interrupt
523 : Effect.logWarning("Failed to end idle Live Activities", { cause }),
524 ),
525 ),
526 ],
527 { concurrency: 3, discard: true },
528 ).pipe(
529 Effect.withSpan("relay.cron.prune_expired_state"),
530 Observability.withSchemaErrorSpanAttributes,
531 Effect.provide(layerRuntime),
532 ),
533 );
534
535 const fetch = Layer.merge(
536 Layer.mergeAll(
537 HttpApiBuilder.layer(RelayApi, { openapiPath: "/openapi.json" }).pipe(
538 Layer.provide(layerApp),
539 ),
540 HttpApiScalar.layer(RelayApi, { path: "/docs" }),
541 RelayHttpApi.layerDocsRedirectRoute,
542 ).pipe(
543 Layer.provide([Etag.layerWeak, layerHttpPlatformNotSupported, RelayHttpApi.layerCors]),
544 ),
545 RelayHttpApi.layerNotFoundRoute,
546 ).pipe(
547 HttpRouter.toHttpEffect,
548 Effect.provideService(HttpRouter.RouterConfig, RELAY_HTTP_ROUTER_CONFIG),
549 withoutCapturedParentSpan,
550 Effect.map((httpEffect) =>
551 traceRelayHttpRequestWith(httpEffect, Layer.empty).pipe(
552 Observability.withSchemaErrorSpanAttributes,
553 ),
554 ),
555 );
556
557 return { fetch };
558 }).pipe(
559 Effect.provide(
560 Layer.empty.pipe(
561 Layer.provideMerge(Cloudflare.Hyperdrive.ConnectBinding),
562 Layer.provideMerge(Cloudflare.Workers.CronEventSourceLive),
563 Layer.provideMerge(Cloudflare.Queues.WriteQueueBinding),
564 Layer.provideMerge(Cloudflare.Queues.EventSourceLive),
565 Layer.provideMerge(Cloudflare.Tunnel.ReadWriteTunnelBinding),
566 Layer.provideMerge(Cloudflare.DNS.ReadWriteDnsHttp),
567 Layer.provideMerge(Cloudflare.Workers.RateLimitBinding),
568 Layer.provideMerge(Cloudflare.R2.ReadBucketBinding),
569 Layer.provideMerge(HookInboxObject.layer),
570 // Disable the duplicate runtime span; ours applies route/header/token redaction and rejects sender traceparent.
571 Layer.provideMerge(
572 Alchemy.Telemetry.layer(Layer.succeed(HttpMiddleware.TracerDisabledWhen)(() => true)),
573 ),
574 Layer.provideMerge(
575 Layer.unwrap(
576 Effect.map(RelayObservability, (observability) =>
577 Axiom.Telemetry({
578 serviceName: "t3code-relay",
579 token: observability.workerIngestToken,
580 traces: observability.traces,
581 }),
582 ),
583 ),
584 ),
585 ),
586 ),
587 ),
588 );
589
590 export default layer;