Skip to content

Open-source Grok Bot alternative for named AI teammates. Local-first desktop, web, and mobile clients with per-bot tools, instructions, and memory. Independent fork of T3 Code.

Fix Relay Worker RuntimeContext wiring (#4653)

Julius Marminge180620e43688
diff --git a/infra/relay/src/agentActivity/ApnsDeliveryQueue.test.ts b/infra/relay/src/agentActivity/ApnsDeliveryQueue.test.ts
index d8131d053..171a81f50 100644
--- a/infra/relay/src/agentActivity/ApnsDeliveryQueue.test.ts
+++ b/infra/relay/src/agentActivity/ApnsDeliveryQueue.test.ts
@@ -1,5 +1,6 @@
import * as NodeCryptoLayer from "@effect/platform-node/NodeCrypto";
import { describe, expect, it } from "@effect/vitest";
+import * as Alchemy from "alchemy";
import * as Cloudflare from "alchemy/Cloudflare";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
@@ -28,6 +29,41 @@ const config: RelayConfiguration.RelayConfiguration["Service"] = {
};
describe("ApnsDeliveryQueue", () => {
+ it.effect("does not require the deployment RuntimeContext when building the Worker layer", () => {
+ const sent: unknown[] = [];
+ const sender: Cloudflare.Queues.WriteQueueClient = {
+ raw: Effect.die("raw queue binding is not used"),
+ send: (body) =>
+ Effect.sync(() => {
+ sent.push(body);
+ }),
+ sendBatch: () => Effect.die("batch queue binding is not used"),
+ };
+ const runtimeContext = {} as Alchemy.BaseRuntimeContext;
+ const layer = ApnsDeliveryQueue.layerCloudflareQueues(sender, runtimeContext).pipe(
+ Layer.provide(NodeCryptoLayer.layer),
+ Layer.provide(RelayConfiguration.layer(config)),
+ );
+
+ return Effect.gen(function* () {
+ const queue = yield* ApnsDeliveryQueue.ApnsDeliveryQueue;
+ yield* queue.enqueuePushNotification({
+ userId: "user-1",
+ deviceId: "device-1",
+ token: "push-token",
+ notification: {
+ title: "Thread",
+ body: "Input: Project",
+ environmentId: "env-1",
+ threadId: "thread-1",
+ deepLink: "/threads/env-1/thread-1",
+ },
+ });
+
+ expect(sent).toHaveLength(1);
+ }).pipe(Effect.provide(layer));
+ });
+
it.effect("preserves job identity and the queue sender cause", () => {
const cause = new Error("queue unavailable");
const senderCause = new Cloudflare.Queues.SendError({
diff --git a/infra/relay/src/agentActivity/ApnsDeliveryQueue.ts b/infra/relay/src/agentActivity/ApnsDeliveryQueue.ts
index 2707653e2..2a1d6abba 100644
--- a/infra/relay/src/agentActivity/ApnsDeliveryQueue.ts
+++ b/infra/relay/src/agentActivity/ApnsDeliveryQueue.ts
@@ -208,21 +208,20 @@ export const make = Effect.gen(function* () {
export const layer = Layer.effect(ApnsDeliveryQueue, make);
-export const layerCloudflareQueues = (sender: Cloudflare.Queues.WriteQueueClient) =>
+export const layerCloudflareQueues = (
+ sender: Cloudflare.Queues.WriteQueueClient,
+ alchemyRuntimeContext: Alchemy.BaseRuntimeContext,
+) =>
layer.pipe(
Layer.provide(
- Layer.effect(
+ Layer.succeed(
ApnsDeliveryQueueSender,
- Alchemy.RuntimeContext.pipe(
- Effect.map((alchemyRuntimeContext) =>
- ApnsDeliveryQueueSender.of({
- send: (body) =>
- sender
- .send(body)
- .pipe(Effect.provideService(Alchemy.RuntimeContext, alchemyRuntimeContext)),
- }),
- ),
- ),
+ ApnsDeliveryQueueSender.of({
+ send: (body) =>
+ sender
+ .send(body)
+ .pipe(Effect.provideService(Alchemy.RuntimeContext, alchemyRuntimeContext)),
+ }),
),
),
);
diff --git a/infra/relay/src/environments/ManagedEndpointProvider.test.ts b/infra/relay/src/environments/ManagedEndpointProvider.test.ts
index d075dc290..a26cd3042 100644
--- a/infra/relay/src/environments/ManagedEndpointProvider.test.ts
+++ b/infra/relay/src/environments/ManagedEndpointProvider.test.ts
@@ -2,6 +2,8 @@ import * as NodeCrypto from "node:crypto";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { describe, expect, it } from "@effect/vitest";
+import * as Alchemy from "alchemy";
+import * as Cloudflare from "alchemy/Cloudflare";
import * as Effect from "effect/Effect";
import * as Layer from "effect/Layer";
import * as Redacted from "effect/Redacted";
@@ -280,6 +282,47 @@ function expectedManagedTunnelName(environmentId: string, userId = "user_ABC"):
}
describe("ManagedEndpointProvider", () => {
+ it.effect("does not require the deployment RuntimeContext when building the Worker layer", () => {
+ const tunnelClient = {
+ list: () => Effect.succeed({ result: [] }),
+ create: (request: { readonly name: string }) =>
+ Effect.succeed({ id: "tunnel-id", name: request.name }),
+ putConfiguration: () => Effect.void,
+ getToken: () => Effect.succeed("connector-token"),
+ delete: () => Effect.void,
+ } as unknown as Cloudflare.Tunnel.ReadWriteTunnelClient;
+ const dnsClient = {
+ listDnsRecords: () => Effect.succeed({ result: [] }),
+ createDnsRecord: () => Effect.succeed({ id: "dns-record-id" }),
+ updateDnsRecord: () => Effect.void,
+ deleteDnsRecord: () => Effect.void,
+ } as unknown as Cloudflare.DNS.ReadWriteDnsClient;
+ const runtimeContext = {} as Alchemy.BaseRuntimeContext;
+ const layer = ManagedEndpointProvider.layerCloudflareBindings(
+ tunnelClient,
+ dnsClient,
+ runtimeContext,
+ ).pipe(
+ Layer.provideMerge(NodeServices.layer),
+ Layer.provide(RelayConfiguration.layer(config)),
+ Layer.provide(
+ Layer.succeed(ManagedEndpointAllocations.ManagedEndpointAllocations, makeAllocations()),
+ ),
+ Layer.provide(Layer.succeed(ManagedTunnelLimits.ManagedTunnelLimits, makeTunnelLimits())),
+ );
+
+ return Effect.gen(function* () {
+ const provider = yield* ManagedEndpointProvider.ManagedEndpointProvider;
+ const result = yield* provider.provision({
+ userId: "user_ABC",
+ environmentId: "env_ABC",
+ origin: { localHttpHost: "127.0.0.1", localHttpPort: 3773 },
+ });
+
+ expect(result.runtime.connectorToken).toBe("connector-token");
+ }).pipe(Effect.provide(layer));
+ });
+
it.effect("provisions a Cloudflare tunnel endpoint and connector token", () => {
const tunnelCalls: TunnelCall[] = [];
const dnsCalls: DnsCall[] = [];
diff --git a/infra/relay/src/environments/ManagedEndpointProvider.ts b/infra/relay/src/environments/ManagedEndpointProvider.ts
index d2ebe3705..46875b121 100644
--- a/infra/relay/src/environments/ManagedEndpointProvider.ts
+++ b/infra/relay/src/environments/ManagedEndpointProvider.ts
@@ -811,137 +811,132 @@ export const layer = Layer.effect(ManagedEndpointProvider, make);
export const layerCloudflareBindings = (
tunnelClient: Cloudflare.Tunnel.ReadWriteTunnelClient,
dnsClient: Cloudflare.DNS.ReadWriteDnsClient,
+ alchemyRuntimeContext: Alchemy.BaseRuntimeContext,
) =>
layer.pipe(
Layer.provide(
- Layer.unwrap(
- Alchemy.RuntimeContext.pipe(
- Effect.map((alchemyRuntimeContext) =>
- Layer.mergeAll(
- layerTunnelClient({
- list: (request) =>
- tunnelClient.list(request).pipe(
- Effect.mapError(
- (cause) =>
- new ManagedEndpointTunnelClientError({
- operation: "list",
- tunnelName: request.name,
- cause,
- }),
- ),
- Effect.provideService(Alchemy.RuntimeContext, alchemyRuntimeContext),
- ),
- create: (request) =>
- tunnelClient.create(request).pipe(
- Effect.mapError(
- (cause) =>
- new ManagedEndpointTunnelClientError({
- operation: "create",
- tunnelName: request.name,
- cause,
- }),
- ),
- Effect.provideService(Alchemy.RuntimeContext, alchemyRuntimeContext),
- ),
- putConfiguration: (tunnelId, config) =>
- tunnelClient.putConfiguration(tunnelId, config).pipe(
- Effect.mapError(
- (cause) =>
- new ManagedEndpointTunnelClientError({
- operation: "put-configuration",
- tunnelId,
- cause,
- }),
- ),
- Effect.provideService(Alchemy.RuntimeContext, alchemyRuntimeContext),
- ),
- getToken: (tunnelId) =>
- tunnelClient.getToken(tunnelId).pipe(
- Effect.mapError(
- (cause) =>
- new ManagedEndpointTunnelClientError({
- operation: "get-token",
- tunnelId,
- cause,
- }),
- ),
- Effect.provideService(Alchemy.RuntimeContext, alchemyRuntimeContext),
- ),
- delete: (tunnelId) =>
- tunnelClient.delete(tunnelId).pipe(
- Effect.mapError(
- (cause) =>
- new ManagedEndpointTunnelClientError({
- operation: "delete",
- tunnelId,
- cause,
- }),
- ),
- Effect.provideService(Alchemy.RuntimeContext, alchemyRuntimeContext),
- ),
- }),
- layerDnsClient({
- listRecords: (hostname) =>
- dnsClient.listDnsRecords({ search: hostname }).pipe(
- Effect.map((response) =>
- response.result.filter(
- (record): record is typeof record & { readonly id: string } =>
- typeof record.id === "string" &&
- normalizeHostname(record.name) === normalizeHostname(hostname),
- ),
- ),
- Effect.mapError(
- (cause) =>
- new ManagedEndpointDnsClientError({
- operation: "list-records",
- hostname,
- cause,
- }),
- ),
- Effect.provideService(Alchemy.RuntimeContext, alchemyRuntimeContext),
- ),
- createRecord: (request) =>
- dnsClient.createDnsRecord(request).pipe(
- Effect.map((response) => ({ id: response.id })),
- Effect.mapError(
- (cause) =>
- new ManagedEndpointDnsClientError({
- operation: "create-record",
- hostname: request.name,
- cause,
- }),
- ),
- Effect.provideService(Alchemy.RuntimeContext, alchemyRuntimeContext),
- ),
- updateRecord: (dnsRecordId, request) =>
- dnsClient.updateDnsRecord(dnsRecordId, request).pipe(
- Effect.mapError(
- (cause) =>
- new ManagedEndpointDnsClientError({
- operation: "update-record",
- hostname: request.name,
- dnsRecordId,
- cause,
- }),
- ),
- Effect.provideService(Alchemy.RuntimeContext, alchemyRuntimeContext),
- ),
- deleteRecord: (dnsRecordId) =>
- dnsClient.deleteDnsRecord(dnsRecordId).pipe(
- Effect.mapError(
- (cause) =>
- new ManagedEndpointDnsClientError({
- operation: "delete-record",
- dnsRecordId,
- cause,
- }),
- ),
- Effect.provideService(Alchemy.RuntimeContext, alchemyRuntimeContext),
- ),
- }),
+ Layer.mergeAll(
+ layerTunnelClient({
+ list: (request) =>
+ tunnelClient.list(request).pipe(
+ Effect.mapError(
+ (cause) =>
+ new ManagedEndpointTunnelClientError({
+ operation: "list",
+ tunnelName: request.name,
+ cause,
+ }),
+ ),
+ Effect.provideService(Alchemy.RuntimeContext, alchemyRuntimeContext),
),
- ),
- ),
+ create: (request) =>
+ tunnelClient.create(request).pipe(
+ Effect.mapError(
+ (cause) =>
+ new ManagedEndpointTunnelClientError({
+ operation: "create",
+ tunnelName: request.name,
+ cause,
+ }),
+ ),
+ Effect.provideService(Alchemy.RuntimeContext, alchemyRuntimeContext),
+ ),
+ putConfiguration: (tunnelId, config) =>
+ tunnelClient.putConfiguration(tunnelId, config).pipe(
+ Effect.mapError(
+ (cause) =>
+ new ManagedEndpointTunnelClientError({
+ operation: "put-configuration",
+ tunnelId,
+ cause,
+ }),
+ ),
+ Effect.provideService(Alchemy.RuntimeContext, alchemyRuntimeContext),
+ ),
+ getToken: (tunnelId) =>
+ tunnelClient.getToken(tunnelId).pipe(
+ Effect.mapError(
+ (cause) =>
+ new ManagedEndpointTunnelClientError({
+ operation: "get-token",
+ tunnelId,
+ cause,
+ }),
+ ),
+ Effect.provideService(Alchemy.RuntimeContext, alchemyRuntimeContext),
+ ),
+ delete: (tunnelId) =>
+ tunnelClient.delete(tunnelId).pipe(
+ Effect.mapError(
+ (cause) =>
+ new ManagedEndpointTunnelClientError({
+ operation: "delete",
+ tunnelId,
+ cause,
+ }),
+ ),
+ Effect.provideService(Alchemy.RuntimeContext, alchemyRuntimeContext),
+ ),
+ }),
+ layerDnsClient({
+ listRecords: (hostname) =>
+ dnsClient.listDnsRecords({ search: hostname }).pipe(
+ Effect.map((response) =>
+ response.result.filter(
+ (record): record is typeof record & { readonly id: string } =>
+ typeof record.id === "string" &&
+ normalizeHostname(record.name) === normalizeHostname(hostname),
+ ),
+ ),
+ Effect.mapError(
+ (cause) =>
+ new ManagedEndpointDnsClientError({
+ operation: "list-records",
+ hostname,
+ cause,
+ }),
+ ),
+ Effect.provideService(Alchemy.RuntimeContext, alchemyRuntimeContext),
+ ),
+ createRecord: (request) =>
+ dnsClient.createDnsRecord(request).pipe(
+ Effect.map((response) => ({ id: response.id })),
+ Effect.mapError(
+ (cause) =>
+ new ManagedEndpointDnsClientError({
+ operation: "create-record",
+ hostname: request.name,
+ cause,
+ }),
+ ),
+ Effect.provideService(Alchemy.RuntimeContext, alchemyRuntimeContext),
+ ),
+ updateRecord: (dnsRecordId, request) =>
+ dnsClient.updateDnsRecord(dnsRecordId, request).pipe(
+ Effect.mapError(
+ (cause) =>
+ new ManagedEndpointDnsClientError({
+ operation: "update-record",
+ hostname: request.name,
+ dnsRecordId,
+ cause,
+ }),
+ ),
+ Effect.provideService(Alchemy.RuntimeContext, alchemyRuntimeContext),
+ ),
+ deleteRecord: (dnsRecordId) =>
+ dnsClient.deleteDnsRecord(dnsRecordId).pipe(
+ Effect.mapError(
+ (cause) =>
+ new ManagedEndpointDnsClientError({
+ operation: "delete-record",
+ dnsRecordId,
+ cause,
+ }),
+ ),
+ Effect.provideService(Alchemy.RuntimeContext, alchemyRuntimeContext),
+ ),
+ }),
),
),
);
diff --git a/infra/relay/src/worker.ts b/infra/relay/src/worker.ts
index 038ba794d..d0fabe8de 100644
--- a/infra/relay/src/worker.ts
+++ b/infra/relay/src/worker.ts
@@ -154,6 +154,8 @@ export const ApiLive = Api.make(
//
// 3. Runtime layers and app construction
//
+ const alchemyRuntimeContext: Alchemy.BaseRuntimeContext = yield* Cloudflare.Worker;
+
const loadSettings = Effect.gen(function* () {
return RelayConfiguration.RelayConfiguration.of({
relayIssuer: relayPublicOrigin,
@@ -193,12 +195,15 @@ export const ApiLive = Api.make(
ManagedEndpointProvider.layerCloudflareBindings(
managedEndpointTunnelBinding,
managedEndpointDnsBinding,
+ alchemyRuntimeContext,
),
),
Layer.provideMerge(DpopProofs.layer),
Layer.provideMerge(ApnsDeliveries.layer),
Layer.provideMerge(ApnsClient.layer.pipe(Layer.provideMerge(ApnsProviderTokens.layer))),
- Layer.provideMerge(ApnsDeliveryQueue.layerCloudflareQueues(apnsDeliveryQueueSender)),
+ Layer.provideMerge(
+ ApnsDeliveryQueue.layerCloudflareQueues(apnsDeliveryQueueSender, alchemyRuntimeContext),
+ ),
Layer.provideMerge(AgentActivityRows.layer),
Layer.provideMerge(Devices.layer),
Layer.provideMerge(EnvironmentCredentials.layer),