The best way to control Claude Code, Codex and more from any computer or phone
| 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; |